@getmikk/mcp-server 1.9.2 → 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) {
@@ -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,113 +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 pathConfidence = /* @__PURE__ */ new Map();
-    const queue = changedNodeIds.map((id) => ({ id, depth: 0, confidence: 1 }));
+    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, confidence: pathConf } = queue.shift();
-      if (visited.has(current))
-        continue;
-      visited.add(current);
-      depthMap.set(current, depth);
-      pathConfidence.set(current, pathConf);
+    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") {
-          const edgeConf = edge.confidence ?? 1;
-          const newPathConf = Math.min(pathConf, edgeConf);
-          queue.push({ id: edge.source, depth: depth + 1, confidence: newPathConf });
+        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, pathConfidence),
+      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
     };
   }
-  /**
-   * Derive confidence from the actual quality of edges traversed, not from
-   * result size. A small result built from fuzzy/unresolved edges is LOW
-   * confidence; a large result built from high-confidence AST edges is HIGH.
-   *
-   * Algorithm:
-   *   - Compute the average minimum-path-confidence across all impacted nodes.
-   *   - Penalise for deep chains (they amplify uncertainty).
-   *   - Map the combined score to HIGH / MEDIUM / LOW.
-   */
-  computeConfidence(impacted, pathConfidence) {
-    if (impacted.length === 0)
-      return "high";
-    let total = 0;
-    for (const id of impacted) {
-      total += pathConfidence.get(id) ?? 1;
-    }
-    const avgConf = total / impacted.length;
-    const sizePenalty = impacted.length > 20 ? 0.15 : impacted.length > 10 ? 0.08 : 0;
-    const score = avgConf - sizePenalty;
-    if (score >= 0.75)
-      return "high";
-    if (score >= 0.5)
-      return "medium";
-    return "low";
-  }
 };
 
 // ../core/dist/graph/dead-code-detector.js
@@ -237141,10 +237348,29 @@ var DeadCodeDetector = class {
     return false;
   }
   isCalledByExportedInSameFile(fn) {
-    for (const callerId of fn.calledBy) {
-      const caller = this.lock.functions[callerId];
-      if (caller && caller.isExported && caller.file === fn.file)
-        return true;
+    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;
   }
@@ -237159,12 +237385,12 @@ var DeadCodeDetector = class {
    *  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";
-    if (DYNAMIC_USAGE_PATTERNS.some((p) => p.test(fn.name)))
-      return "low";
     return "high";
   }
   inferReason(fn) {
@@ -237221,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({
@@ -237235,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(),
@@ -237261,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(),
@@ -237269,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(),
@@ -237290,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(),
@@ -237344,6 +237593,12 @@ var MikkLockSchema = external_exports.object({
   })
 });
 
+// ../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") {
@@ -237505,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) {
@@ -237536,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 || {})) {
@@ -237545,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,
@@ -237555,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 } : {},
@@ -237625,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;
@@ -237660,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);
@@ -237721,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);
 
@@ -237732,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) {
@@ -237746,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) {
@@ -237947,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) {
@@ -237985,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())) {
@@ -238024,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)
@@ -238056,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))
@@ -238076,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,
@@ -238090,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,
@@ -238109,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
       }
     };
   }
@@ -238181,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) {
@@ -238189,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(", ")}]` : "";
@@ -238198,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}) ---`);
@@ -238465,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) {
@@ -238507,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) {
@@ -238567,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) {
@@ -238754,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();
@@ -238787,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",
@@ -238847,9 +239337,16 @@ function registerTools(server2, projectRoot) {
       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,
@@ -238859,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: [{
@@ -238877,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 = `
@@ -238884,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 }]
       };
     }
   );
@@ -238916,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,
@@ -239010,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,
@@ -239614,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 };
       }
@@ -239652,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}`,
@@ -239715,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();
@@ -239771,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: {
@@ -239792,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: {}
@@ -239801,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);
@@ -239956,7 +240496,7 @@ async function safeRead(filePath) {
 }
 
 // src/server.ts
-var VERSION = true ? "1.9.2" : "0.0.0-dev";
+var VERSION = true ? "1.10.0" : "0.0.0-dev";
 function createMikkMcpServer(projectRoot) {
   const server2 = new McpServer({
     name: "mikk",