@hiveai/mcp 0.2.6 → 0.2.7

package/dist/index.js

@@ -903,7 +903,7 @@ async function getBriefing(input, ctx) {
       searchMode = semanticHits ? "semantic" : "literal_fallback";
     }
     const seen = /* @__PURE__ */ new Map();
-    const addOrUpdate = (loaded, reason, score) => {
+    const addOrUpdate = (loaded, reason, score, matchQuality) => {
       const fm = loaded.memory.frontmatter;
       const existing = seen.get(fm.id);
       if (existing) {
@@ -911,6 +911,11 @@ async function getBriefing(input, ctx) {
         if (score !== void 0 && (existing.semantic_score ?? 0) < score) {
           existing.semantic_score = score;
         }
+        if (matchQuality === "exact" && existing.match_quality !== "exact") {
+          existing.match_quality = "exact";
+        } else if (matchQuality === "semantic" && existing.match_quality === "partial") {
+          existing.match_quality = "semantic";
+        }
         return;
       }
       const u = getUsage5(usage, fm.id);
@@ -924,6 +929,7 @@ async function getBriefing(input, ctx) {
         confidence: deriveConfidence4(fm, u),
         read_count: u.read_count,
         reasons: [reason],
+        match_quality: matchQuality ?? "partial",
         ...score !== void 0 ? { semantic_score: score } : {},
         body: loaded.memory.body,
         file_path: loaded.filePath
@@ -931,32 +937,33 @@ async function getBriefing(input, ctx) {
     };
     if (input.files.length > 0) {
       for (const loaded of allMemories) {
-        if (memoryMatchesAnchorPaths2(loaded.memory, input.files)) addOrUpdate(loaded, "anchor");
+        if (memoryMatchesAnchorPaths2(loaded.memory, input.files)) addOrUpdate(loaded, "anchor", void 0, "exact");
       }
       for (const loaded of allMemories) {
         const fm = loaded.memory.frontmatter;
-        if (fm.module && inferred.includes(fm.module)) addOrUpdate(loaded, "module");
-        if (fm.domain && inferred.includes(fm.domain)) addOrUpdate(loaded, "domain");
-        if (fm.tags.some((t) => inferred.includes(t))) addOrUpdate(loaded, "module");
+        if (fm.module && inferred.includes(fm.module)) addOrUpdate(loaded, "module", void 0, "partial");
+        if (fm.domain && inferred.includes(fm.domain)) addOrUpdate(loaded, "domain", void 0, "partial");
+        if (fm.tags.some((t) => inferred.includes(t))) addOrUpdate(loaded, "module", void 0, "partial");
       }
     }
     if (input.task) {
       const tokens = tokenizeQuery2(input.task);
       for (const loaded of allMemories) {
         if (literalMatchesAllTokens2(loaded.memory, tokens)) {
-          addOrUpdate(loaded, "semantic");
+          addOrUpdate(loaded, "semantic", void 0, "exact");
         }
       }
       if (semanticHits) {
         const byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
         for (const hit of semanticHits) {
           const loaded = byId.get(hit.id);
-          if (loaded) addOrUpdate(loaded, "semantic", hit.score);
+          if (loaded) addOrUpdate(loaded, "semantic", hit.score, "semantic");
         }
       }
     }
     const ranked = [...seen.values()].sort((a, b) => {
-      const reasonScore = (m) => (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
+      const reasonScore = (m) => (m.type === "attempt" ? 3 : 0) + // attempt = negative knowledge, surface first to prevent repeating mistakes
+      (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
       const confidenceScore = (m) => m.confidence === "authoritative" ? 4 : m.confidence === "trusted" ? 3 : m.confidence === "low" ? 1 : m.confidence === "stale" ? -2 : 0;
       const sa = reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
       const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
@@ -1003,12 +1010,24 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const trimmedMemoriesText = memoriesSlice.text;
-  const trimmedMemories = memories.map((m) => {
-    if (!memoriesSlice.truncated) return m;
-    const tokensPer = Math.floor(memoriesSlice.allocatedTokens / Math.max(1, memories.length));
-    const t = truncateToTokens(m.body, { maxTokens: tokensPer, mode: "head" });
-    return { ...m, body: t.text };
-  });
+  const trimmedMemories = [];
+  if (!memoriesSlice.truncated) {
+    trimmedMemories.push(...memories);
+  } else {
+    let remaining = memoriesSlice.allocatedTokens;
+    for (const m of memories) {
+      const bodyTokens = estimateTokens(m.body);
+      if (remaining <= 0) break;
+      if (bodyTokens <= remaining) {
+        trimmedMemories.push(m);
+        remaining -= bodyTokens;
+      } else if (remaining > 80) {
+        const t = truncateToTokens(m.body, { maxTokens: remaining, mode: "head" });
+        trimmedMemories.push({ ...m, body: t.text });
+        remaining = 0;
+      }
+    }
+  }
   const totalTokens = projectSlice.estimatedTokens + modulesSlice.estimatedTokens + memoriesSlice.estimatedTokens;
   return {
     ...input.task ? { task: input.task } : {},
@@ -1174,9 +1193,69 @@ ${template}\`\`\`
   };
 }
 
+// src/prompts/post-task.ts
+import { z as z18 } from "zod";
+var PostTaskArgsSchema = {
+  task_summary: z18.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z18.array(z18.string()).optional().describe("Files you created or modified during the task")
+};
+function postTaskPrompt(args, ctx) {
+  const taskLine = args.task_summary ? `
+Task just completed: **${args.task_summary}**` : "";
+  const filesLine = args.files_touched && args.files_touched.length > 0 ? `
+Files touched: ${args.files_touched.map((f) => `\`${f}\``).join(", ")}` : "";
+  const text = `You have just finished a task. Before closing this session, take 60 seconds to capture what you learned.
+${taskLine}${filesLine}
+
+Project root: \`${ctx.paths.root}\`
+
+## Checklist \u2014 answer each question honestly
+
+Go through each item. If the answer is yes, call the corresponding tool immediately.
+
+### 1. Did you try an approach that failed?
+\u2192 If yes, call **\`mem_tried\`** with:
+  - \`what\`: the approach you tried (e.g. "importing gray-matter with ESM dynamic import")
+  - \`why_failed\`: why it didn't work
+  - \`instead\`: what worked instead
+  - \`scope\`: "team" if others will hit the same issue, "personal" if specific to your setup
+  - \`paths\`: the files where the issue manifested
+
+### 2. Did you discover a convention that isn't documented?
+\u2192 If yes, call **\`mem_save\`** with \`type="convention"\` and \`scope="team"\`
+
+### 3. Did you make an architectural decision?
+\u2192 If yes, call **\`mem_save\`** with \`type="decision"\` and document the WHY (constraints, tradeoffs), not just the what
+
+### 4. Did you hit a non-obvious bug or surprising behavior?
+\u2192 If yes, call **\`mem_save\`** with \`type="gotcha"\` and anchor it to the relevant file paths
+
+### 5. Did you find that an existing memory is outdated or wrong?
+\u2192 If yes, call **\`mem_update\`** with the correct information, or **\`mem_reject\`** if it's completely wrong
+
+## Rules
+
+- One memory per insight. Don't cram multiple lessons into one body.
+- Anchor memories to file paths when possible (the \`paths\` field) \u2014 this enables staleness detection.
+- Prefer \`scope="team"\` for anything a teammate or future agent would benefit from.
+- Skip sections where you genuinely have nothing to add. Don't fabricate memories.
+
+When done, respond with a brief summary: "Saved N memories: [list of IDs]" or "Nothing new to save."
+`;
+  return {
+    description: "Post-task reflection: capture what you learned before closing the session",
+    messages: [
+      {
+        role: "user",
+        content: { type: "text", text }
+      }
+    ]
+  };
+}
+
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.6";
+var SERVER_VERSION = "0.2.7";
 function jsonResult(data) {
   return {
     content: [
@@ -1195,7 +1274,7 @@ function createHaiveServer(options = {}) {
   );
   server.tool(
     "mem_save",
-    "Save a new memory (default scope=personal). Use scope=team for shared memories.",
+    "Save a new memory (convention, decision, gotcha, architecture, glossary). For failed approaches use mem_tried instead \u2014 it enforces a structured format that is more useful to future agents. Use scope=team to share with the whole team.",
     MemSaveInputSchema,
     async (input) => jsonResult(await memSave(input, context))
   );
@@ -1285,7 +1364,7 @@ function createHaiveServer(options = {}) {
   );
   server.tool(
     "mem_tried",
-    "Record a failed approach as negative knowledge (type=attempt, auto-validated). Use this whenever you tried something and it didn't work \u2014 saves future agents from repeating the mistake.",
+    "Preferred way to record a failed approach. Enforces a structured what/why_failed/instead format that is immediately actionable for future agents. Auto-validated (no approval cycle). Use whenever you tried an approach and it failed \u2014 prevents the same mistake from happening in the next session.",
     MemTriedInputSchema,
     async (input) => jsonResult(await memTried(input, context))
   );
@@ -1295,6 +1374,12 @@ function createHaiveServer(options = {}) {
     BootstrapProjectArgsSchema,
     (args) => bootstrapProjectPrompt(args, context)
   );
+  server.prompt(
+    "post_task",
+    "Post-task checklist: run this after completing a task to capture failed approaches, new conventions, decisions, and gotchas before closing the session.",
+    PostTaskArgsSchema,
+    (args) => postTaskPrompt(args, context)
+  );
   return { server, context };
 }