@hiveai/cli 0.10.5 → 0.10.8

package/dist/index.js

@@ -3746,9 +3746,8 @@ import { mkdir as mkdir52, writeFile as writeFile92, rm } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
 import path72 from "path";
 import { execSync } from "child_process";
-import { readFile as readFile32, readdir as readdir3, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path92 from "path";
+import { readFile as readFile42, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
 import {
   allocateBudget,
   DEFAULT_AUTO_PROMOTE_RULE,
@@ -3757,11 +3756,9 @@ import {
   extractActionsBriefBody as extractActionsBriefBody2,
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
-  isGlobPath,
-  isRetiredMemory,
   isAutoPromoteEligible,
   isDecaying,
-  isStackPackSeed as isStackPackSeed2,
+  isRetiredMemory,
   literalMatchesAllTokens as literalMatchesAllTokens22,
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap5,
@@ -3769,7 +3766,6 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths22,
-  pathsOverlap,
   queryCodeMap as queryCodeMap2,
   resolveBriefingBudget as resolveBriefingBudget2,
   serializeMemory as serializeMemory9,
@@ -3781,17 +3777,21 @@ import {
   writeBriefingMarker as writeBriefingMarker2
 } from "@hiveai/core";
 import { z as z17 } from "zod";
+import { readdir as readdir3, readFile as readFile32 } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import path92 from "path";
+import { isGlobPath, isStackPackSeed as isStackPackSeed2, pathsOverlap } from "@hiveai/core";
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap22, queryCodeMap as queryCodeMap22 } from "@hiveai/core";
 import { z as z18 } from "zod";
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
 import { z as z19 } from "zod";
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
 import { z as z20 } from "zod";
 import { z as z21 } from "zod";
 import { z as z22 } from "zod";
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync222 } from "fs";
 import { spawn } from "child_process";
 import path102 from "path";
 import {
@@ -3803,7 +3803,7 @@ import {
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
 } from "@hiveai/core";
 import { z as z23 } from "zod";
-import { existsSync as existsSync222 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import {
   addedLinesFromDiff,
   deriveConfidence as deriveConfidence6,
@@ -3818,13 +3818,13 @@ import {
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
 import { z as z24 } from "zod";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import {
   loadMemoriesFromDir as loadMemoriesFromDir18,
   tokenizeQuery as tokenizeQuery4
 } from "@hiveai/core";
 import { z as z25 } from "zod";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import {
   deriveConfidence as deriveConfidence7,
@@ -3834,7 +3834,7 @@ import {
   pathsOverlap as singlePathsOverlap
 } from "@hiveai/core";
 import { z as z26 } from "zod";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import {
   deriveConfidence as deriveConfidence8,
   getUsage as getUsage9,
@@ -3846,7 +3846,7 @@ import {
 import { z as z27 } from "zod";
 import { z as z28 } from "zod";
 import { mkdir as mkdir72, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import path112 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
@@ -3856,7 +3856,7 @@ import {
   serializeMemory as serializeMemory10
 } from "@hiveai/core";
 import { z as z29 } from "zod";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
@@ -3867,7 +3867,7 @@ import { resolveProjectInfo } from "@hiveai/core";
 import { z as z31 } from "zod";
 import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
 import { z as z32 } from "zod";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir222 } from "@hiveai/core";
 import { z as z33 } from "zod";
 import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
@@ -3877,7 +3877,7 @@ import { z as z35 } from "zod";
 import { z as z36 } from "zod";
 import { z as z37 } from "zod";
 import { z as z38 } from "zod";
-import { loadConfigSync } from "@hiveai/core";
+import { hasRecentBriefingMarker, loadConfigSync } from "@hiveai/core";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
@@ -5108,6 +5108,144 @@ async function memSessionEnd(input, ctx) {
     revision_count: 0
   };
 }
+function compactSummary(body) {
+  for (const line of body.split("\n")) {
+    const trimmed = line.replace(/^#+\s*/, "").trim();
+    if (trimmed.length > 0) return trimmed.slice(0, 120);
+  }
+  return body.slice(0, 120);
+}
+function classifyMemoryPriority(memory2, loaded, inputFiles, inputSymbols) {
+  const fm = loaded?.memory.frontmatter;
+  const directAnchor = Boolean(
+    fm && inputFiles.length > 0 && fm.anchor.paths.some((p) => inputFiles.some((file) => pathsOverlap(p, file)))
+  );
+  const directSymbol = Boolean(
+    fm && inputSymbols.length > 0 && fm.anchor.symbols.some(
+      (sym) => inputSymbols.some((wanted) => wanted.toLowerCase() === sym.toLowerCase())
+    )
+  );
+  const strongSemantic = (memory2.semantic_score ?? 0) >= 0.65;
+  const usefulSemantic = (memory2.semantic_score ?? 0) >= 0.35;
+  if (fm?.requires_human_approval || directAnchor || directSymbol || memory2.type === "attempt" && (memory2.match_quality === "exact" || strongSemantic) || memory2.type === "skill" && (memory2.match_quality === "exact" || strongSemantic)) {
+    return "must_read";
+  }
+  if (isStackPackSeed2(fm)) {
+    return "background";
+  }
+  if (memory2.type === "skill" || memory2.reasons.includes("module") || memory2.reasons.includes("domain") || memory2.match_quality === "exact" || usefulSemantic) {
+    return "useful";
+  }
+  return "background";
+}
+function priorityRank(priority) {
+  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
+}
+function classifyBriefingQuality(memories, context) {
+  const mustRead = memories.filter((m) => m.priority === "must_read").length;
+  const useful = memories.filter((m) => m.priority === "useful").length;
+  const background = memories.filter((m) => m.priority === "background").length;
+  const weakSemantic = memories.filter(
+    (m) => m.reasons.length === 1 && m.reasons.includes("semantic") && (m.semantic_score ?? 0) > 0 && (m.semantic_score ?? 0) < 0.35
+  ).length;
+  const reasons = [];
+  if (memories.length === 0) reasons.push("no memories matched the task or files");
+  if (context.isTemplateContext && !context.autoContextGenerated) reasons.push("project context is still a template");
+  if (!context.hasLastSession) reasons.push("no previous session recap");
+  if (mustRead > 0) reasons.push(`${mustRead} must_read memor${mustRead === 1 ? "y" : "ies"} matched directly`);
+  if (useful > 0) reasons.push(`${useful} useful memor${useful === 1 ? "y" : "ies"} matched`);
+  if (background > useful + mustRead && background > 2) reasons.push(`${background} background memories dominate the result`);
+  if (weakSemantic > 0) reasons.push(`${weakSemantic} weak semantic-only match${weakSemantic === 1 ? "" : "es"}`);
+  if (context.searchMode === "literal_fallback") reasons.push("semantic index unavailable or empty; literal fallback used");
+  if (memories.length === 0 || mustRead === 0 && useful === 0) {
+    return { level: "thin", reasons };
+  }
+  if (background > useful + mustRead && background > 2) {
+    return { level: "noisy", reasons };
+  }
+  return { level: "strong", reasons };
+}
+function explainWhySurfaced(memory2, loaded, inputFiles, inferredModules) {
+  const why = [];
+  const fm = loaded?.memory.frontmatter;
+  if (memory2.reasons.includes("anchor") && fm) {
+    const matching = fm.anchor.paths.filter(
+      (p) => inputFiles.length === 0 || inputFiles.some((file) => pathsOverlap(p, file))
+    );
+    if (matching.length > 0) {
+      const exact = matching.filter(
+        (p) => !isGlobPath(p) && inputFiles.some((file) => p === file || pathsOverlap(p, file))
+      );
+      const glob = matching.filter((p) => isGlobPath(p));
+      if (exact.length > 0) {
+        why.push(`Exact/file anchor match: ${exact.slice(0, 4).join(", ")}`);
+      }
+      if (glob.length > 0) {
+        why.push(`Glob anchor match: ${glob.slice(0, 4).join(", ")}`);
+      }
+      if (exact.length === 0 && glob.length === 0) {
+        why.push(`Anchored to touched path${matching.length === 1 ? "" : "s"}: ${matching.slice(0, 4).join(", ")}`);
+      }
+    } else if (fm.anchor.paths.length > 0) {
+      why.push(`Pulled by related anchor: ${fm.anchor.paths.slice(0, 4).join(", ")}`);
+    }
+    if (fm.anchor.symbols.length > 0) {
+      why.push(`Anchor symbol${fm.anchor.symbols.length === 1 ? "" : "s"}: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
+    }
+  }
+  if (memory2.reasons.includes("symbol") && fm) {
+    why.push(`Explicit symbol match: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
+  }
+  if (memory2.reasons.includes("module")) {
+    const moduleHints = [
+      ...memory2.module ? [memory2.module] : [],
+      ...memory2.tags.filter((tag) => inferredModules.includes(tag))
+    ];
+    const shown = moduleHints.length > 0 ? [...new Set(moduleHints)].join(", ") : inferredModules.join(", ");
+    why.push(shown ? `Matched inferred module/tag: ${shown}` : "Matched inferred module context.");
+  }
+  if (memory2.reasons.includes("domain")) {
+    why.push("Matched inferred domain from the target file paths.");
+  }
+  if (memory2.reasons.includes("semantic")) {
+    const score = memory2.semantic_score !== void 0 ? ` score=${Math.round(memory2.semantic_score * 100) / 100}` : "";
+    why.push(`${memory2.match_quality === "exact" ? "Literal task match" : "Semantic/task relevance"}${score}.`);
+  }
+  why.push(`Confidence: ${memory2.confidence}; read ${memory2.read_count} time${memory2.read_count === 1 ? "" : "s"}.`);
+  if (memory2.type === "attempt") why.push("Failed-approach record; read before repeating the same path.");
+  if (memory2.type === "skill") why.push("Skill (reusable procedure/playbook) \u2014 follow the steps described when doing this type of task.");
+  if (memory2.status === "proposed" || memory2.status === "draft") {
+    why.push("Unvalidated record; use cautiously or ask a human before treating it as policy.");
+  }
+  return why;
+}
+async function trySemanticHits(ctx, task, limit) {
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    return null;
+  }
+  const result = await mod.semanticSearch(ctx.paths, task, { limit });
+  if (!result) return null;
+  return result.hits.map((h) => ({ id: h.id, score: h.score }));
+}
+async function loadModuleContexts2(ctx, modules) {
+  if (modules.length === 0) return [];
+  if (!existsSync18(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 = path92.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync18(file)) {
+      out.push({ name: m, content: await readFile32(file, "utf8") });
+    }
+  }
+  return out;
+}
 var GetBriefingInputSchema = {
   task: z17.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
@@ -5153,7 +5291,7 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync18(ctx.paths.memoriesDir)) {
+  if (existsSync19(ctx.paths.memoriesDir)) {
     const allLoaded = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
     const recaps = allLoaded.filter(({ memory: memory2 }) => memory2.frontmatter.type === "session_recap").sort(
       (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
@@ -5238,34 +5376,25 @@ async function getBriefing(input, ctx) {
     if (input.task) {
       const tokens = tokenizeQuery22(input.task);
       const andHits = allMemories.filter((m) => literalMatchesAllTokens22(m.memory, tokens));
-      for (const loaded of andHits) {
-        addOrUpdate(loaded, "semantic", void 0, "exact");
-      }
+      for (const loaded of andHits) addOrUpdate(loaded, "semantic", void 0, "exact");
       if (andHits.length === 0 && tokens.length > 1) {
         for (const loaded of allMemories) {
-          if (literalMatchesAnyToken22(loaded.memory, tokens)) {
-            addOrUpdate(loaded, "semantic", void 0, "partial");
-          }
+          if (literalMatchesAnyToken22(loaded.memory, tokens)) addOrUpdate(loaded, "semantic", void 0, "partial");
         }
       }
       if (semanticHits) {
         for (const hit of semanticHits) {
-          if (hit.score < input.min_semantic_score) {
-            const existing = seen.get(hit.id);
-            if (!existing) continue;
-          }
+          if (hit.score < input.min_semantic_score && !seen.has(hit.id)) continue;
           const loaded = byId.get(hit.id);
           if (loaded) addOrUpdate(loaded, "semantic", hit.score, "semantic");
         }
       }
     }
     const ranked = [...seen.values()].sort((a, b) => {
-      const priorityScore = (m) => priorityRank(classifyMemoryPriority(m, byId.get(m.id), input.files, input.symbols));
-      const reasonScore = (m) => (m.type === "attempt" ? 3 : 0) + // attempt = negative knowledge, surface first to prevent repeating mistakes
-      (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("symbol") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
+      const reasonScore = (m) => (m.type === "attempt" ? 3 : 0) + (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("symbol") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
       const confidenceScore = (m) => m.confidence === "authoritative" ? 4 : m.confidence === "trusted" ? 3 : m.confidence === "low" ? 1 : m.confidence === "stale" ? -2 : 0;
-      const sa = priorityScore(a) * 100 + reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
-      const sb = priorityScore(b) * 100 + reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
+      const sa = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
+      const sb = priorityRank(classifyMemoryPriority(b, byId.get(b.id), input.files, input.symbols)) * 100 + reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
     for (const mem of ranked.slice(0, briefingMaxMemories)) {
@@ -5294,11 +5423,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 writeFile11(loaded.filePath, serializeMemory9({ frontmatter: newFm, body: loaded.memory.body }), "utf8");
           m.status = "validated";
           m.confidence = "trusted";
         } catch {
@@ -5306,12 +5431,12 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync18(ctx.paths.projectContext) ? await readFile32(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync19(ctx.paths.projectContext) ? await readFile42(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 || !existsSync18(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync19(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap5(ctx.paths);
@@ -5347,15 +5472,9 @@ async function getBriefing(input, ctx) {
         );
       }
     } else {
-      if (isTemplateContext) {
-        setupWarnings.push(
-          "project-context.md still contains the default template. Invoke the bootstrap_project MCP prompt to auto-fill it from your codebase. Until then, get_briefing returns no project context."
-        );
-      } else {
-        setupWarnings.push(
-          "No project-context.md found. Run `haive init` then invoke the bootstrap_project MCP prompt."
-        );
-      }
+      setupWarnings.push(
+        isTemplateContext ? "project-context.md still contains the default template. Invoke the bootstrap_project MCP prompt to auto-fill it from your codebase. Until then, get_briefing returns no project context." : "No project-context.md found. Run `haive init` then invoke the bootstrap_project MCP prompt."
+      );
     }
   }
   const moduleContents = briefingIncludeModules ? await loadModuleContexts2(ctx, inferred) : [];
@@ -5418,10 +5537,7 @@ ${m.content}`).join("\n\n---\n\n"),
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
   }
-  const formattedMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({
-    ...m,
-    body: extractActionsBriefBody2(m.body)
-  })) : trimmedMemories;
+  const formattedMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({ ...m, body: extractActionsBriefBody2(m.body) })) : trimmedMemories;
   const outputMemories = formattedMemories.map((m) => ({
     ...m,
     priority: classifyMemoryPriority(m, byId.get(m.id), input.files, input.symbols),
@@ -5436,8 +5552,7 @@ ${m.content}`).join("\n\n---\n\n"),
   let symbolLocations;
   const symbolsToLookup = new Set(input.symbols);
   for (const m of outputMemories) {
-    const loaded = byId.get(m.id);
-    for (const sym of loaded?.memory.frontmatter.anchor.symbols ?? []) {
+    for (const sym of byId.get(m.id)?.memory.frontmatter.anchor.symbols ?? []) {
       symbolsToLookup.add(sym);
     }
   }
@@ -5465,41 +5580,37 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const actionRequired = [];
-  for (const m of outputMemories) {
-    const loaded = byId.get(m.id);
-    if (!loaded?.memory.frontmatter.requires_human_approval) continue;
-    const bodyLines = loaded.memory.body.split("\n");
+  const extractActionItem = (id, body) => {
+    const bodyLines = body.split("\n");
     const quoteBlock = bodyLines.filter((l) => l.startsWith("> ")).map((l) => l.slice(2)).join(" ").replace(/^\*«\s*/, "").replace(/\s*»\*$/, "").trim();
     const headingLine = bodyLines.find((l) => l.startsWith("## "));
-    const summary = headingLine?.replace(/^##\s*/, "").trim() ?? m.id;
-    actionRequired.push({
-      id: m.id,
+    const summary = headingLine?.replace(/^##\s*/, "").trim() ?? id;
+    return {
+      id,
       summary,
-      developer_message: quoteBlock || `Une modification externe potentiellement incompatible a \xE9t\xE9 d\xE9tect\xE9e (${m.id}). Veux-tu que j'analyse l'impact et que je propose des mises \xE0 jour ?`
-    });
+      developer_message: quoteBlock || `Une modification externe potentiellement incompatible a \xE9t\xE9 d\xE9tect\xE9e (${id}). Veux-tu que j'analyse l'impact et que je propose des mises \xE0 jour ?`
+    };
+  };
+  for (const m of outputMemories) {
+    const loaded = byId.get(m.id);
+    if (loaded?.memory.frontmatter.requires_human_approval) {
+      actionRequired.push(extractActionItem(m.id, loaded.memory.body));
+    }
   }
-  if (existsSync18(ctx.paths.memoriesDir)) {
+  if (existsSync19(ctx.paths.memoriesDir)) {
     const allMems = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
     for (const { memory: memory2 } of allMems) {
       const fm = memory2.frontmatter;
       if (!fm.requires_human_approval) continue;
       if (fm.status === "rejected" || fm.status === "deprecated") continue;
       if (actionRequired.some((a) => a.id === fm.id)) continue;
-      const bodyLines = memory2.body.split("\n");
-      const quoteBlock = bodyLines.filter((l) => l.startsWith("> ")).map((l) => l.slice(2)).join(" ").replace(/^\*«\s*/, "").replace(/\s*»\*$/, "").trim();
-      const headingLine = bodyLines.find((l) => l.startsWith("## "));
-      const summary = headingLine?.replace(/^##\s*/, "").trim() ?? fm.id;
-      actionRequired.push({
-        id: fm.id,
-        summary,
-        developer_message: quoteBlock || `Une modification externe potentiellement incompatible a \xE9t\xE9 d\xE9tect\xE9e (${fm.id}). Veux-tu que j'analyse l'impact et que je propose des mises \xE0 jour ?`
-      });
+      actionRequired.push(extractActionItem(fm.id, memory2.body));
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync18(pendingDistillFile)) {
+  if (existsSync19(pendingDistillFile)) {
     try {
-      const raw = await readFile32(pendingDistillFile, "utf8");
+      const raw = await readFile42(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;
@@ -5526,7 +5637,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync18(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync19(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hasUnguessableSignal = outputMemories.some(
     (m) => (m.priority === "must_read" || m.priority === "useful") && specificityScore2(m.body) >= GUESSABLE_THRESHOLD
@@ -5573,7 +5684,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 (existsSync18(ctx.paths.haiveDir)) {
+  if (existsSync19(ctx.paths.haiveDir)) {
     await writeBriefingMarker2(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -5621,144 +5732,6 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   };
 }
-function compactSummary(body) {
-  for (const line of body.split("\n")) {
-    const trimmed = line.replace(/^#+\s*/, "").trim();
-    if (trimmed.length > 0) return trimmed.slice(0, 120);
-  }
-  return body.slice(0, 120);
-}
-function classifyMemoryPriority(memory2, loaded, inputFiles, inputSymbols) {
-  const fm = loaded?.memory.frontmatter;
-  const directAnchor = Boolean(
-    fm && inputFiles.length > 0 && fm.anchor.paths.some((p) => inputFiles.some((file) => pathsOverlap(p, file)))
-  );
-  const directSymbol = Boolean(
-    fm && inputSymbols.length > 0 && fm.anchor.symbols.some(
-      (sym) => inputSymbols.some((wanted) => wanted.toLowerCase() === sym.toLowerCase())
-    )
-  );
-  const strongSemantic = (memory2.semantic_score ?? 0) >= 0.65;
-  const usefulSemantic = (memory2.semantic_score ?? 0) >= 0.35;
-  if (fm?.requires_human_approval || directAnchor || directSymbol || memory2.type === "attempt" && (memory2.match_quality === "exact" || strongSemantic) || memory2.type === "skill" && (memory2.match_quality === "exact" || strongSemantic)) {
-    return "must_read";
-  }
-  if (isStackPackSeed2(fm)) {
-    return "background";
-  }
-  if (memory2.type === "skill" || memory2.reasons.includes("module") || memory2.reasons.includes("domain") || memory2.match_quality === "exact" || usefulSemantic) {
-    return "useful";
-  }
-  return "background";
-}
-function priorityRank(priority) {
-  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
-}
-function classifyBriefingQuality(memories, context) {
-  const mustRead = memories.filter((m) => m.priority === "must_read").length;
-  const useful = memories.filter((m) => m.priority === "useful").length;
-  const background = memories.filter((m) => m.priority === "background").length;
-  const weakSemantic = memories.filter(
-    (m) => m.reasons.length === 1 && m.reasons.includes("semantic") && (m.semantic_score ?? 0) > 0 && (m.semantic_score ?? 0) < 0.35
-  ).length;
-  const reasons = [];
-  if (memories.length === 0) reasons.push("no memories matched the task or files");
-  if (context.isTemplateContext && !context.autoContextGenerated) reasons.push("project context is still a template");
-  if (!context.hasLastSession) reasons.push("no previous session recap");
-  if (mustRead > 0) reasons.push(`${mustRead} must_read memor${mustRead === 1 ? "y" : "ies"} matched directly`);
-  if (useful > 0) reasons.push(`${useful} useful memor${useful === 1 ? "y" : "ies"} matched`);
-  if (background > useful + mustRead && background > 2) reasons.push(`${background} background memories dominate the result`);
-  if (weakSemantic > 0) reasons.push(`${weakSemantic} weak semantic-only match${weakSemantic === 1 ? "" : "es"}`);
-  if (context.searchMode === "literal_fallback") reasons.push("semantic index unavailable or empty; literal fallback used");
-  if (memories.length === 0 || mustRead === 0 && useful === 0) {
-    return { level: "thin", reasons };
-  }
-  if (background > useful + mustRead && background > 2) {
-    return { level: "noisy", reasons };
-  }
-  return { level: "strong", reasons };
-}
-function explainWhySurfaced(memory2, loaded, inputFiles, inferredModules) {
-  const why = [];
-  const fm = loaded?.memory.frontmatter;
-  if (memory2.reasons.includes("anchor") && fm) {
-    const matching = fm.anchor.paths.filter(
-      (p) => inputFiles.length === 0 || inputFiles.some((file) => pathsOverlap(p, file))
-    );
-    if (matching.length > 0) {
-      const exact = matching.filter(
-        (p) => !isGlobPath(p) && inputFiles.some((file) => p === file || pathsOverlap(p, file))
-      );
-      const glob = matching.filter((p) => isGlobPath(p));
-      if (exact.length > 0) {
-        why.push(`Exact/file anchor match: ${exact.slice(0, 4).join(", ")}`);
-      }
-      if (glob.length > 0) {
-        why.push(`Glob anchor match: ${glob.slice(0, 4).join(", ")}`);
-      }
-      if (exact.length === 0 && glob.length === 0) {
-        why.push(`Anchored to touched path${matching.length === 1 ? "" : "s"}: ${matching.slice(0, 4).join(", ")}`);
-      }
-    } else if (fm.anchor.paths.length > 0) {
-      why.push(`Pulled by related anchor: ${fm.anchor.paths.slice(0, 4).join(", ")}`);
-    }
-    if (fm.anchor.symbols.length > 0) {
-      why.push(`Anchor symbol${fm.anchor.symbols.length === 1 ? "" : "s"}: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
-    }
-  }
-  if (memory2.reasons.includes("symbol") && fm) {
-    why.push(`Explicit symbol match: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
-  }
-  if (memory2.reasons.includes("module")) {
-    const moduleHints = [
-      ...memory2.module ? [memory2.module] : [],
-      ...memory2.tags.filter((tag) => inferredModules.includes(tag))
-    ];
-    const shown = moduleHints.length > 0 ? [...new Set(moduleHints)].join(", ") : inferredModules.join(", ");
-    why.push(shown ? `Matched inferred module/tag: ${shown}` : "Matched inferred module context.");
-  }
-  if (memory2.reasons.includes("domain")) {
-    why.push("Matched inferred domain from the target file paths.");
-  }
-  if (memory2.reasons.includes("semantic")) {
-    const score = memory2.semantic_score !== void 0 ? ` score=${Math.round(memory2.semantic_score * 100) / 100}` : "";
-    why.push(`${memory2.match_quality === "exact" ? "Literal task match" : "Semantic/task relevance"}${score}.`);
-  }
-  why.push(`Confidence: ${memory2.confidence}; read ${memory2.read_count} time${memory2.read_count === 1 ? "" : "s"}.`);
-  if (memory2.type === "attempt") why.push("Failed-approach record; read before repeating the same path.");
-  if (memory2.type === "skill") why.push("Skill (reusable procedure/playbook) \u2014 follow the steps described when doing this type of task.");
-  if (memory2.status === "proposed" || memory2.status === "draft") {
-    why.push("Unvalidated record; use cautiously or ask a human before treating it as policy.");
-  }
-  return why;
-}
-async function trySemanticHits(ctx, task, limit) {
-  let mod;
-  try {
-    mod = await import("@hiveai/embeddings");
-  } catch {
-    return null;
-  }
-  const result = await mod.semanticSearch(ctx.paths, task, { limit });
-  if (!result) return null;
-  return result.hits.map((h) => ({ id: h.id, score: h.score }));
-}
-async function loadModuleContexts2(ctx, modules) {
-  if (modules.length === 0) return [];
-  if (!existsSync18(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 = path92.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync18(file)) {
-      out.push({ name: m, content: await readFile32(file, "utf8") });
-    }
-  }
-  return out;
-}
 var CodeMapInputSchema = {
   file: z18.string().optional().describe("Filter to files whose path contains this substring"),
   symbol: z18.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
@@ -5842,7 +5815,7 @@ var MemDiffInputSchema = {
   id_b: z19.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync19(ctx.paths.memoriesDir)) {
+  if (!existsSync20(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
   const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
@@ -5883,7 +5856,7 @@ var GetRecapInputSchema = {
   )
 };
 async function getRecap(input, ctx) {
-  if (!existsSync20(ctx.paths.memoriesDir)) {
+  if (!existsSync21(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
   const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
@@ -5982,7 +5955,7 @@ var WhyThisFileInputSchema = {
   memory_limit: z23.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync21(path102.join(ctx.paths.root, input.path));
+  const fileExists = existsSync222(path102.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),
@@ -6023,7 +5996,7 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync21(ctx.paths.memoriesDir)) return [];
+  if (!existsSync222(ctx.paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex8(ctx.paths);
   const out = [];
@@ -6155,7 +6128,7 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync222(ctx.paths.memoriesDir)) {
+  if (!existsSync23(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
   const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
@@ -6190,6 +6163,7 @@ async function antiPatternsCheck(input, ctx) {
       reasons: [reason],
       tags: fm.tags ?? [],
       anchor_paths: fm.anchor?.paths ?? [],
+      ...fm.sensor != null ? { has_sensor: true } : {},
       ...score !== void 0 ? { semantic_score: score } : {}
     });
   };
@@ -6302,7 +6276,7 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync23(ctx.paths.memoriesDir)) {
+  if (!existsSync24(ctx.paths.memoriesDir)) {
     return { scanned: 0, singletons: 0, clusters: [], notice: "No .ai/memories directory." };
   }
   const cutoff = Date.now() - input.since_days * MS_PER_DAY;
@@ -6413,7 +6387,7 @@ var WhyThisDecisionInputSchema = {
   git_log_limit: z26.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync25(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -6551,7 +6525,7 @@ var MemConflictsInputSchema = {
 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 (!existsSync25(ctx.paths.memoriesDir)) {
+  if (!existsSync26(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
   const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
@@ -6772,6 +6746,15 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
     };
   }
   if (isBlockingWarning(warning)) {
+    if (warning.has_sensor && !warning.reasons.includes("sensor")) {
+      return {
+        ...warning,
+        level: "review",
+        rationale: "memory has a sensor that did not fire \u2014 sensor is the authoritative check; strong semantic match alone is insufficient to block",
+        affected_files: affectedFiles,
+        repair_command: repairCommand
+      };
+    }
     return {
       ...warning,
       level: "blocking",
@@ -6784,6 +6767,15 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
   const semanticScore = warning.semantic_score ?? 0;
   const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
   if (anchoredBlocks && highConfidence && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
+    if (warning.has_sensor && !warning.reasons.includes("sensor")) {
+      return {
+        ...warning,
+        level: "review",
+        rationale: "memory has a sensor that did not fire \u2014 literal match alone is insufficient to block; sensor is the authoritative check",
+        affected_files: affectedFiles,
+        repair_command: repairCommand
+      };
+    }
     return {
       ...warning,
       level: "blocking",
@@ -6938,7 +6930,7 @@ var PatternDetectInputSchema = {
   scope: z29.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
 };
 async function patternDetect(input, ctx) {
-  if (!existsSync26(ctx.paths.haiveDir)) {
+  if (!existsSync27(ctx.paths.haiveDir)) {
     return {
       scanned_events: 0,
       matches: [],
@@ -7067,7 +7059,7 @@ async function patternDetect(input, ctx) {
         fm.id,
         void 0
       );
-      if (existsSync26(file)) continue;
+      if (existsSync27(file)) continue;
       await mkdir72(path112.dirname(file), { recursive: true });
       await writeFile12(
         file,
@@ -7122,7 +7114,7 @@ var MemConflictCandidatesInputSchema = {
   )
 };
 async function memConflictCandidates(input, ctx) {
-  if (!existsSync27(ctx.paths.memoriesDir)) {
+  if (!existsSync28(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -7170,7 +7162,7 @@ var MemTimelineInputSchema = {
   limit: z33.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync28(ctx.paths.memoriesDir)) {
+  if (!existsSync29(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
   const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
@@ -7442,7 +7434,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.10.5";
+var SERVER_VERSION = "0.10.8";
 function jsonResult(data) {
   return {
     content: [
@@ -7546,11 +7538,16 @@ function createHaiveServer(options = {}) {
           return await handler(input);
         }
         if (requireBriefingFirst && MUTATING_TOOLS.has(name) && !briefingLoaded) {
-          return jsonResult({
-            error: "haive_briefing_required",
-            message: "This hAIve project requires get_briefing or mem_relevant_to before state-changing hAIve tools. Call get_briefing({ task: '...' }) first.",
-            tool: name
-          });
+          const hasDiskMarker = await hasRecentBriefingMarker(context.paths).catch(() => false);
+          if (hasDiskMarker) {
+            briefingLoaded = true;
+          } else {
+            return jsonResult({
+              error: "haive_briefing_required",
+              message: "This hAIve project requires get_briefing or mem_relevant_to before state-changing hAIve tools. Call get_briefing({ task: '...' }) first.",
+              tool: name
+            });
+          }
         }
         return await handler(input);
       }
@@ -8412,7 +8409,7 @@ function registerMcp(program2) {
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { readFile as readFile9, writeFile as writeFile13, mkdir as mkdir10 } from "fs/promises";
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import path15 from "path";
 import "commander";
 import {
@@ -8449,7 +8446,7 @@ function registerSync(program2) {
   ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").option("--dry-run", "report what would change without writing any files").action(async (opts) => {
     const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync29(paths.memoriesDir)) {
+    if (!existsSync30(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -8873,7 +8870,7 @@ function bridgeSummaryLine(body) {
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync29(memoriesDir)) return;
+  if (!existsSync30(memoriesDir)) return;
   const all = await loadMemoriesFromDir23(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
@@ -8899,7 +8896,7 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync29(bridgeFile);
+  const fileExists = existsSync30(bridgeFile);
   let existing = fileExists ? await readFile9(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
@@ -8950,7 +8947,7 @@ function collectSinceChanges(root, ref) {
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import path16 from "path";
 import "commander";
 import {
@@ -8992,7 +8989,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync30(paths.haiveDir)) {
+    if (!existsSync31(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9004,7 +9001,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync30(path16.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync31(path16.resolve(root, p)));
       if (missing.length > 0) {
         ui.warn(`Anchor path${missing.length > 1 ? "s" : ""} not found in project:`);
         for (const p of missing) ui.warn(`  \u2717 ${p}`);
@@ -9017,7 +9014,7 @@ function registerMemoryAdd(memory2) {
     const slug = slugify(opts.slug ?? opts.title ?? opts.topic ?? opts.body ?? `${opts.type}-memory`);
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync30(opts.bodyFile)) {
+      if (!existsSync31(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9033,7 +9030,7 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync30(paths.memoriesDir)) {
+    if (existsSync31(paths.memoriesDir)) {
       const incomingHash = createHash2("sha256").update(body.trim()).digest("hex").slice(0, 12);
       const allForHash = await loadMemoriesFromDir24(paths.memoriesDir);
       const hashDup = allForHash.find(
@@ -9046,7 +9043,7 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync30(paths.memoriesDir)) {
+    if (opts.topic && existsSync31(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir24(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
@@ -9091,12 +9088,12 @@ TODO \u2014 write the memory body.
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir11(path16.dirname(file), { recursive: true });
-    if (existsSync30(file)) {
+    if (existsSync31(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync30(paths.memoriesDir)) {
+    if (existsSync31(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir24(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
@@ -9188,7 +9185,7 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import path17 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot14, resolveHaivePaths as resolveHaivePaths11 } from "@hiveai/core";
@@ -9205,7 +9202,7 @@ function registerMemoryList(memory2) {
   memory2.command("list").description("List memories with optional filters").option("--scope <scope>", "personal | team | module").option("--type <type>", "filter by type").option("--tag <tag>", "filter by tag").option("--module <name>", "filter by module name").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("--limit <n>", "max memories to display").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync31(paths.memoriesDir)) {
+    if (!existsSync33(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9280,7 +9277,7 @@ function matchesFilters(loaded, opts) {
 
 // src/commands/memory-promote.ts
 import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import path18 from "path";
 import "commander";
 import {
@@ -9293,7 +9290,7 @@ function registerMemoryPromote(memory2) {
   memory2.command("promote <id>").description("Promote a personal memory to team scope (status -> proposed)").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync33(paths.memoriesDir)) {
+    if (!existsSync34(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9338,7 +9335,7 @@ function registerMemoryPromote(memory2) {
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
 import path19 from "path";
 import "commander";
@@ -9351,7 +9348,7 @@ function registerMemoryApprove(memory2) {
   memory2.command("approve [id]").description("Mark a memory as 'validated'. Use --all to bulk-approve all proposed/draft memories.").option("--all", "approve all proposed and draft memories at once").option("--pending", "approve all memories with status 'proposed'").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9410,7 +9407,7 @@ function registerMemoryApprove(memory2) {
 
 // src/commands/memory-update.ts
 import { readFile as readFile11, writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import path20 from "path";
 import "commander";
 import {
@@ -9422,7 +9419,7 @@ function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync35(paths.memoriesDir)) {
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9464,7 +9461,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync35(opts.bodyFile)) {
+      if (!existsSync36(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9510,7 +9507,7 @@ function parseCsv3(value) {
 
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import path21 from "path";
 import "commander";
 import {
@@ -9530,7 +9527,7 @@ function registerMemoryAutoPromote(memory2) {
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9573,7 +9570,7 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 import path23 from "path";
 import "commander";
@@ -9586,7 +9583,7 @@ function registerMemoryEdit(memory2) {
   memory2.command("edit <id>").description("Open a memory in $EDITOR and re-validate when you save").option("-e, --editor <cmd>", "editor command (defaults to $EDITOR or 'vi')").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9626,7 +9623,7 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import path24 from "path";
 import "commander";
 import {
@@ -9642,7 +9639,7 @@ function registerMemoryForFiles(memory2) {
   memory2.command("for-files <files...>").description("Show memories relevant to the given files (anchor overlap, module, domain)").option("-d, --dir <dir>", "project root").action(async (files, opts) => {
     const root = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync38(paths.memoriesDir)) {
+    if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9754,7 +9751,7 @@ function printGroup(root, label, loaded, usage) {
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import path25 from "path";
 import "commander";
 import {
@@ -9769,7 +9766,7 @@ function registerMemoryHot(memory2) {
   ).option("--threshold <n>", "minimum read_count to qualify (default: 3)", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    if (!existsSync40(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9808,7 +9805,7 @@ function registerMemoryHot(memory2) {
 
 // src/commands/memory-tried.ts
 import { mkdir as mkdir13, writeFile as writeFile19 } from "fs/promises";
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path26 from "path";
 import "commander";
 import {
@@ -9838,7 +9835,7 @@ function registerMemoryTried(memory2) {
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync40(paths.haiveDir)) {
+    if (!existsSync41(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9866,7 +9863,7 @@ function registerMemoryTried(memory2) {
     }
     const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir13(path26.dirname(file), { recursive: true });
-    if (existsSync40(file)) {
+    if (existsSync41(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
@@ -9884,7 +9881,7 @@ function parseCsv4(value) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile13 } from "fs/promises";
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import path27 from "path";
 import "commander";
 import {
@@ -9924,7 +9921,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync41(paths.haiveDir)) {
+    if (!existsSync43(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9980,7 +9977,7 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import path28 from "path";
 import "commander";
 import {
@@ -9993,7 +9990,7 @@ function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -10051,7 +10048,7 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import path29 from "path";
 import "commander";
 import {
@@ -10068,7 +10065,7 @@ function registerMemoryQuery(memory2) {
   memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
     const root = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10127,7 +10124,7 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot26,
@@ -10141,7 +10138,7 @@ function registerMemoryReject(memory2) {
   memory2.command("reject <id>").description("Record a rejection (blocks auto-promotion and lowers confidence)").option("-r, --reason <reason>", "why this memory is being rejected").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -10177,7 +10174,7 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import path30 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
@@ -10192,7 +10189,7 @@ function registerMemoryRm(memory2) {
   memory2.command("rm <id>").description("Delete a memory file (and its usage entry by default)").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -10228,7 +10225,7 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 import { readFile as readFile14 } from "fs/promises";
 import path31 from "path";
 import "commander";
@@ -10243,7 +10240,7 @@ function registerMemoryShow(memory2) {
   memory2.command("show <id>").description("Print a memory's frontmatter, body, and confidence/usage").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -10287,7 +10284,7 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import path33 from "path";
 import "commander";
 import {
@@ -10301,7 +10298,7 @@ function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync49(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10333,7 +10330,7 @@ function registerMemoryStats(memory2) {
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import path34 from "path";
 import "commander";
 import {
@@ -10348,7 +10345,7 @@ function registerMemoryVerify(memory2) {
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("--json", "emit machine-readable JSON (for CI / agents)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot30(opts.dir);
     const paths = resolveHaivePaths27(root);
-    if (!existsSync49(paths.memoriesDir)) {
+    if (!existsSync50(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -10469,7 +10466,7 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile15 } from "fs/promises";
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot31,
@@ -10481,12 +10478,12 @@ function registerMemoryImport(memory2) {
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths28(root);
-    if (!existsSync50(paths.haiveDir)) {
+    if (!existsSync51(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync50(opts.from)) {
+    if (!existsSync51(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -10519,7 +10516,7 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
 import path35 from "path";
 import "commander";
@@ -10594,7 +10591,7 @@ function registerMemoryImportChangelog(memory2) {
     const root = findProjectRoot32(opts.dir);
     const paths = resolveHaivePaths29(root);
     const changelogPath = path35.resolve(root, opts.fromChangelog);
-    if (!existsSync51(changelogPath)) {
+    if (!existsSync53(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -10681,7 +10678,7 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
 import path36 from "path";
 import "commander";
@@ -10706,7 +10703,7 @@ function registerMemoryDigest(program2) {
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot33(opts.dir);
     const paths = resolveHaivePaths30(root);
-    if (!existsSync53(paths.memoriesDir)) {
+    if (!existsSync54(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10789,7 +10786,7 @@ function registerMemoryDigest(program2) {
 
 // src/commands/session-end.ts
 import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path37 from "path";
 import "commander";
@@ -10803,7 +10800,7 @@ import {
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync54(obsFile)) return await buildGitAutoRecap(paths);
+  if (!existsSync55(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile17(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -10994,7 +10991,7 @@ function registerSessionEnd(session2) {
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths31(root);
-    if (!existsSync54(paths.haiveDir)) {
+    if (!existsSync55(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -11027,7 +11024,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync54(path37.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync55(path37.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
@@ -11035,10 +11032,10 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync54(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync55(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync54(paths.memoriesDir)) {
+    if (existsSync55(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir27(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -11100,7 +11097,7 @@ function normalizeAnchorPath(root, filePath) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path38 from "path";
 import "commander";
@@ -11135,14 +11132,14 @@ function registerSnapshot(program2) {
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot35(opts.dir);
     const paths = resolveHaivePaths32(root);
-    if (!existsSync55(paths.haiveDir)) {
+    if (!existsSync56(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
       const contractsDir = path38.join(paths.haiveDir, "contracts");
-      if (!existsSync55(contractsDir)) {
+      if (!existsSync56(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -11266,7 +11263,7 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile26, copyFile } from "fs/promises";
 import path39 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
@@ -11368,7 +11365,7 @@ Next steps:
       return;
     }
     const hubRoot = path39.resolve(root, config.hubPath);
-    if (!existsSync56(hubRoot)) {
+    if (!existsSync57(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -11438,7 +11435,7 @@ Next steps:
     }
     const hubRoot = path39.resolve(root, config.hubPath);
     const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync56(hubSharedDir)) {
+    if (!existsSync57(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -11493,7 +11490,7 @@ Next steps:
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
     const sharedDir = path39.join(paths.memoriesDir, "shared");
-    if (existsSync56(sharedDir)) {
+    if (existsSync57(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
@@ -11522,7 +11519,7 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync58 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
 import path40 from "path";
 import {
@@ -11600,7 +11597,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync57(paths.memoriesDir)) {
+  if (existsSync58(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir29(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -11820,7 +11817,7 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { readdir as readdir5, readFile as readFile19, writeFile as writeFile28 } from "fs/promises";
 import path41 from "path";
 import "commander";
@@ -11868,14 +11865,14 @@ function resolveBenchmarkRoot(dir) {
   return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync58(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync59(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const fixtureDir = path41.join(root, entry.name);
     const reportFile = path41.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync58(reportFile)) continue;
+    if (!existsSync59(reportFile)) continue;
     const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -11966,7 +11963,7 @@ function escapeRegExp(value) {
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import path43 from "path";
 import "commander";
 import {
@@ -12045,7 +12042,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -12069,7 +12066,7 @@ function registerMemorySuggest(memory2) {
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
         await mkdir18(path43.dirname(file), { recursive: true });
-        if (existsSync59(file)) {
+        if (existsSync60(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path43.relative(root, file)}` });
           continue;
         }
@@ -12172,7 +12169,7 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import { writeFile as writeFile30 } from "fs/promises";
 import path44 from "path";
 import "commander";
@@ -12193,7 +12190,7 @@ function registerMemoryArchive(memory2) {
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m'). Default: enforcement.decayAfterDays or 180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--unread", "decay by unread-age ALONE (ignore anchor status) \u2014 more aggressive corpus hygiene", false).option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot41(opts.dir);
     const paths = resolveHaivePaths37(root);
-    if (!existsSync60(paths.memoriesDir)) {
+    if (!existsSync61(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12218,7 +12215,7 @@ function registerMemoryArchive(memory2) {
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const retired = retirementSignal2(fm, mem.body);
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync60(path44.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync61(path44.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -12293,7 +12290,7 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync61, statSync as statSync2 } from "fs";
+import { existsSync as existsSync63, statSync as statSync2 } from "fs";
 import { readFile as readFile20, stat, writeFile as writeFile31 } from "fs/promises";
 import path45 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
@@ -12319,7 +12316,7 @@ function registerDoctor(program2) {
     const findings = [];
     const repairs = [];
     const config = await loadConfig11(paths);
-    if (!existsSync61(paths.haiveDir)) {
+    if (!existsSync63(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -12340,7 +12337,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync61(paths.projectContext)) {
+    if (!existsSync63(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -12369,7 +12366,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const memories = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12512,7 +12509,7 @@ function registerDoctor(program2) {
     if (config.enforcement?.requireBriefingFirst) {
       const claudeSettings = path45.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync61(claudeSettings)) {
+      if (existsSync63(claudeSettings)) {
         try {
           const { readFile: readFile24 } = await import("fs/promises");
           const raw = await readFile24(claudeSettings, "utf8");
@@ -12538,14 +12535,14 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.10.5"));
+    findings.push(...await collectInstallFindings(root, "0.10.8"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.10.5";
+      const cliVersion = "0.10.8";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -12567,7 +12564,7 @@ npm uninstall -g @hiveai/mcp`
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync61(cfgPath)) continue;
+        if (!existsSync63(cfgPath)) continue;
         try {
           const raw = await readFile20(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
@@ -12862,7 +12859,7 @@ which -a haive`
   ];
   for (const rel of integrationFiles) {
     const file = path45.join(root, rel);
-    if (!existsSync61(file)) continue;
+    if (!existsSync63(file)) continue;
     const text = await readFile20(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -12958,7 +12955,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync61(file)) return null;
+  if (!existsSync63(file)) return null;
   try {
     return JSON.parse(await readFile20(file, "utf8"));
   } catch {
@@ -13005,7 +13002,7 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot43,
@@ -13035,7 +13032,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const all = existsSync64(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
     const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
     const enriched = sessions.map((s, i) => {
       const startMs = Date.parse(s.start);
@@ -13277,7 +13274,7 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot45,
@@ -13299,7 +13296,7 @@ function registerWelcome(program2) {
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot45(opts.dir);
     const paths = resolveHaivePaths41(root);
-    if (!existsSync64(paths.memoriesDir)) {
+    if (!existsSync65(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -13371,7 +13368,7 @@ function registerResolveProject(program2) {
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 import path47 from "path";
 import "commander";
 import {
@@ -13397,7 +13394,7 @@ function registerRuntime(program2) {
     const root = path47.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths42(findProjectRoot46(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync65(paths.haiveDir)) {
+    if (!existsSync66(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -13412,7 +13409,7 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync66 } from "fs";
+import { existsSync as existsSync67 } from "fs";
 import path48 from "path";
 import "commander";
 import {
@@ -13431,7 +13428,7 @@ function registerMemoryTimeline(memory2) {
     }
     const root = path48.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths43(findProjectRoot47(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13449,7 +13446,7 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import path49 from "path";
 import "commander";
 import {
@@ -13474,7 +13471,7 @@ function registerMemoryConflictCandidates(memory2) {
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
     const root = path49.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths44(findProjectRoot48(root));
-    if (!existsSync67(paths.memoriesDir)) {
+    if (!existsSync68(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13510,14 +13507,14 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync68, statSync as statSync3 } from "fs";
+import { existsSync as existsSync69, statSync as statSync3 } from "fs";
 import { chmod as chmod2, mkdir as mkdir19, readFile as readFile21, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
 import path50 from "path";
 import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
   findProjectRoot as findProjectRoot49,
-  hasRecentBriefingMarker,
+  hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig13,
   loadMemoriesFromDir as loadMemoriesFromDir36,
@@ -13585,14 +13582,14 @@ function registerEnforce(program2) {
     const root = findProjectRoot49(opts.dir);
     const paths = resolveHaivePaths45(root);
     const cacheDir = path50.join(paths.haiveDir, ".cache");
-    if (existsSync68(cacheDir)) {
+    if (existsSync69(cacheDir)) {
       if (opts.dryRun) ui.info(`would clean ${path50.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
         ui.success(`cleaned ${path50.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync68(paths.runtimeDir)) {
+    if (existsSync69(paths.runtimeDir)) {
       if (opts.dryRun) ui.info(`would clean ${path50.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
@@ -13610,7 +13607,7 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths45(root);
-    if (!existsSync68(paths.haiveDir)) return;
+    if (!existsSync69(paths.haiveDir)) return;
     await mkdir19(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
@@ -13673,9 +13670,9 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths45(root);
-    if (!existsSync68(paths.haiveDir)) return;
+    if (!existsSync69(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
-    const ok = await hasRecentBriefingMarker(paths, payload.session_id);
+    const ok = await hasRecentBriefingMarker2(paths, payload.session_id);
     if (ok) {
       const targetFiles = extractToolPaths(payload, root);
       if (targetFiles.length === 0) return;
@@ -13717,7 +13714,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot49(opts.dir);
   const paths = resolveHaivePaths45(root);
-  if (!existsSync68(paths.haiveDir)) {
+  if (!existsSync69(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -13812,7 +13809,7 @@ async function writeWrapperBriefing(paths, sessionId, task) {
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot49(dir);
   const paths = resolveHaivePaths45(root);
-  const initialized = existsSync68(paths.haiveDir);
+  const initialized = existsSync69(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
@@ -13843,9 +13840,9 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.10.5"));
+  findings.push(...await inspectIntegrationVersions(root, "0.10.8"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
-    const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
+    const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
       severity: "error",
       code: "briefing-missing",
@@ -13913,7 +13910,7 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync68(paths.memoriesDir)) return false;
+  if (!existsSync69(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
@@ -13922,7 +13919,7 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync68(paths.memoriesDir)) return [];
+  if (!existsSync69(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -13960,7 +13957,7 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync68(paths.memoriesDir)) return [];
+  if (!existsSync69(paths.memoriesDir)) return [];
   const changedFiles = await getChangedFiles(paths.root, stage);
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
@@ -14071,7 +14068,7 @@ async function cleanupRuntimeDir(runtimeDir) {
     removed++;
   }
   await writeFile33(path50.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync68(path50.join(runtimeDir, "README.md"))) {
+  if (!existsSync69(path50.join(runtimeDir, "README.md"))) {
     await writeFile33(
       path50.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
@@ -14114,7 +14111,7 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const findings = [];
   for (const rel of files) {
     const file = path50.join(root, rel);
-    if (!existsSync68(file)) continue;
+    if (!existsSync69(file)) continue;
     const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -14210,7 +14207,7 @@ function buildScore(findings, threshold = 80) {
 }
 async function installGitEnforcement(root) {
   const hooksDir = path50.join(root, ".git", "hooks");
-  if (!existsSync68(path50.join(root, ".git"))) {
+  if (!existsSync69(path50.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -14233,7 +14230,7 @@ haive enforce check --stage pre-push --dir . || exit $?
   ];
   for (const hook of hooks) {
     const file = path50.join(hooksDir, hook.name);
-    if (existsSync68(file)) {
+    if (existsSync69(file)) {
       const current = await readFile21(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile33(file, hook.body, "utf8");
@@ -14252,7 +14249,7 @@ ${hook.body}`, "utf8");
 async function installCiEnforcement(root) {
   const workflowPath = path50.join(root, ".github", "workflows", "haive-enforcement.yml");
   await mkdir19(path50.dirname(workflowPath), { recursive: true });
-  if (existsSync68(workflowPath)) {
+  if (existsSync69(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
@@ -14381,7 +14378,7 @@ function normalizeToolPath(file, root) {
   return path50.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync68(paths.memoriesDir)) return [];
+  if (!existsSync69(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
@@ -14455,7 +14452,7 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile2 } from "child_process";
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import { chmod as chmod3, mkdir as mkdir20, readFile as readFile23, writeFile as writeFile34 } from "fs/promises";
 import path51 from "path";
 import { promisify as promisify2 } from "util";
@@ -14538,7 +14535,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot50(opts.dir);
     const paths = resolveHaivePaths46(root);
-    const loaded = existsSync69(paths.memoriesDir) ? await loadMemoriesFromDir37(paths.memoriesDir) : [];
+    const loaded = existsSync70(paths.memoriesDir) ? await loadMemoriesFromDir37(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -14600,7 +14597,7 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync69(paths.memoriesDir)) return [];
+  if (!existsSync70(paths.memoriesDir)) return [];
   const loaded = await loadMemoriesFromDir37(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
@@ -14643,7 +14640,7 @@ function shellQuote(value) {
 
 // src/index.ts
 var program = new Command53();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.10.5").option("--advanced", "show maintenance and experimental commands in help");
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.10.8").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);