@hiveai/mcp 0.2.10 → 0.2.12

package/dist/server.js

@@ -119,6 +119,7 @@ async function memList(input, ctx) {
 }
 
 // src/tools/mem-save.ts
+import { createHash } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import path3 from "path";
@@ -130,7 +131,9 @@ import {
 } from "@hiveai/core";
 import { z as z4 } from "zod";
 var MemSaveInputSchema = {
-  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).describe("Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated)."),
+  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt", "session_recap"]).describe(
+    "Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated). Use 'session_recap' via mem_session_end instead."
+  ),
   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"),
@@ -140,14 +143,61 @@ var MemSaveInputSchema = {
   author: z4.string().optional().describe("Author handle or email"),
   paths: z4.array(z4.string()).default([]).describe("Anchor paths (file paths this memory references)"),
   symbols: z4.array(z4.string()).default([]).describe("Anchor symbols (function/class names this memory references)"),
-  commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)")
+  commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)"),
+  topic: z4.string().optional().describe(
+    "Stable key for this memory. If a memory with the same topic already exists in this scope, it is updated in-place (revision_count++). Use for knowledge that evolves over time."
+  )
 };
+function bodyHash(body) {
+  return createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
+}
 async function memSave(input, ctx) {
   if (!existsSync4(ctx.paths.haiveDir)) {
     throw new Error(
       `No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`
     );
   }
+  const existing = existsSync4(ctx.paths.memoriesDir) ? await loadMemoriesFromDir2(ctx.paths.memoriesDir) : [];
+  const incomingHash = bodyHash(input.body);
+  const hashDuplicate = existing.find(
+    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === input.scope
+  );
+  if (hashDuplicate) {
+    throw new Error(
+      `Duplicate content detected \u2014 identical body already saved as "${hashDuplicate.memory.frontmatter.id}". Use mem_update to modify it, or change the body to add new information.`
+    );
+  }
+  if (input.topic) {
+    const topicMatch = existing.find(
+      ({ memory }) => memory.frontmatter.topic === input.topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
+    );
+    if (topicMatch) {
+      const fm = topicMatch.memory.frontmatter;
+      const newFrontmatter = {
+        ...fm,
+        body: input.body,
+        tags: input.tags.length ? input.tags : fm.tags,
+        revision_count: (fm.revision_count ?? 0) + 1,
+        anchor: {
+          commit: input.commit ?? fm.anchor.commit,
+          paths: input.paths.length ? input.paths : fm.anchor.paths,
+          symbols: input.symbols.length ? input.symbols : fm.anchor.symbols
+        }
+      };
+      await writeFile2(
+        topicMatch.filePath,
+        serializeMemory({ frontmatter: newFrontmatter, body: input.body }),
+        "utf8"
+      );
+      return {
+        id: fm.id,
+        scope: fm.scope,
+        file_path: topicMatch.filePath,
+        action: "updated",
+        revision_count: newFrontmatter.revision_count
+      };
+    }
+  }
   const frontmatter = buildFrontmatter({
     type: input.type,
     slug: input.slug,
@@ -158,7 +208,8 @@ async function memSave(input, ctx) {
     author: input.author,
     paths: input.paths,
     symbols: input.symbols,
-    commit: input.commit
+    commit: input.commit,
+    topic: input.topic
   });
   const file = memoryFilePath(
     ctx.paths,
@@ -171,15 +222,16 @@ async function memSave(input, ctx) {
     throw new Error(`Memory already exists at ${file}`);
   }
   let warning;
-  if (existsSync4(ctx.paths.memoriesDir)) {
-    const existing = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+  let similar_found;
+  if (existing.length > 0) {
     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.`;
+      similar_found = similar.map((m) => m.memory.frontmatter.id);
+      warning = `Possible duplicate: similar memories already exist (${similar_found.join(", ")}). Consider updating one of these instead.`;
     }
   }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
@@ -187,7 +239,9 @@ async function memSave(input, ctx) {
     id: frontmatter.id,
     scope: frontmatter.scope,
     file_path: file,
-    ...warning ? { warning } : {}
+    action: "created",
+    ...warning ? { warning } : {},
+    ...similar_found ? { similar_found } : {}
   };
 }
 
@@ -521,10 +575,14 @@ async function memForFiles(input, ctx) {
       seen.add(loaded.memory.frontmatter.id);
     }
   }
+  const pathSegments = extractPathSegments(input.files);
   for (const loaded of all) {
     if (seen.has(loaded.memory.frontmatter.id)) continue;
     const fm = loaded.memory.frontmatter;
-    const moduleHit = fm.module && inferred.includes(fm.module) || fm.tags.some((t) => inferred.includes(t));
+    const moduleHit = fm.module && inferred.includes(fm.module) || fm.tags.some((t) => inferred.includes(t)) || fm.tags.some((t) => {
+      const tl = t.toLowerCase();
+      return pathSegments.has(tl) || pathSegments.has(tl.replace(/[-_]/g, ""));
+    });
     if (moduleHit) {
       byModule.push(toMatch(loaded, "module", usage));
       seen.add(fm.id);
@@ -566,6 +624,52 @@ function toMatch(loaded, reason, usage) {
     body: loaded.memory.body
   };
 }
+function extractPathSegments(files) {
+  const GENERIC = /* @__PURE__ */ new Set([
+    "src",
+    "main",
+    "java",
+    "kotlin",
+    "python",
+    "go",
+    "lib",
+    "libs",
+    "com",
+    "org",
+    "net",
+    "io",
+    "app",
+    "apps",
+    "pkg",
+    "internal",
+    "test",
+    "tests",
+    "spec",
+    "specs",
+    "impl",
+    "domain",
+    "shared",
+    "resources",
+    "static",
+    "assets",
+    "config",
+    "configs"
+  ]);
+  const out = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parts = file.replace(/\\/g, "/").split("/");
+    for (const part of parts) {
+      const seg = part.toLowerCase().replace(/\.[^.]+$/, "");
+      if (seg.length >= 3 && !GENERIC.has(seg) && /^[a-z]/.test(seg)) {
+        out.add(seg);
+        for (const sub of seg.split(/[-_]/).filter((s) => s.length >= 3)) {
+          out.add(sub);
+        }
+      }
+    }
+  }
+  return out;
+}
 async function loadModuleContexts(ctx, modules, enabled) {
   if (!enabled || modules.length === 0) return [];
   if (!existsSync8(ctx.paths.modulesContextDir)) return [];
@@ -845,10 +949,172 @@ async function memTried(input, ctx) {
   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";
+// src/tools/mem-observe.ts
+import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
 import path6 from "path";
+import {
+  buildFrontmatter as buildFrontmatter3,
+  memoryFilePath as memoryFilePath3,
+  serializeMemory as serializeMemory7
+} from "@hiveai/core";
+import { z as z15 } from "zod";
+var MemObserveInputSchema = {
+  what: z15.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
+  where: z15.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
+  impact: z15.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
+  fix: z15.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
+  scope: z15.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+  module: z15.string().optional().describe("Module name (required when scope=module)"),
+  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
+  author: z15.string().optional().describe("Author handle or email")
+};
+async function memObserve(input, ctx) {
+  if (!existsSync15(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, 6).join("-");
+  const anchorPaths = input.where.split(/[,\n]/).map((s) => s.trim()).filter(Boolean);
+  const baseFm = buildFrontmatter3({
+    type: "gotcha",
+    slug,
+    scope: input.scope,
+    module: input.module,
+    tags: input.tags,
+    paths: anchorPaths,
+    author: input.author
+  });
+  const frontmatter = { ...baseFm, status: "validated" };
+  const lines = [`# ${input.what}`, ""];
+  lines.push(`**Where:** \`${input.where}\``);
+  lines.push("", `**Impact:** ${input.impact}`);
+  if (input.fix) {
+    lines.push("", `**Fix/workaround:** ${input.fix}`);
+  }
+  const body = lines.join("\n") + "\n";
+  const file = memoryFilePath3(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir4(path6.dirname(file), { recursive: true });
+  if (existsSync15(file)) {
+    throw new Error(`Memory already exists at ${file}`);
+  }
+  await writeFile8(file, serializeMemory7({ frontmatter, body }), "utf8");
+  return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
+}
+
+// src/tools/mem-session-end.ts
+import { writeFile as writeFile9, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import path7 from "path";
+import {
+  buildFrontmatter as buildFrontmatter4,
+  loadMemoriesFromDir as loadMemoriesFromDir12,
+  memoryFilePath as memoryFilePath4,
+  serializeMemory as serializeMemory8
+} from "@hiveai/core";
+import { z as z16 } from "zod";
+var MemSessionEndInputSchema = {
+  goal: z16.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z16.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z16.string().default("").describe(
+    "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
+  ),
+  files_touched: z16.array(z16.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z16.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z16.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z16.string().optional().describe("Module name (required when scope=module)")
+};
+function recapTopic(scope, module) {
+  return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
+}
+function buildBody(input) {
+  const lines = [];
+  lines.push(`## Goal
+${input.goal}`);
+  lines.push(`
+## Accomplished
+${input.accomplished}`);
+  if (input.discoveries.trim()) {
+    lines.push(`
+## Discoveries & surprises
+${input.discoveries}`);
+  }
+  if (input.files_touched.length > 0) {
+    lines.push(`
+## Files touched
+${input.files_touched.map((f) => `- \`${f}\``).join("\n")}`);
+  }
+  if (input.next_steps.trim()) {
+    lines.push(`
+## Next steps
+${input.next_steps}`);
+  }
+  return lines.join("\n");
+}
+async function memSessionEnd(input, ctx) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  const body = buildBody(input);
+  const topic = recapTopic(input.scope, input.module);
+  const existing = existsSync16(ctx.paths.memoriesDir) ? await loadMemoriesFromDir12(ctx.paths.memoriesDir) : [];
+  const topicMatch = existing.find(
+    ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
+  );
+  if (topicMatch) {
+    const fm = topicMatch.memory.frontmatter;
+    const revisionCount = (fm.revision_count ?? 0) + 1;
+    const newFrontmatter = {
+      ...fm,
+      revision_count: revisionCount,
+      anchor: {
+        ...fm.anchor,
+        paths: input.files_touched.length ? input.files_touched : fm.anchor.paths
+      }
+    };
+    await writeFile9(
+      topicMatch.filePath,
+      serializeMemory8({ frontmatter: newFrontmatter, body }),
+      "utf8"
+    );
+    return {
+      id: fm.id,
+      scope: fm.scope,
+      file_path: topicMatch.filePath,
+      action: "updated",
+      revision_count: revisionCount
+    };
+  }
+  const frontmatter = buildFrontmatter4({
+    type: "session_recap",
+    slug: "session-recap",
+    scope: input.scope,
+    module: input.module,
+    tags: ["session", "recap"],
+    paths: input.files_touched,
+    topic,
+    status: "validated"
+  });
+  const file = memoryFilePath4(
+    ctx.paths,
+    frontmatter.scope,
+    frontmatter.id,
+    frontmatter.module
+  );
+  await mkdir5(path7.dirname(file), { recursive: true });
+  await writeFile9(file, serializeMemory8({ frontmatter, body }), "utf8");
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file,
+    action: "created",
+    revision_count: 0
+  };
+}
+
+// src/tools/get-briefing.ts
+import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path8 from "path";
 import {
   allocateBudget,
   deriveConfidence as deriveConfidence4,
@@ -857,31 +1123,31 @@ import {
   inferModulesFromPaths as inferModulesFromPaths2,
   isDecaying,
   literalMatchesAllTokens as literalMatchesAllTokens2,
-  loadMemoriesFromDir as loadMemoriesFromDir12,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
 } from "@hiveai/core";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var GetBriefingInputSchema = {
-  task: z15.string().optional().describe(
+  task: z17.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  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(
+  files: z17.array(z17.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z17.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: 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(
+  max_memories: z17.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z17.boolean().default(true),
+  include_module_contexts: z17.boolean().default(true),
+  semantic: z17.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  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"),
-  format: z15.enum(["full", "compact"]).default("full").describe(
+  include_stale: z17.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z17.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z17.enum(["full", "compact"]).default("full").describe(
     "Output format: 'full' returns complete memory bodies; 'compact' returns id + 1-line summary only (call mem_get for details)."
   )
 };
@@ -891,12 +1157,27 @@ async function getBriefing(input, ctx) {
   let searchMode = "literal";
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
-  if (existsSync15(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
+  let lastSession;
+  if (existsSync17(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+    const recaps = allLoaded.filter(({ memory }) => memory.frontmatter.type === "session_recap").sort(
+      (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
+    );
+    if (recaps.length > 0) {
+      const r = recaps[0];
+      const fm = r.memory.frontmatter;
+      lastSession = {
+        id: fm.id,
+        scope: fm.scope,
+        revision_count: fm.revision_count ?? 0,
+        body: r.memory.body
+      };
+    }
     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;
+      if (memory.frontmatter.type === "session_recap") return false;
       return true;
     });
     usage = await loadUsageIndex7(ctx.paths);
@@ -986,7 +1267,7 @@ async function getBriefing(input, ctx) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
     }
   }
-  const projectContext = input.include_project_context && existsSync15(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContext = input.include_project_context && existsSync17(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
   const memoriesText = memories.map((m) => {
     const unverified = m.status === "proposed" ? " [UNVERIFIED \u2014 not yet validated]" : "";
@@ -1052,6 +1333,7 @@ ${m.content}`).join("\n\n---\n\n"),
     ...input.task ? { task: input.task } : {},
     search_mode: searchMode,
     inferred_modules: inferred,
+    ...lastSession ? { last_session: lastSession } : {},
     project_context: projectContext ? { content: projectSlice.text, truncated: projectSlice.truncated } : null,
     module_contexts: trimmedModules,
     memories: outputMemories,
@@ -1087,15 +1369,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync15(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync17(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 = path6.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync15(file)) {
+    const file = path8.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync17(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -1104,11 +1386,11 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/code-map.ts
 import { loadCodeMap, queryCodeMap } from "@hiveai/core";
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 var CodeMapInputSchema = {
-  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")
+  file: z18.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z18.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  max_files: z18.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap(ctx.paths);
@@ -1134,18 +1416,18 @@ async function codeMapTool(input, ctx) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync16 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir13 } from "@hiveai/core";
-import { z as z17 } from "zod";
+import { existsSync as existsSync18 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
+import { z as z19 } from "zod";
 var MemDiffInputSchema = {
-  id_a: z17.string().min(1).describe("First memory id"),
-  id_b: z17.string().min(1).describe("Second memory id")
+  id_a: z19.string().min(1).describe("First memory id"),
+  id_b: z19.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync16(ctx.paths.memoriesDir)) {
+  if (!existsSync18(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
   const foundA = all.find((m) => m.memory.frontmatter.id === input.id_a);
   const foundB = all.find((m) => m.memory.frontmatter.id === input.id_b);
   if (!foundA) throw new Error(`No memory with id "${input.id_a}".`);
@@ -1179,12 +1461,12 @@ async function memDiff(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z18.string().optional().describe(
+  module: z20.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z18.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z20.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -1266,10 +1548,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z19.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z19.array(z19.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z21.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z21.array(z21.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -1285,6 +1567,19 @@ Project root: \`${ctx.paths.root}\`
 
 Go through each item. If the answer is yes, call the corresponding tool immediately.
 
+### 0. Did you read existing code and discover bugs, inconsistencies, or security gaps that weren't in the briefing?
+This is the most important question. Deep code reading surfaces issues that no memory captures yet.
+Examples of things to look for:
+- A method with an invalid signature (e.g. two \`@RequestBody\` on the same handler)
+- A configuration that looks wrong or missing (e.g. webhook path not whitelisted in SecurityConfig)
+- A component scan / DI issue (e.g. a Spring bean not picked up because the package isn't scanned)
+- A DB constraint that will break when you add a new enum value
+- A hardcoded value that should be dynamic (e.g. hardcoded tenant id "default-tenant")
+- Anything that will silently break in production
+
+\u2192 If yes, call **\`mem_save\`** with \`type="gotcha"\`, \`scope="team"\`, and **anchor it to the file** with \`paths\`.
+  This transforms your discovery into institutional knowledge that protects every future agent.
+
 ### 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")
@@ -1299,7 +1594,7 @@ Go through each item. If the answer is yes, call the corresponding tool immediat
 ### 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?
+### 4. Did you hit a non-obvious bug or surprising behavior in a library or framework?
 \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?
@@ -1311,8 +1606,20 @@ Go through each item. If the answer is yes, call the corresponding tool immediat
 - 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.
+- **Question 0 is not optional** \u2014 always scan your exploration history for code-level discoveries.
+
+### 6. Close the session \u2014 always
+Call **\`mem_session_end\`** with:
+- \`goal\`: what you set out to do
+- \`accomplished\`: what was actually done (bullet list)
+- \`discoveries\`: anything surprising or broken found during this session (leave empty if none)
+- \`files_touched\`: the key files you read or modified
+- \`next_steps\`: what remains for the next session or a teammate
+- \`scope\`: "team" if this task affects the whole team, "personal" otherwise
 
-When done, respond with a brief summary: "Saved N memories: [list of IDs]" or "Nothing new to save."
+This creates/updates a single rolling recap that **get_briefing automatically surfaces** at the start of every subsequent session \u2014 no token waste re-explaining what happened.
+
+When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved."
 `;
   return {
     description: "Post-task reflection: capture what you learned before closing the session",
@@ -1326,12 +1633,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]" or "N
 }
 
 // src/prompts/import-docs.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z20.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z20.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z20.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z20.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z22.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z22.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z22.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z22.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -1396,7 +1703,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.10";
+var SERVER_VERSION = "0.2.12";
 function jsonResult(data) {
   return {
     content: [
@@ -1515,6 +1822,18 @@ function createHaiveServer(options = {}) {
     MemDiffInputSchema,
     async (input) => jsonResult(await memDiff(input, context))
   );
+  server.tool(
+    "mem_observe",
+    "Capture a code-level discovery made during exploration: a bug, inconsistency, missing config, or security gap found by reading existing code that was NOT in the briefing. Use this whenever you read code and spot something that could silently break in production. Auto-validated, anchored to file paths for staleness detection. Prefer this over mem_save for reactive discoveries during code reading.",
+    MemObserveInputSchema,
+    async (input) => jsonResult(await memObserve(input, context))
+  );
+  server.tool(
+    "mem_session_end",
+    "Save a structured end-of-session recap (goal / accomplished / discoveries / next steps). Uses topic-upsert: one recap per scope is kept and updated in-place so the next session always has fresh context. Call this before closing every significant session. get_briefing automatically surfaces the latest recap at the top of the next session's briefing.",
+    MemSessionEndInputSchema,
+    async (input) => jsonResult(await memSessionEnd(input, context))
+  );
   server.prompt(
     "bootstrap_project",
     "Instructions for the AI client to analyze the project and save the context.",