@hiveai/cli 0.13.9 → 0.15.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command58 } from "commander";
+import { Command as Command63 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -199,7 +199,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path55, changes]) => ({ path: path55, changes }));
+    let entries = [...counts.entries()].map(([path58, changes]) => ({ path: path58, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -3019,7 +3019,7 @@ ${SEED_FOOTER(stack)}` });
 }
 
 // src/commands/init.ts
-var HAIVE_GITHUB_ACTION_REF = `v${"0.13.9"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.15.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -3202,7 +3202,11 @@ jobs:
         run: npm install -g @hiveai/cli
 
       - name: harness quality regression gate
-        run: haive eval --regression-gate
+        run: haive eval --regression-gate --record --ref "\${{ github.sha }}"
+
+      - name: harness quality trend
+        if: always()
+        run: haive eval --trend || true
 
   # On push to main: push shared memories to the hub (if hubPath is configured)
   # Uncomment and configure hubPath in .ai/haive.config.json to enable.
@@ -4089,10 +4093,13 @@ import {
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig3,
+  hashProjectContext,
   loadMemoriesFromDir as loadMemoriesFromDir15,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths22,
+  projectContextRecentlyEmitted,
   rankMemoriesLexical as rankMemoriesLexical2,
+  recordProjectContextEmission,
   queryCodeMap as queryCodeMap2,
   resolveBriefingBudget as resolveBriefingBudget2,
   serializeMemory as serializeMemory10,
@@ -5711,6 +5718,9 @@ var GetBriefingInputSchema = {
   ),
   max_memories: z19.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
   include_project_context: z19.boolean().default(true),
+  dedupe_project_context: z19.boolean().optional().describe(
+    "Token saver (default ON): skip re-emitting the project-context body if an identical copy was already sent within the last few minutes this session (the agent still has it). Set false to always include it."
+  ),
   include_module_contexts: z19.boolean().default(true),
   semantic: z19.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
@@ -5918,7 +5928,17 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile52(ctx.paths.projectContext, "utf8") : "";
+  let projectContextRaw = input.include_project_context && existsSync21(ctx.paths.projectContext) ? await readFile52(ctx.paths.projectContext, "utf8") : "";
+  let contextOmittedRecent = false;
+  if (projectContextRaw && input.dedupe_project_context !== false) {
+    const ctxHash = hashProjectContext(projectContextRaw);
+    if (await projectContextRecentlyEmitted(ctx.paths, ctxHash)) {
+      contextOmittedRecent = true;
+      projectContextRaw = "";
+    } else {
+      await recordProjectContextEmission(ctx.paths, ctxHash);
+    }
+  }
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
   const setupWarnings = [];
   let autoContextGenerated = false;
@@ -6186,7 +6206,11 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     search_mode: searchMode,
     inferred_modules: inferred,
     ...lastSession ? { last_session: lastSession } : {},
-    project_context: adaptiveTrim ? {
+    project_context: contextOmittedRecent ? {
+      content: "(project context unchanged \u2014 omitted to save tokens; it was provided earlier this session. Pass dedupe_project_context:false to force a full copy.)",
+      truncated: false,
+      omitted_recent: true
+    } : adaptiveTrim ? {
       content: "(adaptive briefing: auto-generated context omitted \u2014 no team-specific policy matched, so a capable model needs nothing extra here)",
       truncated: false,
       ...isTemplateContext && !autoContextGenerated ? { is_template: true } : {},
@@ -7504,7 +7528,7 @@ async function patternDetect(input, ctx) {
   for (const [p, { count, tools }] of pathCounts) {
     if (count < HOT_FILE_MIN) continue;
     if (tools.has("mem_tried") || tools.has("mem_observe")) continue;
-    if (CONFIG_PATTERNS.some((cp) => path122.basename(p).includes(cp))) continue;
+    if (CONFIG_PATTERNS.some((cp2) => path122.basename(p).includes(cp2))) continue;
     const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
     matches.push({
       kind: "hot_file",
@@ -7938,7 +7962,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.13.9";
+var SERVER_VERSION = "0.15.0";
 function jsonResult(data) {
   return {
     content: [
@@ -8687,6 +8711,7 @@ function createHaiveServer(options = {}) {
     "anti_patterns_check",
     [
       "Scan a diff (or set of paths) against documented attempt/gotcha memories.",
+      "[Diff-scan layer: the MEMORY-MATCH component. `pre_commit_check` combines this with sensors + stale checks; `haive enforce check` is the gate.]",
       "Surfaces 'you are about to repeat a known mistake' warnings BEFORE you commit.",
       "",
       "USE BEFORE finalizing a non-trivial change. Cheap and high-signal: the only",
@@ -8830,6 +8855,7 @@ function createHaiveServer(options = {}) {
     "pre_commit_check",
     [
       "One-shot 'should I block this commit?' check. Combines three signals:",
+      "[Diff-scan layer: the COMBINED check (sensors + anti-patterns + stale). `haive enforce check` is the gate that runs this at commit time.]",
       "",
       "  1. anti_patterns_check \u2014 known gotchas/attempts that match the diff",
       "  2. mem_for_files       \u2014 conventions/decisions anchored to touched files",
@@ -12687,9 +12713,12 @@ import "commander";
 import {
   aggregateRetrieval,
   aggregateSensors,
+  appendEvalHistory,
   buildReport,
   compareEvalReports,
+  computeEvalTrend,
   findProjectRoot as findProjectRoot42,
+  loadEvalHistory,
   resolveHaivePaths as resolveHaivePaths38,
   scoreRetrievalCase,
   scoreSensorCase,
@@ -12698,7 +12727,7 @@ import {
 function registerEval(program2) {
   program2.command("eval").description(
     "Rigorous, repeatable quality eval: do the right memories surface (retrieval) and do the right sensors fire (catch-rate)? Emits a numeric 0\u2013100 score. Uses .ai/eval cases via --spec, or auto-synthesizes cases from anchored memories."
-  ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("--baseline", "save this run as the baseline (.ai/eval/baseline.json) for future --compare", false).option("--compare", "diff this run against the saved baseline and print the delta", false).option("--baseline-file <path>", "baseline file to read/write (default: .ai/eval/baseline.json)").option("--fail-on-regression", "with --compare, exit non-zero if the score dropped vs the baseline", false).option("--regression-gate", "CI-safe gate: compare against the baseline IF one exists (fail on regression), else no-op", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("--baseline", "save this run as the baseline (.ai/eval/baseline.json) for future --compare", false).option("--compare", "diff this run against the saved baseline and print the delta", false).option("--baseline-file <path>", "baseline file to read/write (default: .ai/eval/baseline.json)").option("--fail-on-regression", "with --compare, exit non-zero if the score dropped vs the baseline", false).option("--regression-gate", "CI-safe gate: compare against the baseline IF one exists (fail on regression), else no-op", false).option("--record", "append this run's score to .ai/.cache/eval-history.jsonl (trend the harness over time)", false).option("--trend", "print the recorded score trend (sparkline + latest/best/delta) and exit", false).option("--ref <ref>", "version/commit label stored with a --record run").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot42(opts.dir);
     const paths = resolveHaivePaths38(root);
     if (!existsSync65(paths.memoriesDir)) {
@@ -12706,6 +12735,22 @@ function registerEval(program2) {
       process.exitCode = 1;
       return;
     }
+    if (opts.trend) {
+      const trend = computeEvalTrend(await loadEvalHistory(paths));
+      if (opts.json) {
+        console.log(JSON.stringify(trend, null, 2));
+        return;
+      }
+      if (trend.runs === 0) {
+        ui.info("No eval history yet. Run `haive eval --record` to start trending the harness.");
+        return;
+      }
+      const spark = trend.recent.map((s) => "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"[Math.min(7, Math.round(s / 100 * 7))]).join("");
+      const arrow = trend.regressed ? ui.red("\u25BC") : (trend.delta ?? 0) > 0 ? ui.green("\u25B2") : ui.dim("=");
+      console.log(ui.bold("hAIve eval trend"));
+      console.log(`  ${spark}  latest ${arrow} ${trend.latest}/100  ${ui.dim(`(best ${trend.best}, ${trend.runs} run${trend.runs === 1 ? "" : "s"})`)}`);
+      return;
+    }
     const k = Math.max(1, parseInt(opts.top ?? "8", 10) || 8);
     const ctx = { paths };
     const resolvedSpec = await resolveSpec(opts, root, paths.memoriesDir);
@@ -12733,6 +12778,17 @@ function registerEval(program2) {
       sensorAgg = aggregateSensors(results);
     }
     const report = buildReport(retrievalAgg, sensorAgg);
+    if (opts.record) {
+      await appendEvalHistory(paths, {
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        score: report.score,
+        ...report.retrieval ? { mean_recall: report.retrieval.mean_recall, mrr: report.retrieval.mrr } : {},
+        ...report.sensors ? { catch_rate: report.sensors.catch_rate } : {},
+        ...opts.ref ? { ref: opts.ref } : {}
+      }).catch(() => {
+      });
+      if (!opts.json) ui.success(`Recorded eval score ${report.score}/100 to history.`);
+    }
     const baselineFile = opts.baselineFile ? path43.isAbsolute(opts.baselineFile) ? opts.baselineFile : path43.join(root, opts.baselineFile) : path43.join(root, ".ai", "eval", "baseline.json");
     if (opts.baseline) {
       const snapshot = {
@@ -13308,8 +13364,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile26 } = await import("fs/promises");
-      const content = await readFile26(paths.projectContext, "utf8");
+      const { readFile: readFile27 } = await import("fs/promises");
+      const content = await readFile27(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -13483,8 +13539,8 @@ function registerDoctor(program2) {
       let hasClaudeEnforcement = false;
       if (existsSync68(claudeSettings)) {
         try {
-          const { readFile: readFile26 } = await import("fs/promises");
-          const raw = await readFile26(claudeSettings, "utf8");
+          const { readFile: readFile27 } = await import("fs/promises");
+          const raw = await readFile27(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -13507,7 +13563,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.13.9"));
+    findings.push(...await collectInstallFindings(root, "0.15.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -13515,7 +13571,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.13.9";
+      const cliVersion = "0.15.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -14577,6 +14633,7 @@ import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
   findProjectRoot as findProjectRoot52,
+  findUncapturedFailures,
   hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig13,
@@ -14748,52 +14805,73 @@ ${briefing.project_context.content.slice(0, 1800)}`);
 [setup warning] ${warning}`);
     }
   });
-  enforce.command("pre-tool-use").description("Claude Code PreToolUse hook: block writes until hAIve briefing has been loaded.").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  enforce.command("pre-tool-use").description("Claude Code PreToolUse hook: surface the relevant team policy for the edited file (advise; configurable to block).").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths48(root);
     if (!existsSync75(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
-    const ok = await hasRecentBriefingMarker2(paths, payload.session_id);
-    if (ok) {
-      const targetFiles = extractToolPaths(payload, root);
-      if (targetFiles.length === 0) return;
-      const missing = await missingRequiredMemoriesForFiles(paths, targetFiles, payload.session_id);
-      if (missing.length === 0) return;
-      const ids = missing.slice(0, 6).map((memory2) => memory2.memory.frontmatter.id);
+    const config = await loadConfig13(paths);
+    if (config.enforcement?.requireBriefingFirst === false) return;
+    const gate = config.enforcement?.preEditGate ?? "advise";
+    const targetFiles = extractToolPaths(payload, root);
+    const hasMarker = await hasRecentBriefingMarker2(paths, payload.session_id);
+    const missing = targetFiles.length > 0 ? await missingRequiredMemoriesForFiles(paths, targetFiles, payload.session_id) : [];
+    if (hasMarker && missing.length === 0) return;
+    if (targetFiles.length > 0) {
+      await recordFilesIntoBriefingMarker(paths, targetFiles, missing, payload.session_id).catch(() => {
+      });
+    }
+    const contextText = buildPreEditContext(payload.tool_name ?? "write tool", targetFiles, missing, hasMarker);
+    if (gate === "block") {
       console.error(
-        [
-          "hAIve enforcement blocked this action.",
-          `Tool: ${payload.tool_name ?? "write tool"}`,
-          `Files: ${targetFiles.slice(0, 6).join(", ")}`,
-          "",
-          "These files have required hAIve context that was not in the current briefing:",
-          ...ids.map((id) => `  - ${id}`),
-          "",
-          "Load the targeted briefing before editing:",
-          `  ${briefingCommandForFiles(targetFiles)}`
-        ].join("\n")
+        contextText + '\n\nThe relevant context is now recorded \u2014 re-issue the same edit to proceed (no `haive briefing` command needed). To make this advisory instead of blocking, set `{ "enforcement": { "preEditGate": "advise" } }` in .ai/haive.config.json.'
       );
       process.exit(2);
     }
-    const tool = payload.tool_name ?? "write tool";
-    console.error(
-      [
-        "hAIve enforcement blocked this action.",
-        `Tool: ${tool}`,
-        "",
-        "This project is initialized with hAIve. Load the team briefing before editing:",
-        "  haive enforce session-start",
-        "or call MCP get_briefing / mem_relevant_to from your AI client.",
-        "",
-        "If this is intentional, a human can disable enforcement in .ai/haive.config.json:",
-        '  { "enforcement": { "requireBriefingFirst": false } }'
-      ].join("\n")
-    );
-    process.exit(2);
+    emitPreToolUseContext(contextText);
   });
 }
+async function recordFilesIntoBriefingMarker(paths, files, missing, sessionId) {
+  const existing = await readRecentBriefingMarker(paths, sessionId);
+  const ids = new Set(existing?.memory_ids ?? []);
+  for (const { memory: memory2 } of missing) ids.add(memory2.frontmatter.id);
+  await writeBriefingMarker3(paths, {
+    sessionId,
+    task: existing?.task ?? "pre-edit auto-briefing",
+    source: "haive-pre-edit",
+    files,
+    memoryIds: [...ids]
+  });
+}
+function buildPreEditContext(tool, files, missing, hasMarker) {
+  const lines = ["hAIve \u2014 relevant team policy for this edit", `Tool: ${tool}`];
+  if (files.length > 0) lines.push(`Files: ${files.slice(0, 6).join(", ")}`);
+  if (missing.length > 0) {
+    lines.push("", "Consult these before editing (anchored to the files you are touching):");
+    for (const { memory: memory2 } of missing.slice(0, 5)) {
+      const fm = memory2.frontmatter;
+      lines.push("", `### ${fm.id}  (${fm.scope}/${fm.type})`, memory2.body.trim().slice(0, 900));
+    }
+  } else if (!hasMarker) {
+    lines.push(
+      "",
+      "No team briefing was loaded yet this session. Proceeding \u2014 but for substantive work call get_briefing / mem_relevant_to for richer context."
+    );
+  }
+  return lines.join("\n");
+}
+function emitPreToolUseContext(text) {
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext: text
+      }
+    })
+  );
+}
 async function buildFinishReport(dir) {
   const root = findProjectRoot52(dir);
   const paths = resolveHaivePaths48(root);
@@ -14817,6 +14895,7 @@ async function buildFinishReport(dir) {
       }]
     });
   }
+  findings.push(...await checkFailureCapture(paths, config));
   const status = await getGitSyncStatus(root);
   if (!status.available) {
     findings.push({
@@ -14980,6 +15059,47 @@ async function buildFinishReport(dir) {
   findings.push(...await verifyGithubActionsForHead(root, status));
   return finishReport(root, initialized, mode, findings, config);
 }
+async function checkFailureCapture(paths, config) {
+  const gate = config.enforcement?.failureCaptureGate ?? "warn";
+  if (gate === "off") return [];
+  const obsFile = path51.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync75(obsFile)) return [];
+  const failures = [];
+  try {
+    const raw = await readFile23(obsFile, "utf8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const o = JSON.parse(trimmed);
+        if (o.failure_hint && o.ts) failures.push({ ts: o.ts, tool: o.tool ?? "?", summary: o.summary ?? "" });
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  if (failures.length === 0) return [];
+  const memories = existsSync75(paths.memoriesDir) ? await loadMemoriesFromDir38(paths.memoriesDir) : [];
+  const captureTimes = memories.filter(({ memory: memory2 }) => ["attempt", "gotcha"].includes(memory2.frontmatter.type)).map(({ memory: memory2 }) => memory2.frontmatter.created_at);
+  const uncaptured = findUncapturedFailures(failures, captureTimes);
+  if (uncaptured.length === 0) {
+    return [{
+      severity: "ok",
+      code: "failure-capture-clean",
+      message: "No uncaptured hard failures from this session."
+    }];
+  }
+  return [{
+    severity: gate === "block" ? "error" : "info",
+    code: "uncaptured-failures",
+    message: `${uncaptured.length} hard failure(s) this session were never captured as a lesson (mem_tried).`,
+    fix: "Call `mem_tried` (or `haive memory tried`) for each real failure so the next session doesn't repeat it. False positives (e.g. a grep that found nothing) can be ignored.",
+    reason: "Harness ratchet: a mistake that isn't written down gets re-introduced. Set enforcement.failureCaptureGate to 'off' to disable, or 'block' to hard-fail.",
+    affected_files: uncaptured.slice(0, 8).map((f) => `${f.tool}: ${f.summary}`.slice(0, 100)),
+    ...gate === "block" ? { impact: 30 } : {}
+  }];
+}
 function finishReport(root, initialized, mode, findings, config) {
   const score = buildScore(findings, config.enforcement?.scoreThreshold);
   const hasErrors = findings.some((f) => f.severity === "error");
@@ -15124,7 +15244,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.13.9"));
+  findings.push(...await inspectIntegrationVersions(root, "0.15.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." } : {
@@ -15242,7 +15362,7 @@ async function verifyMemoryPolicy(paths, config) {
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
   if (!existsSync75(paths.memoriesDir)) return [];
-  const changedFiles = await getChangedFiles(paths.root, stage);
+  const changedFiles = (await getChangedFiles(paths.root, stage)).filter((f) => !isGeneratedArtifact(f));
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
   }
@@ -16039,8 +16159,10 @@ async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
     return memoryMatchesAnchorPaths6(memory2, files);
   }).map(({ memory: memory2, filePath }) => ({ memory: memory2, filePath }));
 }
-function briefingCommandForFiles(files) {
-  return `haive briefing --files "${files.slice(0, 10).join(",")}" --task "edit ${files.slice(0, 3).join(", ")}"`;
+function isGeneratedArtifact(file) {
+  if (file === ".ai/project-context.md" || file === ".ai/code-map.json") return true;
+  if (file.startsWith(".ai/.cache/") || file.startsWith(".ai/.runtime/") || file.startsWith(".ai/.usage/")) return true;
+  return false;
 }
 async function readStdin2(maxBytes) {
   if (process.stdin.isTTY) return "";
@@ -16118,12 +16240,14 @@ import {
   appendPreventionEvent as appendPreventionEvent2,
   findProjectRoot as findProjectRoot53,
   isRetiredMemory as isRetiredMemory3,
+  loadConfig as loadConfig14,
   loadMemoriesFromDir as loadMemoriesFromDir39,
   loadUsageIndex as loadUsageIndex29,
   recordPrevention as recordPrevention2,
   resolveHaivePaths as resolveHaivePaths49,
   runSensors as runSensors2,
   saveUsageIndex as saveUsageIndex8,
+  selectCommandSensors,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
   serializeMemory as serializeMemory27
 } from "@hiveai/core";
@@ -16151,14 +16275,38 @@ function registerSensors(program2) {
       if (row.last_fired) console.log(`     ${ui.dim("last fired:")} ${row.last_fired}`);
     }
   });
-  sensors.command("check").description("Run regex sensors against a diff; defaults to `git diff --cached`").option("--diff-file <path>", "read unified diff from a file instead of staged changes").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+  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; `haive 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 paths = resolveHaivePaths49(root);
     const memories = await runnableSensorMemories(paths);
     const diff = opts.diffFile ? await readFile24(path53.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = sensorTargetsFromDiff2(diff);
     const hits = runSensors2(memories, targets.length > 0 ? targets : [{ path: "", content: diff }]);
-    const firedIds = [...new Set(hits.map((hit) => hit.memory_id))];
+    const config = await loadConfig14(paths);
+    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 commandHits = [];
+    const commandSkipped = [];
+    if (commandSpecs.length > 0 && runCommands) {
+      for (const spec of commandSpecs) {
+        const failed = await runCommandSensor(spec, root);
+        if (failed) {
+          commandHits.push({
+            memory_id: spec.memory_id,
+            severity: spec.severity,
+            message: spec.message,
+            matched_line: `command failed: ${spec.command}`
+          });
+        }
+      }
+    } else if (commandSpecs.length > 0) {
+      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 loadUsageIndex29(paths);
       const recordedIds = [];
@@ -16181,12 +16329,15 @@ function registerSensors(program2) {
         severity: hit.severity,
         message: hit.message,
         matched_line: hit.matched_line
-      }))
+      })),
+      command_hits: commandHits,
+      command_skipped: commandSkipped
     };
     if (opts.json) {
       console.log(JSON.stringify(output, null, 2));
     } else {
-      console.log(ui.bold(`hAIve sensors check \u2014 ${hits.length} hit(s), ${memories.length} sensor(s)`));
+      const total = hits.length + commandHits.length;
+      console.log(ui.bold(`hAIve sensors check \u2014 ${total} hit(s), ${memories.length} regex + ${commandSpecs.length} command sensor(s)`));
       for (const hit of hits) {
         const marker = hit.severity === "block" ? ui.red("\u2717") : ui.yellow("\u26A0");
         console.log(`  ${marker} ${hit.memory_id} ${ui.dim(`(${hit.severity})`)}`);
@@ -16194,8 +16345,17 @@ function registerSensors(program2) {
         console.log(`     ${hit.message}`);
         if (hit.matched_line) console.log(`     ${ui.dim(hit.matched_line)}`);
       }
+      for (const hit of commandHits) {
+        const marker = hit.severity === "block" ? ui.red("\u2717") : ui.yellow("\u26A0");
+        console.log(`  ${marker} ${hit.memory_id} ${ui.dim(`(${hit.severity}, command)`)}`);
+        console.log(`     ${hit.message}`);
+        console.log(`     ${ui.dim(hit.matched_line)}`);
+      }
+      if (commandSkipped.length > 0) {
+        console.log(ui.dim(`  ${commandSkipped.length} command sensor(s) not run \u2014 pass --commands or set enforcement.runCommandSensors.`));
+      }
     }
-    if (hits.some((hit) => hit.severity === "block")) process.exitCode = 1;
+    if ([...hits, ...commandHits].some((hit) => hit.severity === "block")) process.exitCode = 1;
   });
   sensors.command("promote").description("Promote or demote an existing memory sensor severity").argument("<memory-id>", "memory id carrying the sensor").option("--severity <severity>", "block | warn", "block").option("--yes", "confirm promotion to block severity", false).option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const severity = opts.severity ?? "block";
@@ -16282,6 +16442,14 @@ async function runnableSensorMemories(paths, regexOnly = true) {
     return !isRetiredMemory3(memory2.frontmatter, memory2.body);
   });
 }
+async function runCommandSensor(spec, root) {
+  try {
+    await exec2("bash", ["-c", spec.command], { cwd: root, timeout: 12e4, maxBuffer: 8 * 1024 * 1024 });
+    return false;
+  } catch {
+    return true;
+  }
+}
 async function stagedDiff(root) {
   try {
     const { stdout } = await exec2("git", ["diff", "--cached"], { cwd: root });
@@ -16515,6 +16683,7 @@ import "commander";
 import {
   buildDashboard,
   findProjectRoot as findProjectRoot55,
+  loadConfig as loadConfig15,
   loadMemoriesFromDir as loadMemoriesFromDir41,
   loadPreventionEvents,
   loadUsageIndex as loadUsageIndex30,
@@ -16534,11 +16703,13 @@ function registerDashboard(program2) {
     const memories = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
     const usage = await loadUsageIndex30(paths);
     const preventionEvents = await loadPreventionEvents(paths);
+    const config = await loadConfig15(paths);
     const top = Math.max(1, Number.parseInt(opts.top ?? "10", 10) || 10);
     const dormantDays = opts.dormantDays ? Number.parseInt(opts.dormantDays, 10) : void 0;
     const report = buildDashboard(memories, usage, {
       top,
       preventionEvents,
+      antiPatternGate: config.enforcement?.antiPatternGate ?? "anchored",
       ...dormantDays !== void 0 && Number.isFinite(dormantDays) ? { dormantDays } : {}
     });
     if (opts.json) {
@@ -16549,7 +16720,7 @@ function registerDashboard(program2) {
   });
 }
 function renderDashboard(r) {
-  const { inventory: inv, impact, sensors, health, decay, corpus, prevention } = r;
+  const { inventory: inv, impact, sensors, health, decay, corpus, prevention, gate_precision: gate } = r;
   console.log(ui.bold("hAIve dashboard"));
   console.log(
     `  ${ui.dim("corpus:")} ${inv.total} policy memor${inv.total === 1 ? "y" : "ies"} (${inv.active} active, ${inv.retired} retired) \xB7 ${inv.session_recaps} recap(s) \xB7 ~${corpus.est_tokens.toLocaleString()} tokens`
@@ -16600,6 +16771,15 @@ function renderDashboard(r) {
     }
   }
   console.log();
+  console.log(ui.bold("Gate precision") + ui.dim("  (is the anti-pattern gate real or noisy?)"));
+  const precisionLabel = gate.precision === null ? ui.dim("no signal yet") : gate.precision >= 0.7 ? ui.green(`${Math.round(gate.precision * 100)}%`) : ui.yellow(`${Math.round(gate.precision * 100)}%`);
+  console.log(
+    `  ${precisionLabel} precision \xB7 ${gate.useful} useful (sensor ${gate.sensor_catches} \xB7 anti-pattern ${gate.anti_pattern_catches}) \xB7 ${gate.rejections > 0 ? ui.yellow(`${gate.rejections} rejected`) : "0 rejected"}`
+  );
+  if (gate.suggestion) {
+    ui.info(`Tuning: set enforcement.antiPatternGate="${gate.suggestion.recommended}" \u2014 ${gate.suggestion.reason}`);
+  }
+  console.log();
   console.log(ui.bold("Health"));
   console.log(
     `  stale ${warnNum(health.stale)} \xB7 anchorless ${warnNum(health.anchorless)} \xB7 pending ${health.pending} \xB7 prune candidates ${warnNum(health.prune_candidates)}`
@@ -16634,9 +16814,331 @@ function warnNum(n) {
   return n > 0 ? ui.yellow(String(n)) : String(n);
 }
 
+// src/commands/dev-link.ts
+import { execFile as execFile3 } from "child_process";
+import { cp, readFile as readFile26 } from "fs/promises";
+import { existsSync as existsSync79 } from "fs";
+import path55 from "path";
+import { promisify as promisify3 } from "util";
+import "commander";
+import { findProjectRoot as findProjectRoot56 } from "@hiveai/core";
+var exec3 = promisify3(execFile3);
+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) => {
+    const root = findProjectRoot56(opts.dir);
+    if (!existsSync79(path55.join(root, "packages", "cli", "dist", "index.js"))) {
+      ui.error(`Not the hAIve 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();
+    } catch {
+      globalModules = path55.join(path55.dirname(path55.dirname(process.execPath)), "lib", "node_modules");
+    }
+    const globalHive = path55.join(globalModules, "@hiveai");
+    if (!existsSync79(globalHive)) {
+      ui.error(`No global @hiveai install at ${globalHive}. Install once with \`npm i -g @hiveai/cli\`, then re-run.`);
+      process.exitCode = 1;
+      return;
+    }
+    const linked = [];
+    const copyDist = async (fromPkg, toDistDir) => {
+      const from = path55.join(root, "packages", fromPkg, "dist");
+      if (!existsSync79(from) || !existsSync79(path55.dirname(toDistDir))) return;
+      await cp(from, toDistDir, { recursive: true });
+      linked.push(path55.relative(globalModules, toDistDir));
+    };
+    for (const pkg of ["cli", "mcp"]) {
+      await copyDist(pkg, path55.join(globalHive, pkg, "dist"));
+      for (const nested of ["core", "embeddings"]) {
+        await copyDist(nested, path55.join(globalHive, pkg, "node_modules", "@hiveai", nested, "dist"));
+      }
+    }
+    await copyDist("core", path55.join(globalHive, "core", "dist"));
+    let version = "unknown";
+    try {
+      version = JSON.parse(await readFile26(path55.join(root, "package.json"), "utf8")).version ?? "unknown";
+    } catch {
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: linked.length > 0, version, global_root: globalHive, linked }, null, 2));
+      return;
+    }
+    if (linked.length === 0) {
+      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 @hiveai install:`);
+    for (const t of linked) console.log(`  ${ui.dim("\u2192")} ${t}`);
+    console.log(ui.dim("The global `haive` now runs your local build (git hooks + MCP included)."));
+  });
+}
+
+// src/commands/coverage.ts
+import "commander";
+import { findCoverageGaps, findProjectRoot as findProjectRoot57, resolveHaivePaths as resolveHaivePaths52 } from "@hiveai/core";
+function isNoisePath(p) {
+  if (/(^|\/)(node_modules|dist|build|coverage|\.next)\//.test(p)) return true;
+  if (p.startsWith(".ai/")) return true;
+  if (/\.(jsonl|lock|map|snap|min\.js)$/.test(p)) return true;
+  if (/(^|\/)(pnpm-lock\.yaml|package-lock\.json|yarn\.lock)$/.test(p)) return true;
+  if (/(^|\/)(CHANGELOG|LICENSE)(\.md)?$/.test(p)) return true;
+  return false;
+}
+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) => {
+    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({
+      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 }));
+    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));
+      return;
+    }
+    if (!radar.insideGitRepo) {
+      ui.warn("Not a git repository \u2014 coverage uses git churn to find hot files.");
+      return;
+    }
+    if (gaps.length === 0) {
+      ui.success(`No coverage gaps: every file changed \u2265${minChanges}\xD7 is covered by a team memory.`);
+      return;
+    }
+    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"})`)}`);
+    }
+    console.log(
+      ui.dim(
+        "\nAdd a decision/convention/gotcha anchored to the top files, or a sensor, to close the gap."
+      )
+    );
+  });
+}
+
+// src/commands/merge-driver.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { readFileSync, writeFileSync, existsSync as existsSync80 } from "fs";
+import path56 from "path";
+import "commander";
+import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hiveai/core";
+var GITATTRIBUTES_MARK = "# hAIve merge driver";
+var GITATTRIBUTES_BLOCK = [
+  GITATTRIBUTES_MARK,
+  ".ai/memories/**/*.md merge=haive",
+  "# hAIve merge driver end"
+].join("\n");
+function registerMergeDriver(program2) {
+  const cmd = program2.command("merge-driver").description("Deterministic git merge driver for hAIve memory files (kills .ai/ conflict markers)");
+  cmd.command("run <base> <ours> <theirs>").description("Git merge-driver entrypoint: resolve ours/theirs by frontmatter order, write into <ours>").action((base, ours, theirs) => {
+    try {
+      const oursContent = readFileSync(ours, "utf8");
+      const theirsContent = readFileSync(theirs, "utf8");
+      const result = mergeMemoryVersions(oursContent, theirsContent);
+      if (result.content !== oursContent) writeFileSync(ours, result.content, "utf8");
+      process.exit(0);
+    } catch {
+      process.exit(1);
+    }
+  });
+  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);
+    try {
+      execFileSync3("git", ["config", "merge.haive.name", "hAIve memory merge driver"], { cwd: root });
+      execFileSync3("git", ["config", "merge.haive.driver", "haive merge-driver run %O %A %B"], { cwd: root });
+    } catch {
+      ui.error("Could not set git config \u2014 is this a git repository?");
+      process.exitCode = 1;
+      return;
+    }
+    const gaPath = path56.join(root, ".gitattributes");
+    let content = existsSync80(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    if (!content.includes(GITATTRIBUTES_MARK)) {
+      if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+      content += GITATTRIBUTES_BLOCK + "\n";
+      writeFileSync(gaPath, content, "utf8");
+      ui.success("Installed hAIve merge driver (git config + .gitattributes).");
+    } else {
+      ui.info("hAIve merge driver already present in .gitattributes \u2014 refreshed git config.");
+    }
+    ui.info("Memory-file conflicts under .ai/memories/ now resolve by revision_count \u2192 created_at.");
+  });
+}
+
+// src/commands/memory-resolve-conflict.ts
+import { writeFile as writeFile38 } from "fs/promises";
+import { existsSync as existsSync81 } from "fs";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot59,
+  planConflictResolution,
+  resolveHaivePaths as resolveHaivePaths53,
+  serializeMemory as serializeMemory29
+} from "@hiveai/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 paths = resolveHaivePaths53(root);
+    if (!existsSync81(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}.`);
+      process.exitCode = 1;
+      return;
+    }
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
+    const a = memories.find((m) => m.memory.frontmatter.id === idA);
+    const b = memories.find((m) => m.memory.frontmatter.id === idB);
+    if (!a || !b) {
+      ui.error(`Memory not found: ${!a ? idA : ""} ${!b ? idB : ""}`.trim());
+      process.exitCode = 1;
+      return;
+    }
+    const plan = planConflictResolution(a, b);
+    const loser = plan.supersede_id === idA ? a : b;
+    if (opts.json) {
+      console.log(JSON.stringify({ ...plan, applied: Boolean(opts.yes) }, null, 2));
+    } else {
+      console.log(ui.bold("Conflict resolution"));
+      console.log(`  keep:      ${ui.green(plan.keep_id)}`);
+      console.log(`  supersede: ${ui.red(plan.supersede_id)} ${ui.dim(`\u2192 deprecated`)}`);
+      console.log(`  reason:    ${plan.reason}`);
+    }
+    if (!opts.yes) {
+      if (!opts.json) ui.info("Preview only \u2014 re-run with --yes to apply.");
+      return;
+    }
+    await writeFile38(
+      loser.filePath,
+      serializeMemory29({
+        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
+      }),
+      "utf8"
+    );
+    if (!opts.json) ui.success(`Deprecated ${plan.supersede_id}; ${plan.keep_id} remains authoritative.`);
+  });
+}
+
+// src/commands/memory-seed-git.ts
+import { execFile as execFile4 } from "child_process";
+import { mkdir as mkdir24, writeFile as writeFile39 } from "fs/promises";
+import { existsSync as existsSync83 } from "fs";
+import path57 from "path";
+import { promisify as promisify4 } from "util";
+import "commander";
+import {
+  buildFrontmatter as buildFrontmatter12,
+  findProjectRoot as findProjectRoot60,
+  memoryFilePath as memoryFilePath13,
+  proposeSeedsFromCommits,
+  resolveHaivePaths as resolveHaivePaths54,
+  serializeMemory as serializeMemory30
+} from "@hiveai/core";
+var exec4 = promisify4(execFile4);
+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)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const limit = Math.max(1, parseInt(opts.limit ?? "20", 10) || 20);
+    const days = Math.max(1, parseInt(opts.days ?? "365", 10) || 365);
+    const commits = await readCommits(root, days);
+    const proposals = proposeSeedsFromCommits(commits, limit);
+    if (opts.json) {
+      console.log(JSON.stringify({ scanned_commits: commits.length, proposals, applied: Boolean(opts.apply) }, null, 2));
+    } else if (proposals.length === 0) {
+      ui.info("No revert/hotfix signals found in git history \u2014 nothing to seed.");
+      return;
+    } else {
+      console.log(ui.bold(`hAIve seed-git \u2014 ${proposals.length} proposal(s) from ${commits.length} commit(s)`));
+      for (const p of proposals) {
+        console.log(`  ${ui.yellow("\u25C6")} ${ui.dim(`[${p.kind}]`)} ${p.what}`);
+        if (p.paths.length > 0) console.log(`     ${ui.dim("paths:")} ${p.paths.join(", ")}`);
+      }
+    }
+    if (!opts.apply) {
+      if (!opts.json) ui.info("Preview only \u2014 re-run with --apply to write these as draft memories.");
+      return;
+    }
+    let written = 0;
+    for (const p of proposals) {
+      const fm = {
+        ...buildFrontmatter12({
+          type: "attempt",
+          slug: p.slug,
+          scope: opts.scope ?? "team",
+          tags: ["seed", "git-history", p.kind],
+          paths: p.paths
+        }),
+        status: "draft"
+        // human reviews before it becomes validated
+      };
+      const body = `# ${p.what}
+
+**Why it failed / do NOT use:** ${p.why_failed}
+
+_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 mkdir24(path57.dirname(file), { recursive: true });
+      await writeFile39(file, serializeMemory30({ frontmatter: fm, body }), "utf8");
+      written += 1;
+    }
+    if (!opts.json) {
+      ui.success(`Wrote ${written} draft seed(s). Review them: \`haive memory pending\` \u2192 validate or delete.`);
+    }
+  });
+}
+async function readCommits(root, days) {
+  try {
+    const { stdout } = await exec4(
+      "git",
+      ["log", `--since=${days}.days.ago`, "--name-only", "--pretty=format:%x1f%h%x1f%s", "-n", "500"],
+      { cwd: root, maxBuffer: 8 * 1024 * 1024 }
+    );
+    const blocks = stdout.split("").filter((b) => b.length > 0);
+    const commits = [];
+    for (let i = 0; i + 1 < blocks.length; i += 2) {
+      const sha = blocks[i].trim();
+      const tail = blocks[i + 1];
+      const lines = tail.split("\n").map((l) => l.trim()).filter(Boolean);
+      const subject = lines.shift() ?? "";
+      commits.push({ sha, subject, files: lines });
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+
 // src/index.ts
-var program = new Command58();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.13.9").option("--advanced", "show maintenance and experimental commands in help");
+var program = new Command63();
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.15.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -16647,6 +17149,9 @@ registerAgent(program);
 registerSensors(program);
 registerIngest(program);
 registerDashboard(program);
+registerCoverage(program);
+registerMergeDriver(program);
+registerDevLink(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);
@@ -16676,6 +17181,8 @@ registerMemoryUpdate(memory);
 registerMemoryHot(memory);
 registerMemoryTried(memory);
 registerMemorySeed(memory);
+registerMemorySeedGit(memory);
+registerMemoryResolveConflict(memory);
 registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);