@hiveai/cli 0.20.1 → 0.23.0

package/dist/index.js

@@ -208,7 +208,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path60, changes]) => ({ path: path60, changes }));
+    let entries = [...counts.entries()].map(([path61, changes]) => ({ path: path61, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -834,7 +834,7 @@ var TokenBudgetWriter = class {
 function registerBriefing(program2) {
   program2.command("briefing").description(
     'Print the full project briefing: last session recap + project context + relevant memories.\n  Equivalent to calling get_briefing via MCP. Run before starting any task.\n\n  Examples:\n    haive briefing\n    haive briefing --task "add Stripe payment" --files src/payments/PaymentService.ts\n    haive briefing --budget quick --task "tiny fix"\n'
-  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "8").option("--max-tokens <n>", "approximate token budget for the entire briefing (truncates if exceeded)").option("--explain-source", "annotate each memory with [source: <relative-path> \xB7 anchors: <files>] for traceable citations").option("--radar", "force project radar (recent commits, open TODOs, hot files) even when memories are plentiful").option("--no-radar", "disable the project radar even when memories are scarce").option(
+  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "8").option("--max-tokens <n>", "approximate token budget for the entire briefing (truncates if exceeded)").option("--explain-source", "annotate each memory with [source: <relative-path> \xB7 anchors: <files>] for traceable citations").option("--radar", "force project radar (recent commits, open TODOs, hot files) even when memories are plentiful").option("--no-radar", "disable the project radar even when memories are scarce").option("--json", "emit the ranked briefing as JSON (memories + scores + priority), like the MCP get_briefing tool", false).option(
     "--budget <preset>",
     "align with MCP get_briefing budget_preset: quick | balanced | deep \u2014 sets cap + truncation budget (overrides --max-memories / replaces default open-ended output)",
     void 0
@@ -897,8 +897,10 @@ function registerBriefing(program2) {
       budgetTokensCap = presetNums.max_tokens;
       maxMemories = presetNums.max_memories;
     }
+    const json = opts.json === true;
     const writer = budgetTokensCap !== null ? new TokenBudgetWriter(budgetTokensCap * CHARS_PER_TOKEN) : null;
     const out = (text) => {
+      if (json) return true;
       if (writer) return writer.write(text);
       console.log(text);
       return true;
@@ -1015,6 +1017,10 @@ function registerBriefing(program2) {
     scored.sort((a, b) => b.score - a.score);
     const top = scored.slice(0, maxMemories);
     if (top.length === 0) {
+      if (json) {
+        console.log(JSON.stringify({ task: opts.task ?? null, memories: [], briefing_quality: "thin" }, null, 2));
+        return;
+      }
       ui.info("No relevant memories found.");
       const draftCount = all.filter(
         (m) => m.memory.frontmatter.status === "draft" && (scopeFilter === "all" || m.memory.frontmatter.scope === scopeFilter)
@@ -1046,6 +1052,26 @@ 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 ? backgroundCount > mustReadCount + usefulCount && backgroundCount > 2 ? "noisy" : "strong" : "thin";
+    if (json) {
+      console.log(JSON.stringify({
+        task: opts.task ?? null,
+        files: filePaths,
+        briefing_quality: quality,
+        counts: { must_read: mustReadCount, useful: usefulCount, background: backgroundCount },
+        recap_id: recaps[0]?.memory.frontmatter.id ?? null,
+        memories: top.map((item, i) => ({
+          id: item.memory.frontmatter.id,
+          scope: item.memory.frontmatter.scope,
+          type: item.memory.frontmatter.type,
+          status: item.memory.frontmatter.status,
+          priority: priorities[i],
+          score: item.score,
+          file: path3.relative(root, item.filePath),
+          summary: (item.memory.body.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l.length > 0) ?? "").slice(0, 140)
+        }))
+      }, null, 2));
+      return;
+    }
     out(ui.dim(`briefing_quality: ${quality} \xB7 must_read=${mustReadCount} useful=${usefulCount} background=${backgroundCount}`));
     out("");
     for (const [idx, item] of top.entries()) {
@@ -3339,7 +3365,13 @@ async function seedStackPack(haivePaths, stack) {
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
     if (existsSync10(filePath)) continue;
-    const content = serializeMemory2({ frontmatter: fm, body: `${mem.body}
+    const ruleSlug = combinedSlug.startsWith(`${stack}-`) ? combinedSlug.slice(stack.length + 1) : combinedSlug;
+    const titleCase = (s) => s.split("-").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    const heading = `${titleCase(stack)}: ${titleCase(ruleSlug)}`;
+    const titledBody = /^#{1,3}\s+\S/m.test(mem.body.trim()) ? mem.body : `# ${heading}
+
+${mem.body}`;
+    const content = serializeMemory2({ frontmatter: fm, body: `${titledBody}
 
 ${SEED_FOOTER(stack)}` });
     await mkdir5(path10.dirname(filePath), { recursive: true });
@@ -3354,7 +3386,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.20.1"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.23.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -4710,7 +4742,6 @@ import { z as z25 } from "zod";
 import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
-  appendPreventionEvent,
   BRIDGE_TARGET_PATH,
   buildDocFrequency,
   CODE_STOPWORDS,
@@ -4722,9 +4753,8 @@ import {
   loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
-  recordPrevention,
+  recordPreventionHits,
   runSensors,
-  saveUsageIndex as saveUsageIndex4,
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
@@ -4771,7 +4801,8 @@ import { existsSync as existsSync30 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir23
+  loadMemoriesFromDir as loadMemoriesFromDir23,
+  planConflictResolution
 } from "@hiveai/core";
 import { z as z32 } from "zod";
 import { resolveProjectInfo } from "@hiveai/core";
@@ -5775,7 +5806,15 @@ async function memTried(input, ctx) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
-  return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
+  const sensorGenerated = Boolean(sensor);
+  const hint = sensorGenerated ? void 0 : input.paths.length === 0 ? "No sensor was generated (no `paths` given), so this lesson 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 to close the loop." : "No sensor could be derived from the wording (no distinctive code token). The lesson is briefed but not enforced; add a concrete forbidden token/value, or attach a sensor manually, to make the gate block the repeat.";
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file,
+    sensor_generated: sensorGenerated,
+    ...hint ? { hint } : {}
+  };
 }
 var IngestFindingsInputSchema = {
   format: z16.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
@@ -7326,19 +7365,7 @@ async function antiPatternsCheck(input, ctx) {
   const strongCatches = warnings.filter(
     (w) => w.reasons.includes("sensor") || w.reasons.includes("anchor") && w.reasons.includes("literal")
   );
-  if (strongCatches.length > 0) {
-    const recordedIds = [];
-    for (const w of strongCatches) if (recordPrevention(usage, w.id)) recordedIds.push(w.id);
-    if (recordedIds.length > 0) {
-      await saveUsageIndex4(ctx.paths, usage).catch(() => {
-      });
-      const at = (/* @__PURE__ */ new Date()).toISOString();
-      for (const id of recordedIds) {
-        await appendPreventionEvent(ctx.paths, { at, id, source: "anti-pattern" }).catch(() => {
-        });
-      }
-    }
-  }
+  await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
   return {
     scanned: negative.length,
     warnings
@@ -8256,6 +8283,18 @@ function gitFileDiff(root, file, sinceDays) {
     return null;
   }
 }
+function suggestResolution(byId, idA, idB) {
+  const a = byId.get(idA);
+  const b = byId.get(idB);
+  if (!a || !b) return null;
+  const plan = planConflictResolution(a, b);
+  return {
+    keep_id: plan.keep_id,
+    supersede_id: plan.supersede_id,
+    reason: plan.reason,
+    command: `haive memory resolve-conflict ${plan.keep_id} ${plan.supersede_id} --yes`
+  };
+}
 var MemConflictCandidatesInputSchema = {
   since_days: z32.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
   types: z32.array(z32.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
@@ -8277,6 +8316,7 @@ async function memConflictCandidates(input, ctx) {
     };
   }
   const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
+  const byId = new Map(all.map((m) => [m.memory.frontmatter.id, m]));
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -8285,8 +8325,22 @@ async function memConflictCandidates(input, ctx) {
     maxScan: input.max_scan
   });
   const topicStatusPairs = findTopicStatusConflictPairs(all, input.max_topic_pairs);
+  const enrichedPairs = pairs.map((p) => ({
+    ...p,
+    suggested_resolution: suggestResolution(byId, p.id_a, p.id_b)
+  }));
+  const enrichedTopicStatusPairs = topicStatusPairs.map((p) => ({
+    ...p,
+    suggested_resolution: suggestResolution(byId, p.id_a, p.id_b)
+  }));
   const notice = pairs.length === 0 && topicStatusPairs.length === 0 ? "No lexical or topic-status candidates \u2014 widen since_days/types or lower min_jaccard." : void 0;
-  return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
+  return {
+    pairs: enrichedPairs,
+    topic_status_pairs: enrichedTopicStatusPairs,
+    scanned,
+    truncated,
+    notice
+  };
 }
 var MemResolveProjectInputSchema = {
   cwd: z33.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
@@ -8600,7 +8654,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.20.1";
+var SERVER_VERSION = "0.23.0";
 function jsonResult(data) {
   return {
     content: [
@@ -11134,7 +11188,13 @@ function registerMemoryTried(memory2) {
     await writeFile21(file, serializeMemory19({ frontmatter, body }), "utf8");
     ui.success(`Recorded: ${path27.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
-    if (sensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
+    if (sensor) {
+      ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
+    } else {
+      ui.warn(
+        frontmatter.anchor.paths.length === 0 ? "No sensor generated (no --paths) \u2014 lesson is briefed but NOT enforced. Add --paths to close the loop." : "No sensor could be derived from the wording \u2014 lesson is briefed but NOT enforced. Use a concrete forbidden token to enable a gate block."
+      );
+    }
   });
 }
 function parseCsv4(value) {
@@ -11394,7 +11454,7 @@ import {
   loadUsageIndex as loadUsageIndex18,
   recordRejection as recordRejection3,
   resolveHaivePaths as resolveHaivePaths23,
-  saveUsageIndex as saveUsageIndex5,
+  saveUsageIndex as saveUsageIndex4,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function registerMemoryReject(memory2) {
@@ -11427,7 +11487,7 @@ function registerMemoryReject(memory2) {
     );
     const idx = await loadUsageIndex18(paths);
     recordRejection3(idx, id, opts.reason ?? null);
-    await saveUsageIndex5(paths, idx);
+    await saveUsageIndex4(paths, idx);
     const u = idx.by_id[id];
     ui.success(
       `Rejected ${id} (status=rejected, ${u.rejected_count} rejection${u.rejected_count === 1 ? "" : "s"})`
@@ -11446,7 +11506,7 @@ import {
   findProjectRoot as findProjectRoot27,
   loadUsageIndex as loadUsageIndex19,
   resolveHaivePaths as resolveHaivePaths24,
-  saveUsageIndex as saveUsageIndex6
+  saveUsageIndex as saveUsageIndex5
 } from "@hiveai/core";
 function registerMemoryRm(memory2) {
   memory2.command("delete <id>").alias("rm").description("Delete a memory file (and its usage entry by default). Mirrors MCP mem_delete. Alias: rm").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
@@ -11480,7 +11540,7 @@ function registerMemoryRm(memory2) {
       const idx = await loadUsageIndex19(paths);
       if (idx.by_id[id]) {
         delete idx.by_id[id];
-        await saveUsageIndex6(paths, idx);
+        await saveUsageIndex5(paths, idx);
         ui.info("Removed usage entry");
       }
     }
@@ -11693,7 +11753,7 @@ import {
   recordRejection as recordRejection4,
   recommendFeedbackAdjustment as recommendFeedbackAdjustment2,
   resolveHaivePaths as resolveHaivePaths28,
-  saveUsageIndex as saveUsageIndex7,
+  saveUsageIndex as saveUsageIndex6,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 function registerMemoryFeedback(memory2) {
@@ -11723,7 +11783,7 @@ function registerMemoryFeedback(memory2) {
     const outcome = opts.applied ? "applied" : "rejected";
     if (opts.applied) recordApplied2(index, id);
     else recordRejection4(index, id, opts.reason ?? null);
-    await saveUsageIndex7(paths, index);
+    await saveUsageIndex6(paths, index);
     const usage = getUsage19(index, id);
     const adjustment = opts.rejected ? recommendFeedbackAdjustment2(target.memory.frontmatter, usage) : { action: "none", reason: "No automatic adjustment needed." };
     const adjustedFrontmatter = applyFeedbackAdjustment2(target.memory.frontmatter, adjustment);
@@ -13554,6 +13614,7 @@ function registerEval(program2) {
         root,
         k,
         spec_source: resolvedSpec.source,
+        provenance: { synthesized: resolvedSpec.synthesized, authored: resolvedSpec.authored },
         report,
         gate_precision: gatePrecision,
         ...delta ? { delta } : {},
@@ -13562,13 +13623,18 @@ function registerEval(program2) {
       applyExitGates(opts, report, delta, gatePrecision, gateDelta);
       return;
     }
+    if (resolvedSpec.authored === 0 && resolvedSpec.synthesized > 0) {
+      ui.warn(
+        `All ${resolvedSpec.synthesized} case(s) are self-synthesized from your own memories (self-referential). Add hand-labeled cases in .ai/eval/spec.json, or run \`haive eval --spec <file>\`, for an independent score.`
+      );
+    }
     if (delta) {
       console.log(renderDelta(delta));
     }
     if (gateDelta) {
       console.log(renderGateDelta(gateDelta));
     }
-    const md = renderMarkdown2(root, k, resolvedSpec.source, report, gatePrecision);
+    const md = renderMarkdown2(root, k, resolvedSpec, report, gatePrecision);
     if (opts.out) {
       const outFile = path44.isAbsolute(opts.out) ? opts.out : path44.join(root, opts.out);
       await writeFile33(outFile, md, "utf8");
@@ -13651,30 +13717,39 @@ function renderGateDelta(delta) {
   lines.push(`  rejections ${delta.rejections.baseline ?? "n/a"} \u2192 ${delta.rejections.current ?? "n/a"} ${ui.dim(`(${rejectionDelta})`)}`);
   return lines.join("\n");
 }
+function countCases(spec) {
+  return (spec.retrieval?.length ?? 0) + (spec.sensors?.length ?? 0);
+}
 async function resolveSpec(opts, root, memoriesDir) {
   if (opts.spec) {
     const file = path44.resolve(opts.spec);
     const raw = await readFile21(file, "utf8");
-    return { spec: JSON.parse(raw), source: file };
+    const spec = JSON.parse(raw);
+    return { spec, source: file, synthesized: 0, authored: countCases(spec) };
   }
   const defaultSpec = path44.join(root, ".ai", "eval", "spec.json");
   if (existsSync65(defaultSpec)) {
     const raw = await readFile21(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
     const memories2 = await loadMemoriesFromDir27(memoriesDir);
-    const synthesized = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
+    const synthesized2 = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
     return {
       spec: {
-        retrieval: [...synthesized, ...explicit.retrieval ?? []],
+        retrieval: [...synthesized2, ...explicit.retrieval ?? []],
         sensors: explicit.sensors ?? []
       },
-      source: ".ai/eval/spec.json + synthesized anchored retrieval"
+      source: ".ai/eval/spec.json + synthesized anchored retrieval",
+      synthesized: synthesized2.length,
+      authored: countCases(explicit)
     };
   }
   const memories = await loadMemoriesFromDir27(memoriesDir);
+  const synthesized = synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly });
   return {
-    spec: { retrieval: synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly }) },
-    source: "synthesized anchored retrieval"
+    spec: { retrieval: synthesized },
+    source: "synthesized anchored retrieval",
+    synthesized: synthesized.length,
+    authored: 0
   };
 }
 async function runRetrieval(c, k, ctx) {
@@ -13707,12 +13782,14 @@ async function runSensorCase(c, ctx) {
 function pct(n) {
   return `${Math.round(n * 100)}%`;
 }
-function renderMarkdown2(root, k, source, report, gatePrecision) {
+function renderMarkdown2(root, k, resolved, report, gatePrecision) {
+  const provenance = resolved.authored === 0 ? `${resolved.synthesized} synthesized (self-referential \u2014 sanity floor, not ground truth)` : resolved.synthesized === 0 ? `${resolved.authored} authored (independent ground truth)` : `${resolved.authored} authored (independent) + ${resolved.synthesized} synthesized (self-referential)`;
   const lines = [
     "# hAIve eval report",
     "",
     `Project: \`${root}\` \xB7 top-k: ${k}`,
-    `Spec: ${source}`,
+    `Spec: ${resolved.source}`,
+    `Cases: ${provenance}`,
     "",
     `## Overall score: ${report.score}/100`,
     ""
@@ -14153,8 +14230,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile28 } = await import("fs/promises");
-      const content = await readFile28(paths.projectContext, "utf8");
+      const { readFile: readFile29 } = await import("fs/promises");
+      const content = await readFile29(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -14328,8 +14405,8 @@ function registerDoctor(program2) {
       let hasClaudeEnforcement = false;
       if (existsSync68(claudeSettings)) {
         try {
-          const { readFile: readFile28 } = await import("fs/promises");
-          const raw = await readFile28(claudeSettings, "utf8");
+          const { readFile: readFile29 } = await import("fs/promises");
+          const raw = await readFile29(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -14352,7 +14429,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.20.1"));
+    findings.push(...await collectInstallFindings(root, "0.23.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -14360,7 +14437,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.20.1";
+      const cliVersion = "0.23.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -15433,10 +15510,11 @@ function registerMemoryConflictCandidates(memory2) {
 }
 
 // src/commands/enforce.ts
-import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
+import { execFile as execFile3, execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync75, statSync as statSync3 } from "fs";
 import { chmod as chmod2, mkdir as mkdir21, readFile as readFile24, readdir as readdir6, rm as rm3, writeFile as writeFile37 } from "fs/promises";
 import path53 from "path";
+import { promisify as promisify3 } from "util";
 import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
@@ -15450,15 +15528,18 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir38,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
+  recordPreventionHits as recordPreventionHits2,
   resolveBriefingBudget as resolveBriefingBudget3,
   resolveHaivePaths as resolveHaivePaths48,
   runSensors as runSensors2,
   saveConfig as saveConfig4,
+  selectCommandSensors,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
   writeBriefingMarker as writeBriefingMarker3
 } from "@hiveai/core";
+var execFileAsync2 = promisify3(execFile3);
 var MAX_STDIN_BYTES2 = 256 * 1024;
 var ENFORCE_HOOK_MARKER = "# hAIve enforcement hook";
 function registerEnforce(program2) {
@@ -16060,7 +16141,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.20.1"));
+  findings.push(...await inspectIntegrationVersions(root, "0.23.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 hAIve briefing marker exists." } : {
@@ -16221,6 +16302,26 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
       message: `Relevant decisions/policies were surfaced for ${changedFiles.length} changed file(s): ${relevant.length}/${relevant.length}.`
     }];
   }
+  if (stage === "pre-commit" || stage === "pre-push") {
+    const cfg = await loadConfig14(paths).catch(() => ({}));
+    if (cfg.enforcement?.autoBrief !== false) {
+      await writeBriefingMarker3(paths, {
+        sessionId,
+        source: "haive-autobrief",
+        task: "decision-coverage auto-surfaced at commit",
+        memoryIds: relevant.map(({ memory: memory2 }) => memory2.frontmatter.id),
+        files: changedFiles
+      }).catch(() => {
+      });
+      return [{
+        severity: "ok",
+        code: "decision-coverage-autosurfaced",
+        message: `Surfaced ${relevant.length} relevant decision/policy memor${relevant.length === 1 ? "y" : "ies"} for ${changedFiles.length} changed file(s) at commit time` + (missing.length > 0 ? ` (${missing.length} not previously briefed \u2014 now recorded)` : "") + ". Set enforcement.autoBrief=false to require a manual briefing first.",
+        memory_ids: relevant.slice(0, 12).map(({ memory: memory2 }) => memory2.frontmatter.id),
+        affected_files: changedFiles.slice(0, 10)
+      }];
+    }
+  }
   return [{
     severity: stage === "local" ? "warn" : "error",
     code: "decision-coverage-missing",
@@ -16292,19 +16393,19 @@ async function runSensorGate(paths, diff) {
   if (!diff || !existsSync75(paths.memoriesDir)) return [];
   try {
     const loaded = await loadMemoriesFromDir38(paths.memoriesDir);
-    const sensorMemories = loaded.map((l) => l.memory).filter((m) => {
-      const s = m.frontmatter.sensor;
-      return Boolean(s) && s.kind === "regex" && !isRetiredMemory3(m.frontmatter, m.body);
-    });
-    if (sensorMemories.length === 0) return [];
+    const scannable = loaded.map((l) => l.memory).filter((m) => Boolean(m.frontmatter.sensor) && !isRetiredMemory3(m.frontmatter, m.body));
+    if (scannable.length === 0) return [];
     const targets = sensorTargetsFromDiff2(diff).filter((t) => isSensorScannablePath(t.path));
     if (targets.length === 0) return [];
-    const hits = runSensors2(sensorMemories, targets);
     const findings = [];
     const seen = /* @__PURE__ */ new Set();
+    const firedIds = /* @__PURE__ */ new Set();
+    const regexSensorMemories = scannable.filter((m) => m.frontmatter.sensor.kind === "regex");
+    const hits = regexSensorMemories.length > 0 ? runSensors2(regexSensorMemories, targets) : [];
     for (const hit of hits) {
       if (seen.has(hit.memory_id)) continue;
       seen.add(hit.memory_id);
+      firedIds.add(hit.memory_id);
       const where = hit.file ? ` (${hit.file})` : "";
       if (hit.severity === "block") {
         findings.push({
@@ -16324,11 +16425,51 @@ async function runSensorGate(paths, diff) {
         });
       }
     }
+    const config = await loadConfig14(paths).catch(() => null);
+    if (config?.enforcement?.runCommandSensors === true) {
+      const changedPaths = targets.map((t) => t.path).filter(Boolean);
+      for (const spec of selectCommandSensors(scannable, changedPaths)) {
+        if (seen.has(spec.memory_id)) continue;
+        const failed = await runGateCommandSensor(spec, paths.root);
+        if (!failed) continue;
+        seen.add(spec.memory_id);
+        firedIds.add(spec.memory_id);
+        if (spec.severity === "block") {
+          findings.push({
+            severity: "error",
+            code: "sensor-block",
+            message: `Block command sensor fired \u2014 ${spec.memory_id}: ${spec.message} (command: ${spec.command})`,
+            fix: "Fix the condition the command checks, or run `haive sensors check --commands` to inspect it.",
+            impact: 45
+          });
+        } else {
+          findings.push({
+            severity: "warn",
+            code: "sensor-warn",
+            message: `Command sensor flagged ${spec.memory_id}: ${spec.message}`,
+            fix: "Review the failing command; `haive sensors check --commands` re-runs it.",
+            impact: 5
+          });
+        }
+      }
+    }
+    if (firedIds.size > 0) {
+      await recordPreventionHits2(paths, [...firedIds], "sensor").catch(() => {
+      });
+    }
     return findings;
   } catch {
     return [];
   }
 }
+async function runGateCommandSensor(spec, root) {
+  try {
+    await execFileAsync2("bash", ["-c", spec.command], { cwd: root, timeout: 12e4, maxBuffer: 8 * 1024 * 1024 });
+    return false;
+  } catch {
+    return true;
+  }
+}
 async function findGeneratedArtifacts(paths) {
   const dirty = await runCommand4("git", ["status", "--short", "--untracked-files=all"], paths.root).catch(() => "");
   const generated = dirty.split("\n").map((line) => line.trim()).filter(Boolean).filter(
@@ -17114,28 +17255,25 @@ function registerRun(program2) {
 }
 
 // src/commands/sensors.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { existsSync as existsSync76 } from "fs";
 import { chmod as chmod3, mkdir as mkdir23, readFile as readFile25, writeFile as writeFile38 } from "fs/promises";
 import path54 from "path";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify4 } from "util";
 import "commander";
 import {
-  appendPreventionEvent as appendPreventionEvent2,
   findProjectRoot as findProjectRoot53,
   isRetiredMemory as isRetiredMemory4,
   loadConfig as loadConfig15,
   loadMemoriesFromDir as loadMemoriesFromDir39,
-  loadUsageIndex as loadUsageIndex31,
-  recordPrevention as recordPrevention2,
+  recordPreventionHits as recordPreventionHits3,
   resolveHaivePaths as resolveHaivePaths49,
   runSensors as runSensors3,
-  saveUsageIndex as saveUsageIndex8,
-  selectCommandSensors,
+  selectCommandSensors as selectCommandSensors2,
   sensorTargetsFromDiff as sensorTargetsFromDiff3,
   serializeMemory as serializeMemory29
 } from "@hiveai/core";
-var exec2 = promisify3(execFile3);
+var exec2 = promisify4(execFile4);
 function registerSensors(program2) {
   const sensors = program2.command("sensors").description("Operate executable sensors derived from hAIve memories");
   sensors.command("list").description("List memories carrying executable sensors").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
@@ -17172,7 +17310,7 @@ function registerSensors(program2) {
     const runCommands = opts.commands || config.enforcement?.runCommandSensors === true;
     const changedPaths = targets.map((t) => t.path).filter(Boolean);
     const allSensorMemories = await runnableSensorMemories(paths, false);
-    const commandSpecs = selectCommandSensors(allSensorMemories, changedPaths);
+    const commandSpecs = selectCommandSensors2(allSensorMemories, changedPaths);
     const commandHits = [];
     const commandSkipped = [];
     if (commandSpecs.length > 0 && runCommands) {
@@ -17191,20 +17329,7 @@ function registerSensors(program2) {
       for (const spec of commandSpecs) commandSkipped.push(spec.memory_id);
     }
     const firedIds = [...new Set([...hits, ...commandHits].map((hit) => hit.memory_id))];
-    if (firedIds.length > 0) {
-      const usage = await loadUsageIndex31(paths);
-      const recordedIds = [];
-      for (const id of firedIds) if (recordPrevention2(usage, id)) recordedIds.push(id);
-      if (recordedIds.length > 0) {
-        await saveUsageIndex8(paths, usage).catch(() => {
-        });
-        const at = (/* @__PURE__ */ new Date()).toISOString();
-        for (const id of recordedIds) {
-          await appendPreventionEvent2(paths, { at, id, source: "sensor" }).catch(() => {
-          });
-        }
-      }
-    }
+    await recordPreventionHits3(paths, firedIds, "sensor");
     const output = {
       scanned: memories.length,
       hits: hits.map((hit) => ({
@@ -17571,7 +17696,7 @@ import {
   loadConfig as loadConfig16,
   loadMemoriesFromDir as loadMemoriesFromDir41,
   loadPreventionEvents as loadPreventionEvents4,
-  loadUsageIndex as loadUsageIndex33,
+  loadUsageIndex as loadUsageIndex31,
   resolveHaivePaths as resolveHaivePaths51
 } from "@hiveai/core";
 function registerDashboard(program2) {
@@ -17586,7 +17711,7 @@ function registerDashboard(program2) {
       return;
     }
     const memories = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
-    const usage = await loadUsageIndex33(paths);
+    const usage = await loadUsageIndex31(paths);
     const preventionEvents = await loadPreventionEvents4(paths);
     const config = await loadConfig16(paths);
     const top = Math.max(1, Number.parseInt(opts.top ?? "10", 10) || 10);
@@ -17697,14 +17822,14 @@ function warnNum(n) {
 }
 
 // src/commands/dev-link.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { cp, readFile as readFile27 } from "fs/promises";
 import { existsSync as existsSync79 } from "fs";
 import path56 from "path";
-import { promisify as promisify4 } from "util";
+import { promisify as promisify5 } from "util";
 import "commander";
 import { findProjectRoot as findProjectRoot56 } from "@hiveai/core";
-var exec3 = promisify4(execFile4);
+var exec3 = promisify5(execFile5);
 function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on hAIve itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hiveai install so `haive` 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) => {
@@ -17760,8 +17885,41 @@ function registerDevLink(program2) {
 }
 
 // src/commands/coverage.ts
+import { readFile as readFile28 } from "fs/promises";
+import { existsSync as existsSync80 } from "fs";
+import path57 from "path";
 import "commander";
-import { findCoverageGaps, findProjectRoot as findProjectRoot57, resolveHaivePaths as resolveHaivePaths52 } from "@hiveai/core";
+import {
+  findCoverageGaps,
+  findProjectRoot as findProjectRoot57,
+  mergeHotFiles,
+  resolveHaivePaths as resolveHaivePaths52,
+  tallyHotFiles
+} from "@hiveai/core";
+async function readAgentHotFiles(root, cacheFile, sinceMs) {
+  if (!existsSync80(cacheFile)) return [];
+  const raw = await readFile28(cacheFile, "utf8").catch(() => "");
+  const files = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obs = JSON.parse(trimmed);
+      if (sinceMs > 0 && obs.ts) {
+        const t = Date.parse(obs.ts);
+        if (Number.isFinite(t) && t < sinceMs) continue;
+      }
+      for (const f of obs.files ?? []) {
+        if (typeof f !== "string" || !f) continue;
+        const rel = path57.isAbsolute(f) ? path57.relative(root, f) : f;
+        if (rel.startsWith("..")) continue;
+        files.push(rel);
+      }
+    } catch {
+    }
+  }
+  return tallyHotFiles(files, "agent");
+}
 function isNoisePath(p) {
   if (/(^|\/)(node_modules|dist|build|coverage|\.next)\//.test(p)) return true;
   if (p.startsWith(".ai/")) return true;
@@ -17773,29 +17931,47 @@ function isNoisePath(p) {
 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 git-churn count to flag a file", "3").option("--limit <n>", "max gaps to report", "20").option("--days <n>", "git-history lookback window in days", "90").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).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 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);
     const days = Math.max(1, parseInt(opts.days ?? "90", 10) || 90);
-    const radar = await buildRadar({
+    const source = (opts.source ?? "both").toLowerCase();
+    if (!["git", "agent", "both"].includes(source)) {
+      ui.error("--source must be one of: git | agent | both");
+      process.exitCode = 1;
+      return;
+    }
+    const useGit = source === "git" || source === "both";
+    const useAgent = source === "agent" || source === "both";
+    const radar = useGit ? await buildRadar({
       root,
       taskTokens: null,
       filePaths: [],
       daysBack: Math.ceil(days / 6),
       // getHotFiles multiplies daysBack by 6
       maxHotFiles: 500
-    });
-    const hotFiles = radar.hotFiles.filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes }));
+    }) : 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, path57.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    const hotFiles = mergeHotFiles(gitHotFiles, agentHotFiles);
     const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
     if (opts.json) {
-      console.log(JSON.stringify({ root, scanned_hot_files: hotFiles.length, gaps }, null, 2));
+      console.log(JSON.stringify({
+        root,
+        source,
+        scanned_hot_files: hotFiles.length,
+        git_hot_files: gitHotFiles.length,
+        agent_hot_files: agentHotFiles.length,
+        gaps
+      }, null, 2));
       return;
     }
-    if (!radar.insideGitRepo) {
-      ui.warn("Not a git repository \u2014 coverage uses git churn to find hot files.");
+    if (useGit && radar && !radar.insideGitRepo && agentHotFiles.length === 0) {
+      ui.warn("Not a git repository and no agent-edit history \u2014 nothing to cross-check.");
       return;
     }
     if (gaps.length === 0) {
@@ -17804,7 +17980,8 @@ function registerCoverage(program2) {
     }
     console.log(ui.bold(`hAIve coverage \u2014 ${gaps.length} blind spot(s) (hot files with no covering memory)`));
     for (const gap of gaps) {
-      console.log(`  ${ui.yellow("\u25CB")} ${gap.path} ${ui.dim(`(${gap.changes} change${gap.changes === 1 ? "" : "s"})`)}`);
+      const src = gap.source ? ui.dim(` [${gap.source}]`) : "";
+      console.log(`  ${ui.yellow("\u25CB")} ${gap.path} ${ui.dim(`(${gap.changes} change${gap.changes === 1 ? "" : "s"})`)}${src}`);
     }
     console.log(
       ui.dim(
@@ -17816,8 +17993,8 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync80 } from "fs";
-import path57 from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync81 } from "fs";
+import path58 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hiveai/core";
 var GITATTRIBUTES_MARK = "# hAIve merge driver";
@@ -17849,8 +18026,8 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path57.join(root, ".gitattributes");
-    let content = existsSync80(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    const gaPath = path58.join(root, ".gitattributes");
+    let content = existsSync81(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -17865,11 +18042,12 @@ function registerMergeDriver(program2) {
 
 // src/commands/memory-resolve-conflict.ts
 import { writeFile as writeFile40 } from "fs/promises";
-import { existsSync as existsSync81 } from "fs";
+import { existsSync as existsSync83 } from "fs";
 import "commander";
 import {
+  applyConflictResolution,
   findProjectRoot as findProjectRoot59,
-  planConflictResolution,
+  planConflictResolution as planConflictResolution2,
   resolveHaivePaths as resolveHaivePaths53,
   serializeMemory as serializeMemory31
 } from "@hiveai/core";
@@ -17877,7 +18055,7 @@ 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 paths = resolveHaivePaths53(root);
-    if (!existsSync81(paths.memoriesDir)) {
+    if (!existsSync83(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -17890,43 +18068,53 @@ function registerMemoryResolveConflict(memory2) {
       process.exitCode = 1;
       return;
     }
-    const plan = planConflictResolution(a, b);
+    const plan = planConflictResolution2(a, b);
+    const winner = plan.keep_id === idA ? a : b;
     const loser = plan.supersede_id === idA ? a : b;
+    const applied = applyConflictResolution(winner, loser, plan);
     if (opts.json) {
-      console.log(JSON.stringify({ ...plan, applied: Boolean(opts.yes) }, null, 2));
+      console.log(JSON.stringify({
+        ...plan,
+        winner_revision_count: applied.winner.revision_count,
+        topic: applied.topic,
+        topic_adopted: applied.topic_adopted,
+        applied: Boolean(opts.yes)
+      }, null, 2));
     } else {
       console.log(ui.bold("Conflict resolution"));
-      console.log(`  keep:      ${ui.green(plan.keep_id)}`);
+      console.log(`  keep:      ${ui.green(plan.keep_id)} ${ui.dim(`(rev ${winner.memory.frontmatter.revision_count}\u2192${applied.winner.revision_count})`)}`);
       console.log(`  supersede: ${ui.red(plan.supersede_id)} ${ui.dim(`\u2192 deprecated`)}`);
       console.log(`  reason:    ${plan.reason}`);
+      if (applied.topic) {
+        console.log(`  topic:     ${applied.topic}${applied.topic_adopted ? ui.dim(" (adopted from superseded \u2014 future captures upsert into the winner)") : ""}`);
+      }
     }
     if (!opts.yes) {
       if (!opts.json) ui.info("Preview only \u2014 re-run with --yes to apply.");
       return;
     }
+    await writeFile40(
+      winner.filePath,
+      serializeMemory31({ frontmatter: applied.winner, body: winner.memory.body }),
+      "utf8"
+    );
     await writeFile40(
       loser.filePath,
-      serializeMemory31({
-        frontmatter: {
-          ...loser.memory.frontmatter,
-          status: "deprecated",
-          stale_reason: plan.stale_reason,
-          related_ids: [.../* @__PURE__ */ new Set([...loser.memory.frontmatter.related_ids, plan.keep_id])]
-        },
-        body: loser.memory.body
-      }),
+      serializeMemory31({ frontmatter: applied.loser, body: loser.memory.body }),
       "utf8"
     );
-    if (!opts.json) ui.success(`Deprecated ${plan.supersede_id}; ${plan.keep_id} remains authoritative.`);
+    if (!opts.json) {
+      ui.success(`Deprecated ${plan.supersede_id}; promoted ${plan.keep_id} (rev ${applied.winner.revision_count}${applied.topic ? `, topic=${applied.topic}` : ""}).`);
+    }
   });
 }
 
 // src/commands/memory-seed-git.ts
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { mkdir as mkdir25, writeFile as writeFile41 } from "fs/promises";
-import { existsSync as existsSync83 } from "fs";
-import path58 from "path";
-import { promisify as promisify5 } from "util";
+import { existsSync as existsSync84 } from "fs";
+import path59 from "path";
+import { promisify as promisify6 } from "util";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter12,
@@ -17936,12 +18124,12 @@ import {
   resolveHaivePaths as resolveHaivePaths54,
   serializeMemory as serializeMemory33
 } from "@hiveai/core";
-var exec4 = promisify5(execFile5);
+var exec4 = promisify6(execFile6);
 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 paths = resolveHaivePaths54(root);
-    if (!existsSync83(paths.haiveDir)) {
+    if (!existsSync84(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -17986,8 +18174,8 @@ 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 (existsSync83(file)) continue;
-      await mkdir25(path58.dirname(file), { recursive: true });
+      if (existsSync84(file)) continue;
+      await mkdir25(path59.dirname(file), { recursive: true });
       await writeFile41(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
       written += 1;
     }
@@ -18019,8 +18207,8 @@ async function readCommits(root, days) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync84 } from "fs";
-import path59 from "path";
+import { existsSync as existsSync85 } from "fs";
+import path60 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot61,
@@ -18041,7 +18229,7 @@ function registerBridges(program2) {
     const root = findProjectRoot61(opts.dir);
     const paths = resolveHaivePaths55(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync84(paths.memoriesDir)) {
+    if (!existsSync85(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -18060,7 +18248,7 @@ function registerBridges(program2) {
       targets = BRIDGE_TARGETS3;
     } else {
       targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync84(path59.join(root, BRIDGE_TARGET_PATH3[t]))
+        (t) => existsSync85(path60.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -18089,7 +18277,7 @@ function registerBridges(program2) {
     console.log(ui.bold("hAIve bridge targets:"));
     for (const target of BRIDGE_TARGETS3) {
       const relPath = BRIDGE_TARGET_PATH3[target];
-      const exists = existsSync84(path59.join(root, relPath));
+      const exists = existsSync85(path60.join(root, relPath));
       const marker = exists ? ui.dim("\u2713") : ui.dim("\xB7");
       console.log(`  ${marker} ${target.padEnd(10)} ${relPath}${exists ? "" : "  (not present)"}`);
     }
@@ -18100,7 +18288,7 @@ function registerBridges(program2) {
 
 // src/index.ts
 var program = new Command64();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.20.1").option("--advanced", "show maintenance and experimental commands in help");
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.23.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);