@hivelore/cli 0.30.1 → 0.31.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command64 } from "commander";
+import { Command as Command65 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -13,6 +13,7 @@ import {
   compactAutoRecapBody,
   extractActionsBriefBody,
   findProjectRoot as findProjectRoot2,
+  inferModulesFromPaths,
   literalMatchesAllTokens,
   literalMatchesAnyToken,
   loadCodeMap as loadCodeMap3,
@@ -214,7 +215,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path63, changes]) => ({ path: path63, changes }));
+    let entries = [...counts.entries()].map(([path64, changes]) => ({ path: path64, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -757,8 +758,15 @@ async function refreshCodeMap(root, paths, force) {
 async function refreshCodeSearchIndex(paths) {
   try {
     const mod = await import("@hivelore/embeddings");
+    const cold = !existsSync2(mod.codeIndexPath(paths));
+    if (cold) {
+      console.error(
+        "[hivelore] Building the semantic code index (one-time \u2014 large repos can take a minute). Subsequent briefings reuse the cache."
+      );
+    }
     const embedder = await mod.Embedder.create();
     const { report } = await mod.rebuildCodeIndex(paths, embedder);
+    if (cold) console.error("[hivelore] Semantic code index ready.");
     return report.added > 0 || report.updated > 0 || report.removed > 0;
   } catch {
     return false;
@@ -1062,11 +1070,21 @@ function registerBriefing(program2) {
     const usefulCount = priorities.filter((p) => p === "useful").length;
     const backgroundCount = priorities.filter((p) => p === "background").length;
     const quality = mustReadCount > 0 || usefulCount > 0 ? mustReadCount === 0 && backgroundCount > usefulCount && backgroundCount > 2 ? "noisy" : "strong" : "thin";
+    const inferredModules = inferModulesFromPaths(filePaths);
+    const moduleContexts = [];
+    for (const m of inferredModules) {
+      const ctxFile = path4.join(paths.modulesContextDir, m, "context.md");
+      if (existsSync3(ctxFile)) {
+        moduleContexts.push({ name: m, content: (await readFile2(ctxFile, "utf8")).trim() });
+      }
+    }
     if (json) {
       console.log(JSON.stringify({
         task: opts.task ?? null,
         files: filePaths,
         briefing_quality: quality,
+        inferred_modules: inferredModules,
+        module_contexts: moduleContexts,
         counts: { must_read: mustReadCount, useful: usefulCount, background: backgroundCount },
         recap_id: recaps[0]?.memory.frontmatter.id ?? null,
         memories: top.map((item, i) => ({
@@ -1084,6 +1102,12 @@ function registerBriefing(program2) {
     }
     out(ui.dim(`briefing_quality: ${quality} \xB7 must_read=${mustReadCount} useful=${usefulCount} background=${backgroundCount}`));
     out("");
+    for (const mc of moduleContexts) {
+      if (stopped()) break;
+      out(ui.bold(`=== Module context: ${mc.name} ===`));
+      out(mc.content);
+      out("");
+    }
     printCliBreadcrumbs({
       top,
       priorities,
@@ -3622,12 +3646,18 @@ async function seedStackPack(haivePaths, stack) {
   const DATE_PREFIX = /^\d{4}-\d{2}-\d{2}-/;
   const existingTopics = /* @__PURE__ */ new Set();
   const existingSignatures = /* @__PURE__ */ new Set();
+  const handWrittenSlugs = [];
   if (existsSync10(haivePaths.memoriesDir)) {
     for (const { memory: memory2 } of await loadMemoriesFromDir5(haivePaths.memoriesDir)) {
       if (memory2.frontmatter.topic) existingTopics.add(memory2.frontmatter.topic);
       existingSignatures.add(memory2.frontmatter.id.replace(DATE_PREFIX, ""));
+      if (!memory2.frontmatter.tags.includes("stack-pack")) {
+        handWrittenSlugs.push(memory2.frontmatter.id.replace(DATE_PREFIX, ""));
+      }
     }
   }
+  const overlapHints = [];
+  const slugTokens = (slug) => new Set(slug.split("-").filter((t) => t.length > 3 && !["convention", "decision", "gotcha", "attempt", "architecture"].includes(t)));
   let memCount = 0;
   let sensorCount = 0;
   for (const mem of memories) {
@@ -3636,7 +3666,11 @@ async function seedStackPack(haivePaths, stack) {
       kind: "regex",
       pattern: mem.sensor.pattern,
       ...mem.sensor.flags ? { flags: mem.sensor.flags } : {},
-      paths: mem.sensor.paths ?? [],
+      // Stack rules are stack-wide: when the pack doesn't scope the sensor itself, pin an
+      // explicit repo-wide glob. Leaving [] lets sensorAppliesToPath fall back to the MEMORY's
+      // anchor paths — and seeds get anchored to one exemplar file later, silently shrinking
+      // "never $disconnect() in serverless" to a single file (found in the 0.30.0 field test).
+      paths: mem.sensor.paths ?? ["**"],
       message: mem.sensor.message,
       severity: "warn",
       autogen: false,
@@ -3674,13 +3708,28 @@ ${SEED_FOOTER(stack)}` });
     existingSignatures.add(signature);
     memCount++;
     if (sensor) sensorCount++;
+    const seededTokens = slugTokens(combinedSlug);
+    for (const prior of handWrittenSlugs) {
+      const shared = [...slugTokens(prior)].filter((t) => seededTokens.has(t));
+      if (shared.length >= 2) {
+        overlapHints.push({ seeded: fm.id, existing: prior });
+        break;
+      }
+    }
+  }
+  if (overlapHints.length > 0) {
+    ui.warn(`${overlapHints.length} seeded lesson(s) may duplicate existing hand-written memories:`);
+    for (const h of overlapHints.slice(0, 5)) {
+      ui.info(`  ${h.seeded} \u2194 ${h.existing}`);
+    }
+    ui.info("  Review with `hivelore memory conflict-candidates`, then `hivelore memory resolve-conflict`.");
   }
   return { memories: memCount, sensors: sensorCount };
 }
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.30.1"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.31.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`hivelore init\`. Run \`hivelore init --bootstrap\` to auto-fill from your codebase,
@@ -4899,7 +4948,7 @@ import path42 from "path";
 import {
   deriveConfidence as deriveConfidence2,
   getUsage as getUsage3,
-  inferModulesFromPaths,
+  inferModulesFromPaths as inferModulesFromPaths2,
   loadMemoriesFromDir as loadMemoriesFromDir7,
   loadUsageIndex as loadUsageIndex4,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
@@ -4940,27 +4989,27 @@ import {
   serializeMemory as serializeMemory6
 } from "@hivelore/core";
 import { z as z14 } from "zod";
-import { mkdir as mkdir32, writeFile as writeFile82 } from "fs/promises";
-import { existsSync as existsSync152 } from "fs";
-import path52 from "path";
+import { mkdir as mkdir32, writeFile as writeFile92 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import path62 from "path";
 import {
   buildFrontmatter as buildFrontmatter22,
   memoryFilePath as memoryFilePath22,
-  serializeMemory as serializeMemory7,
+  serializeMemory as serializeMemory8,
   suggestSensorSeed as suggestSensorSeed2
 } from "@hivelore/core";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { execSync } from "child_process";
-import { readFile as readFile32, writeFile as writeFile92 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path62 from "path";
+import { readFile as readFile32, writeFile as writeFile82 } from "fs/promises";
+import { existsSync as existsSync152 } from "fs";
+import path52 from "path";
 import {
   extractSensorExamples,
   judgeProposedSensor,
   loadMemoriesFromDir as loadMemoriesFromDir13,
-  serializeMemory as serializeMemory8
+  serializeMemory as serializeMemory7
 } from "@hivelore/core";
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 import { existsSync as existsSync17 } from "fs";
 import { mkdir as mkdir42, readFile as readFile42, writeFile as writeFile102 } from "fs/promises";
 import path72 from "path";
@@ -5019,7 +5068,7 @@ import {
   compactAutoRecapBody as compactAutoRecapBody2,
   extractActionsBriefBody as extractActionsBriefBody2,
   getUsage as getUsage6,
-  inferModulesFromPaths as inferModulesFromPaths2,
+  inferModulesFromPaths as inferModulesFromPaths22,
   isAutoPromoteEligible,
   isDecaying,
   isRetiredMemory as isRetiredMemory2,
@@ -5832,7 +5881,7 @@ var MemForFilesInputSchema = {
   track: z9.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function memForFiles(input, ctx) {
-  const inferred = inferModulesFromPaths(input.files);
+  const inferred = inferModulesFromPaths2(input.files);
   if (!existsSync92(ctx.paths.memoriesDir)) {
     return {
       inferred_modules: inferred,
@@ -6138,71 +6187,17 @@ async function memApprove(input, ctx) {
     file_path: found.filePath
   };
 }
-var MemTriedInputSchema = {
-  what: z15.string().min(1).describe("Brief description of the approach that was tried"),
-  why_failed: z15.string().min(1).describe("Why it failed or why it should NOT be used"),
-  instead: z15.string().optional().describe("What to use or do instead (recommended alternative)"),
-  scope: z15.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
-  module: z15.string().optional().describe("Module name (required when scope=module)"),
-  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
-  paths: z15.array(z15.string()).default([]).describe("Anchor file paths this applies to"),
-  author: z15.string().optional().describe("Author handle or email")
-};
-async function memTried(input, ctx) {
-  if (!existsSync152(ctx.paths.haiveDir)) {
-    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'hivelore init' first.`);
-  }
-  const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
-  const baseFm = buildFrontmatter22({
-    type: "attempt",
-    slug,
-    scope: input.scope,
-    module: input.module,
-    tags: input.tags,
-    paths: input.paths,
-    author: input.author
-  });
-  const frontmatter = { ...baseFm, status: "validated" };
-  const lines = [`# ${input.what}`, ""];
-  lines.push(`**Why it failed / do NOT use:** ${input.why_failed}`);
-  if (input.instead) {
-    lines.push("", `**Instead, use:** ${input.instead}`);
-  }
-  const body = lines.join("\n") + "\n";
-  const file = memoryFilePath22(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-  await mkdir32(path52.dirname(file), { recursive: true });
-  if (existsSync152(file)) {
-    throw new Error(`Memory already exists at ${file}`);
-  }
-  await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
-  const seed = input.paths.length > 0 ? suggestSensorSeed2(body, input.paths) : null;
-  const hint = input.paths.length === 0 ? "No `paths` given, so this attempt is feedforward-only \u2014 it will be briefed but the gate cannot block the repeat. Re-run with `paths` set to the file(s) where the mistake lives, then call propose_sensor to close the loop." : seed ? "This attempt is NOT yet enforced. Call propose_sensor to turn it into a reliable block \u2014 a candidate is pre-filled in proposed_sensor_seed (refine it: pattern = the faulty usage, absent = the correct-usage marker). Hivelore validates the proposal (silent on current code, fires on the bad example) before trusting it to block." : "This attempt is NOT yet enforced and no candidate pattern could be derived from the wording. Call propose_sensor with a discriminating pattern (pattern = faulty usage, absent = correct-usage marker) to close the loop.";
-  return {
-    id: frontmatter.id,
-    scope: frontmatter.scope,
-    file_path: file,
-    loop_open: true,
-    ...seed ? {
-      proposed_sensor_seed: {
-        pattern: seed.pattern,
-        ...seed.absent ? { absent: seed.absent } : {},
-        message: seed.message
-      }
-    } : {},
-    hint
-  };
-}
 var ProposeSensorInputSchema = {
-  memory_id: z16.string().min(1).describe("Id of the gotcha/attempt memory this sensor protects."),
-  pattern: z16.string().min(1).describe("Regex matching the FAULTY usage (the risky call/token), e.g. 'stripe\\.paymentIntents\\.create'."),
-  absent: z16.string().optional().describe(
+  memory_id: z15.string().min(1).describe("Id of the gotcha/attempt memory this sensor protects."),
+  pattern: z15.string().min(1).describe("Regex matching the FAULTY usage (the risky call/token), e.g. 'stripe\\.paymentIntents\\.create'."),
+  absent: z15.string().optional().describe(
     "Regex for the CORRECT-usage marker (e.g. 'idempotencyKey'). When it appears in the window around a match, the catch is suppressed \u2014 this is what makes the sensor discriminate the faulty call from the correct one. STRONGLY recommended for 'X without Y' lessons."
   ),
-  bad_example: z16.string().optional().describe("A code snippet that SHOULD match \u2014 proves the sensor catches the mistake. If omitted, examples are read from the lesson body."),
-  severity: z16.enum(["warn", "block"]).default("block").describe("block = hard-fail the gate (accepted ONLY if it passes self-validation). warn = advisory."),
-  message: z16.string().optional().describe("LLM-facing fix message shown when it fires. Defaults to one derived from the lesson."),
-  flags: z16.string().optional().describe("Optional regex flags (e.g. 'i' for case-insensitive)."),
-  paths: z16.array(z16.string()).default([]).describe("Override scope paths. Defaults to the memory's anchor paths.")
+  bad_example: z15.string().optional().describe("A code snippet that SHOULD match \u2014 proves the sensor catches the mistake. If omitted, examples are read from the lesson body."),
+  severity: z15.enum(["warn", "block"]).default("block").describe("block = hard-fail the gate (accepted ONLY if it passes self-validation). warn = advisory."),
+  message: z15.string().optional().describe("LLM-facing fix message shown when it fires. Defaults to one derived from the lesson."),
+  flags: z15.string().optional().describe("Optional regex flags (e.g. 'i' for case-insensitive)."),
+  paths: z15.array(z15.string()).default([]).describe("Override scope paths. Defaults to the memory's anchor paths.")
 };
 function deriveMessage(body, pattern, absent) {
   const instead = body.match(/\*\*Instead,\s*use:\*\*\s*([^\n]+)/i)?.[1]?.trim();
@@ -6227,8 +6222,8 @@ async function readPresumedCorrectTargets(root, relPaths) {
       continue;
     } catch {
     }
-    const abs = path62.resolve(root, rel);
-    if (!existsSync16(abs)) continue;
+    const abs = path52.resolve(root, rel);
+    if (!existsSync152(abs)) continue;
     try {
       targets.push({ path: rel, content: await readFile32(abs, "utf8") });
     } catch {
@@ -6237,7 +6232,7 @@ async function readPresumedCorrectTargets(root, relPaths) {
   return targets;
 }
 async function proposeSensor(input, ctx) {
-  if (!existsSync16(ctx.paths.memoriesDir)) {
+  if (!existsSync152(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}. Run 'hivelore init' first.`);
   }
   try {
@@ -6297,7 +6292,7 @@ async function proposeSensor(input, ctx) {
     frontmatter: { ...found.memory.frontmatter, sensor },
     body: found.memory.body
   };
-  await writeFile92(found.filePath, serializeMemory8(next), "utf8");
+  await writeFile82(found.filePath, serializeMemory7(next), "utf8");
   return {
     accepted: true,
     memory_id: input.memory_id,
@@ -6306,6 +6301,97 @@ async function proposeSensor(input, ctx) {
     file_path: found.filePath
   };
 }
+var MemTriedInputSchema = {
+  what: z16.string().min(1).describe("Brief description of the approach that was tried"),
+  why_failed: z16.string().min(1).describe("Why it failed or why it should NOT be used"),
+  instead: z16.string().optional().describe("What to use or do instead (recommended alternative)"),
+  scope: z16.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
+  module: z16.string().optional().describe("Module name (required when scope=module)"),
+  tags: z16.array(z16.string()).default([]).describe("Tags for filtering"),
+  paths: z16.array(z16.string()).default([]).describe("Anchor file paths this applies to"),
+  author: z16.string().optional().describe("Author handle or email"),
+  sensor: z16.object({
+    pattern: z16.string().min(1).describe("Regex matching the FAULTY usage (added diff lines)"),
+    absent: z16.string().optional().describe("Regex marking CORRECT usage nearby \u2014 excludes it from firing"),
+    severity: z16.enum(["warn", "block"]).default("block").describe("block = deterministic gate refusal"),
+    message: z16.string().optional().describe("Self-correction message shown when the sensor fires"),
+    bad_example: z16.string().optional().describe("Code snippet the sensor MUST fire on (validation)")
+  }).optional().describe(
+    "ONE-SHOT loop close: validate and attach a sensor in the same call (equivalent to a follow-up propose_sensor). Validated against HEAD \u2014 silent on current code, fires on the bad example. If rejected, the attempt is still saved and the verdict tells you how to revise."
+  )
+};
+async function memTried(input, ctx) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'hivelore init' first.`);
+  }
+  const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
+  const baseFm = buildFrontmatter22({
+    type: "attempt",
+    slug,
+    scope: input.scope,
+    module: input.module,
+    tags: input.tags,
+    paths: input.paths,
+    author: input.author
+  });
+  const frontmatter = { ...baseFm, status: "validated" };
+  const lines = [`# ${input.what}`, ""];
+  lines.push(`**Why it failed / do NOT use:** ${input.why_failed}`);
+  if (input.instead) {
+    lines.push("", `**Instead, use:** ${input.instead}`);
+  }
+  const body = lines.join("\n") + "\n";
+  const file = memoryFilePath22(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir32(path62.dirname(file), { recursive: true });
+  if (existsSync16(file)) {
+    throw new Error(`Memory already exists at ${file}`);
+  }
+  await writeFile92(file, serializeMemory8({ frontmatter, body }), "utf8");
+  if (input.sensor) {
+    const verdict = await proposeSensor(
+      {
+        memory_id: frontmatter.id,
+        pattern: input.sensor.pattern,
+        absent: input.sensor.absent,
+        severity: input.sensor.severity ?? "block",
+        message: input.sensor.message,
+        bad_example: input.sensor.bad_example,
+        flags: void 0,
+        paths: []
+      },
+      ctx
+    );
+    return {
+      id: frontmatter.id,
+      scope: frontmatter.scope,
+      file_path: file,
+      loop_open: !verdict.accepted,
+      sensor_result: {
+        accepted: verdict.accepted,
+        severity: input.sensor.severity ?? "block",
+        ...verdict.reason ? { reason: verdict.reason } : {},
+        ...verdict.guidance ? { guidance: verdict.guidance } : {}
+      },
+      hint: verdict.accepted ? "Loop closed: the attempt is saved AND enforced \u2014 the gate now refuses a repeat deterministically." : `Attempt saved, but the sensor was rejected (${verdict.reason}). Revise per the guidance and re-propose with propose_sensor.`
+    };
+  }
+  const seed = input.paths.length > 0 ? suggestSensorSeed2(body, input.paths) : null;
+  const hint = input.paths.length === 0 ? "No `paths` given, so this attempt is feedforward-only \u2014 it will be briefed but the gate cannot block the repeat. Re-run with `paths` set to the file(s) where the mistake lives, then call propose_sensor to close the loop." : seed ? "This attempt is NOT yet enforced. Call propose_sensor (or re-run mem_tried with the one-shot `sensor` parameter) to turn it into a reliable block \u2014 a candidate is pre-filled in proposed_sensor_seed (refine it: pattern = the faulty usage, absent = the correct-usage marker). Hivelore validates the proposal (silent on current code, fires on the bad example) before trusting it to block." : "This attempt is NOT yet enforced and no candidate pattern could be derived from the wording. Call propose_sensor with a discriminating pattern (pattern = faulty usage, absent = correct-usage marker) to close the loop.";
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file,
+    loop_open: true,
+    ...seed ? {
+      proposed_sensor_seed: {
+        pattern: seed.pattern,
+        ...seed.absent ? { absent: seed.absent } : {},
+        message: seed.message
+      }
+    } : {},
+    hint
+  };
+}
 var IngestFindingsInputSchema = {
   format: z17.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
   report_path: z17.string().optional().describe("Project-relative path to the findings JSON file. Provide this OR `report`."),
@@ -6886,7 +6972,7 @@ async function getBriefing(input, ctx) {
   const briefingMaxTokens = resolvedBudget.max_tokens;
   const briefingMaxMemories = resolvedBudget.max_memories;
   const briefingIncludeModules = resolvedBudget.include_module_contexts;
-  const inferred = inferModulesFromPaths2(input.files);
+  const inferred = inferModulesFromPaths22(input.files);
   const memories = [];
   let searchMode = "literal";
   let usage = { version: 1, updated_at: "", by_id: {} };
@@ -7196,11 +7282,20 @@ ${m.content}`).join("\n\n---\n\n"),
     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 outputMemories = formattedMemories.map((m) => ({
+  let outputMemories = formattedMemories.map((m) => ({
     ...m,
     priority: classifyMemoryPriority2(m, byId.get(m.id), input.files, input.symbols),
     why: explainWhySurfaced(m, byId.get(m.id), input.files, inferred)
   }));
+  if (input.format === "full") {
+    const hasDirectHits = outputMemories.some((m) => m.priority === "must_read" || m.priority === "useful");
+    if (hasDirectHits) {
+      outputMemories = outputMemories.map(
+        (m) => m.priority === "background" ? { ...m, body: `${compactSummary(m.body)}
+(background \u2014 full body: mem_get("${m.id}"))` } : m
+      );
+    }
+  }
   const briefingQuality = classifyBriefingQuality(outputMemories, {
     isTemplateContext,
     autoContextGenerated,
@@ -7515,7 +7610,7 @@ function oneLine(value) {
   return value.replace(/\s+/g, " ").replace(/"/g, '\\"').trim().slice(0, 120);
 }
 function serverVersion() {
-  return true ? "0.30.1" : "dev";
+  return true ? "0.31.0" : "dev";
 }
 var CodeMapInputSchema = {
   file: z21.string().optional().describe("Filter to files whose path contains this substring"),
@@ -9426,7 +9521,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.30.1";
+var SERVER_VERSION = "0.31.0";
 function jsonResult(data) {
   return {
     content: [
@@ -11972,35 +12067,20 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
 import { existsSync as existsSync45 } from "fs";
 import path28 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter8,
   findProjectRoot as findProjectRoot22,
-  memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths19,
-  serializeMemory as serializeMemory20,
-  suggestSensorSeed as suggestSensorSeed4
+  resolveHaivePaths as resolveHaivePaths19
 } from "@hivelore/core";
+function parseCsv4(raw) {
+  return (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+}
 function registerMemoryTried(memory2) {
   memory2.command("tried").description(
-    `Record a FAILED approach \u2014 prevents repeated mistakes in future sessions.
-
-  This is the most valuable type of negative knowledge. It surfaces FIRST in
-  get_briefing so agents can't miss it. Auto-validated (no approval cycle).
-
-  Use this immediately when you try something and it fails.
-
-  Example:
-    hivelore memory tried \\\\
-      --what "importing X with ESM dynamic import" \\\\
-      --why-failed "tsup bundles it as CJS, dynamic import fails at runtime" \\\\
-      --instead "use static import in the entry file" \\\\
-      --paths packages/cli/src/index.ts
-`
-  ).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) => {
+    'Record a FAILED approach \u2014 prevents repeated mistakes in future sessions.\n\n  This is the most valuable type of negative knowledge. It surfaces FIRST in\n  get_briefing so agents can\'t miss it. Auto-validated (no approval cycle).\n\n  Use this immediately when you try something and it fails.\n\n  One-shot loop close: add --sensor-pattern to validate and attach the guardrail\n  in the same command (equivalent to a follow-up `sensors propose`).\n\n  Example:\n    hivelore memory tried \\\\\n      --what "importing X with ESM dynamic import" \\\\\n      --why-failed "tsup bundles it as CJS, dynamic import fails at runtime" \\\\\n      --instead "use static import in the entry file" \\\\\n      --paths packages/cli/src/index.ts \\\\\n      --sensor-pattern "await import\\\\(" --sensor-absent "static import"\n'
+  ).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("--sensor-pattern <regex>", "one-shot: regex matching the FAULTY usage \u2014 validates + attaches a sensor in this call").option("--sensor-absent <regex>", "one-shot: regex marking CORRECT usage nearby (excludes it from firing)").option("--sensor-severity <level>", "one-shot sensor severity: warn | block", "block").option("--sensor-message <text>", "one-shot: self-correction message shown when the sensor fires").option("--bad-example <code>", "one-shot: code snippet the sensor must fire on (validation)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
     if (!existsSync45(paths.haiveDir)) {
@@ -12008,52 +12088,56 @@ function registerMemoryTried(memory2) {
       process.exitCode = 1;
       return;
     }
-    const slug = opts.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
-    const baseFm = buildFrontmatter8({
-      type: "attempt",
-      slug,
-      scope: opts.scope,
-      module: opts.module,
-      tags: parseCsv4(opts.tags),
-      paths: parseCsv4(opts.paths ?? opts.files),
-      author: opts.author
-    });
-    const frontmatter = { ...baseFm, status: "validated" };
-    const lines = [`# ${opts.what}`, ""];
-    lines.push(`**Why it failed / do NOT use:** ${opts.whyFailed}`);
-    if (opts.instead) {
-      lines.push("", `**Instead, use:** ${opts.instead}`);
-    }
-    const body = lines.join("\n") + "\n";
-    const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir14(path28.dirname(file), { recursive: true });
-    if (existsSync45(file)) {
-      ui.error(`Memory already exists at ${file}`);
+    const severity = opts.sensorSeverity === "warn" ? "warn" : "block";
+    let result;
+    try {
+      result = await memTried(
+        {
+          what: opts.what,
+          why_failed: opts.whyFailed,
+          instead: opts.instead,
+          // "shared" is a legacy MemoryScope alias not accepted by mem_tried — normalize to team.
+          scope: opts.scope === "shared" ? "team" : opts.scope ?? "personal",
+          module: opts.module,
+          tags: parseCsv4(opts.tags),
+          paths: parseCsv4(opts.paths ?? opts.files),
+          author: opts.author,
+          sensor: opts.sensorPattern ? {
+            pattern: opts.sensorPattern,
+            absent: opts.sensorAbsent,
+            severity,
+            message: opts.sensorMessage,
+            bad_example: opts.badExample
+          } : void 0
+        },
+        { paths }
+      );
+    } catch (err) {
+      ui.error(err instanceof Error ? err.message : String(err));
       process.exitCode = 1;
       return;
     }
-    await writeFile23(file, serializeMemory20({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path28.relative(root, file)}`);
-    ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
-    const seed = frontmatter.anchor.paths.length > 0 ? suggestSensorSeed4(body, frontmatter.anchor.paths) : null;
-    if (frontmatter.anchor.paths.length === 0) {
-      ui.warn("No --paths \u2014 lesson is briefed but NOT enforced. Add --paths, then call propose_sensor (MCP) to close the loop.");
-    } else if (seed) {
-      ui.warn("Lesson NOT yet enforced \u2014 close the loop with a validated sensor via propose_sensor (MCP).");
+    ui.success(`Recorded: ${path28.relative(root, result.file_path)}`);
+    ui.info(`id=${result.id}  type=attempt  status=validated (auto-approved)`);
+    if (result.sensor_result) {
+      if (result.sensor_result.accepted) {
+        ui.success(`Loop closed: sensor attached (${result.sensor_result.severity}) \u2014 the gate now refuses a repeat deterministically.`);
+      } else {
+        ui.warn(`Attempt saved, but the sensor was rejected (${result.sensor_result.reason ?? "rejected"}).`);
+        if (result.sensor_result.guidance) ui.info(`  ${result.sensor_result.guidance}`);
+      }
+      return;
+    }
+    if (result.proposed_sensor_seed) {
+      ui.warn("Lesson NOT yet enforced \u2014 close the loop with `--sensor-pattern` (one-shot) or propose_sensor (MCP).");
       ui.info(
-        `  candidate pattern=${JSON.stringify(seed.pattern)}` + (seed.absent ? `  absent=${JSON.stringify(seed.absent)}` : "") + "  \u2014 refine, then validate (silent on current code, fires on the bad example)."
-      );
-    } else {
-      ui.warn(
-        "Lesson NOT yet enforced and no candidate pattern could be derived. Author a discriminating sensor (pattern = faulty usage, absent = correct-usage marker) via propose_sensor."
+        `  candidate pattern=${JSON.stringify(result.proposed_sensor_seed.pattern)}` + (result.proposed_sensor_seed.absent ? `  absent=${JSON.stringify(result.proposed_sensor_seed.absent)}` : "") + "  \u2014 refine, then validate (silent on current code, fires on the bad example)."
       );
+    } else if (result.hint) {
+      ui.warn(result.hint);
     }
   });
 }
-function parseCsv4(value) {
-  if (!value) return [];
-  return value.split(",").map((s) => s.trim()).filter(Boolean);
-}
 
 // src/commands/memory-seed.ts
 import { readFile as readFile14 } from "fs/promises";
@@ -12299,7 +12383,7 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile24 } from "fs/promises";
+import { writeFile as writeFile23 } from "fs/promises";
 import { existsSync as existsSync49 } from "fs";
 import "commander";
 import {
@@ -12308,7 +12392,7 @@ import {
   recordRejection as recordRejection3,
   resolveHaivePaths as resolveHaivePaths23,
   saveUsageIndex as saveUsageIndex4,
-  serializeMemory as serializeMemory21
+  serializeMemory as serializeMemory20
 } from "@hivelore/core";
 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) => {
@@ -12326,9 +12410,9 @@ function registerMemoryReject(memory2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile24(
+    await writeFile23(
       loaded.filePath,
-      serializeMemory21({
+      serializeMemory20({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -12594,7 +12678,7 @@ function pad(value, width) {
 
 // src/commands/memory-feedback.ts
 import { existsSync as existsSync55 } from "fs";
-import { writeFile as writeFile25 } from "fs/promises";
+import { writeFile as writeFile24 } from "fs/promises";
 import "commander";
 import {
   applyFeedbackAdjustment as applyFeedbackAdjustment2,
@@ -12607,7 +12691,7 @@ import {
   recommendFeedbackAdjustment as recommendFeedbackAdjustment2,
   resolveHaivePaths as resolveHaivePaths28,
   saveUsageIndex as saveUsageIndex6,
-  serializeMemory as serializeMemory23
+  serializeMemory as serializeMemory21
 } from "@hivelore/core";
 function registerMemoryFeedback(memory2) {
   memory2.command("feedback <id>").description(
@@ -12642,7 +12726,7 @@ function registerMemoryFeedback(memory2) {
     const adjustedFrontmatter = applyFeedbackAdjustment2(target.memory.frontmatter, adjustment);
     if (adjustedFrontmatter !== target.memory.frontmatter) {
       target.memory.frontmatter = adjustedFrontmatter;
-      await writeFile25(target.filePath, serializeMemory23(target.memory), "utf8");
+      await writeFile24(target.filePath, serializeMemory21(target.memory), "utf8");
     }
     const impact = computeImpact4(target.memory.frontmatter, usage);
     if (opts.json) {
@@ -12660,14 +12744,14 @@ function registerMemoryFeedback(memory2) {
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile26 } from "fs/promises";
+import { writeFile as writeFile25 } from "fs/promises";
 import { existsSync as existsSync56 } from "fs";
 import path36 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot32,
   resolveHaivePaths as resolveHaivePaths29,
-  serializeMemory as serializeMemory24,
+  serializeMemory as serializeMemory23,
   verifyAnchor as verifyAnchor3
 } from "@hivelore/core";
 function registerMemoryVerify(memory2) {
@@ -12734,7 +12818,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification2(mem, result);
-        await writeFile26(filePath, serializeMemory24(next), "utf8");
+        await writeFile25(filePath, serializeMemory23(next), "utf8");
         updated++;
       }
     }
@@ -12848,14 +12932,14 @@ function registerMemoryImport(memory2) {
 
 // src/commands/memory-import-changelog.ts
 import { existsSync as existsSync58 } from "fs";
-import { readFile as readFile17, mkdir as mkdir15, writeFile as writeFile27 } from "fs/promises";
+import { readFile as readFile17, mkdir as mkdir14, writeFile as writeFile26 } from "fs/promises";
 import path37 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter9,
+  buildFrontmatter as buildFrontmatter8,
   findProjectRoot as findProjectRoot34,
   resolveHaivePaths as resolveHaivePaths31,
-  serializeMemory as serializeMemory25
+  serializeMemory as serializeMemory24
 } from "@hivelore/core";
 function parseChangelog(content) {
   const entries = [];
@@ -12945,7 +13029,7 @@ function registerMemoryImportChangelog(memory2) {
     const pkgName = opts.package ?? path37.basename(path37.dirname(changelogPath));
     const scope = opts.scope ?? "team";
     const teamDir = path37.join(paths.memoriesDir, scope);
-    await mkdir15(teamDir, { recursive: true });
+    await mkdir14(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
       const lines = [];
@@ -12971,7 +13055,7 @@ function registerMemoryImportChangelog(memory2) {
 **Action:** Update all usages of ${pkgName} if they rely on any of the above.`
       );
       const slug = `changelog-${pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase()}-v${entry.version.replace(/\./g, "-")}`;
-      const fm = buildFrontmatter9({
+      const fm = buildFrontmatter8({
         type: "gotcha",
         slug,
         scope,
@@ -12985,9 +13069,9 @@ function registerMemoryImportChangelog(memory2) {
         paths: [path37.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile27(
+      await writeFile26(
         path37.join(teamDir, `${fm.id}.md`),
-        serializeMemory25({ frontmatter: fm, body: lines.join("\n") }),
+        serializeMemory24({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
       console.log(ui.green(`  \u2713 ${fm.id}`));
@@ -13010,7 +13094,7 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 
 // src/commands/memory-digest.ts
 import { existsSync as existsSync59 } from "fs";
-import { writeFile as writeFile28 } from "fs/promises";
+import { writeFile as writeFile27 } from "fs/promises";
 import path38 from "path";
 import "commander";
 import {
@@ -13107,7 +13191,7 @@ function registerMemoryDigest(program2) {
     const digest = lines.join("\n");
     if (opts.out) {
       const outPath = path38.resolve(process.cwd(), opts.out);
-      await writeFile28(outPath, digest, "utf8");
+      await writeFile27(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -13116,22 +13200,22 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile29, mkdir as mkdir16, readFile as readFile18, rm as rm2 } from "fs/promises";
+import { writeFile as writeFile28, mkdir as mkdir15, readFile as readFile18, rm as rm2 } from "fs/promises";
 import { existsSync as existsSync60 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path39 from "path";
 import { Option as Option2 } from "commander";
 import {
-  buildFrontmatter as buildFrontmatter10,
+  buildFrontmatter as buildFrontmatter9,
   findProjectRoot as findProjectRoot36,
   loadConfig as loadConfig7,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   loadPreventionEvents as loadPreventionEvents2,
   loadUsageIndex as loadUsageIndex26,
-  memoryFilePath as memoryFilePath10,
+  memoryFilePath as memoryFilePath9,
   renderCaughtForYou,
   resolveHaivePaths as resolveHaivePaths33,
-  serializeMemory as serializeMemory26,
+  serializeMemory as serializeMemory25,
   summarizeCaughtForYou,
   writeSessionHandoff as writeSessionHandoff2
 } from "@hivelore/core";
@@ -13443,7 +13527,7 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile29(topicMatch.filePath, serializeMemory26({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile28(topicMatch.filePath, serializeMemory25({ frontmatter: newFrontmatter, body }), "utf8");
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
@@ -13454,7 +13538,7 @@ function registerSessionEnd(session2) {
         return;
       }
     }
-    const frontmatter = buildFrontmatter10({
+    const frontmatter = buildFrontmatter9({
       type: "session_recap",
       slug: "recap",
       scope,
@@ -13464,9 +13548,9 @@ function registerSessionEnd(session2) {
       topic,
       status: "validated"
     });
-    const file = memoryFilePath10(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir16(path39.dirname(file), { recursive: true });
-    await writeFile29(file, serializeMemory26({ frontmatter, body }), "utf8");
+    const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    await mkdir15(path39.dirname(file), { recursive: true });
+    await writeFile28(file, serializeMemory25({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
@@ -13657,7 +13741,7 @@ function detectFormat(filePath) {
 
 // src/commands/hub.ts
 import { existsSync as existsSync63 } from "fs";
-import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile30, copyFile } from "fs/promises";
+import { mkdir as mkdir16, readFile as readFile19, writeFile as writeFile29, copyFile } from "fs/promises";
 import path41 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
@@ -13667,7 +13751,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir33,
   resolveHaivePaths as resolveHaivePaths35,
   saveConfig as saveConfig3,
-  serializeMemory as serializeMemory27
+  serializeMemory as serializeMemory26
 } from "@hivelore/core";
 function registerHub(program2) {
   const hub = program2.command("hub").description(
@@ -13678,7 +13762,7 @@ function registerHub(program2) {
     "Initialize a new team-knowledge hub repo at <hubPath>.\n\n  Creates a git repo with a .ai/ directory structure ready for shared memories.\n\n  Example:\n    hivelore hub init ../team-hub\n    hivelore hub init /srv/git/team-knowledge\n"
   ).action(async (hubPath) => {
     const absPath = path41.resolve(hubPath);
-    await mkdir17(absPath, { recursive: true });
+    await mkdir16(absPath, { recursive: true });
     const gitCheck = spawnSync5("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
       const init = spawnSync5("git", ["init"], { cwd: absPath, encoding: "utf8" });
@@ -13689,8 +13773,8 @@ function registerHub(program2) {
       }
     }
     const sharedDir = path41.join(absPath, ".ai", "memories", "shared");
-    await mkdir17(sharedDir, { recursive: true });
-    await writeFile30(
+    await mkdir16(sharedDir, { recursive: true });
+    await writeFile29(
       path41.join(absPath, ".ai", "README.md"),
       `# Hivelore Team Knowledge Hub
 
@@ -13712,7 +13796,7 @@ hivelore hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile30(
+    await writeFile29(
       path41.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
@@ -13765,7 +13849,7 @@ Next steps:
     }
     const projectName = path41.basename(root);
     const destDir = path41.join(hubRoot, ".ai", "memories", "shared", projectName);
-    await mkdir17(destDir, { recursive: true });
+    await mkdir16(destDir, { recursive: true });
     const all = await loadMemoriesFromDir33(paths.memoriesDir);
     const shared = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && // Don't push imported memories (avoid echo loops)
@@ -13784,7 +13868,7 @@ Next steps:
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
       const destPath = path41.join(destDir, fileName);
-      await writeFile30(destPath, serializeMemory27(memory2), "utf8");
+      await writeFile29(destPath, serializeMemory26(memory2), "utf8");
       pushed++;
     }
     console.log(ui.green(`\u2713 Pushed ${pushed} shared memor${pushed === 1 ? "y" : "ies"} to hub`));
@@ -13844,7 +13928,7 @@ Next steps:
     for (const sourceName of projectDirs) {
       const sourceDir = path41.join(hubSharedDir, sourceName);
       const destDir = path41.join(paths.memoriesDir, "shared", sourceName);
-      await mkdir17(destDir, { recursive: true });
+      await mkdir16(destDir, { recursive: true });
       const sourceFiles = (await readdir9(sourceDir)).filter((f) => f.endsWith(".md"));
       const { loadMemoriesFromDir: loadDir } = await import("@hivelore/core");
       const existingInDest = await loadDir(destDir);
@@ -13905,7 +13989,7 @@ Next steps:
       console.log(ui.dim("  Run `hivelore hub push` to publish them to the hub."));
     }
     void readFile19;
-    void writeFile30;
+    void writeFile29;
     void saveConfig3;
   });
 }
@@ -13913,7 +13997,7 @@ Next steps:
 // src/commands/stats.ts
 import "commander";
 import { existsSync as existsSync64 } from "fs";
-import { mkdir as mkdir18, writeFile as writeFile31 } from "fs/promises";
+import { mkdir as mkdir17, writeFile as writeFile30 } from "fs/promises";
 import path43 from "path";
 import {
   aggregateUsage,
@@ -14020,7 +14104,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir18(path43.dirname(outAbs), { recursive: true });
+  await mkdir17(path43.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -14032,7 +14116,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     top_memory_reads: memoryHitsLeader,
     roi_hints: roiHints
   };
-  await writeFile31(outAbs, JSON.stringify(payload, null, 2), "utf8");
+  await writeFile30(outAbs, JSON.stringify(payload, null, 2), "utf8");
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
@@ -14210,7 +14294,7 @@ function summarize(name, t0, payload, notes) {
 
 // src/commands/benchmark.ts
 import { existsSync as existsSync65 } from "fs";
-import { readdir as readdir7, readFile as readFile20, writeFile as writeFile33 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile20, writeFile as writeFile31 } from "fs/promises";
 import path44 from "path";
 import "commander";
 import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot41 } from "@hivelore/core";
@@ -14227,7 +14311,7 @@ function registerBenchmark(program2) {
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
       const outFile = path44.isAbsolute(opts.out) ? opts.out : path44.join(root, opts.out);
-      await writeFile33(outFile, markdown, "utf8");
+      await writeFile31(outFile, markdown, "utf8");
       ui.success(`wrote ${path44.relative(process.cwd(), outFile)}`);
       return;
     }
@@ -14356,7 +14440,7 @@ function escapeRegExp(value) {
 }
 
 // src/commands/eval.ts
-import { mkdir as mkdir19, readFile as readFile21, writeFile as writeFile34 } from "fs/promises";
+import { mkdir as mkdir18, readFile as readFile21, writeFile as writeFile33 } from "fs/promises";
 import { existsSync as existsSync66 } from "fs";
 import path45 from "path";
 import "commander";
@@ -14467,8 +14551,8 @@ function registerEval(program2) {
         report,
         gate_precision: gatePrecision
       };
-      await mkdir19(path45.dirname(baselineFile), { recursive: true });
-      await writeFile34(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
+      await mkdir18(path45.dirname(baselineFile), { recursive: true });
+      await writeFile33(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
       if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path45.relative(root, baselineFile)}`);
     }
     let delta = null;
@@ -14522,7 +14606,7 @@ function registerEval(program2) {
     const md = renderMarkdown2(root, k, resolvedSpec, report, gatePrecision, authoredScore);
     if (opts.out) {
       const outFile = path45.isAbsolute(opts.out) ? opts.out : path45.join(root, opts.out);
-      await writeFile34(outFile, md, "utf8");
+      await writeFile33(outFile, md, "utf8");
       ui.success(`wrote ${path45.relative(process.cwd(), outFile)}`);
     } else {
       console.log(md);
@@ -14739,21 +14823,21 @@ function renderMarkdown2(root, k, resolved, report, gatePrecision, authoredScore
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir20, writeFile as writeFile35 } from "fs/promises";
+import { mkdir as mkdir19, writeFile as writeFile34 } from "fs/promises";
 import { existsSync as existsSync67 } from "fs";
 import path46 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
-  buildFrontmatter as buildFrontmatter11,
+  buildFrontmatter as buildFrontmatter10,
   findProjectRoot as findProjectRoot43,
   loadConfig as loadConfig11,
   loadMemoriesFromDir as loadMemoriesFromDir35,
-  memoryFilePath as memoryFilePath11,
+  memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
   resolveHaivePaths as resolveHaivePaths39,
-  serializeMemory as serializeMemory28
+  serializeMemory as serializeMemory27
 } from "@hivelore/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -14831,7 +14915,7 @@ function registerMemorySuggest(memory2) {
           skipped.push({ query: s.query, reason: `similar memory already exists (${dup.memory.frontmatter.id})` });
           continue;
         }
-        const fm = buildFrontmatter11({
+        const fm = buildFrontmatter10({
           type: s.inferred_type,
           slug,
           scope,
@@ -14841,13 +14925,13 @@ function registerMemorySuggest(memory2) {
           status
         });
         const body = renderTemplate(s, fm.id, status);
-        const file = memoryFilePath11(paths, fm.scope, fm.id, fm.module);
-        await mkdir20(path46.dirname(file), { recursive: true });
+        const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
+        await mkdir19(path46.dirname(file), { recursive: true });
         if (existsSync67(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path46.relative(root, file)}` });
           continue;
         }
-        await writeFile35(file, serializeMemory28({ frontmatter: fm, body }), "utf8");
+        await writeFile34(file, serializeMemory27({ frontmatter: fm, body }), "utf8");
         created.push({ id: fm.id, file: path46.relative(root, file), query: s.query });
       }
       if (opts.json) {
@@ -14947,7 +15031,7 @@ function truncate2(text, max) {
 
 // src/commands/memory-archive.ts
 import { existsSync as existsSync68 } from "fs";
-import { writeFile as writeFile36 } from "fs/promises";
+import { writeFile as writeFile35 } from "fs/promises";
 import path47 from "path";
 import "commander";
 import {
@@ -14958,7 +15042,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir36,
   loadUsageIndex as loadUsageIndex29,
   resolveHaivePaths as resolveHaivePaths40,
-  serializeMemory as serializeMemory29
+  serializeMemory as serializeMemory28
 } from "@hivelore/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
 function registerMemoryArchive(memory2) {
@@ -15041,7 +15125,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile36(c.filePath, serializeMemory29({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile35(c.filePath, serializeMemory28({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -15068,7 +15152,7 @@ function parseDays(input) {
 
 // src/commands/doctor.ts
 import { existsSync as existsSync69, statSync as statSync2 } from "fs";
-import { readFile as readFile23, stat, writeFile as writeFile37 } from "fs/promises";
+import { readFile as readFile23, stat, writeFile as writeFile36 } from "fs/promises";
 import path48 from "path";
 import { execFileSync, execSync as execSync4 } from "child_process";
 import "commander";
@@ -15099,13 +15183,17 @@ function registerDoctor(program2) {
     const repairs = [];
     const config = await loadConfig13(paths);
     if (!existsSync69(paths.haiveDir)) {
-      findings.push({
-        severity: "error",
-        code: "not-initialized",
-        message: ".ai/ directory missing \u2014 Hivelore is not initialized in this project.",
-        fix: "hivelore init"
-      });
-      return emit(findings, opts);
+      if (opts.json) {
+        console.log(JSON.stringify({
+          initialized: false,
+          findings: [{ severity: "error", code: "not-initialized", message: ".ai/ directory missing \u2014 Hivelore is not initialized in this project.", fix: "hivelore init" }]
+        }, null, 2));
+      } else {
+        ui.error(`Hivelore is not initialized at ${root} (no .ai/ directory).`);
+        ui.info("Run `hivelore init` to set it up \u2014 everything it writes is removable (.ai/ + bridge files).");
+      }
+      process.exitCode = 1;
+      return;
     }
     if (opts.fix && !opts.dryRun) {
       repairs.push(
@@ -15127,8 +15215,8 @@ function registerDoctor(program2) {
         fix: "hivelore init"
       });
     } else {
-      const { readFile: readFile29 } = await import("fs/promises");
-      const content = await readFile29(paths.projectContext, "utf8");
+      const { readFile: readFile30 } = await import("fs/promises");
+      const content = await readFile30(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `hivelore init`");
       if (isTemplate) {
         findings.push({
@@ -15378,8 +15466,8 @@ function registerDoctor(program2) {
       let hasClaudeEnforcement = false;
       if (existsSync69(claudeSettings)) {
         try {
-          const { readFile: readFile29 } = await import("fs/promises");
-          const raw = await readFile29(claudeSettings, "utf8");
+          const { readFile: readFile30 } = await import("fs/promises");
+          const raw = await readFile30(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("hivelore enforce session-start") && raw.includes("hivelore enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -15402,7 +15490,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `hivelore init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.30.1"));
+    findings.push(...await collectInstallFindings(root, "0.31.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync4("haive-mcp --version", {
@@ -15410,7 +15498,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.30.1";
+      const cliVersion = "0.31.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -15439,7 +15527,7 @@ npm uninstall -g @hivelore/mcp`
             staleConfigs.push(path48.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "hivelore"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
-              await writeFile37(cfgPath, updated, "utf8");
+              await writeFile36(cfgPath, updated, "utf8");
             }
           }
         } catch {
@@ -16497,7 +16585,7 @@ function registerMemoryConflictCandidates(memory2) {
 // src/commands/enforce.ts
 import { execFile as execFile3, execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync76, statSync as statSync3 } from "fs";
-import { chmod as chmod2, mkdir as mkdir21, readFile as readFile24, readdir as readdir8, rm as rm3, writeFile as writeFile38 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir20, readFile as readFile24, readdir as readdir8, rm as rm3, writeFile as writeFile37 } from "fs/promises";
 import path54 from "path";
 import { promisify as promisify3 } from "util";
 import "commander";
@@ -16539,7 +16627,7 @@ function registerEnforce(program2) {
   enforce.command("install").description("Install Hivelore enforcement across MCP config, git hooks, CI template, and supported client hooks.").option("-d, --dir <dir>", "project root").option("--no-git", "skip git pre-commit/pre-push enforcement hooks").option("--no-claude", "skip Claude Code hooks").option("--no-ci", "skip GitHub Actions enforcement workflow").action(async (opts) => {
     const root = findProjectRoot52(opts.dir);
     const paths = resolveHaivePaths48(root);
-    await mkdir21(paths.haiveDir, { recursive: true });
+    await mkdir20(paths.haiveDir, { recursive: true });
     const current = await loadConfig15(paths);
     await saveConfig4(paths, {
       ...current,
@@ -16607,8 +16695,18 @@ function registerEnforce(program2) {
   });
   enforce.command("finish").alias("completion").description(
     "Final agent-exit gate: verify the git sync/release protocol before reporting a task done."
-  ).option("-d, --dir <dir>", "project root").option("--explain", "group findings by blocking/review/info and show repair commands", false).option("--json", "emit JSON", false).action(async (opts) => {
-    const report = await buildFinishReport(opts.dir);
+  ).option("-d, --dir <dir>", "project root").option("--explain", "group findings by blocking/review/info and show repair commands", false).option("--wait", "poll GitHub Actions until the runs for HEAD complete instead of failing on pending CI", false).option("--wait-timeout <minutes>", "max minutes to wait for CI with --wait", "15").option("--json", "emit JSON", false).action(async (opts) => {
+    let report = await buildFinishReport(opts.dir);
+    if (opts.wait) {
+      const WAIT_CODES = /* @__PURE__ */ new Set(["github-actions-pending", "github-actions-runs-missing"]);
+      const deadline = Date.now() + Math.max(1, Number(opts.waitTimeout ?? 15)) * 6e4;
+      const onlyWaitingOnCi = (r) => r.should_block && r.findings.some((f) => f.severity === "error" && WAIT_CODES.has(f.code)) && !r.findings.some((f) => f.severity === "error" && !WAIT_CODES.has(f.code));
+      while (onlyWaitingOnCi(report) && Date.now() < deadline) {
+        if (!opts.json) ui.info("GitHub Actions still running for HEAD \u2014 rechecking in 20s (--wait)\u2026");
+        await new Promise((resolve) => setTimeout(resolve, 2e4));
+        report = await buildFinishReport(opts.dir);
+      }
+    }
     printReport(report, Boolean(opts.json), Boolean(opts.explain));
     if (report.should_block) {
       if (!opts.json) printNextRequiredAction(report);
@@ -16631,7 +16729,7 @@ function registerEnforce(program2) {
     if (!root) return;
     const paths = resolveHaivePaths48(root);
     if (!existsSync76(paths.haiveDir)) return;
-    await mkdir21(paths.runtimeDir, { recursive: true });
+    await mkdir20(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this Hivelore-initialized project.";
     await applyLightweightRepairs(root, paths);
@@ -17075,7 +17173,7 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     memoryIds: briefing.memories.map((m) => m.id)
   });
   const dir = path54.join(paths.runtimeDir, "enforcement", "briefings");
-  await mkdir21(dir, { recursive: true });
+  await mkdir20(dir, { recursive: true });
   const file = path54.join(dir, `${sessionId}.md`);
   const parts = [
     "# Hivelore Briefing",
@@ -17094,7 +17192,7 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile38(file, parts.join("\n") + "\n", "utf8");
+  await writeFile37(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 var PRODUCTION_CODE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|swift|rb|php|cs|cpp|cc|c|h|hpp|vue|svelte)$/i;
@@ -17180,7 +17278,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "Hivelore enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.30.1"));
+  findings.push(...await inspectIntegrationVersions(root, "0.31.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent Hivelore briefing marker exists." } : {
@@ -17428,14 +17526,39 @@ async function runPrecommitPolicy(paths, gate, stage) {
   const reviewWarnings = result.warnings.filter(
     (w) => w.level === "review" && !w.reasons.includes("sensor")
   );
+  const REVIEW_SEEN_TTL_MS = 24 * 60 * 60 * 1e3;
+  const reviewSeenFile = path54.join(paths.runtimeDir, "enforcement", "review-seen.json");
+  let reviewSeen = {};
+  try {
+    reviewSeen = JSON.parse(await readFile24(reviewSeenFile, "utf8"));
+  } catch {
+  }
+  const now = Date.now();
+  const isFreshlySeen = (id) => {
+    const at = Date.parse(reviewSeen[id] ?? "");
+    return Number.isFinite(at) && now - at < REVIEW_SEEN_TTL_MS;
+  };
+  const newWarnings = reviewWarnings.filter((w) => !isFreshlySeen(w.id));
+  const repeatCount = reviewWarnings.length - newWarnings.length;
   const reviewFinding = reviewWarnings.length > 0 ? [{
     severity: "warn",
     code: "anti-pattern-review",
-    message: `${reviewWarnings.length} documented lesson(s) plausibly match this diff \u2014 review before committing: ` + reviewWarnings.slice(0, 3).map((w) => `${w.id} (${w.reasons.join("+")})`).join(", ") + (reviewWarnings.length > 3 ? ", \u2026" : ""),
+    message: `${reviewWarnings.length} documented lesson(s) plausibly match this diff \u2014 review before committing` + (newWarnings.length > 0 ? `: ${newWarnings.slice(0, 3).map((w) => `${w.id} (${w.reasons.join("+")})`).join(", ")}` + (newWarnings.length > 3 ? ", \u2026" : "") : "") + (repeatCount > 0 ? ` (+${repeatCount} shown in the last 24h \u2014 \`hivelore precommit\` lists all)` : "") + ".",
     fix: "Run `hivelore precommit` for the matched lines and repair commands; update the code, or retire the memory if it no longer applies.",
     memory_ids: reviewWarnings.slice(0, 10).map((w) => w.id),
     impact: 5
   }] : [];
+  if (reviewWarnings.length > 0) {
+    try {
+      for (const w of reviewWarnings) reviewSeen[w.id] = new Date(now).toISOString();
+      for (const [id, at] of Object.entries(reviewSeen)) {
+        if (!Number.isFinite(Date.parse(at)) || now - Date.parse(at) >= REVIEW_SEEN_TTL_MS) delete reviewSeen[id];
+      }
+      await mkdir20(path54.dirname(reviewSeenFile), { recursive: true });
+      await writeFile37(reviewSeenFile, JSON.stringify(reviewSeen, null, 2), "utf8");
+    } catch {
+    }
+  }
   if (!result.should_block) {
     return [
       {
@@ -17568,7 +17691,7 @@ function isGeneratedArtifactStatusLine(line) {
 }
 async function cleanupRuntimeDir(runtimeDir) {
   let removed = 0;
-  await mkdir21(runtimeDir, { recursive: true });
+  await mkdir20(runtimeDir, { recursive: true });
   const entries = await readdir8(runtimeDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore" || entry.name === "README.md") continue;
@@ -17579,9 +17702,9 @@ async function cleanupRuntimeDir(runtimeDir) {
     await rm3(path54.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile38(path54.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  await writeFile37(path54.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
   if (!existsSync76(path54.join(runtimeDir, "README.md"))) {
-    await writeFile38(
+    await writeFile37(
       path54.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. Hivelore cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
@@ -17591,14 +17714,14 @@ async function cleanupRuntimeDir(runtimeDir) {
 }
 async function cleanupCacheDir(cacheDir) {
   let removed = 0;
-  await mkdir21(cacheDir, { recursive: true });
+  await mkdir20(cacheDir, { recursive: true });
   const entries = await readdir8(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
     await rm3(path54.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile38(path54.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile37(path54.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -18069,7 +18192,7 @@ async function installGitEnforcement(root) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
-  await mkdir21(hooksDir, { recursive: true });
+  await mkdir20(hooksDir, { recursive: true });
   const resolveCli = `_hivelore() {
   if command -v hivelore >/dev/null 2>&1; then hivelore "$@"
   elif command -v haive >/dev/null 2>&1; then haive "$@"
@@ -18107,14 +18230,14 @@ _hivelore enforce commit-msg "$1" --dir . || exit $?
     if (existsSync76(file)) {
       const current = await readFile24(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile38(file, hook.body, "utf8");
+        await writeFile37(file, hook.body, "utf8");
       } else {
-        await writeFile38(file, `${current.trimEnd()}
+        await writeFile37(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile38(file, hook.body, "utf8");
+      await writeFile37(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
@@ -18122,12 +18245,12 @@ ${hook.body}`, "utf8");
 }
 async function installCiEnforcement(root) {
   const workflowPath = path54.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir21(path54.dirname(workflowPath), { recursive: true });
+  await mkdir20(path54.dirname(workflowPath), { recursive: true });
   if (existsSync76(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile38(workflowPath, `name: haive-enforcement
+  await writeFile37(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -18333,6 +18456,115 @@ function runCommand4(cmd, args, cwd) {
   });
 }
 
+// src/commands/release.ts
+import { existsSync as existsSync77 } from "fs";
+import { readFile as readFile25, writeFile as writeFile38 } from "fs/promises";
+import path55 from "path";
+import "commander";
+import { findProjectRoot as findProjectRoot53 } from "@hivelore/core";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec2 = promisify4(execFile4);
+var VERSION_FILES2 = [
+  "package.json",
+  "packages/core/package.json",
+  "packages/cli/package.json",
+  "packages/mcp/package.json",
+  "packages/embeddings/package.json"
+];
+async function readCurrentVersion(root) {
+  const pkg = JSON.parse(await readFile25(path55.join(root, "package.json"), "utf8"));
+  if (!pkg.version) throw new Error("Root package.json has no version field.");
+  return pkg.version;
+}
+function nextVersion(current, spec) {
+  if (/^\d+\.\d+\.\d+$/.test(spec)) return spec;
+  const m = current.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!m) throw new Error(`Current version "${current}" is not X.Y.Z \u2014 pass an explicit version.`);
+  const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (spec === "patch") return `${major}.${minor}.${patch + 1}`;
+  if (spec === "minor") return `${major}.${minor + 1}.0`;
+  if (spec === "major") return `${major + 1}.0.0`;
+  throw new Error(`Unknown bump "${spec}" \u2014 use patch | minor | major | X.Y.Z.`);
+}
+function registerRelease(program2) {
+  const release = program2.command("release").description("Release protocol helpers: lockstep version bump + CHANGELOG scaffold, then tag + push.");
+  release.command("bump <version>").description("Bump root + core/cli/mcp/embeddings in lockstep (patch|minor|major|X.Y.Z) and scaffold the CHANGELOG section.").option("--title <text>", "CHANGELOG section title (after the version)").option("-d, --dir <dir>", "project root").action(async (spec, opts) => {
+    const root = findProjectRoot53(opts.dir);
+    const current = await readCurrentVersion(root);
+    const next = nextVersion(current, spec);
+    for (const rel of VERSION_FILES2) {
+      const file = path55.join(root, rel);
+      if (!existsSync77(file)) {
+        ui.warn(`skip ${rel} (missing)`);
+        continue;
+      }
+      const raw = await readFile25(file, "utf8");
+      const updated = raw.replace(`"version": "${current}"`, `"version": "${next}"`);
+      if (updated === raw) {
+        ui.error(`${rel} is not at ${current} \u2014 lockstep broken; fix versions manually first.`);
+        process.exitCode = 1;
+        return;
+      }
+      await writeFile38(file, updated, "utf8");
+    }
+    const changelog = path55.join(root, "CHANGELOG.md");
+    if (existsSync77(changelog)) {
+      const raw = await readFile25(changelog, "utf8");
+      const heading = `## [${next}]${opts.title ? ` \u2014 ${opts.title}` : ""}`;
+      if (!raw.includes(`## [${next}]`)) {
+        await writeFile38(
+          changelog,
+          raw.replace("## [Unreleased]", `## [Unreleased]
+
+${heading}
+
+- TODO: describe the changes.
+`),
+          "utf8"
+        );
+      }
+    }
+    ui.success(`Bumped ${current} \u2192 ${next} across ${VERSION_FILES2.length} manifest(s); CHANGELOG scaffolded.`);
+    ui.info("Next: fill the CHANGELOG entry, build/test, commit (the gate runs), then `hivelore release tag`.");
+  });
+  release.command("tag").description("Create vX.Y.Z at HEAD (from the lockstep version), push the branch and that one tag.").option("--no-push", "create the tag locally without pushing").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot53(opts.dir);
+    const version = await readCurrentVersion(root);
+    for (const rel of VERSION_FILES2.slice(1)) {
+      const file = path55.join(root, rel);
+      if (!existsSync77(file)) continue;
+      const v = JSON.parse(await readFile25(file, "utf8")).version;
+      if (v !== version) {
+        ui.error(`${rel} is at ${v}, root at ${version} \u2014 lockstep broken; run \`hivelore release bump\` first.`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const dirty = (await exec2("git", ["status", "--porcelain"], { cwd: root })).stdout.trim();
+    if (dirty.length > 0) {
+      ui.error("Working tree is not clean \u2014 commit the bump before tagging.");
+      process.exitCode = 1;
+      return;
+    }
+    const tag = `v${version}`;
+    const existing = (await exec2("git", ["tag", "--list", tag], { cwd: root })).stdout.trim();
+    if (existing) {
+      ui.error(`Tag ${tag} already exists \u2014 bump the version first.`);
+      process.exitCode = 1;
+      return;
+    }
+    await exec2("git", ["tag", tag], { cwd: root });
+    ui.success(`Created ${tag} at HEAD.`);
+    if (opts.push !== false) {
+      await exec2("git", ["push"], { cwd: root });
+      await exec2("git", ["push", "origin", tag], { cwd: root });
+      ui.success(`Pushed branch and ${tag}.`);
+      ui.info("Next: `hivelore enforce finish --wait` (polls CI), then publish via `pnpm run publish:all` (human step).");
+    }
+  });
+}
+
 // src/commands/run.ts
 import "commander";
 function registerRun(program2) {
@@ -18346,15 +18578,15 @@ function registerRun(program2) {
 }
 
 // src/commands/sensors.ts
-import { execFile as execFile4 } from "child_process";
-import { existsSync as existsSync77 } from "fs";
-import { chmod as chmod3, mkdir as mkdir23, readFile as readFile25, writeFile as writeFile39 } from "fs/promises";
-import path55 from "path";
-import { promisify as promisify4 } from "util";
+import { execFile as execFile5 } from "child_process";
+import { existsSync as existsSync78 } from "fs";
+import { chmod as chmod3, mkdir as mkdir21, readFile as readFile26, writeFile as writeFile39 } from "fs/promises";
+import path56 from "path";
+import { promisify as promisify5 } from "util";
 import "commander";
 import {
   extractSensorExamples as extractSensorExamples2,
-  findProjectRoot as findProjectRoot53,
+  findProjectRoot as findProjectRoot54,
   isRetiredMemory as isRetiredMemory4,
   judgeProposedSensor as judgeProposedSensor2,
   loadConfig as loadConfig16,
@@ -18366,13 +18598,13 @@ import {
   sensorPatternBrittleness as sensorPatternBrittleness2,
   sensorSelfCheck as sensorSelfCheck2,
   scannableSensorTargets,
-  serializeMemory as serializeMemory30
+  serializeMemory as serializeMemory29
 } from "@hivelore/core";
-var exec2 = promisify4(execFile4);
+var exec3 = promisify5(execFile5);
 function registerSensors(program2) {
   const sensors = program2.command("sensors").description("Operate executable sensors derived from Hivelore memories");
   sensors.command("list").description("List memories carrying executable sensors").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot53(opts.dir);
+    const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
     if (opts.json) {
@@ -18401,10 +18633,10 @@ function registerSensors(program2) {
   sensors.command("check").description(
     "Run regex sensors against a diff (the deterministic/computational layer); defaults to `git diff --cached`.\n  Diff-scan layers: `sensors check` (regex) and `anti_patterns_check` (memory match) are components;\n  `pre_commit_check` combines them; `hivelore enforce check` is THE gate that runs at commit."
   ).option("--diff-file <path>", "read unified diff from a file instead of staged changes").option("--json", "emit JSON", false).option("--commands", "ALSO execute shell/test sensors (runs repo-authored commands)", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot53(opts.dir);
+    const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths49(root);
     const memories = await runnableSensorMemories(paths);
-    const diff = opts.diffFile ? await readFile25(path55.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
+    const diff = opts.diffFile ? await readFile26(path56.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = scannableSensorTargets(diff);
     const hits = runSensors3(memories, targets);
     const config = await loadConfig16(paths);
@@ -18479,9 +18711,9 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot53(opts.dir);
+    const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths49(root);
-    const loaded = existsSync77(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
+    const loaded = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -18531,7 +18763,7 @@ function registerSensors(program2) {
       },
       body: found.memory.body
     };
-    await writeFile39(found.filePath, serializeMemory30(next), "utf8");
+    await writeFile39(found.filePath, serializeMemory29(next), "utf8");
     ui.success(`Updated ${id}: sensor severity=${severity}`);
     if (sensor.pattern) ui.info(`pattern=${JSON.stringify(sensor.pattern)}`);
     ui.info(`message=${sensor.message}`);
@@ -18548,9 +18780,9 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot53(opts.dir);
+    const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths49(root);
-    const loaded = existsSync77(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
+    const loaded = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -18587,7 +18819,7 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile39(found.filePath, serializeMemory30({ frontmatter: { ...found.memory.frontmatter, sensor }, body: found.memory.body }), "utf8");
+    await writeFile39(found.filePath, serializeMemory29({ frontmatter: { ...found.memory.frontmatter, sensor }, body: found.memory.body }), "utf8");
     ui.success(`Sensor accepted (${severity}) on ${id}`);
     ui.info(`pattern=${JSON.stringify(opts.pattern)}${opts.absent ? `  absent=${JSON.stringify(opts.absent)}` : ""}`);
     ui.info(
@@ -18601,16 +18833,16 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot53(opts.dir);
+    const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
-    const outDir = path55.resolve(root, opts.outDir ?? ".ai/generated");
-    await mkdir23(outDir, { recursive: true });
-    const outPath = path55.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
+    const outDir = path56.resolve(root, opts.outDir ?? ".ai/generated");
+    await mkdir21(outDir, { recursive: true });
+    const outPath = path56.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
     const content = format === "grep" ? renderGrepScript(rows) : JSON.stringify({ sensors: rows }, null, 2) + "\n";
     await writeFile39(outPath, content, "utf8");
     if (format === "grep") await chmod3(outPath, 493);
-    ui.success(`Exported ${rows.length} sensor(s): ${path55.relative(root, outPath)}`);
+    ui.success(`Exported ${rows.length} sensor(s): ${path56.relative(root, outPath)}`);
   });
 }
 function deriveProposedMessage(body, pattern, absent) {
@@ -18643,7 +18875,7 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync77(paths.memoriesDir)) return [];
+  if (!existsSync78(paths.memoriesDir)) return [];
   const loaded = await loadMemoriesFromDir41(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
@@ -18654,7 +18886,7 @@ async function runnableSensorMemories(paths, regexOnly = true) {
 }
 async function runCommandSensor(spec, root) {
   try {
-    await exec2("bash", ["-c", spec.command], { cwd: root, timeout: 12e4, maxBuffer: 8 * 1024 * 1024 });
+    await exec3("bash", ["-c", spec.command], { cwd: root, timeout: 12e4, maxBuffer: 8 * 1024 * 1024 });
     return false;
   } catch {
     return true;
@@ -18662,7 +18894,7 @@ async function runCommandSensor(spec, root) {
 }
 async function stagedDiff(root) {
   try {
-    const { stdout } = await exec2("git", ["diff", "--cached"], { cwd: root });
+    const { stdout } = await exec3("git", ["diff", "--cached"], { cwd: root });
     return stdout;
   } catch (err) {
     throw new Error(`git diff --cached failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -18693,19 +18925,19 @@ function shellQuote(value) {
 }
 
 // src/commands/ingest.ts
-import { existsSync as existsSync78 } from "fs";
-import { mkdir as mkdir24, readFile as readFile26, writeFile as writeFile40 } from "fs/promises";
-import path56 from "path";
+import { existsSync as existsSync79 } from "fs";
+import { mkdir as mkdir23, readFile as readFile27, writeFile as writeFile40 } from "fs/promises";
+import path57 from "path";
 import "commander";
 import {
   draftsFromFindings as draftsFromFindings2,
   filterNewDrafts as filterNewDrafts2,
-  findProjectRoot as findProjectRoot54,
+  findProjectRoot as findProjectRoot55,
   loadMemoriesFromDir as loadMemoriesFromDir43,
-  memoryFilePath as memoryFilePath12,
+  memoryFilePath as memoryFilePath11,
   parseFindings as parseFindings2,
   resolveHaivePaths as resolveHaivePaths50,
-  serializeMemory as serializeMemory31
+  serializeMemory as serializeMemory30
 } from "@hivelore/core";
 var SEVERITIES = ["info", "minor", "major", "critical", "blocker"];
 function registerIngest(program2) {
@@ -18729,9 +18961,9 @@ function registerIngest(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot54(opts.dir);
+    const root = findProjectRoot55(opts.dir);
     const paths = resolveHaivePaths50(root);
-    if (!existsSync78(paths.haiveDir)) {
+    if (!existsSync79(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -18752,14 +18984,14 @@ function registerIngest(program2) {
         process.exitCode = 1;
         return;
       }
-      const reportPath = path56.resolve(root, file);
-      if (!existsSync78(reportPath)) {
+      const reportPath = path57.resolve(root, file);
+      if (!existsSync79(reportPath)) {
         ui.error(`Report file not found: ${reportPath}`);
         process.exitCode = 1;
         return;
       }
       try {
-        raw = await readFile26(reportPath, "utf8");
+        raw = await readFile27(reportPath, "utf8");
       } catch (err) {
         ui.error(`Could not read ${reportPath}: ${err instanceof Error ? err.message : String(err)}`);
         process.exitCode = 1;
@@ -18785,7 +19017,7 @@ function registerIngest(program2) {
       process.exitCode = 1;
       return;
     }
-    const existing = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir43(paths.memoriesDir) : [];
+    const existing = existsSync79(paths.memoriesDir) ? await loadMemoriesFromDir43(paths.memoriesDir) : [];
     const existingTopics = new Set(
       existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
     );
@@ -18847,14 +19079,14 @@ function registerIngest(program2) {
       await writeDraft2(paths, draft);
       created++;
     }
-    ui.success(`Created ${created} proposed memory(ies) under ${path56.relative(root, paths.memoriesDir)}/`);
+    ui.success(`Created ${created} proposed memory(ies) under ${path57.relative(root, paths.memoriesDir)}/`);
     ui.info("Review with `hivelore memory pending`; promote sensors with `hivelore sensors promote <id> --yes`.");
   });
 }
 async function writeDraft2(paths, draft) {
-  const file = memoryFilePath12(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
-  await mkdir24(path56.dirname(file), { recursive: true });
-  await writeFile40(file, serializeMemory31({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  const file = memoryFilePath11(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
+  await mkdir23(path57.dirname(file), { recursive: true });
+  await writeFile40(file, serializeMemory30({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
 async function fetchSonarIssues(opts) {
@@ -18895,11 +19127,11 @@ async function fetchSonarIssues(opts) {
 }
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 import "commander";
 import {
   buildDashboard,
-  findProjectRoot as findProjectRoot55,
+  findProjectRoot as findProjectRoot56,
   loadConfig as loadConfig17,
   loadMemoriesFromDir as loadMemoriesFromDir44,
   loadPreventionEvents as loadPreventionEvents4,
@@ -18910,14 +19142,14 @@ function registerDashboard(program2) {
   program2.command("dashboard").description(
     "Non-interactive observability snapshot of the memory corpus.\n\n  One-shot rollup an agent or CI can read (unlike `hivelore tui`, no TTY needed):\n  inventory, impact tiers + top memories, sensors (and which ones fired),\n  health (stale / anchorless / pending / prune candidates), decay, and corpus weight.\n  Use --json to pipe it into other tooling."
   ).option("--json", "emit the full report as JSON", false).option("--top <n>", "rows per top-list", "10").option("--dormant-days <n>", "dormancy window for impact scoring").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot55(opts.dir);
+    const root = findProjectRoot56(opts.dir);
     const paths = resolveHaivePaths51(root);
-    if (!existsSync79(paths.haiveDir)) {
+    if (!existsSync80(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = existsSync79(paths.memoriesDir) ? await loadMemoriesFromDir44(paths.memoriesDir) : [];
+    const memories = existsSync80(paths.memoriesDir) ? await loadMemoriesFromDir44(paths.memoriesDir) : [];
     const usage = await loadUsageIndex31(paths);
     const preventionEvents = await loadPreventionEvents4(paths);
     const config = await loadConfig17(paths);
@@ -19041,30 +19273,30 @@ function warnNum(n) {
 }
 
 // src/commands/dev-link.ts
-import { execFile as execFile5 } from "child_process";
-import { cp, readFile as readFile27 } from "fs/promises";
-import { existsSync as existsSync80 } from "fs";
-import path57 from "path";
-import { promisify as promisify5 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { cp, readFile as readFile28 } from "fs/promises";
+import { existsSync as existsSync81 } from "fs";
+import path58 from "path";
+import { promisify as promisify6 } from "util";
 import "commander";
-import { findProjectRoot as findProjectRoot56 } from "@hivelore/core";
-var exec3 = promisify5(execFile5);
+import { findProjectRoot as findProjectRoot57 } from "@hivelore/core";
+var exec4 = promisify6(execFile6);
 function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on Hivelore itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hivelore (or legacy @hiveai) install so the global binary runs your local code.").option("-d, --dir <dir>", "repo root (default: discovered from cwd)").option("--json", "emit a machine-readable summary", false).action(async (opts) => {
-    const root = findProjectRoot56(opts.dir);
-    if (!existsSync80(path57.join(root, "packages", "cli", "dist", "index.js"))) {
+    const root = findProjectRoot57(opts.dir);
+    if (!existsSync81(path58.join(root, "packages", "cli", "dist", "index.js"))) {
       ui.error(`Not the Hivelore monorepo (no packages/cli/dist) at ${root}. Run \`pnpm -r build\` first, or pass --dir.`);
       process.exitCode = 1;
       return;
     }
     let globalModules;
     try {
-      globalModules = (await exec3("npm", ["root", "-g"])).stdout.trim();
+      globalModules = (await exec4("npm", ["root", "-g"])).stdout.trim();
     } catch {
-      globalModules = path57.join(path57.dirname(path57.dirname(process.execPath)), "lib", "node_modules");
+      globalModules = path58.join(path58.dirname(path58.dirname(process.execPath)), "lib", "node_modules");
     }
-    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path57.join(globalModules, scope)).filter((dir) => existsSync80(dir));
+    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path58.join(globalModules, scope)).filter((dir) => existsSync81(dir));
     if (scopeDirs.length === 0) {
       ui.error(`No global @hivelore (or legacy @hiveai) install under ${globalModules}. Install once with \`npm i -g @hivelore/cli\`, then re-run.`);
       process.exitCode = 1;
@@ -19072,24 +19304,24 @@ function registerDevLink(program2) {
     }
     const linked = [];
     const copyDist = async (fromPkg, toDistDir) => {
-      const from = path57.join(root, "packages", fromPkg, "dist");
-      if (!existsSync80(from) || !existsSync80(path57.dirname(toDistDir))) return;
+      const from = path58.join(root, "packages", fromPkg, "dist");
+      if (!existsSync81(from) || !existsSync81(path58.dirname(toDistDir))) return;
       await cp(from, toDistDir, { recursive: true });
-      linked.push(path57.relative(globalModules, toDistDir));
+      linked.push(path58.relative(globalModules, toDistDir));
     };
     for (const globalHive of scopeDirs) {
-      const nestedScope = path57.basename(globalHive);
+      const nestedScope = path58.basename(globalHive);
       for (const pkg of ["cli", "mcp"]) {
-        await copyDist(pkg, path57.join(globalHive, pkg, "dist"));
+        await copyDist(pkg, path58.join(globalHive, pkg, "dist"));
         for (const nested of ["core", "embeddings"]) {
-          await copyDist(nested, path57.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
+          await copyDist(nested, path58.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
         }
       }
-      await copyDist("core", path57.join(globalHive, "core", "dist"));
+      await copyDist("core", path58.join(globalHive, "core", "dist"));
     }
     let version = "unknown";
     try {
-      version = JSON.parse(await readFile27(path57.join(root, "package.json"), "utf8")).version ?? "unknown";
+      version = JSON.parse(await readFile28(path58.join(root, "package.json"), "utf8")).version ?? "unknown";
     } catch {
     }
     if (opts.json) {
@@ -19100,27 +19332,27 @@ function registerDevLink(program2) {
       ui.warn("Nothing linked \u2014 no matching dist targets were found in the global install.");
       return;
     }
-    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path57.basename(d)).join(", ")}`);
+    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path58.basename(d)).join(", ")}`);
     for (const t of linked) console.log(`  ${ui.dim("\u2192")} ${t}`);
     console.log(ui.dim("The global binary now runs your local build (git hooks + MCP included)."));
   });
 }
 
 // src/commands/coverage.ts
-import { readFile as readFile28 } from "fs/promises";
-import { existsSync as existsSync81 } from "fs";
-import path58 from "path";
+import { readFile as readFile29 } from "fs/promises";
+import { existsSync as existsSync83 } from "fs";
+import path59 from "path";
 import "commander";
 import {
   findCoverageGaps,
-  findProjectRoot as findProjectRoot57,
+  findProjectRoot as findProjectRoot58,
   mergeHotFiles,
   resolveHaivePaths as resolveHaivePaths52,
   tallyHotFiles
 } from "@hivelore/core";
 async function readAgentHotFiles(root, cacheFile, sinceMs) {
-  if (!existsSync81(cacheFile)) return [];
-  const raw = await readFile28(cacheFile, "utf8").catch(() => "");
+  if (!existsSync83(cacheFile)) return [];
+  const raw = await readFile29(cacheFile, "utf8").catch(() => "");
   const files = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -19133,7 +19365,7 @@ async function readAgentHotFiles(root, cacheFile, sinceMs) {
       }
       for (const f of obs.files ?? []) {
         if (typeof f !== "string" || !f) continue;
-        const rel = path58.isAbsolute(f) ? path58.relative(root, f) : f;
+        const rel = path59.isAbsolute(f) ? path59.relative(root, f) : f;
         if (rel.startsWith("..")) continue;
         files.push(rel);
       }
@@ -19154,7 +19386,7 @@ function registerCoverage(program2) {
   program2.command("coverage").description(
     "Coverage-gap report: frequently-edited files with no covering team memory (blind spots)."
   ).option("--json", "emit JSON", false).option("--min-changes <n>", "minimum churn count to flag a file", "3").option("--limit <n>", "max gaps to report", "20").option("--days <n>", "lookback window in days (git history + agent edits)", "90").option("--source <which>", "heat source: git | agent | both", "both").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot57(opts.dir);
+    const root = findProjectRoot58(opts.dir);
     const paths = resolveHaivePaths52(root);
     const minChanges = Math.max(1, parseInt(opts.minChanges ?? "3", 10) || 3);
     const limit = Math.max(1, parseInt(opts.limit ?? "20", 10) || 20);
@@ -19177,7 +19409,7 @@ function registerCoverage(program2) {
     }) : null;
     const gitHotFiles = (radar?.hotFiles ?? []).filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes, source: "git" }));
     const sinceMs = Date.now() - days * 864e5;
-    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path58.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path59.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
     const hotFiles = mergeHotFiles(gitHotFiles, agentHotFiles);
     const memories = await loadMemoriesFromDir29(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
@@ -19215,10 +19447,10 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync83 } from "fs";
-import path59 from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync84 } from "fs";
+import path60 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hivelore/core";
+import { findProjectRoot as findProjectRoot59, mergeMemoryVersions } from "@hivelore/core";
 var GITATTRIBUTES_MARK = "# Hivelore merge driver";
 var GITATTRIBUTES_BLOCK = [
   GITATTRIBUTES_MARK,
@@ -19239,7 +19471,7 @@ function registerMergeDriver(program2) {
     }
   });
   cmd.command("install").description("Configure git + .gitattributes so memory-file conflicts auto-resolve").option("-d, --dir <dir>", "project root").action((opts) => {
-    const root = findProjectRoot58(opts.dir);
+    const root = findProjectRoot59(opts.dir);
     try {
       execFileSync3("git", ["config", "merge.haive.name", "Hivelore memory merge driver"], { cwd: root });
       execFileSync3("git", ["config", "merge.haive.driver", "hivelore merge-driver run %O %A %B"], { cwd: root });
@@ -19248,8 +19480,8 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path59.join(root, ".gitattributes");
-    let content = existsSync83(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    const gaPath = path60.join(root, ".gitattributes");
+    let content = existsSync84(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -19264,20 +19496,20 @@ function registerMergeDriver(program2) {
 
 // src/commands/memory-resolve-conflict.ts
 import { writeFile as writeFile41 } from "fs/promises";
-import { existsSync as existsSync84 } from "fs";
+import { existsSync as existsSync85 } from "fs";
 import "commander";
 import {
   applyConflictResolution,
-  findProjectRoot as findProjectRoot59,
+  findProjectRoot as findProjectRoot60,
   planConflictResolution as planConflictResolution2,
   resolveHaivePaths as resolveHaivePaths53,
-  serializeMemory as serializeMemory33
+  serializeMemory as serializeMemory31
 } from "@hivelore/core";
 function registerMemoryResolveConflict(memory2) {
   memory2.command("resolve-conflict <id_a> <id_b>").description("Resolve a contradiction: keep the stronger memory, deprecate (supersede) the other").option("--yes", "apply the resolution (without this, only previews it)", false).option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (idA, idB, opts) => {
-    const root = findProjectRoot59(opts.dir);
+    const root = findProjectRoot60(opts.dir);
     const paths = resolveHaivePaths53(root);
-    if (!existsSync84(paths.memoriesDir)) {
+    if (!existsSync85(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -19317,12 +19549,12 @@ function registerMemoryResolveConflict(memory2) {
     }
     await writeFile41(
       winner.filePath,
-      serializeMemory33({ frontmatter: applied.winner, body: winner.memory.body }),
+      serializeMemory31({ frontmatter: applied.winner, body: winner.memory.body }),
       "utf8"
     );
     await writeFile41(
       loser.filePath,
-      serializeMemory33({ frontmatter: applied.loser, body: loser.memory.body }),
+      serializeMemory31({ frontmatter: applied.loser, body: loser.memory.body }),
       "utf8"
     );
     if (!opts.json) {
@@ -19332,26 +19564,26 @@ function registerMemoryResolveConflict(memory2) {
 }
 
 // src/commands/memory-seed-git.ts
-import { execFile as execFile6 } from "child_process";
-import { mkdir as mkdir25, writeFile as writeFile43 } from "fs/promises";
-import { existsSync as existsSync85 } from "fs";
-import path60 from "path";
-import { promisify as promisify6 } from "util";
+import { execFile as execFile7 } from "child_process";
+import { mkdir as mkdir24, writeFile as writeFile43 } from "fs/promises";
+import { existsSync as existsSync86 } from "fs";
+import path61 from "path";
+import { promisify as promisify7 } from "util";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter12,
-  findProjectRoot as findProjectRoot60,
-  memoryFilePath as memoryFilePath13,
+  buildFrontmatter as buildFrontmatter11,
+  findProjectRoot as findProjectRoot61,
+  memoryFilePath as memoryFilePath12,
   proposeSeedsFromCommits as proposeSeedsFromCommits2,
   resolveHaivePaths as resolveHaivePaths54,
-  serializeMemory as serializeMemory34
+  serializeMemory as serializeMemory33
 } from "@hivelore/core";
-var exec4 = promisify6(execFile6);
+var exec5 = promisify7(execFile7);
 function registerMemorySeedGit(memory2) {
   memory2.command("seed-git").description("Propose draft `attempt` seeds from revert/hotfix commits in git history (cold-start)").option("--apply", "write the proposed seeds as draft memories (default: preview only)", false).option("--limit <n>", "max seeds to propose", "20").option("--days <n>", "git-history lookback window in days", "365").option("--scope <scope>", "personal | team", "team").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot60(opts.dir);
+    const root = findProjectRoot61(opts.dir);
     const paths = resolveHaivePaths54(root);
-    if (!existsSync85(paths.haiveDir)) {
+    if (!existsSync86(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -19379,7 +19611,7 @@ function registerMemorySeedGit(memory2) {
     let written = 0;
     for (const p of proposals) {
       const fm = {
-        ...buildFrontmatter12({
+        ...buildFrontmatter11({
           type: "attempt",
           slug: p.slug,
           scope: opts.scope ?? "team",
@@ -19395,10 +19627,10 @@ function registerMemorySeedGit(memory2) {
 
 _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delete) \u2014 not yet authoritative._
 `;
-      const file = memoryFilePath13(paths, fm.scope, fm.id, fm.module);
-      if (existsSync85(file)) continue;
-      await mkdir25(path60.dirname(file), { recursive: true });
-      await writeFile43(file, serializeMemory34({ frontmatter: fm, body }), "utf8");
+      const file = memoryFilePath12(paths, fm.scope, fm.id, fm.module);
+      if (existsSync86(file)) continue;
+      await mkdir24(path61.dirname(file), { recursive: true });
+      await writeFile43(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
       written += 1;
     }
     if (!opts.json) {
@@ -19408,7 +19640,7 @@ _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delet
 }
 async function readCommits(root, days) {
   try {
-    const { stdout } = await exec4(
+    const { stdout } = await exec5(
       "git",
       ["log", `--since=${days}.days.ago`, "--name-only", "--pretty=format:%x1f%h%x1f%s", "-n", "500"],
       { cwd: root, maxBuffer: 8 * 1024 * 1024 }
@@ -19429,11 +19661,11 @@ async function readCommits(root, days) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync86 } from "fs";
-import path61 from "path";
+import { existsSync as existsSync87 } from "fs";
+import path63 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot61,
+  findProjectRoot as findProjectRoot62,
   resolveHaivePaths as resolveHaivePaths55,
   BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH3,
   BRIDGE_TARGETS as BRIDGE_TARGETS3
@@ -19448,10 +19680,10 @@ function registerBridges(program2) {
     "--only <targets>",
     "comma-separated list of targets to generate (e.g. cline,windsurf,agents)"
   ).option("--max-memories <n>", "max memories to inject per bridge", "8").option("--dry-run", "show what would change without writing").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot61(opts.dir);
+    const root = findProjectRoot62(opts.dir);
     const paths = resolveHaivePaths55(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync86(paths.memoriesDir)) {
+    if (!existsSync87(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -19470,7 +19702,7 @@ function registerBridges(program2) {
       targets = BRIDGE_TARGETS3;
     } else {
       targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync86(path61.join(root, BRIDGE_TARGET_PATH3[t]))
+        (t) => existsSync87(path63.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -19499,7 +19731,7 @@ function registerBridges(program2) {
     console.log(ui.dim(`bridges: ${parts.join(" \xB7 ") || "nothing to do"}`));
   });
   bridges.command("status").alias("list").description("List bridge targets and whether their Hivelore-managed blocks are current").option("-d, --dir <dir>", "project root").option("--max-memories <n>", "max memories expected in generated bridge blocks", "8").action(async (opts) => {
-    const root = findProjectRoot61(opts.dir);
+    const root = findProjectRoot62(opts.dir);
     const paths = resolveHaivePaths55(root);
     const statuses = await getBridgeFileStatuses(root, paths, {
       targets: BRIDGE_TARGETS3,
@@ -19517,13 +19749,14 @@ function registerBridges(program2) {
 }
 
 // src/index.ts
-var program = new Command64();
-program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.30.1").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
+var program = new Command65();
+program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.31.0").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
 registerRuntime(program);
 registerEnforce(program);
+registerRelease(program);
 registerRun(program);
 registerAgent(program);
 registerSensors(program);