@hiveai/mcp 0.12.3 → 0.12.9

package/dist/index.js

@@ -1143,32 +1143,123 @@ async function memTried(input, ctx) {
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 
-// src/tools/mem-observe.ts
-import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
+// src/tools/ingest-findings.ts
 import { existsSync as existsSync16 } from "fs";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile8 } from "fs/promises";
 import path6 from "path";
 import {
-  buildFrontmatter as buildFrontmatter3,
-  isLikelyGuessable,
+  draftsFromFindings,
+  filterNewDrafts,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   memoryFilePath as memoryFilePath3,
+  parseFindings,
   serializeMemory as serializeMemory7
 } from "@hiveai/core";
 import { z as z16 } from "zod";
-var MemObserveInputSchema = {
-  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"),
+var IngestFindingsInputSchema = {
+  format: z16.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
+  report_path: z16.string().optional().describe("Project-relative path to the findings JSON file. Provide this OR `report`."),
+  report: z16.string().optional().describe("Inline findings JSON content. Provide this OR `report_path`."),
+  type: z16.enum(["gotcha", "convention"]).default("gotcha").describe("Memory type for the created drafts"),
+  scope: z16.enum(["personal", "team", "module"]).default("team").describe("Visibility scope for the created memories"),
   module: z16.string().optional().describe("Module name (required when scope=module)"),
-  tags: z16.array(z16.string()).default([]).describe("Tags for filtering"),
+  min_severity: z16.enum(["info", "minor", "major", "critical", "blocker"]).optional().describe("Ignore findings below this severity"),
+  limit: z16.number().int().positive().optional().describe("Cap the number of memories created"),
   author: z16.string().optional().describe("Author handle or email"),
-  force: z16.boolean().default(false).describe(
+  dry_run: z16.boolean().default(false).describe("When true, return the drafts that WOULD be created without writing them")
+};
+async function ingestFindings(input, ctx) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  let raw;
+  if (input.report && input.report.trim()) {
+    raw = input.report;
+  } else if (input.report_path) {
+    const file = path6.resolve(ctx.paths.root, input.report_path);
+    if (!existsSync16(file)) throw new Error(`Report file not found: ${file}`);
+    raw = await readFile3(file, "utf8");
+  } else {
+    throw new Error("Provide either `report_path` or `report`.");
+  }
+  const findings = parseFindings(input.format, raw);
+  const drafts = draftsFromFindings(findings, {
+    type: input.type,
+    scope: input.scope,
+    module: input.module,
+    author: input.author,
+    ...input.min_severity ? { minSeverity: input.min_severity } : {},
+    ...input.limit ? { limit: input.limit } : {}
+  });
+  const existing = existsSync16(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
+  const existingTopics = new Set(
+    existing.map(({ memory }) => memory.frontmatter.topic).filter((t) => Boolean(t))
+  );
+  const fresh = filterNewDrafts(drafts, existingTopics);
+  const skipped = drafts.length - fresh.length;
+  const created = [];
+  for (const draft of fresh) {
+    let filePath;
+    if (!input.dry_run) filePath = await writeDraft(ctx, draft);
+    created.push({
+      id: draft.frontmatter.id,
+      topic: draft.topic,
+      path: draft.finding.path,
+      rule: draft.finding.ruleId,
+      severity: draft.finding.severity,
+      has_sensor: draft.has_sensor,
+      ...filePath ? { file_path: filePath } : {}
+    });
+  }
+  const notice = input.dry_run ? `Dry run \u2014 ${fresh.length} memory(ies) would be created (status=proposed). Re-run with dry_run=false to write them.` : `Created ${fresh.length} proposed memory(ies). They are NOT validated and their sensors are warn-only \u2014 review with mem_pending and promote with 'haive sensors promote'.`;
+  return {
+    format: input.format,
+    parsed: drafts.length,
+    new: fresh.length,
+    skipped_existing: skipped,
+    dry_run: input.dry_run,
+    created,
+    notice
+  };
+}
+async function writeDraft(ctx, draft) {
+  const file = memoryFilePath3(
+    ctx.paths,
+    draft.frontmatter.scope,
+    draft.frontmatter.id,
+    draft.frontmatter.module
+  );
+  await mkdir4(path6.dirname(file), { recursive: true });
+  await writeFile8(file, serializeMemory7({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  return file;
+}
+
+// src/tools/mem-observe.ts
+import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path7 from "path";
+import {
+  buildFrontmatter as buildFrontmatter3,
+  isLikelyGuessable,
+  memoryFilePath as memoryFilePath4,
+  serializeMemory as serializeMemory8
+} from "@hiveai/core";
+import { z as z17 } from "zod";
+var MemObserveInputSchema = {
+  what: z17.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
+  where: z17.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
+  impact: z17.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
+  fix: z17.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
+  scope: z17.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+  module: z17.string().optional().describe("Module name (required when scope=module)"),
+  tags: z17.array(z17.string()).default([]).describe("Tags for filtering"),
+  author: z17.string().optional().describe("Author handle or email"),
+  force: z17.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 (!existsSync16(ctx.paths.haiveDir)) {
+  if (!existsSync17(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(" ");
@@ -1200,26 +1291,26 @@ async function memObserve(input, ctx) {
     lines.push("", `**Fix/workaround:** ${input.fix}`);
   }
   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 (existsSync16(file)) {
+  const file = memoryFilePath4(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir5(path7.dirname(file), { recursive: true });
+  if (existsSync17(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile8(file, serializeMemory7({ frontmatter, body }), "utf8");
+  await writeFile9(file, serializeMemory8({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 
 // src/tools/mem-session-end.ts
-import { writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path8 from "path";
+import { writeFile as writeFile11, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path9 from "path";
 import {
   buildFrontmatter as buildFrontmatter4,
-  loadMemoriesFromDir as loadMemoriesFromDir13,
-  memoryFilePath as memoryFilePath4,
-  serializeMemory as serializeMemory8
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  memoryFilePath as memoryFilePath5,
+  serializeMemory as serializeMemory9
 } from "@hiveai/core";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/session-tracker.ts
 import {
@@ -1227,12 +1318,12 @@ import {
   appendRuntimeJournalEntry,
   loadConfig as loadConfig2
 } from "@hiveai/core";
-import { mkdir as mkdir5, writeFile as writeFile9, rm } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import path7 from "path";
+import { mkdir as mkdir6, writeFile as writeFile10, rm } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path8 from "path";
 import { execSync } from "child_process";
 function pendingDistillPath(ctx) {
-  return path7.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
+  return path8.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
 }
 var SessionTracker = class {
   events = [];
@@ -1311,7 +1402,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 && existsSync17(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync18(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -1324,9 +1415,9 @@ var SessionTracker = class {
             ...gitDiff ? { git_diff: gitDiff } : {},
             ...recapId ? { recap_id: recapId } : {}
           };
-          const cacheDir = path7.join(this.ctx.paths.haiveDir, ".cache");
-          await mkdir5(cacheDir, { recursive: true });
-          await writeFile9(
+          const cacheDir = path8.join(this.ctx.paths.haiveDir, ".cache");
+          await mkdir6(cacheDir, { recursive: true });
+          await writeFile10(
             pendingDistillPath(this.ctx),
             JSON.stringify(payload, null, 2) + "\n",
             "utf8"
@@ -1345,7 +1436,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync17(p)) {
+  if (existsSync18(p)) {
     try {
       await rm(p);
     } catch {
@@ -1362,15 +1453,15 @@ function summarizeTools(events) {
 
 // src/tools/mem-session-end.ts
 var MemSessionEndInputSchema = {
-  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(
+  goal: z18.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z18.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z18.string().default("").describe(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  files_touched: 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)")
+  files_touched: z18.array(z18.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z18.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z18.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z18.string().optional().describe("Module name (required when scope=module)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -1400,23 +1491,23 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync18(ctx.paths.haiveDir)) {
+  if (!existsSync19(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const body = buildBody(input);
   const topic = recapTopic(input.scope, input.module);
   const normalizedFiles = input.files_touched.map((p) => {
-    if (!p || !path8.isAbsolute(p)) return p;
-    const rel = path8.relative(ctx.paths.root, p);
+    if (!p || !path9.isAbsolute(p)) return p;
+    const rel = path9.relative(ctx.paths.root, p);
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync18(path8.resolve(ctx.paths.root, p))
+    (p) => !existsSync19(path9.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync18(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
+  const existing = existsSync19(ctx.paths.memoriesDir) ? await loadMemoriesFromDir14(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
   );
@@ -1432,9 +1523,9 @@ async function memSessionEnd(input, ctx) {
         paths: normalizedFiles.length ? normalizedFiles : fm.anchor.paths
       }
     };
-    await writeFile10(
+    await writeFile11(
       topicMatch.filePath,
-      serializeMemory8({ frontmatter: newFrontmatter, body }),
+      serializeMemory9({ frontmatter: newFrontmatter, body }),
       "utf8"
     );
     await clearPendingDistill(ctx);
@@ -1456,14 +1547,14 @@ async function memSessionEnd(input, ctx) {
     topic,
     status: "validated"
   });
-  const file = memoryFilePath4(
+  const file = memoryFilePath5(
     ctx.paths,
     frontmatter.scope,
     frontmatter.id,
     frontmatter.module
   );
-  await mkdir6(path8.dirname(file), { recursive: true });
-  await writeFile10(file, serializeMemory8({ frontmatter, body }), "utf8");
+  await mkdir7(path9.dirname(file), { recursive: true });
+  await writeFile11(file, serializeMemory9({ frontmatter, body }), "utf8");
   await clearPendingDistill(ctx);
   return {
     id: frontmatter.id,
@@ -1475,8 +1566,8 @@ async function memSessionEnd(input, ctx) {
 }
 
 // src/tools/get-briefing.ts
-import { readFile as readFile4, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile5, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
 import {
   allocateBudget,
   computeImpact as computeImpact2,
@@ -1494,13 +1585,13 @@ import {
   literalMatchesAnyToken as literalMatchesAnyToken2,
   loadCodeMap,
   loadConfig as loadConfig3,
-  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   rankMemoriesLexical as rankMemoriesLexical2,
   queryCodeMap,
   resolveBriefingBudget,
-  serializeMemory as serializeMemory9,
+  serializeMemory as serializeMemory10,
   specificityScore,
   GUESSABLE_THRESHOLD,
   tokenizeQuery as tokenizeQuery2,
@@ -1508,12 +1599,12 @@ import {
   truncateToTokens,
   writeBriefingMarker
 } from "@hiveai/core";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/tools/briefing-helpers.ts
-import { readdir as readdir3, readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import path9 from "path";
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import path10 from "path";
 import { isGlobPath, isStackPackSeed, pathsOverlap } from "@hiveai/core";
 function compactSummary(body) {
   for (const line of body.split("\n")) {
@@ -1639,16 +1730,16 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync19(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync20(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
   const out = [];
   for (const m of modules) {
     if (!available.has(m)) continue;
-    const file = path9.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync19(file)) {
-      out.push({ name: m, content: await readFile3(file, "utf8") });
+    const file = path10.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync20(file)) {
+      out.push({ name: m, content: await readFile4(file, "utf8") });
     }
   }
   return out;
@@ -1656,35 +1747,35 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/get-briefing.ts
 var GetBriefingInputSchema = {
-  task: z18.string().optional().describe(
+  task: z19.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: 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(
+  files: z19.array(z19.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z19.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: 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(
+  max_memories: z19.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z19.boolean().default(true),
+  include_module_contexts: z19.boolean().default(true),
+  semantic: z19.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  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(
+  include_stale: z19.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z19.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z19.enum(["full", "compact", "actions"]).default("full").describe(
     "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
-  symbols: z18.array(z18.string()).default([]).describe(
+  symbols: z19.array(z19.string()).default([]).describe(
     "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
   ),
-  min_semantic_score: z18.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z19.number().min(0).max(1).default(0).describe(
     "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
   ),
-  budget_preset: z18.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z19.enum(["quick", "balanced", "deep"]).optional().describe(
     "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
-var GetBriefingZod = z18.object(GetBriefingInputSchema);
+var GetBriefingZod = z19.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -1700,8 +1791,8 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync20(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  if (existsSync21(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir15(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()
     );
@@ -1864,7 +1955,7 @@ async function getBriefing(input, ctx) {
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated" };
         try {
-          await writeFile11(loaded.filePath, serializeMemory9({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
+          await writeFile12(loaded.filePath, serializeMemory10({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -1872,12 +1963,12 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync20(ctx.paths.projectContext) ? await readFile4(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile5(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 || !existsSync20(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync21(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap(ctx.paths);
@@ -2038,8 +2129,8 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync20(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  if (existsSync21(ctx.paths.memoriesDir)) {
+    const allMems = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -2049,9 +2140,9 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync20(pendingDistillFile)) {
+  if (existsSync21(pendingDistillFile)) {
     try {
-      const raw = await readFile4(pendingDistillFile, "utf8");
+      const raw = await readFile5(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;
@@ -2078,7 +2169,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync20(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync21(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hasUnguessableSignal = outputMemories.some(
     (m) => (m.priority === "must_read" || m.priority === "useful") && specificityScore(m.body) >= GUESSABLE_THRESHOLD
@@ -2125,7 +2216,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 (existsSync20(ctx.paths.haiveDir)) {
+  if (existsSync21(ctx.paths.haiveDir)) {
     await writeBriefingMarker(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -2176,19 +2267,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 z19 } from "zod";
+import { z as z20 } from "zod";
 var CodeMapInputSchema = {
-  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(
+  file: z20.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z20.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  paths: z20.array(z20.string()).default([]).describe(
     "Filter to files under any of these path prefixes (e.g. ['packages/mcp/src/tools/', 'src/auth/']). OR-joined with `file` substring; useful to get a focused view of one module."
   ),
-  max_files: 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(
+  max_files: z20.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z20.number().int().positive().optional().describe(
     "Approximate token budget for the response. When the matching set exceeds it, files are ranked by export density (exports per LOC) and the highest-signal ones are kept first. Omit to disable budgeting (legacy behavior)."
   )
 };
-var CodeMapInputZod = z19.object(CodeMapInputSchema);
+var CodeMapInputZod = z20.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap2(ctx.paths);
   if (!map) {
@@ -2257,18 +2348,18 @@ function estimateFileEntryTokens(f) {
 }
 
 // src/tools/mem-diff.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 MemDiffInputSchema = {
-  id_a: z20.string().min(1).describe("First memory id"),
-  id_b: z20.string().min(1).describe("Second memory id")
+  id_a: z21.string().min(1).describe("First memory id"),
+  id_b: z21.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync21(ctx.paths.memoriesDir)) {
+  if (!existsSync22(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir16(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}".`);
@@ -2302,19 +2393,19 @@ async function memDiff(input, ctx) {
 }
 
 // src/tools/get-recap.ts
-import { existsSync as existsSync22 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir16 } from "@hiveai/core";
-import { z as z21 } from "zod";
+import { existsSync as existsSync23 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir17 } from "@hiveai/core";
+import { z as z22 } from "zod";
 var GetRecapInputSchema = {
-  scope: z21.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z22.enum(["personal", "team", "any"]).default("any").describe(
     "Limit to a specific scope's recap. Default 'any' returns the most recent recap across both personal and team scopes."
   )
 };
 async function getRecap(input, ctx) {
-  if (!existsSync22(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
-  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir17(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()
   );
@@ -2338,13 +2429,13 @@ async function getRecap(input, ctx) {
 }
 
 // src/tools/mem-relevant-to.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var MemRelevantToInputSchema = {
-  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.")
+  task: z23.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z23.array(z23.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z23.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z23.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z23.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -2374,13 +2465,13 @@ async function memRelevantTo(input, ctx) {
 }
 
 // src/tools/code-search.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var CodeSearchInputSchema = {
-  query: z23.string().min(1).describe(
+  query: z24.string().min(1).describe(
     "Natural-language description of what you are looking for in the codebase (e.g. 'function that hashes passwords', 'JWT signing logic', 'route registration')."
   ),
-  k: 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(
+  k: z24.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z24.number().min(0).max(1).default(0.2).describe(
     "Minimum cosine similarity. Hits below this threshold are dropped to avoid noise. Try 0.3+ for stricter matching."
   )
 };
@@ -2410,27 +2501,27 @@ async function codeSearch(input, ctx) {
 }
 
 // src/tools/why-this-file.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { spawn } from "child_process";
-import path10 from "path";
+import path11 from "path";
 import {
   deriveConfidence as deriveConfidence5,
   getUsage as getUsage7,
   loadCodeMap as loadCodeMap3,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadMemoriesFromDir as loadMemoriesFromDir18,
   loadUsageIndex as loadUsageIndex9,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
 } from "@hiveai/core";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var WhyThisFileInputSchema = {
-  path: z24.string().min(1).describe(
+  path: z25.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: 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.")
+  git_log_limit: z25.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
+  memory_limit: z25.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync23(path10.join(ctx.paths.root, input.path));
+  const fileExists = existsSync24(path11.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),
@@ -2471,8 +2562,8 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync23(ctx.paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  if (!existsSync24(ctx.paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex9(ctx.paths);
   const out = [];
   for (const { memory } of all) {
@@ -2526,7 +2617,7 @@ function runCommand(cmd, args, cwd) {
 }
 
 // src/tools/anti-patterns-check.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
   buildDocFrequency,
@@ -2535,7 +2626,7 @@ import {
   diffHasDistinctiveOverlap,
   getUsage as getUsage8,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadMemoriesFromDir as loadMemoriesFromDir19,
   loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
@@ -2543,19 +2634,19 @@ import {
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/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 @hiveai/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."
   )
 };
@@ -2576,10 +2667,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 loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory }) => {
     const t = memory.frontmatter.type;
@@ -2687,19 +2778,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 loadMemoriesFromDir19,
+  loadMemoriesFromDir as loadMemoriesFromDir20,
   tokenizeQuery as tokenizeQuery4
 } from "@hiveai/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([
@@ -2739,11 +2830,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 loadMemoriesFromDir19(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory }) => {
     const fm = memory.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -2847,22 +2938,22 @@ function firstHeading(body) {
 }
 
 // src/tools/why-this-decision.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import {
   deriveConfidence as deriveConfidence7,
   getUsage as getUsage9,
-  loadMemoriesFromDir as loadMemoriesFromDir20,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
   loadUsageIndex as loadUsageIndex11,
   pathsOverlap as singlePathsOverlap
 } from "@hiveai/core";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var WhyThisDecisionInputSchema = {
-  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.")
+  id: z28.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
+  git_log_limit: z28.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -2871,7 +2962,7 @@ async function whyThisDecision(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex11(ctx.paths);
   const target = all.find(({ memory }) => memory.frontmatter.id === input.id);
   if (!target) {
@@ -2994,28 +3085,28 @@ function runCommand2(cmd, args, cwd) {
 }
 
 // src/tools/mem-conflicts.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import {
   deriveConfidence as deriveConfidence8,
   getUsage as getUsage10,
-  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadMemoriesFromDir as loadMemoriesFromDir22,
   loadUsageIndex as loadUsageIndex12,
   pathsOverlap as pathsOverlap2,
   tokenizeQuery as tokenizeQuery5
 } from "@hiveai/core";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var MemConflictsInputSchema = {
-  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.")
+  id: z29.string().min(1).describe("Memory id to check for conflicts."),
+  min_score: z29.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
+  semantic: z29.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 (!existsSync27(ctx.paths.memoriesDir)) {
+  if (!existsSync28(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir22(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.` };
@@ -3127,17 +3218,17 @@ async function trySemanticSimilarities(ctx, target, others) {
 }
 
 // src/tools/precommit-check.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var PreCommitCheckInputSchema = {
-  diff: z29.string().optional().describe(
+  diff: z30.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: 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(
+  paths: z30.array(z30.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z30.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: z29.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z29.boolean().default(false).describe(
+  semantic: z30.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z30.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."
   )
 };
@@ -3423,17 +3514,17 @@ function repairTargetPathForWarning(warning, paths) {
 }
 
 // src/tools/pattern-detect.ts
-import { mkdir as mkdir7, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path11 from "path";
+import { mkdir as mkdir8, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
+import path12 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
   buildFrontmatter as buildFrontmatter5,
-  memoryFilePath as memoryFilePath5,
+  memoryFilePath as memoryFilePath6,
   readUsageEvents,
-  serializeMemory as serializeMemory10
+  serializeMemory as serializeMemory11
 } from "@hiveai/core";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var CONFIG_PATTERNS = [
   ".eslintrc",
   "eslint.config",
@@ -3456,12 +3547,12 @@ var CONFIG_PATTERNS = [
 var MAX_DIFF_BYTES = 4096;
 var HOT_FILE_MIN = 3;
 var PatternDetectInputSchema = {
-  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.")
+  since_days: z31.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
+  dry_run: z31.boolean().default(false).describe("When true, report matches without writing any memory files."),
+  scope: z31.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
 };
 async function patternDetect(input, ctx) {
-  if (!existsSync28(ctx.paths.haiveDir)) {
+  if (!existsSync29(ctx.paths.haiveDir)) {
     return {
       scanned_events: 0,
       matches: [],
@@ -3474,13 +3565,13 @@ async function patternDetect(input, ctx) {
   try {
     const changedFiles = gitChangedFiles(ctx.paths.root, input.since_days);
     const configFiles = changedFiles.filter(
-      (f) => CONFIG_PATTERNS.some((p) => path11.basename(f.toLowerCase()).includes(p))
+      (f) => CONFIG_PATTERNS.some((p) => path12.basename(f.toLowerCase()).includes(p))
     );
     for (const file of configFiles.slice(0, 5)) {
       const diff = gitFileDiff(ctx.paths.root, file, input.since_days);
       if (!diff) continue;
-      const parentDir = path11.basename(path11.dirname(file));
-      const baseName = path11.basename(file).replace(/\.[^.]+$/, "");
+      const parentDir = path12.basename(path12.dirname(file));
+      const baseName = path12.basename(file).replace(/\.[^.]+$/, "");
       const slug = `${parentDir}-${baseName}`.replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
       matches.push({
         kind: "config_change",
@@ -3544,7 +3635,7 @@ async function patternDetect(input, ctx) {
   for (const [p, { count, tools }] of pathCounts) {
     if (count < HOT_FILE_MIN) continue;
     if (tools.has("mem_tried") || tools.has("mem_observe")) continue;
-    if (CONFIG_PATTERNS.some((cp) => path11.basename(p).includes(cp))) continue;
+    if (CONFIG_PATTERNS.some((cp) => path12.basename(p).includes(cp))) continue;
     const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
     matches.push({
       kind: "hot_file",
@@ -3584,17 +3675,17 @@ async function patternDetect(input, ctx) {
         paths: match.anchor_paths,
         status: "proposed"
       });
-      const file = memoryFilePath5(
+      const file = memoryFilePath6(
         ctx.paths,
         fm.scope === "shared" ? "team" : fm.scope,
         fm.id,
         void 0
       );
-      if (existsSync28(file)) continue;
-      await mkdir7(path11.dirname(file), { recursive: true });
-      await writeFile12(
+      if (existsSync29(file)) continue;
+      await mkdir8(path12.dirname(file), { recursive: true });
+      await writeFile13(
         file,
-        serializeMemory10({ frontmatter: fm, body: match.proposed_body }),
+        serializeMemory11({ frontmatter: fm, body: match.proposed_body }),
         "utf8"
       );
       savedIds.push(fm.id);
@@ -3636,25 +3727,25 @@ function gitFileDiff(root, file, sinceDays) {
 }
 
 // src/tools/mem-conflict-candidates.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir22
+  loadMemoriesFromDir as loadMemoriesFromDir23
 } from "@hiveai/core";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var MemConflictCandidatesInputSchema = {
-  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(
+  since_days: z32.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z32.array(z32.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z32.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z32.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z32.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: z32.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 (!existsSync29(ctx.paths.memoriesDir)) {
+  if (!existsSync30(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -3663,7 +3754,7 @@ async function memConflictCandidates(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir22(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -3678,9 +3769,9 @@ async function memConflictCandidates(input, ctx) {
 
 // src/tools/mem-resolve-project.ts
 import { resolveProjectInfo } from "@hiveai/core";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var MemResolveProjectInputSchema = {
-  cwd: z32.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z33.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -3694,10 +3785,10 @@ async function memResolveProject(input, _ctx) {
 
 // src/tools/mem-suggest-topic.ts
 import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z33.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z34.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -3706,19 +3797,19 @@ async function memSuggestTopic(input, _ctx) {
 }
 
 // src/tools/mem-timeline.ts
-import { existsSync as existsSync30 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir23 } from "@hiveai/core";
-import { z as z34 } from "zod";
+import { existsSync as existsSync31 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir24 } from "@hiveai/core";
+import { z as z35 } from "zod";
 var MemTimelineInputSchema = {
-  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")
+  memory_id: z35.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z35.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z35.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync30(ctx.paths.memoriesDir)) {
+  if (!existsSync31(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir24(ctx.paths.memoriesDir);
   const { entries, notice } = collectTimelineEntries(all, {
     memoryId: input.memory_id,
     topic: input.topic,
@@ -3729,11 +3820,11 @@ async function memTimeline(input, ctx) {
 
 // src/tools/runtime-journal-append.ts
 import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var RuntimeJournalAppendInputSchema = {
-  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)")
+  message: z36.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z36.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z36.string().optional().describe("When kind=mcp, which tool name (optional)")
 };
 async function runtimeJournalAppend(input, ctx) {
   await appendRuntimeJournalEntry2(ctx.paths, {
@@ -3749,9 +3840,9 @@ async function runtimeJournalAppend(input, ctx) {
 
 // src/tools/runtime-journal-tail.ts
 import { readRuntimeJournalTail } from "@hiveai/core";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var RuntimeJournalTailInputSchema = {
-  limit: z36.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+  limit: z37.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);
@@ -3762,12 +3853,12 @@ async function runtimeJournalTail(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z37.string().optional().describe(
+  module: z38.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z37.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z38.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -3849,10 +3940,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var PostTaskArgsSchema = {
-  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")
+  task_summary: z39.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z39.array(z39.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -3922,7 +4013,7 @@ This creates/updates a single rolling recap that **get_briefing automatically su
 
 Calling \`mem_session_end\` also **clears the pending-distill marker** (if any), confirming that this session's learnings have been properly captured rather than left as an auto-recap skeleton.
 
-### 7. Verify the git/release exit protocol \u2014 always
+### 7. Verify the git/release/pipeline exit protocol \u2014 always
 Run **\`haive enforce finish\`** before your final response.
 
 This executable gate checks the multi-agent git-sync decision:
@@ -3930,11 +4021,12 @@ This executable gate checks the multi-agent git-sync decision:
 - shippable package changes have a lockstep version bump
 - the release tag \`vX.Y.Z\` exists when a version was bumped
 - commits and tags have been pushed
+- the pushed HEAD's GitHub Actions workflow runs have completed successfully when the repo has a GitHub remote
 - agents never run \`npm publish\` (publication remains human-owned)
 
-If it blocks, fix the reported Git/version/tag/push issue before telling the developer the task is done.
+If it blocks, fix the reported Git/version/tag/push/pipeline issue before telling the developer the task is done.
 
-When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved. hAIve finish gate passed."
+When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved. hAIve finish gate passed; GitHub Actions passed when applicable."
 `;
   return {
     description: "Post-task reflection: capture what you learned before closing the session",
@@ -3948,12 +4040,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
 }
 
 // src/prompts/import-docs.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var ImportDocsArgsSchema = {
-  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")
+  content: z40.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z40.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z40.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z40.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -4019,7 +4111,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.12.3";
+var SERVER_VERSION = "0.12.9";
 function jsonResult(data) {
   return {
     content: [
@@ -4062,7 +4154,8 @@ var MAINTENANCE_PROFILE_TOOLS = [
   "mem_distill",
   "mem_timeline",
   "mem_conflict_candidates",
-  "mem_feedback"
+  "mem_feedback",
+  "ingest_findings"
 ];
 var EXPERIMENTAL_PROFILE_TOOLS = [
   ...MAINTENANCE_PROFILE_TOOLS,
@@ -4096,7 +4189,8 @@ var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_delete",
   "mem_feedback",
   "runtime_journal_append",
-  "pattern_detect"
+  "pattern_detect",
+  "ingest_findings"
 ]);
 function createHaiveServer(options = {}) {
   const context = createContext(options);
@@ -4221,6 +4315,36 @@ function createHaiveServer(options = {}) {
       return jsonResult(await memTried(input, context));
     }
   );
+  registerTool(
+    "ingest_findings",
+    [
+      "Turn scanner findings (SonarQube / SARIF) into proposed, anchored memories with sensors.",
+      "",
+      "USE THIS to seed hAIve from your existing quality tooling: each real defect a scanner",
+      "found becomes a `gotcha`/`convention` memory anchored to the file, pre-filled with a",
+      "conservative `warn` sensor \u2014 so the next agent is steered away from it before re-writing it.",
+      "This closes the review\u2194memory loop and kills the cold-start problem.",
+      "",
+      "SAFETY: drafts are status=proposed and sensors are warn-only + autogen. This tool NEVER",
+      "auto-validates and NEVER auto-blocks. A human reviews (mem_pending) and promotes the sensor.",
+      "",
+      "PARAMETERS:",
+      "  format       \u2014 'sarif' (ESLint/Semgrep/CodeQL) | 'sonar' (SonarQube issues JSON)",
+      "  report_path  \u2014 project-relative path to the report file (OR pass `report` inline)",
+      "  report       \u2014 inline JSON content (OR pass `report_path`)",
+      "  type         \u2014 gotcha (default) | convention",
+      "  scope        \u2014 team (default) | personal | module",
+      "  min_severity \u2014 drop findings below this severity",
+      "  dry_run      \u2014 preview what would be created without writing",
+      "",
+      "RETURNS: { format, parsed, new, skipped_existing, created[], notice }"
+    ].join("\n"),
+    IngestFindingsInputSchema,
+    async (input) => {
+      tracker.record("ingest_findings", `${input.format}:${input.report_path ?? "inline"}`);
+      return jsonResult(await ingestFindings(input, context));
+    }
+  );
   registerTool(
     "mem_observe",
     [