@hiveai/mcp 0.9.2 → 0.9.5

package/dist/server.js

@@ -155,6 +155,30 @@ var MemSaveInputSchema = {
 function bodyHash(body) {
   return createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
 }
+var WORD_RE = /\b[a-z0-9]{3,}\b/gi;
+function bodyTokenSet(body) {
+  const raw = body.toLowerCase().match(WORD_RE) ?? [];
+  return new Set(raw);
+}
+function maxBodySimilarity(incomingTokens, memories, scope, type, excludeIds) {
+  if (incomingTokens.size < 6) return null;
+  let best = null;
+  const skip = excludeIds ?? /* @__PURE__ */ new Set();
+  for (const { memory } of memories) {
+    const fm = memory.frontmatter;
+    if (skip.has(fm.id)) continue;
+    if (fm.scope !== scope || fm.type !== type) continue;
+    if (fm.status === "rejected" || fm.status === "deprecated") continue;
+    const other = bodyTokenSet(memory.body);
+    if (other.size === 0) continue;
+    let inter = 0;
+    for (const t of incomingTokens) if (other.has(t)) inter++;
+    const uni = incomingTokens.size + other.size - inter;
+    const j = uni === 0 ? 0 : inter / uni;
+    if (j >= 0.72 && (!best || j > best.score)) best = { score: j, id: fm.id };
+  }
+  return best;
+}
 async function memSave(input, ctx) {
   if (!existsSync4(ctx.paths.haiveDir)) {
     throw new Error(
@@ -176,12 +200,26 @@ async function memSave(input, ctx) {
       `Duplicate content detected \u2014 identical body already saved as "${hashDuplicate.memory.frontmatter.id}". Use mem_update to modify it, or change the body to add new information.`
     );
   }
+  const incomingTokens = bodyTokenSet(input.body);
+  function bodySimilarWarnings(excludeIds) {
+    const dup = maxBodySimilarity(incomingTokens, existing, resolvedScope, input.type, excludeIds);
+    if (!dup?.id) return {};
+    const body_similar = {
+      id: dup.id,
+      score: Math.round(dup.score * 100) / 100
+    };
+    return {
+      similarityWarning: `Body is ~${Math.round(dup.score * 100)}% similar (token overlap) to existing "${dup.id}" \u2014 consolidate if redundant.`,
+      body_similar
+    };
+  }
   if (input.topic) {
     const topicMatch = existing.find(
       ({ memory }) => memory.frontmatter.topic === input.topic && memory.frontmatter.scope === resolvedScope && (!input.module || memory.frontmatter.module === input.module)
     );
     if (topicMatch) {
       const fm = topicMatch.memory.frontmatter;
+      const { similarityWarning: simW, body_similar: bs } = bodySimilarWarnings(/* @__PURE__ */ new Set([fm.id]));
       const newFrontmatter = {
         ...fm,
         body: input.body,
@@ -198,13 +236,19 @@ async function memSave(input, ctx) {
         serializeMemory({ frontmatter: newFrontmatter, body: input.body }),
         "utf8"
       );
+      const mergedTw = [
+        invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by haive sync.` : null,
+        simW ?? null
+      ].filter(Boolean).join(" \u2014 ") || void 0;
       return {
         id: fm.id,
         scope: fm.scope,
         file_path: topicMatch.filePath,
         action: "updated",
         revision_count: newFrontmatter.revision_count,
-        ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths, warning: `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by haive sync.` } : {}
+        ...mergedTw ? { warning: mergedTw } : {},
+        ...bs ? { body_similar: bs } : {},
+        ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths } : {}
       };
     }
   }
@@ -246,9 +290,11 @@ async function memSave(input, ctx) {
     }
   }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
+  const { similarityWarning: simWarnNew, body_similar: bsNew } = bodySimilarWarnings();
   const finalWarning = [
     invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by \`haive sync\`.` : null,
-    warning ?? null
+    warning ?? null,
+    simWarnNew ?? null
   ].filter(Boolean).join(" \u2014 ") || void 0;
   return {
     id: frontmatter.id,
@@ -257,6 +303,7 @@ async function memSave(input, ctx) {
     action: "created",
     ...finalWarning ? { warning: finalWarning } : {},
     ...similar_found ? { similar_found } : {},
+    ...bsNew ? { body_similar: bsNew } : {},
     ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths } : {}
   };
 }
@@ -272,6 +319,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir3,
   loadUsageIndex,
   pickSnippetNeedle,
+  rankMemoriesLexical,
   tokenizeQuery,
   trackReads
 } from "@hiveai/core";
@@ -288,6 +336,9 @@ var MemSearchInputSchema = {
   semantic: z5.boolean().default(false).describe(
     "Use semantic similarity from the embeddings index (requires `haive embeddings index`)."
   ),
+  lexical_rank: z5.boolean().default(false).describe(
+    "When true (and semantic is false), rank the filtered corpus with Okapi-BM25-style lexical scoring instead of literal AND/OR. Helps phrase-like queries without embeddings."
+  ),
   min_score: z5.number().min(0).max(1).default(0).describe("Minimum cosine similarity (semantic mode only)"),
   track: z5.boolean().default(true).describe("Increment read_count on returned memories (used for passive validation)")
 };
@@ -313,6 +364,27 @@ async function memSearch(input, ctx) {
         notice: "Semantic search unavailable (embeddings index missing or @hiveai/embeddings not installed). Falling back to literal search."
       };
     }
+  } else if (input.lexical_rank && input.query.trim()) {
+    const { ranked, scores } = rankMemoriesLexical(
+      filtered,
+      input.query,
+      input.limit
+    );
+    if (ranked.length > 0) {
+      const snippetNeedle = pickSnippetNeedle(input.query);
+      result = {
+        matches: ranked.map(
+          (loaded, i) => lexicalHit(loaded, snippetNeedle, usage, scores[i])
+        ),
+        total: ranked.length,
+        mode: "lexical_ranked"
+      };
+    } else {
+      result = {
+        ...buildLiteralResult(input, filtered, usage),
+        notice: "Lexical ranking found no BM25-positive hits \u2014 showing literal matches instead."
+      };
+    }
   } else {
     result = buildLiteralResult(input, filtered, usage);
   }
@@ -410,6 +482,9 @@ function toHit(loaded, needle, usage) {
     file_path: loaded.filePath
   };
 }
+function lexicalHit(loaded, needle, usage, lexicalScore) {
+  return { ...toHit(loaded, needle, usage), score: lexicalScore };
+}
 
 // src/tools/mem-verify.ts
 import { writeFile as writeFile3 } from "fs/promises";
@@ -1292,6 +1367,7 @@ import {
   DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
+  extractActionsBriefBody,
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
   isAutoPromoteEligible,
@@ -1304,6 +1380,7 @@ import {
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   queryCodeMap,
+  resolveBriefingBudget,
   serializeMemory as serializeMemory9,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
@@ -1326,17 +1403,29 @@ var GetBriefingInputSchema = {
   ),
   include_stale: z17.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
   track: z17.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z17.enum(["full", "compact"]).default("full").describe(
-    "Output format: 'full' returns complete memory bodies; 'compact' returns id + 1-line summary only (call mem_get for details)."
+  format: z17.enum(["full", "compact", "actions"]).default("full").describe(
+    "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
   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."
+  ),
+  budget_preset: z17.enum(["quick", "balanced", "deep"]).optional().describe(
+    "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
+var GetBriefingZod = z17.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
+  const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
+    max_tokens: input.max_tokens,
+    max_memories: input.max_memories,
+    include_module_contexts: input.include_module_contexts
+  });
+  const briefingMaxTokens = resolvedBudget.max_tokens;
+  const briefingMaxMemories = resolvedBudget.max_memories;
+  const briefingIncludeModules = resolvedBudget.include_module_contexts;
   const inferred = inferModulesFromPaths2(input.files);
   const memories = [];
   let searchMode = "literal";
@@ -1448,8 +1537,8 @@ async function getBriefing(input, ctx) {
       const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
-    for (const mem of ranked.slice(0, input.max_memories)) {
-      if (seen.size >= input.max_memories * 2) break;
+    for (const mem of ranked.slice(0, briefingMaxMemories)) {
+      if (seen.size >= briefingMaxMemories * 2) break;
       const loaded = byId.get(mem.id);
       if (!loaded) continue;
       for (const relId of loaded.memory.frontmatter.related_ids ?? []) {
@@ -1458,7 +1547,7 @@ async function getBriefing(input, ctx) {
         if (related) addOrUpdate(related, "anchor", void 0, "partial");
       }
     }
-    memories.push(...ranked.slice(0, input.max_memories));
+    memories.push(...ranked.slice(0, briefingMaxMemories));
     if (input.track && memories.length > 0) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
       const freshUsage = await loadUsageIndex7(ctx.paths);
@@ -1538,7 +1627,7 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
+  const moduleContents = briefingIncludeModules ? await loadModuleContexts2(ctx, inferred) : [];
   const memoriesText = memories.map((m) => {
     const unverified = m.status === "proposed" ? " [UNVERIFIED \u2014 not yet validated]" : "";
     return `### ${m.id} (${m.scope}/${m.type}, ${m.confidence})${unverified}
@@ -1556,7 +1645,7 @@ ${m.content}`).join("\n\n---\n\n"),
       },
       { key: "memories", text: memoriesText, weight: 4, mode: "head" }
     ],
-    input.max_tokens
+    briefingMaxTokens
   );
   const projectSlice = slices.find((s) => s.key === "project");
   const modulesSlice = slices.find((s) => s.key === "modules");
@@ -1598,7 +1687,10 @@ ${m.content}`).join("\n\n---\n\n"),
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
   }
-  const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : trimmedMemories;
+  const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({
+    ...m,
+    body: extractActionsBriefBody(m.body)
+  })) : trimmedMemories;
   let symbolLocations;
   const symbolsToLookup = new Set(input.symbols);
   for (const m of outputMemories) {
@@ -1720,6 +1812,11 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
         "After completing the task: capture new gotchas with mem_observe, failed approaches with mem_tried, validated patterns with mem_save."
       );
     }
+    if (outputMemories.length > 2 && !input.budget_preset && input.task && !hints.some((h) => h.includes("budget_preset"))) {
+      hints.push(
+        "For tighter token budgets on small tasks pass budget_preset:'quick'; for refactor-sized work use budget_preset:'deep'."
+      );
+    }
   }
   return {
     ...input.task ? { task: input.task } : {},
@@ -1742,7 +1839,8 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     ...hints.length > 0 ? { hints } : {},
     estimated_tokens: totalTokens,
     budget: {
-      max_tokens: input.max_tokens,
+      max_tokens: briefingMaxTokens,
+      ...input.budget_preset ? { preset_applied: input.budget_preset } : {},
       spent: {
         project: projectSlice.estimatedTokens,
         modules: modulesSlice.estimatedTokens,
@@ -1955,7 +2053,7 @@ var MemRelevantToInputSchema = {
   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.")
+  format: z21.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -2968,13 +3066,96 @@ function gitFileDiff(root, file, sinceDays) {
   }
 }
 
-// src/prompts/bootstrap-project.ts
+// src/tools/mem-conflict-candidates.ts
+import { existsSync as existsSync27 } from "fs";
+import { findLexicalConflictPairs, loadMemoriesFromDir as loadMemoriesFromDir21 } from "@hiveai/core";
 import { z as z30 } from "zod";
+var MemConflictCandidatesInputSchema = {
+  since_days: z30.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z30.array(z30.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z30.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z30.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort.")
+};
+async function memConflictCandidates(input, ctx) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
+    return {
+      pairs: [],
+      scanned: 0,
+      truncated: false,
+      notice: "No .ai/memories directory."
+    };
+  }
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
+    sinceDays: input.since_days,
+    types: input.types,
+    minJaccard: input.min_jaccard,
+    maxPairs: input.max_pairs,
+    maxScan: input.max_scan
+  });
+  const notice = pairs.length === 0 ? "No lexical candidate pairs \u2265 threshold \u2014 try lowering min_jaccard or widen since_days/types." : void 0;
+  return { pairs, scanned, truncated, notice };
+}
+
+// src/tools/mem-resolve-project.ts
+import { resolveProjectInfo } from "@hiveai/core";
+import { z as z31 } from "zod";
+var MemResolveProjectInputSchema = {
+  cwd: z31.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+};
+async function memResolveProject(input, _ctx) {
+  void _ctx;
+  return {
+    ok: true,
+    info: resolveProjectInfo({
+      cwd: input.cwd
+    })
+  };
+}
+
+// src/tools/mem-suggest-topic.ts
+import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
+import { z as z32 } from "zod";
+var MemSuggestTopicInputSchema = {
+  type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
+  title: z32.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+};
+async function memSuggestTopic(input, _ctx) {
+  void _ctx;
+  const suggestion = suggestTopicKey(input.type, input.title);
+  return { topic_key: suggestion.topic_key, family: suggestion.family, type: input.type };
+}
+
+// src/tools/mem-timeline.ts
+import { existsSync as existsSync28 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir22 } from "@hiveai/core";
+import { z as z33 } from "zod";
+var MemTimelineInputSchema = {
+  memory_id: z33.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z33.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z33.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+};
+async function memTimeline(input, ctx) {
+  if (!existsSync28(ctx.paths.memoriesDir)) {
+    return { entries: [], total: 0, notice: "No .ai/memories directory." };
+  }
+  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
+  const { entries, notice } = collectTimelineEntries(all, {
+    memoryId: input.memory_id,
+    topic: input.topic,
+    limit: input.limit
+  });
+  return { entries, total: entries.length, notice };
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z34 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z30.string().optional().describe(
+  module: z34.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z30.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z34.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -3056,10 +3237,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z31 } from "zod";
+import { z as z35 } from "zod";
 var PostTaskArgsSchema = {
-  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")
+  task_summary: z35.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z35.array(z35.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -3143,12 +3324,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z32 } from "zod";
+import { z as z36 } from "zod";
 var ImportDocsArgsSchema = {
-  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")
+  content: z36.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z36.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z36.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z36.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -3213,7 +3394,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.2";
+var SERVER_VERSION = "0.9.5";
 function jsonResult(data) {
   return {
     content: [
@@ -3264,6 +3445,23 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memSave(input, context));
     }
   );
+  server.tool(
+    "mem_suggest_topic",
+    [
+      "Propose a stable `topic` key (topic-upsert) from type + short title.",
+      "",
+      "USE BEFORE mem_save when you want deterministic updates to the same memory over time;",
+      "families mimic Engram-style grouping (architecture/*, bug/*, decision/*, \u2026).",
+      "",
+      "PARAMETERS:",
+      "  type  \u2014 convention | decision | gotcha | architecture | glossary | attempt | session_recap",
+      "  title \u2014 phrase to slugify under the suggested family prefix",
+      "",
+      "RETURNS: { topic_key, family, type }"
+    ].join("\n"),
+    MemSuggestTopicInputSchema,
+    async (input) => jsonResult(await memSuggestTopic(input, context))
+  );
   server.tool(
     "mem_tried",
     [
@@ -3355,8 +3553,12 @@ function createHaiveServer(options = {}) {
   server.tool(
     "get_briefing",
     [
-      "\u2B50 CALL THIS FIRST at the start of every task. One-shot onboarding that returns",
-      "everything relevant in a single call under a token budget.",
+      "\u2B50 DEFAULT-FIRST for coding agents on any repo where `haive init` ran: call this BEFORE",
+      "changing source or project config for the current goal (unless the developer explicitly opts out).",
+      "One-shot onboarding: everything relevant in a single call under a token budget.",
+      "",
+      "PROGRESSIVE DISCLOSURE \u2014 after this, drill down only if needed:",
+      "  mem_relevant_to / mem_search (compact lists) \u2192 mem_get (full body + anchors).",
       "",
       "RETURNS (in order of priority):",
       "  0. action_required \u2014 \u26A0\uFE0F HANDLE THIS FIRST if non-empty (see protocol below)",
@@ -3379,7 +3581,8 @@ function createHaiveServer(options = {}) {
       "  task    \u2014 what you are about to do (1\u20132 sentences) \u2014 ALWAYS provide this",
       "  files   \u2014 files you are about to edit \u2014 surfaces anchored memories",
       "  symbols \u2014 symbol names to look up in the code-map (e.g. ['PaymentService'])",
-      "  format  \u2014 'full' (default) | 'compact' (1-line summaries, use when token budget is tight)",
+      "  format  \u2014 'full' (default) | 'compact' (1-line) | 'actions' (bullet-first excerpts)",
+      "  budget_preset \u2014 'quick' | 'balanced' | 'deep' \u2014 scales max_tokens/memories/module contexts",
       "",
       "EXAMPLE USAGE:",
       "  get_briefing({ task: 'add a Stripe payment integration', files: ['src/payments/'], symbols: ['PaymentService'] })",
@@ -3390,7 +3593,7 @@ function createHaiveServer(options = {}) {
       "  low           \u2014 proposed, few reads (take with caution)",
       "  unverified    \u2014 draft (unverified: true flag set)",
       "",
-      "Replaces 4\u20135 separate tool calls. Always call this before any other tool."
+      "Replaces 4\u20135 separate tool calls. Prefer this first; use mem_search / mem_get only for follow-up."
     ].join("\n"),
     GetBriefingInputSchema,
     async (input) => {
@@ -3409,6 +3612,8 @@ function createHaiveServer(options = {}) {
       "SEARCH MODES:",
       "  Literal (default): AND search across id, tags, and body \u2014 all tokens must match.",
       "  Falls back to OR automatically if no AND results (partial match).",
+      "  Lexical rank (lexical_rank: true, semantic: false): Okapi-BM25-style scoring on the",
+      "  filtered corpus \u2014 good for phrase-like queries without embeddings.",
       "  Semantic (semantic: true): embedding-based similarity \u2014 finds related memories",
       "  even with different wording. Requires haive embeddings index to be built.",
       "",
@@ -3417,6 +3622,7 @@ function createHaiveServer(options = {}) {
       "  scope    \u2014 filter by personal | team | module",
       "  type     \u2014 filter by convention | decision | gotcha | architecture | glossary",
       "  semantic \u2014 true for embedding-based search (requires @hiveai/embeddings)",
+      "  lexical_rank \u2014 BM25-style ranking (ignored when semantic is true)",
       "  limit    \u2014 max results (default 10)",
       "",
       "RETURNS: array of { id, type, scope, status, confidence, body, match_quality }"
@@ -3427,6 +3633,22 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memSearch(input, context));
     }
   );
+  server.tool(
+    "mem_timeline",
+    [
+      "Chronological view of related memories: by shared frontmatter.topic OR expanded from a seed id",
+      "(related_ids, same topic, overlapping anchor paths \u2014 one extra hop on related_ids).",
+      "",
+      "PARAMETERS:",
+      "  memory_id \u2014 optional seed memory id",
+      "  topic     \u2014 optional topic key (required if memory_id omitted)",
+      "  limit     \u2014 max entries (default 30)",
+      "",
+      "RETURNS: { entries: [{ id, type, scope, created_at, one_line, topic? }], total, notice? }"
+    ].join("\n"),
+    MemTimelineInputSchema,
+    async (input) => jsonResult(await memTimeline(input, context))
+  );
   server.tool(
     "mem_for_files",
     [
@@ -3456,7 +3678,7 @@ function createHaiveServer(options = {}) {
     [
       "Fetch a single memory by its full id with all details.",
       "",
-      "USE WHEN get_briefing returned a memory in 'compact' format and you need",
+      "USE WHEN get_briefing / mem_relevant_to / mem_search returned a compact hit and you need",
       "the full body, or when you know the exact id of a memory.",
       "",
       "PARAMETERS:",
@@ -3544,6 +3766,22 @@ function createHaiveServer(options = {}) {
     CodeMapInputSchema,
     async (input) => jsonResult(await codeMapTool(input, context))
   );
+  server.tool(
+    "mem_resolve_project",
+    [
+      "Diagnostics: resolve which project root hAIve is using (never throws).",
+      "",
+      "USE IN multi-root workspaces or when the agent CWD may not be the repo root \u2014",
+      "mirrors HAIVE_PROJECT_ROOT, findProjectRoot markers, and presence of .ai/memories.",
+      "",
+      "PARAMETERS:",
+      "  cwd \u2014 optional directory used for discovery when HAIVE_PROJECT_ROOT is unset",
+      "",
+      "RETURNS: { ok: true, info: { cwd, resolved_root, haive_project_root_env, \u2026 } }"
+    ].join("\n"),
+    MemResolveProjectInputSchema,
+    async (input) => jsonResult(await memResolveProject(input, context))
+  );
   server.tool(
     "mem_update",
     [
@@ -3677,6 +3915,8 @@ function createHaiveServer(options = {}) {
       "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.",
       "",
+      "Second step in progressive disclosure (after get_briefing): narrow here, then mem_get for full text.",
+      "",
       "Reuses the same ranking pipeline (anchor / module / literal / semantic) but",
       "skips project_context, modules, action_required, etc.",
       "",
@@ -3685,6 +3925,7 @@ function createHaiveServer(options = {}) {
       "  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)",
+      "  format \u2014 'full' | 'compact' | 'actions' (inherits get_briefing memory framing)",
       "",
       "RETURNS: { task, search_mode, memories: [...], hints?: [...], empty?: true }"
     ].join("\n"),
@@ -3833,6 +4074,24 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memConflicts(input, context));
     }
   );
+  server.tool(
+    "mem_conflict_candidates",
+    [
+      "Bulk lexical scan for decision/architecture-like pairs that look similar (Jaccard on tokens).",
+      "",
+      "Advisory only \u2014 follow with mem_conflicts_with on specific ids for real contradiction checks.",
+      "",
+      "PARAMETERS:",
+      "  since_days, types, min_jaccard, max_pairs, max_scan",
+      "",
+      "RETURNS: { pairs: [{ id_a, id_b, jaccard }], scanned, truncated, notice? }"
+    ].join("\n"),
+    MemConflictCandidatesInputSchema,
+    async (input) => {
+      tracker.record("mem_conflict_candidates", `${input.since_days}d`);
+      return jsonResult(await memConflictCandidates(input, context));
+    }
+  );
   server.tool(
     "pre_commit_check",
     [
@@ -3979,9 +4238,13 @@ export {
   createHaiveServer,
   getBriefing,
   getRecap,
+  memConflictCandidates,
   memConflicts,
   memDistill,
   memRelevantTo,
+  memResolveProject,
+  memSuggestTopic,
+  memTimeline,
   parseMcpCliArgs,
   patternDetect,
   preCommitCheck,