@hiveai/mcp 0.8.0 → 0.9.2

package/dist/index.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/context.ts
 import { findProjectRoot, resolveHaivePaths } from "@hiveai/core";
@@ -142,7 +140,9 @@ var MemSaveInputSchema = {
   ),
   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"),
+  scope: z4.enum(["personal", "team", "module"]).optional().describe(
+    "Visibility scope: personal | team | module. When omitted, falls back to defaultScope in haive.config.json (default: personal)."
+  ),
   module: z4.string().optional().describe("Module name (required when scope=module)"),
   tags: z4.array(z4.string()).default([]).describe("Tags for filtering"),
   domain: z4.string().optional().describe("Domain (e.g. transactions, billing)"),
@@ -164,12 +164,14 @@ async function memSave(input, ctx) {
     );
   }
   const existing = existsSync4(ctx.paths.memoriesDir) ? await loadMemoriesFromDir2(ctx.paths.memoriesDir) : [];
+  const haiveConfig = await loadConfig(ctx.paths);
+  const resolvedScope = input.scope ?? haiveConfig.defaultScope ?? "personal";
   const invalidPaths = input.paths.filter(
     (p) => !existsSync4(path3.resolve(ctx.paths.root, p))
   );
   const incomingHash = bodyHash(input.body);
   const hashDuplicate = existing.find(
-    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === input.scope
+    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === resolvedScope
   );
   if (hashDuplicate) {
     throw new Error(
@@ -178,7 +180,7 @@ async function memSave(input, ctx) {
   }
   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)
+      ({ memory }) => memory.frontmatter.topic === input.topic && memory.frontmatter.scope === resolvedScope && (!input.module || memory.frontmatter.module === input.module)
     );
     if (topicMatch) {
       const fm = topicMatch.memory.frontmatter;
@@ -208,8 +210,6 @@ async function memSave(input, ctx) {
       };
     }
   }
