@getmikk/mcp-server 1.9.1 → 1.10.0

package/dist/index.cjs

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -6800,6 +6803,20 @@ var require_dist = __commonJS({
   }
 });
 
+// ../core/dist/parser/base-parser.js
+var init_base_parser = __esm({
+  "../core/dist/parser/base-parser.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/hash/file-hasher.js
+var init_file_hasher = __esm({
+  "../core/dist/hash/file-hasher.js"() {
+    "use strict";
+  }
+});
+
 // ../../node_modules/.bun/typescript@5.9.3/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({
   "../../node_modules/.bun/typescript@5.9.3/node_modules/typescript/lib/typescript.js"(exports2, module2) {
@@ -15394,7 +15411,7 @@ ${lanes.join("\n")}
             writeOutputIsTTY() {
               return process.stdout.isTTY;
             },
-            readFile: readFile7,
+            readFile: readFile6,
             writeFile: writeFile22,
             watchFile: watchFile2,
             watchDirectory,
@@ -15600,7 +15617,7 @@ ${lanes.join("\n")}
               callback
             );
           }
-          function readFile7(fileName, _encoding) {
+          function readFile6(fileName, _encoding) {
             let buffer;
             try {
               buffer = _fs.readFileSync(fileName);
@@ -52040,7 +52057,7 @@ ${lanes.join("\n")}
         const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
         return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
       }
-      function parseCommandLineWorker(diagnostics, commandLine, readFile7) {
+      function parseCommandLineWorker(diagnostics, commandLine, readFile6) {
         const options = {};
         let watchOptions;
         const fileNames = [];
@@ -52088,7 +52105,7 @@ ${lanes.join("\n")}
           }
         }
         function parseResponseFile(fileName) {
-          const text = tryReadFile(fileName, readFile7 || ((fileName2) => sys.readFile(fileName2)));
+          const text = tryReadFile(fileName, readFile6 || ((fileName2) => sys.readFile(fileName2)));
           if (!isString(text)) {
             errors.push(text);
             return;
@@ -52190,8 +52207,8 @@ ${lanes.join("\n")}
         unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
         optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
       };
-      function parseCommandLine(commandLine, readFile7) {
-        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile7);
+      function parseCommandLine(commandLine, readFile6) {
+        return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile6);
       }
       function getOptionFromName(optionName, allowShort) {
         return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -52273,8 +52290,8 @@ ${lanes.join("\n")}
           watchOptionsToExtend
         );
       }
-      function readConfigFile(fileName, readFile7) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile7);
+      function readConfigFile(fileName, readFile6) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile6);
         return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
       }
       function parseConfigFileTextToJson(fileName, jsonText) {
@@ -52289,14 +52306,14 @@ ${lanes.join("\n")}
           error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
         };
       }
