@hivelore/mcp 0.31.0 → 0.34.1

package/dist/index.js

@@ -1147,7 +1147,12 @@ import {
 import { z as z15 } from "zod";
 var ProposeSensorInputSchema = {
   memory_id: z15.string().min(1).describe("Id of the gotcha/attempt memory this sensor protects."),
-  pattern: z15.string().min(1).describe("Regex matching the FAULTY usage (the risky call/token), e.g. 'stripe\\.paymentIntents\\.create'."),
+  kind: z15.enum(["regex", "shell", "test"]).default("regex").describe(
+    "regex = pattern matched on added diff lines (default). shell|test = a COMMAND the gate runs when the diff touches the sensor's paths \u2014 routes the team's own oracle (an existing test, an invariant script) to this lesson. Command sensors only execute where enforcement.runCommandSensors=true."
+  ),
+  pattern: z15.string().optional().describe("kind=regex: regex matching the FAULTY usage (the risky call/token), e.g. 'stripe\\.paymentIntents\\.create'."),
+  command: z15.string().optional().describe("kind=shell|test: command to execute (e.g. 'npx vitest run tests/payments/refund.spec.ts'). Non-zero exit = the lesson fires."),
+  timeout_ms: z15.number().int().positive().optional().describe("kind=shell|test: max runtime before the executor kills the command (default 120000)."),
   absent: z15.string().optional().describe(
     "Regex for the CORRECT-usage marker (e.g. 'idempotencyKey'). When it appears in the window around a match, the catch is suppressed \u2014 this is what makes the sensor discriminate the faulty call from the correct one. STRONGLY recommended for 'X without Y' lessons."
   ),
@@ -1189,20 +1194,62 @@ async function readPresumedCorrectTargets(root, relPaths) {
   }
   return targets;
 }
+function runCommandForValidation(command, root, timeoutMs = 12e4) {
+  try {
+    execSync(`bash -c ${JSON.stringify(command)}`, {
+      cwd: root,
+      timeout: timeoutMs,
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { status: "passed", detail: "exit 0" };
+  } catch (err) {
+    const e = err;
+    const out = `${e.stdout?.toString() ?? ""}
+${e.stderr?.toString() ?? ""}`.split("\n").filter(Boolean).slice(-8).join("\n");
+    if (e.killed) return { status: "unrunnable", detail: `timed out after ${timeoutMs}ms` };
+    if (e.status === 127 || e.status === 126 || e.code === "ENOENT") {
+      return { status: "unrunnable", detail: e.status === 126 ? "command found but not executable" : "command not found" };
+    }
+    return { status: "failed", detail: out || `exit ${e.status ?? "?"}` };
+  }
+}
 async function proposeSensor(input, ctx) {
   if (!existsSync15(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}. Run 'hivelore init' first.`);
   }
-  try {
-    new RegExp(input.pattern, input.flags ?? "");
-    if (input.absent) new RegExp(input.absent, input.flags ?? "");
-  } catch (err) {
+  const kind = input.kind ?? "regex";
+  if (kind === "regex") {
+    if (!input.pattern) {
+      return {
+        accepted: false,
+        memory_id: input.memory_id,
+        severity: input.severity,
+        reason: "invalid-regex",
+        guidance: "kind=regex requires a `pattern`.",
+        self_check: { silent_on_current: false, fires_on_bad: null, fired_on: [] }
+      };
+    }
+    try {
+      new RegExp(input.pattern, input.flags ?? "");
+      if (input.absent) new RegExp(input.absent, input.flags ?? "");
+    } catch (err) {
+      return {
+        accepted: false,
+        memory_id: input.memory_id,
+        severity: input.severity,
+        reason: "invalid-regex",
+        guidance: `The pattern or absent regex does not compile: ${String(err)}`,
+        self_check: { silent_on_current: false, fires_on_bad: null, fired_on: [] }
+      };
+    }
+  } else if (!input.command?.trim()) {
     return {
       accepted: false,
       memory_id: input.memory_id,
       severity: input.severity,
-      reason: "invalid-regex",
-      guidance: `The pattern or absent regex does not compile: ${String(err)}`,
+      reason: "invalid-command",
+      guidance: "kind=shell|test requires a `command` (the check the gate will execute).",
       self_check: { silent_on_current: false, fires_on_bad: null, fired_on: [] }
     };
   }
@@ -1211,6 +1258,43 @@ async function proposeSensor(input, ctx) {
   if (!found) {
     throw new Error(`No memory found with id ${input.memory_id}`);
   }
+  if (kind !== "regex") {
+    const verdictCmd = runCommandForValidation(input.command.trim(), ctx.paths.root, input.timeout_ms);
+    const anchorPathsCmd = input.paths.length > 0 ? input.paths : found.memory.frontmatter.anchor.paths;
+    if (verdictCmd.status !== "passed" && input.severity === "block") {
+      return {
+        accepted: false,
+        memory_id: input.memory_id,
+        severity: input.severity,
+        reason: verdictCmd.status === "unrunnable" ? "command-unrunnable" : "fails-on-current",
+        guidance: verdictCmd.status === "unrunnable" ? `The command could not run (${verdictCmd.detail}). Fix the command (or timeout_ms), then re-propose.` : `The command FAILS on the current tree \u2014 the presumed-correct state must pass, or the gate would block every commit. Revert the faulty diff (or fix the check), then re-propose. Output tail:
+${verdictCmd.detail}`,
+        self_check: { silent_on_current: false, fires_on_bad: null, fired_on: anchorPathsCmd }
+      };
+    }
+    const sensorCmd = {
+      kind,
+      command: input.command.trim(),
+      ...input.timeout_ms ? { timeout_ms: input.timeout_ms } : {},
+      paths: anchorPathsCmd,
+      message: input.message?.trim() || deriveMessage(found.memory.body, input.command.trim(), void 0),
+      severity: input.severity,
+      autogen: false,
+      last_fired: null
+    };
+    const nextCmd = {
+      frontmatter: { ...found.memory.frontmatter, sensor: sensorCmd },
+      body: found.memory.body
+    };
+    await writeFile8(found.filePath, serializeMemory7(nextCmd), "utf8");
+    return {
+      accepted: true,
+      memory_id: input.memory_id,
+      severity: input.severity,
+      guidance: verdictCmd.status === "passed" ? "Command oracle passes on the current tree; the gate now runs it when the diff touches the sensor's paths (requires enforcement.runCommandSensors=true)." : `Accepted at warn severity, but note: ${verdictCmd.status} on the current tree (${verdictCmd.detail}).`,
+      self_check: { silent_on_current: verdictCmd.status === "passed", fires_on_bad: null, fired_on: [] }
+    };
+  }
   const anchorPaths = input.paths.length > 0 ? input.paths : found.memory.frontmatter.anchor.paths;
   const currentTargets = await readPresumedCorrectTargets(ctx.paths.root, anchorPaths);
   const badExamples = [
@@ -1271,11 +1355,14 @@ var MemTriedInputSchema = {
   paths: z16.array(z16.string()).default([]).describe("Anchor file paths this applies to"),
   author: z16.string().optional().describe("Author handle or email"),
   sensor: z16.object({
-    pattern: z16.string().min(1).describe("Regex matching the FAULTY usage (added diff lines)"),
-    absent: z16.string().optional().describe("Regex marking CORRECT usage nearby \u2014 excludes it from firing"),
+    kind: z16.enum(["regex", "shell", "test"]).default("regex").describe("regex pattern, or a shell/test COMMAND the gate executes (behaviour bridge)"),
+    pattern: z16.string().optional().describe("kind=regex: regex matching the FAULTY usage (added diff lines)"),
+    command: z16.string().optional().describe("kind=shell|test: command the gate runs when the diff touches the sensor's paths (non-zero exit = lesson fires)"),
+    timeout_ms: z16.number().int().positive().optional().describe("kind=shell|test: max runtime (default 120000)"),
+    absent: z16.string().optional().describe("kind=regex: regex marking CORRECT usage nearby \u2014 excludes it from firing"),
     severity: z16.enum(["warn", "block"]).default("block").describe("block = deterministic gate refusal"),
     message: z16.string().optional().describe("Self-correction message shown when the sensor fires"),
-    bad_example: z16.string().optional().describe("Code snippet the sensor MUST fire on (validation)")
+    bad_example: z16.string().optional().describe("kind=regex: code snippet the sensor MUST fire on (validation)")
   }).optional().describe(
     "ONE-SHOT loop close: validate and attach a sensor in the same call (equivalent to a follow-up propose_sensor). Validated against HEAD \u2014 silent on current code, fires on the bad example. If rejected, the attempt is still saved and the verdict tells you how to revise."
   )
@@ -1311,7 +1398,10 @@ async function memTried(input, ctx) {
     const verdict = await proposeSensor(
       {
         memory_id: frontmatter.id,
+        kind: input.sensor.kind ?? "regex",
         pattern: input.sensor.pattern,
+        command: input.sensor.command,
+        timeout_ms: input.sensor.timeout_ms,
         absent: input.sensor.absent,
         severity: input.sensor.severity ?? "block",
         message: input.sensor.message,
@@ -1446,83 +1536,17 @@ async function writeDraft(ctx, draft) {
   return file;
 }
 
-// src/tools/mem-observe.ts
-import { mkdir as mkdir5, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path8 from "path";
+// src/tools/mem-session-end.ts
+import { writeFile as writeFile12, mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path9 from "path";
 import {
   buildFrontmatter as buildFrontmatter3,
-  isLikelyGuessable,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   memoryFilePath as memoryFilePath4,
   serializeMemory as serializeMemory10
 } from "@hivelore/core";
 import { z as z18 } from "zod";
-var MemObserveInputSchema = {
-  what: z18.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
-  where: z18.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
-  impact: z18.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
-  fix: z18.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
-  scope: z18.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
-  module: z18.string().optional().describe("Module name (required when scope=module)"),
-  tags: z18.array(z18.string()).default([]).describe("Tags for filtering"),
-  author: z18.string().optional().describe("Author handle or email"),
-  force: z18.boolean().default(false).describe(
-    "Save even if the observation looks like generic, guessable knowledge. By default, low-specificity observations (things a capable model already knows) are SKIPPED to keep the corpus high-signal \u2014 only unguessable, team-specific discoveries are worth storing."
-  )
-};
-async function memObserve(input, ctx) {
-  if (!existsSync18(ctx.paths.haiveDir)) {
-    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'hivelore init' first.`);
-  }
-  const signalText = [input.what, input.impact, input.fix ?? ""].join(" ");
-  if (!input.force && isLikelyGuessable(signalText)) {
-    return {
-      id: "",
-      scope: input.scope,
-      file_path: "",
-      skipped: true,
-      reason: "Observation looks like generic, guessable knowledge (low specificity) \u2014 not saved. Capture only arbitrary, team-specific facts (exact names, values, formats). Pass force=true to override."
-    };
-  }
-  const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 6).join("-");
-  const anchorPaths = input.where.split(/[,\n]/).map((s) => s.trim()).filter(Boolean);
-  const baseFm = buildFrontmatter3({
-    type: "gotcha",
-    slug,
-    scope: input.scope,
-    module: input.module,
-    tags: input.tags,
-    paths: anchorPaths,
-    author: input.author
-  });
-  const frontmatter = { ...baseFm, status: "validated" };
-  const lines = [`# ${input.what}`, ""];
-  lines.push(`**Where:** \`${input.where}\``);
-  lines.push("", `**Impact:** ${input.impact}`);
-  if (input.fix) {
-    lines.push("", `**Fix/workaround:** ${input.fix}`);
-  }
-  const body = lines.join("\n") + "\n";
-  const file = memoryFilePath4(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-  await mkdir5(path8.dirname(file), { recursive: true });
-  if (existsSync18(file)) {
-    throw new Error(`Memory already exists at ${file}`);
-  }
-  await writeFile11(file, serializeMemory10({ frontmatter, body }), "utf8");
-  return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
-}
-
-// src/tools/mem-session-end.ts
-import { writeFile as writeFile13, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path10 from "path";
-import {
-  buildFrontmatter as buildFrontmatter4,
-  loadMemoriesFromDir as loadMemoriesFromDir15,
-  memoryFilePath as memoryFilePath5,
-  serializeMemory as serializeMemory11
-} from "@hivelore/core";
-import { z as z19 } from "zod";
 
 // src/session-tracker.ts
 import {
@@ -1531,12 +1555,12 @@ import {
   loadConfig as loadConfig2,
   writeSessionHandoff
 } from "@hivelore/core";
-import { mkdir as mkdir6, writeFile as writeFile12, rm } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import path9 from "path";
+import { mkdir as mkdir5, writeFile as writeFile11, rm } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path8 from "path";
 import { execSync as execSync2 } from "child_process";
 function pendingDistillPath(ctx) {
-  return path9.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
+  return path8.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
 }
 var SessionTracker = class {
   events = [];
@@ -1563,7 +1587,7 @@ var SessionTracker = class {
     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)
+        (e) => ["mem_save", "mem_tried", "mem_update", "bootstrap_project_save"].includes(e.tool)
       );
       const totalCalls = this.events.length;
       if (totalCalls === 0) return;
@@ -1640,7 +1664,7 @@ var SessionTracker = class {
         (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
       );
       const isSubstantialSession = totalCalls >= 3 || writingTools.length > 0;
-      if (!ranPostTask && isSubstantialSession && existsSync19(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync18(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -1653,9 +1677,9 @@ var SessionTracker = class {
             ...gitDiff ? { git_diff: gitDiff } : {},
             ...recapId ? { recap_id: recapId } : {}
           };
-          const cacheDir = path9.join(this.ctx.paths.haiveDir, ".cache");
-          await mkdir6(cacheDir, { recursive: true });
-          await writeFile12(
+          const cacheDir = path8.join(this.ctx.paths.haiveDir, ".cache");
+          await mkdir5(cacheDir, { recursive: true });
+          await writeFile11(
             pendingDistillPath(this.ctx),
             JSON.stringify(payload, null, 2) + "\n",
             "utf8"
@@ -1674,7 +1698,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync19(p)) {
+  if (existsSync18(p)) {
     try {
       await rm(p);
     } catch {
@@ -1691,15 +1715,15 @@ function summarizeTools(events) {
 
 // src/tools/mem-session-end.ts
 var MemSessionEndInputSchema = {
-  goal: z19.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
-  accomplished: z19.string().describe("What was actually done \u2014 bullet list recommended"),
-  discoveries: z19.string().default("").describe(
+  goal: z18.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z18.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z18.string().default("").describe(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  files_touched: z19.array(z19.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
-  next_steps: z19.string().default("").describe("What should happen next (for the next session or a teammate)"),
-  scope: z19.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
-  module: z19.string().optional().describe("Module name (required when scope=module)")
+  files_touched: z18.array(z18.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z18.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z18.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z18.string().optional().describe("Module name (required when scope=module)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -1729,23 +1753,23 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync20(ctx.paths.haiveDir)) {
+  if (!existsSync19(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'hivelore init' first.`);
   }
   const body = buildBody(input);
   const topic = recapTopic(input.scope, input.module);
   const normalizedFiles = input.files_touched.map((p) => {
-    if (!p || !path10.isAbsolute(p)) return p;
-    const rel = path10.relative(ctx.paths.root, p);
+    if (!p || !path9.isAbsolute(p)) return p;
+    const rel = path9.relative(ctx.paths.root, p);
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync20(path10.resolve(ctx.paths.root, p))
+    (p) => !existsSync19(path9.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync20(ctx.paths.memoriesDir) ? await loadMemoriesFromDir15(ctx.paths.memoriesDir) : [];
+  const existing = existsSync19(ctx.paths.memoriesDir) ? await loadMemoriesFromDir15(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
   );
@@ -1761,9 +1785,9 @@ async function memSessionEnd(input, ctx) {
         paths: normalizedFiles.length ? normalizedFiles : fm.anchor.paths
       }
     };
-    await writeFile13(
+    await writeFile12(
       topicMatch.filePath,
-      serializeMemory11({ frontmatter: newFrontmatter, body }),
+      serializeMemory10({ frontmatter: newFrontmatter, body }),
       "utf8"
     );
     await clearPendingDistill(ctx);
@@ -1775,7 +1799,7 @@ async function memSessionEnd(input, ctx) {
       revision_count: revisionCount
     };
   }
-  const frontmatter = buildFrontmatter4({
+  const frontmatter = buildFrontmatter3({
     type: "session_recap",
     slug: "recap",
     scope: input.scope,
@@ -1785,14 +1809,14 @@ async function memSessionEnd(input, ctx) {
     topic,
     status: "validated"
   });
-  const file = memoryFilePath5(
+  const file = memoryFilePath4(
     ctx.paths,
     frontmatter.scope,
     frontmatter.id,
     frontmatter.module
   );
-  await mkdir7(path10.dirname(file), { recursive: true });
-  await writeFile13(file, serializeMemory11({ frontmatter, body }), "utf8");
+  await mkdir6(path9.dirname(file), { recursive: true });
+  await writeFile12(file, serializeMemory10({ frontmatter, body }), "utf8");
   await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
@@ -1804,9 +1828,9 @@ async function memSessionEnd(input, ctx) {
 }
 
 // src/tools/get-briefing.ts
-import { readFile as readFile6, writeFile as writeFile14, readdir as readdir4 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
-import path12 from "path";
+import { readFile as readFile6, writeFile as writeFile13, readdir as readdir4 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import path11 from "path";
 import {
   allocateBudget,
   assessBootstrapState,
@@ -1840,7 +1864,7 @@ import {
   queryCodeMap,
   readSessionHandoff,
   resolveBriefingBudget,
-  serializeMemory as serializeMemory12,
+  serializeMemory as serializeMemory11,
   specificityScore,
   GUESSABLE_THRESHOLD,
   tokenizeQuery as tokenizeQuery2,
@@ -1848,12 +1872,12 @@ import {
   truncateToTokens,
   writeBriefingMarker
 } from "@hivelore/core";
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 
 // src/tools/briefing-helpers.ts
 import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync21 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path10 from "path";
 import {
   classifyMemoryPriority as coreClassifyPriority,
   isGlobPath,
@@ -1986,15 +2010,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync21(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync20(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 = path11.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync21(file)) {
+    const file = path10.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync20(file)) {
       out.push({ name: m, content: await readFile5(file, "utf8") });
     }
   }
@@ -2003,38 +2027,38 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/get-briefing.ts
 var GetBriefingInputSchema = {
-  task: z20.string().optional().describe(
+  task: z19.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z20.array(z20.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z20.number().int().positive().default(8e3).describe(
+  files: z19.array(z19.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z19.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: z20.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z20.boolean().default(true),
-  dedupe_project_context: z20.boolean().optional().describe(
+  max_memories: z19.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z19.boolean().default(true),
+  dedupe_project_context: z19.boolean().optional().describe(
     "Token saver (default ON): skip re-emitting the project-context body if an identical copy was already sent within the last few minutes this session (the agent still has it). Set false to always include it."
   ),
-  include_module_contexts: z20.boolean().default(true),
-  semantic: z20.boolean().default(true).describe(
+  include_module_contexts: z19.boolean().default(true),
+  semantic: z19.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `hivelore embeddings index`)."
   ),
-  include_stale: z20.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
-  track: z20.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z20.enum(["full", "compact", "actions"]).default("full").describe(
+  include_stale: z19.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z19.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z19.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: z20.array(z20.string()).default([]).describe(
+  symbols: z19.array(z19.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 `hivelore index code` to have been run."
   ),
-  min_semantic_score: z20.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z19.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: z20.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z19.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 = z20.object(GetBriefingInputSchema);
+var GetBriefingZod = z19.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -2050,7 +2074,7 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync22(ctx.paths.memoriesDir)) {
+  if (existsSync21(ctx.paths.memoriesDir)) {
     const allLoaded = await loadMemoriesFromDir16(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()
@@ -2225,7 +2249,7 @@ async function getBriefing(input, ctx) {
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated", validated_by: "auto" };
         try {
-          await writeFile14(loaded.filePath, serializeMemory12({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
+          await writeFile13(loaded.filePath, serializeMemory11({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -2233,7 +2257,7 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  let projectContextRaw = input.include_project_context && existsSync22(ctx.paths.projectContext) ? await readFile6(ctx.paths.projectContext, "utf8") : "";
+  let projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile6(ctx.paths.projectContext, "utf8") : "";
   let contextOmittedRecent = false;
   if (projectContextRaw && input.dedupe_project_context !== false) {
     const ctxHash = hashProjectContext(projectContextRaw);
@@ -2248,7 +2272,7 @@ async function getBriefing(input, ctx) {
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync22(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync21(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap(ctx.paths);
@@ -2422,7 +2446,7 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync22(ctx.paths.memoriesDir)) {
+  if (existsSync21(ctx.paths.memoriesDir)) {
     const allMems = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
@@ -2433,7 +2457,7 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync22(pendingDistillFile)) {
+  if (existsSync21(pendingDistillFile)) {
     try {
       const raw = await readFile6(pendingDistillFile, "utf8");
       const pd = JSON.parse(raw);
@@ -2462,7 +2486,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync22(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync21(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hasUnguessableSignal = outputMemories.some(
     (m) => (m.priority === "must_read" || m.priority === "useful") && specificityScore(m.body) >= GUESSABLE_THRESHOLD
@@ -2480,7 +2504,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
         pcRaw = await readFile6(ctx.paths.projectContext, "utf8");
       } catch {
       }
-      const allForBootstrap = existsSync22(ctx.paths.memoriesDir) ? await loadMemoriesFromDir16(ctx.paths.memoriesDir) : [];
+      const allForBootstrap = existsSync21(ctx.paths.memoriesDir) ? await loadMemoriesFromDir16(ctx.paths.memoriesDir) : [];
       const cmForBootstrap = await loadCodeMap(ctx.paths);
       let existingModules = [];
       try {
@@ -2530,7 +2554,7 @@ Invoke the \`bootstrap_repo\` MCP prompt, or close these gaps directly:
     }
     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."
+        "After completing the task: capture failed approaches with mem_tried, new gotchas and validated patterns with mem_save."
       );
     }
     if (outputMemories.length > 2 && !input.budget_preset && input.task && !hints.some((h) => h.includes("budget_preset"))) {
@@ -2544,7 +2568,7 @@ Invoke the \`bootstrap_repo\` MCP prompt, or close these gaps directly:
       "No team-specific policy matched these files/task \u2014 nothing here a capable model can't infer. The auto-generated project context was trimmed to keep this briefing near-zero-cost; proceed with normal Read/Grep."
     );
   }
-  if (outputMemories.length > 0 && existsSync22(ctx.paths.haiveDir)) {
+  if (outputMemories.length > 0 && existsSync21(ctx.paths.haiveDir)) {
     const proof = briefingProofLine(await loadPreventionEvents(ctx.paths));
     if (proof) hints.push(proof);
   }
@@ -2558,7 +2582,7 @@ Invoke the \`bootstrap_repo\` MCP prompt, or close these gaps directly:
     adaptiveTrim
   });
   const breadcrumbTokens = breadcrumbs ? estimateTokens([...breadcrumbs.start_here, ...breadcrumbs.drill_down, breadcrumbs.note ?? ""].join("\n")) : 0;
-  if (existsSync22(ctx.paths.haiveDir)) {
+  if (existsSync21(ctx.paths.haiveDir)) {
     await writeBriefingMarker(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -2614,8 +2638,8 @@ Invoke the \`bootstrap_repo\` MCP prompt, or close these gaps directly:
   };
 }
 async function detectRunCommands(root) {
-  const pkgPath = path12.join(root, "package.json");
-  if (!existsSync22(pkgPath)) return null;
+  const pkgPath = path11.join(root, "package.json");
+  if (!existsSync21(pkgPath)) return null;
   try {
     const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
@@ -2682,24 +2706,24 @@ function oneLine(value) {
   return value.replace(/\s+/g, " ").replace(/"/g, '\\"').trim().slice(0, 120);
 }
 function serverVersion() {
-  return true ? "0.31.0" : "dev";
+  return true ? "0.34.1" : "dev";
 }
 
 // src/tools/code-map.ts
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hivelore/core";
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 var CodeMapInputSchema = {
-  file: z21.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z21.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  paths: z21.array(z21.string()).default([]).describe(
+  file: z20.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z20.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  paths: z20.array(z20.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: z21.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
-  max_tokens: z21.number().int().positive().optional().describe(
+  max_files: z20.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z20.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)."
   )
 };
-var CodeMapInputZod = z21.object(CodeMapInputSchema);
+var CodeMapInputZod = z20.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap2(ctx.paths);
   if (!map) {
@@ -2768,15 +2792,15 @@ function estimateFileEntryTokens(f) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir17 } from "@hivelore/core";
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 var MemDiffInputSchema = {
-  id_a: z22.string().min(1).describe("First memory id"),
-  id_b: z22.string().min(1).describe("Second memory id")
+  id_a: z21.string().min(1).describe("First memory id"),
+  id_b: z21.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync23(ctx.paths.memoriesDir)) {
+  if (!existsSync22(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
   const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
@@ -2813,16 +2837,16 @@ async function memDiff(input, ctx) {
 }
 
 // src/tools/get-recap.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir18 } from "@hivelore/core";
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 var GetRecapInputSchema = {
-  scope: z23.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z22.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 (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
   const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
@@ -2849,13 +2873,13 @@ async function getRecap(input, ctx) {
 }
 
 // src/tools/mem-relevant-to.ts
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 var MemRelevantToInputSchema = {
-  task: z24.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
-  files: z24.array(z24.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
-  limit: z24.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
-  min_semantic_score: z24.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
-  format: z24.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
+  task: z23.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z23.array(z23.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z23.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z23.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z23.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 = {
@@ -2885,14 +2909,14 @@ async function memRelevantTo(input, ctx) {
 }
 
 // src/tools/code-search.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 import { loadCodeMap as loadCodeMap3 } from "@hivelore/core";
 var CodeSearchInputSchema = {
-  query: z25.string().min(1).describe(
+  query: z24.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: z25.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
-  min_score: z25.number().min(0).max(1).default(0.2).describe(
+  k: z24.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z24.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."
   )
 };
@@ -2934,155 +2958,39 @@ async function codeSearch(input, ctx) {
   };
 }
 
-// src/tools/why-this-file.ts
-import { existsSync as existsSync25 } from "fs";
-import { spawn } from "child_process";
-import path13 from "path";
-import {
-  deriveConfidence as deriveConfidence5,
-  getUsage as getUsage7,
-  loadCodeMap as loadCodeMap4,
-  loadMemoriesFromDir as loadMemoriesFromDir19,
-  loadUsageIndex as loadUsageIndex9,
-  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
-} from "@hivelore/core";
-import { z as z26 } from "zod";
-var WhyThisFileInputSchema = {
-  path: z26.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: z26.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
-  memory_limit: z26.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
-};
-async function whyThisFile(input, ctx) {
-  const fileExists = existsSync25(path13.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),
-    loadCodeMap4(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 (!existsSync25(ctx.paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex9(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 = getUsage7(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 existsSync26 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import {
   addedLinesFromDiff,
   BRIDGE_TARGET_PATH,
   buildDocFrequency,
   CODE_STOPWORDS,
-  deriveConfidence as deriveConfidence6,
+  deriveConfidence as deriveConfidence5,
   diffHasDistinctiveOverlap,
-  getUsage as getUsage8,
+  getUsage as getUsage7,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir20,
-  loadUsageIndex as loadUsageIndex10,
+  loadMemoriesFromDir as loadMemoriesFromDir19,
+  loadUsageIndex as loadUsageIndex9,
   literalMatchesAnyToken as literalMatchesAnyToken3,
-  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3,
   recordPreventionHits,
   runSensors,
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hivelore/core";
-import { z as z27 } from "zod";
+import { z as z25 } from "zod";
 var AntiPatternsCheckInputSchema = {
-  diff: z27.string().optional().describe(
+  diff: z25.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: z27.array(z27.string()).default([]).describe(
+  paths: z25.array(z25.string()).default([]).describe(
     "File paths affected by the change. Memories anchored to any of these paths are surfaced regardless of the diff content."
   ),
-  limit: z27.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
-  semantic: z27.boolean().default(true).describe(
+  limit: z25.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
+  semantic: z25.boolean().default(true).describe(
     "When true, also use semantic search (requires @hivelore/embeddings + memory index) to find related anti-patterns."
   ),
-  min_semantic_score: z27.number().min(0).max(1).default(0.45).describe(
+  min_semantic_score: z25.number().min(0).max(1).default(0.45).describe(
     "Minimum cosine score for semantic-only anti-pattern hits. Anchor/literal matches still surface. Default 0.45 keeps broad, weakly-related memories out of review noise."
   )
 };
@@ -3166,10 +3074,10 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync24(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
-  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory }) => {
     const t = memory.frontmatter.type;
@@ -3180,7 +3088,7 @@ async function antiPatternsCheck(input, ctx) {
   if (negative.length === 0) {
     return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
   }
-  const usage = await loadUsageIndex10(ctx.paths);
+  const usage = await loadUsageIndex9(ctx.paths);
   const docFreq = buildDocFrequency(negative.map(({ memory }) => memory.body));
   const seen = /* @__PURE__ */ new Map();
   const upsert = (fm, body, reason, score) => {
@@ -3192,12 +3100,12 @@ async function antiPatternsCheck(input, ctx) {
       }
       return;
     }
-    const u = getUsage8(usage, fm.id);
+    const u = getUsage7(usage, fm.id);
     seen.set(fm.id, {
       id: fm.id,
       type: fm.type,
       scope: fm.scope,
-      confidence: deriveConfidence6(fm, u),
+      confidence: deriveConfidence5(fm, u),
       body_preview: body.split("\n").slice(0, 5).join("\n").slice(0, 400),
       reasons: [reason],
       tags: fm.tags ?? [],
@@ -3208,7 +3116,7 @@ async function antiPatternsCheck(input, ctx) {
   };
   if (input.paths.length > 0) {
     for (const { memory } of negative) {
-      if (memoryMatchesAnchorPaths4(memory, input.paths)) {
+      if (memoryMatchesAnchorPaths3(memory, input.paths)) {
         upsert(memory.frontmatter, memory.body, "anchor");
       }
     }
@@ -3285,19 +3193,19 @@ async function antiPatternsCheck(input, ctx) {
 }
 
 // src/tools/mem-distill.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
   tokenizeQuery as tokenizeQuery4
 } from "@hivelore/core";
-import { z as z28 } from "zod";
+import { z as z26 } from "zod";
 var MemDistillInputSchema = {
-  since_days: z28.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
-  min_cluster: z28.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
-  type_filter: z28.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
+  since_days: z26.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
+  min_cluster: z26.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
+  type_filter: z26.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: z28.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
+  scope: z26.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([
@@ -3337,11 +3245,11 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync27(ctx.paths.memoriesDir)) {
+  if (!existsSync25(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 loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory }) => {
     const fm = memory.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -3444,299 +3352,19 @@ function firstHeading(body) {
   return void 0;
 }
 
-// src/tools/why-this-decision.ts
-import { existsSync as existsSync28 } from "fs";
-import { spawn as spawn2 } from "child_process";
-import {
-  deriveConfidence as deriveConfidence7,
-  getUsage as getUsage9,
-  loadMemoriesFromDir as loadMemoriesFromDir22,
-  loadUsageIndex as loadUsageIndex11,
-  pathsOverlap as singlePathsOverlap
-} from "@hivelore/core";
-import { z as z29 } from "zod";
-var WhyThisDecisionInputSchema = {
-  id: z29.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
-  git_log_limit: z29.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
-};
-async function whyThisDecision(input, ctx) {
-  if (!existsSync28(ctx.paths.memoriesDir)) {
-    return {
-      found: false,
-      related: [],
-      path_neighbors: [],
-      recent_commits: [],
-      notice: "No .ai/memories directory."
-    };
-  }
-  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex11(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 = getUsage9(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 = getUsage9(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 = getUsage9(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 existsSync29 } from "fs";
-import {
-  deriveConfidence as deriveConfidence8,
-  getUsage as getUsage10,
-  loadMemoriesFromDir as loadMemoriesFromDir23,
-  loadUsageIndex as loadUsageIndex12,
-  pathsOverlap as pathsOverlap2,
-  tokenizeQuery as tokenizeQuery5
-} from "@hivelore/core";
-import { z as z30 } from "zod";
-var MemConflictsInputSchema = {
-  id: z30.string().min(1).describe("Memory id to check for conflicts."),
-  min_score: z30.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
-  semantic: z30.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 (!existsSync29(ctx.paths.memoriesDir)) {
-    return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
-  }
-  const all = await loadMemoriesFromDir23(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 loadUsageIndex12(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) => pathsOverlap2(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 = getUsage10(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) => pathsOverlap2(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("@hivelore/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 { pathsOverlap as pathsOverlap3 } from "@hivelore/core";
-import { z as z31 } from "zod";
+import { pathsOverlap as pathsOverlap2 } from "@hivelore/core";
+import { z as z27 } from "zod";
 var PreCommitCheckInputSchema = {
-  diff: z31.string().optional().describe(
+  diff: z27.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: z31.array(z31.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
-  block_on: z31.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
+  paths: z27.array(z27.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z27.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: z31.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z31.boolean().default(false).describe(
+  semantic: z27.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z27.boolean().default(false).describe(
     "When true, ALSO block a high-confidence anti-pattern (attempt/gotcha) that is anchored to a touched file AND corroborated by the diff (literal token overlap, or semantic >= 0.45) \u2014 not just very strong semantic matches. Powers the 'anchored' enforcement gate. Config/docs-only commits are still downgraded. Default false preserves the soft, semantic-only blocking behavior."
   )
 };
@@ -3805,7 +3433,7 @@ async function preCommitCheck(input, ctx) {
 }
 function classifyWarning(warning, paths, anchoredBlocks = false) {
   const codeFiles = paths.filter((p) => !p.startsWith(".ai/") && !isHaiveOwnedPath(p));
-  const anchorHits = (warning.anchor_paths ?? []).length > 0 ? codeFiles.filter((p) => (warning.anchor_paths ?? []).some((ap) => pathsOverlap3(ap, p))) : [];
+  const anchorHits = (warning.anchor_paths ?? []).length > 0 ? codeFiles.filter((p) => (warning.anchor_paths ?? []).some((ap) => pathsOverlap2(ap, p))) : [];
   const affectedFiles = anchorHits.length > 0 ? anchorHits : codeFiles;
   const repairCommand = repairCommandForWarning(warning, affectedFiles);
   const fileDowngrade = fileTypeDowngradeReason(warning, affectedFiles);
@@ -4041,228 +3669,15 @@ function repairTargetPathForWarning(warning, paths) {
   return usablePaths[0];
 }
 
-// src/tools/pattern-detect.ts
-import { mkdir as mkdir8, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
-import path14 from "path";
-import { execSync as execSync3 } from "child_process";
-import {
-  buildFrontmatter as buildFrontmatter5,
-  memoryFilePath as memoryFilePath6,
-  readUsageEvents,
-  serializeMemory as serializeMemory13
-} from "@hivelore/core";
-import { z as z32 } 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: z32.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
-  dry_run: z32.boolean().default(false).describe("When true, report matches without writing any memory files."),
-  scope: z32.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
-};
-async function patternDetect(input, ctx) {
-  if (!existsSync30(ctx.paths.haiveDir)) {
-    return {
-      scanned_events: 0,
-      matches: [],
-      saved: 0,
-      saved_ids: [],
-      notice: "No .ai/ directory found. Run 'hivelore init' first."
-    };
-  }
-  const matches = [];
-  try {
-    const changedFiles = gitChangedFiles(ctx.paths.root, input.since_days);
-    const configFiles = changedFiles.filter(
-      (f) => CONFIG_PATTERNS.some((p) => path14.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 = path14.basename(path14.dirname(file));
-      const baseName = path14.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) => path14.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 = memoryFilePath6(
-        ctx.paths,
-        fm.scope === "shared" ? "team" : fm.scope,
-        fm.id,
-        void 0
-      );
-      if (existsSync30(file)) continue;
-      await mkdir8(path14.dirname(file), { recursive: true });
-      await writeFile15(
-        file,
-        serializeMemory13({ 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 = execSync3(
-      `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 = execSync3(
-      `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/tools/mem-conflict-candidates.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
   planConflictResolution
 } from "@hivelore/core";
-import { z as z33 } from "zod";
+import { z as z28 } from "zod";
 function suggestResolution(byId, idA, idB) {
   const a = byId.get(idA);
   const b = byId.get(idB);
@@ -4276,17 +3691,17 @@ function suggestResolution(byId, idA, idB) {
   };
 }
 var MemConflictCandidatesInputSchema = {
-  since_days: z33.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
-  types: z33.array(z33.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
-  min_jaccard: z33.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
-  max_pairs: z33.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
-  max_scan: z33.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
-  max_topic_pairs: z33.number().int().positive().max(100).default(20).describe(
+  since_days: z28.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z28.array(z28.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z28.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z28.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z28.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
+  max_topic_pairs: z28.number().int().positive().max(100).default(20).describe(
     "Cap for extra signal: memories sharing the same topic with validated vs rejected status."
   )
 };
 async function memConflictCandidates(input, ctx) {
-  if (!existsSync31(ctx.paths.memoriesDir)) {
+  if (!existsSync26(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -4295,7 +3710,7 @@ async function memConflictCandidates(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir24(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const byId = new Map(all.map((m) => [m.memory.frontmatter.id, m]));
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
@@ -4325,9 +3740,9 @@ async function memConflictCandidates(input, ctx) {
 
 // src/tools/mem-resolve-project.ts
 import { resolveProjectInfo } from "@hivelore/core";
-import { z as z34 } from "zod";
+import { z as z29 } from "zod";
 var MemResolveProjectInputSchema = {
-  cwd: z34.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z29.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -4341,10 +3756,10 @@ async function memResolveProject(input, _ctx) {
 
 // src/tools/mem-suggest-topic.ts
 import { MemoryTypeSchema, suggestTopicKey } from "@hivelore/core";
-import { z as z35 } from "zod";
+import { z as z30 } from "zod";
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z35.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z30.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -4353,19 +3768,19 @@ async function memSuggestTopic(input, _ctx) {
 }
 
 // src/tools/mem-timeline.ts
-import { existsSync as existsSync32 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir25 } from "@hivelore/core";
-import { z as z36 } from "zod";
+import { existsSync as existsSync27 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir22 } from "@hivelore/core";
+import { z as z31 } from "zod";
 var MemTimelineInputSchema = {
-  memory_id: z36.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
-  topic: z36.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
-  limit: z36.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+  memory_id: z31.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z31.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z31.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync32(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir25(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
   const { entries, notice } = collectTimelineEntries(all, {
     memoryId: input.memory_id,
     topic: input.topic,
@@ -4374,47 +3789,13 @@ async function memTimeline(input, ctx) {
   return { entries, total: entries.length, notice };
 }
 
-// src/tools/runtime-journal-append.ts
-import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hivelore/core";
-import { z as z37 } from "zod";
-var RuntimeJournalAppendInputSchema = {
-  message: z37.string().min(1).describe("Short line to append to the runtime session journal"),
-  kind: z37.enum(["note", "session_end", "mcp"]).default("note"),
-  tool: z37.string().optional().describe("When kind=mcp, which tool name (optional)")
-};
-async function runtimeJournalAppend(input, ctx) {
-  await appendRuntimeJournalEntry2(ctx.paths, {
-    kind: input.kind,
-    message: input.message,
-    ...input.tool ? { tool: input.tool } : {}
-  });
-  return {
-    ok: true,
-    path_hint: `${ctx.paths.runtimeDir}/session-journal.ndjson`
-  };
-}
-
-// src/tools/runtime-journal-tail.ts
-import { readRuntimeJournalTail } from "@hivelore/core";
-import { z as z38 } from "zod";
-var RuntimeJournalTailInputSchema = {
-  limit: z38.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
-};
-async function runtimeJournalTail(input, ctx) {
-  const entries = await readRuntimeJournalTail(ctx.paths, input.limit);
-  if (entries.length === 0) {
-    return { entries: [], empty: true };
-  }
-  return { entries };
-}
-
 // src/prompts/bootstrap-project.ts
-import { z as z39 } from "zod";
+import { z as z32 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z39.string().optional().describe(
+  module: z32.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z39.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z32.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -4497,16 +3878,16 @@ ${template}\`\`\`
 
 // src/prompts/bootstrap-repo.ts
 import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import {
   assessBootstrapState as assessBootstrapState2,
-  loadCodeMap as loadCodeMap5,
-  loadMemoriesFromDir as loadMemoriesFromDir26,
+  loadCodeMap as loadCodeMap4,
+  loadMemoriesFromDir as loadMemoriesFromDir23,
   renderBootstrapChecklist as renderBootstrapChecklist2
 } from "@hivelore/core";
-import { z as z40 } from "zod";
+import { z as z33 } from "zod";
 var BootstrapRepoArgsSchema = {
-  focus: z40.string().optional().describe("Optional area to emphasize first (e.g. 'payments', 'auth').")
+  focus: z33.string().optional().describe("Optional area to emphasize first (e.g. 'payments', 'auth').")
 };
 async function currentAssessment(ctx) {
   let projectContextRaw = "";
@@ -4514,8 +3895,8 @@ async function currentAssessment(ctx) {
     projectContextRaw = await readFile7(ctx.paths.projectContext, "utf8");
   } catch {
   }
-  const memories = existsSync33(ctx.paths.memoriesDir) ? await loadMemoriesFromDir26(ctx.paths.memoriesDir) : [];
-  const codeMap = await loadCodeMap5(ctx.paths);
+  const memories = existsSync28(ctx.paths.memoriesDir) ? await loadMemoriesFromDir23(ctx.paths.memoriesDir) : [];
+  const codeMap = await loadCodeMap4(ctx.paths);
   let existingModules = [];
   try {
     const entries = await readdir5(ctx.paths.modulesContextDir, { withFileTypes: true });
@@ -4582,10 +3963,10 @@ Main code areas detected: ${areas}
 }
 
 // src/prompts/post-task.ts
-import { z as z41 } from "zod";
+import { z as z34 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z41.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z41.array(z41.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z34.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z34.array(z34.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -4682,12 +4063,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z42 } from "zod";
+import { z as z35 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z42.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z42.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z42.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z42.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z35.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z35.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z35.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z35.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -4753,7 +4134,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { hasRecentBriefingMarker, loadConfigSync } from "@hivelore/core";
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.31.0";
+var SERVER_VERSION = "0.34.1";
 function jsonResult(data) {
   return {
     content: [
@@ -4801,14 +4182,7 @@ var MAINTENANCE_PROFILE_TOOLS = [
   "ingest_findings"
 ];
 var EXPERIMENTAL_PROFILE_TOOLS = [
-  ...MAINTENANCE_PROFILE_TOOLS,
-  "mem_observe",
-  "why_this_file",
-  "why_this_decision",
-  "mem_conflicts_with",
-  "pattern_detect",
-  "runtime_journal_append",
-  "runtime_journal_tail"
+  ...MAINTENANCE_PROFILE_TOOLS
 ];
 var TOOL_PROFILES = {
   enforcement: new Set(ENFORCEMENT_PROFILE_TOOLS),
@@ -4823,7 +4197,6 @@ var BRIEFING_TOOLS = /* @__PURE__ */ new Set(["get_briefing", "mem_relevant_to"]
 var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_save",
   "mem_tried",
-  "mem_observe",
   "mem_session_end",
   "bootstrap_project_save",
   "mem_update",
@@ -4831,8 +4204,6 @@ var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_reject",
   "mem_delete",
   "mem_feedback",
-  "runtime_journal_append",
-  "pattern_detect",
   "ingest_findings",
   "propose_sensor"
 ]);
@@ -4895,7 +4266,7 @@ function createHaiveServer(options = {}) {
       "  - A domain term and what it means in this codebase",
       "",
       "DO NOT USE for failed approaches \u2192 use mem_tried instead (better structure).",
-      "DO NOT USE for code discoveries during exploration \u2192 use mem_observe instead.",
+      "For reactive code discoveries during exploration, prefer a compact gotcha via mem_save.",
       "",
       "PARAMETERS:",
       "  type     \u2014 convention | decision | gotcha | architecture | glossary | attempt",
@@ -5022,38 +4393,6 @@ function createHaiveServer(options = {}) {
       return jsonResult(await ingestFindings(input, context));
     }
   );
-  registerTool(
-    "mem_observe",
-    [
-      "Capture a code-level discovery made WHILE READING existing code.",
-      "",
-      "USE THIS when you read a file and spot something the team may not know about:",
-      "  - A bug or race condition hiding in the code",
-      "  - A security gap or missing validation",
-      "  - An inconsistency between two files",
-      "  - A missing configuration or environment variable",
-      "  - Anything that could silently break in production",
-      "",
-      "DIFFERENCE from mem_save: mem_observe is for REACTIVE discoveries during code",
-      "reading. mem_save is for deliberate knowledge capture (conventions, decisions).",
-      "",
-      "Auto-validated, anchored to file paths for staleness detection.",
-      "",
-      "PARAMETERS:",
-      "  what   \u2014 one-line title (e.g. 'MobilePaymentController: duplicate @RequestBody')",
-      "  where  \u2014 file path(s) where the issue lives",
-      "  impact \u2014 what breaks or could break because of this",
-      "  fix    \u2014 suggested fix (optional)",
-      "  scope  \u2014 team (default, since discoveries benefit everyone)",
-      "",
-      "RETURNS: { id, file_path }"
-    ].join("\n"),
-    MemObserveInputSchema,
-    async (input) => {
-      tracker.record("mem_observe", input.where);
-      return jsonResult(await memObserve(input, context));
-    }
-  );
   registerTool(
     "mem_session_end",
     [
@@ -5513,26 +4852,6 @@ function createHaiveServer(options = {}) {
       return jsonResult(await codeSearch(input, context));
     }
   );
-  registerTool(
-    "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));
-    }
-  );
   registerTool(
     "anti_patterns_check",
     [
@@ -5582,54 +4901,6 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memDistill(input, context));
     }
   );
-  registerTool(
-    "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));
-    }
-  );
-  registerTool(
-    "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));
-    }
-  );
   registerTool(
     "mem_conflict_candidates",
     [
@@ -5638,7 +4909,7 @@ function createHaiveServer(options = {}) {
       "  1. Lexical similarity (Jaccard) on decision/architecture-like pairs",
       "  2. Same frontmatter.topic with validated vs rejected \u2014 quick human-review signal",
       "",
-      "Advisory only \u2014 follow with mem_conflicts_with on specific ids.",
+      "Advisory only \u2014 review the listed candidate ids, then resolve with mem_update/mem_delete.",
       "",
       "PARAMETERS:",
       "  since_days, types, min_jaccard, max_pairs, max_scan, max_topic_pairs",
@@ -5651,32 +4922,6 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memConflictCandidates(input, context));
     }
   );
-  registerTool(
-    "runtime_journal_append",
-    [
-      "Append one line to `.ai/.runtime/session-journal.ndjson` \u2014 machine-local session continuity.",
-      "",
-      "Does NOT replace team memories; complements mem_session_end recaps for local traces.",
-      "",
-      "PARAMETERS: message, kind (note|session_end|mcp), optional tool",
-      "",
-      "RETURNS: { ok, path_hint }"
-    ].join("\n"),
-    RuntimeJournalAppendInputSchema,
-    async (input) => jsonResult(await runtimeJournalAppend(input, context))
-  );
-  registerTool(
-    "runtime_journal_tail",
-    [
-      "Read the last N entries from the runtime session journal (parsed JSON lines).",
-      "",
-      "PARAMETERS: limit (default 30, max 500)",
-      "",
-      "RETURNS: { entries: [...], empty?: true }"
-    ].join("\n"),
-    RuntimeJournalTailInputSchema,
-    async (input) => jsonResult(await runtimeJournalTail(input, context))
-  );
   registerTool(
     "pre_commit_check",
     [
@@ -5703,37 +4948,6 @@ function createHaiveServer(options = {}) {
       return jsonResult(await preCommitCheck(input, context));
     }
   );
-  registerTool(
-    "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));
-    }
-  );
   registerTool(
     "mem_diff",
     [
@@ -5784,7 +4998,7 @@ function createHaiveServer(options = {}) {
       [
         "\u2B50 Post-task reflection \u2014 run at the end of every session to capture what you learned:",
         "failed approaches (mem_tried), new conventions/decisions/gotchas (mem_save),",
-        "code discoveries (mem_observe), and an end-of-session recap (mem_session_end).",
+        "failed approaches (mem_tried), and an end-of-session recap (mem_session_end).",
         "In autopilot mode a minimal recap saves automatically; calling this produces a richer one."
       ].join(" "),
       PostTaskArgsSchema,