@hivelore/mcp 0.37.0 → 0.38.0

package/dist/server.js

@@ -1448,43 +1448,142 @@ async function memTried(input, ctx) {
   };
 }
 
-// src/tools/ingest-findings.ts
-import { existsSync as existsSync17 } from "fs";
+// src/tools/scaffold-test.ts
+import { existsSync as existsSync17, statSync } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile10 } from "fs/promises";
 import path7 from "path";
+import { z as z17 } from "zod";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  normalizeFramework,
+  parseLessonFields,
+  pickTestFramework,
+  scaffoldPostIncidentTest
+} from "@hivelore/core";
+var PY_SIGNALS = ["pyproject.toml", "setup.py", "pytest.ini", "requirements.txt", "tox.ini"];
+async function detectTestFrameworkForPaths(root, anchorPaths) {
+  const starts = anchorPaths.length > 0 ? anchorPaths : ["."];
+  for (const rel of starts) {
+    let dir = path7.resolve(root, rel);
+    try {
+      if (!statSync(dir).isDirectory()) dir = path7.dirname(dir);
+    } catch {
+      if (path7.extname(dir)) dir = path7.dirname(dir);
+    }
+    while (dir.startsWith(root)) {
+      const pkgJson = path7.join(dir, "package.json");
+      const hasPkg = existsSync17(pkgJson);
+      const goMod = existsSync17(path7.join(dir, "go.mod"));
+      const pySignal = PY_SIGNALS.some((s) => existsSync17(path7.join(dir, s)));
+      if (hasPkg || goMod || pySignal) {
+        let pkg = null;
+        if (hasPkg) {
+          try {
+            pkg = JSON.parse(await readFile4(pkgJson, "utf8"));
+          } catch {
+            pkg = null;
+          }
+        }
+        const baseDir = path7.relative(root, dir).split(path7.sep).join("/");
+        return { framework: pickTestFramework(pkg, { goMod, pySignal }), baseDir };
+      }
+      const parent = path7.dirname(dir);
+      if (parent === dir || dir === root) break;
+      dir = parent;
+    }
+  }
+  return { framework: "vitest", baseDir: "" };
+}
+var ScaffoldTestInputSchema = {
+  memory_id: z17.string().min(1).describe("Id of the attempt/gotcha lesson to scaffold a post-incident test from."),
+  framework: z17.enum(["vitest", "jest", "pytest", "gotest"]).optional().describe("Test framework. Auto-detected from the package that owns the lesson's anchor paths when omitted."),
+  out_path: z17.string().optional().describe("Override the generated test file path (repo-relative)."),
+  write: z17.boolean().default(true).describe("Write the file to disk (default). false = return the content for preview without writing.")
+};
+async function scaffoldTest(input, ctx) {
+  const loaded = existsSync17(ctx.paths.memoriesDir) ? await loadMemoriesFromDir14(ctx.paths.memoriesDir) : [];
+  const found = loaded.find(({ memory }) => memory.frontmatter.id === input.memory_id);
+  if (!found) {
+    return { ok: false, error: `No memory found with id ${input.memory_id}`, memory_id: input.memory_id };
+  }
+  const anchorPaths = found.memory.frontmatter.anchor.paths ?? [];
+  const detected = await detectTestFrameworkForPaths(ctx.paths.root, anchorPaths);
+  const framework = input.framework ? normalizeFramework(input.framework) ?? detected.framework : detected.framework;
+  const fields = parseLessonFields(found.memory.body);
+  const scaffold = scaffoldPostIncidentTest(
+    {
+      memoryId: input.memory_id,
+      title: fields.title || input.memory_id,
+      whyFailed: fields.whyFailed,
+      instead: fields.instead,
+      incident: found.memory.frontmatter.sensor?.incident,
+      paths: anchorPaths
+    },
+    { framework, outPath: input.out_path, baseDir: detected.baseDir }
+  );
+  const abs = path7.isAbsolute(scaffold.relPath) ? scaffold.relPath : path7.resolve(ctx.paths.root, scaffold.relPath);
+  let written = false;
+  let alreadyExists = false;
+  if (input.write) {
+    if (existsSync17(abs)) {
+      alreadyExists = true;
+    } else {
+      await mkdir4(path7.dirname(abs), { recursive: true });
+      await writeFile10(abs, scaffold.content, "utf8");
+      written = true;
+    }
+  }
+  return {
+    ok: true,
+    memory_id: input.memory_id,
+    framework,
+    path: scaffold.relPath,
+    run_command: scaffold.runCommand,
+    propose_command: scaffold.proposeCommand,
+    content: scaffold.content,
+    written,
+    already_exists: alreadyExists,
+    notice: alreadyExists ? "File already exists \u2014 not overwritten. Delete it or pass out_path to write elsewhere." : "PENDING test scaffolded. Fill in the assertion (RED on the incident, GREEN once fixed), run it, then arm it with propose_command \u2014 propose_sensor stays the sole validated writer."
+  };
+}
+
+// src/tools/ingest-findings.ts
+import { existsSync as existsSync18 } from "fs";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile11 } from "fs/promises";
+import path8 from "path";
 import {
   draftsFromFindings,
   filterNewDrafts,
-  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   memoryFilePath as memoryFilePath3,
   parseFindings,
   serializeMemory as serializeMemory9
 } from "@hivelore/core";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var IngestFindingsInputSchema = {
-  format: z17.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
-  report_path: z17.string().optional().describe("Project-relative path to the findings JSON file. Provide this OR `report`."),
-  report: z17.string().optional().describe("Inline findings JSON content. Provide this OR `report_path`."),
-  type: z17.enum(["gotcha", "convention"]).default("gotcha").describe("Memory type for the created drafts"),
-  scope: z17.enum(["personal", "team", "module"]).default("team").describe("Visibility scope for the created memories"),
-  module: z17.string().optional().describe("Module name (required when scope=module)"),
-  min_severity: z17.enum(["info", "minor", "major", "critical", "blocker"]).optional().describe("Ignore findings below this severity"),
-  include_stylistic: z17.boolean().optional().describe("Also ingest auto-fixable stylistic rules (semi/quotes/prefer-const\u2026); off by default as low-value noise"),
-  limit: z17.number().int().positive().optional().describe("Cap the number of memories created"),
-  author: z17.string().optional().describe("Author handle or email"),
-  dry_run: z17.boolean().default(false).describe("When true, return the drafts that WOULD be created without writing them")
+  format: z18.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
+  report_path: z18.string().optional().describe("Project-relative path to the findings JSON file. Provide this OR `report`."),
+  report: z18.string().optional().describe("Inline findings JSON content. Provide this OR `report_path`."),
+  type: z18.enum(["gotcha", "convention"]).default("gotcha").describe("Memory type for the created drafts"),
+  scope: z18.enum(["personal", "team", "module"]).default("team").describe("Visibility scope for the created memories"),
+  module: z18.string().optional().describe("Module name (required when scope=module)"),
+  min_severity: z18.enum(["info", "minor", "major", "critical", "blocker"]).optional().describe("Ignore findings below this severity"),
+  include_stylistic: z18.boolean().optional().describe("Also ingest auto-fixable stylistic rules (semi/quotes/prefer-const\u2026); off by default as low-value noise"),
+  limit: z18.number().int().positive().optional().describe("Cap the number of memories created"),
+  author: z18.string().optional().describe("Author handle or email"),
+  dry_run: z18.boolean().default(false).describe("When true, return the drafts that WOULD be created without writing them")
 };
 async function ingestFindings(input, ctx) {
-  if (!existsSync17(ctx.paths.haiveDir)) {
+  if (!existsSync18(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'hivelore init' first.`);
   }
   let raw;
   if (input.report && input.report.trim()) {
     raw = input.report;
   } else if (input.report_path) {
-    const file = path7.resolve(ctx.paths.root, input.report_path);
-    if (!existsSync17(file)) throw new Error(`Report file not found: ${file}`);
-    raw = await readFile4(file, "utf8");
+    const file = path8.resolve(ctx.paths.root, input.report_path);
+    if (!existsSync18(file)) throw new Error(`Report file not found: ${file}`);
+    raw = await readFile5(file, "utf8");
   } else {
     throw new Error("Provide either `report_path` or `report`.");
   }
@@ -1498,7 +1597,7 @@ async function ingestFindings(input, ctx) {
     ...input.include_stylistic ? { includeStylistic: true } : {},
     ...input.limit ? { limit: input.limit } : {}
   });
-  const existing = existsSync17(ctx.paths.memoriesDir) ? await loadMemoriesFromDir14(ctx.paths.memoriesDir) : [];
+  const existing = existsSync18(ctx.paths.memoriesDir) ? await loadMemoriesFromDir15(ctx.paths.memoriesDir) : [];
   const existingTopics = new Set(
     existing.map(({ memory }) => memory.frontmatter.topic).filter((t) => Boolean(t))
   );
@@ -1536,22 +1635,22 @@ async function writeDraft(ctx, draft) {
     draft.frontmatter.id,
     draft.frontmatter.module
   );
-  await mkdir4(path7.dirname(file), { recursive: true });
-  await writeFile10(file, serializeMemory9({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  await mkdir5(path8.dirname(file), { recursive: true });
+  await writeFile11(file, serializeMemory9({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
 
 // 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 { writeFile as writeFile13, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import path10 from "path";
 import {
   buildFrontmatter as buildFrontmatter3,
-  loadMemoriesFromDir as loadMemoriesFromDir15,
+  loadMemoriesFromDir as loadMemoriesFromDir16,
   memoryFilePath as memoryFilePath4,
   serializeMemory as serializeMemory10
 } from "@hivelore/core";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/session-tracker.ts
 import {
@@ -1560,12 +1659,12 @@ import {
   loadConfig as loadConfig2,
   writeSessionHandoff
 } from "@hivelore/core";
-import { mkdir as mkdir5, writeFile as writeFile11, rm } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path8 from "path";
+import { mkdir as mkdir6, writeFile as writeFile12, rm } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path9 from "path";
 import { execSync as execSync2 } from "child_process";
 function pendingDistillPath(ctx) {
-  return path8.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
+  return path9.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
 }
 var SessionTracker = class {
   events = [];
@@ -1669,7 +1768,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 && existsSync18(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync19(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -1682,9 +1781,9 @@ var SessionTracker = class {
             ...gitDiff ? { git_diff: gitDiff } : {},
             ...recapId ? { recap_id: recapId } : {}
           };
-          const cacheDir = path8.join(this.ctx.paths.haiveDir, ".cache");
-          await mkdir5(cacheDir, { recursive: true });
-          await writeFile11(
+          const cacheDir = path9.join(this.ctx.paths.haiveDir, ".cache");
+          await mkdir6(cacheDir, { recursive: true });
+          await writeFile12(
             pendingDistillPath(this.ctx),
             JSON.stringify(payload, null, 2) + "\n",
             "utf8"
@@ -1703,7 +1802,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync18(p)) {
+  if (existsSync19(p)) {
     try {
       await rm(p);
     } catch {
@@ -1720,15 +1819,15 @@ function summarizeTools(events) {
 
 // src/tools/mem-session-end.ts
 var MemSessionEndInputSchema = {
-  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(
+  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(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  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)")
+  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)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -1758,23 +1857,23 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync19(ctx.paths.haiveDir)) {
+  if (!existsSync20(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 || !path9.isAbsolute(p)) return p;
-    const rel = path9.relative(ctx.paths.root, p);
+    if (!p || !path10.isAbsolute(p)) return p;
+    const rel = path10.relative(ctx.paths.root, p);
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync19(path9.resolve(ctx.paths.root, p))
+    (p) => !existsSync20(path10.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync19(ctx.paths.memoriesDir) ? await loadMemoriesFromDir15(ctx.paths.memoriesDir) : [];
+  const existing = existsSync20(ctx.paths.memoriesDir) ? await loadMemoriesFromDir16(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
   );
@@ -1790,7 +1889,7 @@ async function memSessionEnd(input, ctx) {
         paths: normalizedFiles.length ? normalizedFiles : fm.anchor.paths
       }
     };
-    await writeFile12(
+    await writeFile13(
       topicMatch.filePath,
       serializeMemory10({ frontmatter: newFrontmatter, body }),
       "utf8"
@@ -1820,8 +1919,8 @@ async function memSessionEnd(input, ctx) {
     frontmatter.id,
     frontmatter.module
   );
-  await mkdir6(path9.dirname(file), { recursive: true });
-  await writeFile12(file, serializeMemory10({ frontmatter, body }), "utf8");
+  await mkdir7(path10.dirname(file), { recursive: true });
+  await writeFile13(file, serializeMemory10({ frontmatter, body }), "utf8");
   await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
@@ -1833,9 +1932,9 @@ async function memSessionEnd(input, ctx) {
 }
 
 // src/tools/get-briefing.ts
-import { readFile as readFile6, writeFile as writeFile13, readdir as readdir4 } from "fs/promises";
-import { existsSync as existsSync21 } from "fs";
-import path11 from "path";
+import { readFile as readFile7, writeFile as writeFile14, readdir as readdir4 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
+import path12 from "path";
 import {
   allocateBudget,
   assessBootstrapState,
@@ -1859,7 +1958,7 @@ import {
   loadConfig as loadConfig3,
   memoryHasExcludedTag,
   hashProjectContext,
-  loadMemoriesFromDir as loadMemoriesFromDir16,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
   loadPreventionEvents,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
@@ -1877,12 +1976,12 @@ import {
   truncateToTokens,
   writeBriefingMarker
 } from "@hivelore/core";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/tools/briefing-helpers.ts
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path10 from "path";
+import { readdir as readdir3, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import path11 from "path";
 import {
   classifyMemoryPriority as coreClassifyPriority,
   isGlobPath,
@@ -2015,16 +2114,16 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync20(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync21(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 = path10.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync20(file)) {
-      out.push({ name: m, content: await readFile5(file, "utf8") });
+    const file = path11.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync21(file)) {
+      out.push({ name: m, content: await readFile6(file, "utf8") });
     }
   }
   return out;
@@ -2032,38 +2131,38 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/get-briefing.ts
 var GetBriefingInputSchema = {
-  task: z19.string().optional().describe(
+  task: z20.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  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(
+  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(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  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(
+  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(
     "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: z19.boolean().default(true),
-  semantic: z19.boolean().default(true).describe(
+  include_module_contexts: z20.boolean().default(true),
+  semantic: z20.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `hivelore embeddings index`)."
   ),
-  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(
+  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(
     "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: z19.array(z19.string()).default([]).describe(
+  symbols: z20.array(z20.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: z19.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z20.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: z19.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z20.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 = z19.object(GetBriefingInputSchema);
+var GetBriefingZod = z20.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -2079,8 +2178,8 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync21(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
+  if (existsSync22(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir17(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()
     );
@@ -2254,7 +2353,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 writeFile13(loaded.filePath, serializeMemory11({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
+          await writeFile14(loaded.filePath, serializeMemory11({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -2262,7 +2361,7 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  let projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile6(ctx.paths.projectContext, "utf8") : "";
+  let projectContextRaw = input.include_project_context && existsSync22(ctx.paths.projectContext) ? await readFile7(ctx.paths.projectContext, "utf8") : "";
   let contextOmittedRecent = false;
   if (projectContextRaw && input.dedupe_project_context !== false) {
     const ctxHash = hashProjectContext(projectContextRaw);
@@ -2277,7 +2376,7 @@ async function getBriefing(input, ctx) {
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync21(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync22(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap(ctx.paths);
@@ -2451,8 +2550,8 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync21(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
+  if (existsSync22(ctx.paths.memoriesDir)) {
+    const allMems = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -2462,9 +2561,9 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync21(pendingDistillFile)) {
+  if (existsSync22(pendingDistillFile)) {
     try {
-      const raw = await readFile6(pendingDistillFile, "utf8");
+      const raw = await readFile7(pendingDistillFile, "utf8");
       const pd = JSON.parse(raw);
       const ageMs = Date.now() - new Date(pd.session_end).getTime();
       const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1e3;
@@ -2491,7 +2590,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync21(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync22(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
@@ -2506,10 +2605,10 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     try {
       let pcRaw = "";
       try {
-        pcRaw = await readFile6(ctx.paths.projectContext, "utf8");
+        pcRaw = await readFile7(ctx.paths.projectContext, "utf8");
       } catch {
       }
-      const allForBootstrap = existsSync21(ctx.paths.memoriesDir) ? await loadMemoriesFromDir16(ctx.paths.memoriesDir) : [];
+      const allForBootstrap = existsSync22(ctx.paths.memoriesDir) ? await loadMemoriesFromDir17(ctx.paths.memoriesDir) : [];
       const cmForBootstrap = await loadCodeMap(ctx.paths);
       let existingModules = [];
       try {
@@ -2573,7 +2672,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 && existsSync21(ctx.paths.haiveDir)) {
+  if (outputMemories.length > 0 && existsSync22(ctx.paths.haiveDir)) {
     const proof = briefingProofLine(await loadPreventionEvents(ctx.paths));
     if (proof) hints.push(proof);
   }
@@ -2587,7 +2686,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 (existsSync21(ctx.paths.haiveDir)) {
+  if (existsSync22(ctx.paths.haiveDir)) {
     await writeBriefingMarker(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -2643,10 +2742,10 @@ Invoke the \`bootstrap_repo\` MCP prompt, or close these gaps directly:
   };
 }
 async function detectRunCommands(root) {
-  const pkgPath = path11.join(root, "package.json");
-  if (!existsSync21(pkgPath)) return null;
+  const pkgPath = path12.join(root, "package.json");
+  if (!existsSync22(pkgPath)) return null;
   try {
-    const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
+    const pkg = JSON.parse(await readFile7(pkgPath, "utf8"));
     const scripts = pkg.scripts ?? {};
     const order = ["test", "build", "lint", "typecheck", "type-check", "dev", "start"];
     const lines = order.filter((name) => typeof scripts[name] === "string" && scripts[name].trim() !== "").map((name) => `- \`${name}\`: \`${scripts[name]}\``);
@@ -2711,24 +2810,24 @@ function oneLine(value) {
   return value.replace(/\s+/g, " ").replace(/"/g, '\\"').trim().slice(0, 120);
 }
 function serverVersion() {
-  return true ? "0.37.0" : "dev";
+  return true ? "0.38.0" : "dev";
 }
 
 // src/tools/code-map.ts
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hivelore/core";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var CodeMapInputSchema = {
-  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(
+  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(
     "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: 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(
+  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(
     "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 = z20.object(CodeMapInputSchema);
+var CodeMapInputZod = z21.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap2(ctx.paths);
   if (!map) {
@@ -2797,18 +2896,18 @@ function estimateFileEntryTokens(f) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync22 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir17 } from "@hivelore/core";
-import { z as z21 } from "zod";
+import { existsSync as existsSync23 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir18 } from "@hivelore/core";
+import { z as z22 } from "zod";
 var MemDiffInputSchema = {
-  id_a: z21.string().min(1).describe("First memory id"),
-  id_b: z21.string().min(1).describe("Second memory id")
+  id_a: z22.string().min(1).describe("First memory id"),
+  id_b: z22.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync22(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir18(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}".`);
@@ -2842,19 +2941,19 @@ async function memDiff(input, ctx) {
 }
 
 // src/tools/get-recap.ts
-import { existsSync as existsSync23 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir18 } from "@hivelore/core";
-import { z as z22 } from "zod";
+import { existsSync as existsSync24 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir19 } from "@hivelore/core";
+import { z as z23 } from "zod";
 var GetRecapInputSchema = {
-  scope: z22.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z23.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 (!existsSync23(ctx.paths.memoriesDir)) {
+  if (!existsSync24(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
-  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(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()
   );
@@ -2878,13 +2977,13 @@ async function getRecap(input, ctx) {
 }
 
 // src/tools/mem-relevant-to.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var MemRelevantToInputSchema = {
-  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.")
+  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.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -2914,14 +3013,14 @@ async function memRelevantTo(input, ctx) {
 }
 
 // src/tools/code-search.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import { loadCodeMap as loadCodeMap3 } from "@hivelore/core";
 var CodeSearchInputSchema = {
-  query: z24.string().min(1).describe(
+  query: z25.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: 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(
+  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(
     "Minimum cosine similarity. Hits below this threshold are dropped to avoid noise. Try 0.3+ for stricter matching."
   )
 };
@@ -2964,7 +3063,7 @@ async function codeSearch(input, ctx) {
 }
 
 // src/tools/anti-patterns-check.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
   BRIDGE_TARGET_PATH,
@@ -2974,7 +3073,7 @@ import {
   diffHasDistinctiveOverlap,
   getUsage as getUsage7,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir19,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
   loadUsageIndex as loadUsageIndex9,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3,
@@ -2983,19 +3082,19 @@ import {
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hivelore/core";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var AntiPatternsCheckInputSchema = {
-  diff: z25.string().optional().describe(
+  diff: z26.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: z25.array(z25.string()).default([]).describe(
+  paths: z26.array(z26.string()).default([]).describe(
     "File paths affected by the change. Memories anchored to any of these paths are surfaced regardless of the diff content."
   ),
-  limit: z25.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
-  semantic: z25.boolean().default(true).describe(
+  limit: z26.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
+  semantic: z26.boolean().default(true).describe(
     "When true, also use semantic search (requires @hivelore/embeddings + memory index) to find related anti-patterns."
   ),
-  min_semantic_score: z25.number().min(0).max(1).default(0.45).describe(
+  min_semantic_score: z26.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."
   )
 };
@@ -3079,10 +3178,10 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync25(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
-  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory }) => {
     const t = memory.frontmatter.type;
@@ -3198,19 +3297,19 @@ async function antiPatternsCheck(input, ctx) {
 }
 
 // src/tools/mem-distill.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir20,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
   tokenizeQuery as tokenizeQuery4
 } from "@hivelore/core";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var MemDistillInputSchema = {
-  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(
+  since_days: z27.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
+  min_cluster: z27.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
+  type_filter: z27.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: z26.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
+  scope: z27.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([
@@ -3250,11 +3349,11 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync25(ctx.paths.memoriesDir)) {
+  if (!existsSync26(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 loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory }) => {
     const fm = memory.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -3359,17 +3458,17 @@ function firstHeading(body) {
 
 // src/tools/precommit-check.ts
 import { pathsOverlap as pathsOverlap2 } from "@hivelore/core";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var PreCommitCheckInputSchema = {
-  diff: z27.string().optional().describe(
+  diff: z28.string().optional().describe(
     "Raw unified diff text to scan. If omitted, only `paths` is used. When called from a pre-commit hook, pipe the output of `git diff --cached`."
   ),
-  paths: 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(
+  paths: z28.array(z28.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z28.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
     "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
   ),
-  semantic: z27.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z27.boolean().default(false).describe(
+  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z28.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."
   )
 };
@@ -3675,14 +3774,14 @@ function repairTargetPathForWarning(warning, paths) {
 }
 
 // src/tools/mem-conflict-candidates.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadMemoriesFromDir as loadMemoriesFromDir22,
   planConflictResolution
 } from "@hivelore/core";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function suggestResolution(byId, idA, idB) {
   const a = byId.get(idA);
   const b = byId.get(idB);
@@ -3696,17 +3795,17 @@ function suggestResolution(byId, idA, idB) {
   };
 }
 var MemConflictCandidatesInputSchema = {
-  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(
+  since_days: z29.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z29.array(z29.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z29.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z29.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z29.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: z29.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 (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -3715,7 +3814,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 byId = new Map(all.map((m) => [m.memory.frontmatter.id, m]));
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
@@ -3745,9 +3844,9 @@ async function memConflictCandidates(input, ctx) {
 
 // src/tools/mem-resolve-project.ts
 import { resolveProjectInfo } from "@hivelore/core";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var MemResolveProjectInputSchema = {
-  cwd: z29.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z30.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -3761,10 +3860,10 @@ async function memResolveProject(input, _ctx) {
 
 // src/tools/mem-suggest-topic.ts
 import { MemoryTypeSchema, suggestTopicKey } from "@hivelore/core";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z30.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z31.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -3773,19 +3872,19 @@ async function memSuggestTopic(input, _ctx) {
 }
 
 // src/tools/mem-timeline.ts
-import { existsSync as existsSync27 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir22 } from "@hivelore/core";
-import { z as z31 } from "zod";
+import { existsSync as existsSync28 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir23 } from "@hivelore/core";
+import { z as z32 } from "zod";
 var MemTimelineInputSchema = {
-  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")
+  memory_id: z32.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z32.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z32.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync27(ctx.paths.memoriesDir)) {
+  if (!existsSync28(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,
@@ -3795,12 +3894,12 @@ async function memTimeline(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z32.string().optional().describe(
+  module: z33.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z32.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z33.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -3882,25 +3981,25 @@ ${template}\`\`\`
 }
 
 // src/prompts/bootstrap-repo.ts
-import { readFile as readFile7, readdir as readdir5 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
+import { readFile as readFile8, readdir as readdir5 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
 import {
   assessBootstrapState as assessBootstrapState2,
   loadCodeMap as loadCodeMap4,
-  loadMemoriesFromDir as loadMemoriesFromDir23,
+  loadMemoriesFromDir as loadMemoriesFromDir24,
   renderBootstrapChecklist as renderBootstrapChecklist2
 } from "@hivelore/core";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var BootstrapRepoArgsSchema = {
-  focus: z33.string().optional().describe("Optional area to emphasize first (e.g. 'payments', 'auth').")
+  focus: z34.string().optional().describe("Optional area to emphasize first (e.g. 'payments', 'auth').")
 };
 async function currentAssessment(ctx) {
   let projectContextRaw = "";
   try {
-    projectContextRaw = await readFile7(ctx.paths.projectContext, "utf8");
+    projectContextRaw = await readFile8(ctx.paths.projectContext, "utf8");
   } catch {
   }
-  const memories = existsSync28(ctx.paths.memoriesDir) ? await loadMemoriesFromDir23(ctx.paths.memoriesDir) : [];
+  const memories = existsSync29(ctx.paths.memoriesDir) ? await loadMemoriesFromDir24(ctx.paths.memoriesDir) : [];
   const codeMap = await loadCodeMap4(ctx.paths);
   let existingModules = [];
   try {
@@ -3968,10 +4067,10 @@ Main code areas detected: ${areas}
 }
 
 // src/prompts/post-task.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var PostTaskArgsSchema = {
-  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")
+  task_summary: z35.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z35.array(z35.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -4068,12 +4167,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var ImportDocsArgsSchema = {
-  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")
+  content: z36.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z36.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z36.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z36.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -4139,7 +4238,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.37.0";
+var SERVER_VERSION = "0.38.0";
 function jsonResult(data) {
   return {
     content: [
@@ -4162,7 +4261,8 @@ var ENFORCEMENT_PROFILE_TOOLS = [
   "code_search",
   "pre_commit_check",
   "mem_session_end",
-  "propose_sensor"
+  "propose_sensor",
+  "scaffold_test"
 ];
 var MAINTENANCE_PROFILE_TOOLS = [
   ...ENFORCEMENT_PROFILE_TOOLS,
@@ -4368,6 +4468,35 @@ function createHaiveServer(options = {}) {
       return jsonResult(await proposeSensor(input, context));
     }
   );
+  registerTool(
+    "scaffold_test",
+    [
+      "Generate a PENDING post-incident test from a lesson (attempt/gotcha) \u2014 the on-ramp to a command",
+      "sensor. A command sensor routes YOUR test as its oracle, but someone has to write it; this writes",
+      "the skeleton so you only fill in the assertion.",
+      "",
+      "USE THIS right after mem_tried when the mistake is behavioural (a regex can't express it): it",
+      "writes a stub carrying the incident's provenance and returns the exact `sensors propose --kind",
+      "test` command to arm it.",
+      "",
+      "It DOES NOT arm a sensor \u2014 propose_sensor stays the sole validated writer, and the stub is left",
+      "PENDING (todo/skip) so the suite stays green until you write the assertion. Monorepo-aware: the",
+      "framework and location come from the package that owns the lesson's anchor paths.",
+      "",
+      "PARAMETERS:",
+      "  memory_id \u2014 the attempt/gotcha to scaffold from",
+      "  framework \u2014 vitest | jest | pytest | gotest (auto-detected when omitted)",
+      "  out_path  \u2014 override the test file path (repo-relative)",
+      "  write     \u2014 write the file (default true); false returns the content for preview",
+      "",
+      "RETURNS: { ok, path, run_command, propose_command, content, written, already_exists, notice }"
+    ].join("\n"),
+    ScaffoldTestInputSchema,
+    async (input) => {
+      tracker.record("scaffold_test", input.memory_id);
+      return jsonResult(await scaffoldTest(input, context));
+    }
+  );
   registerTool(
     "ingest_findings",
     [
@@ -5064,6 +5193,7 @@ export {
   codeMapTool,
   codeSearch,
   createHaiveServer,
+  detectTestFrameworkForPaths,
   getAllowedToolsForProfile,
   getBriefing,
   getRecap,
@@ -5079,6 +5209,7 @@ export {
   printHaiveMcpVersion,
   proposeSensor,
   readPresumedCorrectTargets,
-  runHaiveMcpStdio
+  runHaiveMcpStdio,
+  scaffoldTest
 };
 //# sourceMappingURL=server.js.map