@hivelore/mcp 0.30.0

package/dist/server.d.ts

@@ -0,0 +1,819 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import * as _hivelore_core from '@hivelore/core';
+import { HaivePaths, ConfidenceLevel, ImpactTier, SensorTarget, resolveProjectInfo, readRuntimeJournalTail } from '@hivelore/core';
+import { z } from 'zod';
+
+interface HaiveContext {
+    paths: HaivePaths;
+}
+interface CreateContextOptions {
+    root?: string;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}
+
+declare class SessionTracker {
+    private events;
+    private startedAt;
+    private config;
+    private ctx;
+    private shutdownRegistered;
+    constructor(ctx: HaiveContext);
+    init(): Promise<void>;
+    record(tool: string, summary?: string): void;
+    private registerShutdownHandler;
+}
+
+type BriefingMemoryPriority = "must_read" | "useful" | "background";
+interface BriefingQuality {
+    level: "strong" | "thin" | "noisy";
+    reasons: string[];
+}
+interface BriefingMemory {
+    id: string;
+    scope: string;
+    type: string;
+    module?: string;
+    tags: string[];
+    status: string;
+    confidence: ConfidenceLevel;
+    /** Present when confidence is 'low' or 'unverified' — AI should weight this memory cautiously. */
+    unverified?: true;
+    read_count: number;
+    /** Demonstrated-utility score in [0,1] from the closed-loop impact layer (reads + applied + sensor fires vs rejections/stale/dormancy). */
+    impact_score?: number;
+    /** Impact tier derived from {@link impact_score}. A nudge in ranking; surfaced for transparency. */
+    impact_tier?: ImpactTier;
+    reasons: Array<"anchor" | "module" | "domain" | "semantic" | "symbol">;
+    match_quality: "exact" | "partial" | "semantic";
+    semantic_score?: number;
+    /** Relevance tier for the current task. `must_read` should be consumed before edits. */
+    priority: BriefingMemoryPriority;
+    /** Human/agent-readable explanation for why this record was surfaced. */
+    why?: string[];
+    body: string;
+    file_path: string;
+}
+interface CodeMapSymbolHit {
+    symbol: string;
+    /** files that export this symbol */
+    locations: Array<{
+        file: string;
+        kind: string;
+        line: number;
+        description?: string;
+    }>;
+}
+interface ActionRequiredItem {
+    /** Memory id containing the alert */
+    id: string;
+    /** Short human-readable summary of the issue */
+    summary: string;
+    /**
+     * The exact message to show the developer before doing anything.
+     * Copy-paste this verbatim — do NOT paraphrase or act before confirmation.
+     */
+    developer_message: string;
+}
+/** A single structured breadcrumb pointer (machine-readable twin of a `start_here` string). */
+interface BriefingBreadcrumbItem {
+    type: "memory" | "code" | "files";
+    /** memory: record id (fetch with mem_get). */
+    id?: string;
+    scope?: string;
+    /** memory record type (decision/gotcha/…). */
+    mem_type?: string;
+    priority?: string;
+    /** memory: anchor path the lesson applies to · code: file exporting the symbol · files: a target path. */
+    file?: string;
+    line?: number;
+    kind?: string;
+    symbol?: string;
+}
+interface BriefingBreadcrumbs {
+    /**
+     * Small first-hop map for the agent. These are not full context; they are the best
+     * places to look before deciding whether deeper reads are needed.
+     */
+    start_here: string[];
+    /**
+     * Structured twin of {@link start_here} — typed pointers (id / file / line / kind) so an agent can
+     * act (open the file, mem_get the id) without parsing strings. Still pointers, never body copies.
+     */
+    start_here_items?: BriefingBreadcrumbItem[];
+    /**
+     * Follow-up calls/reads for progressive disclosure. Agents should pull these only
+     * when the task still needs more detail after the briefing.
+     */
+    drill_down: string[];
+    /** Short operating note for this briefing. */
+    note?: string;
+}
+interface BriefingOutput {
+    task?: string;
+    /** Version of the Hivelore MCP server answering this briefing — lets the agent/human spot a stale server vs the repo. */
+    server_version: string;
+    search_mode: "semantic" | "literal_fallback" | "literal";
+    match_quality_note?: string;
+    inferred_modules: string[];
+    last_session?: {
+        id: string;
+        scope: string;
+        revision_count: number;
+        body: string;
+    };
+    project_context: {
+        content: string;
+        truncated: boolean;
+        is_template?: boolean;
+        auto_generated?: boolean;
+        omitted_recent?: boolean;
+    } | null;
+    module_contexts: Array<{
+        name: string;
+        content: string;
+        truncated: boolean;
+    }>;
+    memories: BriefingMemory[];
+    briefing_quality: BriefingQuality;
+    /**
+     * Breadcrumbs-first context map: keep the default briefing small, then pull deeper
+     * memories/code references only when the task needs them.
+     */
+    breadcrumbs?: BriefingBreadcrumbs;
+    symbol_locations?: CodeMapSymbolHit[];
+    /**
+     * Memories that require explicit human confirmation before any code action.
+     * IMPORTANT: for each item, show developer_message to the developer and
+     * wait for explicit approval before modifying any code.
+     */
+    action_required: ActionRequiredItem[];
+    decay_warnings: string[];
+    setup_warnings: string[];
+    /**
+     * True when this briefing carries little actionable signal:
+     * - project-context.md is still the default template
+     * - no memories matched the task (or none exist at all)
+     * - no previous session recap
+     */
+    low_value?: true;
+    /**
+     * Whether this briefing carries knowledge a capable model could NOT have inferred on its own.
+     * - "high": at least one surfaced memory is arbitrary/team-specific (unguessable).
+     * - "low":  nothing team-specific matched — a generic agent would reach the same answer.
+     */
+    briefing_value?: "high" | "low";
+    /**
+     * Short, action-oriented hints surfaced to the agent based on the briefing payload.
+     */
+    hints?: string[];
+    estimated_tokens: number;
+    budget: {
+        max_tokens: number;
+        /** Per-section token spend. `breadcrumbs` is present only when the breadcrumbs map is emitted. */
+        spent: {
+            project: number;
+            modules: number;
+            memories: number;
+            breadcrumbs?: number;
+        };
+        preset_applied?: "quick" | "balanced" | "deep";
+    };
+}
+
+declare const GetBriefingZod: z.ZodObject<{
+    task: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    max_tokens: z.ZodDefault<z.ZodNumber>;
+    max_memories: z.ZodDefault<z.ZodNumber>;
+    include_project_context: z.ZodDefault<z.ZodBoolean>;
+    dedupe_project_context: z.ZodOptional<z.ZodBoolean>;
+    include_module_contexts: z.ZodDefault<z.ZodBoolean>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+    include_stale: z.ZodDefault<z.ZodBoolean>;
+    track: z.ZodDefault<z.ZodBoolean>;
+    format: z.ZodDefault<z.ZodEnum<["full", "compact", "actions"]>>;
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    min_semantic_score: z.ZodDefault<z.ZodNumber>;
+    budget_preset: z.ZodOptional<z.ZodEnum<["quick", "balanced", "deep"]>>;
+}, "strip", z.ZodTypeAny, {
+    symbols: string[];
+    format: "full" | "compact" | "actions";
+    files: string[];
+    max_tokens: number;
+    max_memories: number;
+    include_project_context: boolean;
+    include_module_contexts: boolean;
+    semantic: boolean;
+    include_stale: boolean;
+    track: boolean;
+    min_semantic_score: number;
+    task?: string | undefined;
+    dedupe_project_context?: boolean | undefined;
+    budget_preset?: "quick" | "balanced" | "deep" | undefined;
+}, {
+    symbols?: string[] | undefined;
+    format?: "full" | "compact" | "actions" | undefined;
+    task?: string | undefined;
+    files?: string[] | undefined;
+    max_tokens?: number | undefined;
+    max_memories?: number | undefined;
+    include_project_context?: boolean | undefined;
+    dedupe_project_context?: boolean | undefined;
+    include_module_contexts?: boolean | undefined;
+    semantic?: boolean | undefined;
+    include_stale?: boolean | undefined;
+    track?: boolean | undefined;
+    min_semantic_score?: number | undefined;
+    budget_preset?: "quick" | "balanced" | "deep" | undefined;
+}>;
+type GetBriefingInput = z.infer<typeof GetBriefingZod>;
+declare function getBriefing(input: GetBriefingInput, ctx: HaiveContext): Promise<BriefingOutput>;
+
+declare const CodeMapInputZod: z.ZodObject<{
+    file: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    max_files: z.ZodDefault<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    max_files: number;
+    symbol?: string | undefined;
+    max_tokens?: number | undefined;
+    file?: string | undefined;
+}, {
+    symbol?: string | undefined;
+    paths?: string[] | undefined;
+    max_tokens?: number | undefined;
+    file?: string | undefined;
+    max_files?: number | undefined;
+}>;
+type CodeMapInput = z.infer<typeof CodeMapInputZod>;
+interface CodeMapToolOutput {
+    available: boolean;
+    generated_at?: string;
+    total_files?: number;
+    files: Array<{
+        path: string;
+        summary?: string;
+        loc: number;
+        exports: Array<{
+            name: string;
+            kind: string;
+            description?: string;
+            line: number;
+        }>;
+    }>;
+    /** Number of matched files dropped due to max_files / max_tokens. */
+    truncated?: number;
+    /** True when at least one file was dropped to fit the token budget. */
+    budget_clipped?: true;
+    notice?: string;
+}
+declare function codeMapTool(input: CodeMapInput, ctx: HaiveContext): Promise<CodeMapToolOutput>;
+
+declare const GetRecapInputSchema: {
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "any"]>>;
+};
+type GetRecapInput = {
+    [K in keyof typeof GetRecapInputSchema]: z.infer<(typeof GetRecapInputSchema)[K]>;
+};
+interface GetRecapOutput {
+    recap: {
+        id: string;
+        scope: string;
+        revision_count: number;
+        created_at: string;
+        body: string;
+    } | null;
+    notice?: string;
+}
+/**
+ * Lightweight alternative to get_briefing when you ONLY need the previous
+ * session recap (e.g. resuming a long task between sessions). Skips project
+ * context, modules, and memory ranking — pays only the recap's token cost.
+ */
+declare function getRecap(input: GetRecapInput, ctx: HaiveContext): Promise<GetRecapOutput>;
+
+declare const MemRelevantToInputSchema: {
+    task: z.ZodString;
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    min_semantic_score: z.ZodDefault<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<["full", "compact", "actions"]>>;
+};
+type MemRelevantToInput = {
+    [K in keyof typeof MemRelevantToInputSchema]: z.infer<(typeof MemRelevantToInputSchema)[K]>;
+};
+interface MemRelevantToOutput {
+    task: string;
+    search_mode: "semantic" | "literal_fallback" | "literal";
+    memories: BriefingMemory[];
+    briefing_quality: BriefingQuality;
+    hints?: string[];
+    /**
+     * True when the search returned zero memories — clients can skip surfacing
+     * an empty payload to the model.
+     */
+    empty?: true;
+}
+/**
+ * One-shot ranked memories for a task. Use instead of get_briefing when you
+ * already have project context loaded and only want the relevant memory layer.
+ *
+ * Runs the same ranking (anchor / module / literal / semantic) as get_briefing
+ * but skips project_context, module_contexts, action_required, etc. — paying
+ * only the cost of the memory bodies you actually get back.
+ */
+declare function memRelevantTo(input: MemRelevantToInput, ctx: HaiveContext): Promise<MemRelevantToOutput>;
+
+declare const CodeSearchInputSchema: {
+    query: z.ZodString;
+    k: z.ZodDefault<z.ZodNumber>;
+    min_score: z.ZodDefault<z.ZodNumber>;
+};
+type CodeSearchInput = {
+    [K in keyof typeof CodeSearchInputSchema]: z.infer<(typeof CodeSearchInputSchema)[K]>;
+};
+interface CodeSearchHit {
+    file: string;
+    name: string;
+    kind: string;
+    line: number;
+    description?: string;
+    score: number;
+}
+interface CodeSearchOutput {
+    available: boolean;
+    hits: CodeSearchHit[];
+    /** True when the embeddings index was built from an older code-map — results may miss new/moved symbols. */
+    stale?: true;
+    notice?: string;
+}
+declare function codeSearch(input: CodeSearchInput, ctx: HaiveContext): Promise<CodeSearchOutput>;
+
+declare const WhyThisFileInputSchema: {
+    path: z.ZodString;
+    git_log_limit: z.ZodDefault<z.ZodNumber>;
+    memory_limit: z.ZodDefault<z.ZodNumber>;
+};
+type WhyThisFileInput = {
+    [K in keyof typeof WhyThisFileInputSchema]: z.infer<(typeof WhyThisFileInputSchema)[K]>;
+};
+interface WhyThisFileOutput {
+    file: string;
+    exists: boolean;
+    recent_commits: Array<{
+        sha: string;
+        author: string;
+        relative_date: string;
+        subject: string;
+    }>;
+    memories: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        body_preview: string;
+    }>;
+    code_map_entry: {
+        summary?: string;
+        loc: number;
+        exports: Array<{
+            name: string;
+            kind: string;
+            line: number;
+            description?: string;
+        }>;
+    } | null;
+    hints?: string[];
+}
+/**
+ * One-shot file-context lookup: combines recent git history, memories anchored
+ * to the path, and the code-map entry. Designed to answer "why is this file
+ * the way it is?" in a single call instead of 3-4 manual ones.
+ */
+declare function whyThisFile(input: WhyThisFileInput, ctx: HaiveContext): Promise<WhyThisFileOutput>;
+
+interface AntiPatternsCheckInput {
+    diff?: string;
+    paths: string[];
+    limit: number;
+    semantic: boolean;
+    min_semantic_score?: number;
+}
+interface AntiPatternsWarning {
+    id: string;
+    type: "attempt" | "gotcha";
+    scope: string;
+    confidence: string;
+    body_preview: string;
+    reasons: Array<"anchor" | "literal" | "semantic" | "sensor">;
+    /**
+     * True when the LITERAL overlap includes a token that is *distinctive* to this memory
+     * (rare across the gotcha corpus) — e.g. `BigInt`, `open-in-view`. Only a distinctive
+     * literal overlap is precise enough to hard-block; a shared common word ("memory",
+     * "scope", "version") sets only the `literal` reason for review. Powers the gate.
+     */
+    distinctive_literal?: boolean;
+    semantic_score?: number;
+    /** When a regex sensor fired: its self-correction message and severity. */
+    sensor_message?: string;
+    sensor_severity?: "warn" | "block";
+    /** Memory tags — used downstream (e.g. pre_commit_check) to weight a warning by topic. */
+    tags?: string[];
+    /** Anchor paths of the memory — lets the gate tell what kind of file this warning is about. */
+    anchor_paths?: string[];
+    /**
+     * True when the memory has an executable sensor defined.
+     * Used by the pre-commit gate: if a sensor exists but did NOT fire (no "sensor" reason),
+     * the sensor is the authoritative check and literal matching alone should not block.
+     */
+    has_sensor?: boolean;
+}
+interface AntiPatternsCheckOutput {
+    /** Total number of attempt+gotcha memories that exist in this project. */
+    scanned: number;
+    warnings: AntiPatternsWarning[];
+    notice?: string;
+}
+/**
+ * Scan a diff (or set of paths) against documented attempt/gotcha memories.
+ * Surfaces "you are about to repeat a known mistake" warnings BEFORE you commit.
+ *
+ * Matching strategy:
+ *   1. Anchor — memories anchored to any of the changed paths
+ *   2. Literal — tokens from the diff overlap with memory body
+ *   3. Semantic — cosine similarity (when enabled and index available)
+ */
+declare function antiPatternsCheck(input: AntiPatternsCheckInput, ctx: HaiveContext): Promise<AntiPatternsCheckOutput>;
+
+declare const MemDistillInputSchema: {
+    since_days: z.ZodDefault<z.ZodNumber>;
+    min_cluster: z.ZodDefault<z.ZodNumber>;
+    type_filter: z.ZodDefault<z.ZodEnum<["gotcha", "attempt", "all"]>>;
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "module", "any"]>>;
+};
+type MemDistillInput = {
+    [K in keyof typeof MemDistillInputSchema]: z.infer<(typeof MemDistillInputSchema)[K]>;
+};
+interface DistillCluster {
+    suggested_topic: string;
+    suggested_type: "convention" | "gotcha";
+    member_ids: string[];
+    overlapping_paths: string[];
+    common_keywords: string[];
+    sample_titles: string[];
+    /** ISO date of the latest member */
+    latest_at: string;
+}
+interface MemDistillOutput {
+    scanned: number;
+    /** Memories that didn't fit any cluster (kept here so callers can inspect singletons). */
+    singletons: number;
+    clusters: DistillCluster[];
+    notice?: string;
+}
+/**
+ * Cluster recurring observations / attempts so a human can collapse N similar
+ * memories into one richer convention/gotcha. Uses cheap heuristics (anchor
+ * path overlap + body keyword overlap) — no embeddings needed.
+ *
+ * Output is *advisory*: nothing is written to disk. The caller (CLI / human)
+ * decides whether to mem_save the consolidated form.
+ */
+declare function memDistill(input: MemDistillInput, ctx: HaiveContext): Promise<MemDistillOutput>;
+
+declare const WhyThisDecisionInputSchema: {
+    id: z.ZodString;
+    git_log_limit: z.ZodDefault<z.ZodNumber>;
+};
+type WhyThisDecisionInput = {
+    [K in keyof typeof WhyThisDecisionInputSchema]: z.infer<(typeof WhyThisDecisionInputSchema)[K]>;
+};
+interface WhyThisDecisionOutput {
+    found: boolean;
+    decision?: {
+        id: string;
+        type: string;
+        scope: string;
+        status: string;
+        confidence: string;
+        body: string;
+        created_at: string;
+    };
+    /** Memories explicitly linked via related_ids on the decision (or vice versa). */
+    related: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        body_preview: string;
+        relation: "explicit" | "back-link";
+    }>;
+    /** Other memories anchored to overlapping paths — implicit context. */
+    path_neighbors: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        overlap: string[];
+        body_preview: string;
+    }>;
+    /** Recent git commits touching any of the decision's anchored paths. */
+    recent_commits: Array<{
+        path: string;
+        sha: string;
+        author: string;
+        relative_date: string;
+        subject: string;
+    }>;
+    hints?: string[];
+    notice?: string;
+}
+/**
+ * Trace the genealogy of a `decision` memory: the decision itself + memories
+ * explicitly linked to it + memories anchored to overlapping paths + recent
+ * commits touching those paths. One call instead of 4-5 manual lookups.
+ *
+ * Works on any memory type, but is optimized for `decision` and `architecture`.
+ */
+declare function whyThisDecision(input: WhyThisDecisionInput, ctx: HaiveContext): Promise<WhyThisDecisionOutput>;
+
+declare const MemConflictsInputSchema: {
+    id: z.ZodString;
+    min_score: z.ZodDefault<z.ZodNumber>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+};
+type MemConflictsInput = {
+    [K in keyof typeof MemConflictsInputSchema]: z.infer<(typeof MemConflictsInputSchema)[K]>;
+};
+type ConflictReason = "opposite-status" | "attempt-vs-convention-same-paths" | "polarity-keywords" | "explicit-contradiction-tag";
+interface ConflictHit {
+    id: string;
+    type: string;
+    scope: string;
+    status: string;
+    confidence: string;
+    body_preview: string;
+    similarity: number | null;
+    reasons: ConflictReason[];
+    shared_paths: string[];
+}
+interface MemConflictsOutput {
+    found: boolean;
+    target?: {
+        id: string;
+        type: string;
+        status: string;
+    };
+    scanned: number;
+    conflicts: ConflictHit[];
+    notice?: string;
+}
+/**
+ * Find memories that potentially CONTRADICT the given memory. Useful before
+ * relying on a memory's advice — surfaces "another memory says the opposite".
+ *
+ * Detection layers (any of these triggers a hit):
+ *   - Opposite status: target is validated, neighbor is rejected — for the same topic
+ *   - Type mismatch on overlapping paths: an `attempt` (don't do X) coexists with
+ *     a `convention` (do X) anchored to overlapping paths
+ *   - Polarity keywords: target says "use X" while a semantic neighbor says "don't use X"
+ *   - Explicit contradiction tag (#contradicts:<id>) in either body
+ */
+declare function memConflicts(input: MemConflictsInput, ctx: HaiveContext): Promise<MemConflictsOutput>;
+
+declare const PreCommitCheckInputSchema: {
+    diff: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    block_on: z.ZodDefault<z.ZodEnum<["any", "high-confidence", "never"]>>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+    anchored_blocks: z.ZodDefault<z.ZodBoolean>;
+};
+type PreCommitCheckInput = {
+    [K in keyof typeof PreCommitCheckInputSchema]: z.infer<(typeof PreCommitCheckInputSchema)[K]>;
+};
+interface PreCommitCheckOutput {
+    /** True when at least one finding meets the configured block_on threshold. */
+    should_block: boolean;
+    /** Per-section summary; clients should surface the warnings + reasons to the user. */
+    summary: {
+        anti_patterns: number;
+        blocking_warnings?: number;
+        review_warnings?: number;
+        info_warnings?: number;
+        relevant_memories: number;
+        stale_anchors: number;
+    };
+    warnings: ClassifiedAntiPatternsWarning[];
+    /** Memories anchored to the touched files — convention reminders for the change author. */
+    relevant_memories: Array<{
+        id: string;
+        type: string;
+        confidence: string;
+        body_preview: string;
+    }>;
+    /** Memories whose anchored paths overlap with the diff AND are now stale — likely outdated knowledge. */
+    stale_anchors: Array<{
+        id: string;
+        paths: string[];
+        body_preview: string;
+    }>;
+    notice?: string;
+}
+type AntiPatternLevel = "blocking" | "review" | "info";
+interface ClassifiedAntiPatternsWarning extends AntiPatternsWarning {
+    /**
+     * blocking = commit gate should fail for the configured threshold;
+     * review = plausible but not strong enough to block;
+     * info = weak signal, hidden by default in human CLI output.
+     */
+    level: AntiPatternLevel;
+    rationale: string;
+    affected_files: string[];
+    repair_command: string;
+}
+/**
+ * One-shot "should I block this commit?" check.
+ *
+ * Combines three signals into a single call agents and git hooks can consume:
+ *   1. anti_patterns_check — known gotchas/attempts that match the diff
+ *   2. mem_for_files — conventions/decisions anchored to touched files
+ *   3. mem_verify — memories whose anchors are stale (knowledge may be wrong)
+ *
+ * Returns should_block per the configured threshold, plus the raw findings so
+ * the caller can render them. CLI wrapper: `hivelore precommit`.
+ */
+declare function preCommitCheck(input: PreCommitCheckInput, ctx: HaiveContext): Promise<PreCommitCheckOutput>;
+
+/**
+ * Read the PRESUMED-CORRECT contents of anchored files for sensor self-checks.
+ *
+ * "Silent on current" must test the last COMMITTED state (HEAD), not the working tree: an agent
+ * typically proposes a sensor right after hitting the failure, while the bad pattern is still
+ * sitting uncommitted in the anchored file — validating against the working tree then rejects
+ * every honest proposal with fires-on-current. HEAD already passed the gate, so it is the
+ * presumed-correct baseline; fall back to the working tree for files not yet in git.
+ */
+declare function readPresumedCorrectTargets(root: string, relPaths: string[]): Promise<SensorTarget[]>;
+
+declare const PatternDetectInputSchema: {
+    since_days: z.ZodDefault<z.ZodNumber>;
+    dry_run: z.ZodDefault<z.ZodBoolean>;
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team"]>>;
+};
+type PatternDetectInput = {
+    [K in keyof typeof PatternDetectInputSchema]: z.infer<(typeof PatternDetectInputSchema)[K]>;
+};
+type PatternKind = "config_change" | "repeated_path" | "hot_file";
+interface PatternMatch {
+    kind: PatternKind;
+    signal: string;
+    proposed_type: "convention" | "gotcha";
+    proposed_slug: string;
+    proposed_body: string;
+    anchor_paths: string[];
+}
+interface PatternDetectOutput {
+    scanned_events: number;
+    matches: PatternMatch[];
+    /** Number of proposed memories saved (0 if dry_run). */
+    saved: number;
+    /** IDs of saved memories. */
+    saved_ids: string[];
+    notice?: string;
+}
+declare function patternDetect(input: PatternDetectInput, ctx: HaiveContext): Promise<PatternDetectOutput>;
+
+/** Input is intentionally minimal — callers may pass cwd for multi-root clients. */
+declare const MemResolveProjectInputSchema: {
+    cwd: z.ZodOptional<z.ZodString>;
+};
+type MemResolveProjectInput = {
+    [K in keyof typeof MemResolveProjectInputSchema]: z.infer<(typeof MemResolveProjectInputSchema)[K]>;
+};
+declare function memResolveProject(input: MemResolveProjectInput, _ctx: HaiveContext): Promise<{
+    info: ReturnType<typeof resolveProjectInfo>;
+    ok: true;
+}>;
+
+declare const MemSuggestTopicInputSchema: {
+    type: z.ZodEnum<["convention", "decision", "gotcha", "architecture", "glossary", "skill", "attempt", "session_recap"]>;
+    title: z.ZodString;
+};
+type MemSuggestTopicInput = {
+    [K in keyof typeof MemSuggestTopicInputSchema]: z.infer<(typeof MemSuggestTopicInputSchema)[K]>;
+};
+declare function memSuggestTopic(input: MemSuggestTopicInput, _ctx: HaiveContext): Promise<{
+    topic_key: string;
+    family: string;
+    type: string;
+}>;
+
+declare const MemTimelineInputSchema: {
+    memory_id: z.ZodOptional<z.ZodString>;
+    topic: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+type MemTimelineInput = {
+    [K in keyof typeof MemTimelineInputSchema]: z.infer<(typeof MemTimelineInputSchema)[K]>;
+};
+declare function memTimeline(input: MemTimelineInput, ctx: HaiveContext): Promise<{
+    entries: _hivelore_core.TimelineEntry[];
+    total: number;
+    notice: string | undefined;
+}>;
+
+interface SuggestedResolution {
+    keep_id: string;
+    supersede_id: string;
+    reason: string;
+    /** Copy-paste command that APPLIES the guided supersede (promotes winner, deprecates loser). */
+    command: string;
+}
+declare const MemConflictCandidatesInputSchema: {
+    since_days: z.ZodDefault<z.ZodNumber>;
+    types: z.ZodDefault<z.ZodArray<z.ZodEnum<["decision", "architecture", "convention", "gotcha"]>, "many">>;
+    min_jaccard: z.ZodDefault<z.ZodNumber>;
+    max_pairs: z.ZodDefault<z.ZodNumber>;
+    max_scan: z.ZodDefault<z.ZodNumber>;
+    max_topic_pairs: z.ZodDefault<z.ZodNumber>;
+};
+type MemConflictCandidatesInput = {
+    [K in keyof typeof MemConflictCandidatesInputSchema]: z.infer<(typeof MemConflictCandidatesInputSchema)[K]>;
+};
+declare function memConflictCandidates(input: MemConflictCandidatesInput, ctx: HaiveContext): Promise<{
+    pairs: {
+        suggested_resolution: SuggestedResolution | null;
+        id_a: string;
+        id_b: string;
+        jaccard: number;
+    }[];
+    topic_status_pairs: {
+        suggested_resolution: SuggestedResolution | null;
+        id_a: string;
+        id_b: string;
+        topic: string;
+        status_a: string;
+        status_b: string;
+    }[];
+    scanned: number;
+    truncated: boolean;
+    notice: string | undefined;
+}>;
+
+declare const RuntimeJournalAppendInputSchema: {
+    message: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<["note", "session_end", "mcp"]>>;
+    tool: z.ZodOptional<z.ZodString>;
+};
+type RuntimeJournalAppendInput = {
+    [K in keyof typeof RuntimeJournalAppendInputSchema]: z.infer<(typeof RuntimeJournalAppendInputSchema)[K]>;
+};
+declare function runtimeJournalAppend(input: RuntimeJournalAppendInput, ctx: HaiveContext): Promise<{
+    ok: true;
+    path_hint: string;
+}>;
+
+declare const RuntimeJournalTailInputSchema: {
+    limit: z.ZodDefault<z.ZodNumber>;
+};
+type RuntimeJournalTailInput = {
+    [K in keyof typeof RuntimeJournalTailInputSchema]: z.infer<(typeof RuntimeJournalTailInputSchema)[K]>;
+};
+declare function runtimeJournalTail(input: RuntimeJournalTailInput, ctx: HaiveContext): Promise<{
+    entries: Awaited<ReturnType<typeof readRuntimeJournalTail>>;
+    empty?: boolean;
+}>;
+
+declare const SERVER_NAME = "hivelore";
+declare const SERVER_VERSION: string;
+type ToolProfile = "enforcement" | "maintenance" | "experimental" | "full";
+declare const ENFORCEMENT_PROFILE_TOOLS: readonly ["get_briefing", "mem_save", "mem_tried", "mem_search", "mem_get", "mem_verify", "mem_relevant_to", "code_map", "code_search", "pre_commit_check", "mem_session_end", "propose_sensor"];
+declare const MAINTENANCE_PROFILE_TOOLS: readonly ["get_briefing", "mem_save", "mem_tried", "mem_search", "mem_get", "mem_verify", "mem_relevant_to", "code_map", "code_search", "pre_commit_check", "mem_session_end", "propose_sensor", "mem_suggest_topic", "mem_for_files", "mem_list", "get_project_context", "bootstrap_project_save", "mem_resolve_project", "mem_update", "mem_approve", "mem_reject", "mem_pending", "mem_delete", "mem_diff", "get_recap", "anti_patterns_check", "mem_distill", "mem_timeline", "mem_conflict_candidates", "mem_feedback", "ingest_findings"];
+declare const EXPERIMENTAL_PROFILE_TOOLS: readonly ["get_briefing", "mem_save", "mem_tried", "mem_search", "mem_get", "mem_verify", "mem_relevant_to", "code_map", "code_search", "pre_commit_check", "mem_session_end", "propose_sensor", "mem_suggest_topic", "mem_for_files", "mem_list", "get_project_context", "bootstrap_project_save", "mem_resolve_project", "mem_update", "mem_approve", "mem_reject", "mem_pending", "mem_delete", "mem_diff", "get_recap", "anti_patterns_check", "mem_distill", "mem_timeline", "mem_conflict_candidates", "mem_feedback", "ingest_findings", "mem_observe", "why_this_file", "why_this_decision", "mem_conflicts_with", "pattern_detect", "runtime_journal_append", "runtime_journal_tail"];
+declare const TOOL_PROFILES: Record<Exclude<ToolProfile, "full">, ReadonlySet<string>>;
+declare function getAllowedToolsForProfile(profile: ToolProfile): ReadonlySet<string>;
+declare function createHaiveServer(options?: CreateContextOptions): {
+    server: McpServer;
+    context: HaiveContext;
+    tracker: SessionTracker;
+};
+/** Parse argv for the standalone haive-mcp binary / CLI subprocess parity. */
+declare function parseMcpCliArgs(argv: string[]): {
+    root?: string;
+    versionOnly: boolean;
+};
+/** Print MCP server version (same as haive CLI when bundled together). */
+declare function printHaiveMcpVersion(): void;
+/**
+ * Run the MCP server over stdio. Used by `haive-mcp` and by `hivelore mcp --stdio`
+ * when the MCP implementation is bundled into the CLI.
+ */
+declare function runHaiveMcpStdio(options: {
+    root?: string;
+}): Promise<void>;
+
+export { type AntiPatternsCheckInput, type AntiPatternsCheckOutput, type BriefingOutput, type CodeMapInput, type CodeMapToolOutput, type CodeSearchInput, type CodeSearchOutput, ENFORCEMENT_PROFILE_TOOLS, EXPERIMENTAL_PROFILE_TOOLS, type GetBriefingInput, type GetRecapInput, type GetRecapOutput, MAINTENANCE_PROFILE_TOOLS, type MemConflictCandidatesInput, type MemConflictsInput, type MemConflictsOutput, type MemDistillInput, type MemDistillOutput, type MemRelevantToInput, type MemRelevantToOutput, type MemResolveProjectInput, type MemSuggestTopicInput, type MemTimelineInput, type PatternDetectInput, type PatternDetectOutput, type PreCommitCheckInput, type PreCommitCheckOutput, type RuntimeJournalAppendInput, type RuntimeJournalTailInput, SERVER_NAME, SERVER_VERSION, TOOL_PROFILES, type ToolProfile, type WhyThisDecisionInput, type WhyThisDecisionOutput, type WhyThisFileInput, type WhyThisFileOutput, antiPatternsCheck, codeMapTool, codeSearch, createHaiveServer, getAllowedToolsForProfile, getBriefing, getRecap, memConflictCandidates, memConflicts, memDistill, memRelevantTo, memResolveProject, memSuggestTopic, memTimeline, parseMcpCliArgs, patternDetect, preCommitCheck, printHaiveMcpVersion, readPresumedCorrectTargets, runHaiveMcpStdio, runtimeJournalAppend, runtimeJournalTail, whyThisDecision, whyThisFile };