@hiveai/mcp 0.17.0 → 0.19.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,10 +1577,11 @@ 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,
@@ -1588,6 +1600,7 @@ import {
   loadConfig as loadConfig3,
   hashProjectContext,
   loadMemoriesFromDir as loadMemoriesFromDir15,
+  loadPreventionEvents,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   projectContextRecentlyEmitted,
@@ -1595,7 +1608,7 @@ import {
   recordProjectContextEmission,
   queryCodeMap,
   resolveBriefingBudget,
-  serializeMemory as serializeMemory10,
+  serializeMemory as serializeMemory11,
   specificityScore,
   GUESSABLE_THRESHOLD,
   tokenizeQuery as tokenizeQuery2,
@@ -1971,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 {
@@ -2242,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,
@@ -2651,6 +2668,7 @@ import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
   appendPreventionEvent,
+  BRIDGE_TARGET_PATH,
   buildDocFrequency,
   CODE_STOPWORDS,
   deriveConfidence as deriveConfidence6,
@@ -2692,6 +2710,23 @@ 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 = [];
@@ -2706,7 +2741,7 @@ function stripAiDirHunks(diff) {
     if (line.startsWith("diff --git ")) {
       flush();
       const target = line.match(/ b\/(.+)$/)?.[1] ?? "";
-      keep = !target.startsWith(".ai/");
+      keep = !isHaiveOwnedPath(target);
     }
     block.push(line);
   }
@@ -2785,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);
@@ -2827,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 = [];
@@ -3452,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",
@@ -3585,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";
@@ -3593,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 = [
@@ -3754,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);
@@ -4182,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.17.0";
+var SERVER_VERSION = "0.19.0";
 function jsonResult(data) {
   return {
     content: [