@treedy/lsp-mcp 0.2.6 → 0.2.7

package/dist/index.js

@@ -22148,6 +22148,43 @@ var singletonRpcStarting = false;
 var REGISTRY_LOOKUP_TTL_MS = Number.parseInt(process.env.LSP_MCP_REGISTRY_LOOKUP_TTL_MS || "300000", 10);
 var registryLatestCache = new Map;
 var registryLatestInflight = new Map;
+var CAPABILITY_SNAPSHOT_TTL_MS = Number.parseInt(process.env.LSP_MCP_CAPABILITY_SNAPSHOT_TTL_MS || "600000", 10);
+var capabilitySnapshotStore = new Map;
+var diagnosticsDeltaStore = new Map;
+function resolveLikelyBundledBackendPath(name) {
+  const entryFile = process.argv[1] ? path2.resolve(process.argv[1]) : null;
+  if (!entryFile)
+    return null;
+  const entryDir = path2.dirname(entryFile);
+  const candidates = [
+    path2.resolve(entryDir, "bundled", name),
+    path2.resolve(entryDir, "..", "dist", "bundled", name)
+  ];
+  for (const candidate of candidates) {
+    if (fs3.existsSync(candidate))
+      return candidate;
+  }
+  return candidates[0] || null;
+}
+function loadBenchmarkReport(reportPath) {
+  if (!fs3.existsSync(reportPath)) {
+    return { found: false, path: reportPath, report: null };
+  }
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(reportPath, "utf8"));
+    if (!parsed || !Array.isArray(parsed.cases)) {
+      return { found: false, path: reportPath, report: null, error: "invalid benchmark report schema" };
+    }
+    return { found: true, path: reportPath, report: parsed };
+  } catch (error2) {
+    return { found: false, path: reportPath, report: null, error: String(error2) };
+  }
+}
+function loadLatestBenchmarkReport() {
+  const configured = process.env.LSP_MCP_BENCHMARK_REPORT_PATH || ".tmp/benchmark-latest.json";
+  const reportPath = path2.isAbsolute(configured) ? configured : path2.resolve(process.cwd(), configured);
+  return loadBenchmarkReport(reportPath);
+}
 function resolveBackendRuntimeMode3() {
   const requireBundled = (process.env.LSP_MCP_REQUIRE_BUNDLED_BACKENDS ?? "false").toLowerCase() === "true";
   if (requireBundled)
@@ -22188,6 +22225,52 @@ command timeout`.trim() });
     });
   });
 }
+function makeCapabilitySnapshotId(enabledLanguages) {
+  return `cap_${Date.now().toString(36)}_${enabledLanguages.join("-")}_${randomBytes(4).toString("hex")}`;
+}
+function readCapabilitySnapshot(id) {
+  if (!id)
+    return null;
+  const entry = capabilitySnapshotStore.get(id);
+  if (!entry)
+    return null;
+  if (entry.expiresAt <= Date.now()) {
+    capabilitySnapshotStore.delete(id);
+    return null;
+  }
+  return entry;
+}
+function cleanupCapabilitySnapshots() {
+  const now = Date.now();
+  for (const [id, entry] of capabilitySnapshotStore.entries()) {
+    if (entry.expiresAt <= now)
+      capabilitySnapshotStore.delete(id);
+  }
+}
+function withConfidenceFields(payload) {
+  if (typeof payload.confidence === "number" && typeof payload.confidence_reason === "string") {
+    return payload;
+  }
+  const errorCode = typeof payload.error_code === "string" ? payload.error_code : null;
+  const hasError = typeof payload.error === "string" && payload.error.length > 0;
+  let confidence = 0.9;
+  let reason = "Backend response appears complete and non-fallback.";
+  if (hasError) {
+    confidence = 0.2;
+    reason = `Strict error returned${errorCode ? ` (${errorCode})` : ""}; follow recovery plan before trusting result.`;
+  } else if (payload.fallback_used === true || payload.approximate === true) {
+    confidence = 0.55;
+    reason = "Fallback/approximate path used; validate with follow-up semantic call.";
+  } else if (typeof payload.count === "number" && payload.count === 0) {
+    confidence = 0.65;
+    reason = "No results found; this may be valid but should be double-checked.";
+  }
+  return {
+    ...payload,
+    confidence,
+    confidence_reason: reason
+  };
+}
 function getWorkspaceForLanguage(language) {
   return activeWorkspaceByLanguage.get(language) || null;
 }
@@ -22214,10 +22297,12 @@ var SEMANTIC_TOOL_NAMES = new Set([
   "symbols",
   "completions",
   "diagnostics",
+  "diagnostics_delta",
   "rename",
   "prepare_rename",
   "signature_help",
   "read_file_with_hints",
+  "semantic_navigate",
   "peek_definition",
   "code_action",
   "update_document",
@@ -22231,6 +22316,15 @@ function isSemanticTool(toolName) {
 }
 function semanticWorkspaceRequiredResponse(language, toolName) {
   const setupCommand = `switch_workspace_for_language(language='${language}', path='/abs/project/root')`;
+  const recoveryPlan = [{
+    step: 1,
+    action: "set_language_workspace",
+    type: "tool_call",
+    tool: "switch_workspace_for_language",
+    args: { language, path: "/abs/project/root" },
+    command: setupCommand,
+    reason: "Semantic tools require an explicit per-language workspace mapping."
+  }];
   return {
     content: [{
       type: "text",
@@ -22246,13 +22340,155 @@ function semanticWorkspaceRequiredResponse(language, toolName) {
         required_workspace_scope: "language",
         next_step: `Call ${setupCommand} before using semantic tools.`,
         install_commands: [setupCommand],
+        recovery_plan: recoveryPlan,
         missing_packages: [],
         resolved_workspace: null,
-        backend_instance_id: null
+        backend_instance_id: null,
+        result_size: 0,
+        cursor_available: false,
+        truncated: false,
+        latency_ms: null,
+        confidence: 0.25,
+        confidence_reason: "Strict workspace precondition failed; no semantic result available."
       })
     }]
   };
 }
+function parseToolLikeCommand(command) {
+  const trimmed = command.trim();
+  const match = /^([a-z_][a-z0-9_]*)\((.*)\)$/i.exec(trimmed);
+  if (!match)
+    return null;
+  const tool = match[1];
+  const argsRaw = match[2].trim();
+  if (argsRaw.length === 0)
+    return { tool, args: {} };
+  const pairs = [];
+  let current = "";
+  let depth = 0;
+  let quote = null;
+  for (const char of argsRaw) {
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      current += char;
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      current += char;
+      continue;
+    }
+    if (char === "," && depth === 0) {
+      if (current.trim().length > 0)
+        pairs.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim().length > 0)
+    pairs.push(current.trim());
+  const args = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0)
+      return null;
+    const key = pair.slice(0, idx).trim();
+    const valueRaw = pair.slice(idx + 1).trim();
+    let value = valueRaw;
+    if (valueRaw.startsWith("'") && valueRaw.endsWith("'") || valueRaw.startsWith('"') && valueRaw.endsWith('"')) {
+      value = valueRaw.slice(1, -1);
+    } else if (valueRaw === "true" || valueRaw === "false") {
+      value = valueRaw === "true";
+    } else if (/^-?\d+$/.test(valueRaw)) {
+      value = Number.parseInt(valueRaw, 10);
+    } else if (/^-?\d+\.\d+$/.test(valueRaw)) {
+      value = Number.parseFloat(valueRaw);
+    }
+    args[key] = value;
+  }
+  return { tool, args };
+}
+function buildRecoveryPlan(installCommands, nextStep) {
+  const normalized = Array.from(new Set(installCommands.map((command) => String(command || "").trim()).filter((command) => command.length > 0)));
+  if (normalized.length === 0 && nextStep.trim().length > 0) {
+    normalized.push(nextStep.trim());
+  }
+  return normalized.map((command, idx) => {
+    const parsed = parseToolLikeCommand(command);
+    return {
+      step: idx + 1,
+      action: idx === 0 ? "run_next_step" : "retry_with_followup",
+      type: parsed ? "tool_call" : "shell_command",
+      tool: parsed?.tool ?? null,
+      args: parsed?.args ?? null,
+      command,
+      reason: "Follow this command sequence to recover from strict semantic errors."
+    };
+  });
+}
+function normalizeRecoveryPlan(value, installCommands, nextStep) {
+  if (!Array.isArray(value))
+    return buildRecoveryPlan(installCommands, nextStep);
+  const out = [];
+  for (let i = 0;i < value.length; i++) {
+    const raw = value[i];
+    if (!raw || typeof raw !== "object")
+      continue;
+    const rec = raw;
+    const command = String(rec.command || "").trim();
+    const parsed = command.length > 0 ? parseToolLikeCommand(command) : null;
+    const type = rec.type === "tool_call" || rec.type === "shell_command" ? rec.type : parsed ? "tool_call" : "shell_command";
+    out.push({
+      step: typeof rec.step === "number" && Number.isFinite(rec.step) ? rec.step : i + 1,
+      action: typeof rec.action === "string" && rec.action.length > 0 ? rec.action : i === 0 ? "run_next_step" : "retry_with_followup",
+      type,
+      tool: typeof rec.tool === "string" ? rec.tool : type === "tool_call" ? parsed?.tool ?? null : null,
+      args: rec.args && typeof rec.args === "object" && !Array.isArray(rec.args) ? rec.args : type === "tool_call" ? parsed?.args ?? null : null,
+      command: command.length > 0 ? command : typeof rec.tool === "string" ? `${String(rec.tool)}(...)` : "",
+      reason: typeof rec.reason === "string" && rec.reason.length > 0 ? rec.reason : "Follow this command sequence to recover from strict semantic errors."
+    });
+  }
+  if (out.length > 0)
+    return out;
+  return buildRecoveryPlan(installCommands, nextStep);
+}
+function inferResponseResultSize(payload) {
+  if (typeof payload.count === "number" && Number.isFinite(payload.count))
+    return payload.count;
+  const arrayKeys = ["matches", "references", "diagnostics", "lines", "symbols", "hints"];
+  for (const key of arrayKeys) {
+    if (Array.isArray(payload[key]))
+      return payload[key].length;
+  }
+  if (typeof payload.result === "string")
+    return payload.result.length;
+  return 0;
+}
+function withStandardCostFields(payload) {
+  const page = payload.page && typeof payload.page === "object" ? payload.page : null;
+  const preview = payload.preview && typeof payload.preview === "object" ? payload.preview : null;
+  const hasCursor = payload.next && typeof payload.next === "object" && !!payload.next?.arguments?.cursor || page && page.has_more === true;
+  const truncated = preview && preview.truncated === true || page && page.has_more === true;
+  return {
+    ...payload,
+    result_size: typeof payload.result_size === "number" ? payload.result_size : inferResponseResultSize(payload),
+    cursor_available: typeof payload.cursor_available === "boolean" ? payload.cursor_available : !!hasCursor,
+    truncated: typeof payload.truncated === "boolean" ? payload.truncated : !!truncated,
+    latency_ms: typeof payload.latency_ms === "number" ? payload.latency_ms : null
+  };
+}
 function normalizeSemanticErrorPayload(payload, toolName, resolvedLanguage, resolvedWorkspace) {
   const rawError = payload.error;
   const hasError = typeof rawError === "string" && rawError.length > 0;
@@ -22263,17 +22499,19 @@ function normalizeSemanticErrorPayload(payload, toolName, resolvedLanguage, reso
   const nextStep = typeof payload.next_step === "string" && payload.next_step.length > 0 ? payload.next_step : resolvedLanguage && resolvedLanguage !== "multi" ? `Call switch_workspace_for_language(language='${resolvedLanguage}', path='/abs/project/root') then retry ${toolName}.` : `Retry ${toolName} after setting per-language workspace with switch_workspace_for_language(...).`;
   const installCommands = Array.isArray(payload.install_commands) ? payload.install_commands : [nextStep];
   const missingPackages = Array.isArray(payload.missing_packages) ? payload.missing_packages : [];
-  return {
+  const recoveryPlan = normalizeRecoveryPlan(payload.recovery_plan, installCommands.map((cmd) => String(cmd)), nextStep);
+  return withStandardCostFields({
     ...payload,
     error_code: normalizedCode,
     strict_mode: payload.strict_mode ?? true,
     next_step: nextStep,
     install_commands: installCommands,
+    recovery_plan: recoveryPlan,
     missing_packages: missingPackages,
     tool: payload.tool ?? toolName,
     resolved_language: payload.resolved_language ?? resolvedLanguage ?? null,
     resolved_workspace: payload.resolved_workspace ?? resolvedWorkspace ?? null
-  };
+  });
 }
 function withSemanticContext(response, toolName, resolvedWorkspace, backendInstanceId, resolvedLanguage) {
   if (!isSemanticTool(toolName))
@@ -22303,11 +22541,13 @@ function withSemanticContext(response, toolName, resolvedWorkspace, backendInsta
         }]
       };
     }
+    const parsedRecord = parsed;
+    const parsedResolvedLanguage = (typeof parsedRecord.resolved_language === "string" ? parsedRecord.resolved_language : null) || (typeof parsedRecord.language === "string" ? parsedRecord.language : null) || effectiveLanguage;
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          ...normalizeSemanticErrorPayload(parsed, toolName, parsed.resolved_language ?? parsed.language ?? effectiveLanguage, resolvedWorkspace),
+          ...withConfidenceFields(withStandardCostFields(normalizeSemanticErrorPayload(parsedRecord, toolName, parsedResolvedLanguage, resolvedWorkspace))),
           resolved_language: parsed.resolved_language ?? parsed.language ?? effectiveLanguage,
           resolved_workspace: resolvedWorkspace,
           backend_instance_id: backendInstanceId
@@ -22322,7 +22562,13 @@ function withSemanticContext(response, toolName, resolvedWorkspace, backendInsta
           result: first.text,
           resolved_language: effectiveLanguage,
           resolved_workspace: resolvedWorkspace,
-          backend_instance_id: backendInstanceId
+          backend_instance_id: backendInstanceId,
+          result_size: typeof first.text === "string" ? first.text.length : 0,
+          cursor_available: false,
+          truncated: false,
+          latency_ms: null,
+          confidence: 0.6,
+          confidence_reason: "Non-JSON response; semantic confidence is reduced."
         })
       }]
     };
@@ -22364,6 +22610,10 @@ var LLM_FEATURE_PROBE_METADATA = {
   call_hierarchy: {
     expected_latency_ms: { p50: 280, p95: 2200 },
     failure_signatures: ["NOT_IMPLEMENTED", "No call hierarchy available", "LANGUAGE_WORKSPACE_REQUIRED"]
+  },
+  type_hierarchy: {
+    expected_latency_ms: { p50: 320, p95: 2600 },
+    failure_signatures: ["NOT_IMPLEMENTED", "NO_SYMBOL_AT_POSITION", "TYPE_HIERARCHY_FALLBACK_ERROR"]
   }
 };
 var LLM_FEATURE_TARGETS = [
@@ -22372,7 +22622,8 @@ var LLM_FEATURE_TARGETS = [
   "moniker",
   "inlay_hint_resolve",
   "read_file_with_hints",
-  "call_hierarchy"
+  "call_hierarchy",
+  "type_hierarchy"
 ];
 function fileExistsSafe(p) {
   try {
@@ -22803,37 +23054,42 @@ server.registerTool("semantic_session_start", {
     resolvedLanguage = inferLanguageFromPath(abs, config2);
   }
   if (!resolvedLanguage) {
+    const nextStep2 = "Call semantic_session_start(language='typescript'|'python'|'vue', workspace='/abs/project/root').";
+    const installCommands2 = ["semantic_session_start(language='typescript', workspace='/abs/project/root')"];
     return {
       content: [{
         type: "text",
-        text: JSON.stringify({
+        text: JSON.stringify(withConfidenceFields(withStandardCostFields({
           success: false,
           error: "SEMANTIC_SESSION_LANGUAGE_REQUIRED",
           error_code: "SEMANTIC_SESSION_LANGUAGE_REQUIRED",
           message: "Unable to infer language. Provide language or a file/workspace path.",
-          next_step: "Call semantic_session_start(language='typescript'|'python'|'vue', workspace='/abs/project/root').",
-          install_commands: ["semantic_session_start(language='typescript', workspace='/abs/project/root')"],
+          next_step: nextStep2,
+          install_commands: installCommands2,
+          recovery_plan: buildRecoveryPlan(installCommands2, nextStep2),
           missing_packages: [],
           strict_mode: true
-        })
+        })))
       }]
     };
   }
   if (!config2.languages[resolvedLanguage]?.enabled) {
+    const nextStep2 = `Set LSP_MCP_${resolvedLanguage.toUpperCase()}_ENABLED=true and restart server.`;
     return {
       content: [{
         type: "text",
-        text: JSON.stringify({
+        text: JSON.stringify(withConfidenceFields(withStandardCostFields({
           success: false,
           error: "LANGUAGE_DISABLED",
           error_code: "LANGUAGE_DISABLED",
           language: resolvedLanguage,
           message: `Language '${resolvedLanguage}' is disabled in current config.`,
-          next_step: `Set LSP_MCP_${resolvedLanguage.toUpperCase()}_ENABLED=true and restart server.`,
+          next_step: nextStep2,
           install_commands: [],
+          recovery_plan: buildRecoveryPlan([], nextStep2),
           missing_packages: [],
           strict_mode: true
-        })
+        })))
       }]
     };
   }
@@ -22982,10 +23238,11 @@ server.registerTool("semantic_session_start", {
     fallback_command: sampleHover
   });
   const success = !!resolvedWorkspace && dependencyStatus === "ok" && (!shouldStartBackend || backendStarted);
+  const nextStep = success ? commands[commands.length - 1] : installCommands[0] || commands[0];
   return {
     content: [{
       type: "text",
-      text: JSON.stringify({
+      text: JSON.stringify(withConfidenceFields(withStandardCostFields({
         success,
         language: resolvedLanguage,
         resolved_language: resolvedLanguage,
@@ -22999,21 +23256,522 @@ server.registerTool("semantic_session_start", {
         strict_mode: true,
         commands,
         feature_probe_sequence: probeSteps,
-        next_step: success ? commands[commands.length - 1] : installCommands[0] || commands[0]
-      })
+        next_step: nextStep,
+        recovery_plan: success ? [] : buildRecoveryPlan(installCommands, nextStep)
+      })))
     }]
   };
 });
+server.registerTool("semantic_navigate", {
+  description: "Run an LLM-oriented semantic workflow in one call: optional search -> definition -> references -> read_file_with_hints.",
+  inputSchema: {
+    file: exports_external.string(),
+    line: exports_external.number().int().positive(),
+    column: exports_external.number().int().positive(),
+    mode: exports_external.enum(["fast", "deep"]).default("deep").optional(),
+    strategy: exports_external.enum(["balanced", "definition_first", "references_first"]).default("balanced").optional(),
+    query: exports_external.string().optional(),
+    page_size: exports_external.number().int().positive().max(200).default(20).optional(),
+    hint_start_line: exports_external.number().int().positive().default(1).optional(),
+    hint_max_lines: exports_external.number().int().positive().max(400).default(120).optional(),
+    reference_preview: exports_external.number().int().positive().max(200).default(20).optional()
+  }
+}, async ({ file, line, column, mode, strategy, query, page_size, hint_start_line, hint_max_lines, reference_preview }) => {
+  const startedAt = Date.now();
+  const navigateMode = mode === "fast" ? "fast" : "deep";
+  const navigateStrategy = strategy === "definition_first" || strategy === "references_first" ? strategy : "balanced";
+  const absFile = path2.isAbsolute(file) ? file : activeWorkspacePath ? path2.join(activeWorkspacePath, file) : path2.resolve(file);
+  const language = inferLanguageFromPath(absFile, config2);
+  if (!language) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(withConfidenceFields(withStandardCostFields({
+          error: "UNSUPPORTED_FILE_TYPE",
+          error_code: "UNSUPPORTED_FILE_TYPE",
+          message: `Cannot infer language for '${file}'.`,
+          next_step: "Provide a file path with a supported extension.",
+          recovery_plan: [{
+            step: 1,
+            action: "provide_supported_file",
+            type: "tool_call",
+            tool: "semantic_navigate",
+            args: { file: "/abs/path/to/file.ts|.py|.vue", line: 1, column: 1 },
+            command: "semantic_navigate(file='/abs/path/to/file.ts|.py|.vue', line=1, column=1)",
+            reason: "semantic_navigate requires a resolvable source file."
+          }],
+          strict_mode: true
+        })))
+      }]
+    };
+  }
+  const workspace = getWorkspaceForLanguage(language);
+  if (!workspace) {
+    return semanticWorkspaceRequiredResponse(language, "semantic_navigate");
+  }
+  const singletonLock = await ensureBackendSingleton(language, workspace);
+  if (!singletonLock.ok) {
+    return withSemanticContext(singletonLock.response, "semantic_navigate", workspace, null, language);
+  }
+  const proxyHost = singletonLock.proxyHost;
+  const proxyPort = singletonLock.proxyPort;
+  const backendInstanceId = proxyHost && proxyPort ? `proxy:${language}@${proxyHost}:${proxyPort}` : backendManager.getBackendIdentity(language)?.instanceId ?? null;
+  const callBackendTool = (toolName, backendArgs) => {
+    if (proxyHost && proxyPort) {
+      return callRemoteBackendTool(proxyHost, proxyPort, language, toolName, backendArgs, workspace);
+    }
+    return backendManager.callTool(language, toolName, backendArgs);
+  };
+  if (!proxyHost && !proxyPort && !startedBackends.has(language)) {
+    await backendManager.getBackend(language);
+    startedBackends.add(language);
+    await backendManager.callTool(language, "switch_workspace", { path: workspace });
+  }
+  const parseToolPayload = (response) => {
+    const text = response.content?.[0]?.text ?? "{}";
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { result: text };
+    }
+  };
+  const workflowSteps = {};
+  const runStep = async (stepName, toolName, toolArgs, fallbackResult = {}) => {
+    const stepStarted = Date.now();
+    try {
+      const payload = parseToolPayload(await callBackendTool(toolName, toolArgs));
+      if (payload && typeof payload === "object" && payload.error) {
+        workflowSteps[stepName] = {
+          status: "error",
+          tool: toolName,
+          latency_ms: Date.now() - stepStarted,
+          error: payload.error,
+          error_code: payload.error_code || "STEP_ERROR",
+          next_step: payload.next_step || `Retry ${toolName}.`
+        };
+        return { ok: false, payload };
+      }
+      workflowSteps[stepName] = {
+        status: "ok",
+        tool: toolName,
+        latency_ms: Date.now() - stepStarted,
+        ...payload || fallbackResult
+      };
+      return { ok: true, payload };
+    } catch (error2) {
+      workflowSteps[stepName] = {
+        status: "error",
+        tool: toolName,
+        latency_ms: Date.now() - stepStarted,
+        error: String(error2),
+        error_code: "STEP_EXCEPTION"
+      };
+      return { ok: false, payload: { error: String(error2), error_code: "STEP_EXCEPTION" } };
+    }
+  };
+  const stepOrder = [];
+  if (typeof query === "string" && query.trim().length > 0) {
+    stepOrder.push("search");
+    const searchRes = await runStep("search", "search", {
+      pattern: query.trim(),
+      path: workspace,
+      page_size: typeof page_size === "number" ? page_size : 20
+    });
+    if (searchRes.ok && searchRes.payload && typeof searchRes.payload === "object") {
+      const items = extractSearchLikeItems(searchRes.payload);
+      workflowSteps.search = {
+        ...workflowSteps.search,
+        count: extractSearchLikeCount(searchRes.payload, items),
+        preview: items.slice(0, typeof page_size === "number" ? page_size : 20),
+        cursor_available: !!searchRes.payload?.next?.arguments?.cursor,
+        truncated: !!searchRes.payload?.page?.has_more
+      };
+    }
+  }
+  let definitionRes = { ok: false, payload: {} };
+  let referencesRes = { ok: false, payload: {} };
+  const runDefinition = async () => {
+    stepOrder.push("definition");
+    definitionRes = await runStep("definition", "definition", { file: absFile, line, column });
+  };
+  const runReferences = async () => {
+    stepOrder.push("references");
+    referencesRes = await runStep("references", "references", {
+      file: absFile,
+      line,
+      column,
+      page_size: typeof reference_preview === "number" ? reference_preview : navigateMode === "fast" ? 10 : 20
+    });
+  };
+  if (navigateStrategy === "references_first") {
+    await runReferences();
+    await runDefinition();
+  } else if (navigateStrategy === "definition_first") {
+    await runDefinition();
+    await runReferences();
+  } else {
+    await runDefinition();
+    await runReferences();
+  }
+  let hintsRes = { ok: false, payload: {} };
+  const runHints = navigateMode === "deep" || typeof hint_start_line === "number" || typeof hint_max_lines === "number";
+  if (runHints) {
+    hintsRes = await runStep("read_file_with_hints", "read_file_with_hints", {
+      file: absFile,
+      start_line: typeof hint_start_line === "number" ? hint_start_line : 1,
+      max_lines: typeof hint_max_lines === "number" ? hint_max_lines : 120
+    });
+  } else {
+    workflowSteps.read_file_with_hints = {
+      status: "skipped",
+      tool: "read_file_with_hints",
+      reason: "Skipped in fast mode to reduce payload and latency."
+    };
+  }
+  const referencesPayload = referencesRes.payload && typeof referencesRes.payload === "object" ? referencesRes.payload : {};
+  const referenceItems = extractReferencesItems(referencesPayload);
+  const referenceCount = extractReferencesCount(referencesPayload, referenceItems);
+  const ok = Boolean(definitionRes.ok || referencesRes.ok || hintsRes.ok);
+  const nextStep = ok ? navigateMode === "fast" ? "For richer context, rerun semantic_navigate(mode='deep', ...) before refactors." : "Continue with code_action/rename based on references and hints." : `Retry semantic_navigate after running doctor(probe_backends=true) and checking workspace/dependencies for '${language}'.`;
+  const recoveryPlan = ok ? [] : buildRecoveryPlan([`doctor(probe_backends=true, check_latest_versions=true)`, `switch_workspace_for_language(language='${language}', path='${workspace}')`], nextStep);
+  const result = withConfidenceFields(withStandardCostFields({
+    ok,
+    tool: "semantic_navigate",
+    strict_mode: true,
+    mode: navigateMode,
+    strategy: navigateStrategy,
+    file: absFile,
+    position: { line, column },
+    resolved_language: language,
+    resolved_workspace: workspace,
+    backend_instance_id: backendInstanceId,
+    steps: workflowSteps,
+    summary: {
+      mode: navigateMode,
+      strategy: navigateStrategy,
+      step_order: stepOrder,
+      references_count: referenceCount,
+      definition_ok: definitionRes.ok,
+      references_ok: referencesRes.ok,
+      hints_ok: hintsRes.ok
+    },
+    next_step: nextStep,
+    recovery_plan: recoveryPlan,
+    latency_ms: Date.now() - startedAt,
+    result_size: referenceCount,
+    cursor_available: !!referencesPayload?.next?.arguments?.cursor,
+    truncated: !!referencesPayload?.page?.has_more
+  }));
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }]
+  };
+});
+server.registerTool("diagnostics_delta", {
+  description: "Run diagnostics and return delta against previous diagnostics snapshot for the same language/workspace/path.",
+  inputSchema: {
+    path: exports_external.string(),
+    summary_only: exports_external.boolean().default(false).optional(),
+    preview_limit: exports_external.number().int().positive().default(100).optional(),
+    hotspot_limit: exports_external.number().int().positive().max(50).default(5).optional(),
+    severity: exports_external.enum(["error", "warning", "information", "hint"]).optional(),
+    source: exports_external.string().optional(),
+    page_size: exports_external.number().int().positive().max(500).default(100).optional(),
+    cursor: exports_external.string().optional()
+  }
+}, async ({ path: targetPath, summary_only, preview_limit, hotspot_limit, severity, source, page_size, cursor }) => {
+  const pageSize = typeof page_size === "number" ? page_size : 100;
+  const hotspotLimit = typeof hotspot_limit === "number" ? hotspot_limit : 5;
+  if (typeof cursor === "string") {
+    const page = readCursorPage("diagnostics_delta", cursor, pageSize);
+    if (!page.ok) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(withConfidenceFields(withStandardCostFields({
+            ok: false,
+            tool: "diagnostics_delta",
+            strict_mode: true,
+            error: page.data.error || "INVALID_CURSOR",
+            error_code: "INVALID_CURSOR",
+            next_step: "Call diagnostics_delta(path=...) again without cursor to create a new baseline page.",
+            cursor_available: false,
+            truncated: false,
+            result_size: 0
+          })))
+        }]
+      };
+    }
+    const items = Array.isArray(page.data.items) ? page.data.items : [];
+    const summary = page.data.summary || {};
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(withConfidenceFields(withStandardCostFields({
+          ok: true,
+          tool: "diagnostics_delta",
+          strict_mode: true,
+          page: page.data.page,
+          count: page.data.count ?? items.length,
+          delta: {
+            ...summary.delta || {},
+            changes_page: items
+          },
+          next_step: page.data.page?.has_more ? "Use expand_result(cursor=...) or diagnostics_delta(cursor=...) to continue paged diagnostics changes." : "Call diagnostics_delta again after edits to get new incremental diagnostics changes."
+        })))
+      }]
+    };
+  }
+  const absPath = path2.isAbsolute(targetPath) ? targetPath : activeWorkspacePath ? path2.join(activeWorkspacePath, targetPath) : path2.resolve(targetPath);
+  const language = inferLanguageFromPath(absPath, config2);
+  if (!language) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(withConfidenceFields(withStandardCostFields({
+          error: "UNSUPPORTED_FILE_TYPE",
+          error_code: "UNSUPPORTED_FILE_TYPE",
+          message: `Cannot infer language for '${targetPath}'.`,
+          strict_mode: true,
+          next_step: "Provide a file/path with a supported extension for diagnostics_delta.",
+          recovery_plan: [{
+            step: 1,
+            action: "provide_supported_path",
+            type: "tool_call",
+            tool: "diagnostics_delta",
+            args: { path: "/abs/path/to/file.ts|.py|.vue" },
+            command: "diagnostics_delta(path='/abs/path/to/file.ts|.py|.vue')",
+            reason: "diagnostics_delta needs a language-resolvable file or directory."
+          }],
+          ...withStandardCostFields({ result_size: 0, cursor_available: false, truncated: false, latency_ms: null })
+        })))
+      }]
+    };
+  }
+  const workspace = getWorkspaceForLanguage(language);
+  if (!workspace) {
+    return semanticWorkspaceRequiredResponse(language, "diagnostics_delta");
+  }
+  const startedAt = Date.now();
+  const singletonLock = await ensureBackendSingleton(language, workspace);
+  if (!singletonLock.ok) {
+    return withSemanticContext(singletonLock.response, "diagnostics_delta", workspace, null, language);
+  }
+  const proxyHost = singletonLock.proxyHost;
+  const proxyPort = singletonLock.proxyPort;
+  const backendInstanceId = proxyHost && proxyPort ? `proxy:${language}@${proxyHost}:${proxyPort}` : backendManager.getBackendIdentity(language)?.instanceId ?? null;
+  const callBackendTool = (toolName, backendArgs) => {
+    if (proxyHost && proxyPort) {
+      return callRemoteBackendTool(proxyHost, proxyPort, language, toolName, backendArgs, workspace);
+    }
+    return backendManager.callTool(language, toolName, backendArgs);
+  };
+  if (!proxyHost && !proxyPort && !startedBackends.has(language)) {
+    await backendManager.getBackend(language);
+    startedBackends.add(language);
+    await backendManager.callTool(language, "switch_workspace", { path: workspace });
+  }
+  try {
+    const diagnosticsRes = await callBackendTool("diagnostics", {
+      path: absPath,
+      summary_only: !!summary_only
+    });
+    const parsed = JSON.parse(diagnosticsRes.content?.[0]?.text || "{}");
+    const diagnostics = extractDiagnosticsItems(parsed);
+    const currentByFingerprint = new Map;
+    for (const diag of diagnostics) {
+      currentByFingerprint.set(fingerprintDiagnostic(diag), diag);
+    }
+    const cacheKey = `${language}:${workspace}:${absPath}`;
+    const previous = diagnosticsDeltaStore.get(cacheKey);
+    const previousByFingerprint = new Map;
+    for (const diag of previous?.diagnostics || []) {
+      previousByFingerprint.set(fingerprintDiagnostic(diag), diag);
+    }
+    const added = [];
+    const removed = [];
+    for (const [fp, diag] of currentByFingerprint.entries()) {
+      if (!previousByFingerprint.has(fp))
+        added.push(diag);
+    }
+    for (const [fp, diag] of previousByFingerprint.entries()) {
+      if (!currentByFingerprint.has(fp))
+        removed.push(diag);
+    }
+    const levelMap = {
+      error: 1,
+      warning: 2,
+      information: 3,
+      hint: 4
+    };
+    const severityCode = severity ? levelMap[severity] : null;
+    const applyFilters = (diag) => {
+      if (typeof severityCode === "number" && Number(diag.severity ?? 0) !== severityCode)
+        return false;
+      if (typeof source === "string" && source.trim().length > 0) {
+        const src = String(diag.source ?? "").toLowerCase();
+        if (!src.includes(source.trim().toLowerCase()))
+          return false;
+      }
+      return true;
+    };
+    const filteredAdded = added.filter(applyFilters);
+    const filteredRemoved = removed.filter(applyFilters);
+    const deltaChanges = [
+      ...filteredAdded.map((diag) => ({ kind: "added", diagnostic: diag })),
+      ...filteredRemoved.map((diag) => ({ kind: "removed", diagnostic: diag }))
+    ];
+    const resolveDiagFile = (diag) => {
+      const file = String(diag.file || diag.path || "").trim();
+      if (file.length > 0)
+        return file;
+      const uri = String(diag.uri || "").trim();
+      if (uri.startsWith("file://")) {
+        try {
+          return decodeURIComponent(uri.replace("file://", ""));
+        } catch {
+          return uri;
+        }
+      }
+      return absPath;
+    };
+    const resolveDiagSeverity = (diag) => {
+      const code = Number(diag.severity ?? 0);
+      if (code === 1)
+        return "error";
+      if (code === 2)
+        return "warning";
+      if (code === 3)
+        return "information";
+      if (code === 4)
+        return "hint";
+      return "unknown";
+    };
+    const fileSummaryMap = new Map;
+    for (const diag of diagnostics) {
+      const file = resolveDiagFile(diag);
+      const sev = resolveDiagSeverity(diag);
+      const row = fileSummaryMap.get(file) || {
+        file,
+        current_count: 0,
+        added_count: 0,
+        removed_count: 0,
+        by_severity: {}
+      };
+      row.current_count += 1;
+      row.by_severity[sev] = (row.by_severity[sev] || 0) + 1;
+      fileSummaryMap.set(file, row);
+    }
+    for (const diag of filteredAdded) {
+      const file = resolveDiagFile(diag);
+      const row = fileSummaryMap.get(file) || {
+        file,
+        current_count: 0,
+        added_count: 0,
+        removed_count: 0,
+        by_severity: {}
+      };
+      row.added_count += 1;
+      fileSummaryMap.set(file, row);
+    }
+    for (const diag of filteredRemoved) {
+      const file = resolveDiagFile(diag);
+      const row = fileSummaryMap.get(file) || {
+        file,
+        current_count: 0,
+        added_count: 0,
+        removed_count: 0,
+        by_severity: {}
+      };
+      row.removed_count += 1;
+      fileSummaryMap.set(file, row);
+    }
+    const file_summary = Array.from(fileSummaryMap.values()).sort((a, b) => b.current_count + b.added_count - (a.current_count + a.added_count));
+    const top_hotspots = file_summary.slice(0, hotspotLimit);
+    diagnosticsDeltaStore.set(cacheKey, {
+      updatedAt: Date.now(),
+      diagnostics
+    });
+    const limit = typeof preview_limit === "number" ? preview_limit : 100;
+    const deltaCursor = deltaChanges.length > limit ? makeCursor("diagnostics_delta", deltaChanges, deltaChanges.length, {
+      delta: {
+        previous_count: previous?.diagnostics.length ?? 0,
+        current_count: diagnostics.length,
+        added_count: filteredAdded.length,
+        removed_count: filteredRemoved.length,
+        baseline_created: !previous,
+        baseline_updated_at: previous?.updatedAt ?? null,
+        file_summary,
+        top_hotspots,
+        filters: {
+          severity: severity ?? null,
+          source: source ?? null
+        }
+      }
+    }) : null;
+    const deltaPayload = withConfidenceFields(withStandardCostFields({
+      ok: true,
+      tool: "diagnostics_delta",
+      strict_mode: true,
+      path: absPath,
+      resolved_language: language,
+      resolved_workspace: workspace,
+      backend_instance_id: backendInstanceId,
+      delta: {
+        previous_count: previous?.diagnostics.length ?? 0,
+        current_count: diagnostics.length,
+        added_count: filteredAdded.length,
+        removed_count: filteredRemoved.length,
+        added_preview: filteredAdded.slice(0, limit),
+        removed_preview: filteredRemoved.slice(0, limit),
+        changes_page: deltaChanges.slice(0, limit),
+        baseline_created: !previous,
+        baseline_updated_at: previous?.updatedAt ?? null,
+        file_summary,
+        top_hotspots,
+        filters: {
+          hotspot_limit: hotspotLimit,
+          severity: severity ?? null,
+          source: source ?? null
+        }
+      },
+      next_step: "Call diagnostics_delta again after edits to get incremental diagnostics changes.",
+      fallback_used: false,
+      approximate: false,
+      latency_ms: Date.now() - startedAt,
+      result_size: diagnostics.length,
+      cursor_available: !!deltaCursor,
+      truncated: deltaChanges.length > limit,
+      next: deltaCursor ? { tool: "diagnostics_delta", arguments: { cursor: deltaCursor, page_size: pageSize } } : null
+    }));
+    return { content: [{ type: "text", text: JSON.stringify(deltaPayload) }] };
+  } catch (error2) {
+    return withSemanticContext({
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: String(error2),
+          error_code: "DIAGNOSTICS_DELTA_ERROR",
+          strict_mode: true,
+          next_step: "Retry diagnostics_delta or run diagnostics(path=...) directly.",
+          install_commands: [],
+          missing_packages: []
+        })
+      }]
+    }, "diagnostics_delta", workspace, backendInstanceId, language);
+  }
+});
 server.registerTool("doctor", {
   description: "Run environment and backend readiness checks for out-of-box troubleshooting.",
   inputSchema: {
     probe_backends: exports_external.boolean().default(false).optional(),
     check_latest_versions: exports_external.boolean().default(false).optional(),
+    capability_snapshot_id: exports_external.string().optional(),
     page_size: exports_external.number().int().positive().default(50).optional(),
     cursor: exports_external.string().optional()
   }
-}, async ({ probe_backends, check_latest_versions, page_size, cursor }) => {
+}, async ({ probe_backends, check_latest_versions, capability_snapshot_id, page_size, cursor }) => {
   const pageSize = typeof page_size === "number" ? page_size : 50;
+  cleanupCapabilitySnapshots();
   if (typeof cursor === "string") {
     const page = readCursorPage("doctor", cursor, pageSize);
     if (!page.ok) {
@@ -23062,6 +23820,115 @@ server.registerTool("doctor", {
     uv: checkCommand("uv"),
     bun: checkCommand("bun")
   };
+  const latestBenchmark = loadLatestBenchmarkReport();
+  const benchmarkInsights = (() => {
+    if (!latestBenchmark.found || !latestBenchmark.report) {
+      return {
+        found: false,
+        path: latestBenchmark.path,
+        error: latestBenchmark.error || null,
+        next_step: `Run \`bun run benchmark:report\` to generate ${latestBenchmark.path}.`
+      };
+    }
+    const report = latestBenchmark.report;
+    const cases = Array.isArray(report.cases) ? report.cases : [];
+    const baselineConfigured = process.env.LSP_MCP_BENCHMARK_BASELINE_PATH || ".tmp/benchmark-baseline.json";
+    const baselinePath = path2.isAbsolute(baselineConfigured) ? baselineConfigured : path2.resolve(process.cwd(), baselineConfigured);
+    const baseline = loadBenchmarkReport(baselinePath);
+    const baselineCases = baseline.report?.cases || [];
+    const baselineMap = new Map(baselineCases.map((c) => [c.id, c]));
+    const trendPairs = cases.map((curr) => {
+      const prev = baselineMap.get(curr.id);
+      if (!prev || prev.latency_ms <= 0)
+        return null;
+      const deltaMs = curr.latency_ms - prev.latency_ms;
+      const deltaPct = deltaMs / prev.latency_ms * 100;
+      return {
+        id: curr.id,
+        tool: curr.tool,
+        current_latency_ms: curr.latency_ms,
+        baseline_latency_ms: prev.latency_ms,
+        delta_ms: deltaMs,
+        delta_pct: Math.round(deltaPct * 10) / 10
+      };
+    }).filter((v) => !!v);
+    const regressions = trendPairs.filter((p) => p.delta_pct > 20 && p.delta_ms > 50).sort((a, b) => b.delta_pct - a.delta_pct);
+    const improvements = trendPairs.filter((p) => p.delta_pct < -20 && p.delta_ms < -50).sort((a, b) => a.delta_pct - b.delta_pct);
+    const slowCases = [...cases].filter((c) => typeof c.latency_ms === "number" && c.latency_ms >= 1200).sort((a, b) => b.latency_ms - a.latency_ms).slice(0, 5);
+    const errorCases = cases.filter((c) => !c.ok);
+    const tokenHeavyCases = cases.filter((c) => c.truncated || c.cursor_available || c.result_size > 400);
+    const totalLatency = report.summary?.total_latency_ms ?? cases.reduce((sum, c) => sum + (Number(c.latency_ms) || 0), 0);
+    const budgetStatus = regressions.length > 0 ? "regressed" : errorCases.length > 0 ? "degraded" : totalLatency > 6000 ? "high_latency" : "healthy";
+    return {
+      found: true,
+      path: latestBenchmark.path,
+      generated_at: report.generated_at,
+      total_cases: report.summary?.total_cases ?? cases.length,
+      ok_cases: report.summary?.ok_cases ?? cases.filter((c) => c.ok).length,
+      error_cases: report.summary?.error_cases ?? errorCases.length,
+      total_latency_ms: totalLatency,
+      budget_status: budgetStatus,
+      trend: {
+        baseline_found: baseline.found,
+        baseline_path: baseline.path,
+        compared_cases: trendPairs.length,
+        regressions_count: regressions.length,
+        improvements_count: improvements.length,
+        regressions: regressions.slice(0, 5),
+        improvements: improvements.slice(0, 5)
+      },
+      slow_cases: slowCases,
+      token_heavy_cases: tokenHeavyCases.slice(0, 5),
+      recommended_mode: totalLatency > 6000 ? "semantic_navigate(mode='fast')" : "semantic_navigate(mode='deep')",
+      next_step: regressions.length > 0 ? "Benchmark regressed vs baseline; review regressions before changing LLM defaults." : errorCases.length > 0 ? "Investigate failed benchmark cases before trusting semantic automation." : "Use slow_cases and token_heavy_cases to set default mode/strategy for LLM workflows."
+    };
+  })();
+  const llmSemanticDefaults = (() => {
+    const found = !!benchmarkInsights.found;
+    const budget = String(benchmarkInsights.budget_status || "unknown");
+    const tokenHeavyCount = Array.isArray(benchmarkInsights.token_heavy_cases) ? benchmarkInsights.token_heavy_cases.length : 0;
+    const slowCaseIds = new Set(Array.isArray(benchmarkInsights.slow_cases) ? benchmarkInsights.slow_cases.map((c) => String(c.id || "")) : []);
+    const mode = budget === "high_latency" || budget === "degraded" || budget === "regressed" ? "fast" : "deep";
+    const strategy = slowCaseIds.has("semantic_navigate_references_first_fast") ? "definition_first" : slowCaseIds.has("semantic_navigate_definition_first_fast") ? "references_first" : "balanced";
+    const pageSize2 = mode === "fast" || tokenHeavyCount > 0 ? 20 : 50;
+    const referencePreview = mode === "fast" ? 10 : 20;
+    const hintMaxLines = mode === "fast" ? 60 : 120;
+    const diagnosticsPageSize = mode === "fast" ? 50 : 100;
+    const diagnosticsPreviewLimit = mode === "fast" ? 50 : 100;
+    const diagnosticsHotspotLimit = mode === "fast" ? 5 : 10;
+    const rationale = [];
+    if (!found)
+      rationale.push("No benchmark report found; using conservative defaults.");
+    if (budget === "regressed")
+      rationale.push("Regression vs baseline detected; prioritize faster/safer navigation settings.");
+    if (budget === "degraded")
+      rationale.push("Benchmark has failing cases; reduce semantic payload until errors are resolved.");
+    if (budget === "high_latency")
+      rationale.push("High latency detected; prefer fast mode and smaller pages.");
+    if (tokenHeavyCount > 0)
+      rationale.push("Token-heavy benchmark cases detected; cap page sizes and preview windows.");
+    if (rationale.length === 0)
+      rationale.push("Benchmark health is acceptable; use balanced deep defaults.");
+    return {
+      version: 1,
+      source: found ? "doctor.benchmarkInsights" : "default_policy",
+      budget_status: budget,
+      semantic_navigate: {
+        mode,
+        strategy,
+        page_size: pageSize2,
+        reference_preview: referencePreview,
+        hint_start_line: 1,
+        hint_max_lines: hintMaxLines
+      },
+      diagnostics_delta: {
+        page_size: diagnosticsPageSize,
+        preview_limit: diagnosticsPreviewLimit,
+        hotspot_limit: diagnosticsHotspotLimit
+      },
+      rationale
+    };
+  })();
   const backendPackages = getBackendPackages(config2).filter((pkg) => config2.languages[pkg.language]?.enabled);
   const backendRuntimeMode = resolveBackendRuntimeMode3();
   const versionByLanguage = new Map(backendManager.getVersions().map((version2) => [version2.language, version2]));
