@hiveai/core 0.15.0 → 0.18.0

package/dist/index.d.ts

@@ -565,6 +565,21 @@ interface ImpactSummary {
 }
 /** Roll up a set of impact scores into tier counts. */
 declare function summarizeImpact(scores: ImpactScore[]): ImpactSummary;
+type FeedbackAdjustmentAction = "none" | "downgrade-block-sensor" | "deprecate-memory";
+interface FeedbackAdjustment {
+    action: FeedbackAdjustmentAction;
+    reason: string;
+}
+interface FeedbackAdjustmentOptions {
+    /** Rejections needed before deprecating a memory with no positive outcomes. Defaults to 2. */
+    rejectionThreshold?: number;
+}
+/**
+ * Turn explicit human rejection (`mem_feedback outcome=rejected`) into a deterministic
+ * noise-reduction action. Pure: callers decide whether to persist the returned change.
+ */
+declare function recommendFeedbackAdjustment(fm: MemoryFrontmatter, usage: MemoryUsage, options?: FeedbackAdjustmentOptions): FeedbackAdjustment;
+declare function applyFeedbackAdjustment(fm: MemoryFrontmatter, adjustment: FeedbackAdjustment, now?: Date): MemoryFrontmatter;
 
 type PreventionSource = "sensor" | "anti-pattern";
 interface PreventionEvent {
@@ -608,6 +623,44 @@ interface RecurrenceReport {
     top: RecurrenceRow[];
 }
 declare function computeRecurrence(events: PreventionEvent[]): RecurrenceReport;
+interface BriefingProofLineOptions {
+    /** End of the reporting window. Defaults to now. */
+    now?: Date;
+    /** Window size in days. Defaults to 30 ("this month" in product copy). */
+    days?: number;
+}
+/**
+ * Coordination point for Lot C: turn prevention events into one compact proof line
+ * suitable for get_briefing, without coupling this lot to the MCP tool.
+ */
+declare function briefingProofLine(events: PreventionEvent[], options?: BriefingProofLineOptions): string | null;
+interface CaughtForYouOptions {
+    /** Only include events at or after this instant. */
+    since?: string | Date;
+    /** Only include events at or before this instant. Defaults to now. */
+    now?: Date;
+    /** Max rows in the summary. Defaults to 5. */
+    limit?: number;
+}
+interface CaughtForYouRow {
+    id: string;
+    title: string;
+    source: PreventionSource;
+    catches: number;
+    previous_count: number;
+    current_count: number;
+    last_at: string;
+}
+interface CaughtForYouSummary {
+    total_catches: number;
+    since: string | null;
+    until: string;
+    rows: CaughtForYouRow[];
+}
+/** Build the end-of-session "caught for you" scene from prevention events. Pure. */
+declare function summarizeCaughtForYou(events: PreventionEvent[], memories: LoadedMemory[], usage: UsageIndex, options?: CaughtForYouOptions): CaughtForYouSummary;
+/** Render a compact human-readable block for CLI/session recaps. */
+declare function renderCaughtForYou(summary: CaughtForYouSummary): string | null;
 
 /** How long an emitted project context is considered "still fresh in the agent's context". */
 declare const PROJECT_CONTEXT_THROTTLE_MS: number;
@@ -676,6 +729,12 @@ interface SensorCaseResult {
 }
 interface RetrievalAggregate {
     cases: RetrievalCaseResult[];
+    /**
+     * Top-k precision = expected hits ÷ surfaced results. Inherently LOW when only ~1 memory is
+     * expected per case but k results are surfaced (e.g. 1/8 ≈ 0.12) — this is a top-k artifact, not
+     * a quality defect. Retrieval quality is judged by `mean_recall` and `mrr`; precision is NOT part
+     * of the headline eval score (see `scoreEval`). Reported for completeness only.
+     */
     mean_precision: number;
     mean_recall: number;
     /** Mean reciprocal rank of the first expected hit — rewards ranking the right memory high. */
@@ -795,6 +854,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/).
@@ -1180,6 +1252,13 @@ interface HaiveConfig {
         toolProfile?: "enforcement" | "maintenance" | "experimental" | "full";
         /** Named memory/policy families enabled for this project. */
         policyPacks?: string[];
+        /**
+         * Branch on which `enforce finish` enforces the release discipline (lockstep version bump +
+         * matching pushed tag) as a HARD gate. On any other branch — feature/* or an integration branch
+         * like `develop` — those same checks are advisory (warn), since the version/tag are produced when
+         * releasing from this branch, not on every integration commit. Default: "main".
+         */
+        releaseBranch?: string;
     };
 }
 declare const DEFAULT_CONFIG: HaiveConfig;
