@hiveai/mcp 0.9.14 → 0.9.16

package/README.md

@@ -2,7 +2,7 @@
 
 > **hAIve MCP server** — policy-aware briefing and memory tools for MCP-compatible AI coding agents.
 
-The MCP server is how agents load team policy before changing code. By default it exposes a small enforcement-oriented tool surface: briefing, relevant memories, failed-attempt capture, anchor verification, code-map lookup, and pre-commit checks. The larger maintenance surface is still available with `HAIVE_TOOL_PROFILE=full`.
+The MCP server is how agents load team policy before changing code. By default it exposes a small enforcement-oriented tool surface: briefing, relevant memories, failed-attempt capture, anchor verification, code-map lookup, and pre-commit checks. Larger maintenance and experimental surfaces are opt-in via `HAIVE_TOOL_PROFILE`.
 
 hAIve is not just a memory database. The MCP layer participates in enforcement: state-changing hAIve tools require `get_briefing` or `mem_relevant_to` first, so agents cannot silently skip team context while using hAIve.
 
@@ -117,17 +117,26 @@ Default tools:
 - `mem_tried`
 - `mem_search`
 - `mem_get`
-- `mem_update`
 - `mem_verify`
 - `code_map`
 - `pre_commit_check`
+- `mem_session_end`
 
 Default prompts:
 
 - `bootstrap_project`
 - `post_task`
 
-Set `HAIVE_TOOL_PROFILE=full` to expose advanced lifecycle, import, timeline, conflict, runtime-journal, and diagnostic tools.
+### Tool Profiles
+
+`HAIVE_TOOL_PROFILE` controls how much hAIve surface an agent sees:
+
+- `enforcement` (default): compact repo-native context harness for coding agents.
+- `maintenance`: adds corpus review, lifecycle, distillation, code-search, and project-context maintenance tools.
+- `experimental`: adds exploratory diagnostics such as runtime journal, pattern detection, why-this-file, why-this-decision, and conflict analysis.
+- `full`: legacy alias for `experimental`.
+
+Use `maintenance` for human/team stewardship sessions and `experimental` only when you are intentionally working on hAIve's broader research tooling.
 
 ### `get_briefing` ⭐ Start every task with this
 

package/dist/index.js

@@ -1394,6 +1394,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
+  pathsOverlap,
   queryCodeMap,
   resolveBriefingBudget,
   serializeMemory as serializeMemory9,
@@ -1702,10 +1703,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) {
@@ -1871,6 +1876,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 {
@@ -2676,7 +2719,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";
@@ -2712,7 +2755,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;
@@ -2747,7 +2790,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) => {
@@ -2837,10 +2880,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) => ({
@@ -2854,10 +2900,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,
@@ -2867,6 +2915,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;
@@ -3458,7 +3530,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.14";
+var SERVER_VERSION = "0.9.16";
 function jsonResult(data) {
   return {
     content: [
@@ -3469,15 +3541,58 @@ function jsonResult(data) {
     ]
   };
 }
-var ENFORCEMENT_PROFILE_TOOLS = /* @__PURE__ */ new Set([
+var ENFORCEMENT_PROFILE_TOOLS = [
   "get_briefing",
   "mem_save",
+  "mem_tried",
   "mem_search",
+  "mem_get",
   "mem_verify",
   "mem_relevant_to",
+  "code_map",
   "pre_commit_check",
   "mem_session_end"
-]);
+];
+var MAINTENANCE_PROFILE_TOOLS = [
+  ...ENFORCEMENT_PROFILE_TOOLS,
+  "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",
+  "code_search",
+  "anti_patterns_check",
+  "mem_distill",
+  "mem_timeline",
+  "mem_conflict_candidates"
+];
+var EXPERIMENTAL_PROFILE_TOOLS = [
+  ...MAINTENANCE_PROFILE_TOOLS,
+  "mem_observe",
+  "why_this_file",
+  "why_this_decision",
+  "mem_conflicts_with",
+  "pattern_detect",
+  "runtime_journal_append",
+  "runtime_journal_tail"
+];
+var TOOL_PROFILES = {
+  enforcement: new Set(ENFORCEMENT_PROFILE_TOOLS),
+  maintenance: new Set(MAINTENANCE_PROFILE_TOOLS),
+  experimental: new Set(EXPERIMENTAL_PROFILE_TOOLS)
+};
+function getAllowedToolsForProfile(profile) {
+  if (profile === "full") return TOOL_PROFILES.experimental;
+  return TOOL_PROFILES[profile] ?? TOOL_PROFILES.enforcement;
+}
 var BRIEFING_TOOLS = /* @__PURE__ */ new Set(["get_briefing", "mem_relevant_to"]);
 var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_save",
@@ -3504,7 +3619,8 @@ function createHaiveServer(options = {}) {
     { name: SERVER_NAME, version: SERVER_VERSION },
     { capabilities: { tools: {}, prompts: {} } }
   );
-  const shouldRegisterTool = (name) => toolProfile === "full" || ENFORCEMENT_PROFILE_TOOLS.has(name);
+  const allowedTools = getAllowedToolsForProfile(toolProfile);
+  const shouldRegisterTool = (name) => allowedTools.has(name);
   const registerTool = (name, description, schema, handler) => {
     if (!shouldRegisterTool(name)) return;
     const tool = server.tool.bind(server);
@@ -3528,7 +3644,11 @@ function createHaiveServer(options = {}) {
       }
     );
   };
-  const shouldRegisterPrompt = (name) => toolProfile === "full" || name === "bootstrap_project" || name === "post_task";
+  const shouldRegisterPrompt = (name) => {
+    if (name === "bootstrap_project" || name === "post_task") return true;
+    if (name === "import_docs") return toolProfile !== "enforcement";
+    return toolProfile === "experimental" || toolProfile === "full";
+  };
   registerTool(
     "mem_save",
     [