@hiveai/mcp 0.2.4 → 0.2.7

package/dist/server.js

@@ -124,12 +124,13 @@ import { existsSync as existsSync4 } from "fs";
 import path3 from "path";
 import {
   buildFrontmatter,
+  loadMemoriesFromDir as loadMemoriesFromDir2,
   memoryFilePath,
   serializeMemory
 } from "@hiveai/core";
 import { z as z4 } from "zod";
 var MemSaveInputSchema = {
-  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary"]).describe("Kind of memory being saved"),
+  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).describe("Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated)."),
   slug: z4.string().min(1).describe("Short human-readable identifier \u2014 becomes part of the filename"),
   body: z4.string().describe("Markdown body of the memory"),
   scope: z4.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope: personal | team | module"),
@@ -169,11 +170,24 @@ async function memSave(input, ctx) {
   if (existsSync4(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
+  let warning;
+  if (existsSync4(ctx.paths.memoriesDir)) {
+    const existing = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+    const slugTokens = input.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
+    const similar = existing.filter(({ memory }) => {
+      const id = memory.frontmatter.id.toLowerCase();
+      return slugTokens.length >= 2 && slugTokens.filter((t) => id.includes(t)).length >= Math.ceil(slugTokens.length * 0.6);
+    });
+    if (similar.length > 0) {
+      warning = `Possible duplicate detected. Similar memories: ${similar.map((m) => m.memory.frontmatter.id).join(", ")}. Consider updating one of these instead.`;
+    }
+  }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
   return {
     id: frontmatter.id,
     scope: frontmatter.scope,
-    file_path: file
+    file_path: file,
+    ...warning ? { warning } : {}
   };
 }
 
@@ -184,7 +198,8 @@ import {
   extractSnippet,
   getUsage,
   literalMatchesAllTokens,
-  loadMemoriesFromDir as loadMemoriesFromDir2,
+  literalMatchesAnyToken,
+  loadMemoriesFromDir as loadMemoriesFromDir3,
   loadUsageIndex,
   pickSnippetNeedle,
   tokenizeQuery,
@@ -194,7 +209,7 @@ import { z as z5 } from "zod";
 var MemSearchInputSchema = {
   query: z5.string().describe("Substring matched against id, tags, and body"),
   scope: z5.enum(["personal", "team", "module"]).optional().describe("Restrict results to a single scope"),
-  type: z5.enum(["convention", "decision", "gotcha", "architecture", "glossary"]).optional().describe("Restrict results to a memory type"),
+  type: z5.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).optional().describe("Restrict results to a memory type"),
   module: z5.string().optional().describe("Restrict results to a module"),
   status: z5.enum(["draft", "proposed", "validated", "deprecated", "stale", "rejected"]).optional().describe("Filter by a single status. Omit to return all statuses."),
   exclude_rejected: z5.boolean().default(false).describe("When true, exclude memories with status=rejected from results."),
@@ -209,7 +224,7 @@ async function memSearch(input, ctx) {
   if (!existsSync5(ctx.paths.memoriesDir)) {
     return { matches: [], total: 0, mode: input.semantic ? "literal_fallback" : "literal" };
   }
-  const all = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir3(ctx.paths.memoriesDir);
   const filtered = all.filter(({ memory }) => passesFilters(memory.frontmatter, input));
   const usage = await loadUsageIndex(ctx.paths);
   let result;
@@ -245,13 +260,23 @@ function passesFilters(fm, input) {
 }
 function buildLiteralResult(input, filtered, usage) {
   const tokens = tokenizeQuery(input.query);
-  const matched = filtered.filter(({ memory }) => literalMatchesAllTokens(memory, tokens));
   const snippetNeedle = pickSnippetNeedle(input.query);
-  const top = matched.slice(0, input.limit);
+  let andMatched = filtered.filter(({ memory }) => literalMatchesAllTokens(memory, tokens));
+  if (andMatched.length > 0) {
+    const top2 = andMatched.slice(0, input.limit);
+    return {
+      matches: top2.map((loaded) => toHit(loaded, snippetNeedle, usage)),
+      total: andMatched.length,
+      mode: "literal"
+    };
+  }
+  const orMatched = filtered.filter(({ memory }) => literalMatchesAnyToken(memory, tokens));
+  const top = orMatched.slice(0, input.limit);
   return {
     matches: top.map((loaded) => toHit(loaded, snippetNeedle, usage)),
-    total: matched.length,
-    mode: "literal"
+    total: orMatched.length,
+    mode: "literal",
+    notice: `No exact match for all tokens. Showing partial matches (OR fallback) \u2014 ${orMatched.length} result${orMatched.length === 1 ? "" : "s"}.`
   };
 }
 async function trySemanticSearch(ctx, input, filtered, usage) {
@@ -315,7 +340,7 @@ function toHit(loaded, needle, usage) {
 import { writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir3,
+  loadMemoriesFromDir as loadMemoriesFromDir4,
   serializeMemory as serializeMemory2,
   verifyAnchor
 } from "@hiveai/core";
@@ -331,7 +356,7 @@ async function memVerify(input, ctx) {
       summary: { checked: 0, fresh: 0, stale: 0, anchorless_skipped: 0, updated: 0 }
     };
   }
-  const all = await loadMemoriesFromDir3(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
   const targets = input.id ? all.filter((m) => m.memory.frontmatter.id === input.id) : all;
   const results = [];
   let fresh = 0;
@@ -410,7 +435,7 @@ function applyVerification(mem, result) {
 import { writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir4,
+  loadMemoriesFromDir as loadMemoriesFromDir5,
   loadUsageIndex as loadUsageIndex2,
   recordRejection,
   saveUsageIndex,
@@ -425,7 +450,7 @@ async function memReject(input, ctx) {
   if (!existsSync7(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
   const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
   if (!loaded) throw new Error(`No memory with id "${input.id}".`);
   await writeFile4(
@@ -461,7 +486,7 @@ import {
   deriveConfidence as deriveConfidence2,
   getUsage as getUsage2,
   inferModulesFromPaths,
-  loadMemoriesFromDir as loadMemoriesFromDir5,
+  loadMemoriesFromDir as loadMemoriesFromDir6,
   loadUsageIndex as loadUsageIndex3,
   memoryMatchesAnchorPaths,
   trackReads as trackReads2
@@ -483,7 +508,7 @@ async function memForFiles(input, ctx) {
       module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
     };
   }
-  const all = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex3(ctx.paths);
   const seen = /* @__PURE__ */ new Set();
   const byAnchor = [];
@@ -562,7 +587,7 @@ import { existsSync as existsSync9 } from "fs";
 import {
   deriveConfidence as deriveConfidence3,
   getUsage as getUsage3,
-  loadMemoriesFromDir as loadMemoriesFromDir6,
+  loadMemoriesFromDir as loadMemoriesFromDir7,
   loadUsageIndex as loadUsageIndex4
 } from "@hiveai/core";
 import { z as z9 } from "zod";
@@ -573,7 +598,7 @@ async function memGet(input, ctx) {
   if (!existsSync9(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const fm = found.memory.frontmatter;
@@ -605,7 +630,7 @@ async function memGet(input, ctx) {
 import { existsSync as existsSync10 } from "fs";
 import { unlink } from "fs/promises";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir7,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
   loadUsageIndex as loadUsageIndex5,
   saveUsageIndex as saveUsageIndex2
 } from "@hiveai/core";
@@ -618,7 +643,7 @@ async function memDelete(input, ctx) {
   if (!existsSync10(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   await unlink(found.filePath);
@@ -637,7 +662,7 @@ async function memDelete(input, ctx) {
 // src/tools/mem-update.ts
 import { writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir8, serializeMemory as serializeMemory4 } from "@hiveai/core";
+import { loadMemoriesFromDir as loadMemoriesFromDir9, serializeMemory as serializeMemory4 } from "@hiveai/core";
 import { z as z11 } from "zod";
 var MemUpdateInputSchema = {
   id: z11.string().min(1).describe("Id of the memory to update"),
@@ -653,7 +678,7 @@ async function memUpdate(input, ctx) {
   if (!existsSync11(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
   const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
   if (!loaded) throw new Error(`No memory with id "${input.id}".`);
   const { frontmatter, body } = loaded.memory;
@@ -698,7 +723,7 @@ async function memUpdate(input, ctx) {
 import { existsSync as existsSync12 } from "fs";
 import {
   getUsage as getUsage4,
-  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadMemoriesFromDir as loadMemoriesFromDir10,
   loadUsageIndex as loadUsageIndex6
 } from "@hiveai/core";
 import { z as z12 } from "zod";
@@ -707,7 +732,7 @@ var MemPendingInputSchema = {
 };
 async function memPending(input, ctx) {
   if (!existsSync12(ctx.paths.memoriesDir)) return { pending: [] };
-  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex6(ctx.paths);
   const now = Date.now();
   const proposed = all.filter(({ memory }) => {
@@ -741,7 +766,7 @@ async function memPending(input, ctx) {
 import { writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
   serializeMemory as serializeMemory5
 } from "@hiveai/core";
 import { z as z13 } from "zod";
@@ -752,7 +777,7 @@ async function memApprove(input, ctx) {
   if (!existsSync13(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const previous = found.memory.frontmatter.status;
@@ -769,10 +794,60 @@ async function memApprove(input, ctx) {
   };
 }
 
-// src/tools/get-briefing.ts
-import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+// src/tools/mem-tried.ts
+import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import path5 from "path";
+import {
+  buildFrontmatter as buildFrontmatter2,
+  memoryFilePath as memoryFilePath2,
+  serializeMemory as serializeMemory6
+} from "@hiveai/core";
+import { z as z14 } from "zod";
+var MemTriedInputSchema = {
+  what: z14.string().min(1).describe("Brief description of the approach that was tried"),
+  why_failed: z14.string().min(1).describe("Why it failed or why it should NOT be used"),
+  instead: z14.string().optional().describe("What to use or do instead (recommended alternative)"),
+  scope: z14.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
+  module: z14.string().optional().describe("Module name (required when scope=module)"),
+  tags: z14.array(z14.string()).default([]).describe("Tags for filtering"),
+  paths: z14.array(z14.string()).default([]).describe("Anchor file paths this applies to"),
+  author: z14.string().optional().describe("Author handle or email")
+};
+async function memTried(input, ctx) {
+  if (!existsSync14(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
+  const baseFm = buildFrontmatter2({
+    type: "attempt",
+    slug,
+    scope: input.scope,
+    module: input.module,
+    tags: input.tags,
+    paths: input.paths,
+    author: input.author
+  });
+  const frontmatter = { ...baseFm, status: "validated" };
+  const lines = [`# ${input.what}`, ""];
+  lines.push(`**Why it failed / do NOT use:** ${input.why_failed}`);
+  if (input.instead) {
+    lines.push("", `**Instead, use:** ${input.instead}`);
+  }
+  const body = lines.join("\n") + "\n";
+  const file = memoryFilePath2(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir3(path5.dirname(file), { recursive: true });
+  if (existsSync14(file)) {
+    throw new Error(`Memory already exists at ${file}`);
+  }
+  await writeFile7(file, serializeMemory6({ frontmatter, body }), "utf8");
+  return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
+}
+
+// src/tools/get-briefing.ts
+import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path6 from "path";
 import {
   allocateBudget,
   deriveConfidence as deriveConfidence4,
@@ -780,43 +855,50 @@ import {
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
   literalMatchesAllTokens as literalMatchesAllTokens2,
-  loadMemoriesFromDir as loadMemoriesFromDir11,
+  loadMemoriesFromDir as loadMemoriesFromDir12,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
 } from "@hiveai/core";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var GetBriefingInputSchema = {
-  task: z14.string().optional().describe(
+  task: z15.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z14.array(z14.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z14.number().int().positive().default(8e3).describe(
+  files: z15.array(z15.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z15.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: z14.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z14.boolean().default(true),
-  include_module_contexts: z14.boolean().default(true),
-  semantic: z14.boolean().default(true).describe(
+  max_memories: z15.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z15.boolean().default(true),
+  include_module_contexts: z15.boolean().default(true),
+  semantic: z15.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  track: z14.boolean().default(true).describe("Increment read_count on returned memories")
+  include_stale: z15.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z15.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function getBriefing(input, ctx) {
   const inferred = inferModulesFromPaths2(input.files);
   const memories = [];
   let searchMode = "literal";
-  if (existsSync14(ctx.paths.memoriesDir)) {
-    const allMemories = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  if (existsSync15(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
+    const allMemories = allLoaded.filter(({ memory }) => {
+      const s = memory.frontmatter.status;
+      if (s === "rejected" || s === "deprecated") return false;
+      if (!input.include_stale && s === "stale") return false;
+      return true;
+    });
     const usage = await loadUsageIndex7(ctx.paths);
     const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
     if (input.task && input.semantic) {
       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) {
@@ -824,6 +906,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);
@@ -837,6 +924,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
@@ -844,32 +932,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);
@@ -880,10 +969,13 @@ async function getBriefing(input, ctx) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
     }
   }
-  const projectContext = input.include_project_context && existsSync14(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContext = input.include_project_context && existsSync15(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
-  const memoriesText = memories.map((m) => `### ${m.id} (${m.scope}/${m.type}, ${m.confidence})
-${m.body.trim()}`).join("\n\n---\n\n");
+  const memoriesText = memories.map((m) => {
+    const unverified = m.status === "proposed" ? " [UNVERIFIED \u2014 not yet validated]" : "";
+    return `### ${m.id} (${m.scope}/${m.type}, ${m.confidence})${unverified}
+${m.body.trim()}`;
+  }).join("\n\n---\n\n");
   const slices = allocateBudget(
     [
       { key: "project", text: projectContext, weight: 3, mode: "head" },
@@ -913,12 +1005,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 } : {},
@@ -951,15 +1055,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync14(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync15(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
   const out = [];
   for (const m of modules) {
     if (!available.has(m)) continue;
-    const file = path5.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync14(file)) {
+    const file = path6.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync15(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -968,11 +1072,11 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/code-map.ts
 import { loadCodeMap, queryCodeMap } from "@hiveai/core";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var CodeMapInputSchema = {
-  file: z15.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z15.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  max_files: z15.number().int().positive().default(40).describe("Cap on returned files")
+  file: z16.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z16.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  max_files: z16.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap(ctx.paths);
@@ -998,12 +1102,12 @@ async function codeMapTool(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z16.string().optional().describe(
+  module: z17.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z16.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z17.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -1084,9 +1188,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.4";
+var SERVER_VERSION = "0.2.7";
 function jsonResult(data) {
   return {
     content: [
@@ -1105,7 +1269,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))
   );
@@ -1193,12 +1357,24 @@ function createHaiveServer(options = {}) {
     MemApproveInputSchema,
     async (input) => jsonResult(await memApprove(input, context))
   );
+  server.tool(
+    "mem_tried",
+    "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))
+  );
   server.prompt(
     "bootstrap_project",
     "Instructions for the AI client to analyze the project and save the context.",
     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 };
 }
 export {