@hivelore/cli 0.42.1 → 0.44.0

package/README.md

@@ -233,6 +233,7 @@ Run the repeatable quality gate for Hivelore itself or for a project using Hivel
 ```bash
 hivelore eval
 hivelore eval --semantic-only
+hivelore eval --semantic-ranking  # require and exercise the real embeddings-backed ranker
 hivelore eval --spec .ai/eval/spec.json --fail-under 80
 ```
 
@@ -533,14 +534,14 @@ hivelore install-hooks --dir /path/to/project
 
 ---
 
-### `hivelore embeddings`
+### `hivelore index`
 
 Manage the local semantic search index (requires `@hivelore/embeddings` to be installed).
 
 ```bash
-hivelore embeddings index          # Build or refresh the embeddings index
-hivelore embeddings status         # Show index stats (count, last updated, model)
-hivelore embeddings query "how do we handle retries on payment failures"
+hivelore index memories            # Build or refresh the embeddings index
+hivelore index status              # Show index stats (count, last updated, model)
+hivelore index query "how do we handle retries on payment failures"
 ```
 
 The model (`bge-small-en-v1.5`, ~110MB) is downloaded on first use and cached locally. **No data leaves your machine.**
@@ -655,8 +656,8 @@ Install `@hivelore/embeddings` for similarity-based memory retrieval:
 
 ```bash
 npm install -g @hivelore/embeddings
-hivelore embeddings index          # First run downloads the model (~110MB)
-hivelore embeddings query "payment retry logic"
+hivelore index memories            # First run downloads the model (~110MB)
+hivelore index query "payment retry logic"
 ```
 
 From MCP: set `semantic: true` on `mem_search` or `get_briefing`.

package/dist/{chunk-EJ7A4IKD.js → chunk-6KRXMDLC.js}

@@ -3,6 +3,8 @@
 // ../mcp/dist/server.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { mkdir as mkdir8, writeFile as writeFile15 } from "fs/promises";
+import path15 from "path";
 import { findProjectRoot, resolveHaivePaths } from "@hivelore/core";
 import { mkdir, writeFile } from "fs/promises";
 import { existsSync } from "fs";
@@ -133,7 +135,7 @@ import {
   suggestSensorSeed as suggestSensorSeed2
 } from "@hivelore/core";
 import { z as z16 } from "zod";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { readFile as readFile3, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync15, rmSync, symlinkSync } from "fs";
 import os from "os";
