@hiveai/mcp 0.5.0 → 0.6.0

package/dist/index.js

@@ -2065,13 +2065,520 @@ async function antiPatternsCheck(input, ctx) {
   };
 }
 
-// src/prompts/bootstrap-project.ts
+// src/tools/mem-distill.ts
+import { existsSync as existsSync22 } from "fs";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir18,
+  tokenizeQuery as tokenizeQuery4
+} from "@hiveai/core";
 import { z as z25 } from "zod";
+var MemDistillInputSchema = {
+  since_days: z25.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
+  min_cluster: z25.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
+  type_filter: z25.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
+    "Memory type to scan. 'gotcha' targets observe-style discoveries that recur, 'attempt' surfaces failed approaches that repeat, 'all' considers both."
+  ),
+  scope: z25.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
+};
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "into",
+  "when",
+  "then",
+  "also",
+  "must",
+  "have",
+  "does",
+  "not",
+  "but",
+  "you",
+  "your",
+  "its",
+  "because",
+  "why",
+  "how",
+  "what",
+  "use",
+  "using",
+  "used",
+  "add",
+  "added",
+  "make",
+  "made",
+  "fix",
+  "fixed",
+  "bug",
+  "error"
+]);
+async function memDistill(input, ctx) {
+  if (!existsSync22(ctx.paths.memoriesDir)) {
+    return { scanned: 0, singletons: 0, clusters: [], notice: "No .ai/memories directory." };
+  }
+  const cutoff = Date.now() - input.since_days * MS_PER_DAY;
+  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const candidates = all.filter(({ memory }) => {
+    const fm = memory.frontmatter;
+    if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
+    if (input.scope !== "any" && fm.scope !== input.scope) return false;
+    if (input.type_filter === "gotcha" && fm.type !== "gotcha") return false;
+    if (input.type_filter === "attempt" && fm.type !== "attempt") return false;
+    if (input.type_filter === "all" && fm.type !== "gotcha" && fm.type !== "attempt") return false;
+    if (Date.parse(fm.created_at) < cutoff) return false;
+    return true;
+  });
+  if (candidates.length < input.min_cluster) {
+    return {
+      scanned: candidates.length,
+      singletons: candidates.length,
+      clusters: [],
+      notice: candidates.length === 0 ? `No matching memories in the last ${input.since_days} days.` : `Only ${candidates.length} candidate${candidates.length === 1 ? "" : "s"} \u2014 below min_cluster=${input.min_cluster}.`
+    };
+  }
+  const features = candidates.map((loaded) => ({
+    loaded,
+    keywords: keywordSet(loaded),
+    paths: new Set(loaded.memory.frontmatter.anchor.paths)
+  }));
+  const parent = features.map((_, i) => i);
+  const find = (i) => parent[i] === i ? i : parent[i] = find(parent[i] ?? 0);
+  const union = (a, b) => {
+    const ra = find(a), rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < features.length; i++) {
+    for (let j = i + 1; j < features.length; j++) {
+      const fi = features[i], fj = features[j];
+      const pathSim = jaccard(fi.paths, fj.paths);
+      const kwSim = jaccard(fi.keywords, fj.keywords);
+      if (pathSim >= 0.5 || kwSim >= 0.4) union(i, j);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < features.length; i++) {
+    const root = find(i);
+    const arr = groups.get(root) ?? [];
+    arr.push(i);
+    groups.set(root, arr);
+  }
+  const clusters = [];
+  let singletons = 0;
+  for (const indices of groups.values()) {
+    if (indices.length < input.min_cluster) {
+      singletons += indices.length;
+      continue;
+    }
+    const members = indices.map((i) => features[i]);
+    const allPaths = /* @__PURE__ */ new Set();
+    const allKeywords = /* @__PURE__ */ new Map();
+    let latest = 0;
+    for (const m of members) {
+      for (const p of m.paths) allPaths.add(p);
+      for (const k of m.keywords) allKeywords.set(k, (allKeywords.get(k) ?? 0) + 1);
+      const t = Date.parse(m.loaded.memory.frontmatter.created_at);
+      if (t > latest) latest = t;
+    }
+    const commonKeywords = [...allKeywords.entries()].filter(([, n]) => n >= Math.max(2, Math.floor(members.length / 2))).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([k]) => k);
+    const titles = members.map((m) => firstHeading(m.loaded.memory.body) ?? m.loaded.memory.frontmatter.id).slice(0, 5);
+    const suggestedType = members.every((m) => m.loaded.memory.frontmatter.type === "attempt") ? "gotcha" : "convention";
+    clusters.push({
+      suggested_topic: commonKeywords.slice(0, 3).join("-") || "merged-observations",
+      suggested_type: suggestedType,
+      member_ids: members.map((m) => m.loaded.memory.frontmatter.id),
+      overlapping_paths: [...allPaths].slice(0, 10),
+      common_keywords: commonKeywords,
+      sample_titles: titles,
+      latest_at: new Date(latest).toISOString()
+    });
+  }
+  clusters.sort((a, b) => b.member_ids.length - a.member_ids.length);
+  return {
+    scanned: candidates.length,
+    singletons,
+    clusters
+  };
+}
+function keywordSet(loaded) {
+  const text = (loaded.memory.body + " " + loaded.memory.frontmatter.tags.join(" ")).slice(0, 800);
+  const tokens = tokenizeQuery4(text).filter((t) => t.length >= 4 && !STOP_WORDS.has(t));
+  return new Set(tokens);
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersect = 0;
+  for (const x of a) if (b.has(x)) intersect++;
+  const union = a.size + b.size - intersect;
+  return union === 0 ? 0 : intersect / union;
+}
+function firstHeading(body) {
+  for (const line of body.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("#")) return t.replace(/^#+\s*/, "").slice(0, 80);
+    if (t.length > 0) return t.slice(0, 80);
+  }
+  return void 0;
+}
+
+// src/tools/why-this-decision.ts
+import { existsSync as existsSync23 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import {
+  deriveConfidence as deriveConfidence7,
+  getUsage as getUsage8,
+  loadMemoriesFromDir as loadMemoriesFromDir19,
+  loadUsageIndex as loadUsageIndex10,
+  pathsOverlap as singlePathsOverlap
+} from "@hiveai/core";
+import { z as z26 } from "zod";
+var WhyThisDecisionInputSchema = {
+  id: z26.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
+  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)) {
+    return {
+      found: false,
+      related: [],
+      path_neighbors: [],
+      recent_commits: [],
+      notice: "No .ai/memories directory."
+    };
+  }
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex10(ctx.paths);
+  const target = all.find(({ memory }) => memory.frontmatter.id === input.id);
+  if (!target) {
+    return {
+      found: false,
+      related: [],
+      path_neighbors: [],
+      recent_commits: [],
+      notice: `Memory '${input.id}' not found.`
+    };
+  }
+  const fm = target.memory.frontmatter;
+  const targetUsage = getUsage8(usage, fm.id);
+  const decision = {
+    id: fm.id,
+    type: fm.type,
+    scope: fm.scope,
+    status: fm.status,
+    confidence: deriveConfidence7(fm, targetUsage),
+    body: target.memory.body,
+    created_at: fm.created_at
+  };
+  const relatedSet = new Set(fm.related_ids ?? []);
+  const related = [];
+  for (const { memory } of all) {
+    if (memory.frontmatter.id === fm.id) continue;
+    const isExplicit = relatedSet.has(memory.frontmatter.id);
+    const isBackLink = (memory.frontmatter.related_ids ?? []).includes(fm.id);
+    if (!isExplicit && !isBackLink) continue;
+    const u = getUsage8(usage, memory.frontmatter.id);
+    related.push({
+      id: memory.frontmatter.id,
+      type: memory.frontmatter.type,
+      scope: memory.frontmatter.scope,
+      confidence: deriveConfidence7(memory.frontmatter, u),
+      body_preview: memory.body.split("\n").slice(0, 4).join("\n").slice(0, 300),
+      relation: isExplicit ? "explicit" : "back-link"
+    });
+  }
+  const targetPaths = fm.anchor.paths;
+  const path_neighbors = [];
+  if (targetPaths.length > 0) {
+    for (const { memory } of all) {
+      if (memory.frontmatter.id === fm.id) continue;
+      if (relatedSet.has(memory.frontmatter.id)) continue;
+      const overlappingPaths = memory.frontmatter.anchor.paths.filter(
+        (p) => targetPaths.some((tp) => singlePathsOverlap(p, tp))
+      );
+      if (overlappingPaths.length === 0) continue;
+      const u = getUsage8(usage, memory.frontmatter.id);
+      path_neighbors.push({
+        id: memory.frontmatter.id,
+        type: memory.frontmatter.type,
+        scope: memory.frontmatter.scope,
+        confidence: deriveConfidence7(memory.frontmatter, u),
+        overlap: overlappingPaths,
+        body_preview: memory.body.split("\n").slice(0, 3).join("\n").slice(0, 200)
+      });
+      if (path_neighbors.length >= 10) break;
+    }
+  }
+  const recent_commits = [];
+  for (const p of targetPaths.slice(0, 5)) {
+    try {
+      const commits = await runGitLog2(ctx.paths.root, p, input.git_log_limit);
+      for (const c of commits) recent_commits.push({ path: p, ...c });
+    } catch {
+    }
+  }
+  const hints = [];
+  if (decision.confidence === "low" || decision.confidence === "stale") {
+    hints.push(`\u26A0\uFE0F Confidence is ${decision.confidence}. Verify this decision still applies before quoting it.`);
+  }
+  if (related.length === 0 && path_neighbors.length === 0 && targetPaths.length === 0) {
+    hints.push("No related memories and no anchored paths \u2014 this decision is isolated; consider adding related_ids or paths.");
+  }
+  if (fm.type !== "decision" && fm.type !== "architecture") {
+    hints.push(`Memory type is '${fm.type}', not 'decision'/'architecture' \u2014 output may be less informative.`);
+  }
+  return {
+    found: true,
+    decision,
+    related,
+    path_neighbors,
+    recent_commits,
+    ...hints.length > 0 ? { hints } : {}
+  };
+}
+async function runGitLog2(cwd, filePath, limit) {
+  const sep = "<<HV>>";
+  const fmt = `%h${sep}%an${sep}%ar${sep}%s`;
+  const output = await runCommand2(
+    "git",
+    ["log", "-n", String(limit), `--pretty=format:${fmt}`, "--", filePath],
+    cwd
+  );
+  if (!output.trim()) return [];
+  return output.split("\n").map((line) => {
+    const [sha = "", author = "", relative_date = "", subject = ""] = line.split(sep);
+    return { sha, author, relative_date, subject };
+  }).filter((c) => c.sha);
+}
+function runCommand2(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `${cmd} exited with code ${code}`));
+    });
+  });
+}
+
+// src/tools/mem-conflicts.ts
+import { existsSync as existsSync24 } from "fs";
+import {
+  deriveConfidence as deriveConfidence8,
+  getUsage as getUsage9,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
+  loadUsageIndex as loadUsageIndex11,
+  pathsOverlap,
+  tokenizeQuery as tokenizeQuery5
+} from "@hiveai/core";
+import { z as z27 } from "zod";
+var MemConflictsInputSchema = {
+  id: z27.string().min(1).describe("Memory id to check for conflicts."),
+  min_score: z27.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
+  semantic: z27.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
+};
+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)) {
+    return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
+  }
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const target = all.find(({ memory }) => memory.frontmatter.id === input.id);
+  if (!target) {
+    return { found: false, scanned: 0, conflicts: [], notice: `Memory '${input.id}' not found.` };
+  }
+  const usage = await loadUsageIndex11(ctx.paths);
+  const others = all.filter(
+    ({ memory }) => memory.frontmatter.id !== input.id && memory.frontmatter.type !== "session_recap"
+  );
+  const simScores = input.semantic ? await trySemanticSimilarities(ctx, target, others) : null;
+  const targetText = (target.memory.body + " " + target.memory.frontmatter.tags.join(" ")).toLowerCase();
+  const targetTokens = new Set(tokenizeQuery5(targetText));
+  const targetPolarity = polarity(targetText);
+  const targetPaths = target.memory.frontmatter.anchor.paths;
+  const explicitContradicts = extractContradictsTags(target.memory.body);
+  const conflicts = [];
+  for (const other of others) {
+    const fm = other.memory.frontmatter;
+    const otherText = (other.memory.body + " " + fm.tags.join(" ")).toLowerCase();
+    const reasons = [];
+    const sim = simScores?.get(fm.id) ?? null;
+    const hasPathOverlap = fm.anchor.paths.some((p) => targetPaths.some((tp) => pathsOverlap(p, tp)));
+    const otherTokens = new Set(tokenizeQuery5(otherText));
+    const tokenOverlap = countIntersection(targetTokens, otherTokens);
+    const isSemanticNeighbor = sim !== null && sim >= input.min_score;
+    if (!hasPathOverlap && tokenOverlap < 4 && !isSemanticNeighbor) continue;
+    const otherContradicts = extractContradictsTags(other.memory.body);
+    if (explicitContradicts.has(fm.id) || otherContradicts.has(input.id)) {
+      reasons.push("explicit-contradiction-tag");
+    }
+    if (target.memory.frontmatter.status === "validated" && fm.status === "rejected" || target.memory.frontmatter.status === "rejected" && fm.status === "validated") {
+      if (tokenOverlap >= 4 || isSemanticNeighbor) reasons.push("opposite-status");
+    }
+    if (hasPathOverlap) {
+      const tType = target.memory.frontmatter.type;
+      const oType = fm.type;
+      const isAttemptVsRule = tType === "attempt" && (oType === "convention" || oType === "decision") || oType === "attempt" && (tType === "convention" || tType === "decision");
+      if (isAttemptVsRule) reasons.push("attempt-vs-convention-same-paths");
+    }
+    if (isSemanticNeighbor) {
+      const otherPolarity = polarity(otherText);
+      if (targetPolarity === "positive" && otherPolarity === "negative" || targetPolarity === "negative" && otherPolarity === "positive") {
+        reasons.push("polarity-keywords");
+      }
+    }
+    if (reasons.length === 0) continue;
+    const u = getUsage9(usage, fm.id);
+    conflicts.push({
+      id: fm.id,
+      type: fm.type,
+      scope: fm.scope,
+      status: fm.status,
+      confidence: deriveConfidence8(fm, u),
+      body_preview: other.memory.body.split("\n").slice(0, 4).join("\n").slice(0, 300),
+      similarity: sim,
+      reasons,
+      shared_paths: fm.anchor.paths.filter((p) => targetPaths.some((tp) => pathsOverlap(p, tp)))
+    });
+  }
+  conflicts.sort((a, b) => {
+    const score = (c) => (c.reasons.includes("explicit-contradiction-tag") ? 100 : 0) + (c.reasons.includes("opposite-status") ? 50 : 0) + (c.reasons.includes("attempt-vs-convention-same-paths") ? 25 : 0) + (c.reasons.includes("polarity-keywords") ? 10 : 0) + (c.similarity ?? 0) * 5;
+    return score(b) - score(a);
+  });
+  return {
+    found: true,
+    target: {
+      id: target.memory.frontmatter.id,
+      type: target.memory.frontmatter.type,
+      status: target.memory.frontmatter.status
+    },
+    scanned: others.length,
+    conflicts: conflicts.slice(0, 10)
+  };
+}
+function polarity(text) {
+  const neg = NEGATIVE_PATTERNS.test(text);
+  const pos = POSITIVE_PATTERNS.test(text);
+  if (neg && !pos) return "negative";
+  if (pos && !neg) return "positive";
+  return "neutral";
+}
+function extractContradictsTags(body) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of body.matchAll(/#contradicts:([\w-]+)/g)) {
+    if (m[1]) out.add(m[1]);
+  }
+  return out;
+}
+function countIntersection(a, b) {
+  let n = 0;
+  for (const x of a) if (b.has(x)) n++;
+  return n;
+}
+async function trySemanticSimilarities(ctx, target, others) {
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    return null;
+  }
+  const result = await mod.semanticSearch(
+    ctx.paths,
+    target.memory.body,
+    { limit: others.length }
+  );
+  if (!result) return null;
+  const map = /* @__PURE__ */ new Map();
+  for (const hit of result.hits) map.set(hit.id, hit.score);
+  return map;
+}
+
+// src/tools/precommit-check.ts
+import { z as z28 } from "zod";
+var PreCommitCheckInputSchema = {
+  diff: z28.string().optional().describe(
+    "Raw unified diff text to scan. If omitted, only `paths` is used. When called from a pre-commit hook, pipe the output of `git diff --cached`."
+  ),
+  paths: z28.array(z28.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z28.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
+    "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
+  ),
+  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index).")
+};
+async function preCommitCheck(input, ctx) {
+  if (!input.diff && input.paths.length === 0) {
+    return {
+      should_block: false,
+      summary: { anti_patterns: 0, relevant_memories: 0, stale_anchors: 0 },
+      warnings: [],
+      relevant_memories: [],
+      stale_anchors: [],
+      notice: "Nothing to check \u2014 provide either `diff` or `paths`."
+    };
+  }
+  const apResult = await antiPatternsCheck({
+    diff: input.diff,
+    paths: input.paths,
+    limit: 20,
+    semantic: input.semantic
+  }, ctx);
+  const relevant = input.paths.length > 0 ? await memForFiles({ files: input.paths, include_module_contexts: false, track: false }, ctx) : { by_anchor: [], by_module: [], by_domain: [], module_contexts: [], inferred_modules: [] };
+  const relevantMatches = [...relevant.by_anchor, ...relevant.by_module];
+  const verifyResult = input.paths.length > 0 ? await memVerify({ update: false, id: void 0 }, ctx) : { results: [], summary: { checked: 0, fresh: 0, stale: 0, anchorless_skipped: 0, updated: 0 } };
+  const filesTouching = new Set(relevantMatches.map((m) => m.id));
+  const staleHits = verifyResult.results.filter((r) => r.stale && filesTouching.has(r.id));
+  const blockOn = input.block_on;
+  let should_block = false;
+  if (blockOn !== "never") {
+    const high = apResult.warnings.filter(
+      (w) => w.confidence === "authoritative" || w.confidence === "trusted"
+    );
+    if (blockOn === "any" && (apResult.warnings.length > 0 || staleHits.length > 0)) should_block = true;
+    if (blockOn === "high-confidence" && (high.length > 0 || staleHits.length > 0)) should_block = true;
+  }
+  const relevant_memories = relevantMatches.slice(0, 8).map((m) => ({
+    id: m.id,
+    type: m.type,
+    confidence: String(m.confidence),
+    body_preview: (m.body ?? "").split("\n").slice(0, 4).join("\n").slice(0, 250)
+  }));
+  return {
+    should_block,
+    summary: {
+      anti_patterns: apResult.warnings.length,
+      relevant_memories: relevant_memories.length,
+      stale_anchors: staleHits.length
+    },
+    warnings: apResult.warnings,
+    relevant_memories,
+    stale_anchors: staleHits.map((r) => ({
+      id: r.id,
+      // The matching `relevantMatches` entry tells us which paths overlap.
+      paths: relevantMatches.find((m) => m.id === r.id) ? input.paths.filter((p) => relevantMatches.some((m) => m.id === r.id)) : [],
+      body_preview: r.reason ?? "anchored code drifted; verify before relying on this memory"
+    }))
+  };
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z29 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z25.string().optional().describe(
+  module: z29.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z25.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z29.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -2153,10 +2660,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z26 } from "zod";
+import { z as z30 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z26.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z26.array(z26.string()).optional().describe("Files you created or modified during the task")
+  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")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -2238,12 +2745,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z27 } from "zod";
+import { z as z31 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z27.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z27.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z27.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z27.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  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")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -2379,7 +2886,7 @@ function summarizeTools(events) {
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.5.0";
+var SERVER_VERSION = "0.6.0";
 function jsonResult(data) {
   return {
     content: [
@@ -2926,6 +3433,104 @@ function createHaiveServer(options = {}) {
       return jsonResult(await antiPatternsCheck(input, context));
     }
   );
+  server.tool(
+    "mem_distill",
+    [
+      "Cluster recurring observations / failed attempts so a human can collapse",
+      "N similar memories into one richer convention/gotcha. Cheap heuristic",
+      "(anchor path overlap + body keyword overlap) \u2014 no embeddings required.",
+      "",
+      "USE periodically (e.g. monthly) to prevent memory pollution from agents",
+      "saving the same observation many times.",
+      "",
+      "PARAMETERS:",
+      "  since_days   \u2014 only consider memories from the last N days (default 30)",
+      "  min_cluster  \u2014 minimum cluster size to surface (default 3)",
+      "  type_filter  \u2014 'gotcha' | 'attempt' | 'all' (default 'gotcha')",
+      "  scope        \u2014 'personal' | 'team' | 'module' | 'any' (default 'any')",
+      "",
+      "RETURNS: { scanned, singletons, clusters: [{ suggested_topic, member_ids, ... }] }",
+      "Output is advisory \u2014 nothing is written to disk."
+    ].join("\n"),
+    MemDistillInputSchema,
+    async (input) => {
+      tracker.record("mem_distill", `${input.type_filter}/since=${input.since_days}d`);
+      return jsonResult(await memDistill(input, context));
+    }
+  );
+  server.tool(
+    "why_this_decision",
+    [
+      "Trace the genealogy of a memory (especially decision/architecture):",
+      "the memory itself + memories explicitly linked via related_ids + memories",
+      "anchored to overlapping paths + recent commits touching those paths.",
+      "",
+      "USE WHEN you find a memory and need to understand WHY it was made and",
+      "what surrounds it. One call instead of 4-5 manual lookups.",
+      "",
+      "PARAMETERS:",
+      "  id            \u2014 memory id (required)",
+      "  git_log_limit \u2014 how many recent commits per anchor path (default 5)",
+      "",
+      "RETURNS: { decision, related: [...], path_neighbors: [...], recent_commits: [...] }"
+    ].join("\n"),
+    WhyThisDecisionInputSchema,
+    async (input) => {
+      tracker.record("why_this_decision", input.id);
+      return jsonResult(await whyThisDecision(input, context));
+    }
+  );
+  server.tool(
+    "mem_conflicts_with",
+    [
+      "Detect memories that potentially CONTRADICT a given memory.",
+      "",
+      "USE BEFORE relying on a memory's advice \u2014 surfaces 'another memory says",
+      "the opposite'. Detection uses several heuristics layered together:",
+      "",
+      "  1. Opposite status \u2014 validated vs rejected on overlapping topic",
+      "  2. attempt-vs-convention on overlapping anchor paths",
+      "  3. Polarity keywords \u2014 'use X' vs 'do not use X' among semantic neighbors",
+      "  4. Explicit #contradicts:<id> tags in either body",
+      "",
+      "PARAMETERS:",
+      "  id        \u2014 memory id to check (required)",
+      "  min_score \u2014 minimum cosine similarity for semantic neighbors (default 0.5)",
+      "  semantic  \u2014 use embeddings (default true)",
+      "",
+      "RETURNS: { found, target, scanned, conflicts: [{ id, reasons, similarity, ... }] }"
+    ].join("\n"),
+    MemConflictsInputSchema,
+    async (input) => {
+      tracker.record("mem_conflicts_with", input.id);
+      return jsonResult(await memConflicts(input, context));
+    }
+  );
+  server.tool(
+    "pre_commit_check",
+    [
+      "One-shot 'should I block this commit?' check. Combines three signals:",
+      "",
+      "  1. anti_patterns_check \u2014 known gotchas/attempts that match the diff",
+      "  2. mem_for_files       \u2014 conventions/decisions anchored to touched files",
+      "  3. mem_verify          \u2014 memories whose anchors are stale (knowledge may be wrong)",
+      "",
+      "USE FROM A GIT HOOK or before finalizing a non-trivial change.",
+      "",
+      "PARAMETERS:",
+      "  diff       \u2014 raw unified diff text (e.g. `git diff --cached`)",
+      "  paths      \u2014 affected file paths (project-relative)",
+      "  block_on   \u2014 'any' | 'high-confidence' (default) | 'never'",
+      "  semantic   \u2014 use embeddings in anti_patterns_check (default true)",
+      "",
+      "RETURNS: { should_block, summary, warnings, relevant_memories, stale_anchors }"
+    ].join("\n"),
+    PreCommitCheckInputSchema,
+    async (input) => {
+      tracker.record("pre_commit_check", `${input.paths.length}p`);
+      return jsonResult(await preCommitCheck(input, context));
+    }
+  );
   server.tool(
     "mem_diff",
     [