-  const haiveConfig = await loadConfig(ctx.paths);
-  const resolvedScope = input.scope !== "personal" ? input.scope : haiveConfig.defaultScope ?? "personal";
   const frontmatter = buildFrontmatter({
     type: input.type,
     slug: input.slug,
@@ -1040,9 +1040,9 @@ async function memObserve(input, ctx) {
 }
 
 // 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 { writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path8 from "path";
 import {
   buildFrontmatter as buildFrontmatter4,
   loadMemoriesFromDir as loadMemoriesFromDir12,
@@ -1050,6 +1050,134 @@ import {
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z16 } from "zod";
+
+// src/session-tracker.ts
+import { appendUsageEvent, loadConfig as loadConfig2 } from "@hiveai/core";
+import { mkdir as mkdir5, writeFile as writeFile9, rm } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import path7 from "path";
+import { execSync } from "child_process";
+function pendingDistillPath(ctx) {
+  return path7.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
+}
+var SessionTracker = class {
+  events = [];
+  startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  config = null;
+  ctx;
+  shutdownRegistered = false;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async init() {
+    this.config = await loadConfig2(this.ctx.paths);
+    if (this.config.autoSessionEnd) {
+      this.registerShutdownHandler();
+    }
+  }
+  record(tool, summary) {
+    const event = { tool, at: (/* @__PURE__ */ new Date()).toISOString(), summary };
+    this.events.push(event);
+    void appendUsageEvent(this.ctx.paths, event);
+  }
+  registerShutdownHandler() {
+    if (this.shutdownRegistered) return;
+    this.shutdownRegistered = true;
+    const save = async () => {
+      const writingTools = this.events.filter(
+        (e) => ["mem_save", "mem_tried", "mem_observe", "mem_update", "bootstrap_project_save"].includes(e.tool)
+      );
+      const totalCalls = this.events.length;
+      if (totalCalls === 0) return;
+      const toolSummary = summarizeTools(this.events);
+      const filesSet = /* @__PURE__ */ new Set();
+      for (const e of this.events) {
+        if (e.summary) {
+          const matches = e.summary.match(/[^\s"',]+\.[a-zA-Z]{1,6}/g) ?? [];
+          for (const m of matches) filesSet.add(m);
+        }
+      }
+      let gitDiff;
+      try {
+        const raw = execSync("git diff HEAD", {
+          cwd: this.ctx.paths.root,
+          timeout: 5e3,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        gitDiff = raw.slice(0, 8192) || void 0;
+      } catch {
+      }
+      let recapId;
+      try {
+        const result = await memSessionEnd(
+          {
+            goal: `Auto-captured session (${totalCalls} tool call${totalCalls === 1 ? "" : "s"})`,
+            accomplished: toolSummary,
+            discoveries: writingTools.length > 0 ? `${writingTools.length} memor${writingTools.length === 1 ? "y" : "ies"} saved during this session.` : "No new memories saved this session.",
+            files_touched: [...filesSet].slice(0, 10),
+            next_steps: "",
+            scope: this.config?.defaultScope ?? "personal",
+            module: void 0
+          },
+          this.ctx
+        );
+        recapId = result.id;
+      } catch {
+      }
+      const ranPostTask = this.events.some(
+        (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
+      );
+      if (!ranPostTask && existsSync16(this.ctx.paths.haiveDir)) {
+        try {
+          const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
+          const payload = {
+            session_start: this.startedAt,
+            session_end: (/* @__PURE__ */ new Date()).toISOString(),
+            total_tool_calls: totalCalls,
+            tool_summary: toolSummary,
+            memories_saved: memoriesSaved,
+            git_diff_available: !!gitDiff,
+            ...gitDiff ? { git_diff: gitDiff } : {},
+            ...recapId ? { recap_id: recapId } : {}
+          };
+          const cacheDir = path7.join(this.ctx.paths.haiveDir, ".cache");
+          await mkdir5(cacheDir, { recursive: true });
+          await writeFile9(
+            pendingDistillPath(this.ctx),
+            JSON.stringify(payload, null, 2) + "\n",
+            "utf8"
+          );
+        } catch {
+        }
+      }
+    };
+    process.once("SIGTERM", () => {
+      void save().finally(() => process.exit(0));
+    });
+    process.once("SIGINT", () => {
+      void save().finally(() => process.exit(0));
+    });
+  }
+};
+async function clearPendingDistill(ctx) {
+  const p = pendingDistillPath(ctx);
+  if (existsSync16(p)) {
+    try {
+      await rm(p);
+    } catch {
+    }
+  }
+}
+function summarizeTools(events) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    counts.set(e.tool, (counts.get(e.tool) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([t, n]) => `${t} \xD7${n}`).join(", ");
+}
+
+// src/tools/mem-session-end.ts
 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"),
@@ -1089,18 +1217,18 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync16(ctx.paths.haiveDir)) {
+  if (!existsSync17(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 invalidPaths = input.files_touched.filter(
-    (p) => !existsSync16(path7.resolve(ctx.paths.root, p))
+    (p) => !existsSync17(path8.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync16(ctx.paths.memoriesDir) ? await loadMemoriesFromDir12(ctx.paths.memoriesDir) : [];
+  const existing = existsSync17(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)
   );
@@ -1115,11 +1243,12 @@ async function memSessionEnd(input, ctx) {
         paths: input.files_touched.length ? input.files_touched : fm.anchor.paths
       }
     };
-    await writeFile9(
+    await writeFile10(
       topicMatch.filePath,
       serializeMemory8({ frontmatter: newFrontmatter, body }),
       "utf8"
     );
+    await clearPendingDistill(ctx);
     return {
       id: fm.id,
       scope: fm.scope,
@@ -1144,8 +1273,9 @@ async function memSessionEnd(input, ctx) {
     frontmatter.id,
     frontmatter.module
   );
-  await mkdir5(path7.dirname(file), { recursive: true });
-  await writeFile9(file, serializeMemory8({ frontmatter, body }), "utf8");
+  await mkdir6(path8.dirname(file), { recursive: true });
+  await writeFile10(file, serializeMemory8({ frontmatter, body }), "utf8");
+  await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
     scope: frontmatter.scope,
@@ -1156,24 +1286,27 @@ async function memSessionEnd(input, ctx) {
 }
 
 // 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 { readFile as readFile3, readdir as readdir3, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path9 from "path";
 import {
   allocateBudget,
+  DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
+  isAutoPromoteEligible,
   isDecaying,
   literalMatchesAllTokens as literalMatchesAllTokens2,
   literalMatchesAnyToken as literalMatchesAnyToken2,
   loadCodeMap,
-  loadConfig as loadConfig2,
+  loadConfig as loadConfig3,
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   queryCodeMap,
+  serializeMemory as serializeMemory9,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
@@ -1212,7 +1345,7 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync17(ctx.paths.memoriesDir)) {
+  if (existsSync18(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()
@@ -1330,15 +1463,38 @@ async function getBriefing(input, ctx) {
     memories.push(...ranked.slice(0, input.max_memories));
     if (input.track && memories.length > 0) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
+      const freshUsage = await loadUsageIndex7(ctx.paths);
+      const cfg = await loadConfig3(ctx.paths);
+      const rule = {
+        minReads: cfg.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE.minReads,
+        maxRejections: DEFAULT_AUTO_PROMOTE_RULE.maxRejections
+      };
+      for (const m of memories) {
+        const loaded = byId.get(m.id);
+        if (!loaded) continue;
+        const u = getUsage5(freshUsage, m.id);
+        if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
+        const newFm = { ...loaded.memory.frontmatter, status: "validated" };
+        try {
+          await writeFile11(
+            loaded.filePath,
+            serializeMemory9({ frontmatter: newFm, body: loaded.memory.body }),
+            "utf8"
+          );
+          m.status = "validated";
+          m.confidence = "trusted";
+        } catch {
+        }
+      }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync17(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync18(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync17(ctx.paths.projectContext)) && input.include_project_context) {
-    const haiveConfig = await loadConfig2(ctx.paths);
+  if ((isTemplateContext || !existsSync18(ctx.paths.projectContext)) && input.include_project_context) {
+    const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap(ctx.paths);
       if (codeMap) {
@@ -1490,7 +1646,7 @@ ${m.content}`).join("\n\n---\n\n"),
       developer_message: quoteBlock || `Une modification externe potentiellement incompatible a \xE9t\xE9 d\xE9tect\xE9e (${m.id}). Veux-tu que j'analyse l'impact et que je propose des mises \xE0 jour ?`
     });
   }
-  if (existsSync17(ctx.paths.memoriesDir)) {
+  if (existsSync18(ctx.paths.memoriesDir)) {
     const allMems = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
@@ -1508,8 +1664,37 @@ ${m.content}`).join("\n\n---\n\n"),
       });
     }
   }
+  const pendingDistillFile = pendingDistillPath(ctx);
+  if (existsSync18(pendingDistillFile)) {
+    try {
+      const raw = await readFile3(pendingDistillFile, "utf8");
+      const pd = JSON.parse(raw);
+      const ageMs = Date.now() - new Date(pd.session_end).getTime();
+      const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1e3;
+      if (ageMs < SEVEN_DAYS) {
+        const savedNote = pd.memories_saved.length > 0 ? ` ${pd.memories_saved.length} memor${pd.memories_saved.length === 1 ? "y was" : "ies were"} saved.` : " No memories were saved.";
+        const diffNote = pd.git_diff_available ? " A git diff snapshot is available in the pending-distill file for context." : "";
+        actionRequired.push({
+          id: "__pending_distill__",
+          summary: "Previous session has undistilled learnings \u2014 invoke post_task to capture them",
+          developer_message: `The previous session (${pd.total_tool_calls} tool calls, ${pd.tool_summary}) was closed by autopilot without a full post_task distillation.${savedNote}${diffNote}
+
+**Before starting your task:** invoke the MCP prompt \`post_task\` to capture any decisions, gotchas, or conventions from that session. This takes ~30 seconds and prevents institutional knowledge from being lost.
+
+When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pending distill marker.`
+        });
+      } else {
+        try {
+          const { rm: rm2 } = await import("fs/promises");
+          await rm2(pendingDistillFile);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync17(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync18(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hints = [];
   if (isColdStart) {
@@ -1588,15 +1773,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync17(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync18(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 = path8.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync17(file)) {
+    const file = path9.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync18(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -1685,7 +1870,7 @@ function estimateFileEntryTokens(f) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
 import { z as z19 } from "zod";
 var MemDiffInputSchema = {
@@ -1693,7 +1878,7 @@ var MemDiffInputSchema = {
   id_b: z19.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync18(ctx.paths.memoriesDir)) {
+  if (!existsSync19(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
   const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
@@ -1730,7 +1915,7 @@ async function memDiff(input, ctx) {
 }
 
 // src/tools/get-recap.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
 import { z as z20 } from "zod";
 var GetRecapInputSchema = {
@@ -1739,7 +1924,7 @@ var GetRecapInputSchema = {
   )
 };
 async function getRecap(input, ctx) {
-  if (!existsSync19(ctx.paths.memoriesDir)) {
+  if (!existsSync20(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
   const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
@@ -1837,9 +2022,9 @@ async function codeSearch(input, ctx) {
 }
 
 // src/tools/why-this-file.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { spawn } from "child_process";
-import path9 from "path";
+import path10 from "path";
 import {
   deriveConfidence as deriveConfidence5,
   getUsage as getUsage6,
@@ -1857,7 +2042,7 @@ var WhyThisFileInputSchema = {
   memory_limit: z23.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync20(path9.join(ctx.paths.root, input.path));
+  const fileExists = existsSync21(path10.join(ctx.paths.root, input.path));
   const [commits, memories, codeMap] = await Promise.all([
     runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
     collectAnchoredMemories(ctx, input.path, input.memory_limit),
@@ -1898,7 +2083,7 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync20(ctx.paths.memoriesDir)) return [];
+  if (!existsSync21(ctx.paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex8(ctx.paths);
   const out = [];
@@ -1953,7 +2138,7 @@ function runCommand(cmd, args, cwd) {
 }
 
 // src/tools/anti-patterns-check.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import {
   deriveConfidence as deriveConfidence6,
   getUsage as getUsage7,
@@ -1984,7 +2169,7 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync21(ctx.paths.memoriesDir)) {
+  if (!existsSync22(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
   const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
@@ -2066,7 +2251,7 @@ async function antiPatternsCheck(input, ctx) {
 }
 
 // src/tools/mem-distill.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import {
   loadMemoriesFromDir as loadMemoriesFromDir18,
   tokenizeQuery as tokenizeQuery4
@@ -2118,7 +2303,7 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync22(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     return { scanned: 0, singletons: 0, clusters: [], notice: "No .ai/memories directory." };
   }
   const cutoff = Date.now() - input.since_days * MS_PER_DAY;
@@ -2226,7 +2411,7 @@ function firstHeading(body) {
 }
 
 // src/tools/why-this-decision.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import {
   deriveConfidence as deriveConfidence7,
@@ -2241,7 +2426,7 @@ var WhyThisDecisionInputSchema = {
   git_log_limit: z26.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync23(ctx.paths.memoriesDir)) {
+  if (!existsSync24(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -2373,7 +2558,7 @@ function runCommand2(cmd, args, cwd) {
 }
 
 // src/tools/mem-conflicts.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
   deriveConfidence as deriveConfidence8,
   getUsage as getUsage9,
@@ -2391,7 +2576,7 @@ var MemConflictsInputSchema = {
 var POSITIVE_PATTERNS = /\b(use|prefer|always|should use|do this|recommended|ok to)\b/i;
 var NEGATIVE_PATTERNS = /\b(do not use|don'?t use|never|avoid|forbidden|deprecated|stop using|do NOT|❌)\b/i;
 async function memConflicts(input, ctx) {
-  if (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync25(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
   const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
@@ -2572,13 +2757,226 @@ async function preCommitCheck(input, ctx) {
   };
 }
 
-// src/prompts/bootstrap-project.ts
+// src/tools/pattern-detect.ts
+import { mkdir as mkdir7, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync26 } from "fs";
+import path11 from "path";
+import { execSync as execSync2 } from "child_process";
+import {
+  buildFrontmatter as buildFrontmatter5,
+  memoryFilePath as memoryFilePath5,
+  readUsageEvents,
+  serializeMemory as serializeMemory10
+} from "@hiveai/core";
 import { z as z29 } from "zod";
+var CONFIG_PATTERNS = [
+  ".eslintrc",
+  "eslint.config",
+  "prettier.config",
+  ".prettierrc",
+  "tsconfig",
+  "jsconfig",
+  "vitest.config",
+  "jest.config",
+  ".env.example",
+  ".env.defaults",
+  "tailwind.config",
+  "vite.config",
+  "next.config",
+  "babel.config",
+  "postcss.config",
+  "renovate.json",
+  "dependabot.yml"
+];
+var MAX_DIFF_BYTES = 4096;
+var HOT_FILE_MIN = 3;
+var PatternDetectInputSchema = {
+  since_days: z29.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
+  dry_run: z29.boolean().default(false).describe("When true, report matches without writing any memory files."),
+  scope: z29.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
+};
+async function patternDetect(input, ctx) {
+  if (!existsSync26(ctx.paths.haiveDir)) {
+    return {
+      scanned_events: 0,
+      matches: [],
+      saved: 0,
+      saved_ids: [],
+      notice: "No .ai/ directory found. Run 'haive init' first."
+    };
+  }
+  const matches = [];
+  try {
+    const changedFiles = gitChangedFiles(ctx.paths.root, input.since_days);
+    const configFiles = changedFiles.filter(
+      (f) => CONFIG_PATTERNS.some((p) => path11.basename(f.toLowerCase()).includes(p))
+    );
+    for (const file of configFiles.slice(0, 5)) {
+      const diff = gitFileDiff(ctx.paths.root, file, input.since_days);
+      if (!diff) continue;
+      const parentDir = path11.basename(path11.dirname(file));
+      const baseName = path11.basename(file).replace(/\.[^.]+$/, "");
+      const slug = `${parentDir}-${baseName}`.replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
+      matches.push({
+        kind: "config_change",
+        signal: `Config file modified: ${file}`,
+        proposed_type: "convention",
+        proposed_slug: `config-change-${slug}`,
+        proposed_body: [
+          `# Config change: \`${file}\``,
+          "",
+          "This configuration file was recently modified. The diff below captures the intent.",
+          "Review and update this memory with the **reason** for the change if known.",
+          "",
+          "```diff",
+          diff.slice(0, MAX_DIFF_BYTES),
+          "```"
+        ].join("\n"),
+        anchor_paths: [file]
+      });
+    }
+  } catch {
+  }
+  const events = await readUsageEvents(ctx.paths);
+  const cutoff = Date.now() - input.since_days * 24 * 60 * 60 * 1e3;
+  const recent = events.filter((e) => Date.parse(e.at) >= cutoff);
+  const pathCounts = /* @__PURE__ */ new Map();
+  for (const e of recent) {
+    if (!["mem_tried", "mem_observe", "mem_save"].includes(e.tool)) continue;
+    if (!e.summary) continue;
+    const tokens = e.summary.match(/[^\s"'`,;()[\]{}]+\.[a-zA-Z]{1,6}/g) ?? [];
+    for (const t of tokens) {
+      const key = t.toLowerCase();
+      const existing = pathCounts.get(key);
+      if (existing) {
+        existing.count++;
+        existing.tools.add(e.tool);
+      } else {
+        pathCounts.set(key, { count: 1, tools: /* @__PURE__ */ new Set([e.tool]) });
+      }
+    }
+  }
+  for (const [p, { count, tools }] of pathCounts) {
+    if (count < HOT_FILE_MIN) continue;
+    const isGotchaSignal = tools.has("mem_tried") || tools.has("mem_observe");
+    if (!isGotchaSignal) continue;
+    const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
+    matches.push({
+      kind: "repeated_path",
+      signal: `Path '${p}' appears ${count}\xD7 in mem_tried/mem_observe events`,
+      proposed_type: "gotcha",
+      proposed_slug: `repeated-issue-${slug}`,
+      proposed_body: [
+        `# Recurring issue near \`${p}\``,
+        "",
+        `This file appeared ${count} times in failed-approach or observation events over the last ${input.since_days} days. Review the related attempt/gotcha memories and consolidate them into a single authoritative gotcha.`,
+        "",
+        `**Source signals:** ${[...tools].join(", ")} (${count} events)`
+      ].join("\n"),
+      anchor_paths: [p]
+    });
+  }
+  for (const [p, { count, tools }] of pathCounts) {
+    if (count < HOT_FILE_MIN) continue;
+    if (tools.has("mem_tried") || tools.has("mem_observe")) continue;
+    if (CONFIG_PATTERNS.some((cp) => path11.basename(p).includes(cp))) continue;
+    const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
+    matches.push({
+      kind: "hot_file",
+      signal: `Path '${p}' referenced ${count}\xD7 across mem_save events`,
+      proposed_type: "convention",
+      proposed_slug: `hot-file-${slug}`,
+      proposed_body: [
+        `# Frequent edits to \`${p}\``,
+        "",
+        `This file was referenced ${count} times in memory-saving events over the last ${input.since_days} days \u2014 a signal that a recurring pattern or convention applies here.`,
+        "",
+        "**Suggested action:** review recent memories anchored to this path and extract the common pattern as a named convention."
+      ].join("\n"),
+      anchor_paths: [p]
+    });
+  }
+  if (matches.length === 0) {
+    return {
+      scanned_events: recent.length,
+      matches: [],
+      saved: 0,
+      saved_ids: [],
+      notice: `No patterns detected in the last ${input.since_days} days (${recent.length} events scanned).`
+    };
+  }
+  if (input.dry_run) {
+    return { scanned_events: recent.length, matches, saved: 0, saved_ids: [] };
+  }
+  const savedIds = [];
+  for (const match of matches) {
+    try {
+      const fm = buildFrontmatter5({
+        type: match.proposed_type,
+        slug: match.proposed_slug,
+        scope: input.scope,
+        tags: ["pattern-detect", match.kind],
+        paths: match.anchor_paths,
+        status: "proposed"
+      });
+      const file = memoryFilePath5(
+        ctx.paths,
+        fm.scope === "shared" ? "team" : fm.scope,
+        fm.id,
+        void 0
+      );
+      if (existsSync26(file)) continue;
+      await mkdir7(path11.dirname(file), { recursive: true });
+      await writeFile12(
+        file,
+        serializeMemory10({ frontmatter: fm, body: match.proposed_body }),
+        "utf8"
+      );
+      savedIds.push(fm.id);
+    } catch {
+    }
+  }
+  return {
+    scanned_events: recent.length,
+    matches,
+    saved: savedIds.length,
+    saved_ids: savedIds
+  };
+}
+function gitChangedFiles(root, sinceDays) {
+  try {
+    const out = execSync2(
+      `git log --name-only --pretty="" --diff-filter=AM --since="${sinceDays} days ago"`,
+      { cwd: root, encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
+    );
+    return [...new Set(out.split("\n").map((l) => l.trim()).filter(Boolean))];
+  } catch {
+    return [];
+  }
+}
+function gitFileDiff(root, file, sinceDays) {
+  try {
+    const out = execSync2(
+      `git log -p --follow --since="${sinceDays} days ago" -- "${file}"`,
+      { cwd: root, encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
+    );
+    if (!out.trim()) return null;
+    const diffLines = out.split("\n").filter(
+      (l) => l.startsWith("+") || l.startsWith("-") || l.startsWith("@@") || l.startsWith("diff")
+    );
+    return diffLines.join("\n").slice(0, MAX_DIFF_BYTES) || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z30 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z29.string().optional().describe(
+  module: z30.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z29.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z30.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -2660,10 +3058,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z30.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z30.array(z30.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z31.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z31.array(z31.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -2731,6 +3129,8 @@ Call **\`mem_session_end\`** with:
 
 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.
 
+Calling \`mem_session_end\` also **clears the pending-distill marker** (if any), confirming that this session's learnings have been properly captured rather than left as an auto-recap skeleton.
+
 When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved."
 `;
   return {
@@ -2745,12 +3145,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z31.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z31.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z31.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z31.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z32.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z32.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z32.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z32.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -2813,80 +3213,9 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 
-// src/session-tracker.ts
-import { appendUsageEvent, loadConfig as loadConfig3 } from "@hiveai/core";
-var SessionTracker = class {
-  events = [];
-  startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  config = null;
-  ctx;
-  shutdownRegistered = false;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  async init() {
-    this.config = await loadConfig3(this.ctx.paths);
-    if (this.config.autoSessionEnd) {
-      this.registerShutdownHandler();
-    }
-  }
-  record(tool, summary) {
-    const event = { tool, at: (/* @__PURE__ */ new Date()).toISOString(), summary };
-    this.events.push(event);
-    void appendUsageEvent(this.ctx.paths, event);
-  }
-  registerShutdownHandler() {
-    if (this.shutdownRegistered) return;
-    this.shutdownRegistered = true;
-    const save = async () => {
-      const writingTools = this.events.filter(
-        (e) => ["mem_save", "mem_tried", "mem_observe", "mem_update", "bootstrap_project_save"].includes(e.tool)
-      );
-      const totalCalls = this.events.length;
-      if (totalCalls === 0) return;
-      const toolSummary = summarizeTools(this.events);
-      const filesSet = /* @__PURE__ */ new Set();
-      for (const e of this.events) {
-        if (e.summary) {
-          const matches = e.summary.match(/[^\s"',]+\.[a-zA-Z]{1,6}/g) ?? [];
-          for (const m of matches) filesSet.add(m);
-        }
-      }
-      try {
-        await memSessionEnd(
-          {
-            goal: `Auto-captured session (${totalCalls} tool call${totalCalls === 1 ? "" : "s"})`,
-            accomplished: toolSummary,
-            discoveries: writingTools.length > 0 ? `${writingTools.length} memor${writingTools.length === 1 ? "y" : "ies"} saved during this session.` : "No new memories saved this session.",
-            files_touched: [...filesSet].slice(0, 10),
-            next_steps: "",
-            scope: this.config?.defaultScope ?? "personal",
-            module: void 0
-          },
-          this.ctx
-        );
-      } catch {
-      }
-    };
-    process.once("SIGTERM", () => {
-      void save().finally(() => process.exit(0));
-    });
-    process.once("SIGINT", () => {
-      void save().finally(() => process.exit(0));
-    });
-  }
-};
-function summarizeTools(events) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    counts.set(e.tool, (counts.get(e.tool) ?? 0) + 1);
-  }
-  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([t, n]) => `${t} \xD7${n}`).join(", ");
-}
-
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.8.0";
+var SERVER_VERSION = "0.9.2";
 function jsonResult(data) {
   return {
     content: [
@@ -3531,6 +3860,37 @@ function createHaiveServer(options = {}) {
       return jsonResult(await preCommitCheck(input, context));
     }
   );
+  server.tool(
+    "pattern_detect",
+    [
+      "Heuristic memory detector \u2014 finds knowledge worth saving WITHOUT calling an LLM.",
+      "",
+      "Runs three signals over local git history and the tool-usage log:",
+      "  1. CONFIG_CHANGE \u2014 config files modified recently (tsconfig, eslint, prettier, \u2026)",
+      "     \u2192 proposes a convention memory with the git diff as body.",
+      "  2. REPEATED_PATH \u2014 same file appears \u22653\xD7 in mem_tried/mem_observe events",
+      "     \u2192 proposes a gotcha memory anchored to that path.",
+      "  3. HOT_FILE \u2014 source file referenced \u22653\xD7 in writing-tool events",
+      "     \u2192 proposes a convention memory (frequent edits = pattern emerging).",
+      "",
+      "Saves memories with status='proposed'. They feed into auto-promote (Phase 4)",
+      "or are surfaced in the next post_task distillation for LLM review.",
+      "",
+      "USE periodically (e.g. end of sprint) or trigger from post-commit hook.",
+      "",
+      "PARAMETERS:",
+      "  since_days \u2014 look-back window in days (default 7)",
+      "  dry_run    \u2014 report matches without saving (default false)",
+      "  scope      \u2014 'team' (default) | 'personal'",
+      "",
+      "RETURNS: { scanned_events, matches: [{kind, signal, proposed_type, \u2026}], saved, saved_ids }"
+    ].join("\n"),
+    PatternDetectInputSchema,
+    async (input) => {
+      tracker.record("pattern_detect", `since=${input.since_days}d/dry_run=${input.dry_run}`);
+      return jsonResult(await patternDetect(input, context));
+    }
+  );
   server.tool(
     "mem_diff",
     [
@@ -3584,9 +3944,13 @@ function createHaiveServer(options = {}) {
   );
   return { server, context, tracker };
 }
-
-// src/index.ts
-function parseArgs(argv) {
+function parseMcpCliArgs(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--version" || arg === "-V") {
+      return { versionOnly: true };
+    }
+  }
   const out = {};
   for (let i = 2; i < argv.length; i++) {
     const arg = argv[i];
@@ -3596,18 +3960,26 @@ function parseArgs(argv) {
       out.root = arg.slice("--root=".length);
     }
   }
-  return out;
+  return { root: out.root, versionOnly: false };
 }
-async function main() {
-  const { root } = parseArgs(process.argv);
-  const { server, context } = createHaiveServer({ root });
+function printHaiveMcpVersion() {
+  console.log(SERVER_VERSION);
+}
+async function runHaiveMcpStdio(options) {
+  const { server, context } = createHaiveServer({ root: options.root });
   console.error(
     `[haive-mcp] starting server v${SERVER_VERSION} (project root: ${context.paths.root})`
   );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  await server.connect(new StdioServerTransport());
+}
+
+// src/index.ts
+var parsed = parseMcpCliArgs(process.argv);
+if (parsed.versionOnly) {
+  printHaiveMcpVersion();
+  process.exit(0);
 }
-main().catch((err) => {
+runHaiveMcpStdio({ root: parsed.root }).catch((err) => {
   console.error("[haive-mcp] fatal:", err instanceof Error ? err.message : err);
   process.exit(1);
 });