@hivelore/mcp 0.42.1 → 0.43.2

package/dist/server.d.ts

@@ -192,6 +192,8 @@ declare const GetBriefingZod: z.ZodObject<{
     semantic: z.ZodDefault<z.ZodBoolean>;
     include_stale: z.ZodDefault<z.ZodBoolean>;
     track: z.ZodDefault<z.ZodBoolean>;
+    memory_scopes: z.ZodOptional<z.ZodArray<z.ZodEnum<["personal", "team", "module", "shared"]>, "many">>;
+    deterministic: z.ZodOptional<z.ZodBoolean>;
     format: z.ZodDefault<z.ZodEnum<["full", "compact", "actions"]>>;
     symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     min_semantic_score: z.ZodDefault<z.ZodNumber>;
@@ -210,6 +212,8 @@ declare const GetBriefingZod: z.ZodObject<{
     min_semantic_score: number;
     task?: string | undefined;
     dedupe_project_context?: boolean | undefined;
+    memory_scopes?: ("personal" | "team" | "module" | "shared")[] | undefined;
+    deterministic?: boolean | undefined;
     budget_preset?: "quick" | "balanced" | "deep" | undefined;
 }, {
     symbols?: string[] | undefined;
@@ -224,6 +228,8 @@ declare const GetBriefingZod: z.ZodObject<{
     semantic?: boolean | undefined;
     include_stale?: boolean | undefined;
     track?: boolean | undefined;
+    memory_scopes?: ("personal" | "team" | "module" | "shared")[] | undefined;
+    deterministic?: boolean | undefined;
     min_semantic_score?: number | undefined;
     budget_preset?: "quick" | "balanced" | "deep" | undefined;
 }>;
@@ -509,6 +515,8 @@ declare const ProposeSensorInputSchema: {
     memory_id: z.ZodString;
     kind: z.ZodDefault<z.ZodEnum<["regex", "ast", "shell", "test"]>>;
     pattern: z.ZodOptional<z.ZodString>;
+    rule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    language: z.ZodOptional<z.ZodString>;
     command: z.ZodOptional<z.ZodString>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     absent: z.ZodOptional<z.ZodString>;
@@ -561,22 +569,25 @@ interface AstScanResult {
     matches: AstMatch[];
     detail?: string;
 }
+type AstRule = Record<string, unknown>;
 declare function astEngineAvailable(): Promise<boolean>;
 /** Map a file extension to a built-in ast-grep language. Unknown → null (unsupported, warn only). */
-declare function astLangForPath(filePath: string): "TypeScript" | "Tsx" | "JavaScript" | null;
+declare function astLangForPath(filePath: string, explicitLanguage?: string): string | null;
 /**
  * Run one AST pattern (with optional `absent` sub-pattern) over a file's FULL content.
  * A match is suppressed when `absent` matches INSIDE the matched node — the structural version of
  * the regex `absent` window: the required companion lives in the call's own arguments.
  */
-declare function runAstPattern(content: string, filePath: string, pattern: string, absent?: string): Promise<AstScanResult>;
+declare function runAstPattern(content: string, filePath: string, pattern?: string, absent?: string, rule?: AstRule, language?: string): Promise<AstScanResult>;
 /**
  * Gate-side evaluation: matches on the full content, FIRES only when a match intersects the added
  * lines (introduction, not mere presence). `addedLines` empty/undefined = validation mode (any
  * match counts — used for silent-on-current / fires-on-bad checks).
  */
 declare function runAstSensorOnContent(input: {
-    pattern: string;
+    pattern?: string;
+    rule?: AstRule;
+    language?: string;
     absent?: string;
     content: string;
     filePath: string;
@@ -593,8 +604,10 @@ declare const MemTriedInputSchema: {
     paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     author: z.ZodOptional<z.ZodString>;
     sensor: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodDefault<z.ZodEnum<["regex", "shell", "test"]>>;
+        kind: z.ZodDefault<z.ZodEnum<["regex", "ast", "shell", "test"]>>;
         pattern: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        language: z.ZodOptional<z.ZodString>;
         command: z.ZodOptional<z.ZodString>;
         timeout_ms: z.ZodOptional<z.ZodNumber>;
         absent: z.ZodOptional<z.ZodString>;
@@ -604,10 +617,12 @@ declare const MemTriedInputSchema: {
         red_ref: z.ZodOptional<z.ZodString>;
         bad_example: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        kind: "regex" | "shell" | "test";
+        kind: "regex" | "ast" | "shell" | "test";
         severity: "warn" | "block";
         pattern?: string | undefined;
         message?: string | undefined;
+        rule?: Record<string, unknown> | undefined;
+        language?: string | undefined;
         command?: string | undefined;
         timeout_ms?: number | undefined;
         absent?: string | undefined;
@@ -617,7 +632,9 @@ declare const MemTriedInputSchema: {
     }, {
         pattern?: string | undefined;
         message?: string | undefined;
-        kind?: "regex" | "shell" | "test" | undefined;
+        kind?: "regex" | "ast" | "shell" | "test" | undefined;
+        rule?: Record<string, unknown> | undefined;
+        language?: string | undefined;
         command?: string | undefined;
         timeout_ms?: number | undefined;
         absent?: string | undefined;

package/dist/server.js

@@ -1132,7 +1132,7 @@ import {
 import { z as z16 } from "zod";
 
 // src/tools/propose-sensor.ts
-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";
@@ -1152,10 +1152,32 @@ import { z as z15 } from "zod";
 // src/ast-sensors.ts
 import path5 from "path";
 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;
   }
@@ -1164,11 +1186,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) {
@@ -1183,12 +1216,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();
@@ -1197,7 +1230,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) };
   }
@@ -1214,7 +1249,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 {
@@ -1234,7 +1269,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(
@@ -1265,7 +1302,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,
@@ -1286,7 +1323,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,
@@ -1311,7 +1348,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
@@ -1338,7 +1375,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 });
@@ -1378,13 +1415,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: [] }
       };
     }
@@ -1405,7 +1442,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,
@@ -1416,7 +1453,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,
@@ -1431,7 +1468,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,
@@ -1460,10 +1497,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;
@@ -1482,10 +1519,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,
@@ -1548,6 +1587,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(),
@@ -1569,7 +1618,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
     };
@@ -1638,8 +1687,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"),
@@ -1689,6 +1740,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,
@@ -1991,7 +2044,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";
 function pendingDistillPath(ctx) {
   return path10.join(ctx.paths.haiveDir, ".cache", "pending-distill.json");
 }
@@ -2034,7 +2087,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",
@@ -2066,7 +2119,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",
@@ -2478,6 +2531,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."
   ),
@@ -2506,9 +2561,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()
     );
@@ -2541,10 +2598,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();
@@ -2880,7 +2938,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;
@@ -2937,7 +2995,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 {
@@ -2948,7 +3006,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) {
@@ -3139,7 +3197,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.43.2" : "dev";
 }
 
 // src/tools/code-map.ts
@@ -4312,6 +4370,7 @@ ${template}\`\`\`
 // src/prompts/bootstrap-repo.ts
 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,
@@ -4339,7 +4398,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
   });
 }
@@ -4567,7 +4626,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { hasRecentBriefingMarker, loadConfigSync } from "@hivelore/core";
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.42.1";
+var SERVER_VERSION = "0.43.2";
 function jsonResult(data) {
   return {
     content: [