@hiveai/mcp 0.15.0 → 0.18.0

package/dist/index.js

@@ -670,15 +670,19 @@ async function memReject(input, ctx) {
 
 // src/tools/mem-feedback.ts
 import {
+  applyFeedbackAdjustment,
   computeImpact,
   getUsage as getUsage2,
   loadMemoriesFromDir as loadMemoriesFromDir6,
   loadUsageIndex as loadUsageIndex3,
   recordApplied,
   recordRejection as recordRejection2,
-  saveUsageIndex as saveUsageIndex2
+  recommendFeedbackAdjustment,
+  saveUsageIndex as saveUsageIndex2,
+  serializeMemory as serializeMemory4
 } from "@hiveai/core";
 import { existsSync as existsSync8 } from "fs";
+import { writeFile as writeFile5 } from "fs/promises";
 import { z as z8 } from "zod";
 var MemFeedbackInputSchema = {
   id: z8.string().min(1).describe("Full memory id the feedback is about"),
@@ -704,6 +708,12 @@ async function memFeedback(input, ctx) {
   }
   await saveUsageIndex2(ctx.paths, index);
   const usage = getUsage2(index, input.id);
+  const adjustment = input.outcome === "rejected" ? recommendFeedbackAdjustment(target.memory.frontmatter, usage) : { action: "none", reason: "No automatic adjustment needed." };
+  const adjustedFrontmatter = applyFeedbackAdjustment(target.memory.frontmatter, adjustment);
+  if (adjustedFrontmatter !== target.memory.frontmatter) {
+    target.memory.frontmatter = adjustedFrontmatter;
+    await writeFile5(target.filePath, serializeMemory4(target.memory), "utf8");
+  }
   const impact = computeImpact(target.memory.frontmatter, usage);
   return {
     ok: true,
@@ -714,7 +724,8 @@ async function memFeedback(input, ctx) {
       applied_count: usage.applied_count,
       rejected_count: usage.rejected_count
     },
-    impact: { score: impact.score, tier: impact.tier, signals: impact.signals }
+    impact: { score: impact.score, tier: impact.tier, signals: impact.signals },
+    feedback_adjustment: adjustment
   };
 }
 
@@ -954,9 +965,9 @@ async function memDelete(input, ctx) {
 }
 
 // src/tools/mem-update.ts
-import { writeFile as writeFile5 } from "fs/promises";
+import { writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir10, serializeMemory as serializeMemory4 } from "@hiveai/core";
+import { loadMemoriesFromDir as loadMemoriesFromDir10, serializeMemory as serializeMemory5 } from "@hiveai/core";
 import { z as z12 } from "zod";
 var MemUpdateInputSchema = {
   id: z12.string().min(1).describe("Id of the memory to update"),
@@ -1005,9 +1016,9 @@ async function memUpdate(input, ctx) {
   if (updated_fields.length === 0) {
     throw new Error("No fields to update \u2014 provide at least one of: body, tags, paths, symbols, commit, domain, author.");
   }
-  await writeFile5(
+  await writeFile6(
     loaded.filePath,
-    serializeMemory4({ frontmatter: newFrontmatter, body: newBody }),
+    serializeMemory5({ frontmatter: newFrontmatter, body: newBody }),
     "utf8"
   );
   return { id: input.id, file_path: loaded.filePath, updated_fields };
@@ -1057,11 +1068,11 @@ async function memPending(input, ctx) {
 }
 
 // src/tools/mem-approve.ts
-import { writeFile as writeFile6 } from "fs/promises";
+import { writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import {
   loadMemoriesFromDir as loadMemoriesFromDir12,
-  serializeMemory as serializeMemory5
+  serializeMemory as serializeMemory6
 } from "@hiveai/core";
 import { z as z14 } from "zod";
 var MemApproveInputSchema = {
@@ -1079,7 +1090,7 @@ async function memApprove(input, ctx) {
     frontmatter: { ...found.memory.frontmatter, status: "validated" },
     body: found.memory.body
   };
-  await writeFile6(found.filePath, serializeMemory5(next), "utf8");
+  await writeFile7(found.filePath, serializeMemory6(next), "utf8");
   return {
     id: input.id,
     previous_status: previous,
@@ -1089,13 +1100,13 @@ async function memApprove(input, ctx) {
 }
 
 // src/tools/mem-tried.ts
-import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
 import path5 from "path";
 import {
   buildFrontmatter as buildFrontmatter2,
   memoryFilePath as memoryFilePath2,
-  serializeMemory as serializeMemory6,
+  serializeMemory as serializeMemory7,
   suggestSensorFromMemory as suggestSensorFromMemory2
 } from "@hiveai/core";
 import { z as z15 } from "zod";
@@ -1139,13 +1150,13 @@ async function memTried(input, ctx) {
   if (existsSync15(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile7(file, serializeMemory6({ frontmatter, body }), "utf8");
+  await writeFile8(file, serializeMemory7({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 
 // src/tools/ingest-findings.ts
 import { existsSync as existsSync16 } from "fs";
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile9 } from "fs/promises";
 import path6 from "path";
 import {
   draftsFromFindings,
@@ -1153,7 +1164,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir13,
   memoryFilePath as memoryFilePath3,
   parseFindings,
-  serializeMemory as serializeMemory7
+  serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z16 } from "zod";
 var IngestFindingsInputSchema = {
@@ -1230,19 +1241,19 @@ async function writeDraft(ctx, draft) {
     draft.frontmatter.module
   );
   await mkdir4(path6.dirname(file), { recursive: true });
-  await writeFile8(file, serializeMemory7({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  await writeFile9(file, serializeMemory8({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
 
 // src/tools/mem-observe.ts
-import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile10 } from "fs/promises";
 import { existsSync as existsSync17 } from "fs";
 import path7 from "path";
 import {
   buildFrontmatter as buildFrontmatter3,
   isLikelyGuessable,
   memoryFilePath as memoryFilePath4,
-  serializeMemory as serializeMemory8
+  serializeMemory as serializeMemory9
 } from "@hiveai/core";
 import { z as z17 } from "zod";
 var MemObserveInputSchema = {
@@ -1296,19 +1307,19 @@ async function memObserve(input, ctx) {
   if (existsSync17(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile9(file, serializeMemory8({ frontmatter, body }), "utf8");
+  await writeFile10(file, serializeMemory9({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 
 // src/tools/mem-session-end.ts
-import { writeFile as writeFile11, mkdir as mkdir7 } from "fs/promises";
+import { writeFile as writeFile12, mkdir as mkdir7 } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
 import path9 from "path";
 import {
   buildFrontmatter as buildFrontmatter4,
   loadMemoriesFromDir as loadMemoriesFromDir14,
   memoryFilePath as memoryFilePath5,
-  serializeMemory as serializeMemory9
+  serializeMemory as serializeMemory10
 } from "@hiveai/core";
 import { z as z18 } from "zod";
 
@@ -1318,7 +1329,7 @@ import {
   appendRuntimeJournalEntry,
   loadConfig as loadConfig2
 } from "@hiveai/core";
-import { mkdir as mkdir6, writeFile as writeFile10, rm } from "fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile11, rm } from "fs/promises";
 import { existsSync as existsSync18 } from "fs";
 import path8 from "path";
 import { execSync } from "child_process";
@@ -1417,7 +1428,7 @@ var SessionTracker = class {
           };
           const cacheDir = path8.join(this.ctx.paths.haiveDir, ".cache");
           await mkdir6(cacheDir, { recursive: true });
-          await writeFile10(
+          await writeFile11(
             pendingDistillPath(this.ctx),
             JSON.stringify(payload, null, 2) + "\n",
             "utf8"
@@ -1523,9 +1534,9 @@ async function memSessionEnd(input, ctx) {
         paths: normalizedFiles.length ? normalizedFiles : fm.anchor.paths
       }
     };
-    await writeFile11(
+    await writeFile12(
       topicMatch.filePath,
-      serializeMemory9({ frontmatter: newFrontmatter, body }),
+      serializeMemory10({ frontmatter: newFrontmatter, body }),
       "utf8"
     );
     await clearPendingDistill(ctx);
@@ -1554,7 +1565,7 @@ async function memSessionEnd(input, ctx) {
     frontmatter.module
   );
   await mkdir7(path9.dirname(file), { recursive: true });
-  await writeFile11(file, serializeMemory9({ frontmatter, body }), "utf8");
+  await writeFile12(file, serializeMemory10({ frontmatter, body }), "utf8");
   await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
@@ -1566,15 +1577,17 @@ async function memSessionEnd(input, ctx) {
 }
 
 // src/tools/get-briefing.ts
-import { readFile as readFile5, writeFile as writeFile12 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile13 } from "fs/promises";
 import { existsSync as existsSync21 } from "fs";
 import {
   allocateBudget,
+  briefingProofLine,
   computeImpact as computeImpact2,
   DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
   evaluateSkillActivation,
+  compactAutoRecapBody,
   extractActionsBriefBody,
   getUsage as getUsage6,
   inferModulesFromPaths as inferModulesFromPaths2,
@@ -1587,6 +1600,7 @@ import {
   loadConfig as loadConfig3,
   hashProjectContext,
   loadMemoriesFromDir as loadMemoriesFromDir15,
+  loadPreventionEvents,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   projectContextRecentlyEmitted,
@@ -1594,7 +1608,7 @@ import {
   recordProjectContextEmission,
   queryCodeMap,
   resolveBriefingBudget,
-  serializeMemory as serializeMemory10,
+  serializeMemory as serializeMemory11,
   specificityScore,
   GUESSABLE_THRESHOLD,
   tokenizeQuery as tokenizeQuery2,
@@ -1608,7 +1622,12 @@ import { z as z19 } from "zod";
 import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync20 } from "fs";
 import path10 from "path";
-import { isGlobPath, isStackPackSeed, pathsOverlap } from "@hiveai/core";
+import {
+  classifyMemoryPriority as coreClassifyPriority,
+  isGlobPath,
+  pathsOverlap,
+  priorityRank as corePriorityRank
+} from "@hiveai/core";
 function compactSummary(body) {
   for (const line of body.split("\n")) {
     const trimmed = line.replace(/^#+\s*/, "").trim();
@@ -1626,21 +1645,23 @@ function classifyMemoryPriority(memory, loaded, inputFiles, inputSymbols) {
       (sym) => inputSymbols.some((wanted) => wanted.toLowerCase() === sym.toLowerCase())
     )
   );
-  const strongSemantic = (memory.semantic_score ?? 0) >= 0.65;
-  const usefulSemantic = (memory.semantic_score ?? 0) >= 0.35;
-  if (fm?.requires_human_approval || directAnchor || directSymbol || memory.type === "attempt" && (memory.match_quality === "exact" || strongSemantic) || memory.type === "skill" && (memory.match_quality === "exact" || strongSemantic)) {
-    return "must_read";
-  }
-  if (isStackPackSeed(fm)) {
-    return "background";
-  }
-  if (memory.type === "skill" || memory.reasons.includes("module") || memory.reasons.includes("domain") || memory.match_quality === "exact" || usefulSemantic) {
-    return "useful";
-  }
-  return "background";
+  const semantic = memory.semantic_score ?? 0;
+  return coreClassifyPriority({
+    type: memory.type,
+    tags: fm?.tags ?? memory.tags ?? [],
+    requiresHumanApproval: Boolean(fm?.requires_human_approval),
+    directAnchor,
+    directSymbol,
+    exactTaskMatch: memory.match_quality === "exact",
+    strongSemantic: semantic >= 0.65,
+    usefulSemantic: semantic >= 0.35,
+    moduleOrDomainMatch: memory.reasons.includes("module") || memory.reasons.includes("domain"),
+    tagTaskMatch: false
+    // MCP ranking doesn't use a separate tag-token signal
+  });
 }
 function priorityRank(priority) {
-  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
+  return corePriorityRank(priority);
 }
 function classifyBriefingQuality(memories, context) {
   const mustRead = memories.filter((m) => m.priority === "must_read").length;
@@ -1809,7 +1830,9 @@ async function getBriefing(input, ctx) {
         id: fm.id,
         scope: fm.scope,
         revision_count: fm.revision_count ?? 0,
-        body: r.memory.body
+        // Auto-generated recaps are low-signal tool dumps — compact them so they inform without
+        // dominating the briefing head. Human/post_task recaps pass through unchanged.
+        body: compactAutoRecapBody(r.memory.body)
       };
     }
     const allMemories = allLoaded.filter(({ memory }) => {
@@ -1961,7 +1984,7 @@ async function getBriefing(input, ctx) {
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated" };
         try {
-          await writeFile12(loaded.filePath, serializeMemory10({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
+          await writeFile13(loaded.filePath, serializeMemory11({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -2232,6 +2255,10 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       "No team-specific policy matched these files/task \u2014 nothing here a capable model can't infer. The auto-generated project context was trimmed to keep this briefing near-zero-cost; proceed with normal Read/Grep."
     );
   }
+  if (outputMemories.length > 0 && existsSync21(ctx.paths.haiveDir)) {
+    const proof = briefingProofLine(await loadPreventionEvents(ctx.paths));
+    if (proof) hints.push(proof);
+  }
   if (existsSync21(ctx.paths.haiveDir)) {
     await writeBriefingMarker(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
@@ -2641,6 +2668,7 @@ import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
   appendPreventionEvent,
+  BRIDGE_TARGET_PATH,
   buildDocFrequency,
   CODE_STOPWORDS,
   deriveConfidence as deriveConfidence6,
@@ -2682,6 +2710,44 @@ function tokenizeDiffForLiteral(diff) {
   const wordTokens = source.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 4 && !CODE_STOPWORDS.has(t));
   return [.../* @__PURE__ */ new Set([...wsTokens, ...wordTokens])];
 }
+var HAIVE_GENERATED_FILES = /* @__PURE__ */ new Set([
+  ...Object.values(BRIDGE_TARGET_PATH),
+  // .clinerules, .windsurfrules, .continuerules, .rules, AGENTS.md, .github/copilot-instructions.md, .sourcegraph/cody-rules.md
+  "CLAUDE.md",
+  ".cursorrules",
+  ".gitignore",
+  ".mcp.json",
+  ".cursor/mcp.json",
+  ".vscode/mcp.json"
+]);
+function isHaiveOwnedPath(p) {
+  if (p.startsWith(".ai/")) return true;
+  if (HAIVE_GENERATED_FILES.has(p)) return true;
+  if (p.startsWith(".cursor/rules/")) return true;
+  if (/^\.github\/workflows\/haive-.*\.ya?ml$/.test(p)) return true;
+  return false;
+}
+function stripAiDirHunks(diff) {
+  if (!diff.includes("diff --git")) return diff;
+  const out = [];
+  let block = [];
+  let keep = true;
+  const flush = () => {
+    if (keep) out.push(...block);
+    block = [];
+    keep = true;
+  };
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const target = line.match(/ b\/(.+)$/)?.[1] ?? "";
+      keep = !isHaiveOwnedPath(target);
+    }
+    block.push(line);
+  }
+  flush();
+  return out.join("\n");
+}
 async function antiPatternsCheck(input, ctx) {
   if (!input.diff && input.paths.length === 0) {
     return {
@@ -2737,10 +2803,11 @@ async function antiPatternsCheck(input, ctx) {
       }
     }
   }
-  if (input.diff) {
-    const tokens = tokenizeDiffForLiteral(input.diff);
-    const added = addedLinesFromDiff(input.diff);
-    const addedText = added.trim().length > 0 ? added : input.diff;
+  const scanDiff = input.diff ? stripAiDirHunks(input.diff) : input.diff;
+  if (scanDiff) {
+    const tokens = tokenizeDiffForLiteral(scanDiff);
+    const added = addedLinesFromDiff(scanDiff);
+    const addedText = added.trim().length > 0 ? added : scanDiff;
     if (tokens.length > 0) {
       for (const { memory } of negative) {
         if (literalMatchesAnyToken3(memory, tokens)) {
@@ -2753,11 +2820,13 @@ async function antiPatternsCheck(input, ctx) {
       }
     }
   }
-  if (input.diff) {
-    const added = addedLinesFromDiff(input.diff);
-    const diffTargets = sensorTargetsFromDiff(input.diff);
+  if (scanDiff) {
+    const added = addedLinesFromDiff(scanDiff);
+    const diffTargets = sensorTargetsFromDiff(scanDiff);
     const hasFileTargets = diffTargets.some((target) => target.path.length > 0);
-    const targets = diffTargets.length > 0 && hasFileTargets ? diffTargets : input.paths.length > 0 ? input.paths.map((p) => ({ path: p, content: added.trim().length > 0 ? added : input.diff })) : [{ path: "", content: added.trim().length > 0 ? added : input.diff }];
+    const codePaths = input.paths.filter((p) => !isHaiveOwnedPath(p));
+    const fallbackContent = added.trim().length > 0 ? added : scanDiff;
+    const targets = diffTargets.length > 0 && hasFileTargets ? diffTargets : codePaths.length > 0 ? codePaths.map((p) => ({ path: p, content: fallbackContent })) : [{ path: "", content: fallbackContent }];
     const hits = runSensors(negative.map(({ memory }) => memory), targets);
     for (const hit of hits) {
       const found = negative.find(({ memory }) => memory.frontmatter.id === hit.memory_id);
@@ -2770,10 +2839,10 @@ async function antiPatternsCheck(input, ctx) {
       }
     }
   }
-  if (input.semantic && input.diff) {
+  if (input.semantic && scanDiff) {
     try {
       const mod = await import("@hiveai/embeddings");
-      const result = await mod.semanticSearch(ctx.paths, input.diff, { limit: input.limit * 2 });
+      const result = await mod.semanticSearch(ctx.paths, scanDiff, { limit: input.limit * 2 });
       if (result) {
         const negativeIds = new Set(negative.map(({ memory }) => memory.frontmatter.id));
         for (const hit of result.hits) {
@@ -2795,7 +2864,7 @@ async function antiPatternsCheck(input, ctx) {
     return score(b) - score(a);
   }).slice(0, input.limit);
   const strongCatches = warnings.filter(
-    (w) => w.reasons.includes("sensor") || w.distinctive_literal === true || w.reasons.includes("anchor") && w.reasons.includes("literal")
+    (w) => w.reasons.includes("sensor") || w.reasons.includes("anchor") && w.reasons.includes("literal")
   );
   if (strongCatches.length > 0) {
     const recordedIds = [];
@@ -3420,7 +3489,9 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
       repair_command: repairCommand
     };
   }
-  if (hasSemantic && semanticScore >= 0.45 || highConfidence && warning.reasons.includes("anchor") && warning.reasons.includes("literal")) {
+  const corroborated = warning.reasons.includes("anchor") || warning.distinctive_literal === true;
+  const semanticReviewFloor = corroborated ? 0.45 : 0.6;
+  if (hasSemantic && semanticScore >= semanticReviewFloor || highConfidence && warning.reasons.includes("anchor") && warning.reasons.includes("literal")) {
     return {
       ...warning,
       level: "review",
@@ -3553,7 +3624,7 @@ function repairTargetPathForWarning(warning, paths) {
 }
 
 // src/tools/pattern-detect.ts
-import { mkdir as mkdir8, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile14 } from "fs/promises";
 import { existsSync as existsSync29 } from "fs";
 import path12 from "path";
 import { execSync as execSync2 } from "child_process";
@@ -3561,7 +3632,7 @@ import {
   buildFrontmatter as buildFrontmatter5,
   memoryFilePath as memoryFilePath6,
   readUsageEvents,
-  serializeMemory as serializeMemory11
+  serializeMemory as serializeMemory12
 } from "@hiveai/core";
 import { z as z31 } from "zod";
 var CONFIG_PATTERNS = [
@@ -3722,9 +3793,9 @@ async function patternDetect(input, ctx) {
       );
       if (existsSync29(file)) continue;
       await mkdir8(path12.dirname(file), { recursive: true });
-      await writeFile13(
+      await writeFile14(
         file,
-        serializeMemory11({ frontmatter: fm, body: match.proposed_body }),
+        serializeMemory12({ frontmatter: fm, body: match.proposed_body }),
         "utf8"
       );
       savedIds.push(fm.id);
@@ -4150,7 +4221,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { hasRecentBriefingMarker, loadConfigSync } from "@hiveai/core";
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.15.0";
+var SERVER_VERSION = "0.18.0";
 function jsonResult(data) {
   return {
     content: [