@@ -23119,7 +23986,9 @@ server.registerTool("doctor", {
     }
   };
   const latestLookupStats = {
+    schema_version: 1,
     enabled: !!check_latest_versions,
+    cache_ttl_ms: REGISTRY_LOOKUP_TTL_MS,
     requested: 0,
     cache_hits: 0,
     inflight_hits: 0,
@@ -23233,6 +24102,7 @@ server.registerTool("doctor", {
     }];
   }));
   const backendVersionSummary = {
+    schema_version: 1,
     check_latest_versions: !!check_latest_versions,
     lookup_stats: latestLookupStats,
     counts: backendVersionCounts,
@@ -23263,6 +24133,41 @@ server.registerTool("doctor", {
     uv_cache_dir: uvCacheDir,
     uv_cache_writable: uvCacheWritable
   };
+  if (config2.languages.python?.enabled && backendRuntimeMode === "bundled") {
+    const pythonBundledDir = resolveLikelyBundledBackendPath("python");
+    const bundledExists = !!pythonBundledDir && fs3.existsSync(pythonBundledDir);
+    const bundledRuntimeCheck = {
+      runtime_mode: backendRuntimeMode,
+      bundled_dir: pythonBundledDir,
+      bundled_dir_exists: bundledExists,
+      uv_available: checks4.uv.available,
+      probe_executed: false
+    };
+    if (!bundledExists) {
+      bundledRuntimeCheck.status = "missing_bundle";
+      bundledRuntimeCheck.next_step = "Run `bun run build:bundled` to produce `dist/bundled/python`.";
+    } else if (!checks4.uv.available) {
+      bundledRuntimeCheck.status = "missing_uv";
+      bundledRuntimeCheck.next_step = "Install uv and ensure `uv` is available in PATH.";
+    } else if (probe_backends) {
+      const probe = await runCommandCapture("uv", ["run", "--quiet", "--directory", pythonBundledDir, "python-lsp-mcp", "--help"], 8000);
+      bundledRuntimeCheck.probe_executed = true;
+      bundledRuntimeCheck.probe_command = `uv run --quiet --directory ${pythonBundledDir} python-lsp-mcp --help`;
+      bundledRuntimeCheck.probe_exit_code = probe.code;
+      bundledRuntimeCheck.probe_output = (probe.stdout || probe.stderr || "").trim().slice(0, 500);
+      if (probe.code === 0) {
+        bundledRuntimeCheck.status = "ok";
+        bundledRuntimeCheck.next_step = "Bundled python runtime probe succeeded.";
+      } else {
+        bundledRuntimeCheck.status = "probe_failed";
+        bundledRuntimeCheck.next_step = "Run the probe command manually to inspect full error and ensure UV cache/network access.";
+      }
+    } else {
+      bundledRuntimeCheck.status = "probe_skipped";
+      bundledRuntimeCheck.next_step = "Run doctor(probe_backends=true) to execute bundled python runtime probe.";
+    }
+    workspaceDependencyChecks.python_bundled_runtime = bundledRuntimeCheck;
+  }
   const discoveryRoot = activeWorkspacePath;
   if (discoveryRoot && fileExistsSafe(discoveryRoot) && fs3.statSync(discoveryRoot).isDirectory()) {
     const candidates = discoverWorkspaceCandidates(discoveryRoot, 2);
@@ -23297,6 +24202,12 @@ server.registerTool("doctor", {
     };
   }
   const enabledLanguages = Object.keys(config2.languages).filter((lang) => config2.languages[lang]?.enabled);
+  const inputSnapshot = readCapabilitySnapshot(capability_snapshot_id || null);
+  let capabilitySnapshotStatus = "none";
+  if (capability_snapshot_id && !inputSnapshot) {
+    capabilitySnapshotStatus = "invalid_or_expired";
+  }
+  let outputCapabilitySnapshotId = inputSnapshot?.id || null;
   const workspaceDiscovery = workspaceDependencyChecks.language_workspace_discovery;
   const vueChecks = workspaceDependencyChecks.vue;
   const languageCommandChains = Object.fromEntries(enabledLanguages.map((lang) => {
@@ -23366,75 +24277,99 @@ server.registerTool("doctor", {
       return `read_file_with_hints(file='${sampleFile}', start_line=1, max_lines=80)`;
     if (feature === "call_hierarchy")
       return `call_hierarchy(file='${sampleFile}', line=1, column=1, direction='both')`;
+    if (feature === "type_hierarchy")
+      return `type_hierarchy(file='${sampleFile}', line=1, column=1, direction='both')`;
     return `hover(file='${sampleFile}', line=1, column=1)`;
   };
   const featureCapabilityMatrix = {};
-  for (const lang of enabledLanguages) {
-    const language = lang;
-    const chainWorkspace = languageCommandChains[language]?.workspace || null;
-    if (!probe_backends) {
-      const featureNextSteps = Object.fromEntries(LLM_FEATURE_TARGETS.map((feature) => {
-        const meta = LLM_FEATURE_PROBE_METADATA[feature];
-        return [
-          feature,
-          {
-            status: "unknown",
-            command: featureCommandTemplate(language, feature, chainWorkspace),
-            note: "Run doctor(probe_backends=true) for backend capability verification.",
-            expected_latency_ms: meta.expected_latency_ms,
-            failure_signatures: meta.failure_signatures
-          }
-        ];
-      }));
-      featureCapabilityMatrix[lang] = {
-        probe_required: true,
+  const canReuseSnapshot = !!inputSnapshot && !probe_backends && JSON.stringify([...inputSnapshot.enabledLanguages].sort()) === JSON.stringify([...enabledLanguages].sort());
+  if (canReuseSnapshot && inputSnapshot) {
+    capabilitySnapshotStatus = "reused";
+    for (const lang of enabledLanguages) {
+      featureCapabilityMatrix[lang] = inputSnapshot.featureCapabilityMatrix[lang] || {
         status: "unknown",
-        next_step: "Call doctor(probe_backends=true) to fetch per-language feature capabilities.",
-        feature_next_steps: featureNextSteps
+        note: "Language missing in capability snapshot; rerun doctor(probe_backends=true)."
       };
-      continue;
     }
-    try {
-      const tools = await backendManager.getTools(language);
-      const toolSet = new Set(tools.map((t) => t.name));
-      const features = Object.fromEntries(LLM_FEATURE_TARGETS.map((name) => [
-        name,
-        toolSet.has(name) ? "supported" : "not_supported"
-      ]));
-      const featureNextSteps = Object.fromEntries(LLM_FEATURE_TARGETS.map((feature) => {
-        const supported = toolSet.has(feature);
-        const command = featureCommandTemplate(language, feature, chainWorkspace);
-        const meta = LLM_FEATURE_PROBE_METADATA[feature];
-        return [
-          feature,
-          supported ? {
-            status: "supported",
-            command,
-            note: `Run ${feature} directly after workspace setup.`,
-            expected_latency_ms: meta.expected_latency_ms,
-            failure_signatures: meta.failure_signatures
-          } : {
-            status: "not_supported",
-            command,
-            fallback_command: "hover(file='/abs/path/to/file', line=1, column=1)",
-            note: "Feature missing in backend; expect strict NOT_IMPLEMENTED.",
-            expected_latency_ms: meta.expected_latency_ms,
-            failure_signatures: meta.failure_signatures
-          }
-        ];
-      }));
-      featureCapabilityMatrix[lang] = {
-        status: "ok",
-        tool_count: tools.length,
-        features,
-        feature_next_steps: featureNextSteps
-      };
-    } catch (error2) {
-      featureCapabilityMatrix[lang] = {
-        status: "error",
-        error: String(error2)
-      };
+  } else
+    for (const lang of enabledLanguages) {
+      const language = lang;
+      const chainWorkspace = languageCommandChains[language]?.workspace || null;
+      if (!probe_backends) {
+        const featureNextSteps = Object.fromEntries(LLM_FEATURE_TARGETS.map((feature) => {
+          const meta = LLM_FEATURE_PROBE_METADATA[feature];
+          return [
+            feature,
+            {
+              status: "unknown",
+              command: featureCommandTemplate(language, feature, chainWorkspace),
+              note: "Run doctor(probe_backends=true) for backend capability verification.",
+              expected_latency_ms: meta.expected_latency_ms,
+              failure_signatures: meta.failure_signatures
+            }
+          ];
+        }));
+        featureCapabilityMatrix[lang] = {
+          probe_required: true,
+          status: "unknown",
+          next_step: "Call doctor(probe_backends=true) to fetch per-language feature capabilities.",
+          feature_next_steps: featureNextSteps
+        };
+        continue;
+      }
+      try {
+        const tools = await backendManager.getTools(language);
+        const toolSet = new Set(tools.map((t) => t.name));
+        const features = Object.fromEntries(LLM_FEATURE_TARGETS.map((name) => [
+          name,
+          toolSet.has(name) ? "supported" : "not_supported"
+        ]));
+        const featureNextSteps = Object.fromEntries(LLM_FEATURE_TARGETS.map((feature) => {
+          const supported = toolSet.has(feature);
+          const command = featureCommandTemplate(language, feature, chainWorkspace);
+          const meta = LLM_FEATURE_PROBE_METADATA[feature];
+          return [
+            feature,
+            supported ? {
+              status: "supported",
+              command,
+              note: `Run ${feature} directly after workspace setup.`,
+              expected_latency_ms: meta.expected_latency_ms,
+              failure_signatures: meta.failure_signatures
+            } : {
+              status: "not_supported",
+              command,
+              fallback_command: "hover(file='/abs/path/to/file', line=1, column=1)",
+              note: "Feature missing in backend; expect strict NOT_IMPLEMENTED.",
+              expected_latency_ms: meta.expected_latency_ms,
+              failure_signatures: meta.failure_signatures
+            }
+          ];
+        }));
+        featureCapabilityMatrix[lang] = {
+          status: "ok",
+          tool_count: tools.length,
+          features,
+          feature_next_steps: featureNextSteps
+        };
+      } catch (error2) {
+        featureCapabilityMatrix[lang] = {
+          status: "error",
+          error: String(error2)
+        };
+      }
     }
+  if (probe_backends) {
+    const snapshotId = makeCapabilitySnapshotId(enabledLanguages);
+    capabilitySnapshotStore.set(snapshotId, {
+      id: snapshotId,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + CAPABILITY_SNAPSHOT_TTL_MS,
+      enabledLanguages: [...enabledLanguages],
+      featureCapabilityMatrix
+    });
+    outputCapabilitySnapshotId = snapshotId;
+    capabilitySnapshotStatus = "created";
   }
   const probeResults = {};
   if (probe_backends) {
@@ -23457,6 +24392,17 @@ server.registerTool("doctor", {
     recommendations.push("Install uv for Python backend support.");
   if (!checks4.bun.available)
     recommendations.push("Install Bun if you run this server from source.");
+  if (!benchmarkInsights.found) {
+    recommendations.push(`Benchmark report not found. ${benchmarkInsights.next_step}`);
+  } else {
+    if (benchmarkInsights.budget_status === "regressed") {
+      recommendations.push("Benchmark trend regressed vs baseline. Review benchmarkInsights.trend.regressions before rollout.");
+    } else if (benchmarkInsights.budget_status === "degraded") {
+      recommendations.push("Latest benchmark has failing cases; prioritize fixing those before enabling aggressive semantic automation.");
+    } else if (benchmarkInsights.budget_status === "high_latency") {
+      recommendations.push("Latest benchmark latency is high; prefer semantic_navigate(mode='fast') and narrower page_size defaults.");
+    }
+  }
   if (config2.languages.vue?.enabled && activeWorkspacePath) {
     const missing = (vueChecks?.projects || []).filter((p) => !p.ok);
     if (missing.length > 0) {
@@ -23486,6 +24432,22 @@ server.registerTool("doctor", {
       recommendations.push("Python backend failed before handshake. Run `uv run --directory dist/bundled/python python-lsp-mcp --help` to preinstall runtime dependencies.");
     }
   }
+  const pythonBundledRuntimeCheck = workspaceDependencyChecks.python_bundled_runtime;
+  if (pythonBundledRuntimeCheck) {
+    if (pythonBundledRuntimeCheck.status === "missing_bundle") {
+      recommendations.push(String(pythonBundledRuntimeCheck.next_step || "Bundled python runtime missing."));
+    } else if (pythonBundledRuntimeCheck.status === "missing_uv") {
+      recommendations.push(String(pythonBundledRuntimeCheck.next_step || "uv is required for bundled python runtime."));
+    } else if (pythonBundledRuntimeCheck.status === "probe_failed") {
+      recommendations.push("Bundled python runtime probe failed. Check uv cache/network, then retry doctor(probe_backends=true).");
+      if (pythonBundledRuntimeCheck.probe_command) {
+        recommendations.push(`Probe command: ${pythonBundledRuntimeCheck.probe_command}`);
+      }
+    }
+  }
+  if (capabilitySnapshotStatus === "invalid_or_expired") {
+    recommendations.push("Provided capability_snapshot_id is invalid or expired. Run doctor(probe_backends=true) to refresh.");
+  }
   for (const [lang, drift] of Object.entries(backendPackageDrift)) {
     if (drift.drift_status === "policy_drift") {
       recommendations.push(`${lang} backend is not using latest update policy. ${drift.next_step}`);
@@ -23504,9 +24466,13 @@ server.registerTool("doctor", {
     checks: checks4,
     activeWorkspacePath,
     backendRuntimeMode,
+    capability_snapshot_id: outputCapabilitySnapshotId,
+    capability_snapshot_status: capabilitySnapshotStatus,
     enabledLanguages,
     backendPackageDrift,
     backendVersionSummary,
+    benchmarkInsights,
+    llmSemanticDefaults,
     workspaceDependencyChecks,
     languageCommandChains,
     backendCommands,
@@ -23520,6 +24486,8 @@ server.registerTool("doctor", {
   for (const [name, check2] of Object.entries(checks4)) {
     items.push({ kind: "runtime_check", key: name, value: check2 });
   }
+  items.push({ kind: "benchmark_insight", key: "latest", value: benchmarkInsights });
+  items.push({ kind: "llm_default", key: "semantic_defaults", value: llmSemanticDefaults });
   for (const [name, depCheck] of Object.entries(workspaceDependencyChecks)) {
     items.push({ kind: "workspace_dependency", key: name, value: depCheck });
   }
@@ -23547,7 +24515,13 @@ server.registerTool("doctor", {
     enabledLanguages,
     recommendations_count: recommendations.length,
     command_chains_count: Object.keys(languageCommandChains).length,
+    capability_snapshot_id: outputCapabilitySnapshotId,
+    capability_snapshot_status: capabilitySnapshotStatus,
+    backend_version_schema_version: backendVersionSummary.schema_version,
     backend_version_counts: backendVersionSummary.counts,
+    benchmark_found: !!benchmarkInsights.found,
+    benchmark_budget_status: benchmarkInsights.budget_status || "unknown",
+    llm_defaults_version: llmSemanticDefaults.version,
     item_count: items.length
   };
   const doctorCursor = makeCursor("doctor", items, items.length, doctorSummary);
@@ -23585,7 +24559,8 @@ server.registerTool("lsp_probe_profile", {
     moniker: "p2_advanced",
     linked_editing_range: "p2_advanced",
     inlay_hint_resolve: "p2_advanced",
-    call_hierarchy: "p2_advanced"
+    call_hierarchy: "p2_advanced",
+    type_hierarchy: "p2_advanced"
   };
   const selectedFeatures = feature ? [feature] : [...LLM_FEATURE_TARGETS, "hover", "definition", "references"];
   const uniqueFeatures = Array.from(new Set(selectedFeatures)).filter((name) => LLM_FEATURE_PROBE_METADATA[name]);
@@ -23793,6 +24768,22 @@ function extractReferencesItems(parsed) {
 function extractReferencesCount(parsed, items) {
   return typeof parsed?.count === "number" ? parsed.count : items.length;
 }
+function extractDiagnosticsItems(parsed) {
+  if (Array.isArray(parsed))
+    return parsed;
+  if (Array.isArray(parsed?.diagnostics))
+    return parsed.diagnostics;
+  return [];
+}
+function fingerprintDiagnostic(diag) {
+  const file = String(diag.file || diag.path || "");
+  const line = Number(diag.line ?? diag?.range?.start?.line ?? -1);
+  const column = Number(diag.column ?? diag?.range?.start?.character ?? -1);
+  const severity = String(diag.severity || "");
+  const code = String(diag.code || "");
+  const message = String(diag.message || "");
+  return `${file}|${line}|${column}|${severity}|${code}|${message}`;
+}
 function isInlayHintUnsupportedError(errorText) {
   const text = errorText.toLowerCase();
   return text.includes("textdocument/inlayhint") || text.includes("unhandled method") || text.includes("method not found") || text.includes("not implemented") || text.includes("unknown tool") || text.includes("tool not found") || text.includes("inlay_hints") || text.includes("-32601");
@@ -23924,6 +24915,169 @@ function findWorkspaceIdentifierHits(identifier, workspacePath) {
   }
   return hits;
 }
+function searchWorkspacePatternHits(workspacePath, pattern, globs, maxHits = 200) {
+  if (!workspacePath || !pattern.trim())
+    return [];
+  const args = [
+    "--no-ignore-vcs",
+    "--line-number",
+    "--column",
+    "--no-heading",
+    "--color",
+    "never",
+    ...globs.flatMap((g) => ["-g", g]),
+    pattern,
+    "."
+  ];
+  const result = spawnSync("rg", args, { cwd: workspacePath, encoding: "utf-8" });
+  if (result.error || typeof result.stdout !== "string" || result.stdout.trim().length === 0)
+    return [];
+  const hits = [];
+  for (const line of result.stdout.trim().split(`
+`)) {
+    const match = /^(.*?):(\d+):(\d+):(.*)$/.exec(line);
+    if (!match)
+      continue;
+    hits.push({
+      file: path2.resolve(workspacePath, match[1]),
+      line: Number.parseInt(match[2], 10),
+      column: Number.parseInt(match[3], 10),
+      text: match[4]
+    });
+    if (hits.length >= maxHits)
+      break;
+  }
+  return hits;
+}
+function parseTypeSupertypesFromLine(language, lineText, symbol) {
+  const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (language === "python") {
+    const m = new RegExp(`^\\s*class\\s+${escaped}\\s*\\(([^)]*)\\)`).exec(lineText);
+    if (!m)
+      return [];
+    return m[1].split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const classMatch = new RegExp(`\\bclass\\s+${escaped}\\b([^\\{]*)`).exec(lineText);
+  const interfaceMatch = new RegExp(`\\binterface\\s+${escaped}\\b([^\\{]*)`).exec(lineText);
+  const tail = (classMatch?.[1] || interfaceMatch?.[1] || "").trim();
+  if (!tail)
+    return [];
+  const supers = [];
+  const extendsMatch = /\bextends\s+([A-Za-z0-9_$.,<>\s]+)/.exec(tail);
+  if (extendsMatch?.[1]) {
+    supers.push(...extendsMatch[1].split(",").map((s) => s.replace(/<.*?>/g, "").trim()).filter(Boolean));
+  }
+  const implMatch = /\bimplements\s+([A-Za-z0-9_$.,<>\s]+)/.exec(tail);
+  if (implMatch?.[1]) {
+    supers.push(...implMatch[1].split(",").map((s) => s.replace(/<.*?>/g, "").trim()).filter(Boolean));
+  }
+  return Array.from(new Set(supers));
+}
+function toHintPosition1Based(hint, language) {
+  const pos = hint.position;
+  if (!pos || typeof pos !== "object")
+    return null;
+  if (typeof pos.line !== "number")
+    return null;
+  if (typeof pos.column === "number") {
+    return { line: pos.line, column: pos.column };
+  }
+  if (typeof pos.character === "number") {
+    return { line: pos.line + 1, column: pos.character + 1 };
+  }
+  if (language === "typescript" && typeof pos.line === "number") {
+    return { line: pos.line, column: 1 };
+  }
+  return null;
+}
+function buildApproximateSemanticTokens(content, language) {
+  const keywords = new Set([
+    "class",
+    "interface",
+    "type",
+    "extends",
+    "implements",
+    "function",
+    "return",
+    "const",
+    "let",
+    "var",
+    "if",
+    "else",
+    "for",
+    "while",
+    "import",
+    "export",
+    "from",
+    "def",
+    "async",
+    "await",
+    "try",
+    "except"
+  ]);
+  const tokens = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    const regex = /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'|\b\d+(?:\.\d+)?\b|[A-Za-z_$][A-Za-z0-9_$]*/g;
+    let m;
+    while ((m = regex.exec(line)) !== null) {
+      const text = m[0];
+      const col = m.index + 1;
+      let tokenType = "variable";
+      if (text.startsWith("'") || text.startsWith('"'))
+        tokenType = "string";
+      else if (/^\d/.test(text))
+        tokenType = "number";
+      else if (keywords.has(text))
+        tokenType = "keyword";
+      else if (/[A-Z]/.test(text[0]))
+        tokenType = language === "python" ? "class" : "type";
+      else if (line.slice(m.index + text.length).trimStart().startsWith("("))
+        tokenType = "function";
+      else if (m.index > 0 && line[m.index - 1] === ".")
+        tokenType = "property";
+      tokens.push({
+        line: i + 1,
+        column: col,
+        length: text.length,
+        token_type: tokenType,
+        token_modifiers: [],
+        text
+      });
+      if (tokens.length >= 5000)
+        return tokens;
+    }
+  }
+  return tokens;
+}
+function buildApproximateLinkedEditingRanges(content, line, column) {
+  const ident = extractIdentifierAtPosition(content, line, column);
+  if (!ident)
+    return { identifier: null, ranges: [] };
+  const escaped = ident.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`\\b${escaped}\\b`, "g");
+  const ranges = [];
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    regex.lastIndex = 0;
+    let m;
+    while ((m = regex.exec(lines[i])) !== null) {
+      const startCol = m.index + 1;
+      ranges.push({
+        start: { line: i + 1, column: startCol },
+        end: { line: i + 1, column: startCol + ident.length }
+      });
+      if (ranges.length >= 5000)
+        return { identifier: ident, ranges };
+    }
+  }
+  return { identifier: ident, ranges };
+}
 function findDeclarationInFile(content, identifier) {
   const lines = content.split(`
 `);
@@ -24081,6 +25235,7 @@ function buildVueMissingDepsErrorResponse(toolName, workspacePath) {
     `cd ${installRoot} && yarn add -D typescript @vue/language-server`,
     `cd ${installRoot} && bun add -d typescript @vue/language-server`
   ];
+  const recoveryPlan = buildRecoveryPlan(installCommands, installCommands[0]);
   return {
     content: [{
       type: "text",
@@ -24094,6 +25249,7 @@ function buildVueMissingDepsErrorResponse(toolName, workspacePath) {
         strict_mode: VUE_STRICT_SEMANTIC,
         missing_packages: ["typescript", "@vue/language-server"],
         install_commands: installCommands,
+        recovery_plan: recoveryPlan,
         next_step: installCommands[0],
         required_packages: ["typescript", "@vue/language-server"],
         install_example: installCommands[0],
@@ -25366,6 +26522,259 @@ ${results.join(`
         const availableTools = await backendManager.getTools(language);
         const supportsTool = availableTools.some((t) => t.name === tool.name);
         if (!supportsTool) {
+          if (tool.name === "inlay_hint_resolve" && availableTools.some((t) => t.name === "inlay_hints")) {
+            try {
+              const hintsResponse = await callBackendTool("inlay_hints", { file: filePath });
+              const parsedHints = JSON.parse(hintsResponse.content[0]?.text || "{}");
+              const hints = Array.isArray(parsedHints?.hints) ? parsedHints.hints : [];
+              const targetLine = Number(args.line);
+              const targetColumn = Number(args.column);
+              const targetLabel = typeof args.label === "string" ? String(args.label) : null;
+              const withDistance = hints.map((hint) => {
+                const pos = toHintPosition1Based(hint, language);
+                if (!pos)
+                  return null;
+                const labelRaw = hint.label;
+                const label = typeof labelRaw === "string" ? labelRaw : Array.isArray(labelRaw) ? labelRaw.map((p) => String(p.value || "")).join("") : "";
+                if (targetLabel && label.trim() !== targetLabel.trim())
+                  return null;
+                const distance = Math.abs(pos.line - targetLine) * 1000 + Math.abs(pos.column - targetColumn);
+                return { hint, label, pos, distance };
+              }).filter((item) => !!item).sort((a, b) => a.distance - b.distance);
+              const best = withDistance[0];
+              if (!best) {
+                return withSemanticContext({
+                  content: [{
+                    type: "text",
+                    text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                      error: "No inlay hint found at this position",
+                      error_code: "NO_INLAY_HINT_FOUND",
+                      strict_mode: true,
+                      fallback_used: true,
+                      approximate: true,
+                      available_hints: hints.length,
+                      next_step: "Call inlay_hints(file=...) to inspect available hint positions, then retry with exact line/column.",
+                      recovery_plan: buildRecoveryPlan([`inlay_hints(file='${filePath}')`, `inlay_hint_resolve(file='${filePath}', line=${targetLine}, column=${targetColumn})`], "Inspect hint positions and retry inlay_hint_resolve with exact coordinates.")
+                    })))
+                  }]
+                }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+              }
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    ok: true,
+                    tool: "inlay_hint_resolve",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    position: best.pos,
+                    label: best.label,
+                    hint: best.hint,
+                    available_hints: hints.length,
+                    next_step: "Use resolved hint label/context for downstream explanation or refactor planning."
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            } catch (error2) {
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    error: String(error2),
+                    error_code: "INLAY_HINT_RESOLVE_FALLBACK_ERROR",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    next_step: "Retry inlay_hint_resolve or call inlay_hints(file=...) directly."
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            }
+          }
+          if (tool.name === "type_hierarchy") {
+            try {
+              const direction = String(args.direction || "both");
+              const sourceText = fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf-8") : "";
+              const symbol = extractIdentifierAtPosition(sourceText, Number(args.line), Number(args.column));
+              if (!symbol) {
+                return withSemanticContext({
+                  content: [{
+                    type: "text",
+                    text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                      error: "Unable to infer symbol for type hierarchy fallback",
+                      error_code: "NO_SYMBOL_AT_POSITION",
+                      strict_mode: true,
+                      fallback_used: true,
+                      approximate: true,
+                      next_step: "Move cursor onto a class/interface symbol and retry type_hierarchy."
+                    })))
+                  }]
+                }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+              }
+              const lines = sourceText.split(`
+`);
+              const targetLine = Number(args.line);
+              const lineText = lines[Math.max(0, targetLine - 1)] || "";
+              const supertypesRaw = parseTypeSupertypesFromLine(language, lineText, symbol);
+              const supertypes = supertypesRaw.map((name) => ({ name, relation: "supertype" }));
+              const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+              const subtypePatterns = language === "python" ? [`^\\s*class\\s+[A-Za-z_][A-Za-z0-9_]*\\s*\\([^)]*\\b${escaped}\\b[^)]*\\)`] : [
+                `\\bclass\\s+[A-Za-z_$][A-Za-z0-9_$]*\\s+extends\\s+${escaped}\\b`,
+                `\\b(class|interface)\\s+[A-Za-z_$][A-Za-z0-9_$]*[^\\n\\{]*\\bimplements\\b[^\\n\\{]*\\b${escaped}\\b`
+              ];
+              const subtypeGlobs = language === "python" ? ["*.py"] : ["*.ts", "*.tsx", "*.js", "*.jsx", "*.vue", "*.d.ts"];
+              const subtypeHits = resolvedWorkspace ? subtypePatterns.flatMap((p) => searchWorkspacePatternHits(resolvedWorkspace, p, subtypeGlobs, 120)) : [];
+              const seenSubtype = new Set;
+              const subtypes = subtypeHits.filter((hit) => {
+                const key = `${hit.file}:${hit.line}:${hit.column}`;
+                if (seenSubtype.has(key))
+                  return false;
+                seenSubtype.add(key);
+                return true;
+              }).map((hit) => ({
+                file: hit.file,
+                line: hit.line,
+                column: hit.column,
+                preview: hit.text.trim(),
+                relation: "subtype"
+              })).slice(0, 120);
+              const includeSuper = direction === "both" || direction === "supertypes";
+              const includeSub = direction === "both" || direction === "subtypes";
+              const filteredSupers = includeSuper ? supertypes : [];
+              const filteredSubs = includeSub ? subtypes : [];
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    ok: true,
+                    tool: "type_hierarchy",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    symbol,
+                    direction,
+                    hierarchy: {
+                      supertypes: filteredSupers,
+                      subtypes: filteredSubs
+                    },
+                    next_step: "Verify approximate hierarchy edges with definition/references before edits.",
+                    result_size: filteredSupers.length + filteredSubs.length,
+                    truncated: subtypes.length > filteredSubs.length,
+                    cursor_available: false
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            } catch (error2) {
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    error: String(error2),
+                    error_code: "TYPE_HIERARCHY_FALLBACK_ERROR",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    next_step: "Retry type_hierarchy or use definition/references manually."
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            }
+          }
+          if (tool.name === "semantic_tokens") {
+            try {
+              const sourceText = fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf-8") : "";
+              const approxTokens = buildApproximateSemanticTokens(sourceText, language);
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    ok: true,
+                    tool: "semantic_tokens",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    file: absPath,
+                    tokens: approxTokens.slice(0, 1000),
+                    count: approxTokens.length,
+                    next_step: "Use approximate tokens for structural reading; validate with hover/definition before edits.",
+                    truncated: approxTokens.length > 1000,
+                    cursor_available: false
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            } catch (error2) {
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    error: String(error2),
+                    error_code: "SEMANTIC_TOKENS_FALLBACK_ERROR",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    next_step: "Retry semantic_tokens or use summarize_file/read_file_with_hints."
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            }
+          }
+          if (tool.name === "linked_editing_range") {
+            try {
+              const sourceText = fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf-8") : "";
+              const line = Number(args.line);
+              const column = Number(args.column);
+              const approx = buildApproximateLinkedEditingRanges(sourceText, line, column);
+              if (!approx.identifier) {
+                return withSemanticContext({
+                  content: [{
+                    type: "text",
+                    text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                      error: "Unable to infer symbol for linked editing fallback",
+                      error_code: "NO_SYMBOL_AT_POSITION",
+                      strict_mode: true,
+                      fallback_used: true,
+                      approximate: true,
+                      next_step: "Move cursor onto an identifier and retry linked_editing_range."
+                    })))
+                  }]
+                }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+              }
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    ok: true,
+                    tool: "linked_editing_range",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    file: absPath,
+                    identifier: approx.identifier,
+                    ranges: approx.ranges.slice(0, 1000),
+                    count: approx.ranges.length,
+                    next_step: "Use linked ranges for synchronized edits; validate with references before large refactors.",
+                    truncated: approx.ranges.length > 1000,
+                    cursor_available: false
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            } catch (error2) {
+              return withSemanticContext({
+                content: [{
+                  type: "text",
+                  text: JSON.stringify(withStandardCostFields(withConfidenceFields({
+                    error: String(error2),
+                    error_code: "LINKED_EDITING_RANGE_FALLBACK_ERROR",
+                    strict_mode: true,
+                    fallback_used: true,
+                    approximate: true,
+                    next_step: "Retry linked_editing_range or use references for safer edit scope."
+                  })))
+                }]
+              }, tool.name, resolvedWorkspace, backendInstanceId(), language);
+            }
+          }
           return withSemanticContext({
             content: [
               {
@@ -25961,4 +27370,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=BA652C589634FFA364756E2164756E21
+//# debugId=15CB193D47835A7764756E2164756E21