@hiveai/core 0.14.0 → 0.17.0

package/dist/index.d.ts

@@ -795,6 +795,19 @@ declare const STACK_PACK_TAG = "stack-pack";
 declare function isStackPackSeed(fm: {
     tags?: string[];
 } | null | undefined): boolean;
+/**
+ * Tags that mark a memory as a *local dev-environment workaround* (hot-swap, nested node_modules,
+ * global-install quirks) rather than repo-specific team policy. These are real, but they describe
+ * tooling debt, not unguessable team knowledge — and because they get read on almost every session
+ * their read_count inflates and they crowd the briefing. Ranking caps them at `background` UNLESS
+ * they directly anchor a file being edited, so they stop displacing actual policy. The fix for a
+ * recurring one is to repair the environment, not to keep surfacing the note.
+ */
+declare const ENV_WORKAROUND_TAGS: Set<string>;
+/** True when a memory is tagged as a local dev-environment workaround (see {@link ENV_WORKAROUND_TAGS}). */
+declare function isEnvWorkaroundMemory(fm: {
+    tags?: string[];
+} | null | undefined): boolean;
 /**
  * Best-effort inference: given a list of file paths, infer module names from
  * conventional layouts (packages/X/, apps/X/, modules/X/, src/X/).
@@ -1137,6 +1150,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.
@@ -1465,6 +1501,14 @@ declare function writeBriefingMarker(paths: HaivePaths, input: {
     source: string;
     memoryIds?: string[];
     files?: string[];
+    /**
+     * Accumulate memory_ids/files with the existing fresh marker for THIS session instead of
+     * overwriting (default true). This is what lets decision-coverage build up as the agent works:
+     * every get_briefing call, every pre-edit injection, every `haive briefing` ADDS to the
+     * session's consulted set — so a broad commit no longer requires one giant briefing covering
+     * every relevant decision at once. Pass false to replace (e.g. starting a brand-new session).
+     */
+    accumulate?: boolean;
 }): Promise<BriefingMarker>;
 declare function hasRecentBriefingMarker(paths: HaivePaths, sessionId?: string, ttlMs?: number): Promise<boolean>;
 declare function readRecentBriefingMarker(paths: HaivePaths, sessionId?: string, ttlMs?: number): Promise<BriefingMarker | null>;
@@ -1545,6 +1589,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[];
 /**
@@ -1650,6 +1715,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;
@@ -1658,6 +1764,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;
@@ -1730,6 +1838,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;
@@ -1741,4 +1851,267 @@ 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, 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 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, hashProjectContext, 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, projectContextRecentlyEmitted, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordApplied, recordPrevention, recordProjectContextEmission, 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;
+
+/**
+ * Recap compaction — keep the auto-generated session recap from dominating the briefing head.
+ *
+ * The MCP server auto-saves a minimal recap on exit (goal = "Auto-captured session (N tool calls)",
+ * body = a raw tool-call/file dump). It's low signal, yet get_briefing shows the freshest recap's
+ * full body at the very top of every briefing. A human/post_task recap (with a real Discoveries
+ * section) is far richer. This module detects an auto recap and compresses it to its useful core
+ * (the Discoveries, if any) so it informs without crowding. Pure, unit-tested.
+ */
+/**
+ * True when a recap body looks auto-generated (vs. a human/post_task recap). Auto recaps come in a
+ * couple of shapes, all low-signal: the session-tracker's "Auto-captured session (N tool calls)" and
+ * the run-wrapper's "Edited N files across M tool calls". The common tell is a raw tool-call count.
+ */
+declare function isAutoRecap(body: string): boolean;
+/**
+ * Return a compact version of an auto recap body: a one-line header (the Goal line) plus the
+ * Discoveries section when it carries real content (e.g. detected failures). Non-auto recaps are
+ * returned unchanged.
+ */
+declare function compactAutoRecapBody(body: string, maxChars?: number): string;
+
+type MemoryPriority = "must_read" | "useful" | "background";
+/**
+ * Normalized priority evidence. A caller fills only the signals it can compute; unknown ones default
+ * to false (see {@link DEFAULT_PRIORITY_SIGNALS}). The MCP path has semantic scores; the CLI path has
+ * lexical scores — both reduce to these booleans.
+ */
+interface PrioritySignals {
+    /** Memory type (attempt, gotcha, skill, decision, …). */
+    type: string;
+    /** Memory tags — used for the stack-pack / env-workaround down-rank. */
+    tags: string[];
+    /** The memory demands explicit human approval — always surface first. */
+    requiresHumanApproval: boolean;
+    /** Anchored to a file the agent is editing. */
+    directAnchor: boolean;
+    /** Anchored to a symbol the agent requested. */
+    directSymbol: boolean;
+    /** Exact/literal task match (semantic match_quality "exact", or an exact lexical task hit). */
+    exactTaskMatch: boolean;
+    /** Strong semantic relevance (cosine ≥ 0.65). CLI has no embeddings → passes false. */
+    strongSemantic: boolean;
+    /** Useful-level relevance: semantic ≥ 0.35, a partial task hit, or a high lexical score. */
+    usefulSemantic: boolean;
+    /** Matched an inferred module or domain from the touched files. */
+    moduleOrDomainMatch: boolean;
+    /** A memory tag matched a task token. */
+    tagTaskMatch: boolean;
+}
+declare const DEFAULT_PRIORITY_SIGNALS: PrioritySignals;
+/** Convenience: build a full signal set from a partial one. */
+declare function prioritySignals(partial: Partial<PrioritySignals>): PrioritySignals;
+/**
+ * Classify a memory's briefing priority from its signals. Order matters:
+ *   1. must_read — human-approval gates, direct anchor/symbol matches, and exact/strong hits on
+ *      negative (attempt) or skill memories: the things an agent must not miss.
+ *   2. background (down-rank) — generic stack-pack seeds and local dev-environment workarounds never
+ *      claim `useful` on a semantic/tag match alone; they'd crowd out repo-specific knowledge. (A
+ *      direct anchor already promoted them to must_read above, so genuinely-relevant ones still rank.)
+ *   3. useful — skills, module/domain matches, exact hits, and useful-level relevance.
+ *   4. background — everything else.
+ */
+declare function classifyMemoryPriority(signals: PrioritySignals): MemoryPriority;
+declare function priorityRank(priority: MemoryPriority): number;
+
+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, DEFAULT_PRIORITY_SIGNALS, type DashboardOptions, type DashboardReport, type DepChange, type DepTrackResult, type DependencySnapshot, type DocFrequency, type DormantRow, type DraftOptions, type DraftsOptions, ENV_WORKAROUND_TAGS, 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 MemoryPriority, 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, type PrioritySignals, 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, classifyMemoryPriority, codeMapPath, collectTimelineEntries, compactAutoRecapBody, 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, isAutoRecap, isCovered, isDecaying, isDistinctiveToken, isEnvWorkaroundMemory, 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, priorityRank, prioritySignals, 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 };