@hiveai/mcp 0.9.13 → 0.9.15

package/dist/server.d.ts

@@ -83,6 +83,8 @@ interface BriefingMemory {
     reasons: Array<"anchor" | "module" | "domain" | "semantic">;
     match_quality: "exact" | "partial" | "semantic";
     semantic_score?: number;
+    /** Human/agent-readable explanation for why this record was surfaced. */
+    why?: string[];
     body: string;
     file_path: string;
 }
@@ -517,10 +519,12 @@ interface PreCommitCheckOutput {
     summary: {
         anti_patterns: number;
         blocking_warnings?: number;
+        review_warnings?: number;
+        info_warnings?: number;
         relevant_memories: number;
         stale_anchors: number;
     };
-    warnings: AntiPatternsWarning[];
+    warnings: ClassifiedAntiPatternsWarning[];
     /** Memories anchored to the touched files — convention reminders for the change author. */
     relevant_memories: Array<{
         id: string;
@@ -536,6 +540,16 @@ interface PreCommitCheckOutput {
     }>;
     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;
+}
 /**
  * One-shot "should I block this commit?" check.
  *

package/dist/server.js

@@ -1392,6 +1392,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
+  pathsOverlap,
   queryCodeMap,
   resolveBriefingBudget,
   serializeMemory as serializeMemory9,
@@ -1700,10 +1701,14 @@ ${m.content}`).join("\n\n---\n\n"),
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
   }
-  const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({
+  const formattedMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({
     ...m,
     body: extractActionsBriefBody(m.body)
   })) : trimmedMemories;
+  const outputMemories = formattedMemories.map((m) => ({
+    ...m,
+    why: explainWhySurfaced(m, byId.get(m.id), input.files, inferred)
+  }));
   let symbolLocations;
   const symbolsToLookup = new Set(input.symbols);
   for (const m of outputMemories) {
@@ -1869,6 +1874,44 @@ function compactSummary(body) {
   }
   return body.slice(0, 120);
 }
+function explainWhySurfaced(memory, loaded, inputFiles, inferredModules) {
+  const why = [];
+  const fm = loaded?.memory.frontmatter;
+  if (memory.reasons.includes("anchor") && fm) {
+    const matching = fm.anchor.paths.filter(
+      (p) => inputFiles.length === 0 || inputFiles.some((file) => pathsOverlap(p, file))
+    );
+    if (matching.length > 0) {
+      why.push(`Anchored to touched path${matching.length === 1 ? "" : "s"}: ${matching.slice(0, 4).join(", ")}`);
+    } else if (fm.anchor.paths.length > 0) {
+      why.push(`Pulled by related anchor: ${fm.anchor.paths.slice(0, 4).join(", ")}`);
+    }
+    if (fm.anchor.symbols.length > 0) {
+      why.push(`Anchor symbol${fm.anchor.symbols.length === 1 ? "" : "s"}: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
+    }
+  }
+  if (memory.reasons.includes("module")) {
+    const moduleHints = [
+      ...memory.module ? [memory.module] : [],
+      ...memory.tags.filter((tag) => inferredModules.includes(tag))
+    ];
+    const shown = moduleHints.length > 0 ? [...new Set(moduleHints)].join(", ") : inferredModules.join(", ");
+    why.push(shown ? `Matched inferred module/tag: ${shown}` : "Matched inferred module context.");
+  }
+  if (memory.reasons.includes("domain")) {
+    why.push("Matched inferred domain from the target file paths.");
+  }
+  if (memory.reasons.includes("semantic")) {
+    const score = memory.semantic_score !== void 0 ? ` score=${Math.round(memory.semantic_score * 100) / 100}` : "";
+    why.push(`${memory.match_quality === "exact" ? "Literal task match" : "Semantic/task relevance"}${score}.`);
+  }
+  why.push(`Confidence: ${memory.confidence}; read ${memory.read_count} time${memory.read_count === 1 ? "" : "s"}.`);
+  if (memory.type === "attempt") why.push("Failed-approach record; read before repeating the same path.");
+  if (memory.status === "proposed" || memory.status === "draft") {
+    why.push("Unvalidated record; use cautiously or ask a human before treating it as policy.");
+  }
+  return why;
+}
 async function trySemanticHits(ctx, task, limit) {
   let mod;
   try {
@@ -2674,7 +2717,7 @@ import {
   getUsage as getUsage9,
   loadMemoriesFromDir as loadMemoriesFromDir20,
   loadUsageIndex as loadUsageIndex11,
-  pathsOverlap,
+  pathsOverlap as pathsOverlap2,
   tokenizeQuery as tokenizeQuery5
 } from "@hiveai/core";
 import { z as z27 } from "zod";
@@ -2710,7 +2753,7 @@ async function memConflicts(input, ctx) {
     const otherText = (other.memory.body + " " + fm.tags.join(" ")).toLowerCase();
     const reasons = [];
     const sim = simScores?.get(fm.id) ?? null;
-    const hasPathOverlap = fm.anchor.paths.some((p) => targetPaths.some((tp) => pathsOverlap(p, tp)));
+    const hasPathOverlap = fm.anchor.paths.some((p) => targetPaths.some((tp) => pathsOverlap2(p, tp)));
     const otherTokens = new Set(tokenizeQuery5(otherText));
     const tokenOverlap = countIntersection(targetTokens, otherTokens);
     const isSemanticNeighbor = sim !== null && sim >= input.min_score;
@@ -2745,7 +2788,7 @@ async function memConflicts(input, ctx) {
       body_preview: other.memory.body.split("\n").slice(0, 4).join("\n").slice(0, 300),
       similarity: sim,
       reasons,
-      shared_paths: fm.anchor.paths.filter((p) => targetPaths.some((tp) => pathsOverlap(p, tp)))
+      shared_paths: fm.anchor.paths.filter((p) => targetPaths.some((tp) => pathsOverlap2(p, tp)))
     });
   }
   conflicts.sort((a, b) => {
@@ -2835,10 +2878,13 @@ async function preCommitCheck(input, ctx) {
   const filesTouching = new Set(relevantMatches.map((m) => m.id));
   const staleHits = verifyResult.results.filter((r) => r.stale && filesTouching.has(r.id));
   const blockOn = input.block_on;
-  const blockingWarnings = apResult.warnings.filter(isBlockingWarning);
+  const classifiedWarnings = apResult.warnings.map(classifyWarning);
+  const blockingWarnings = classifiedWarnings.filter((w) => w.level === "blocking");
+  const reviewWarnings = classifiedWarnings.filter((w) => w.level === "review");
+  const infoWarnings = classifiedWarnings.filter((w) => w.level === "info");
   let should_block = false;
   if (blockOn !== "never") {
-    if (blockOn === "any" && (apResult.warnings.length > 0 || staleHits.length > 0)) should_block = true;
+    if (blockOn === "any" && (blockingWarnings.length > 0 || reviewWarnings.length > 0 || staleHits.length > 0)) should_block = true;
     if (blockOn === "high-confidence" && (blockingWarnings.length > 0 || staleHits.length > 0)) should_block = true;
   }
   const relevant_memories = relevantMatches.slice(0, 8).map((m) => ({
@@ -2852,10 +2898,12 @@ async function preCommitCheck(input, ctx) {
     summary: {
       anti_patterns: apResult.warnings.length,
       blocking_warnings: blockingWarnings.length,
+      review_warnings: reviewWarnings.length,
+      info_warnings: infoWarnings.length,
       relevant_memories: relevant_memories.length,
       stale_anchors: staleHits.length
     },
-    warnings: apResult.warnings,
+    warnings: classifiedWarnings,
     relevant_memories,
     stale_anchors: staleHits.map((r) => ({
       id: r.id,
@@ -2865,6 +2913,30 @@ async function preCommitCheck(input, ctx) {
     }))
   };
 }
+function classifyWarning(warning) {
+  if (isBlockingWarning(warning)) {
+    return {
+      ...warning,
+      level: "blocking",
+      rationale: "authoritative/trusted memory plus strong semantic match to the diff (score >= 0.65)"
+    };
+  }
+  const hasSemantic = warning.reasons.includes("semantic");
+  const semanticScore = warning.semantic_score ?? 0;
+  const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
+  if (hasSemantic && semanticScore >= 0.45 || highConfidence && warning.reasons.includes("anchor") && warning.reasons.includes("literal")) {
+    return {
+      ...warning,
+      level: "review",
+      rationale: hasSemantic ? "semantic match is plausible but below blocking threshold" : "anchored high-confidence memory also matched diff tokens, but no strong semantic proof"
+    };
+  }
+  return {
+    ...warning,
+    level: "info",
+    rationale: "weak signal only (literal/anchor/low semantic evidence); surfaced for audit, hidden in concise CLI output"
+  };
+}
 function isBlockingWarning(warning) {
   const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
   if (!highConfidence) return false;
@@ -3456,7 +3528,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { loadConfigSync } from "@hiveai/core";
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.13";
+var SERVER_VERSION = "0.9.15";
 function jsonResult(data) {
   return {
     content: [
@@ -3470,9 +3542,12 @@ function jsonResult(data) {
 var ENFORCEMENT_PROFILE_TOOLS = /* @__PURE__ */ new Set([
   "get_briefing",
   "mem_save",
+  "mem_tried",
   "mem_search",
+  "mem_get",
   "mem_verify",
   "mem_relevant_to",
+  "code_map",
   "pre_commit_check",
   "mem_session_end"
 ]);