@hivelore/mcp 0.30.1 → 0.33.0

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 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 { HaivePaths, ConfidenceLevel, ImpactTier, SensorTarget, resolveProjectInfo } from '@hivelore/core';
 import { z } from 'zod';
 
 interface HaiveContext {
@@ -353,49 +353,6 @@ interface CodeSearchOutput {
 }
 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[];
@@ -485,106 +442,6 @@ interface MemDistillOutput {
  */
 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">>;
@@ -648,6 +505,36 @@ interface ClassifiedAntiPatternsWarning extends AntiPatternsWarning {
  */
 declare function preCommitCheck(input: PreCommitCheckInput, ctx: HaiveContext): Promise<PreCommitCheckOutput>;
 
+declare const ProposeSensorInputSchema: {
+    memory_id: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<["regex", "shell", "test"]>>;
+    pattern: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    absent: z.ZodOptional<z.ZodString>;
+    bad_example: z.ZodOptional<z.ZodString>;
+    severity: z.ZodDefault<z.ZodEnum<["warn", "block"]>>;
+    message: z.ZodOptional<z.ZodString>;
+    flags: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+};
+type ProposeSensorInput = {
+    [K in keyof typeof ProposeSensorInputSchema]: z.infer<(typeof ProposeSensorInputSchema)[K]>;
+};
+interface ProposeSensorOutput {
+    accepted: boolean;
+    memory_id: string;
+    severity: "warn" | "block";
+    /** Set when rejected — why, and how to revise. */
+    reason?: string;
+    guidance?: string;
+    self_check: {
+        silent_on_current: boolean;
+        fires_on_bad: boolean | null;
+        fired_on: string[];
+    };
+    file_path?: string;
+}
 /**
  * Read the PRESUMED-CORRECT contents of anchored files for sensor self-checks.
  *
@@ -658,34 +545,75 @@ declare function preCommitCheck(input: PreCommitCheckInput, ctx: HaiveContext):
  * 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 function proposeSensor(input: ProposeSensorInput, ctx: HaiveContext): Promise<ProposeSensorOutput>;
 
-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 const MemTriedInputSchema: {
+    what: z.ZodString;
+    why_failed: z.ZodString;
+    instead: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "module"]>>;
+    module: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    author: z.ZodOptional<z.ZodString>;
+    sensor: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<["regex", "shell", "test"]>>;
+        pattern: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        absent: z.ZodOptional<z.ZodString>;
+        severity: z.ZodDefault<z.ZodEnum<["warn", "block"]>>;
+        message: z.ZodOptional<z.ZodString>;
+        bad_example: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "regex" | "shell" | "test";
+        severity: "warn" | "block";
+        pattern?: string | undefined;
+        message?: string | undefined;
+        command?: string | undefined;
+        timeout_ms?: number | undefined;
+        absent?: string | undefined;
+        bad_example?: string | undefined;
+    }, {
+        pattern?: string | undefined;
+        message?: string | undefined;
+        kind?: "regex" | "shell" | "test" | undefined;
+        command?: string | undefined;
+        timeout_ms?: number | undefined;
+        absent?: string | undefined;
+        severity?: "warn" | "block" | undefined;
+        bad_example?: string | undefined;
+    }>>;
+};
+type MemTriedInput = {
+    [K in keyof typeof MemTriedInputSchema]: z.infer<(typeof MemTriedInputSchema)[K]>;
+};
+interface MemTriedOutput {
+    id: string;
+    scope: string;
+    file_path: string;
+    /**
+     * A captured attempt closes its prevention loop (gate can block the repeat) only once a sensor is
+     * VALIDATED via propose_sensor. True until then — the lesson is briefed but not enforced.
+     */
+    loop_open: boolean;
+    /** Heuristic candidate to PRE-FILL a propose_sensor call (refine, then call it). Never a persisted sensor. */
+    proposed_sensor_seed?: {
+        pattern: string;
+        absent?: string;
+        message: string;
+    };
+    /** Next-step guidance: how to close the loop via propose_sensor. */
+    hint?: string;
+    /** When input.sensor was given: the inline propose_sensor verdict (accepted ⇒ loop closed). */
+    sensor_result?: {
+        accepted: boolean;
+        severity: "warn" | "block";
+        reason?: string;
+        guidance?: string;
+    };
 }
-declare function patternDetect(input: PatternDetectInput, ctx: HaiveContext): Promise<PatternDetectOutput>;
+declare function memTried(input: MemTriedInput, ctx: HaiveContext): Promise<MemTriedOutput>;
 
 /** Input is intentionally minimal — callers may pass cwd for multi-root clients. */
 declare const MemResolveProjectInputSchema: {
@@ -764,36 +692,12 @@ declare function memConflictCandidates(input: MemConflictCandidatesInput, ctx: H
     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 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"];
 declare const TOOL_PROFILES: Record<Exclude<ToolProfile, "full">, ReadonlySet<string>>;
 declare function getAllowedToolsForProfile(profile: ToolProfile): ReadonlySet<string>;
 declare function createHaiveServer(options?: CreateContextOptions): {
@@ -816,4 +720,4 @@ 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 };
+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 MemDistillInput, type MemDistillOutput, type MemRelevantToInput, type MemRelevantToOutput, type MemResolveProjectInput, type MemSuggestTopicInput, type MemTimelineInput, type MemTriedOutput, type PreCommitCheckInput, type PreCommitCheckOutput, type ProposeSensorOutput, SERVER_NAME, SERVER_VERSION, TOOL_PROFILES, type ToolProfile, antiPatternsCheck, codeMapTool, codeSearch, createHaiveServer, getAllowedToolsForProfile, getBriefing, getRecap, memConflictCandidates, memDistill, memRelevantTo, memResolveProject, memSuggestTopic, memTimeline, memTried, parseMcpCliArgs, preCommitCheck, printHaiveMcpVersion, proposeSensor, readPresumedCorrectTargets, runHaiveMcpStdio };