-      function readJsonConfigFile(fileName, readFile7) {
-        const textOrDiagnostic = tryReadFile(fileName, readFile7);
+      function readJsonConfigFile(fileName, readFile6) {
+        const textOrDiagnostic = tryReadFile(fileName, readFile6);
         return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
       }
-      function tryReadFile(fileName, readFile7) {
+      function tryReadFile(fileName, readFile6) {
         let text;
         try {
-          text = readFile7(fileName);
+          text = readFile6(fileName);
         } catch (e) {
           return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
         }
@@ -141824,12 +141841,12 @@ ${lanes.join("\n")}
       function createCompilerHost(options, setParentNodes) {
         return createCompilerHostWorker(options, setParentNodes);
       }
-      function createGetSourceFile(readFile7, setParentNodes) {
+      function createGetSourceFile(readFile6, setParentNodes) {
         return (fileName, languageVersionOrOptions, onError) => {
           let text;
           try {
             mark("beforeIORead");
-            text = readFile7(fileName);
+            text = readFile6(fileName);
             mark("afterIORead");
             measure("I/O Read", "beforeIORead", "afterIORead");
           } catch (e) {
@@ -142733,7 +142750,7 @@ ${lanes.join("\n")}
           getRedirectFromOutput,
           forEachResolvedProjectReference: forEachResolvedProjectReference2
         });
-        const readFile7 = host.readFile.bind(host);
+        const readFile6 = host.readFile.bind(host);
         (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
         (_f = tracing) == null ? void 0 : _f.pop();
@@ -142959,7 +142976,7 @@ ${lanes.join("\n")}
           shouldTransformImportCall,
           emitBuildInfo,
           fileExists: fileExists2,
-          readFile: readFile7,
+          readFile: readFile6,
           directoryExists,
           getSymlinkCache,
           realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
@@ -217133,6 +217150,34 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
   }
 });
 
+// ../core/dist/parser/tree-sitter/queries.js
+var init_queries = __esm({
+  "../core/dist/parser/tree-sitter/queries.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/parser/tree-sitter/parser.js
+var import_node_module, import_meta, getRequire, _require, ParserModule, Parser;
+var init_parser = __esm({
+  "../core/dist/parser/tree-sitter/parser.js"() {
+    "use strict";
+    import_node_module = require("node:module");
+    init_file_hasher();
+    init_base_parser();
+    init_queries();
+    import_meta = {};
+    getRequire = () => {
+      if (typeof require !== "undefined")
+        return require;
+      return (0, import_node_module.createRequire)(import_meta.url);
+    };
+    _require = getRequire();
+    ParserModule = _require("web-tree-sitter");
+    Parser = ParserModule.Parser || ParserModule;
+  }
+});
+
 // ../../node_modules/.bun/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js
 var require_array = __commonJS({
   "../../node_modules/.bun/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.js"(exports2) {
@@ -236753,11 +236798,24 @@ var fs6 = __toESM(require("node:fs/promises"), 1);
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 
-// ../core/dist/parser/typescript/ts-extractor.js
-var import_typescript = __toESM(require_typescript(), 1);
+// ../core/dist/parser/oxc-parser.js
+var import_oxc_parser = require("oxc-parser");
+init_base_parser();
 
-// ../core/dist/parser/javascript/js-extractor.js
-var import_typescript2 = __toESM(require_typescript(), 1);
+// ../core/dist/parser/oxc-resolver.js
+var import_oxc_resolver = require("oxc-resolver");
+
+// ../core/dist/parser/oxc-parser.js
+init_file_hasher();
+
+// ../core/dist/parser/go/go-parser.js
+init_base_parser();
+
+// ../core/dist/parser/go/go-extractor.js
+init_file_hasher();
+
+// ../core/dist/parser/go/go-parser.js
+init_file_hasher();
 
 // ../core/dist/utils/errors.js
 var MikkError = class extends Error {
@@ -236779,6 +236837,29 @@ var LockNotFoundError = class extends MikkError {
   }
 };
 
+// ../core/dist/parser/index.js
+init_base_parser();
+
+// ../core/dist/parser/typescript/ts-parser.js
+init_base_parser();
+
+// ../core/dist/parser/typescript/ts-extractor.js
+var import_typescript = __toESM(require_typescript(), 1);
+init_file_hasher();
+
+// ../core/dist/parser/typescript/ts-parser.js
+init_file_hasher();
+
+// ../core/dist/parser/javascript/js-parser.js
+init_base_parser();
+
+// ../core/dist/parser/javascript/js-extractor.js
+var import_typescript2 = __toESM(require_typescript(), 1);
+init_file_hasher();
+
+// ../core/dist/parser/javascript/js-parser.js
+init_file_hasher();
+
 // ../core/dist/parser/boundary-checker.js
 var path = __toESM(require("node:path"), 1);
 function stripPrefix(s) {
@@ -236839,7 +236920,10 @@ var BoundaryChecker = class {
     for (const file of Object.values(this.lock.files)) {
       if (file.moduleId === "unknown" || !file.imports?.length)
         continue;
-      for (const importedPath of file.imports) {
+      for (const imp of file.imports) {
+        const importedPath = imp.resolvedPath;
+        if (!importedPath)
+          continue;
         const importedFile = this.lock.files[importedPath];
         if (!importedFile || importedFile.moduleId === "unknown" || file.moduleId === importedFile.moduleId)
           continue;
@@ -236911,95 +236995,236 @@ var BoundaryChecker = class {
   }
 };
 
-// ../core/dist/parser/tree-sitter/parser.js
-var import_node_module = require("node:module");
-var import_meta = {};
-var getRequire = () => {
-  if (typeof require !== "undefined")
-    return require;
-  return (0, import_node_module.createRequire)(import_meta.url);
+// ../core/dist/parser/index.js
+init_parser();
+
+// ../core/dist/graph/risk-engine.js
+var RiskEngine = class {
+  graph;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  /**
+   * Compute the absolute risk score (0-100) for modifying a specific node.
+   * Formula: Base Risk = (Connected Nodes * 1.5) + (Depth * 2) + Modifiers
+   */
+  scoreNode(nodeId) {
+    const node = this.graph.nodes.get(nodeId);
+    if (!node)
+      return 0;
+    const context = this.analyzeContext(nodeId);
+    const modifiers = this.analyzeModifiers(node);
+    let score = context.connectedNodesCount * 1.5 + context.dependencyDepth * 2;
+    if (modifiers.isAuthOrSecurity)
+      score += 30;
+    if (modifiers.isDatabaseOrState)
+      score += 20;
+    if (modifiers.isPublicAPI)
+      score += 15;
+    return Math.min(Math.max(score, 0), 100);
+  }
+  analyzeContext(nodeId) {
+    const visited = /* @__PURE__ */ new Set();
+    let maxDepth = 0;
+    const queue = [{ id: nodeId, depth: 0 }];
+    let queueHead = 0;
+    visited.add(nodeId);
+    let connectedNodesCount = 0;
+    while (queueHead < queue.length) {
+      const current = queue[queueHead++];
+      maxDepth = Math.max(maxDepth, current.depth);
+      const inEdges = this.graph.inEdges.get(current.id) || [];
+      connectedNodesCount += inEdges.length;
+      for (const edge of inEdges) {
+        if (!visited.has(edge.from)) {
+          visited.add(edge.from);
+          queue.push({ id: edge.from, depth: current.depth + 1 });
+        }
+      }
+    }
+    return {
+      connectedNodesCount,
+      dependencyDepth: maxDepth
+    };
+  }
+  analyzeModifiers(node) {
+    const nameAndFile = `${node.name} ${node.file}`.toLowerCase();
+    const authKeywords = ["auth", "login", "jwt", "verify", "token", "crypt", "hash", "password"];
+    const dbKeywords = ["db", "query", "sql", "insert", "update", "delete", "redis", "cache", "transaction"];
+    return {
+      isAuthOrSecurity: authKeywords.some((kw) => nameAndFile.includes(kw)),
+      isDatabaseOrState: dbKeywords.some((kw) => nameAndFile.includes(kw)),
+      isPublicAPI: !!node.metadata?.isExported
+    };
+  }
+};
+
+// ../core/dist/graph/confidence-engine.js
+var ConfidenceEngine = class {
+  graph;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  /**
+   * Compute confidence decay along a specific path of node IDs.
+   * @param pathIds Array of node IDs forming a path (e.g. ['A', 'B', 'C'])
+   * @returns Cumulative confidence score from 0.0 to 1.0
+   */
+  calculatePathConfidence(pathIds) {
+    if (pathIds.length < 2)
+      return 1;
+    let totalConfidence = 1;
+    for (let i = 0; i < pathIds.length - 1; i++) {
+      const current = pathIds[i];
+      const next = pathIds[i + 1];
+      const outEdges = this.graph.outEdges.get(current) || [];
+      let maxEdgeConfidence = 0;
+      for (const edge of outEdges) {
+        if (edge.to === next) {
+          if (edge.confidence > maxEdgeConfidence) {
+            maxEdgeConfidence = edge.confidence;
+          }
+        }
+      }
+      if (maxEdgeConfidence === 0) {
+        return 0;
+      }
+      totalConfidence *= maxEdgeConfidence;
+    }
+    return totalConfidence;
+  }
+  /**
+   * Calculates the overall aggregated confidence for a target node
+   * by averaging the confidence of all paths leading to it.
+   */
+  calculateNodeAggregatedConfidence(paths) {
+    if (paths.length === 0)
+      return 1;
+    const pathConfidences = paths.map((path6) => this.calculatePathConfidence(path6));
+    const sum = pathConfidences.reduce((a, b) => a + b, 0);
+    return Number((sum / paths.length).toFixed(3));
+  }
 };
-var _require = getRequire();
-var ParserModule = _require("web-tree-sitter");
-var Parser = ParserModule.Parser || ParserModule;
 
 // ../core/dist/graph/impact-analyzer.js
 var ImpactAnalyzer = class {
   graph;
+  riskEngine;
+  confidenceEngine;
   constructor(graph) {
     this.graph = graph;
+    this.riskEngine = new RiskEngine(graph);
+    this.confidenceEngine = new ConfidenceEngine(graph);
   }
   /** Given a list of changed node IDs, find everything impacted */
   analyze(changedNodeIds) {
-    const visited = /* @__PURE__ */ new Set();
-    const depthMap = /* @__PURE__ */ new Map();
-    const queue = changedNodeIds.map((id) => ({ id, depth: 0 }));
+    const visited = /* @__PURE__ */ new Map();
+    const queue = changedNodeIds.map((id) => ({ id, depth: 0, path: [id], pathSet: /* @__PURE__ */ new Set([id]) }));
+    let queueHead = 0;
     let maxDepth = 0;
-    const changedSet = new Set(changedNodeIds);
-    const changedModules = /* @__PURE__ */ new Set();
-    for (const id of changedNodeIds) {
-      const node = this.graph.nodes.get(id);
-      if (node)
-        changedModules.add(node.moduleId);
-    }
-    while (queue.length > 0) {
-      const { id: current, depth } = queue.shift();
-      if (visited.has(current))
-        continue;
-      visited.add(current);
-      depthMap.set(current, depth);
+    const entryPoints = /* @__PURE__ */ new Set();
+    const criticalModules = /* @__PURE__ */ new Set();
+    while (queueHead < queue.length) {
+      const { id: current, depth, path: path6, pathSet } = queue[queueHead++];
+      if (!visited.has(current)) {
+        visited.set(current, { depth, paths: [path6] });
+      } else {
+        visited.get(current).paths.push(path6);
+        if (depth < visited.get(current).depth) {
+          visited.get(current).depth = depth;
+        }
+      }
       maxDepth = Math.max(maxDepth, depth);
+      const node = this.graph.nodes.get(current);
+      if (node?.metadata?.isExported) {
+        entryPoints.add(current);
+      }
       const dependents = this.graph.inEdges.get(current) || [];
       for (const edge of dependents) {
-        if (!visited.has(edge.source) && edge.type !== "contains") {
-          queue.push({ id: edge.source, depth: depth + 1 });
+        if (edge.type === "contains")
+          continue;
+        if (!pathSet.has(edge.from)) {
+          const newPathSet = new Set(pathSet);
+          newPathSet.add(edge.from);
+          queue.push({
+            id: edge.from,
+            depth: depth + 1,
+            path: [...path6, edge.from],
+            pathSet: newPathSet
+          });
         }
       }
     }
-    const impacted = [...visited].filter((id) => !changedSet.has(id));
+    const impactedIds = Array.from(visited.keys()).filter((id) => !changedNodeIds.includes(id));
+    let totalRisk = 0;
+    let totalConfidence = 0;
     const classified = {
       critical: [],
       high: [],
       medium: [],
       low: []
     };
-    for (const id of impacted) {
+    for (const id of impactedIds) {
+      const context = visited.get(id);
       const node = this.graph.nodes.get(id);
-      if (!node)
-        continue;
-      const depth = depthMap.get(id) ?? 999;
-      const crossesBoundary = !changedModules.has(node.moduleId);
-      const risk = depth === 1 && crossesBoundary ? "critical" : depth === 1 ? "high" : depth === 2 ? "medium" : "low";
-      const entry = {
+      let risk = this.riskEngine.scoreNode(id);
+      const reversedPaths = context.paths.map((p) => [...p].reverse());
+      const confidence = this.confidenceEngine.calculateNodeAggregatedConfidence(reversedPaths);
+      if (context.depth === 1 && node?.moduleId) {
+        const crossesBoundary = changedNodeIds.some((id2) => {
+          const changedNode = this.graph.nodes.get(id2);
+          if (!changedNode?.moduleId || !node.moduleId) {
+            return false;
+          }
+          return changedNode.moduleId !== node.moduleId;
+        });
+        if (crossesBoundary) {
+          risk = Math.max(risk, 80);
+        }
+      }
+      totalRisk += risk;
+      totalConfidence += confidence;
+      const impactEntry = {
         nodeId: id,
-        label: node.label,
-        file: node.file,
-        moduleId: node.moduleId,
-        risk,
-        depth
+        label: node?.name || "unknown",
+        file: node?.file || "unknown",
+        risk: risk >= 80 ? "CRITICAL" : risk >= 60 ? "HIGH" : risk >= 40 ? "MEDIUM" : "LOW",
+        riskScore: risk,
+        depth: context.depth
       };
-      classified[risk].push(entry);
-    }
+      if (risk >= 80)
+        classified.critical.push(impactEntry);
+      else if (risk >= 60)
+        classified.high.push(impactEntry);
+      else if (risk >= 40)
+        classified.medium.push(impactEntry);
+      else
+        classified.low.push(impactEntry);
+      if (risk > 70 && node?.moduleId) {
+        criticalModules.add(node.moduleId);
+      }
+    }
+    const avgConfidence = impactedIds.length > 0 ? totalConfidence / impactedIds.length : 1;
+    const riskScore = impactedIds.length > 0 ? Math.min(Math.max(totalRisk / impactedIds.length, 0), 100) : 0;
+    const allImpacted = [
+      ...classified.critical,
+      ...classified.high,
+      ...classified.medium,
+      ...classified.low
+    ];
     return {
       changed: changedNodeIds,
-      impacted,
+      impacted: impactedIds,
+      allImpacted,
       depth: maxDepth,
-      confidence: this.computeConfidence(impacted.length, maxDepth),
+      entryPoints: Array.from(entryPoints),
+      criticalModules: Array.from(criticalModules),
+      paths: Array.from(visited.values()).flatMap((v) => v.paths),
+      confidence: Number(avgConfidence.toFixed(3)),
+      riskScore: Math.round(riskScore),
       classified
     };
   }
-  /**
-   * How confident are we in this impact analysis?
-   * High = few nodes affected, shallow depth
-   * Low = many nodes affected, deep chains
-   */
-  computeConfidence(impactedCount, depth) {
-    if (impactedCount < 5 && depth < 3)
-      return "high";
-    if (impactedCount < 20 && depth < 6)
-      return "medium";
-    return "low";
-  }
 };
 
 // ../core/dist/graph/dead-code-detector.js
@@ -237007,7 +237232,6 @@ var ENTRY_POINT_PATTERNS = [
   /^(main|bootstrap|start|init|setup|configure|register|mount)$/i,
   /^(app|server|index|mod|program)$/i,
   /Handler$/i,
-  // Express/Koa/Hono handlers
   /Middleware$/i,
   /Controller$/i,
   /^use[A-Z]/,
@@ -237023,14 +237247,26 @@ var TEST_PATTERNS = [
   /\.spec\./,
   /__test__/
 ];
+var DYNAMIC_USAGE_PATTERNS = [
+  /^addEventListener$/i,
+  /^removeEventListener$/i,
+  /^on[A-Z]/,
+  /(invoke|dispatch|emit|call|apply)/i,
+  /^ngOnInit$/i,
+  /^componentDidMount$/i,
+  /^componentWillUnmount$/i
+];
 var DeadCodeDetector = class {
   graph;
   lock;
   routeHandlers;
+  /** Files that have at least one unresolved import (empty resolvedPath) */
+  filesWithUnresolvedImports;
   constructor(graph, lock) {
     this.graph = graph;
     this.lock = lock;
     this.routeHandlers = new Set((lock.routes ?? []).map((r) => r.handler).filter(Boolean));
+    this.filesWithUnresolvedImports = this.buildUnresolvedImportFileSet();
   }
   detect() {
     const dead = [];
@@ -237049,13 +237285,15 @@ var DeadCodeDetector = class {
         continue;
       if (this.isExempt(fn, id))
         continue;
+      const confidence = this.inferConfidence(fn);
       const entry = {
         id,
         name: fn.name,
         file: fn.file,
         moduleId,
         type: "function",
-        reason: this.inferReason(fn, id)
+        reason: this.inferReason(fn),
+        confidence
       };
       dead.push(entry);
       byModule[moduleId].dead++;
@@ -237069,9 +237307,7 @@ var DeadCodeDetector = class {
         }
         const inEdges = this.graph.inEdges.get(id) || [];
         const hasCallers = inEdges.some((e) => e.type === "calls" || e.type === "imports");
-        if (hasCallers)
-          continue;
-        if (cls.isExported)
+        if (hasCallers || cls.isExported)
           continue;
         const entry = {
           id,
@@ -237079,7 +237315,8 @@ var DeadCodeDetector = class {
           file: cls.file,
           moduleId,
           type: "class",
-          reason: "Class has no callers or importers and is not exported"
+          reason: "Class has no callers or importers and is not exported",
+          confidence: this.filesWithUnresolvedImports.has(cls.file) ? "medium" : "high"
         };
         dead.push(entry);
         byModule[moduleId].dead++;
@@ -237094,7 +237331,7 @@ var DeadCodeDetector = class {
       byModule
     };
   }
-  // ─── Exemption checks ──────────────────────────────────────────
+  // ─── Private helpers ───────────────────────────────────────────
   isExempt(fn, id) {
     if (fn.isExported)
       return true;
@@ -237106,24 +237343,85 @@ var DeadCodeDetector = class {
       return true;
     if (fn.name === "constructor" || fn.name === "__init__")
       return true;
-    if (this.isCalledByExportedInSameFile(fn, id))
+    if (this.isCalledByExportedInSameFile(fn))
       return true;
     return false;
   }
-  isCalledByExportedInSameFile(fn, fnId) {
-    for (const callerId of fn.calledBy) {
-      const caller = this.lock.functions[callerId];
-      if (caller && caller.isExported && caller.file === fn.file) {
-        return true;
+  isCalledByExportedInSameFile(fn) {
+    const file = fn.file;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [fn.id];
+    while (queue.length > 0) {
+      const currentId = queue.pop();
+      if (visited.has(currentId))
+        continue;
+      visited.add(currentId);
+      const current = this.lock.functions[currentId];
+      if (!current)
+        continue;
+      for (const callerId of current.calledBy) {
+        if (visited.has(callerId))
+          continue;
+        const caller = this.lock.functions[callerId];
+        if (!caller)
+          continue;
+        if (caller.file !== file)
+          continue;
+        if (caller.isExported)
+          return true;
+        queue.push(callerId);
       }
     }
     return false;
   }
-  inferReason(fn, id) {
+  /**
+   * Assign a confidence level to a dead code finding.
+   *
+   * Priority (first match wins):
+   *  medium — lock.calledBy has entries that didn't become graph edges:
+   *           something references this function but resolution failed.
+   *  medium — file has unresolved imports: the graph may be incomplete.
+   *  low    — function name matches common dynamic-dispatch patterns.
+   *  high   — none of the above: safe to remove.
+   */
+  inferConfidence(fn) {
+    if (DYNAMIC_USAGE_PATTERNS.some((p) => p.test(fn.name)))
+      return "low";
+    if (fn.calledBy.length > 0)
+      return "medium";
+    if (this.filesWithUnresolvedImports.has(fn.file))
+      return "medium";
+    return "high";
+  }
+  inferReason(fn) {
     if (fn.calledBy.length === 0) {
       return "No callers found anywhere in the codebase";
     }
-    return `${fn.calledBy.length} references exist but none resolved to active call edges`;
+    return `${fn.calledBy.length} reference(s) in lock but none resolved to active call edges`;
+  }
+  /**
+   * Build the set of file paths that have at least one import whose
+   * resolvedPath is empty. Used to downgrade confidence for all dead
+   * findings in those files, since the graph may be incomplete.
+   *
+   * We derive this from the lock's file entries. Each file entry stores
+   * its imports; any import with an empty resolvedPath (or no match in
+   * the graph nodes) indicates an unresolved dependency.
+   */
+  buildUnresolvedImportFileSet() {
+    const result = /* @__PURE__ */ new Set();
+    if (!this.lock.files)
+      return result;
+    for (const [filePath, fileInfo] of Object.entries(this.lock.files)) {
+      const imports = fileInfo.imports ?? [];
+      for (const imp of imports) {
+        if (!imp.resolvedPath || imp.resolvedPath === "") {
+          result.add(filePath);
+          break;
+        }
+      }
+    }
+    return result;
   }
 };
 
@@ -237149,6 +237447,19 @@ var MikkOverwriteSchema = external_exports.object({
   lastOverwrittenBy: external_exports.string().optional(),
   lastOverwrittenAt: external_exports.string().optional()
 }).default({ mode: "never", requireConfirmation: true });
+var MikkPolicySchema = external_exports.object({
+  maxRiskScore: external_exports.number().default(70),
+  maxImpactNodes: external_exports.number().default(10),
+  protectedModules: external_exports.array(external_exports.string()).default(["auth", "security", "billing"]),
+  enforceStrictBoundaries: external_exports.boolean().default(true),
+  requireReasoningForCritical: external_exports.boolean().default(true)
+}).default({
+  maxRiskScore: 70,
+  maxImpactNodes: 10,
+  protectedModules: ["auth", "security", "billing"],
+  enforceStrictBoundaries: true,
+  requireReasoningForCritical: true
+});
 var MikkContractSchema = external_exports.object({
   version: external_exports.string(),
   project: external_exports.object({
@@ -237163,7 +237474,8 @@ var MikkContractSchema = external_exports.object({
     constraints: external_exports.array(external_exports.string()).default([]),
     decisions: external_exports.array(MikkDecisionSchema).default([])
   }),
-  overwrite: MikkOverwriteSchema
+  overwrite: MikkOverwriteSchema,
+  policies: MikkPolicySchema
 });
 var MikkLockFunctionSchema = external_exports.object({
   id: external_exports.string(),
@@ -237189,7 +237501,9 @@ var MikkLockFunctionSchema = external_exports.object({
     line: external_exports.number(),
     type: external_exports.enum(["try-catch", "throw"]),
     detail: external_exports.string()
-  })).optional()
+  })).optional(),
+  confidence: external_exports.number().optional(),
+  riskScore: external_exports.number().optional()
 });
 var MikkLockModuleSchema = external_exports.object({
   id: external_exports.string(),
@@ -237197,12 +237511,17 @@ var MikkLockModuleSchema = external_exports.object({
   hash: external_exports.string(),
   fragmentPath: external_exports.string()
 });
+var MikkLockImportSchema = external_exports.object({
+  source: external_exports.string(),
+  resolvedPath: external_exports.string().optional(),
+  names: external_exports.array(external_exports.string()).optional()
+});
 var MikkLockFileSchema = external_exports.object({
   path: external_exports.string(),
   hash: external_exports.string(),
   moduleId: external_exports.string(),
   lastModified: external_exports.string(),
-  imports: external_exports.array(external_exports.string()).optional()
+  imports: external_exports.array(MikkLockImportSchema).optional()
 });
 var MikkLockClassSchema = external_exports.object({
   id: external_exports.string(),
@@ -237218,7 +237537,9 @@ var MikkLockClassSchema = external_exports.object({
     line: external_exports.number(),
     type: external_exports.enum(["try-catch", "throw"]),
     detail: external_exports.string()
-  })).optional()
+  })).optional(),
+  confidence: external_exports.number().optional(),
+  riskScore: external_exports.number().optional()
 });
 var MikkLockGenericSchema = external_exports.object({
   id: external_exports.string(),
@@ -237272,22 +237593,49 @@ var MikkLockSchema = external_exports.object({
   })
 });
 
-// ../core/dist/contract/contract-reader.js
+// ../core/dist/contract/lock-compiler.js
+init_file_hasher();
+
+// ../core/dist/hash/tree-hasher.js
+init_file_hasher();
+
+// ../core/dist/utils/json.js
 var fs = __toESM(require("node:fs/promises"), 1);
+async function readJsonSafe(filePath, fileLabel = "JSON file") {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      throw e;
+    }
+    throw new Error(`Failed to read ${fileLabel}: ${e.message}`);
+  }
+  const sanitized = content.replace(/^\uFEFF/, "");
+  try {
+    return JSON.parse(sanitized);
+  } catch (e) {
+    throw new Error(`Malformed ${fileLabel}: Syntax error - ${e.message}`);
+  }
+}
+
+// ../core/dist/contract/contract-reader.js
 var ContractReader = class {
   /** Read and validate mikk.json */
   async read(contractPath) {
-    let content;
+    let json;
     try {
-      content = await fs.readFile(contractPath, "utf-8");
-    } catch {
-      throw new ContractNotFoundError(contractPath);
+      json = await readJsonSafe(contractPath, "mikk.json");
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        throw new ContractNotFoundError(contractPath);
+      }
+      throw e;
     }
-    const json = JSON.parse(content.replace(/^\uFEFF/, ""));
     const result = MikkContractSchema.safeParse(json);
     if (!result.success) {
       const errors = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid mikk.json:
+      throw new Error(`Invalid mikk.json structure:
 ${errors}`);
     }
     return result.data;
@@ -237299,18 +237647,20 @@ var fs2 = __toESM(require("node:fs/promises"), 1);
 var LockReader = class {
   /** Read and validate mikk.lock.json */
   async read(lockPath) {
-    let content;
+    let json;
     try {
-      content = await fs2.readFile(lockPath, "utf-8");
-    } catch {
-      throw new LockNotFoundError();
+      json = await readJsonSafe(lockPath, "mikk.lock.json");
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        throw new LockNotFoundError();
+      }
+      throw e;
     }
-    const json = JSON.parse(content.replace(/^\uFEFF/, ""));
     const hydrated = hydrateLock(json);
     const result = MikkLockSchema.safeParse(hydrated);
     if (!result.success) {
       const errors = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid mikk.lock.json:
+      throw new Error(`Invalid mikk.lock.json structure:
 ${errors}`);
     }
     return result.data;
@@ -237410,8 +237760,9 @@ function compactifyLock(lock) {
     };
     if (file.moduleId && file.moduleId !== "unknown")
       c.moduleId = file.moduleId;
-    if (file.imports && file.imports.length > 0)
-      c.imports = file.imports;
+    if (file.imports && file.imports.length > 0) {
+      c.imports = file.imports.map(normalizeImportEntry);
+    }
     out.files[key] = c;
   }
   if (lock.contextFiles && lock.contextFiles.length > 0) {
@@ -237441,7 +237792,10 @@ function hydrateLock(raw) {
   const hasFnIndex = fnIndex.length > 0;
   const fileModuleMap = {};
   for (const [key, c] of Object.entries(raw.files || {})) {
-    fileModuleMap[key] = c.moduleId || "unknown";
+    const moduleId = c.moduleId || "unknown";
+    const normalizedKey = normalizeFilePath(key);
+    fileModuleMap[key] = moduleId;
+    fileModuleMap[normalizedKey] = moduleId;
   }
   out.functions = {};
   for (const [key, c] of Object.entries(raw.functions || {})) {
@@ -237450,6 +237804,7 @@ function hydrateLock(raw) {
     const lines = c.lines || [c.startLine || 0, c.endLine || 0];
     const calls = (c.calls || []).map((v) => typeof v === "number" ? fnIndex[v] ?? null : v).filter(Boolean);
     const calledBy = (c.calledBy || []).map((v) => typeof v === "number" ? fnIndex[v] ?? null : v).filter(Boolean);
+    const normalizedFile = normalizeFilePath(file);
     out.functions[fullId] = {
       id: fullId,
       name,
@@ -237460,7 +237815,7 @@ function hydrateLock(raw) {
       // P4: empty string when not stored
       calls,
       calledBy,
-      moduleId: fileModuleMap[file] || c.moduleId || "unknown",
+      moduleId: fileModuleMap[normalizedFile] || fileModuleMap[file] || c.moduleId || "unknown",
       // P6: derive from file
       ...c.params ? { params: c.params } : {},
       ...c.returnType ? { returnType: c.returnType } : {},
@@ -237530,7 +237885,7 @@ function hydrateLock(raw) {
       hash: c.hash || "",
       moduleId: c.moduleId || "unknown",
       lastModified: c.lastModified || "",
-      ...c.imports && c.imports.length > 0 ? { imports: c.imports } : {}
+      ...c.imports && c.imports.length > 0 ? { imports: c.imports.map(normalizeImportEntry) } : {}
     };
   }
   out.modules = raw.modules;
@@ -237565,6 +237920,20 @@ function parseEntityKeyFull(key) {
     name: rest.slice(lastColon + 1)
   };
 }
+function normalizeImportEntry(entry) {
+  if (!entry)
+    return { source: "" };
+  if (typeof entry === "string")
+    return { source: entry };
+  return {
+    source: entry.source,
+    resolvedPath: entry.resolvedPath || void 0,
+    names: entry.names?.length ? entry.names : void 0
+  };
+}
+function normalizeFilePath(p) {
+  return (p || "").replace(/\\/g, "/").toLowerCase();
+}
 
 // ../core/dist/contract/adr-manager.js
 var fs3 = __toESM(require("node:fs/promises"), 1);
@@ -237626,6 +237995,9 @@ var AdrManager = class {
   }
 };
 
+// ../core/dist/hash/index.js
+init_file_hasher();
+
 // ../core/dist/hash/hash-store.js
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 
@@ -237637,11 +238009,14 @@ var BM25Index = class {
   documentFrequency = /* @__PURE__ */ new Map();
   // term → how many docs contain it
   avgDocLength = 0;
+  totalDocLength = 0;
+  // running total — avoids O(n²) recompute on every addDocument
   /** Clear the index */
   clear() {
     this.documents = [];
     this.documentFrequency.clear();
     this.avgDocLength = 0;
+    this.totalDocLength = 0;
   }
   /** Add a document with pre-tokenized terms */
   addDocument(id, tokens) {
@@ -237651,7 +238026,8 @@ var BM25Index = class {
     for (const term of uniqueTerms) {
       this.documentFrequency.set(term, (this.documentFrequency.get(term) ?? 0) + 1);
     }
-    this.avgDocLength = this.documents.reduce((sum, d) => sum + d.length, 0) / this.documents.length;
+    this.totalDocLength += normalizedTokens.length;
+    this.avgDocLength = this.totalDocLength / this.documents.length;
   }
   /** Search the index and return ranked results */
   search(query, limit = 20) {
@@ -237852,25 +238228,90 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "my",
   "your"
 ]);
-function extractKeywords2(task) {
-  return task.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+var SHORT_TECH_WORDS = /* @__PURE__ */ new Set([
+  "ai",
+  "ml",
+  "ui",
+  "ux",
+  "ts",
+  "js",
+  "db",
+  "io",
+  "id",
+  "ip",
+  "ci",
+  "cd",
+  "qa",
+  "api",
+  "mcp",
+  "jwt",
+  "sql"
+]);
+function normalizeKeyword(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "");
+}
+function extractKeywords2(task, requiredKeywords = []) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of task.matchAll(/"([^"]+)"|'([^']+)'/g)) {
+    const phrase = (match[1] ?? match[2] ?? "").toLowerCase().trim();
+    if (!phrase || seen.has(phrase))
+      continue;
+    seen.add(phrase);
+    out.push(phrase);
+  }
+  const words = task.toLowerCase().replace(/[^a-z0-9\s_-]/g, " ").split(/\s+/).map(normalizeKeyword).filter((w) => {
+    if (!w || STOP_WORDS.has(w))
+      return false;
+    if (w.length > 2)
+      return true;
+    return SHORT_TECH_WORDS.has(w);
+  });
+  for (const w of words) {
+    if (seen.has(w))
+      continue;
+    seen.add(w);
+    out.push(w);
+  }
+  const expandedRequired = requiredKeywords.flatMap((item) => item.split(/[,\s]+/)).map(normalizeKeyword).filter(Boolean);
+  for (const kw of expandedRequired) {
+    if (seen.has(kw))
+      continue;
+    seen.add(kw);
+    out.push(kw);
+  }
+  return out;
 }
 function keywordScore(fn, keywords) {
   if (keywords.length === 0)
-    return 0;
+    return { score: 0, matchedKeywords: [] };
   const nameLower = fn.name.toLowerCase();
   const fileLower = fn.file.toLowerCase();
+  const fileNoExt = fileLower.replace(/\.(d\.ts|ts|tsx|js|jsx|mjs|cjs|mts|cts)\b/g, " ");
+  const purposeLower = (fn.purpose ?? "").toLowerCase();
+  const tokenSet = /* @__PURE__ */ new Set([
+    ...nameLower.match(/[a-z0-9]+/g) ?? [],
+    ...fileNoExt.match(/[a-z0-9]+/g) ?? [],
+    ...purposeLower.match(/[a-z0-9]+/g) ?? []
+  ]);
   let score = 0;
+  const matched = [];
   for (const kw of keywords) {
-    if (nameLower === kw) {
+    const shortKw = kw.length <= 2;
+    const exactName = nameLower === kw;
+    const partial2 = shortKw ? tokenSet.has(kw) : nameLower.includes(kw) || fileLower.includes(kw) || purposeLower.includes(kw);
+    if (exactName) {
       score = Math.max(score, WEIGHT.KEYWORD_EXACT);
-    } else if (nameLower.includes(kw) || fileLower.includes(kw)) {
+      matched.push(kw);
+    } else if (partial2) {
       score = Math.max(score, WEIGHT.KEYWORD_PARTIAL);
+      matched.push(kw);
     }
   }
-  return score;
+  return { score, matchedKeywords: matched };
 }
-function resolveSeeds(query, contract, lock) {
+function resolveSeeds(query, contract, lock, keywords) {
+  const strictMode = query.relevanceMode === "strict";
   const seeds = /* @__PURE__ */ new Set();
   if (query.focusFiles && query.focusFiles.length > 0) {
     for (const filePath of query.focusFiles) {
@@ -237890,14 +238331,13 @@ function resolveSeeds(query, contract, lock) {
     }
   }
   if (seeds.size === 0) {
-    const keywords = extractKeywords2(query.task);
     for (const fn of Object.values(lock.functions)) {
-      if (keywordScore(fn, keywords) >= WEIGHT.KEYWORD_PARTIAL) {
+      if (keywordScore(fn, keywords).score >= WEIGHT.KEYWORD_PARTIAL) {
         seeds.add(fn.id);
       }
     }
   }
-  if (seeds.size === 0) {
+  if (!strictMode && seeds.size === 0) {
     const taskLower = query.task.toLowerCase();
     for (const mod of contract.declared.modules) {
       if (taskLower.includes(mod.id.toLowerCase()) || taskLower.includes(mod.name.toLowerCase())) {
@@ -237929,25 +238369,72 @@ var ContextBuilder = class {
    * 6. Group survivors by module, emit structured context
    */
   build(query) {
+    const relevanceMode = query.relevanceMode ?? "balanced";
+    const strictMode = relevanceMode === "strict";
     const tokenBudget = query.tokenBudget ?? DEFAULT_TOKEN_BUDGET;
     const maxHops = query.maxHops ?? 4;
-    const seeds = resolveSeeds(query, this.contract, this.lock);
+    const requiredKeywords = query.requiredKeywords ?? [];
+    const keywords = extractKeywords2(query.task, requiredKeywords);
+    const requiredKeywordSet = new Set(requiredKeywords.flatMap((item) => item.split(/[,\s]+/)).map(normalizeKeyword).filter(Boolean));
+    const seeds = resolveSeeds(query, this.contract, this.lock, keywords);
+    const seedSet = new Set(seeds);
     const proximityMap = seeds.length > 0 ? bfsNeighbors(seeds, this.lock.functions, maxHops) : /* @__PURE__ */ new Map();
-    const keywords = extractKeywords2(query.task);
     const allFunctions = Object.values(this.lock.functions);
+    const focusFiles = query.focusFiles ?? [];
+    const focusModules = new Set(query.focusModules ?? []);
+    const requireAllKeywords = query.requireAllKeywords ?? false;
+    const minKeywordMatches = query.minKeywordMatches ?? 1;
+    const strictPassIds = /* @__PURE__ */ new Set();
+    const reasons = [];
+    const suggestions = [];
+    const nearMissSuggestions = [];
     const scored = allFunctions.map((fn) => {
       let score = 0;
       const depth = proximityMap.get(fn.id);
       if (depth !== void 0) {
         score += depthToScore(depth);
       }
-      score += keywordScore(fn, keywords);
-      if (fn.calledBy.length === 0)
+      const kwInfo = keywordScore(fn, keywords);
+      score += kwInfo.score;
+      const matchedSet = new Set(kwInfo.matchedKeywords);
+      const inFocusFile = focusFiles.some((filePath) => fn.file.includes(filePath) || filePath.includes(fn.file));
+      const inFocusModule = focusModules.has(fn.moduleId);
+      const inFocus = inFocusFile || inFocusModule;
+      const requiredPass = requiredKeywordSet.size === 0 ? true : [...requiredKeywordSet].every((kw) => matchedSet.has(kw));
+      const generalPass = requireAllKeywords ? keywords.length > 0 && matchedSet.size >= keywords.length : keywords.length === 0 ? false : matchedSet.size >= minKeywordMatches;
+      const keywordPass = requiredPass && generalPass;
+      if (keywordPass)
+        strictPassIds.add(fn.id);
+      if (strictMode) {
+        const isSeed = seedSet.has(fn.id);
+        const seedFromFocus = isSeed && (inFocus || focusFiles.length > 0 || focusModules.size > 0);
+        if (!(inFocus || keywordPass || seedFromFocus)) {
+          if (kwInfo.score > 0) {
+            nearMissSuggestions.push(`${fn.name} (${fn.file}:${fn.startLine})`);
+          }
+          return { fn, score: -1 };
+        }
+      }
+      if (!strictMode && fn.calledBy.length === 0)
         score += WEIGHT.ENTRY_POINT;
       return { fn, score };
     });
     scored.sort((a, b) => b.score - a.score);
-    const selected = [];
+    for (const { fn, score } of scored) {
+      if (score <= 0)
+        continue;
+      suggestions.push(`${fn.name} (${fn.file}:${fn.startLine})`);
+      if (suggestions.length >= 5)
+        break;
+    }
+    for (const s of nearMissSuggestions) {
+      if (suggestions.includes(s))
+        continue;
+      suggestions.push(s);
+      if (suggestions.length >= 5)
+        break;
+    }
+    let selected = [];
     let usedTokens = 0;
     for (const { fn, score } of scored) {
       if (score <= 0 && seeds.length > 0)
@@ -237961,6 +238448,51 @@ var ContextBuilder = class {
       selected.push(fn);
       usedTokens += tokens;
     }
+    if (strictMode) {
+      if (requiredKeywordSet.size > 0) {
+        reasons.push(`required terms: ${[...requiredKeywordSet].join(", ")}`);
+      }
+      if (strictPassIds.size === 0) {
+        reasons.push("no functions matched strict keyword filters");
+      }
+    }
+    if (strictMode && query.exactOnly) {
+      selected = selected.filter((fn) => strictPassIds.has(fn.id));
+      usedTokens = selected.reduce((sum, fn) => sum + estimateTokens(this.buildFunctionSnippet(fn, query)), 0);
+      if (selected.length === 0 && strictPassIds.size > 0) {
+        reasons.push("exact matches exist but did not fit token budget or max function limit");
+      }
+    }
+    if (strictMode && query.failFast && selected.length === 0) {
+      reasons.push("fail-fast enabled: returning no context when exact match set is empty");
+      return {
+        project: {
+          name: this.contract.project.name,
+          language: this.contract.project.language,
+          description: this.contract.project.description,
+          moduleCount: this.contract.declared.modules.length,
+          functionCount: Object.keys(this.lock.functions).length
+        },
+        modules: [],
+        constraints: this.contract.declared.constraints,
+        decisions: this.contract.declared.decisions.map((d) => ({
+          title: d.title,
+          reason: d.reason
+        })),
+        contextFiles: [],
+        routes: [],
+        prompt: "",
+        meta: {
+          seedCount: seeds.length,
+          totalFunctionsConsidered: allFunctions.length,
+          selectedFunctions: 0,
+          estimatedTokens: 0,
+          keywords,
+          reasons,
+          suggestions: suggestions.length > 0 ? suggestions : void 0
+        }
+      };
+    }
     const byModule = /* @__PURE__ */ new Map();
     for (const fn of selected) {
       if (!byModule.has(fn.moduleId))
@@ -237981,6 +238513,8 @@ var ContextBuilder = class {
       });
     }
     contextModules.sort((a, b) => b.functions.length - a.functions.length);
+    const contextFiles = strictMode ? [] : this.lock.contextFiles;
+    const routes = strictMode ? [] : this.lock.routes;
     return {
       project: {
         name: this.contract.project.name,
@@ -237995,12 +238529,12 @@ var ContextBuilder = class {
         title: d.title,
         reason: d.reason
       })),
-      contextFiles: this.lock.contextFiles?.map((cf) => ({
+      contextFiles: contextFiles?.map((cf) => ({
         path: cf.path,
         content: readContextFile(cf.path, query.projectRoot),
         type: cf.type
       })),
-      routes: this.lock.routes?.map((r) => ({
+      routes: routes?.map((r) => ({
         method: r.method,
         path: r.path,
         handler: r.handler,
@@ -238014,7 +238548,9 @@ var ContextBuilder = class {
         totalFunctionsConsidered: allFunctions.length,
         selectedFunctions: selected.length,
         estimatedTokens: usedTokens,
-        keywords
+        keywords,
+        reasons: reasons.length > 0 ? reasons : void 0,
+        suggestions: selected.length === 0 && suggestions.length > 0 ? suggestions : void 0
       }
     };
   }
@@ -238086,6 +238622,7 @@ var ContextBuilder = class {
   /** Generate the natural-language prompt section */
   generatePrompt(query, modules) {
     const lines = [];
+    const strictMode = query.relevanceMode === "strict";
     lines.push("=== ARCHITECTURAL CONTEXT ===");
     lines.push(`Project: ${this.contract.project.name} (${this.contract.project.language})`);
     if (this.contract.project.description) {
@@ -238094,7 +238631,7 @@ var ContextBuilder = class {
     lines.push(`Task: ${query.task}`);
     lines.push("");
     const routes = this.lock.routes;
-    if (routes && routes.length > 0) {
+    if (!strictMode && routes && routes.length > 0) {
       lines.push("=== HTTP ROUTES ===");
       for (const r of routes) {
         const mw = r.middlewares.length > 0 ? ` [${r.middlewares.join(", ")}]` : "";
@@ -238103,7 +238640,7 @@ var ContextBuilder = class {
       lines.push("");
     }
     const ctxFiles = this.lock.contextFiles;
-    if (ctxFiles && ctxFiles.length > 0) {
+    if (!strictMode && ctxFiles && ctxFiles.length > 0) {
       lines.push("=== DATA MODELS & SCHEMAS ===");
       for (const cf of ctxFiles) {
         lines.push(`--- ${cf.path} (${cf.type}) ---`);
@@ -238370,6 +238907,16 @@ var ClaudeProvider = class {
     lines.push(`  <seeds_found>${context.meta?.seedCount ?? 0}</seeds_found>`);
     lines.push(`  <functions_selected>${context.meta?.selectedFunctions ?? 0} of ${context.meta?.totalFunctionsConsidered ?? 0}</functions_selected>`);
     lines.push(`  <estimated_tokens>${context.meta?.estimatedTokens ?? 0}</estimated_tokens>`);
+    if (context.meta?.reasons && context.meta.reasons.length > 0) {
+      for (const reason of context.meta.reasons) {
+        lines.push(`  <reason>${esc2(reason)}</reason>`);
+      }
+    }
+    if (context.meta?.suggestions && context.meta.suggestions.length > 0) {
+      for (const s of context.meta.suggestions) {
+        lines.push(`  <suggestion>${esc2(s)}</suggestion>`);
+      }
+    }
     lines.push("</context_meta>");
     lines.push("");
     for (const mod of context.modules) {
@@ -238412,6 +238959,22 @@ var ClaudeProvider = class {
       lines.push("</module>");
       lines.push("");
     }
+    if (context.modules.length === 0 && context.meta?.reasons?.length) {
+      lines.push("<no_match_reason>");
+      for (const reason of context.meta.reasons) {
+        lines.push(`  <item>${esc2(reason)}</item>`);
+      }
+      lines.push("</no_match_reason>");
+      lines.push("");
+      if (context.meta.suggestions && context.meta.suggestions.length > 0) {
+        lines.push("<did_you_mean>");
+        for (const suggestion of context.meta.suggestions) {
+          lines.push(`  <item>${esc2(suggestion)}</item>`);
+        }
+        lines.push("</did_you_mean>");
+        lines.push("");
+      }
+    }
     if (context.contextFiles && context.contextFiles.length > 0) {
       lines.push("<context_files>");
       for (const cf of context.contextFiles) {
@@ -238472,6 +239035,20 @@ var CompactProvider = class {
       `Task keywords: ${context.meta?.keywords?.join(", ") ?? ""}`,
       ""
     ];
+    if (context.modules.length === 0 && context.meta?.reasons?.length) {
+      lines.push("No exact context selected:");
+      for (const reason of context.meta.reasons) {
+        lines.push(`- ${reason}`);
+      }
+      if (context.meta.suggestions && context.meta.suggestions.length > 0) {
+        lines.push("");
+        lines.push("Did you mean:");
+        for (const suggestion of context.meta.suggestions) {
+          lines.push(`- ${suggestion}`);
+        }
+      }
+      lines.push("");
+    }
     for (const mod of context.modules) {
       lines.push(`## ${mod.name}`);
       for (const fn of mod.functions) {
@@ -238659,6 +239236,22 @@ var IntentSchema = external_exports.object({
 // src/tools.ts
 var projectCache = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 3e4;
+function invalidateCache(projectRoot) {
+  projectCache.delete(projectRoot);
+}
+var MAX_SEARCHER_ROOTS = 5;
+function getSemanticSearcher(projectRoot) {
+  let s = semanticSearchers.get(projectRoot);
+  if (!s) {
+    if (semanticSearchers.size >= MAX_SEARCHER_ROOTS) {
+      const oldestKey = semanticSearchers.keys().next().value;
+      if (oldestKey !== void 0) semanticSearchers.delete(oldestKey);
+    }
+    s = new SemanticSearcher(projectRoot);
+    semanticSearchers.set(projectRoot, s);
+  }
+  return s;
+}
 var _CPT = 4;
 var _ALC = 42;
 var _tallies = /* @__PURE__ */ new Map();
@@ -238692,14 +239285,6 @@ function _track(root, raw, resp) {
   return { used, raw, saved, sessionSaved: t.saved, sessionCalls: t.calls };
 }
 var semanticSearchers = /* @__PURE__ */ new Map();
-function getSemanticSearcher(projectRoot) {
-  let s = semanticSearchers.get(projectRoot);
-  if (!s) {
-    s = new SemanticSearcher(projectRoot);
-    semanticSearchers.set(projectRoot, s);
-  }
-  return s;
-}
 function registerTools(server2, projectRoot) {
   server2.tool(
     "mikk_test_tool",
@@ -238745,16 +239330,23 @@ function registerTools(server2, projectRoot) {
   );
   server2.tool(
     "mikk_query_context",
-    "Ask an architecture question \xC3\xA2\xE2\u201A\xAC\xC2\x9D returns graph-traced context with relevant functions, files, and call chains. Use this to understand how code flows through the project.",
+    "Ask an architecture question \u2014 returns graph-traced context with relevant functions, files, and call chains. Use this to understand how code flows through the project.",
     {
       question: external_exports.string().describe("The architecture question or task description"),
       maxHops: external_exports.number().optional().default(4).describe("Graph traversal depth (default: 4)"),
       tokenBudget: external_exports.number().optional().default(6e3).describe("Max tokens for function bodies (default: 6000)"),
       focusFile: external_exports.string().optional().describe("Anchor traversal from a specific file path"),
       focusModule: external_exports.string().optional().describe("Anchor traversal from a specific module ID"),
+      strict: external_exports.boolean().optional().default(false).describe("High-precision mode: include only tightly relevant context"),
+      requiredTerms: external_exports.array(external_exports.string()).optional().describe("Required terms that must match returned context"),
+      requireAllKeywords: external_exports.boolean().optional().default(false).describe("In strict mode, require all extracted keywords"),
+      minKeywordMatches: external_exports.number().optional().default(1).describe("In strict mode, minimum keyword hits per function"),
+      exactOnly: external_exports.boolean().optional().default(false).describe("Hard gate: keep only strict keyword matches"),
+      failFast: external_exports.boolean().optional().default(false).describe("Return no context if strict filters find no exact match"),
+      autoFallback: external_exports.boolean().optional().default(true).describe("When strict mode returns empty, retry with balanced retrieval"),
       provider: external_exports.enum(["claude", "generic", "compact"]).optional().default("generic").describe("AI provider format: claude (XML tags), generic (plain), compact (minimal tokens)")
     },
-    async ({ question, maxHops, tokenBudget, focusFile, focusModule, provider }) => {
+    async ({ question, maxHops, tokenBudget, focusFile, focusModule, strict, requiredTerms, requireAllKeywords, minKeywordMatches, exactOnly, failFast, autoFallback, provider }) => {
       const { contract, lock, staleness } = await loadContractAndLock(projectRoot);
       const query = {
         task: question,
@@ -238764,10 +239356,37 @@ function registerTools(server2, projectRoot) {
         focusModules: focusModule ? [focusModule] : void 0,
         includeCallGraph: true,
         includeBodies: true,
+        relevanceMode: strict ? "strict" : "balanced",
+        requiredKeywords: requiredTerms,
+        requireAllKeywords,
+        minKeywordMatches,
+        exactOnly,
+        failFast,
         projectRoot
       };
       const builder = new ContextBuilder(contract, lock);
-      const ctx = builder.build(query);
+      let ctx = builder.build(query);
+      let fallbackUsed = false;
+      if (autoFallback !== false && strict && ctx.modules.length === 0) {
+        const relaxed = {
+          ...query,
+          relevanceMode: "balanced",
+          requiredKeywords: void 0,
+          requireAllKeywords: false,
+          minKeywordMatches: 1,
+          exactOnly: false,
+          failFast: false
+        };
+        const fallback = builder.build(relaxed);
+        if (fallback.modules.length > 0) {
+          ctx = fallback;
+          fallbackUsed = true;
+          ctx.meta.reasons = [
+            ...ctx.meta.reasons ?? [],
+            "strict query had no exact matches; returned balanced fallback context"
+          ];
+        }
+      }
       if (ctx.modules.length === 0) {
         return {
           content: [{
@@ -238782,6 +239401,7 @@ function registerTools(server2, projectRoot) {
       const warning = staleness ? `
 
 ${staleness}` : "";
+      const fallbackNote = fallbackUsed ? "Note: strict mode had no exact matches; showing balanced fallback context.\n\n" : "";
       const _rawQC = (tokenBudget ?? 6e3) * 3;
       const _tokQC = _track(projectRoot, _rawQC, output);
       const tokLine = `
@@ -238789,7 +239409,7 @@ ${staleness}` : "";
 ---
 // tokens: ${JSON.stringify(_tokQC)}`;
       return {
-        content: [{ type: "text", text: output + warning + "\n\n---\nHint: Use mikk_before_edit on any files you plan to modify, then mikk_impact_analysis to see the full blast radius." + tokLine }]
+        content: [{ type: "text", text: fallbackNote + output + warning + "\n\n---\nHint: Use mikk_before_edit on any files you plan to modify, then mikk_impact_analysis to see the full blast radius." + tokLine }]
       };
     }
   );
@@ -238821,7 +239441,7 @@ ${staleness}` : "";
       const result = analyzer.analyze(fileNodes.map((n) => n.id));
       const impactedDetails = result.impacted.slice(0, 30).map((id) => {
         const node = graph.nodes.get(id);
-        return { function: node?.label ?? id, file: node?.file ?? "", module: node?.moduleId ?? "" };
+        return { function: node?.name ?? id, file: node?.file ?? "", module: node?.moduleId ?? "" };
       });
       const response = {
         file,
@@ -238915,7 +239535,7 @@ ${staleness}` : "";
         const result = analyzer.analyze(fileFns.map((fn) => fn.id));
         const impactedDetails = result.impacted.slice(0, 20).map((id) => {
           const node = graph.nodes.get(id);
-          return { function: node?.label ?? id, file: node?.file ?? "", module: node?.moduleId ?? "" };
+          return { function: node?.name ?? id, file: node?.file ?? "", module: node?.moduleId ?? "" };
         });
         const exportedAtRisk = fileFns.filter((fn) => fn.isExported).map((fn) => ({
           name: fn.name,
@@ -238953,7 +239573,7 @@ ${staleness}` : "";
         constraintStatus: totalViolations === 0 ? "pass" : "fail",
         files: fileReports,
         warning: staleness,
-        hint: totalViolations > 0 ? "\xC3\u201A\xC2\x8F Constraint violations detected! Review the violations before proceeding. Use mikk_get_constraints for full rule context." : "All constraints satisfied. If safe, proceed with your edits."
+        hint: totalViolations > 0 ? "\u26A0 Constraint violations detected! Review the violations before proceeding. Use mikk_get_constraints for full rule context." : "All constraints satisfied. If safe, proceed with your edits."
       };
       const _rawBE = _filesTok(lock, filesToEdit) * 4;
       response.tokens = _track(projectRoot, _rawBE, response);
@@ -239087,7 +239707,7 @@ ${staleness}` : "";
           content: [{
             type: "text",
             text: [
-              "\xC3\u201A\xC2\x9D\xC3\u2026\xE2\u20AC\u2122 Semantic search requires @xenova/transformers.",
+              "\u26A0 Semantic search requires @xenova/transformers.",
               "",
               "Install it in your project root:",
               "  npm install @xenova/transformers",
@@ -239216,7 +239836,7 @@ ${content}`
   );
   server2.tool(
     "mikk_dead_code",
-    "Detect dead code \xC3\xA2\xE2\u201A\xAC\xC2\x9D functions with zero callers after exempting exports, entry points, route handlers, tests, and constructors. Use this before refactoring or cleanup.",
+    "Detect dead code \u2014 functions with zero callers after exempting exports, entry points, route handlers, tests, and constructors. Use this before refactoring or cleanup.",
     {
       moduleId: external_exports.string().optional().describe("Filter results to a specific module ID")
     },
@@ -239241,7 +239861,7 @@ ${content}`
   );
   server2.tool(
     "mikk_manage_adr",
-    "CRUD for Architectural Decision Records (ADRs) in mikk.json. Actions: list, get, add, update, remove. WHEN TO USE: When making architectural changes \xC3\xA2\xE2\u201A\xAC\xE2\u20AC\x9D document WHY so future AI agents understand. AFTER THIS: ADRs automatically surface in mikk_query_context responses. Required for add: id, title, reason.",
+    "CRUD for Architectural Decision Records (ADRs) in mikk.json. Actions: list, get, add, update, remove. WHEN TO USE: When making architectural changes \u2014 document WHY so future AI agents understand. AFTER THIS: ADRs automatically surface in mikk_query_context responses. Required for add: id, title, reason.",
     {
       action: external_exports.enum(["list", "get", "add", "update", "remove"]).describe("The CRUD action to perform"),
       id: external_exports.string().optional().describe("ADR id (required for get, update, remove)"),
@@ -239351,7 +239971,7 @@ ${content}`
   );
   server2.tool(
     "mikk_read_file",
-    "Read file scoped to specific functions. Returns bodies with metadata headers (params, calls, calledBy). WHEN TO USE: When you know which functions you need \xC3\xA2\xE2\u201A\xAC\xE2\u20AC\x9D saves tokens vs mikk_get_file. AFTER THIS: Use mikk_before_edit before making changes. TIP: This is the preferred way to read code \xC3\xA2\xE2\u201A\xAC\xE2\u20AC\x9D always specify function names when possible.",
+    "Read file scoped to specific functions. Returns bodies with metadata headers (params, calls, calledBy). WHEN TO USE: When you know which functions you need \u2014 saves tokens vs mikk_get_file. AFTER THIS: Use mikk_before_edit before making changes. TIP: This is the preferred way to read code \u2014 always specify function names when possible.",
     {
       file: external_exports.string().describe("File path relative to project root"),
       functions: external_exports.array(external_exports.string()).optional().describe("Function names to extract. If omitted, returns the whole file.")
@@ -239391,7 +240011,7 @@ ${content}` }]
           (f) => (f.name === fnName || f.name.endsWith(`.${fnName}`)) && (f.file === normalizedFile || f.file.endsWith("/" + normalizedFile))
         );
         if (!fn) {
-          sections.push(`// \xC3\u201A\xC2\x9D\xC3\u2026\xE2\u20AC\u2122 Function "${fnName}" not found in ${file}`);
+          sections.push(`// \u26A0 Function "${fnName}" not found in ${file}`);
           continue;
         }
         const header = [
@@ -239519,11 +240139,16 @@ ${staleness}` : "";
           }
         }
         const totalFns = affectedSymbols.reduce((s, f) => s + f.functions.length, 0);
-        return { content: [{ type: "text", text: JSON.stringify({
-          summary: `${affectedSymbols.length} file(s), ${totalFns} function(s) affected`,
-          affectedSymbols,
-          warning: staleness
-        }, null, 2) }] };
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              summary: `${affectedSymbols.length} file(s), ${totalFns} function(s) affected`,
+              affectedSymbols,
+              warning: staleness
+            }, null, 2)
+          }]
+        };
       } catch (err) {
         return { content: [{ type: "text", text: `Git diff failed: ${err.message}` }], isError: true };
       }
@@ -239531,7 +240156,7 @@ ${staleness}` : "";
   );
   server2.tool(
     "mikk_rename",
-    "Plan a coordinated multi-file rename. Finds all call sites and import locations for a function and provides a step-by-step edit plan. WHEN TO USE: Before renaming any function \xC3\xA2\xE2\u201A\xAC\xE2\u20AC\x9D ensures you update ALL call sites. AFTER THIS: Execute the edit plan, then run mikk analyze.",
+    "Plan a coordinated multi-file rename. Finds all call sites and import locations for a function and provides a step-by-step edit plan. WHEN TO USE: Before renaming any function \u2014 ensures you update ALL call sites. AFTER THIS: Execute the edit plan, then run mikk analyze.",
     {
       functionName: external_exports.string().describe("The current function name to rename"),
       newName: external_exports.string().describe("The desired new name")
@@ -239557,7 +240182,7 @@ ${staleness}` : "";
         lineRange: `${fn.startLine}-${fn.endLine}`
       }));
       const filesImporting = Object.values(lock.files).filter(
-        (file) => file.imports?.some((imp) => imp.includes(functionName) || imp.includes(targetFn.file))
+        (file) => file.imports?.some((imp) => imp.names.includes(functionName) || imp.source === targetFn.file)
       );
       const instructions = [
         `1. Rename definition in ${targetFn.file}:${targetFn.startLine}`,
@@ -239620,9 +240245,19 @@ ${staleness}` : "";
   );
 }
 async function loadContractAndLock(projectRoot) {
+  const lockFilePath = path4.join(projectRoot, "mikk.lock.json");
   const cached2 = projectCache.get(projectRoot);
-  if (cached2 && Date.now() - cached2.cachedAt < CACHE_TTL_MS) {
-    return { contract: cached2.contract, lock: cached2.lock, staleness: cached2.staleness };
+  if (cached2) {
+    try {
+      const stat2 = await fs6.stat(lockFilePath);
+      if (stat2.mtimeMs > cached2.cachedAt) {
+        invalidateCache(projectRoot);
+      } else if (Date.now() - cached2.cachedAt < CACHE_TTL_MS) {
+        return { contract: cached2.contract, lock: cached2.lock, staleness: cached2.staleness };
+      }
+    } catch {
+      invalidateCache(projectRoot);
+    }
   }
   const contractReader = new ContractReader();
   const lockReader = new LockReader();
@@ -239631,7 +240266,7 @@ async function loadContractAndLock(projectRoot) {
   const syncStatus = lock.syncState?.status ?? "unknown";
   let staleness = null;
   if (syncStatus === "drifted" || syncStatus === "conflict") {
-    staleness = `\xC3\u201A\xC2\x8F Lock file is ${syncStatus}. Run \`mikk analyze\` for accurate results.`;
+    staleness = `\u26A0 Lock file is ${syncStatus}. Run \`mikk analyze\` for accurate results.`;
   }
   if (!staleness) {
     const fileEntries = Object.entries(lock.files);
@@ -239654,7 +240289,7 @@ async function loadContractAndLock(projectRoot) {
       }
     }
     if (mismatched > 0) {
-      staleness = `\xC3\u201A\xC2\x8F STALE: ${mismatched} file(s) changed since last analysis (${mismatchedFiles.slice(0, 3).join(", ")}${mismatched > 3 ? "..." : ""}). Run \`mikk analyze\`.`;
+      staleness = `\u26A0 STALE: ${mismatched} file(s) changed since last analysis (${mismatchedFiles.slice(0, 3).join(", ")}${mismatched > 3 ? "..." : ""}). Run \`mikk analyze\`.`;
     }
   }
   const graph = buildGraphFromLock(lock);
@@ -239676,7 +240311,7 @@ function buildGraphFromLock(lock) {
     nodes.set(fn.id, {
       id: fn.id,
       type: "function",
-      label: fn.name,
+      name: fn.name,
       file: fn.file,
       moduleId: fn.moduleId,
       metadata: {
@@ -239697,7 +240332,7 @@ function buildGraphFromLock(lock) {
     nodes.set(file.path, {
       id: file.path,
       type: "file",
-      label: path4.basename(file.path),
+      name: path4.basename(file.path),
       file: file.path,
       moduleId: file.moduleId,
       metadata: {}
@@ -239706,7 +240341,7 @@ function buildGraphFromLock(lock) {
   for (const fn of Object.values(lock.functions)) {
     for (const calleeId of fn.calls) {
       if (!nodes.has(calleeId)) continue;
-      const edge = { source: fn.id, target: calleeId, type: "calls" };
+      const edge = { from: fn.id, to: calleeId, type: "calls", confidence: 1 };
       edges.push(edge);
       const out = outEdges.get(fn.id) ?? [];
       out.push(edge);
@@ -239726,7 +240361,7 @@ function detectCircularDeps(fns, lock) {
         const cycleStart = cyclePath.indexOf(id);
         const cycle = cyclePath.slice(cycleStart).map((cid) => lock.functions[cid]?.name ?? cid);
         cycle.push(lock.functions[id]?.name ?? id);
-        warnings.push(`\xC3\u201A\xC2\x8F Circular: ${cycle.join(" \xC3\xA2\xE2\u201A\xAC\xC2\xA0\xC3\xA2\xE2\u201A\xAC\xE2\u201E\xA2 ")}`);
+        warnings.push(`\u26A0 Circular: ${cycle.join(" -> ")}`);
         return true;
       }
       if (visited.has(id)) return false;
@@ -239861,7 +240496,7 @@ async function safeRead(filePath) {
 }
 
 // src/server.ts
-var VERSION = true ? "1.9.1" : "0.0.0-dev";
+var VERSION = true ? "1.10.0" : "0.0.0-dev";
 function createMikkMcpServer(projectRoot) {
   const server2 = new McpServer({
     name: "mikk",