@hiveai/mcp 0.4.5 → 0.5.0

package/dist/index.js

@@ -1200,6 +1200,9 @@ var GetBriefingInputSchema = {
   ),
   symbols: z17.array(z17.string()).default([]).describe(
     "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
+  ),
+  min_semantic_score: z17.number().min(0).max(1).default(0).describe(
+    "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
   )
 };
 async function getBriefing(input, ctx) {
@@ -1232,6 +1235,7 @@ async function getBriefing(input, ctx) {
       return true;
     });
     usage = await loadUsageIndex7(ctx.paths);
+    byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
     const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
     if (input.task && input.semantic) {
       searchMode = semanticHits ? "semantic" : "literal_fallback";
@@ -1296,6 +1300,10 @@ async function getBriefing(input, ctx) {
       }
       if (semanticHits) {
         for (const hit of semanticHits) {
+          if (hit.score < input.min_semantic_score) {
+            const existing = seen.get(hit.id);
+            if (!existing) continue;
+          }
           const loaded = byId.get(hit.id);
           if (loaded) addOrUpdate(loaded, "semantic", hit.score, "semantic");
         }
@@ -1309,7 +1317,6 @@ async function getBriefing(input, ctx) {
       const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
-    byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
     for (const mem of ranked.slice(0, input.max_memories)) {
       if (seen.size >= input.max_memories * 2) break;
       const loaded = byId.get(mem.id);
@@ -1501,6 +1508,36 @@ ${m.content}`).join("\n\n---\n\n"),
       });
     }
   }
+  const memoriesEmpty = outputMemories.length === 0;
+  const hasMemoriesDir = existsSync17(ctx.paths.memoriesDir);
+  const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
+  const hints = [];
+  if (isColdStart) {
+    hints.push(
+      "haive is uninitialized for this project (project-context.md is template, 0 memories, no past session). Skip future get_briefing calls until memories exist \u2014 use Read/Grep directly. Run `haive init` and the bootstrap_project prompt to fix."
+    );
+  } else {
+    if (outputMemories.some((m) => m.type === "attempt")) {
+      hints.push(
+        "\u26A0\uFE0F One or more 'attempt' memories matched \u2014 these document failed approaches. Read them BEFORE writing code to avoid repeating the mistake."
+      );
+    }
+    if (outputMemories.some((m) => m.type === "gotcha")) {
+      hints.push(
+        "Gotcha memories matched \u2014 non-obvious traps. Verify the 'how to apply' line still holds before assuming behavior."
+      );
+    }
+    if (memoriesEmpty && hasMemoriesDir && input.task) {
+      hints.push(
+        "No memories matched this task. Try mem_search with broader/different terms, or call mem_for_files with the files you intend to edit."
+      );
+    }
+    if (input.task && outputMemories.length > 0 && actionRequired.length === 0) {
+      hints.push(
+        "After completing the task: capture new gotchas with mem_observe, failed approaches with mem_tried, validated patterns with mem_save."
+      );
+    }
+  }
   return {
     ...input.task ? { task: input.task } : {},
     search_mode: searchMode,
@@ -1518,6 +1555,8 @@ ${m.content}`).join("\n\n---\n\n"),
     action_required: actionRequired,
     decay_warnings: decayWarnings,
     setup_warnings: setupWarnings,
+    ...isColdStart ? { low_value: true } : {},
+    ...hints.length > 0 ? { hints } : {},
     estimated_tokens: totalTokens,
     budget: {
       max_tokens: input.max_tokens,
@@ -1565,12 +1604,18 @@ async function loadModuleContexts2(ctx, modules) {
 }
 
 // src/tools/code-map.ts
-import { loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hiveai/core";
+import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hiveai/core";
 import { z as z18 } from "zod";
 var CodeMapInputSchema = {
   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")
+  paths: z18.array(z18.string()).default([]).describe(
+    "Filter to files under any of these path prefixes (e.g. ['packages/mcp/src/tools/', 'src/auth/']). OR-joined with `file` substring; useful to get a focused view of one module."
+  ),
+  max_files: z18.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z18.number().int().positive().optional().describe(
+    "Approximate token budget for the response. When the matching set exceeds it, files are ranked by export density (exports per LOC) and the highest-signal ones are kept first. Omit to disable budgeting (legacy behavior)."
+  )
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap2(ctx.paths);
@@ -1581,19 +1626,63 @@ async function codeMapTool(input, ctx) {
       notice: "No code map found. Run `haive index code` to generate `.ai/code-map.json`."
     };
   }
-  const { files } = queryCodeMap2(map, { file: input.file, symbol: input.symbol });
+  const { files: matched } = queryCodeMap2(map, { file: input.file, symbol: input.symbol });
+  const pathsFiltered = input.paths.length === 0 ? matched : matched.filter((f) => input.paths.some((p) => f.path.startsWith(stripLeadingSlash(p))));
+  const alphabetical = [...pathsFiltered].sort((a, b) => a.path.localeCompare(b.path));
+  let kept = alphabetical;
+  let budgetClipped = false;
+  if (input.max_tokens !== void 0) {
+    const byDensity = [...alphabetical].sort((a, b) => {
+      const da = density(a.entry.exports.length, a.entry.loc);
+      const db = density(b.entry.exports.length, b.entry.loc);
+      if (da !== db) return db - da;
+      return a.path.localeCompare(b.path);
+    });
+    const keepSet = /* @__PURE__ */ new Set();
+    let spent = 0;
+    for (const f of byDensity) {
+      const cost = estimateFileEntryTokens(f);
+      if (spent + cost > input.max_tokens && keepSet.size > 0) {
+        budgetClipped = true;
+        break;
+      }
+      keepSet.add(f.path);
+      spent += cost;
+    }
+    if (budgetClipped) {
+      kept = alphabetical.filter((f) => keepSet.has(f.path));
+    }
+  }
+  const finalFiles = kept.slice(0, input.max_files);
+  const totalDropped = pathsFiltered.length - finalFiles.length;
   return {
     available: true,
     generated_at: map.generated_at,
     total_files: Object.keys(map.files).length,
-    files: files.slice(0, input.max_files).map((f) => ({
+    files: finalFiles.map((f) => ({
       path: f.path,
       ...f.entry.summary ? { summary: f.entry.summary } : {},
       loc: f.entry.loc,
       exports: f.entry.exports
-    }))
+    })),
+    ...totalDropped > 0 ? { truncated: totalDropped } : {},
+    ...budgetClipped ? { budget_clipped: true } : {}
   };
 }
+function density(exports, loc) {
+  if (loc <= 0) return 0;
+  return exports / Math.max(loc, 1);
+}
+function stripLeadingSlash(p) {
+  return p.startsWith("/") ? p.slice(1) : p;
+}
+function estimateFileEntryTokens(f) {
+  const exportsCost = f.entry.exports.reduce(
+    (acc, e) => acc + 6 + estimateTokens2(e.description ?? ""),
+    0
+  );
+  return estimateTokens2(f.path) + estimateTokens2(f.entry.summary ?? "") + exportsCost + 4;
+}
 
 // src/tools/mem-diff.ts
 import { existsSync as existsSync18 } from "fs";
@@ -1640,13 +1729,349 @@ async function memDiff(input, ctx) {
   };
 }
 
-// src/prompts/bootstrap-project.ts
+// src/tools/get-recap.ts
+import { existsSync as existsSync19 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
 import { z as z20 } from "zod";
+var GetRecapInputSchema = {
+  scope: z20.enum(["personal", "team", "any"]).default("any").describe(
+    "Limit to a specific scope's recap. Default 'any' returns the most recent recap across both personal and team scopes."
+  )
+};
+async function getRecap(input, ctx) {
+  if (!existsSync19(ctx.paths.memoriesDir)) {
+    return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
+  }
+  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
+  const recaps = all.filter(({ memory }) => memory.frontmatter.type === "session_recap").filter(({ memory }) => input.scope === "any" || memory.frontmatter.scope === input.scope).sort(
+    (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
+  );
+  if (recaps.length === 0) {
+    return {
+      recap: null,
+      notice: input.scope === "any" ? "No session recap saved yet. Run mem_session_end (or post_task prompt) to capture one." : `No session recap found in scope '${input.scope}'.`
+    };
+  }
+  const r = recaps[0];
+  const fm = r.memory.frontmatter;
+  return {
+    recap: {
+      id: fm.id,
+      scope: fm.scope,
+      revision_count: fm.revision_count ?? 0,
+      created_at: fm.created_at,
+      body: r.memory.body
+    }
+  };
+}
+
+// src/tools/mem-relevant-to.ts
+import { z as z21 } from "zod";
+var MemRelevantToInputSchema = {
+  task: z21.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z21.array(z21.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z21.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z21.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z21.enum(["full", "compact"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies.")
+};
+async function memRelevantTo(input, ctx) {
+  const briefingInput = {
+    task: input.task,
+    files: input.files,
+    max_tokens: 16e3,
+    max_memories: input.limit,
+    include_project_context: false,
+    include_module_contexts: false,
+    semantic: true,
+    include_stale: false,
+    track: true,
+    format: input.format,
+    symbols: [],
+    min_semantic_score: input.min_semantic_score
+  };
+  const briefing = await getBriefing(briefingInput, ctx);
+  const out = {
+    task: input.task,
+    search_mode: briefing.search_mode,
+    memories: briefing.memories
+  };
+  if (briefing.hints && briefing.hints.length > 0) out.hints = briefing.hints;
+  if (briefing.memories.length === 0) out.empty = true;
+  return out;
+}
+
+// src/tools/code-search.ts
+import { z as z22 } from "zod";
+var CodeSearchInputSchema = {
+  query: z22.string().min(1).describe(
+    "Natural-language description of what you are looking for in the codebase (e.g. 'function that hashes passwords', 'JWT signing logic', 'route registration')."
+  ),
+  k: z22.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z22.number().min(0).max(1).default(0.2).describe(
+    "Minimum cosine similarity. Hits below this threshold are dropped to avoid noise. Try 0.3+ for stricter matching."
+  )
+};
+async function codeSearch(input, ctx) {
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    return {
+      available: false,
+      hits: [],
+      notice: "@hiveai/embeddings is not installed. Install it (`pnpm add @hiveai/embeddings`) and run `haive index code-search` to enable semantic code search."
+    };
+  }
+  const result = await mod.codeSemanticSearch(ctx.paths, input.query, {
+    limit: input.k,
+    minScore: input.min_score
+  });
+  if (!result) {
+    return {
+      available: false,
+      hits: [],
+      notice: "Code semantic-search index not built. Run `haive index code-search` to generate it (builds embeddings for every exported symbol in the code-map)."
+    };
+  }
+  return { available: true, hits: result.hits };
+}
+
+// src/tools/why-this-file.ts
+import { existsSync as existsSync20 } from "fs";
+import { spawn } from "child_process";
+import path9 from "path";
+import {
+  deriveConfidence as deriveConfidence5,
+  getUsage as getUsage6,
+  loadCodeMap as loadCodeMap3,
+  loadMemoriesFromDir as loadMemoriesFromDir16,
+  loadUsageIndex as loadUsageIndex8,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
+} from "@hiveai/core";
+import { z as z23 } from "zod";
+var WhyThisFileInputSchema = {
+  path: z23.string().min(1).describe(
+    "Project-relative path to the file you want context on (e.g. 'packages/mcp/src/tools/mem-save.ts')."
+  ),
+  git_log_limit: z23.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
+  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 [commits, memories, codeMap] = await Promise.all([
+    runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
+    collectAnchoredMemories(ctx, input.path, input.memory_limit),
+    loadCodeMap3(ctx.paths)
+  ]);
+  const codeMapEntry = codeMap?.files[input.path];
+  const hints = [];
+  if (!fileExists) {
+    hints.push(`File '${input.path}' does not exist on disk \u2014 path may be wrong or file removed.`);
+  }
+  if (commits.length === 0 && fileExists) {
+    hints.push("No git history found \u2014 file may be untracked or git not initialized.");
+  }
+  if (memories.length === 0 && fileExists) {
+    hints.push(
+      "No memories anchored here. If you discover something non-obvious while editing, use mem_observe (with where=" + input.path + ") to capture it."
+    );
+  }
+  if (memories.some((m) => m.type === "attempt" || m.type === "gotcha")) {
+    hints.push("\u26A0\uFE0F attempt/gotcha memories anchored to this file \u2014 read them BEFORE editing.");
+  }
+  return {
+    file: input.path,
+    exists: fileExists,
+    recent_commits: commits,
+    memories,
+    code_map_entry: codeMapEntry ? {
+      ...codeMapEntry.summary ? { summary: codeMapEntry.summary } : {},
+      loc: codeMapEntry.loc,
+      exports: codeMapEntry.exports.map((e) => ({
+        name: e.name,
+        kind: e.kind,
+        line: e.line,
+        ...e.description ? { description: e.description } : {}
+      }))
+    } : null,
+    ...hints.length > 0 ? { hints } : {}
+  };
+}
+async function collectAnchoredMemories(ctx, filePath, limit) {
+  if (!existsSync20(ctx.paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex8(ctx.paths);
+  const out = [];
+  for (const { memory } of all) {
+    const fm = memory.frontmatter;
+    if (fm.status === "rejected" || fm.status === "deprecated") continue;
+    if (fm.type === "session_recap") continue;
+    if (!memoryMatchesAnchorPaths3(memory, [filePath])) continue;
+    const u = getUsage6(usage, fm.id);
+    out.push({
+      id: fm.id,
+      type: fm.type,
+      scope: fm.scope,
+      confidence: deriveConfidence5(fm, u),
+      body_preview: memory.body.split("\n").slice(0, 6).join("\n")
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+async function runGitLog(cwd, filePath, limit) {
+  const sep = "<<HV>>";
+  const fmt = `%h${sep}%an${sep}%ar${sep}%s`;
+  const output = await runCommand(
+    "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 runCommand(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(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/anti-patterns-check.ts
+import { existsSync as existsSync21 } from "fs";
+import {
+  deriveConfidence as deriveConfidence6,
+  getUsage as getUsage7,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadUsageIndex as loadUsageIndex9,
+  literalMatchesAnyToken as literalMatchesAnyToken3,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
+  tokenizeQuery as tokenizeQuery3
+} from "@hiveai/core";
+import { z as z24 } from "zod";
+var AntiPatternsCheckInputSchema = {
+  diff: z24.string().optional().describe(
+    "Raw unified diff text (or any code/text snippet) to scan for previously documented anti-patterns. Tokens from the diff are used to match memory bodies and the embeddings index."
+  ),
+  paths: z24.array(z24.string()).default([]).describe(
+    "File paths affected by the change. Memories anchored to any of these paths are surfaced regardless of the diff content."
+  ),
+  limit: z24.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
+  semantic: z24.boolean().default(true).describe(
+    "When true, also use semantic search (requires @hiveai/embeddings + memory index) to find related anti-patterns."
+  )
+};
+async function antiPatternsCheck(input, ctx) {
+  if (!input.diff && input.paths.length === 0) {
+    return {
+      scanned: 0,
+      warnings: [],
+      notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
+    };
+  }
+  if (!existsSync21(ctx.paths.memoriesDir)) {
+    return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
+  }
+  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  const negative = all.filter(({ memory }) => {
+    const t = memory.frontmatter.type;
+    if (t !== "attempt" && t !== "gotcha") return false;
+    const s = memory.frontmatter.status;
+    return s !== "rejected" && s !== "deprecated" && s !== "stale";
+  });
+  if (negative.length === 0) {
+    return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
+  }
+  const usage = await loadUsageIndex9(ctx.paths);
+  const seen = /* @__PURE__ */ new Map();
+  const upsert = (fm, body, reason, score) => {
+    const existing = seen.get(fm.id);
+    if (existing) {
+      if (!existing.reasons.includes(reason)) existing.reasons.push(reason);
+      if (score !== void 0 && (existing.semantic_score ?? 0) < score) {
+        existing.semantic_score = score;
+      }
+      return;
+    }
+    const u = getUsage7(usage, fm.id);
+    seen.set(fm.id, {
+      id: fm.id,
+      type: fm.type,
+      scope: fm.scope,
+      confidence: deriveConfidence6(fm, u),
+      body_preview: body.split("\n").slice(0, 5).join("\n").slice(0, 400),
+      reasons: [reason],
+      ...score !== void 0 ? { semantic_score: score } : {}
+    });
+  };
+  if (input.paths.length > 0) {
+    for (const { memory } of negative) {
+      if (memoryMatchesAnchorPaths4(memory, input.paths)) {
+        upsert(memory.frontmatter, memory.body, "anchor");
+      }
+    }
+  }
+  if (input.diff) {
+    const tokens = tokenizeQuery3(input.diff);
+    if (tokens.length > 0) {
+      for (const { memory } of negative) {
+        if (literalMatchesAnyToken3(memory, tokens)) {
+          upsert(memory.frontmatter, memory.body, "literal");
+        }
+      }
+    }
+  }
+  if (input.semantic && input.diff) {
+    try {
+      const mod = await import("@hiveai/embeddings");
+      const result = await mod.semanticSearch(ctx.paths, input.diff, { limit: input.limit * 2 });
+      if (result) {
+        const negativeIds = new Set(negative.map(({ memory }) => memory.frontmatter.id));
+        for (const hit of result.hits) {
+          if (!negativeIds.has(hit.id)) continue;
+          const found = negative.find(({ memory }) => memory.frontmatter.id === hit.id);
+          if (found) upsert(found.memory.frontmatter, found.memory.body, "semantic", hit.score);
+        }
+      }
+    } catch {
+    }
+  }
+  const warnings = [...seen.values()].sort((a, b) => {
+    const score = (w) => {
+      const reasonW = (w.reasons.includes("anchor") ? 4 : 0) + (w.reasons.includes("literal") ? 2 : 0) + (w.reasons.includes("semantic") ? 1 : 0);
+      const confW = w.confidence === "authoritative" ? 3 : w.confidence === "trusted" ? 2 : w.confidence === "low" ? 1 : 0;
+      return reasonW + confW + (w.semantic_score ?? 0);
+    };
+    return score(b) - score(a);
+  }).slice(0, input.limit);
+  return {
+    scanned: negative.length,
+    warnings
+  };
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z25 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z20.string().optional().describe(
+  module: z25.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z20.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z25.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -1728,10 +2153,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z21 } from "zod";
+import { z as z26 } from "zod";
 var PostTaskArgsSchema = {
-  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")
+  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")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -1813,12 +2238,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z22 } from "zod";
+import { z as z27 } from "zod";
 var ImportDocsArgsSchema = {
-  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")
+  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")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -1882,7 +2307,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 }
 
 // src/session-tracker.ts
-import { loadConfig as loadConfig3 } from "@hiveai/core";
+import { appendUsageEvent, loadConfig as loadConfig3 } from "@hiveai/core";
 var SessionTracker = class {
   events = [];
   startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -1899,7 +2324,9 @@ var SessionTracker = class {
     }
   }
   record(tool, summary) {
-    this.events.push({ tool, at: (/* @__PURE__ */ new Date()).toISOString(), 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;
@@ -1952,7 +2379,7 @@ function summarizeTools(events) {
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.4.5";
+var SERVER_VERSION = "0.5.0";
 function jsonResult(data) {
   return {
     content: [
@@ -2161,7 +2588,10 @@ function createHaiveServer(options = {}) {
       "RETURNS: array of { id, type, scope, status, confidence, body, match_quality }"
     ].join("\n"),
     MemSearchInputSchema,
-    async (input) => jsonResult(await memSearch(input, context))
+    async (input) => {
+      tracker.record("mem_search", input.query.slice(0, 80));
+      return jsonResult(await memSearch(input, context));
+    }
   );
   server.tool(
     "mem_for_files",
@@ -2389,6 +2819,113 @@ function createHaiveServer(options = {}) {
     MemDeleteInputSchema,
     async (input) => jsonResult(await memDelete(input, context))
   );
+  server.tool(
+    "get_recap",
+    [
+      "Return ONLY the most recent session_recap. Cheaper than get_briefing when",
+      "you just want to know 'what was I doing last time?' and don't need project",
+      "context, modules, or memory ranking.",
+      "",
+      "PARAMETERS:",
+      "  scope \u2014 'personal' | 'team' | 'any' (default 'any', returns the most recent across both)",
+      "",
+      "RETURNS: { recap: { id, scope, revision_count, created_at, body } | null, notice? }"
+    ].join("\n"),
+    GetRecapInputSchema,
+    async (input) => {
+      tracker.record("get_recap", input.scope);
+      return jsonResult(await getRecap(input, context));
+    }
+  );
+  server.tool(
+    "mem_relevant_to",
+    [
+      "One-shot ranked memories for a task \u2014 use instead of get_briefing when",
+      "project context is already loaded and you only want the relevant memory layer.",
+      "",
+      "Reuses the same ranking pipeline (anchor / module / literal / semantic) but",
+      "skips project_context, modules, action_required, etc.",
+      "",
+      "PARAMETERS:",
+      "  task    \u2014 1\u20132 sentences describing what you are about to do (required)",
+      "  files   \u2014 files you'll edit (surfaces anchored memories)",
+      "  limit   \u2014 cap on returned memories (default 8)",
+      "  min_semantic_score \u2014 drop weak semantic hits below this cosine (default 0.25)",
+      "",
+      "RETURNS: { task, search_mode, memories: [...], hints?: [...], empty?: true }"
+    ].join("\n"),
+    MemRelevantToInputSchema,
+    async (input) => {
+      tracker.record("mem_relevant_to", input.task.slice(0, 80));
+      return jsonResult(await memRelevantTo(input, context));
+    }
+  );
+  server.tool(
+    "code_search",
+    [
+      "Semantic search over the codebase \u2014 finds exported symbols (functions, classes,",
+      "interfaces) related to a natural-language query. Replaces blind grep when you",
+      "don't know the exact symbol name.",
+      "",
+      "Requires `haive index code-search` to have been run (builds embeddings for every",
+      "exported symbol from the code-map). Falls back to a notice when index is missing.",
+      "",
+      "PARAMETERS:",
+      "  query     \u2014 natural language (e.g. 'function that hashes passwords', 'JWT signing')",
+      "  k         \u2014 number of top hits (default 5)",
+      "  min_score \u2014 minimum cosine similarity (default 0.2; try 0.3+ for stricter)",
+      "",
+      "RETURNS: { available: bool, hits: [{ file, name, kind, line, description?, score }] }"
+    ].join("\n"),
+    CodeSearchInputSchema,
+    async (input) => {
+      tracker.record("code_search", input.query.slice(0, 80));
+      return jsonResult(await codeSearch(input, context));
+    }
+  );
+  server.tool(
+    "why_this_file",
+    [
+      "One-shot file-context lookup: combines recent git history, memories anchored",
+      "to the path, and the code-map entry. Answers 'why is this file the way it is?'",
+      "in a single call instead of 3-4 manual ones.",
+      "",
+      "PARAMETERS:",
+      "  path           \u2014 project-relative path (required)",
+      "  git_log_limit  \u2014 recent commits to include (default 5)",
+      "  memory_limit   \u2014 anchored memories cap (default 5)",
+      "",
+      "RETURNS: { file, exists, recent_commits: [...], memories: [...], code_map_entry, hints? }"
+    ].join("\n"),
+    WhyThisFileInputSchema,
+    async (input) => {
+      tracker.record("why_this_file", input.path);
+      return jsonResult(await whyThisFile(input, context));
+    }
+  );
+  server.tool(
+    "anti_patterns_check",
+    [
+      "Scan a diff (or set of paths) against documented attempt/gotcha memories.",
+      "Surfaces 'you are about to repeat a known mistake' warnings BEFORE you commit.",
+      "",
+      "USE BEFORE finalizing a non-trivial change. Cheap and high-signal: the only",
+      "memories scanned are 'attempt' and 'gotcha' types.",
+      "",
+      "PARAMETERS:",
+      "  diff     \u2014 raw unified diff text (or any code snippet) \u2014 optional if `paths` provided",
+      "  paths    \u2014 affected file paths (optional if `diff` provided)",
+      "  limit    \u2014 cap on returned warnings (default 8)",
+      "  semantic \u2014 also use semantic search (default true; requires embeddings index)",
+      "",
+      "RETURNS: { scanned, warnings: [{ id, type, scope, confidence, body_preview, reasons, semantic_score? }] }"
+    ].join("\n"),
+    AntiPatternsCheckInputSchema,
+    async (input) => {
+      tracker.record("anti_patterns_check", input.paths.join(",").slice(0, 80));
+      return jsonResult(await antiPatternsCheck(input, context));
+    }
+  );
   server.tool(
     "mem_diff",
     [