@@ -1488,6 +1567,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>;
@@ -1683,8 +1770,26 @@ declare function parseSarif(input: string | unknown): Finding[];
  * lives in `component` as `projectKey:relative/path`; we strip the project key.
  */
 declare function parseSonar(input: string | unknown): Finding[];
+/**
+ * Parse the ESLint JSON formatter output (`eslint --format json`): an array of
+ * `{ filePath, messages: [{ ruleId, severity, message, line }] }`. No SARIF formatter
+ * package needed — this is ESLint's built-in format. `severity` is 2=error, 1=warning.
+ * `opts.cwd`, when given, makes absolute `filePath`s project-relative so anchoring works.
+ */
+declare function parseEslintJson(input: string | unknown, opts?: {
+    cwd?: string;
+}): Finding[];
+/**
+ * Parse `npm audit --json` output (`vulnerabilities` map). Each vulnerable package becomes one
+ * finding anchored to `package.json` (vulnerabilities are dependency-level, not file-level), so
+ * the next agent is warned before re-introducing or ignoring the advisory.
+ */
+declare function parseNpmAudit(input: string | unknown): Finding[];
+type FindingFormat = "sarif" | "sonar" | "eslint" | "npm-audit";
 /** Dispatch to the right parser by declared format. */
-declare function parseFindings(format: "sarif" | "sonar", input: string | unknown): Finding[];
+declare function parseFindings(format: FindingFormat, input: string | unknown, opts?: {
+    cwd?: string;
+}): 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). */
@@ -1723,6 +1828,21 @@ interface GateTuningSuggestion {
     recommended: AntiPatternGate;
     reason: string;
 }
+interface GatePrecisionMetricDelta {
+    baseline: number | null;
+    current: number | null;
+    delta: number | null;
+}
+interface GatePrecisionDelta {
+    precision: GatePrecisionMetricDelta;
+    rejections: GatePrecisionMetricDelta;
+    /** True when humans rejected more gate output than the baseline run. */
+    false_positives_increased: boolean;
+    /** True when precision is known on both sides and dropped. */
+    precision_regressed: boolean;
+    /** CI-friendly rollup: either more false positives or lower known precision. */
+    regressed: boolean;
+}
 /**
  * Compute the gate's signal quality from prevention events + usage.
  * @param currentGate the configured antiPatternGate, used to decide whether to suggest a change.
@@ -1734,6 +1854,8 @@ declare function computeGatePrecision(events: PreventionEvent[], usage: UsageInd
  * there isn't enough signal to act on.
  */
 declare function suggestGate(precision: number | null, rejections: number, currentGate: AntiPatternGate): GateTuningSuggestion | null;
