@hiveai/mcp 0.10.9 → 0.12.0

package/dist/server.js

@@ -151,6 +151,13 @@ var MemSaveInputSchema = {
   commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)"),
   topic: z4.string().optional().describe(
     "Stable key for this memory. If a memory with the same topic already exists in this scope, it is updated in-place (revision_count++). Use for knowledge that evolves over time."
+  ),
+  activation: z4.object({
+    keywords: z4.array(z4.string()).default([]),
+    globs: z4.array(z4.string()).default([]),
+    always: z4.boolean().default(false)
+  }).optional().describe(
+    "Only for type='skill'. Progressive-disclosure triggers: the skill is surfaced ONLY when a keyword matches the task or a glob matches the edited files (or always=true). Omit to keep the skill always-eligible."
   )
 };
 function bodyHash(body) {
@@ -269,7 +276,8 @@ async function memSave(input, ctx) {
     commit: input.commit,
     topic: input.topic,
     status: haiveConfig.defaultStatus === "validated" ? "validated" : void 0,
-    sensor: suggestSensorForSavedMemory(input.type, input.body, input.paths) ?? void 0
+    sensor: suggestSensorForSavedMemory(input.type, input.body, input.paths) ?? void 0,
+    activation: input.type === "skill" ? input.activation : void 0
   });
   const file = memoryFilePath(
     ctx.paths,
@@ -658,28 +666,78 @@ async function memReject(input, ctx) {
   };
 }
 
+// src/tools/mem-feedback.ts
+import {
+  computeImpact,
+  getUsage as getUsage2,
+  loadMemoriesFromDir as loadMemoriesFromDir6,
+  loadUsageIndex as loadUsageIndex3,
+  recordApplied,
+  recordRejection as recordRejection2,
+  saveUsageIndex as saveUsageIndex2
+} from "@hiveai/core";
+import { existsSync as existsSync8 } from "fs";
+import { z as z8 } from "zod";
+var MemFeedbackInputSchema = {
+  id: z8.string().min(1).describe("Full memory id the feedback is about"),
+  outcome: z8.enum(["applied", "rejected"]).describe(
+    "'applied' = this memory changed what you did (strong positive utility signal); 'rejected' = it was wrong/outdated/unhelpful (negative signal, blocks auto-promotion)."
+  ),
+  reason: z8.string().optional().describe("Why it was rejected (stored on the memory's usage record). Only used for outcome='rejected'.")
+};
+async function memFeedback(input, ctx) {
+  if (!existsSync8(ctx.paths.memoriesDir)) {
+    return { ok: false, id: input.id, error: "No .ai/memories \u2014 run `haive init` first." };
+  }
+  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
+  const target = all.find((m) => m.memory.frontmatter.id === input.id);
+  if (!target) {
+    return { ok: false, id: input.id, error: `No memory with id '${input.id}'.` };
+  }
+  const index = await loadUsageIndex3(ctx.paths);
+  if (input.outcome === "applied") {
+    recordApplied(index, input.id);
+  } else {
+    recordRejection2(index, input.id, input.reason ?? null);
+  }
+  await saveUsageIndex2(ctx.paths, index);
+  const usage = getUsage2(index, input.id);
+  const impact = computeImpact(target.memory.frontmatter, usage);
+  return {
+    ok: true,
+    id: input.id,
+    outcome: input.outcome,
+    usage: {
+      read_count: usage.read_count,
+      applied_count: usage.applied_count,
+      rejected_count: usage.rejected_count
+    },
+    impact: { score: impact.score, tier: impact.tier, signals: impact.signals }
+  };
+}
+
 // src/tools/mem-for-files.ts
 import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import path4 from "path";
 import {
   deriveConfidence as deriveConfidence2,
-  getUsage as getUsage2,
+  getUsage as getUsage3,
   inferModulesFromPaths,
-  loadMemoriesFromDir as loadMemoriesFromDir6,
-  loadUsageIndex as loadUsageIndex3,
+  loadMemoriesFromDir as loadMemoriesFromDir7,
+  loadUsageIndex as loadUsageIndex4,
   memoryMatchesAnchorPaths,
   trackReads as trackReads2
 } from "@hiveai/core";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var MemForFilesInputSchema = {
-  files: z8.array(z8.string()).min(1).describe("Project-relative file paths the agent is currently working on"),
-  include_module_contexts: z8.boolean().default(true).describe("Inline the matching .ai/modules/<name>/context.md contents"),
-  track: z8.boolean().default(true).describe("Increment read_count on returned memories")
+  files: z9.array(z9.string()).min(1).describe("Project-relative file paths the agent is currently working on"),
+  include_module_contexts: z9.boolean().default(true).describe("Inline the matching .ai/modules/<name>/context.md contents"),
+  track: z9.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function memForFiles(input, ctx) {
   const inferred = inferModulesFromPaths(input.files);
-  if (!existsSync8(ctx.paths.memoriesDir)) {
+  if (!existsSync9(ctx.paths.memoriesDir)) {
     return {
       inferred_modules: inferred,
       by_anchor: [],
@@ -688,8 +746,8 @@ async function memForFiles(input, ctx) {
       module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
     };
   }
-  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex3(ctx.paths);
+  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex4(ctx.paths);
   const seen = /* @__PURE__ */ new Set();
   const byAnchor = [];
   const byModule = [];
@@ -737,7 +795,7 @@ async function memForFiles(input, ctx) {
 }
 function toMatch(loaded, reason, usage) {
   const fm = loaded.memory.frontmatter;
-  const u = getUsage2(usage, fm.id);
+  const u = getUsage3(usage, fm.id);
   return {
     id: fm.id,
     scope: fm.scope,
@@ -801,7 +859,7 @@ function extractPathSegments(files) {
 }
 async function loadModuleContexts(ctx, modules, enabled) {
   if (!enabled || modules.length === 0) return [];
-  if (!existsSync8(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync9(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir2(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
@@ -809,7 +867,7 @@ async function loadModuleContexts(ctx, modules, enabled) {
   for (const m of modules) {
     if (!available.has(m)) continue;
     const file = path4.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync8(file)) {
+    if (existsSync9(file)) {
       out.push({ name: m, content: await readFile2(file, "utf8") });
     }
   }
@@ -817,26 +875,26 @@ async function loadModuleContexts(ctx, modules, enabled) {
 }
 
 // src/tools/mem-get.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import {
   deriveConfidence as deriveConfidence3,
-  getUsage as getUsage3,
-  loadMemoriesFromDir as loadMemoriesFromDir7,
-  loadUsageIndex as loadUsageIndex4
+  getUsage as getUsage4,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
+  loadUsageIndex as loadUsageIndex5
 } from "@hiveai/core";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var MemGetInputSchema = {
-  id: z9.string().min(1).describe("Memory id to fetch")
+  id: z10.string().min(1).describe("Memory id to fetch")
 };
 async function memGet(input, ctx) {
-  if (!existsSync9(ctx.paths.memoriesDir)) {
+  if (!existsSync10(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const fm = found.memory.frontmatter;
-  const u = getUsage3(await loadUsageIndex4(ctx.paths), fm.id);
+  const u = getUsage4(await loadUsageIndex5(ctx.paths), fm.id);
   return {
     id: fm.id,
     scope: fm.scope,
@@ -861,32 +919,32 @@ async function memGet(input, ctx) {
 }
 
 // src/tools/mem-delete.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { unlink } from "fs/promises";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir8,
-  loadUsageIndex as loadUsageIndex5,
-  saveUsageIndex as saveUsageIndex2
+  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadUsageIndex as loadUsageIndex6,
+  saveUsageIndex as saveUsageIndex3
 } from "@hiveai/core";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var MemDeleteInputSchema = {
-  id: z10.string().min(1).describe("Memory id to delete"),
-  keep_usage: z10.boolean().default(false).describe("Keep the usage.json entry instead of removing it alongside the file")
+  id: z11.string().min(1).describe("Memory id to delete"),
+  keep_usage: z11.boolean().default(false).describe("Keep the usage.json entry instead of removing it alongside the file")
 };
 async function memDelete(input, ctx) {
-  if (!existsSync10(ctx.paths.memoriesDir)) {
+  if (!existsSync11(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   await unlink(found.filePath);
   let usageRemoved = false;
   if (!input.keep_usage) {
-    const idx = await loadUsageIndex5(ctx.paths);
+    const idx = await loadUsageIndex6(ctx.paths);
     if (idx.by_id[input.id]) {
       delete idx.by_id[input.id];
-      await saveUsageIndex2(ctx.paths, idx);
+      await saveUsageIndex3(ctx.paths, idx);
       usageRemoved = true;
     }
   }
@@ -895,24 +953,24 @@ async function memDelete(input, ctx) {
 
 // src/tools/mem-update.ts
 import { writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir9, serializeMemory as serializeMemory4 } from "@hiveai/core";
-import { z as z11 } from "zod";
+import { existsSync as existsSync12 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir10, serializeMemory as serializeMemory4 } from "@hiveai/core";
+import { z as z12 } from "zod";
 var MemUpdateInputSchema = {
-  id: z11.string().min(1).describe("Id of the memory to update"),
-  body: z11.string().optional().describe("New Markdown body \u2014 replaces the existing body"),
-  tags: z11.array(z11.string()).optional().describe("New tags array \u2014 fully replaces existing tags"),
-  paths: z11.array(z11.string()).optional().describe("New anchor paths \u2014 fully replaces existing anchor.paths"),
-  symbols: z11.array(z11.string()).optional().describe("New anchor symbols \u2014 fully replaces existing anchor.symbols"),
-  commit: z11.string().optional().describe("New anchor commit SHA"),
-  domain: z11.string().optional().describe("New domain label"),
-  author: z11.string().optional().describe("New author handle or email")
+  id: z12.string().min(1).describe("Id of the memory to update"),
+  body: z12.string().optional().describe("New Markdown body \u2014 replaces the existing body"),
+  tags: z12.array(z12.string()).optional().describe("New tags array \u2014 fully replaces existing tags"),
+  paths: z12.array(z12.string()).optional().describe("New anchor paths \u2014 fully replaces existing anchor.paths"),
+  symbols: z12.array(z12.string()).optional().describe("New anchor symbols \u2014 fully replaces existing anchor.symbols"),
+  commit: z12.string().optional().describe("New anchor commit SHA"),
+  domain: z12.string().optional().describe("New domain label"),
+  author: z12.string().optional().describe("New author handle or email")
 };
 async function memUpdate(input, ctx) {
-  if (!existsSync11(ctx.paths.memoriesDir)) {
+  if (!existsSync12(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
   const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
   if (!loaded) throw new Error(`No memory with id "${input.id}".`);
   const { frontmatter, body } = loaded.memory;
@@ -954,20 +1012,20 @@ async function memUpdate(input, ctx) {
 }
 
 // src/tools/mem-pending.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import {
-  getUsage as getUsage4,
-  loadMemoriesFromDir as loadMemoriesFromDir10,
-  loadUsageIndex as loadUsageIndex6
+  getUsage as getUsage5,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
+  loadUsageIndex as loadUsageIndex7
 } from "@hiveai/core";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var MemPendingInputSchema = {
-  scope: z12.enum(["personal", "team", "module"]).optional()
+  scope: z13.enum(["personal", "team", "module"]).optional()
 };
 async function memPending(input, ctx) {
-  if (!existsSync12(ctx.paths.memoriesDir)) return { pending: [] };
-  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex6(ctx.paths);
+  if (!existsSync13(ctx.paths.memoriesDir)) return { pending: [] };
+  const all = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex7(ctx.paths);
   const now = Date.now();
   const proposed = all.filter(({ memory }) => {
     if (memory.frontmatter.status !== "proposed") return false;
@@ -975,12 +1033,12 @@ async function memPending(input, ctx) {
     return true;
   });
   proposed.sort(
-    (a, b) => getUsage4(usage, b.memory.frontmatter.id).read_count - getUsage4(usage, a.memory.frontmatter.id).read_count
+    (a, b) => getUsage5(usage, b.memory.frontmatter.id).read_count - getUsage5(usage, a.memory.frontmatter.id).read_count
   );
   return {
     pending: proposed.map(({ memory, filePath }) => {
       const fm = memory.frontmatter;
-      const u = getUsage4(usage, fm.id);
+      const u = getUsage5(usage, fm.id);
       return {
         id: fm.id,
         scope: fm.scope,
@@ -998,20 +1056,20 @@ async function memPending(input, ctx) {
 
 // src/tools/mem-approve.ts
 import { writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir11,
+  loadMemoriesFromDir as loadMemoriesFromDir12,
   serializeMemory as serializeMemory5
 } from "@hiveai/core";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var MemApproveInputSchema = {
-  id: z13.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
+  id: z14.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
 };
 async function memApprove(input, ctx) {
-  if (!existsSync13(ctx.paths.memoriesDir)) {
+  if (!existsSync14(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const previous = found.memory.frontmatter.status;
@@ -1030,7 +1088,7 @@ async function memApprove(input, ctx) {
 
 // src/tools/mem-tried.ts
 import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import path5 from "path";
 import {
   buildFrontmatter as buildFrontmatter2,
@@ -1038,19 +1096,19 @@ import {
   serializeMemory as serializeMemory6,
   suggestSensorFromMemory as suggestSensorFromMemory2
 } from "@hiveai/core";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var MemTriedInputSchema = {
-  what: z14.string().min(1).describe("Brief description of the approach that was tried"),
-  why_failed: z14.string().min(1).describe("Why it failed or why it should NOT be used"),
-  instead: z14.string().optional().describe("What to use or do instead (recommended alternative)"),
-  scope: z14.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
-  module: z14.string().optional().describe("Module name (required when scope=module)"),
-  tags: z14.array(z14.string()).default([]).describe("Tags for filtering"),
-  paths: z14.array(z14.string()).default([]).describe("Anchor file paths this applies to"),
-  author: z14.string().optional().describe("Author handle or email")
+  what: z15.string().min(1).describe("Brief description of the approach that was tried"),
+  why_failed: z15.string().min(1).describe("Why it failed or why it should NOT be used"),
+  instead: z15.string().optional().describe("What to use or do instead (recommended alternative)"),
+  scope: z15.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
+  module: z15.string().optional().describe("Module name (required when scope=module)"),
+  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
+  paths: z15.array(z15.string()).default([]).describe("Anchor file paths this applies to"),
+  author: z15.string().optional().describe("Author handle or email")
 };
 async function memTried(input, ctx) {
-  if (!existsSync14(ctx.paths.haiveDir)) {
+  if (!existsSync15(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
@@ -1076,7 +1134,7 @@ async function memTried(input, ctx) {
   }
   const file = memoryFilePath2(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir3(path5.dirname(file), { recursive: true });
-  if (existsSync14(file)) {
+  if (existsSync15(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile7(file, serializeMemory6({ frontmatter, body }), "utf8");
@@ -1085,7 +1143,7 @@ async function memTried(input, ctx) {
 
 // src/tools/mem-observe.ts
 import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import path6 from "path";
 import {
   buildFrontmatter as buildFrontmatter3,
@@ -1093,22 +1151,22 @@ import {
   memoryFilePath as memoryFilePath3,
   serializeMemory as serializeMemory7
 } from "@hiveai/core";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var MemObserveInputSchema = {
-  what: z15.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
-  where: z15.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
-  impact: z15.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
-  fix: z15.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
-  scope: z15.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
-  module: z15.string().optional().describe("Module name (required when scope=module)"),
-  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
-  author: z15.string().optional().describe("Author handle or email"),
-  force: z15.boolean().default(false).describe(
+  what: z16.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
+  where: z16.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
+  impact: z16.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
+  fix: z16.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
+  scope: z16.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+  module: z16.string().optional().describe("Module name (required when scope=module)"),
+  tags: z16.array(z16.string()).default([]).describe("Tags for filtering"),
+  author: z16.string().optional().describe("Author handle or email"),
+  force: z16.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 (!existsSync15(ctx.paths.haiveDir)) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const signalText = [input.what, input.impact, input.fix ?? ""].join(" ");
@@ -1142,7 +1200,7 @@ async function memObserve(input, ctx) {
   const body = lines.join("\n") + "\n";
   const file = memoryFilePath3(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir4(path6.dirname(file), { recursive: true });
-  if (existsSync15(file)) {
+  if (existsSync16(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile8(file, serializeMemory7({ frontmatter, body }), "utf8");
@@ -1151,15 +1209,15 @@ async function memObserve(input, ctx) {
 
 // src/tools/mem-session-end.ts
 import { writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import path8 from "path";
 import {
   buildFrontmatter as buildFrontmatter4,
-  loadMemoriesFromDir as loadMemoriesFromDir12,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   memoryFilePath as memoryFilePath4,
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/session-tracker.ts
 import {
@@ -1168,7 +1226,7 @@ import {
   loadConfig as loadConfig2
 } from "@hiveai/core";
 import { mkdir as mkdir5, writeFile as writeFile9, rm } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import path7 from "path";
 import { execSync } from "child_process";
 function pendingDistillPath(ctx) {
@@ -1251,7 +1309,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 && existsSync16(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync17(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -1285,7 +1343,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync16(p)) {
+  if (existsSync17(p)) {
     try {
       await rm(p);
     } catch {
@@ -1302,15 +1360,15 @@ function summarizeTools(events) {
 
 // src/tools/mem-session-end.ts
 var MemSessionEndInputSchema = {
-  goal: z16.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
-  accomplished: z16.string().describe("What was actually done \u2014 bullet list recommended"),
-  discoveries: z16.string().default("").describe(
+  goal: z17.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z17.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z17.string().default("").describe(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  files_touched: z16.array(z16.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
-  next_steps: z16.string().default("").describe("What should happen next (for the next session or a teammate)"),
-  scope: z16.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
-  module: z16.string().optional().describe("Module name (required when scope=module)")
+  files_touched: z17.array(z17.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z17.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z17.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z17.string().optional().describe("Module name (required when scope=module)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -1340,7 +1398,7 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync17(ctx.paths.haiveDir)) {
+  if (!existsSync18(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const body = buildBody(input);
@@ -1351,12 +1409,12 @@ async function memSessionEnd(input, ctx) {
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync17(path8.resolve(ctx.paths.root, p))
+    (p) => !existsSync18(path8.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync17(ctx.paths.memoriesDir) ? await loadMemoriesFromDir12(ctx.paths.memoriesDir) : [];
+  const existing = existsSync18(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
   );
@@ -1416,14 +1474,16 @@ async function memSessionEnd(input, ctx) {
 
 // src/tools/get-briefing.ts
 import { readFile as readFile4, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import {
   allocateBudget,
+  computeImpact as computeImpact2,
   DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
+  evaluateSkillActivation,
   extractActionsBriefBody,
-  getUsage as getUsage5,
+  getUsage as getUsage6,
   inferModulesFromPaths as inferModulesFromPaths2,
   isAutoPromoteEligible,
   isDecaying,
@@ -1432,8 +1492,8 @@ import {
   literalMatchesAnyToken as literalMatchesAnyToken2,
   loadCodeMap,
   loadConfig as loadConfig3,
-  loadMemoriesFromDir as loadMemoriesFromDir13,
-  loadUsageIndex as loadUsageIndex7,
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   queryCodeMap,
   resolveBriefingBudget,
@@ -1445,11 +1505,11 @@ import {
   truncateToTokens,
   writeBriefingMarker
 } from "@hiveai/core";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/tools/briefing-helpers.ts
 import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import path9 from "path";
 import { isGlobPath, isStackPackSeed, pathsOverlap } from "@hiveai/core";
 function compactSummary(body) {
@@ -1576,7 +1636,7 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync18(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync19(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
@@ -1584,7 +1644,7 @@ async function loadModuleContexts2(ctx, modules) {
   for (const m of modules) {
     if (!available.has(m)) continue;
     const file = path9.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync18(file)) {
+    if (existsSync19(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -1593,35 +1653,35 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/get-briefing.ts
 var GetBriefingInputSchema = {
-  task: z17.string().optional().describe(
+  task: z18.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z17.array(z17.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z17.number().int().positive().default(8e3).describe(
+  files: z18.array(z18.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z18.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: z17.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z17.boolean().default(true),
-  include_module_contexts: z17.boolean().default(true),
-  semantic: z17.boolean().default(true).describe(
+  max_memories: z18.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z18.boolean().default(true),
+  include_module_contexts: z18.boolean().default(true),
+  semantic: z18.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  include_stale: z17.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
-  track: z17.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z17.enum(["full", "compact", "actions"]).default("full").describe(
+  include_stale: z18.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z18.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z18.enum(["full", "compact", "actions"]).default("full").describe(
     "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
-  symbols: z17.array(z17.string()).default([]).describe(
+  symbols: z18.array(z18.string()).default([]).describe(
     "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
   ),
-  min_semantic_score: z17.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z18.number().min(0).max(1).default(0).describe(
     "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
   ),
-  budget_preset: z17.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z18.enum(["quick", "balanced", "deep"]).optional().describe(
     "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
-var GetBriefingZod = z17.object(GetBriefingInputSchema);
+var GetBriefingZod = z18.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -1637,8 +1697,8 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync19(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  if (existsSync20(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir14(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()
     );
@@ -1660,7 +1720,7 @@ async function getBriefing(input, ctx) {
       if (memory.frontmatter.type === "session_recap") return false;
       return true;
     });
-    usage = await loadUsageIndex7(ctx.paths);
+    usage = await loadUsageIndex8(ctx.paths);
     byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
     const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
     if (input.task && input.semantic) {
@@ -1682,7 +1742,8 @@ async function getBriefing(input, ctx) {
         }
         return;
       }
-      const u = getUsage5(usage, fm.id);
+      const u = getUsage6(usage, fm.id);
+      const imp = computeImpact2(fm, u);
       seen.set(fm.id, {
         id: fm.id,
         scope: fm.scope,
@@ -1693,6 +1754,8 @@ async function getBriefing(input, ctx) {
         confidence: deriveConfidence4(fm, u),
         ...fm.status === "draft" || fm.status === "proposed" ? { unverified: true } : {},
         read_count: u.read_count,
+        impact_score: imp.score,
+        impact_tier: imp.tier,
         reasons: [reason],
         match_quality: matchQuality ?? "partial",
         ...score !== void 0 ? { semantic_score: score } : {},
@@ -1736,11 +1799,28 @@ async function getBriefing(input, ctx) {
         }
       }
     }
+    const activatedSkills = /* @__PURE__ */ new Set();
+    for (const [id, m] of seen) {
+      if (m.type !== "skill") continue;
+      const loaded = byId.get(id);
+      if (!loaded) continue;
+      const act = evaluateSkillActivation(loaded.memory.frontmatter, {
+        task: input.task,
+        files: input.files
+      });
+      if (act.applicable && !act.activated) {
+        seen.delete(id);
+        continue;
+      }
+      if (act.applicable && act.activated) activatedSkills.add(id);
+    }
     const ranked = [...seen.values()].sort((a, b) => {
       const reasonScore = (m) => (m.type === "attempt" ? 3 : 0) + (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("symbol") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
       const confidenceScore = (m) => m.confidence === "authoritative" ? 4 : m.confidence === "trusted" ? 3 : m.confidence === "low" ? 1 : m.confidence === "stale" ? -2 : 0;
-      const sa = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
-      const sb = priorityRank(classifyMemoryPriority(b, byId.get(b.id), input.files, input.symbols)) * 100 + reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
+      const impactScore = (m) => (m.impact_score ?? 0) * 3;
+      const activationBoost = (m) => activatedSkills.has(m.id) ? 5 : 0;
+      const sa = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + impactScore(a) + activationBoost(a) + (a.semantic_score ?? 0);
+      const sb = priorityRank(classifyMemoryPriority(b, byId.get(b.id), input.files, input.symbols)) * 100 + reasonScore(b) + confidenceScore(b) + impactScore(b) + activationBoost(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
     for (const mem of ranked.slice(0, briefingMaxMemories)) {
@@ -1756,7 +1836,7 @@ async function getBriefing(input, ctx) {
     memories.push(...ranked.slice(0, briefingMaxMemories));
     if (input.track && memories.length > 0) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
-      const freshUsage = await loadUsageIndex7(ctx.paths);
+      const freshUsage = await loadUsageIndex8(ctx.paths);
       const cfg = await loadConfig3(ctx.paths);
       const rule = {
         minReads: cfg.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE.minReads,
@@ -1765,7 +1845,7 @@ async function getBriefing(input, ctx) {
       for (const m of memories) {
         const loaded = byId.get(m.id);
         if (!loaded) continue;
-        const u = getUsage5(freshUsage, m.id);
+        const u = getUsage6(freshUsage, m.id);
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated" };
         try {
@@ -1777,12 +1857,12 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync19(ctx.paths.projectContext) ? await readFile4(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync20(ctx.paths.projectContext) ? await readFile4(ctx.paths.projectContext, "utf8") : "";
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync19(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync20(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap(ctx.paths);
@@ -1878,7 +1958,7 @@ ${m.content}`).join("\n\n---\n\n"),
   const totalTokens = projectSlice.estimatedTokens + modulesSlice.estimatedTokens + memoriesSlice.estimatedTokens;
   const decayWarnings = [];
   for (const m of trimmedMemories) {
-    const u = getUsage5(usage, m.id);
+    const u = getUsage6(usage, m.id);
     const loaded = byId.get(m.id);
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
@@ -1943,8 +2023,8 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync19(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  if (existsSync20(ctx.paths.memoriesDir)) {
+    const allMems = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -1954,7 +2034,7 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync19(pendingDistillFile)) {
+  if (existsSync20(pendingDistillFile)) {
     try {
       const raw = await readFile4(pendingDistillFile, "utf8");
       const pd = JSON.parse(raw);
@@ -1983,7 +2063,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync19(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync20(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
@@ -2030,7 +2110,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       "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 (existsSync19(ctx.paths.haiveDir)) {
+  if (existsSync20(ctx.paths.haiveDir)) {
     await writeBriefingMarker(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -2081,19 +2161,19 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
 
 // src/tools/code-map.ts
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hiveai/core";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var CodeMapInputSchema = {
-  file: z18.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z18.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  paths: z18.array(z18.string()).default([]).describe(
+  file: z19.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z19.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  paths: z19.array(z19.string()).default([]).describe(
     "Filter to files under any of these path prefixes (e.g. ['packages/mcp/src/tools/', 'src/auth/']). OR-joined with `file` substring; useful to get a focused view of one module."
   ),
-  max_files: z18.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
-  max_tokens: z18.number().int().positive().optional().describe(
+  max_files: z19.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z19.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 = z18.object(CodeMapInputSchema);
+var CodeMapInputZod = z19.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap2(ctx.paths);
   if (!map) {
@@ -2162,18 +2242,18 @@ function estimateFileEntryTokens(f) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync20 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
-import { z as z19 } from "zod";
+import { existsSync as existsSync21 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
+import { z as z20 } from "zod";
 var MemDiffInputSchema = {
-  id_a: z19.string().min(1).describe("First memory id"),
-  id_b: z19.string().min(1).describe("Second memory id")
+  id_a: z20.string().min(1).describe("First memory id"),
+  id_b: z20.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync20(ctx.paths.memoriesDir)) {
+  if (!existsSync21(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
   const foundA = all.find((m) => m.memory.frontmatter.id === input.id_a);
   const foundB = all.find((m) => m.memory.frontmatter.id === input.id_b);
   if (!foundA) throw new Error(`No memory with id "${input.id_a}".`);
@@ -2207,19 +2287,19 @@ async function memDiff(input, ctx) {
 }
 
 // src/tools/get-recap.ts
-import { existsSync as existsSync21 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
-import { z as z20 } from "zod";
+import { existsSync as existsSync22 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir16 } from "@hiveai/core";
+import { z as z21 } from "zod";
 var GetRecapInputSchema = {
-  scope: z20.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z21.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 (!existsSync21(ctx.paths.memoriesDir)) {
+  if (!existsSync22(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
-  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
   const recaps = all.filter(({ memory }) => memory.frontmatter.type === "session_recap").filter(({ memory }) => input.scope === "any" || memory.frontmatter.scope === input.scope).sort(
     (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
   );
@@ -2243,13 +2323,13 @@ async function getRecap(input, ctx) {
 }
 
 // src/tools/mem-relevant-to.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var MemRelevantToInputSchema = {
-  task: z21.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
-  files: z21.array(z21.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
-  limit: z21.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
-  min_semantic_score: z21.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
-  format: z21.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
+  task: z22.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z22.array(z22.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z22.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z22.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z22.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 = {
@@ -2279,13 +2359,13 @@ async function memRelevantTo(input, ctx) {
 }
 
 // src/tools/code-search.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var CodeSearchInputSchema = {
-  query: z22.string().min(1).describe(
+  query: z23.string().min(1).describe(
     "Natural-language description of what you are looking for in the codebase (e.g. 'function that hashes passwords', 'JWT signing logic', 'route registration')."
   ),
-  k: z22.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
-  min_score: z22.number().min(0).max(1).default(0.2).describe(
+  k: z23.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z23.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."
   )
 };
@@ -2315,27 +2395,27 @@ async function codeSearch(input, ctx) {
 }
 
 // src/tools/why-this-file.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { spawn } from "child_process";
 import path10 from "path";
 import {
   deriveConfidence as deriveConfidence5,
-  getUsage as getUsage6,
+  getUsage as getUsage7,
   loadCodeMap as loadCodeMap3,
-  loadMemoriesFromDir as loadMemoriesFromDir16,
-  loadUsageIndex as loadUsageIndex8,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadUsageIndex as loadUsageIndex9,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
 } from "@hiveai/core";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var WhyThisFileInputSchema = {
-  path: z23.string().min(1).describe(
+  path: z24.string().min(1).describe(
     "Project-relative path to the file you want context on (e.g. 'packages/mcp/src/tools/mem-save.ts')."
   ),
-  git_log_limit: z23.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
-  memory_limit: z23.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
+  git_log_limit: z24.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
+  memory_limit: z24.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync22(path10.join(ctx.paths.root, input.path));
+  const fileExists = existsSync23(path10.join(ctx.paths.root, input.path));
   const [commits, memories, codeMap] = await Promise.all([
     runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
     collectAnchoredMemories(ctx, input.path, input.memory_limit),
@@ -2376,16 +2456,16 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync22(ctx.paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex8(ctx.paths);
+  if (!existsSync23(ctx.paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir17(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 = getUsage6(usage, fm.id);
+    const u = getUsage7(usage, fm.id);
     out.push({
       id: fm.id,
       type: fm.type,
@@ -2431,83 +2511,39 @@ function runCommand(cmd, args, cwd) {
 }
 
 // src/tools/anti-patterns-check.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import {
   addedLinesFromDiff,
+  buildDocFrequency,
+  CODE_STOPWORDS,
   deriveConfidence as deriveConfidence6,
-  getUsage as getUsage7,
+  diffHasDistinctiveOverlap,
+  getUsage as getUsage8,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
-  loadUsageIndex as loadUsageIndex9,
+  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
   runSensors,
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var AntiPatternsCheckInputSchema = {
-  diff: z24.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: z24.array(z24.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: z24.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
-  semantic: z24.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 @hiveai/embeddings + memory index) to find related anti-patterns."
   ),
-  min_semantic_score: z24.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."
   )
 };
-var CODE_STOPWORDS = /* @__PURE__ */ new Set([
-  "import",
-  "export",
-  "function",
-  "return",
-  "const",
-  "let",
-  "var",
-  "class",
-  "public",
-  "private",
-  "protected",
-  "static",
-  "this",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "void",
-  "async",
-  "await",
-  "from",
-  "type",
-  "interface",
-  "extends",
-  "implements",
-  "number",
-  "string",
-  "boolean",
-  "value",
-  "default",
-  "case",
-  "break",
-  "continue",
-  "throw",
-  "catch",
-  "finally",
-  "else",
-  "while",
-  "for",
-  "new",
-  "super",
-  "yield",
-  "module",
-  "require",
-  "console"
-]);
 function tokenizeDiffForLiteral(diff) {
   const lines = diff.split("\n");
   const looksLikeDiff = lines.some((l) => /^[+-]/.test(l));
@@ -2525,10 +2561,10 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync23(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 loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory }) => {
     const t = memory.frontmatter.type;
@@ -2539,7 +2575,8 @@ async function antiPatternsCheck(input, ctx) {
   if (negative.length === 0) {
     return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
   }
-  const usage = await loadUsageIndex9(ctx.paths);
+  const usage = await loadUsageIndex10(ctx.paths);
+  const docFreq = buildDocFrequency(negative.map(({ memory }) => memory.body));
   const seen = /* @__PURE__ */ new Map();
   const upsert = (fm, body, reason, score) => {
     const existing = seen.get(fm.id);
@@ -2550,7 +2587,7 @@ async function antiPatternsCheck(input, ctx) {
       }
       return;
     }
-    const u = getUsage7(usage, fm.id);
+    const u = getUsage8(usage, fm.id);
     seen.set(fm.id, {
       id: fm.id,
       type: fm.type,
@@ -2573,10 +2610,16 @@ async function antiPatternsCheck(input, ctx) {
   }
   if (input.diff) {
     const tokens = tokenizeDiffForLiteral(input.diff);
+    const added = addedLinesFromDiff(input.diff);
+    const addedText = added.trim().length > 0 ? added : input.diff;
     if (tokens.length > 0) {
       for (const { memory } of negative) {
         if (literalMatchesAnyToken3(memory, tokens)) {
           upsert(memory.frontmatter, memory.body, "literal");
+          if (diffHasDistinctiveOverlap(addedText, memory.body, docFreq)) {
+            const w = seen.get(memory.frontmatter.id);
+            if (w) w.distinctive_literal = true;
+          }
         }
       }
     }
@@ -2629,19 +2672,19 @@ async function antiPatternsCheck(input, ctx) {
 }
 
 // src/tools/mem-distill.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadMemoriesFromDir as loadMemoriesFromDir19,
   tokenizeQuery as tokenizeQuery4
 } from "@hiveai/core";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var MemDistillInputSchema = {
-  since_days: z25.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
-  min_cluster: z25.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
-  type_filter: z25.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
+  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: z25.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([
@@ -2681,11 +2724,11 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync24(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 loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory }) => {
     const fm = memory.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -2789,22 +2832,22 @@ function firstHeading(body) {
 }
 
 // src/tools/why-this-decision.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import {
   deriveConfidence as deriveConfidence7,
-  getUsage as getUsage8,
-  loadMemoriesFromDir as loadMemoriesFromDir19,
-  loadUsageIndex as loadUsageIndex10,
+  getUsage as getUsage9,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
+  loadUsageIndex as loadUsageIndex11,
   pathsOverlap as singlePathsOverlap
 } from "@hiveai/core";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var WhyThisDecisionInputSchema = {
-  id: z26.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
-  git_log_limit: z26.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
+  id: z27.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
+  git_log_limit: z27.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync25(ctx.paths.memoriesDir)) {
+  if (!existsSync26(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -2813,8 +2856,8 @@ async function whyThisDecision(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex10(ctx.paths);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex11(ctx.paths);
   const target = all.find(({ memory }) => memory.frontmatter.id === input.id);
   if (!target) {
     return {
@@ -2826,7 +2869,7 @@ async function whyThisDecision(input, ctx) {
     };
   }
   const fm = target.memory.frontmatter;
-  const targetUsage = getUsage8(usage, fm.id);
+  const targetUsage = getUsage9(usage, fm.id);
   const decision = {
     id: fm.id,
     type: fm.type,
@@ -2843,7 +2886,7 @@ async function whyThisDecision(input, ctx) {
     const isExplicit = relatedSet.has(memory.frontmatter.id);
     const isBackLink = (memory.frontmatter.related_ids ?? []).includes(fm.id);
     if (!isExplicit && !isBackLink) continue;
-    const u = getUsage8(usage, memory.frontmatter.id);
+    const u = getUsage9(usage, memory.frontmatter.id);
     related.push({
       id: memory.frontmatter.id,
       type: memory.frontmatter.type,
@@ -2863,7 +2906,7 @@ async function whyThisDecision(input, ctx) {
         (p) => targetPaths.some((tp) => singlePathsOverlap(p, tp))
       );
       if (overlappingPaths.length === 0) continue;
-      const u = getUsage8(usage, memory.frontmatter.id);
+      const u = getUsage9(usage, memory.frontmatter.id);
       path_neighbors.push({
         id: memory.frontmatter.id,
         type: memory.frontmatter.type,
@@ -2936,33 +2979,33 @@ function runCommand2(cmd, args, cwd) {
 }
 
 // src/tools/mem-conflicts.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import {
   deriveConfidence as deriveConfidence8,
-  getUsage as getUsage9,
-  loadMemoriesFromDir as loadMemoriesFromDir20,
-  loadUsageIndex as loadUsageIndex11,
+  getUsage as getUsage10,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadUsageIndex as loadUsageIndex12,
   pathsOverlap as pathsOverlap2,
   tokenizeQuery as tokenizeQuery5
 } from "@hiveai/core";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var MemConflictsInputSchema = {
-  id: z27.string().min(1).describe("Memory id to check for conflicts."),
-  min_score: z27.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
-  semantic: z27.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
+  id: z28.string().min(1).describe("Memory id to check for conflicts."),
+  min_score: z28.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
+  semantic: z28.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 (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const target = all.find(({ memory }) => memory.frontmatter.id === input.id);
   if (!target) {
     return { found: false, scanned: 0, conflicts: [], notice: `Memory '${input.id}' not found.` };
   }
-  const usage = await loadUsageIndex11(ctx.paths);
+  const usage = await loadUsageIndex12(ctx.paths);
   const others = all.filter(
     ({ memory }) => memory.frontmatter.id !== input.id && memory.frontmatter.type !== "session_recap"
   );
@@ -3003,7 +3046,7 @@ async function memConflicts(input, ctx) {
       }
     }
     if (reasons.length === 0) continue;
-    const u = getUsage9(usage, fm.id);
+    const u = getUsage10(usage, fm.id);
     conflicts.push({
       id: fm.id,
       type: fm.type,
@@ -3069,17 +3112,17 @@ async function trySemanticSimilarities(ctx, target, others) {
 }
 
 // src/tools/precommit-check.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var PreCommitCheckInputSchema = {
-  diff: z28.string().optional().describe(
+  diff: z29.string().optional().describe(
     "Raw unified diff text to scan. If omitted, only `paths` is used. When called from a pre-commit hook, pipe the output of `git diff --cached`."
   ),
-  paths: z28.array(z28.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
-  block_on: z28.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
+  paths: z29.array(z29.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z29.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
     "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
   ),
-  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z28.boolean().default(false).describe(
+  semantic: z29.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z29.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."
   )
 };
@@ -3209,7 +3252,12 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
   const hasSemantic = warning.reasons.includes("semantic");
   const semanticScore = warning.semantic_score ?? 0;
   const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
-  if (anchoredBlocks && highConfidence && warning.scope !== "personal" && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
+  if (anchoredBlocks && highConfidence && warning.scope !== "personal" && warning.reasons.includes("anchor") && // A literal overlap only corroborates a BLOCK when it is on a token *distinctive*
+  // to this gotcha (rare in the corpus). Sharing a common domain word ("memory",
+  // "scope", "version") — or a version-bump diff — no longer hard-blocks; it falls
+  // through to `review` below. This kills the incidental-token false positives that
+  // made agents work for nothing. A moderate semantic match still corroborates.
+  (warning.distinctive_literal === true || hasSemantic && semanticScore >= 0.45)) {
     if (warning.has_sensor && !warning.reasons.includes("sensor")) {
       return {
         ...warning,
@@ -3361,7 +3409,7 @@ function repairTargetPathForWarning(warning, paths) {
 
 // src/tools/pattern-detect.ts
 import { mkdir as mkdir7, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import path11 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
@@ -3370,7 +3418,7 @@ import {
   readUsageEvents,
   serializeMemory as serializeMemory10
 } from "@hiveai/core";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var CONFIG_PATTERNS = [
   ".eslintrc",
   "eslint.config",
@@ -3393,12 +3441,12 @@ var CONFIG_PATTERNS = [
 var MAX_DIFF_BYTES = 4096;
 var HOT_FILE_MIN = 3;
 var PatternDetectInputSchema = {
-  since_days: z29.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
-  dry_run: z29.boolean().default(false).describe("When true, report matches without writing any memory files."),
-  scope: z29.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
+  since_days: z30.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
+  dry_run: z30.boolean().default(false).describe("When true, report matches without writing any memory files."),
+  scope: z30.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
 };
 async function patternDetect(input, ctx) {
-  if (!existsSync27(ctx.paths.haiveDir)) {
+  if (!existsSync28(ctx.paths.haiveDir)) {
     return {
       scanned_events: 0,
       matches: [],
@@ -3527,7 +3575,7 @@ async function patternDetect(input, ctx) {
         fm.id,
         void 0
       );
-      if (existsSync27(file)) continue;
+      if (existsSync28(file)) continue;
       await mkdir7(path11.dirname(file), { recursive: true });
       await writeFile12(
         file,
@@ -3573,25 +3621,25 @@ function gitFileDiff(root, file, sinceDays) {
 }
 
 // src/tools/mem-conflict-candidates.ts
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir21
+  loadMemoriesFromDir as loadMemoriesFromDir22
 } from "@hiveai/core";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var MemConflictCandidatesInputSchema = {
-  since_days: z30.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
-  types: z30.array(z30.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
-  min_jaccard: z30.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
-  max_pairs: z30.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
-  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
-  max_topic_pairs: z30.number().int().positive().max(100).default(20).describe(
+  since_days: z31.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z31.array(z31.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z31.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z31.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z31.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: z31.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 (!existsSync28(ctx.paths.memoriesDir)) {
+  if (!existsSync29(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -3600,7 +3648,7 @@ async function memConflictCandidates(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -3615,9 +3663,9 @@ async function memConflictCandidates(input, ctx) {
 
 // src/tools/mem-resolve-project.ts
 import { resolveProjectInfo } from "@hiveai/core";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var MemResolveProjectInputSchema = {
-  cwd: z31.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z32.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -3631,10 +3679,10 @@ async function memResolveProject(input, _ctx) {
 
 // src/tools/mem-suggest-topic.ts
 import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z32.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z33.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -3643,19 +3691,19 @@ async function memSuggestTopic(input, _ctx) {
 }
 
 // src/tools/mem-timeline.ts
-import { existsSync as existsSync29 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir22 } from "@hiveai/core";
-import { z as z33 } from "zod";
+import { existsSync as existsSync30 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir23 } from "@hiveai/core";
+import { z as z34 } from "zod";
 var MemTimelineInputSchema = {
-  memory_id: z33.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
-  topic: z33.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
-  limit: z33.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+  memory_id: z34.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z34.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z34.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync29(ctx.paths.memoriesDir)) {
+  if (!existsSync30(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
   const { entries, notice } = collectTimelineEntries(all, {
     memoryId: input.memory_id,
     topic: input.topic,
@@ -3666,11 +3714,11 @@ async function memTimeline(input, ctx) {
 
 // src/tools/runtime-journal-append.ts
 import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var RuntimeJournalAppendInputSchema = {
-  message: z34.string().min(1).describe("Short line to append to the runtime session journal"),
-  kind: z34.enum(["note", "session_end", "mcp"]).default("note"),
-  tool: z34.string().optional().describe("When kind=mcp, which tool name (optional)")
+  message: z35.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z35.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z35.string().optional().describe("When kind=mcp, which tool name (optional)")
 };
 async function runtimeJournalAppend(input, ctx) {
   await appendRuntimeJournalEntry2(ctx.paths, {
@@ -3686,9 +3734,9 @@ async function runtimeJournalAppend(input, ctx) {
 
 // src/tools/runtime-journal-tail.ts
 import { readRuntimeJournalTail } from "@hiveai/core";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var RuntimeJournalTailInputSchema = {
-  limit: z35.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+  limit: z36.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);
@@ -3699,12 +3747,12 @@ async function runtimeJournalTail(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z36.string().optional().describe(
+  module: z37.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z36.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z37.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -3786,10 +3834,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z37.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z37.array(z37.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z38.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z38.array(z38.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -3885,12 +3933,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z38.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z38.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z38.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z38.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z39.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z39.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z39.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z39.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -3956,7 +4004,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { hasRecentBriefingMarker, loadConfigSync } from "@hiveai/core";
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.10.9";
+var SERVER_VERSION = "0.12.0";
 function jsonResult(data) {
   return {
     content: [
@@ -3998,7 +4046,8 @@ var MAINTENANCE_PROFILE_TOOLS = [
   "anti_patterns_check",
   "mem_distill",
   "mem_timeline",
-  "mem_conflict_candidates"
+  "mem_conflict_candidates",
+  "mem_feedback"
 ];
 var EXPERIMENTAL_PROFILE_TOOLS = [
   ...MAINTENANCE_PROFILE_TOOLS,
@@ -4030,6 +4079,7 @@ var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_approve",
   "mem_reject",
   "mem_delete",
+  "mem_feedback",
   "runtime_journal_append",
   "pattern_detect"
 ]);
@@ -4525,6 +4575,28 @@ function createHaiveServer(options = {}) {
     MemRejectInputSchema,
     async (input) => jsonResult(await memReject(input, context))
   );
+  registerTool(
+    "mem_feedback",
+    [
+      "Record whether a memory actually HELPED \u2014 the closed-loop utility signal.",
+      "",
+      "USE right after a memory changed (or failed to change) what you did:",
+      "  - outcome='applied'  \u2192 the memory steered your work (strong positive signal)",
+      "  - outcome='rejected' \u2192 it was wrong/outdated/unhelpful (negative signal)",
+      "",
+      "A read only means a memory was surfaced; 'applied' means it demonstrably helped.",
+      "This powers `haive memory impact` (impact tiers + prune candidates) and future ranking.",
+      "",
+      "PARAMETERS:",
+      "  id      \u2014 full memory id the feedback is about",
+      "  outcome \u2014 'applied' | 'rejected'",
+      "  reason  \u2014 why it was rejected (optional, stored on the usage record)",
+      "",
+      "RETURNS: { ok, id, outcome, usage:{read_count,applied_count,rejected_count}, impact:{score,tier,signals} }"
+    ].join("\n"),
+    MemFeedbackInputSchema,
+    async (input) => jsonResult(await memFeedback(input, context))
+  );
   registerTool(
     "mem_pending",
     [