@@ -193,7 +195,7 @@ import {
 import { mkdir as mkdir6, writeFile as writeFile12, rm } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
 import path10 from "path";
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 import { readFile as readFile7, writeFile as writeFile14, readdir as readdir4 } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
 import path13 from "path";
@@ -305,6 +307,7 @@ import { z as z32 } from "zod";
 import { z as z33 } from "zod";
 import { readFile as readFile8, readdir as readdir5 } from "fs/promises";
 import { existsSync as existsSync29 } from "fs";
+import path14 from "path";
 import {
   assessBootstrapState as assessBootstrapState2,
   loadCodeMap as loadCodeMap4,
@@ -1283,10 +1286,32 @@ async function memApprove(input, ctx) {
   };
 }
 var cachedEngine;
+var registeredDynamicLanguages = /* @__PURE__ */ new Set();
+async function loadDynamicLanguages(engine) {
+  const registrations = {};
+  const candidates = [
+    ["python", () => import("@ast-grep/lang-python")],
+    ["go", () => import("@ast-grep/lang-go")],
+    ["rust", () => import("@ast-grep/lang-rust")],
+    ["java", () => import("@ast-grep/lang-java")]
+  ];
+  for (const [name, load] of candidates) {
+    try {
+      const mod = await load();
+      registrations[name] = mod.default;
+      registeredDynamicLanguages.add(name);
+    } catch {
+    }
+  }
+  if (Object.keys(registrations).length > 0) {
+    engine.registerDynamicLanguage(registrations);
+  }
+}
 async function loadAstEngine() {
   if (cachedEngine !== void 0) return cachedEngine;
   try {
     cachedEngine = await import("@ast-grep/napi");
+    await loadDynamicLanguages(cachedEngine);
   } catch {
     cachedEngine = null;
   }
@@ -1295,11 +1320,22 @@ async function loadAstEngine() {
 async function astEngineAvailable() {
   return await loadAstEngine() !== null;
 }
-function astLangForPath(filePath) {
+function astLangForPath(filePath, explicitLanguage) {
+  if (explicitLanguage) {
+    const normalized = explicitLanguage.toLowerCase();
+    if (["typescript", "tsx", "javascript", "html", "css"].includes(normalized)) {
+      return normalized === "typescript" ? "TypeScript" : normalized === "tsx" ? "Tsx" : normalized === "javascript" ? "JavaScript" : normalized[0].toUpperCase() + normalized.slice(1);
+    }
+    return registeredDynamicLanguages.has(normalized) ? normalized : null;
+  }
   const ext = path5.extname(filePath).toLowerCase();
   if (ext === ".ts" || ext === ".mts" || ext === ".cts") return "TypeScript";
   if (ext === ".tsx") return "Tsx";
   if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") return "JavaScript";
+  if (ext === ".py" && registeredDynamicLanguages.has("python")) return "python";
+  if (ext === ".go" && registeredDynamicLanguages.has("go")) return "go";
+  if (ext === ".rs" && registeredDynamicLanguages.has("rust")) return "rust";
+  if (ext === ".java" && registeredDynamicLanguages.has("java")) return "java";
   return null;
 }
 function absentPresentInNode(node, absent) {
@@ -1314,12 +1350,12 @@ function absentPresentInNode(node, absent) {
     return text.includes(absent);
   }
 }
-async function runAstPattern(content, filePath, pattern, absent) {
+async function runAstPattern(content, filePath, pattern, absent, rule, language) {
   const engine = await loadAstEngine();
   if (!engine) return { status: "engine-missing", matches: [] };
-  const langName = astLangForPath(filePath);
+  const langName = astLangForPath(filePath, language);
   if (!langName) return { status: "unsupported-language", matches: [] };
-  const lang = engine.Lang[langName];
+  const lang = langName in engine.Lang ? engine.Lang[langName] : langName;
   let root;
   try {
     root = engine.parse(lang, content).root();
@@ -1328,7 +1364,9 @@ async function runAstPattern(content, filePath, pattern, absent) {
   }
   let nodes;
   try {
-    nodes = root.findAll(pattern);
+    const matcher = rule ? { rule: pattern ? { all: [{ pattern }, rule] } : rule } : pattern;
+    if (!matcher) return { status: "invalid-pattern", matches: [], detail: "missing pattern/rule" };
+    nodes = root.findAll(matcher);
   } catch (err) {
     return { status: "invalid-pattern", matches: [], detail: String(err).slice(0, 200) };
   }
@@ -1345,7 +1383,7 @@ async function runAstPattern(content, filePath, pattern, absent) {
   return { status: "ok", matches };
 }
 async function runAstSensorOnContent(input) {
-  const scan = await runAstPattern(input.content, input.filePath, input.pattern, input.absent);
+  const scan = await runAstPattern(input.content, input.filePath, input.pattern, input.absent, input.rule, input.language);
   if (scan.status !== "ok" || !input.addedLines || input.addedLines.size === 0) return scan;
   const added = input.addedLines;
   return {
@@ -1363,7 +1401,9 @@ var ProposeSensorInputSchema = {
   kind: z15.enum(["regex", "ast", "shell", "test"]).default("regex").describe(
     "regex = pattern matched on added diff lines (default). ast = an ast-grep STRUCTURAL pattern (e.g. 'stripe.paymentIntents.create($$$)') matched on the AST of changed files \u2014 comments and strings can never false-positive; `absent` is a sub-pattern that must be missing INSIDE the match (requires the optional @ast-grep/napi engine). shell|test = a COMMAND the gate runs when the diff touches the sensor's paths \u2014 routes the team's own oracle (an existing test, an invariant script) to this lesson. Command sensors only execute where enforcement.runCommandSensors=true."
   ),
-  pattern: z15.string().optional().describe("kind=regex: regex matching the FAULTY usage (the risky call/token), e.g. 'stripe\\.paymentIntents\\.create'."),
+  pattern: z15.string().optional().describe("kind=regex: regex matching the faulty usage; kind=ast: optional structural pattern (may be combined with `rule`)."),
+  rule: z15.record(z15.unknown()).optional().describe("kind=ast: full ast-grep Rule object (kind/inside/has/not/all/any/etc.). May be used alone or combined with pattern."),
+  language: z15.string().optional().describe("kind=ast: explicit built-in/dynamic language name for non-standard file extensions."),
   command: z15.string().optional().describe("kind=shell|test: command to execute (e.g. 'npx vitest run tests/payments/refund.spec.ts'). Non-zero exit = the lesson fires."),
   timeout_ms: z15.number().int().positive().optional().describe("kind=shell|test: max runtime before the executor kills the command (default 120000)."),
   absent: z15.string().optional().describe(
@@ -1394,7 +1434,7 @@ async function readPresumedCorrectTargets(root, relPaths) {
   const targets = [];
   for (const rel of relPaths) {
     try {
-      const content = execSync(`git show ${JSON.stringify(`HEAD:./${rel}`)}`, {
+      const content = execFileSync("git", ["show", `HEAD:./${rel}`], {
         cwd: root,
         encoding: "utf8",
         maxBuffer: 10 * 1024 * 1024,
@@ -1415,7 +1455,7 @@ async function readPresumedCorrectTargets(root, relPaths) {
 }
 function runCommandForValidation(command, root, timeoutMs = 12e4) {
   try {
-    execSync(`bash -c ${JSON.stringify(command)}`, {
+    execFileSync("bash", ["-c", command], {
       cwd: root,
       timeout: timeoutMs,
       maxBuffer: 8 * 1024 * 1024,
@@ -1440,7 +1480,7 @@ function proveRedOnIncident(command, root, redRef, timeoutMs) {
   let added = false;
   try {
     try {
-      execSync(`git worktree add --detach ${JSON.stringify(worktree)} ${JSON.stringify(redRef)}`, {
+      execFileSync("git", ["worktree", "add", "--detach", worktree, redRef], {
         cwd: root,
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 6e4
@@ -1467,7 +1507,7 @@ function proveRedOnIncident(command, root, redRef, timeoutMs) {
   } finally {
     if (added) {
       try {
-        execSync(`git worktree remove --force ${JSON.stringify(worktree)}`, { cwd: root, stdio: "ignore", timeout: 6e4 });
+        execFileSync("git", ["worktree", "remove", "--force", worktree], { cwd: root, stdio: "ignore", timeout: 6e4 });
       } catch {
         try {
           rmSync(worktree, { recursive: true, force: true });
@@ -1507,13 +1547,13 @@ async function proposeSensor(input, ctx) {
       };
     }
   } else if (kind === "ast") {
-    if (!input.pattern?.trim()) {
+    if (!input.pattern?.trim() && !input.rule) {
       return {
         accepted: false,
         memory_id: input.memory_id,
         severity: input.severity,
         reason: "invalid-pattern",
-        guidance: "kind=ast requires a `pattern` (an ast-grep structural pattern).",
+        guidance: "kind=ast requires a structural `pattern` or a full ast-grep `rule` object.",
         self_check: { silent_on_current: false, fires_on_bad: null, fired_on: [] }
       };
     }
@@ -1534,7 +1574,7 @@ async function proposeSensor(input, ctx) {
   }
   const personalScopeNudge = found.memory.frontmatter.scope === "personal" ? ` Note: this lesson is personal-scoped, so the sensor guards only YOUR machine (personal memories are gitignored). Promote it so the gate travels with the repo: hivelore memory promote ${input.memory_id}.` : "";
   if (kind === "ast") {
-    const pattern = input.pattern.trim();
+    const pattern = input.pattern?.trim();
     if (!await astEngineAvailable() && input.severity === "block") {
       return {
         accepted: false,
@@ -1545,7 +1585,7 @@ async function proposeSensor(input, ctx) {
         self_check: { silent_on_current: false, fires_on_bad: null, fired_on: [] }
       };
     }
-    const brittleAst = sensorPatternBrittleness(pattern);
+    const brittleAst = pattern ? sensorPatternBrittleness(pattern) : null;
     if (brittleAst && input.severity === "block") {
       return {
         accepted: false,
@@ -1560,7 +1600,7 @@ async function proposeSensor(input, ctx) {
     const currentTargetsAst = await readPresumedCorrectTargets(ctx.paths.root, anchorPathsAst);
     const firedOnAst = [];
     for (const target of currentTargetsAst) {
-      const scan = await runAstSensorOnContent({ pattern, absent: input.absent, content: target.content, filePath: target.path });
+      const scan = await runAstSensorOnContent({ pattern, rule: input.rule, language: input.language, absent: input.absent, content: target.content, filePath: target.path });
       if (scan.status === "invalid-pattern") {
         return {
           accepted: false,
@@ -1589,10 +1629,10 @@ async function proposeSensor(input, ctx) {
     ];
     let firesOnBadAst = null;
     if (badExamplesAst.length > 0 && await astEngineAvailable()) {
-      const exampleLang = anchorPathsAst.find((p) => astLangForPath(p) !== null) ?? "example.tsx";
+      const exampleLang = anchorPathsAst.find((p) => astLangForPath(p, input.language) !== null) ?? "example.tsx";
       firesOnBadAst = false;
       for (const example of badExamplesAst) {
-        const scan = await runAstSensorOnContent({ pattern, absent: input.absent, content: example, filePath: exampleLang });
+        const scan = await runAstSensorOnContent({ pattern, rule: input.rule, language: input.language, absent: input.absent, content: example, filePath: exampleLang });
         if (scan.status === "ok" && scan.matches.length > 0) {
           firesOnBadAst = true;
           break;
@@ -1611,10 +1651,12 @@ async function proposeSensor(input, ctx) {
     }
     const sensorAst = {
       kind: "ast",
-      pattern,
+      ...pattern ? { pattern } : {},
+      ...input.rule ? { rule: input.rule } : {},
+      ...input.language ? { language: input.language } : {},
       ...input.absent ? { absent: input.absent } : {},
       paths: anchorPathsAst,
-      message: input.message?.trim() || deriveMessage(found.memory.body, pattern, input.absent),
+      message: input.message?.trim() || deriveMessage(found.memory.body, pattern ?? "AST rule", input.absent),
       ...input.incident?.trim() ? { incident: input.incident.trim() } : {},
       severity: input.severity,
       autogen: false,
@@ -1677,6 +1719,16 @@ ${verdictCmd.detail}`,
         self_check: { silent_on_current: false, fires_on_bad: null, fired_on: anchorPathsCmd }
       };
     }
+    if (input.severity === "block" && !input.red_ref?.trim()) {
+      return {
+        accepted: false,
+        memory_id: input.memory_id,
+        severity: input.severity,
+        reason: "red-required",
+        guidance: "A blocking shell/test sensor requires `red_ref`: the oracle must PASS on the current tree and FAIL on the pre-fix incident state. Pass the incident commit/ref, or propose the sensor at warn severity until RED can be proven.",
+        self_check: { silent_on_current: true, fires_on_bad: null, fired_on: [] }
+      };
+    }
     const sensorCmd = {
       kind,
       command: input.command.trim(),
@@ -1698,7 +1750,7 @@ ${verdictCmd.detail}`,
       accepted: true,
       memory_id: input.memory_id,
       severity: input.severity,
-      guidance: (verdictCmd.status === "passed" ? "Command oracle passes on the current tree; the gate now runs it when the diff touches the sensor's paths (requires enforcement.runCommandSensors=true)." : `Accepted at warn severity, but note: ${verdictCmd.status} on the current tree (${verdictCmd.detail}).`) + (redProven ? " RED proven: the oracle demonstrably FAILS on the incident state (red_ref) \u2014 recorded as red_proven." : " Tip: pass red_ref (the pre-fix commit) to PROVE the oracle catches the incident, not merely that it passes today.") + (pendingTests.length > 0 ? ` Note: the routed test is still a PENDING stub (${pendingTests.join(", ")}) \u2014 it passes on anything; write the assertion to make this oracle real.` : "") + personalScopeNudge,
+      guidance: (verdictCmd.status === "passed" ? "Command oracle passes on the current tree; the gate now runs it when the diff touches the sensor's paths (requires enforcement.runCommandSensors=true)." : `Accepted at warn severity, but note: ${verdictCmd.status} on the current tree (${verdictCmd.detail}).`) + (redProven ? " RED proven: the oracle demonstrably FAILS on the incident state (red_ref) \u2014 recorded as red_proven." : " This warn-only oracle is not RED-proven; pass red_ref before promoting it to block.") + (pendingTests.length > 0 ? ` Note: the routed test is still a PENDING stub (${pendingTests.join(", ")}) \u2014 it passes on anything; write the assertion to make this oracle real.` : "") + personalScopeNudge,
       self_check: { silent_on_current: verdictCmd.status === "passed", fires_on_bad: redProven ? true : null, fired_on: [] },
       file_path: found.filePath
     };
@@ -1765,8 +1817,10 @@ var MemTriedInputSchema = {
   paths: z16.array(z16.string()).default([]).describe("Anchor file paths this applies to"),
   author: z16.string().optional().describe("Author handle or email"),
   sensor: z16.object({
-    kind: z16.enum(["regex", "shell", "test"]).default("regex").describe("regex pattern, or a shell/test COMMAND the gate executes (behaviour bridge)"),
-    pattern: z16.string().optional().describe("kind=regex: regex matching the FAULTY usage (added diff lines)"),
+    kind: z16.enum(["regex", "ast", "shell", "test"]).default("regex").describe("regex/AST pattern, or a shell/test command"),
+    pattern: z16.string().optional().describe("kind=regex|ast: pattern matching the faulty usage"),
+    rule: z16.record(z16.unknown()).optional().describe("kind=ast: full ast-grep Rule object"),
+    language: z16.string().optional().describe("kind=ast: explicit built-in/dynamic language"),
     command: z16.string().optional().describe("kind=shell|test: command the gate runs when the diff touches the sensor's paths (non-zero exit = lesson fires)"),
     timeout_ms: z16.number().int().positive().optional().describe("kind=shell|test: max runtime (default 120000)"),
     absent: z16.string().optional().describe("kind=regex: regex marking CORRECT usage nearby \u2014 excludes it from firing"),
@@ -1816,6 +1870,8 @@ async function memTried(input, ctx) {
         memory_id: frontmatter.id,
         kind: input.sensor.kind ?? "regex",
         pattern: input.sensor.pattern,
+        rule: input.sensor.rule,
+        language: input.sensor.language,
         command: input.sensor.command,
         timeout_ms: input.sensor.timeout_ms,
         absent: input.sensor.absent,
@@ -2109,7 +2165,7 @@ var SessionTracker = class {
       }
       let gitDiff;
       try {
-        const raw = execSync2("git diff HEAD", {
+        const raw = execSync("git diff HEAD", {
           cwd: this.ctx.paths.root,
           timeout: 5e3,
           encoding: "utf8",
@@ -2141,7 +2197,7 @@ var SessionTracker = class {
         const triedThreads = this.events.filter((e) => e.tool === "mem_tried").map((e) => e.summary ?? "").filter(Boolean);
         let diffStat;
         try {
-          diffStat = execSync2("git diff --stat HEAD", {
+          diffStat = execSync("git diff --stat HEAD", {
             cwd: this.ctx.paths.root,
             timeout: 5e3,
             encoding: "utf8",
@@ -2491,6 +2547,8 @@ var GetBriefingInputSchema = {
   ),
   include_stale: z20.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
   track: z20.boolean().default(true).describe("Increment read_count on returned memories"),
+  memory_scopes: z20.array(z20.enum(["personal", "team", "module", "shared"])).optional().describe("Restrict the candidate corpus to selected scopes. Omit to include every scope."),
+  deterministic: z20.boolean().optional().describe("Ignore machine-local usage/impact signals so repeated evaluations rank the shared corpus reproducibly."),
   format: z20.enum(["full", "compact", "actions"]).default("full").describe(
     "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
@@ -2519,9 +2577,11 @@ async function getBriefing(input, ctx) {
   let searchMode = "literal";
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
+  const allowedScopes = input.memory_scopes ? new Set(input.memory_scopes) : null;
+  const scopeAllowed = (loaded) => allowedScopes === null || allowedScopes.has(loaded.memory.frontmatter.scope);
   let lastSession;
   if (existsSync22(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+    const allLoaded = (await loadMemoriesFromDir17(ctx.paths.memoriesDir)).filter(scopeAllowed);
     const recaps = allLoaded.filter(({ memory }) => memory.frontmatter.type === "session_recap").sort(
       (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
     );
@@ -2554,10 +2614,11 @@ async function getBriefing(input, ctx) {
       if (memoryHasExcludedTag(memory.frontmatter, excludeTags)) return false;
       return true;
     });
-    usage = await loadUsageIndex8(ctx.paths);
+    usage = input.deterministic ? { version: 1, updated_at: "", by_id: {} } : await loadUsageIndex8(ctx.paths);
     byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
-    const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
-    if (input.task && input.semantic) {
+    const semanticEnabled = input.semantic && input.deterministic !== true;
+    const semanticHits = input.task && semanticEnabled ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
+    if (input.task && semanticEnabled) {
       searchMode = semanticHits ? "semantic" : "literal_fallback";
     }
     const seen = /* @__PURE__ */ new Map();
@@ -2893,7 +2954,7 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   if (existsSync22(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+    const allMems = (await loadMemoriesFromDir17(ctx.paths.memoriesDir)).filter(scopeAllowed);
     for (const { memory } of allMems) {
       const fm = memory.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -2950,7 +3011,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
         pcRaw = await readFile7(ctx.paths.projectContext, "utf8");
       } catch {
       }
-      const allForBootstrap = existsSync22(ctx.paths.memoriesDir) ? await loadMemoriesFromDir17(ctx.paths.memoriesDir) : [];
+      const allForBootstrap = existsSync22(ctx.paths.memoriesDir) ? (await loadMemoriesFromDir17(ctx.paths.memoriesDir)).filter(scopeAllowed) : [];
       const cmForBootstrap = await loadCodeMap(ctx.paths);
       let existingModules = [];
       try {
@@ -2961,7 +3022,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       const bootstrap = assessBootstrapState({
         projectContextRaw: pcRaw,
         memories: allForBootstrap,
-        codeFiles: cmForBootstrap ? Object.keys(cmForBootstrap.files) : [],
+        codeFiles: cmForBootstrap ? Object.keys(cmForBootstrap.files).filter((file) => existsSync22(path13.join(ctx.paths.root, file))) : [],
         existingModules
       });
       if (bootstrap.state !== "ready" && bootstrap.metrics.mainAreas > 0) {
@@ -3152,7 +3213,7 @@ function oneLine(value) {
   return value.replace(/\s+/g, " ").replace(/"/g, '\\"').trim().slice(0, 120);
 }
 function serverVersion() {
-  return true ? "0.42.1" : "dev";
+  return true ? "0.44.0" : "dev";
 }
 var CodeMapInputSchema = {
   file: z21.string().optional().describe("Filter to files whose path contains this substring"),
@@ -3395,7 +3456,8 @@ var AntiPatternsCheckInputSchema = {
   ),
   min_semantic_score: z26.number().min(0).max(1).default(0.45).describe(
     "Minimum cosine score for semantic-only anti-pattern hits. Anchor/literal matches still surface. Default 0.45 keeps broad, weakly-related memories out of review noise."
-  )
+  ),
+  track: z26.boolean().default(true).describe("Record real prevention outcomes. Set false for eval/selftest probes so synthetic cases never inflate ROI.")
 };
 function tokenizeDiffForLiteral(diff) {
   const lines = diff.split("\n");
@@ -3588,7 +3650,9 @@ async function antiPatternsCheck(input, ctx) {
   }).slice(0, input.limit);
   const isHardBlockCatch = (w) => w.reasons.includes("sensor");
   const strongCatches = warnings.filter(isHardBlockCatch);
-  await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
+  if (input.track !== false) {
+    await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
+  }
   return {
     scanned: negative.length,
     warnings
@@ -4260,7 +4324,7 @@ async function currentAssessment(ctx) {
   return assessBootstrapState2({
     projectContextRaw,
     memories,
-    codeFiles: codeMap ? Object.keys(codeMap.files) : [],
+    codeFiles: codeMap ? Object.keys(codeMap.files).filter((file) => existsSync29(path14.join(ctx.paths.root, file))) : [],
     existingModules
   });
 }
@@ -4317,13 +4381,14 @@ Main code areas detected: ${areas}
 }
 var PostTaskArgsSchema = {
   task_summary: z35.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z35.array(z35.string()).optional().describe("Files you created or modified during the task")
+  files_touched: z35.string().optional().describe("Files you created or modified during the task, as CSV or a JSON array string")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
 Task just completed: **${args.task_summary}**` : "";
-  const filesLine = args.files_touched && args.files_touched.length > 0 ? `
-Files touched: ${args.files_touched.map((f) => `\`${f}\``).join(", ")}` : "";
+  const filesTouched = parsePromptFilesTouched(args.files_touched);
+  const filesLine = filesTouched.length > 0 ? `
+Files touched: ${filesTouched.map((f) => `\`${f}\``).join(", ")}` : "";
   const text = `You have just finished a task. Before closing this session, take 60 seconds to capture what you learned.
 ${taskLine}${filesLine}
 
@@ -4412,6 +4477,20 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
     ]
   };
 }
+function parsePromptFilesTouched(input) {
+  const raw = input?.trim();
+  if (!raw) return [];
+  if (raw.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean);
+      }
+    } catch {
+    }
+  }
+  return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
 var ImportDocsArgsSchema = {
   content: z36.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
   source: z36.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
@@ -4479,7 +4558,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.42.1";
+var SERVER_VERSION = "0.44.0";
 function jsonResult(data) {
   return {
     content: [
@@ -5418,11 +5497,22 @@ function printHaiveMcpVersion() {
 }
 async function runHaiveMcpStdio(options) {
   const { server, context } = createHaiveServer({ root: options.root, env: process.env });
+  await writeMcpRuntimeMarker(context).catch(() => {
+  });
   console.error(
     `[haive-mcp] starting server v${SERVER_VERSION} (project root: ${context.paths.root})`
   );
   await server.connect(new StdioServerTransport());
 }
+async function writeMcpRuntimeMarker(context) {
+  await mkdir8(context.paths.runtimeDir, { recursive: true });
+  await writeFile15(path15.join(context.paths.runtimeDir, "mcp-server.json"), JSON.stringify({
+    version: SERVER_VERSION,
+    pid: process.pid,
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    command: "hivelore mcp --stdio"
+  }, null, 2), "utf8");
+}
 
 export {
   astEngineAvailable,
@@ -5457,6 +5547,7 @@ export {
   createHaiveServer,
   parseMcpCliArgs,
   printHaiveMcpVersion,
-  runHaiveMcpStdio
+  runHaiveMcpStdio,
+  writeMcpRuntimeMarker
 };
-//# sourceMappingURL=chunk-EJ7A4IKD.js.map
+//# sourceMappingURL=chunk-6KRXMDLC.js.map