+/** Compare gate signal quality against a baseline for CI regression gates. Pure. */
+declare function compareGatePrecision(baseline: GatePrecision, current: GatePrecision): GatePrecisionDelta;
 
 interface DashboardOptions {
     /** How many rows to include in each "top" list. Default 10. */
@@ -1781,6 +1903,19 @@ interface DashboardReport {
         by_type: Record<string, number>;
         by_status: Record<string, number>;
     };
+    /** OUTCOME measurement: prevention events = times a memory's sensor/anti-pattern fired on a real
+     *  diff, intercepting a known mistake. Distinct from retrieval (reads) — demonstrated value. */
+    prevention: {
+        total_events: number;
+        memories_with_catches: number;
+        top: PreventionRow[];
+        /** Catch volume over time (from the prevention event log). */
+        trend: PreventionTrend;
+        /** 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;
     impact: ImpactSummary & {
         top: ImpactRow[];
     };
@@ -1806,19 +1941,6 @@ interface DashboardReport {
         decaying: number;
         top_dormant: DormantRow[];
     };
-    /** OUTCOME measurement: prevention events = times a memory's sensor/anti-pattern fired on a real
-     *  diff, intercepting a known mistake. Distinct from retrieval (reads) — demonstrated value. */
-    prevention: {
-        total_events: number;
-        memories_with_catches: number;
-        top: PreventionRow[];
-        /** Catch volume over time (from the prevention event log). */
-        trend: PreventionTrend;
-        /** 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;
@@ -2005,7 +2127,7 @@ interface SeedProposal {
     /** The source commit, for provenance. */
     source_sha: string;
     /** Detected signal kind. */
-    kind: "revert" | "fixup";
+    kind: "revert" | "fixup" | "workaround";
 }
 /**
  * Turn commits into seed proposals. A `Revert "X"` commit proposes an attempt about X; an obvious
@@ -2013,6 +2135,42 @@ interface SeedProposal {
  */
 declare function proposeSeedsFromCommits(commits: GitCommit[], limit?: number): SeedProposal[];
 
+/**
+ * Pure stack-detection helpers for cold-start seeding.
+ *
+ * Multi-language: reads package.json deps (JS/TS), requirements.txt (Python),
+ * go.mod (Go), and pom.xml (Java/Spring) to produce the list of detected stacks.
+ * No I/O — the caller reads the files and passes contents in, making this fully testable.
+ */
+interface DetectStacksInput {
+    /** Merged deps from package.json (dependencies + devDependencies). */
+    packageJsonDeps?: Record<string, string>;
+    /** Raw text of requirements.txt (or any requirements file). */
+    requirementsTxt?: string;
+    /** Raw text of go.mod. */
+    goMod?: string;
+    /** Raw text of pom.xml. */
+    pomXml?: string;
+    /** Raw text of composer.json (PHP). */
+    composerJson?: string;
+    /** Raw text of Gemfile (Ruby). */
+    gemfile?: string;
+    /** True when at least one .csproj/.sln file is present (.NET). */
+    hasCsproj?: boolean;
+    /** True when a Dockerfile is present. */
+    hasDockerfile?: boolean;
+    /** True when turbo.json is present (Turborepo). */
+    hasTurboJson?: boolean;
+    /** True when nx.json is present (Nx). */
+    hasNxJson?: boolean;
+}
+type DetectableStack = "nestjs" | "nextjs" | "remix" | "react" | "express" | "fastify" | "prisma" | "drizzle" | "zustand" | "redux" | "reactquery" | "trpc" | "mongoose" | "graphql" | "vue" | "tailwind" | "vite" | "sveltekit" | "astro" | "typescript" | "monorepo" | "fastapi" | "django" | "flask" | "go" | "spring" | "laravel" | "rails" | "dotnet" | "docker";
+/**
+ * Detect stacks present in a project from the raw contents of its manifest files.
+ * Pure — no I/O. Pass what you have; omit what you don't.
+ */
+declare function detectStacksFromManifests(input: DetectStacksInput): DetectableStack[];
+
 interface MergeResult {
     /** The chosen file content. */
     content: string;
@@ -2027,4 +2185,147 @@ interface MergeResult {
  */
 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 };
+/**
+ * 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;
+
+/**
+ * Native bridge generator — produces agent-harness-specific config files
+ * from the hAIve corpus (validated memories + block sensors).
+ *
+ * One pure formatter per target; no I/O.
+ * The CLI command (cli/commands/bridges.ts) handles file writes and
+ * idempotent marker-based updates.
+ *
+ * Exposed for Lot A (init.ts): call generateBridges() from haive init
+ * to seed all bridges at initialisation time.
+ */
+
+type BridgeTarget = "claude" | "cursor" | "cline" | "windsurf" | "continue" | "cody" | "zed" | "roo" | "gemini" | "aider" | "agents" | "copilot";
+/** Canonical relative path from project root for each target. */
+declare const BRIDGE_TARGET_PATH: Record<BridgeTarget, string>;
+declare const BRIDGE_TARGETS: BridgeTarget[];
+/**
+ * Condensed sensor shape for bridge injection.
+ * Callers extract this from Memory.frontmatter.sensor — no sensor-module import needed.
+ */
+interface BridgeSensor {
+    id: string;
+    severity: "block" | "warn";
+    message: string;
+    /** Regex pattern, present when sensor.kind === "regex". */
+    pattern?: string;
+    /** Scoped file paths (sensor.paths ?? anchor.paths). */
+    paths: string[];
+}
+interface BridgeMemoryEntry {
+    id: string;
+    scope: string;
+    type: string;
+    summary: string;
+    /** Anchor paths the memory applies to (for path-scoped display / Cursor globs). */
+    paths: string[];
+}
+interface GenerateBridgesOptions {
+    /** Max memories to inject per bridge (default: 8). */
+    maxMemories?: number;
+    /** Restrict generation to these targets. Defaults to all BRIDGE_TARGETS. */
+    targets?: BridgeTarget[];
+}
+interface BridgeFileOutput {
+    target: BridgeTarget;
+    /** Relative path from project root. */
+    path: string;
+    content: string;
+}
+declare const BRIDGE_MARKERS: {
+    readonly memoriesStart: "<!-- haive:memories-start -->";
+    readonly memoriesEnd: "<!-- haive:memories-end -->";
+    readonly sensorsStart: "<!-- haive:sensors-start -->";
+    readonly sensorsEnd: "<!-- haive:sensors-end -->";
+};
+/** First meaningful line of a memory body, condensed for bridge display. */
+declare function bridgeMemorySummary(body: string): string;
+/**
+ * Filter and rank memories + sensors for bridge injection.
+ * Pure — callers load data; this function does not read files.
+ */
+declare function prepareBridgeData(memories: Memory[], sensors: BridgeSensor[], opts?: Pick<GenerateBridgesOptions, "maxMemories">): {
+    topMemories: BridgeMemoryEntry[];
+    blockSensors: BridgeSensor[];
+};
+/**
+ * Generate bridge file content for the requested targets.
+ *
+ * Pure: accepts loaded memories + sensors, returns file content strings.
+ * The CLI command handles I/O and idempotent marker-based updates.
+ *
+ * **Lot A integration point**: call this from `haive init` to seed bridges at initialisation.
+ * Signature is intentionally stable — init.ts should call:
+ *   `generateBridges(memories, sensors, { targets: BRIDGE_TARGETS })`
+ */
+declare function generateBridges(memories: Memory[], sensors: BridgeSensor[], opts?: GenerateBridgesOptions): BridgeFileOutput[];
+
+export { AUTOPILOT_DEFAULTS, type Activation, type ActivationContext, ActivationSchema, type Anchor, AnchorSchema, type AntiPatternGate, type AutoPromoteRule, BRIDGE_MARKERS, BRIDGE_TARGETS, BRIDGE_TARGET_PATH, BRIEFING_MARKER_TTL_MS, BRIEFING_PRESET_DEFAULTS, type BreakingChange, type BridgeFileOutput, type BridgeMemoryEntry, type BridgeSensor, type BridgeTarget, type BriefingBudgetNumbers, type BriefingBudgetPreset, type BriefingMarker, type BriefingProofLineOptions, type BudgetPart, type BudgetSlice, type BuildCodeMapOptions, CHARS_PER_TOKEN, CODE_MAP_FILE, CODE_STOPWORDS, CONFIG_FILE, type CaughtForYouOptions, type CaughtForYouRow, type CaughtForYouSummary, 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 DetectStacksInput, type DetectableStack, 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 FeedbackAdjustment, type FeedbackAdjustmentAction, type FeedbackAdjustmentOptions, type Finding, type FindingFormat, type FindingSeverity, GUESSABLE_THRESHOLD, type GatePrecision, type GatePrecisionDelta, type GatePrecisionMetricDelta, type GateTuningSuggestion, type GenerateBridgesOptions, 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, applyFeedbackAdjustment, bridgeMemorySummary, briefingMarkerPath, briefingMarkersDir, briefingProofLine, buildCodeMap, buildCoverageIndex, buildDashboard, buildDocFrequency, buildFrontmatter, buildReport, bumpRead, classifyMemoryPriority, codeMapPath, collectTimelineEntries, compactAutoRecapBody, compareEvalReports, compareGatePrecision, compareImpact, compileRegexSensor, computeEvalTrend, computeGatePrecision, computeImpact, computePreventionTrend, computeRecurrence, configPath, contractLockPath, deriveConfidence, detectStacksFromManifests, diffContract, diffHasDistinctiveOverlap, distinctiveCap, draftsFromFindings, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, evalHistoryPath, evaluateSkillActivation, extractActionsBriefBody, extractSnippet, filterNewDrafts, findCoverageGaps, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, findUncapturedFailures, findingBody, findingToDraft, firstMemoryOneLine, generateBridges, 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, parseEslintJson, parseFindings, parseMemory, parseNpmAudit, parseSarif, parseSince, parseSonar, pathsOverlap, pickSnippetNeedle, planConflictResolution, prepareBridgeData, preventionLogPath, priorityRank, prioritySignals, projectContextRecentlyEmitted, proposeSeedsFromCommits, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recommendFeedbackAdjustment, recordApplied, recordPrevention, recordProjectContextEmission, recordRejection, relPathFrom, renderCaughtForYou, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runRegexSensor, runSensors, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, scoreRetrievalCase, scoreSensorCase, selectCommandSensors, sensorAppliesToPath, sensorTargetsFromDiff, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestGate, suggestSensorFromMemory, suggestTopicKey, summarizeCaughtForYou, summarizeImpact, synthesizeSelfEvalCases, titleFromBody, tokenizeQuery, tokenizeWords, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };