pybao-cli 1.3.97 → 1.3.99

package/dist/{chunk-X7NKBF4S.js → chunk-VYINZ75I.js}

@@ -4,20 +4,20 @@ import {
   LspServerRegistry,
   findNearestRoot,
   getInstallNotices
-} from "./chunk-CJ5J54UV.js";
+} from "./chunk-QX6FKMRR.js";
 import {
   levenshtein
 } from "./chunk-UZ34JEUK.js";
 import {
   getCwd
-} from "./chunk-4UESJIJZ.js";
+} from "./chunk-CMQGXFRW.js";
 
 // src/lsp/index.ts
 import { extname as extname2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { readFile as readFile4 } from "fs/promises";
 import * as http from "http";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // src/tools/search/LspTool/client/generic.ts
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node.js";
@@ -387,6 +387,8 @@ var LspClientManager = class _LspClientManager {
   prewarmHits = /* @__PURE__ */ new Map();
   spawnMetrics = /* @__PURE__ */ new Map();
   requestMetrics = /* @__PURE__ */ new Map();
+  compareSamples = /* @__PURE__ */ new Map();
+  qualitySamples = /* @__PURE__ */ new Map();
   constructor() {
   }
   static getInstance() {
@@ -529,7 +531,7 @@ var LspClientManager = class _LspClientManager {
     const safeCwd = /[^\x00-\x7F]/.test(resolvedRoot) ? process.cwd() : resolvedRoot;
     let initOpts = serverInfo.initializationOptions;
     if (serverInfo.id === "pyright" || serverInfo.id === "ty") {
-      const { detectPythonVenv } = await import("./registry-VYHW665M.js");
+      const { detectPythonVenv } = await import("./registry-YC7VJDV4.js");
       const pythonPath = detectPythonVenv(resolvedRoot);
       if (pythonPath) {
         initOpts = { ...initOpts ?? {}, pythonPath };
@@ -551,7 +553,10 @@ var LspClientManager = class _LspClientManager {
   }
   async shutdownAll() {
     for (const client of this.clients.values()) {
-      await client.shutdown();
+      const shutdown = client.shutdown;
+      if (typeof shutdown === "function") {
+        await shutdown();
+      }
     }
     this.clients.clear();
     this.broken.clear();
@@ -562,6 +567,8 @@ var LspClientManager = class _LspClientManager {
     this.prewarmHits.clear();
     this.spawnMetrics.clear();
     this.requestMetrics.clear();
+    this.compareSamples.clear();
+    this.qualitySamples.clear();
   }
   async workspaceSymbol(query, rootPath = getCwd(), options) {
     if (this.clients.size === 0) {
@@ -784,11 +791,109 @@ var LspClientManager = class _LspClientManager {
         latencyP95Ms: p95Latency,
         baselineAvgMs: baselineAvg,
         baselineP95Ms: baselineP95,
+        baselineSamples: entry.baseline?.samples ?? 0,
         regression,
         failureReasons: { ...entry.failureReasons }
       };
     });
+    const compareMetrics = Array.from(this.compareSamples.entries()).map(([language, samples]) => {
+      const sampleCount = samples.length;
+      if (sampleCount === 0) {
+        return {
+          language,
+          samples: 0,
+          traversalAvg: 0,
+          queryAvg: 0,
+          missingAvg: 0,
+          extraAvg: 0,
+          missingRateAvg: 0,
+          extraRateAvg: 0,
+          lastSampleAt: null
+        };
+      }
+      const totals = samples.reduce(
+        (acc, sample) => {
+          acc.traversal += sample.traversalCount;
+          acc.query += sample.queryCount;
+          acc.missing += sample.missingCount;
+          acc.extra += sample.extraCount;
+          acc.missingRate += sample.traversalCount > 0 ? sample.missingCount / sample.traversalCount : 0;
+          acc.extraRate += sample.queryCount > 0 ? sample.extraCount / sample.queryCount : 0;
+          acc.lastAt = Math.max(acc.lastAt, sample.at);
+          return acc;
+        },
+        {
+          traversal: 0,
+          query: 0,
+          missing: 0,
+          extra: 0,
+          missingRate: 0,
+          extraRate: 0,
+          lastAt: 0
+        }
+      );
+      return {
+        language,
+        samples: sampleCount,
+        traversalAvg: totals.traversal / sampleCount,
+        queryAvg: totals.query / sampleCount,
+        missingAvg: totals.missing / sampleCount,
+        extraAvg: totals.extra / sampleCount,
+        missingRateAvg: totals.missingRate / sampleCount,
+        extraRateAvg: totals.extraRate / sampleCount,
+        lastSampleAt: totals.lastAt
+      };
+    });
+    const tsQualityMetrics = Array.from(this.qualitySamples.entries()).map(([language, samples]) => {
+      const sampleCount = samples.length;
+      if (sampleCount === 0) {
+        return {
+          language,
+          samples: 0,
+          successRate: 0,
+          emptyRate: 0,
+          coverageAvg: 0,
+          traversalAvg: 0,
+          queryAvg: 0,
+          lastSampleAt: null
+        };
+      }
+      const totals = samples.reduce(
+        (acc, sample) => {
+          acc.success += sample.success ? 1 : 0;
+          acc.empty += sample.empty ? 1 : 0;
+          acc.traversal += sample.traversalCount;
+          acc.query += sample.queryCount;
+          acc.coverage += sample.traversalCount > 0 ? sample.queryCount / sample.traversalCount : 1;
+          acc.lastAt = Math.max(acc.lastAt, sample.at);
+          return acc;
+        },
+        {
+          success: 0,
+          empty: 0,
+          traversal: 0,
+          query: 0,
+          coverage: 0,
+          lastAt: 0
+        }
+      );
+      return {
+        language,
+        samples: sampleCount,
+        successRate: totals.success / sampleCount,
+        emptyRate: totals.empty / sampleCount,
+        coverageAvg: totals.coverage / sampleCount,
+        traversalAvg: totals.traversal / sampleCount,
+        queryAvg: totals.query / sampleCount,
+        lastSampleAt: totals.lastAt
+      };
+    });
     return {
+      schemaVersion: 1,
+      sampleWindow: {
+        latencySamples: 50,
+        baselineSamples: this.getRequestBaselineSampleSize()
+      },
       clients: Array.from(this.clients.keys()),
       spawning: Array.from(this.spawning.keys()),
       broken: Array.from(this.broken.values()),
@@ -797,7 +902,9 @@ var LspClientManager = class _LspClientManager {
       readiness,
       prewarms,
       metrics,
-      requestMetrics
+      requestMetrics,
+      compareMetrics,
+      tsQualityMetrics
     };
   }
   // New helper to expose waitForReadiness to clients who only have a manager
@@ -910,6 +1017,16 @@ var LspClientManager = class _LspClientManager {
   getRequestRegressionFactor() {
     return 1.5;
   }
+  getCompareSampleLimit() {
+    const override = Number.parseInt(process.env.PYB_TS_COMPARE_SAMPLE_LIMIT ?? "", 10);
+    if (Number.isFinite(override) && override > 0) return override;
+    return 50;
+  }
+  getQualitySampleLimit() {
+    const override = Number.parseInt(process.env.PYB_TS_QUALITY_SAMPLE_LIMIT ?? "", 10);
+    if (Number.isFinite(override) && override > 0) return override;
+    return 50;
+  }
   recordRequestAttempt(serverId, operation) {
     const entry = this.getRequestEntry(serverId, operation);
     entry.attempts += 1;
@@ -935,6 +1052,26 @@ var LspClientManager = class _LspClientManager {
     entry.failures += 1;
     entry.failureReasons[reason] += 1;
   }
+  recordCompareSample(language, sample) {
+    const limit = this.getCompareSampleLimit();
+    if (limit <= 0) return;
+    const list = this.compareSamples.get(language) ?? [];
+    list.push(sample);
+    if (list.length > limit) {
+      list.splice(0, list.length - limit);
+    }
+    this.compareSamples.set(language, list);
+  }
+  recordQualitySample(language, sample) {
+    const limit = this.getQualitySampleLimit();
+    if (limit <= 0) return;
+    const list = this.qualitySamples.get(language) ?? [];
+    list.push(sample);
+    if (list.length > limit) {
+      list.splice(0, list.length - limit);
+    }
+    this.qualitySamples.set(language, list);
+  }
   getBaseTtlMs(reason) {
     const override = Number.parseInt(process.env.PYB_LSP_BROKEN_TTL_MS ?? "", 10);
     if (Number.isFinite(override) && override > 0) return override;
@@ -1288,7 +1425,11 @@ var ParserRegistry = class {
     ".tsx": "tsx",
     ".js": "typescript",
     // Use TS parser for JS
+    ".mjs": "typescript",
+    ".cjs": "typescript",
     ".jsx": "tsx",
+    ".mts": "typescript",
+    ".cts": "typescript",
     ".py": "python",
     ".sh": "bash",
     ".bash": "bash",
@@ -1337,7 +1478,6 @@ var ParserRegistry = class {
 };
 
 // src/utils/tree-sitter/loader.ts
-import { Parser, Language } from "web-tree-sitter";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import path2 from "path";
 var getDirname = () => {
@@ -1348,6 +1488,13 @@ var getDirname = () => {
   }
 };
 var _dirname = getDirname();
+var webTreeSitterModule = null;
+var loadWebTreeSitter = async () => {
+  if (!webTreeSitterModule) {
+    webTreeSitterModule = import("web-tree-sitter");
+  }
+  return webTreeSitterModule;
+};
 var parserCache = /* @__PURE__ */ new Map();
 var isInitialized = false;
 var LANGUAGE_MAP = {
@@ -1382,6 +1529,7 @@ async function ensureInitialized() {
     resourcesDir = path2.resolve(_dirname, "../../../resources/tree-sitter");
   }
   const treeWasmPath = path2.join(resourcesDir, "tree-sitter.wasm");
+  const { Parser } = await loadWebTreeSitter();
   await Parser.init({
     locateFile: () => treeWasmPath
   });
@@ -1404,6 +1552,7 @@ var loadLanguage = async (lang) => {
       resourcesDir = path2.resolve(_dirname, "../../../resources/tree-sitter");
     }
     const wasmPath = path2.join(resourcesDir, fileName);
+    const { Language, Parser } = await loadWebTreeSitter();
     const language = await Language.load(wasmPath);
     const parser = new Parser();
     parser.setLanguage(language);
@@ -1422,7 +1571,167 @@ var initParser = async () => {
 };
 
 // src/utils/tree-sitter/lsp-adapter.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+
+// src/utils/tree-sitter/query-registry.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { createHash } from "crypto";
+import { Query } from "web-tree-sitter";
+var SOURCE_CACHE = /* @__PURE__ */ new Map();
+var COMPILED_CACHE = /* @__PURE__ */ new Map();
+var LIST_CACHE = /* @__PURE__ */ new Map();
+var __filename = fileURLToPath5(import.meta.url);
+var __dirname2 = path3.dirname(__filename);
+function normalizeLanguage(langKey) {
+  if (langKey === "tsx") return "typescript";
+  return langKey;
+}
+function getQueryDir(langKey) {
+  const normalized = normalizeLanguage(langKey);
+  return path3.join(__dirname2, "queries", normalized);
+}
+function computeHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function getSourceCacheKey(langKey, queryName) {
+  return `${normalizeLanguage(langKey)}:${queryName}`;
+}
+function extractCaptureCounts(source) {
+  const counts = {};
+  const regex = /@([A-Za-z0-9_.-]+)/g;
+  let match = regex.exec(source);
+  while (match) {
+    const name = match[1];
+    counts[name] = (counts[name] ?? 0) + 1;
+    match = regex.exec(source);
+  }
+  return counts;
+}
+function isValidQueryFileName(name) {
+  return /^[a-z0-9_-]+\.scm$/i.test(name);
+}
+var QueryRegistry = class {
+  static async getQuerySource(langKey, queryName) {
+    const key = getSourceCacheKey(langKey, queryName);
+    if (SOURCE_CACHE.has(key)) {
+      return SOURCE_CACHE.get(key) ?? null;
+    }
+    const dir = getQueryDir(langKey);
+    const queryPath = path3.join(dir, `${queryName}.scm`);
+    try {
+      const source = await readFile2(queryPath, "utf-8");
+      SOURCE_CACHE.set(key, source);
+      return source;
+    } catch {
+      SOURCE_CACHE.set(key, null);
+      return null;
+    }
+  }
+  static async getCompiledQuery(langKey, queryName) {
+    const source = await this.getQuerySource(langKey, queryName);
+    if (!source) return null;
+    const sourceHash = computeHash(source);
+    const key = getSourceCacheKey(langKey, queryName);
+    const cached = COMPILED_CACHE.get(key);
+    if (cached && cached.sourceHash === sourceHash) {
+      return cached.query;
+    }
+    const parser = await loadLanguage(normalizeLanguage(langKey));
+    const language = parser.language;
+    if (!language) return null;
+    const query = new Query(language, source);
+    COMPILED_CACHE.set(key, { sourceHash, query });
+    return query;
+  }
+  static async listQueries(langKey) {
+    const normalized = normalizeLanguage(langKey);
+    if (LIST_CACHE.has(normalized)) {
+      return LIST_CACHE.get(normalized);
+    }
+    const dir = getQueryDir(normalized);
+    try {
+      const files = await readdir2(dir, { withFileTypes: true });
+      const queries = files.filter((entry) => entry.isFile() && entry.name.endsWith(".scm")).map((entry) => entry.name.replace(/\.scm$/, "")).sort();
+      LIST_CACHE.set(normalized, queries);
+      return queries;
+    } catch {
+      LIST_CACHE.set(normalized, []);
+      return [];
+    }
+  }
+  static async validateQueryLayout(langKey) {
+    const normalized = normalizeLanguage(langKey);
+    const dir = getQueryDir(normalized);
+    const errors = [];
+    const invalidEntries = [];
+    const queries = [];
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          invalidEntries.push(entry.name);
+          errors.push(`invalid_directory:${entry.name}`);
+          continue;
+        }
+        if (!entry.isFile()) {
+          invalidEntries.push(entry.name);
+          errors.push(`invalid_entry:${entry.name}`);
+          continue;
+        }
+        if (!entry.name.endsWith(".scm")) {
+          invalidEntries.push(entry.name);
+          errors.push(`invalid_extension:${entry.name}`);
+          continue;
+        }
+        if (!isValidQueryFileName(entry.name)) {
+          invalidEntries.push(entry.name);
+          errors.push(`invalid_name:${entry.name}`);
+          continue;
+        }
+        queries.push(entry.name.replace(/\.scm$/, ""));
+      }
+      return {
+        valid: errors.length === 0,
+        errors,
+        queries: queries.sort(),
+        invalidEntries
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        valid: false,
+        errors: [`read_error:${message}`],
+        queries: [],
+        invalidEntries: []
+      };
+    }
+  }
+  static async getCoverageReport(langKey) {
+    const normalized = normalizeLanguage(langKey);
+    const queryNames = await this.listQueries(normalized);
+    const queries = [];
+    let totalCaptures = 0;
+    for (const name of queryNames) {
+      const source = await this.getQuerySource(normalized, name);
+      if (!source) continue;
+      const captureCounts = extractCaptureCounts(source);
+      const total = Object.values(captureCounts).reduce((sum, count) => sum + count, 0);
+      totalCaptures += total;
+      queries.push({ name, captureCounts, totalCaptures: total });
+    }
+    return {
+      language: normalized,
+      totalQueries: queries.length,
+      totalCaptures,
+      queries
+    };
+  }
+};
+
+// src/utils/tree-sitter/lsp-adapter.ts
 var SYMBOL_KIND_MAP2 = {
   function_declaration: "Function",
   function_expression: "Function",
@@ -1453,31 +1762,262 @@ var SYMBOL_KIND_MAP2 = {
   trait_definition: "Interface",
   module: "Module"
 };
+var PARSE_CACHE = /* @__PURE__ */ new Map();
+var PARSE_CACHE_TTL_MS = 30 * 1e3;
+var INCREMENTAL_CACHE = /* @__PURE__ */ new Map();
+var INCREMENTAL_CACHE_TTL_MS = 30 * 1e3;
+var PARSE_CACHE_STATS = {
+  incrementalHits: 0,
+  incrementalMisses: 0,
+  fullHits: 0,
+  fullMisses: 0,
+  fallbackCount: 0
+};
+function computeHash2(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function getParseCacheKey(langId, filePath, code) {
+  const hash = computeHash2(code);
+  return `${langId}:${filePath}:${hash}`;
+}
+function getIncrementalCacheKey(langId, filePath) {
+  return `${langId}:${filePath}`;
+}
+function getPositionForIndex(text, index) {
+  let row = 0;
+  let column = 0;
+  let i = 0;
+  const limit = Math.max(0, Math.min(index, text.length));
+  while (i < limit) {
+    if (text[i] === "\n") {
+      row += 1;
+      column = 0;
+    } else {
+      column += 1;
+    }
+    i += 1;
+  }
+  return { row, column };
+}
+function computeTextEdit(oldText, newText) {
+  if (oldText === newText) return null;
+  let startIndex = 0;
+  const oldLen = oldText.length;
+  const newLen = newText.length;
+  const minLen = Math.min(oldLen, newLen);
+  while (startIndex < minLen && oldText[startIndex] === newText[startIndex]) {
+    startIndex += 1;
+  }
+  let oldEndIndex = oldLen;
+  let newEndIndex = newLen;
+  while (oldEndIndex > startIndex && newEndIndex > startIndex && oldText[oldEndIndex - 1] === newText[newEndIndex - 1]) {
+    oldEndIndex -= 1;
+    newEndIndex -= 1;
+  }
+  const startPosition = getPositionForIndex(oldText, startIndex);
+  const oldEndPosition = getPositionForIndex(oldText, oldEndIndex);
+  const newEndPosition = getPositionForIndex(newText, newEndIndex);
+  return {
+    startIndex,
+    oldEndIndex,
+    newEndIndex,
+    startPosition,
+    oldEndPosition,
+    newEndPosition
+  };
+}
+async function parseWithUnified(langId, code, filePath, now, preferIncremental) {
+  const incrementalKey = getIncrementalCacheKey(langId, filePath);
+  const parser = await loadLanguage(langId);
+  const cachedIncremental = INCREMENTAL_CACHE.get(incrementalKey);
+  let usedIncremental = false;
+  if (preferIncremental && cachedIncremental && now < cachedIncremental.expiresAt) {
+    if (cachedIncremental.content === code) {
+      PARSE_CACHE_STATS.incrementalHits += 1;
+      return cachedIncremental.tree;
+    }
+    const edit = computeTextEdit(cachedIncremental.content, code);
+    if (edit) {
+      try {
+        cachedIncremental.tree.edit(edit);
+        const tree2 = parser.parse(code, cachedIncremental.tree);
+        INCREMENTAL_CACHE.set(incrementalKey, {
+          tree: tree2,
+          content: code,
+          expiresAt: now + INCREMENTAL_CACHE_TTL_MS
+        });
+        PARSE_CACHE_STATS.incrementalHits += 1;
+        return tree2;
+      } catch {
+        usedIncremental = true;
+      }
+    } else {
+      usedIncremental = true;
+    }
+  }
+  if (preferIncremental) {
+    PARSE_CACHE_STATS.incrementalMisses += 1;
+  }
+  const fullKey = getParseCacheKey(langId, filePath, code);
+  const cachedFull = PARSE_CACHE.get(fullKey);
+  if (cachedFull && now < cachedFull.expiresAt) {
+    PARSE_CACHE_STATS.fullHits += 1;
+    INCREMENTAL_CACHE.set(incrementalKey, {
+      tree: cachedFull.tree,
+      content: code,
+      expiresAt: now + INCREMENTAL_CACHE_TTL_MS
+    });
+    if (usedIncremental) {
+      PARSE_CACHE_STATS.fallbackCount += 1;
+    }
+    return cachedFull.tree;
+  }
+  PARSE_CACHE_STATS.fullMisses += 1;
+  const tree = parser.parse(code);
+  PARSE_CACHE.set(fullKey, { tree, expiresAt: now + PARSE_CACHE_TTL_MS });
+  INCREMENTAL_CACHE.set(incrementalKey, {
+    tree,
+    content: code,
+    expiresAt: now + INCREMENTAL_CACHE_TTL_MS
+  });
+  if (usedIncremental) {
+    PARSE_CACHE_STATS.fallbackCount += 1;
+  }
+  return tree;
+}
+async function parseWithCache(langId, code, filePath, now = Date.now()) {
+  return parseWithUnified(langId, code, filePath, now, false);
+}
+async function parseWithIncremental(langId, code, filePath, now = Date.now()) {
+  return parseWithUnified(langId, code, filePath, now, true);
+}
+function getParseCacheMetrics() {
+  return {
+    incremental: {
+      hits: PARSE_CACHE_STATS.incrementalHits,
+      misses: PARSE_CACHE_STATS.incrementalMisses,
+      size: INCREMENTAL_CACHE.size
+    },
+    full: {
+      hits: PARSE_CACHE_STATS.fullHits,
+      misses: PARSE_CACHE_STATS.fullMisses,
+      size: PARSE_CACHE.size
+    },
+    fallbackCount: PARSE_CACHE_STATS.fallbackCount
+  };
+}
+function collectSymbolsFromNode(node) {
+  const symbols = [];
+  const kind = SYMBOL_KIND_MAP2[node.type];
+  if (kind) {
+    const name = TreeSitterLspAdapter.getName(node);
+    if (name) {
+      const symbol = {
+        name,
+        kind,
+        range: {
+          start: { line: node.startPosition.row, character: node.startPosition.column },
+          end: { line: node.endPosition.row, character: node.endPosition.column }
+        },
+        children: []
+      };
+      for (const child of node.namedChildren) {
+        symbol.children?.push(...collectSymbolsFromNode(child));
+      }
+      symbols.push(symbol);
+      return symbols;
+    }
+  }
+  for (const child of node.namedChildren) {
+    symbols.push(...collectSymbolsFromNode(child));
+  }
+  return symbols;
+}
 var TreeSitterLspAdapter = class {
-  static async getDocumentSymbols(filePath) {
+  static async getDocumentSymbols(filePath, options) {
     const langId = ParserRegistry.getLanguage(filePath);
     if (!langId) {
       return [];
     }
     try {
-      const parser = await loadLanguage(langId);
-      const content = await readFile2(filePath, "utf-8");
-      const tree = parser.parse(content);
-      return this.collectSymbols(tree.rootNode);
+      const content = await readFile3(filePath, "utf-8");
+      const tree = await parseWithIncremental(langId, content, filePath);
+      const mode = this.resolveSymbolMode(options);
+      const queryName = options?.queryName ?? "symbols";
+      const traversalSymbols = collectSymbolsFromNode(tree.rootNode);
+      const querySymbols = await this.collectSymbolsViaQuery(tree.rootNode, langId, queryName);
+      let result;
+      if (mode === "traversal") {
+        result = traversalSymbols;
+      } else if (mode === "query") {
+        result = querySymbols.length > 0 ? querySymbols : traversalSymbols;
+      } else {
+        result = traversalSymbols.length > 0 ? traversalSymbols : querySymbols;
+      }
+      const traversalCount = this.flattenSymbols(traversalSymbols).length;
+      const queryCount = this.flattenSymbols(querySymbols).length;
+      LspClientManager.getInstance().recordQualitySample(langId, {
+        success: true,
+        empty: result.length === 0,
+        traversalCount,
+        queryCount,
+        at: Date.now()
+      });
+      return result;
     } catch (error) {
+      LspClientManager.getInstance().recordQualitySample(langId, {
+        success: false,
+        empty: true,
+        traversalCount: 0,
+        queryCount: 0,
+        at: Date.now()
+      });
       if (error instanceof Error) {
         throw new Error(`Tree-sitter parse failed for ${filePath}: ${error.message}`);
       }
       throw new Error(`Tree-sitter parse failed for ${filePath}`);
     }
   }
-  static collectSymbols(node) {
-    const symbols = [];
-    const kind = SYMBOL_KIND_MAP2[node.type];
-    if (kind) {
+  static async compareDocumentSymbols(filePath, options) {
+    const langId = ParserRegistry.getLanguage(filePath);
+    if (!langId) {
+      return { traversal: [], query: [], missingInQuery: [], extraInQuery: [] };
+    }
+    const content = await readFile3(filePath, "utf-8");
+    const tree = await parseWithIncremental(langId, content, filePath);
+    const traversal = collectSymbolsFromNode(tree.rootNode);
+    const queryName = options?.queryName ?? "symbols";
+    const query = await this.collectSymbolsViaQuery(tree.rootNode, langId, queryName);
+    return this.compareSymbolSets(traversal, query);
+  }
+  static resolveSymbolMode(options) {
+    if (options?.mode) return options.mode;
+    const raw = String(process.env.PYB_TS_SYMBOLS_MODE ?? "").trim().toLowerCase();
+    if (raw === "query") return "query";
+    if (raw === "compare") return "compare";
+    return "traversal";
+  }
+  static async collectSymbolsViaQuery(node, langId, queryName) {
+    const query = await QueryRegistry.getCompiledQuery(langId, queryName);
+    if (!query) return [];
+    const captures = query.captures(node);
+    const seen = /* @__PURE__ */ new Map();
+    for (const capture of captures) {
+      if (capture.name !== "symbol") continue;
+      seen.set(capture.node.id, capture.node);
+    }
+    return this.buildSymbolTree(Array.from(seen.values()));
+  }
+  static buildSymbolTree(nodes) {
+    const symbolsById = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const kind = SYMBOL_KIND_MAP2[node.type];
+      if (!kind) continue;
       const name = this.getName(node);
-      if (name) {
-        const symbol = {
+      if (!name) continue;
+      symbolsById.set(node.id, {
+        node,
+        symbol: {
           name,
           kind,
           range: {
@@ -1485,18 +2025,66 @@ var TreeSitterLspAdapter = class {
             end: { line: node.endPosition.row, character: node.endPosition.column }
           },
           children: []
-        };
-        for (const child of node.namedChildren) {
-          symbol.children?.push(...this.collectSymbols(child));
         }
-        symbols.push(symbol);
-        return symbols;
-      }
+      });
     }
-    for (const child of node.namedChildren) {
-      symbols.push(...this.collectSymbols(child));
+    const roots = [];
+    for (const entry of symbolsById.values()) {
+      let parent = entry.node.parent;
+      let parentSymbol = null;
+      while (parent) {
+        const parentEntry = symbolsById.get(parent.id);
+        if (parentEntry) {
+          parentSymbol = parentEntry.symbol;
+          break;
+        }
+        parent = parent.parent;
+      }
+      if (parentSymbol) {
+        parentSymbol.children = parentSymbol.children ?? [];
+        parentSymbol.children.push(entry.symbol);
+      } else {
+        roots.push(entry.symbol);
+      }
     }
-    return symbols;
+    const sortSymbols = (items) => {
+      items.sort((a, b) => {
+        if (a.range.start.line !== b.range.start.line) {
+          return a.range.start.line - b.range.start.line;
+        }
+        return a.range.start.character - b.range.start.character;
+      });
+      for (const item of items) {
+        if (item.children && item.children.length > 0) {
+          sortSymbols(item.children);
+        }
+      }
+    };
+    sortSymbols(roots);
+    return roots;
+  }
+  static compareSymbolSets(traversal, query) {
+    const traversalKeys = new Set(this.flattenSymbols(traversal).map(this.symbolKey));
+    const queryKeys = new Set(this.flattenSymbols(query).map(this.symbolKey));
+    const missingInQuery = Array.from(traversalKeys).filter((key) => !queryKeys.has(key));
+    const extraInQuery = Array.from(queryKeys).filter((key) => !traversalKeys.has(key));
+    return { traversal, query, missingInQuery, extraInQuery };
+  }
+  static flattenSymbols(symbols) {
+    const result = [];
+    const walk = (items) => {
+      for (const item of items) {
+        result.push(item);
+        if (item.children && item.children.length > 0) {
+          walk(item.children);
+        }
+      }
+    };
+    walk(symbols);
+    return result;
+  }
+  static symbolKey(symbol) {
+    return `${symbol.name}|${symbol.kind}|${symbol.range.start.line}|${symbol.range.start.character}`;
   }
   static getName(node) {
     const nameNode = node.childForFieldName("name");
@@ -1511,36 +2099,8 @@ var TreeSitterLspAdapter = class {
 };
 
 // src/utils/tree-sitter/scope-analyzer.ts
-import { Query } from "web-tree-sitter";
-import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { createHash } from "crypto";
-var QUERIES = {
-  python: `
-    (function_definition name: (identifier) @name)
-    (parameters (identifier) @param)
-    (assignment left: (identifier) @var)
-    (for_statement left: (identifier) @var)
-  `,
-  typescript: `
-    (function_declaration name: (identifier) @name)
-    (method_definition name: (property_identifier) @name)
-    (variable_declarator name: (identifier) @var)
-    (variable_declarator name: (array_pattern (identifier) @var))
-    (variable_declarator name: (object_pattern (pair_pattern key: (property_identifier) value: (identifier) @var)))
-    (variable_declarator name: (object_pattern (pair_pattern key: (property_identifier) value: (assignment_pattern left: (identifier) @var))))
-    (variable_declarator name: (object_pattern (shorthand_property_identifier_pattern) @var))
-    (required_parameter pattern: (identifier) @param)
-    (required_parameter pattern: (array_pattern (identifier) @param))
-    (required_parameter pattern: (object_pattern (shorthand_property_identifier_pattern) @param))
-    (optional_parameter pattern: (identifier) @param)
-    (shorthand_property_identifier_pattern) @var
-    (catch_clause (identifier) @var)
-    (for_in_statement left: (identifier) @var)
-    (for_statement initializer: (lexical_declaration (variable_declarator name: (identifier) @var)))
-  `
-};
+import { Query as Query2 } from "web-tree-sitter";
+import { createHash as createHash3 } from "crypto";
 var SCOPE_NODE_TYPES = {
   python: /* @__PURE__ */ new Set(["function_definition", "class_definition", "module"]),
   typescript: /* @__PURE__ */ new Set([
@@ -1552,6 +2112,28 @@ var SCOPE_NODE_TYPES = {
     "class_declaration",
     "statement_block",
     "program"
+  ]),
+  go: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "method_declaration",
+    "function_literal",
+    "block",
+    "source_file"
+  ]),
+  rust: /* @__PURE__ */ new Set([
+    "function_item",
+    "impl_item",
+    "trait_item",
+    "block",
+    "source_file"
+  ]),
+  java: /* @__PURE__ */ new Set([
+    "method_declaration",
+    "constructor_declaration",
+    "class_declaration",
+    "interface_declaration",
+    "block",
+    "program"
   ])
 };
 var SCOPE_BOUNDARY_TYPES = {
@@ -1564,26 +2146,32 @@ var SCOPE_BOUNDARY_TYPES = {
     "method_definition",
     "class_declaration",
     "statement_block"
+  ]),
+  go: /* @__PURE__ */ new Set(["function_declaration", "method_declaration", "function_literal"]),
+  rust: /* @__PURE__ */ new Set(["function_item", "impl_item", "trait_item"]),
+  java: /* @__PURE__ */ new Set([
+    "method_declaration",
+    "constructor_declaration",
+    "class_declaration",
+    "interface_declaration"
   ])
 };
-var __filename = fileURLToPath5(import.meta.url);
-var __dirname2 = path3.dirname(__filename);
+function normalizeScopeLanguage(langKey) {
+  if (langKey === "tsx") return "typescript";
+  return langKey;
+}
 async function loadScopeQuery(langKey) {
-  const queryPath = path3.join(__dirname2, "queries", langKey, "locals.scm");
-  try {
-    return await readFile3(queryPath, "utf-8");
-  } catch {
-    return QUERIES[langKey] ?? null;
-  }
+  const normalized = normalizeScopeLanguage(langKey);
+  return QueryRegistry.getQuerySource(normalized, "locals");
 }
 var QUERY_PRIORITY_LANGUAGES = ["typescript", "python"];
 var SCOPE_CACHE = /* @__PURE__ */ new Map();
 var SCOPE_CACHE_TTL_MS = 30 * 1e3;
-function computeHash(value) {
-  return createHash("sha256").update(value).digest("hex");
+function computeHash3(value) {
+  return createHash3("sha256").update(value).digest("hex");
 }
 function getScopeCacheKey(langKey, code, position) {
-  const hash = computeHash(code);
+  const hash = computeHash3(code);
   return `${langKey}:${hash}:${position.row}:${position.column}`;
 }
 function getCachedScope(key, now) {
@@ -1605,7 +2193,7 @@ var ScopeAnalyzer = class {
     if (!queryStr) return { total: 0, unique: 0, names: [] };
     const language = parser.language;
     if (!language) return { total: 0, unique: 0, names: [] };
-    const query = new Query(language, queryStr);
+    const query = new Query2(language, queryStr);
     const tree = parser.parse(code);
     const captures = query.captures(tree.rootNode);
     const names = captures.map((c) => c.node.text);
@@ -1613,7 +2201,8 @@ var ScopeAnalyzer = class {
     return { total: captures.length, unique: uniqueNames.length, names: uniqueNames };
   }
   static isPriorityLanguage(langKey) {
-    return QUERY_PRIORITY_LANGUAGES.includes(langKey);
+    const normalized = normalizeScopeLanguage(langKey);
+    return QUERY_PRIORITY_LANGUAGES.includes(normalized);
   }
   static getPriorityLanguages() {
     return [...QUERY_PRIORITY_LANGUAGES];
@@ -1623,12 +2212,13 @@ var ScopeAnalyzer = class {
     if (!langKey) {
       throw new Error(`Unsupported language for file: ${filename}`);
     }
+    const normalizedLangKey = normalizeScopeLanguage(langKey);
     const now = Date.now();
-    const cacheKey = getScopeCacheKey(langKey, code, position);
+    const cacheKey = getScopeCacheKey(normalizedLangKey, code, position);
     const cached = getCachedScope(cacheKey, now);
     if (cached) return cached;
     const parser = await loadLanguage(langKey);
-    const tree = parser.parse(code);
+    const tree = await parseWithCache(langKey, code, filename, now);
     const node = tree.rootNode.descendantForPosition(position);
     const ancestors = [];
     let current = node;
@@ -1637,7 +2227,7 @@ var ScopeAnalyzer = class {
       current = current.parent;
     }
     const scopeNodes = ancestors.filter((n) => {
-      const types = SCOPE_NODE_TYPES[langKey];
+      const types = SCOPE_NODE_TYPES[normalizedLangKey];
       return types ? types.has(n.type) : false;
     });
     const result = {
@@ -1645,11 +2235,11 @@ var ScopeAnalyzer = class {
       closure: []
     };
     if (scopeNodes.length === 0) return result;
-    const queryStr = await loadScopeQuery(langKey);
+    const queryStr = await loadScopeQuery(normalizedLangKey);
     if (!queryStr) return result;
     const language = parser.language;
     if (!language) return result;
-    const query = new Query(language, queryStr);
+    const query = new Query2(language, queryStr);
     for (let i = 0; i < scopeNodes.length; i++) {
       const scopeNode = scopeNodes[i];
       const captures = query.captures(scopeNode);
@@ -1659,7 +2249,7 @@ var ScopeAnalyzer = class {
         let temp = defNode.parent;
         let isDirect = true;
         while (temp && temp.id !== scopeNode.id) {
-          const boundaryTypes = SCOPE_BOUNDARY_TYPES[langKey];
+          const boundaryTypes = SCOPE_BOUNDARY_TYPES[normalizedLangKey];
           if (boundaryTypes?.has(temp.type)) {
             isDirect = false;
             break;
@@ -1667,7 +2257,7 @@ var ScopeAnalyzer = class {
           temp = temp.parent;
         }
         if (capture.name === "name") {
-          const boundaryTypes = SCOPE_BOUNDARY_TYPES[langKey];
+          const boundaryTypes = SCOPE_BOUNDARY_TYPES[normalizedLangKey];
           if (boundaryTypes?.has(defNode.parent?.type ?? "")) {
             temp = defNode.parent?.parent ?? null;
             isDirect = true;
@@ -1685,7 +2275,7 @@ var ScopeAnalyzer = class {
         }
       }
       if (i === 0 && scopeNode.type === "statement_block") {
-        const boundaryTypes = SCOPE_BOUNDARY_TYPES[langKey];
+        const boundaryTypes = SCOPE_BOUNDARY_TYPES[normalizedLangKey];
         const parent = scopeNode.parent;
         if (parent && boundaryTypes?.has(parent.type)) {
           const parentCaptures = query.captures(parent);
@@ -1731,29 +2321,149 @@ function normalizeUri(filePath) {
   }
   return uri;
 }
-function formatTreeSitterSymbols(symbols, depth = 0) {
-  let text = "";
-  const indent = "  ".repeat(depth);
-  for (const s of symbols) {
-    text += `${indent}- ${s.name} (${s.kind}) [Ln ${s.range.start.line + 1}]
-`;
-    if (s.children && s.children.length > 0) {
-      text += formatTreeSitterSymbols(s.children, depth + 1);
+var SYMBOL_MODULE_KINDS = /* @__PURE__ */ new Set(["Module", "Namespace"]);
+var SYMBOL_CLASS_KINDS = /* @__PURE__ */ new Set(["Class", "Interface", "Struct", "Enum", "Type"]);
+var SYMBOL_FUNCTION_KINDS = /* @__PURE__ */ new Set(["Function", "Method"]);
+function resolveNumberEnv(raw, fallback) {
+  const parsed = Number(raw);
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return fallback;
+}
+function collectSymbolSummary(symbols) {
+  const summary = {
+    total: 0,
+    modules: { count: 0, names: [] },
+    classes: { count: 0, names: [] },
+    functions: { count: 0, names: [] },
+    others: 0
+  };
+  const visit = (items) => {
+    for (const item of items) {
+      summary.total += 1;
+      if (SYMBOL_MODULE_KINDS.has(item.kind)) {
+        summary.modules.count += 1;
+        summary.modules.names.push(item.name);
+      } else if (SYMBOL_CLASS_KINDS.has(item.kind)) {
+        summary.classes.count += 1;
+        summary.classes.names.push(item.name);
+      } else if (SYMBOL_FUNCTION_KINDS.has(item.kind)) {
+        summary.functions.count += 1;
+        summary.functions.names.push(item.name);
+      } else {
+        summary.others += 1;
+      }
+      if (item.children && item.children.length > 0) {
+        visit(item.children);
+      }
     }
-  }
-  return text;
+  };
+  visit(symbols);
+  return summary;
+}
+function formatSummaryList(label, names, maxNames) {
+  if (names.length === 0) return null;
+  const sliced = names.slice(0, maxNames);
+  const suffix = names.length > maxNames ? `, +${names.length - maxNames}` : "";
+  return `${label}: ${sliced.join(", ")}${suffix}`;
+}
+function formatSymbolSummary(summary, maxNames) {
+  const lines = [
+    `Summary: total ${summary.total}, modules ${summary.modules.count}, classes ${summary.classes.count}, functions ${summary.functions.count}`
+  ];
+  const moduleLine = formatSummaryList("Modules", summary.modules.names, maxNames);
+  const classLine = formatSummaryList("Classes", summary.classes.names, maxNames);
+  const functionLine = formatSummaryList("Functions", summary.functions.names, maxNames);
+  if (moduleLine) lines.push(moduleLine);
+  if (classLine) lines.push(classLine);
+  if (functionLine) lines.push(functionLine);
+  return lines.join("\n");
+}
+function renderSymbolTree(symbols, maxNodes) {
+  const lines = [];
+  let rendered = 0;
+  const total = countSymbols(symbols);
+  const visit = (items, depth) => {
+    if (rendered >= maxNodes) return;
+    const indent = "  ".repeat(depth);
+    for (const item of items) {
+      if (rendered >= maxNodes) return;
+      lines.push(`${indent}- ${item.name} (${item.kind}) [Ln ${item.range.start.line + 1}]`);
+      rendered += 1;
+      if (item.children && item.children.length > 0) {
+        visit(item.children, depth + 1);
+      }
+      if (rendered >= maxNodes) return;
+    }
+  };
+  visit(symbols, 0);
+  return {
+    text: lines.join("\n"),
+    rendered,
+    total,
+    truncated: rendered < total
+  };
+}
+function countSymbols(symbols) {
+  let count = 0;
+  const visit = (items) => {
+    for (const item of items) {
+      count += 1;
+      if (item.children && item.children.length > 0) {
+        visit(item.children);
+      }
+    }
+  };
+  visit(symbols);
+  return count;
+}
+function resolveCompareSampleRate() {
+  const raw = Number(process.env.PYB_TS_COMPARE_SAMPLE_RATE);
+  if (Number.isFinite(raw) && raw >= 0) return Math.min(1, raw);
+  return 0.1;
+}
+function shouldSampleCompare() {
+  const rate = resolveCompareSampleRate();
+  if (rate <= 0) return false;
+  if (rate >= 1) return true;
+  return Math.random() < rate;
+}
+function recordCompareMetrics(filePath, comparison) {
+  const language = ParserRegistry.getLanguage(filePath);
+  if (!language) return;
+  const traversal = Array.isArray(comparison?.traversal) ? comparison.traversal : [];
+  const query = Array.isArray(comparison?.query) ? comparison.query : [];
+  const missing = Array.isArray(comparison?.missingInQuery) ? comparison.missingInQuery : [];
+  const extra = Array.isArray(comparison?.extraInQuery) ? comparison.extraInQuery : [];
+  LspClientManager.getInstance().recordCompareSample(language, {
+    traversalCount: countSymbols(traversal),
+    queryCount: countSymbols(query),
+    missingCount: missing.length,
+    extraCount: extra.length,
+    at: Date.now()
+  });
 }
 function formatTreeSitterDocumentSymbolResult(symbols) {
-  const formatted = symbols.length > 0 ? `Document symbols:
-${formatTreeSitterSymbols(symbols)}` : "No symbols found.";
+  if (symbols.length === 0) {
+    return { formatted: "No symbols found.", resultCount: 0, fileCount: 0 };
+  }
+  const maxNodes = resolveNumberEnv(process.env.PYB_TS_SYMBOLS_MAX_NODES, 200);
+  const maxNames = resolveNumberEnv(process.env.PYB_TS_SYMBOLS_SUMMARY_MAX_NAMES, 6);
+  const summary = collectSymbolSummary(symbols);
+  const summaryText = formatSymbolSummary(summary, maxNames);
+  const rendered = renderSymbolTree(symbols, maxNodes);
+  const parts = [`Document symbols:`, summaryText, rendered.text].filter(Boolean);
+  const truncationLine = rendered.truncated ? `Truncated: showing ${rendered.rendered}/${rendered.total} symbols. Set PYB_TS_SYMBOLS_MAX_NODES to increase.` : "";
+  const formatted = truncationLine ? `${parts.join("\n")}
+${truncationLine}` : parts.join("\n");
   return {
     formatted,
     resultCount: symbols.length,
-    fileCount: symbols.length > 0 ? 1 : 0
+    fileCount: 1
   };
 }
 var fastPathFailures = /* @__PURE__ */ new Map();
 var fastPathLastFallbackReason = /* @__PURE__ */ new Map();
+var fastPathHealth = /* @__PURE__ */ new Map();
 var scopeLastFallbackReason = /* @__PURE__ */ new Map();
 var scopeStrategyUsed = /* @__PURE__ */ new Map();
 var operationFallbackReasons = /* @__PURE__ */ new Map();
@@ -1801,7 +2511,9 @@ var FAST_PATH_CONFIG = {
 };
 var FAST_PATH_TIMEOUT_MS = 500;
 var FAST_PATH_CACHE_TTL_MS = 30 * 1e3;
+var FAST_PATH_DOWNGRADE_TIMEOUT_MS = 60 * 1e3;
 var fastPathSymbolCache = /* @__PURE__ */ new Map();
+var fastPathDowngrade = /* @__PURE__ */ new Map();
 function recordFastPathFailure(filePath, reason, now) {
   let perFile = fastPathFailures.get(filePath);
   if (!perFile) {
@@ -1812,15 +2524,114 @@ function recordFastPathFailure(filePath, reason, now) {
   const existing = perFile.get(reason);
   if (!existing || now - existing.firstAt > config.windowMs) {
     perFile.set(reason, { count: 1, firstAt: now, lastAt: now });
-    return;
+  } else {
+    existing.count += 1;
+    existing.lastAt = now;
+  }
+  let state = fastPathHealth.get(filePath);
+  if (!state) {
+    state = {
+      successCount: 0,
+      failureCount: 0,
+      timeoutCount: 0,
+      lastSuccessAt: null,
+      lastFailureAt: null,
+      avgDurationMs: null,
+      durations: []
+    };
+    fastPathHealth.set(filePath, state);
+  }
+  state.failureCount += 1;
+  if (reason === "timeout") {
+    state.timeoutCount += 1;
+    fastPathDowngrade.set(filePath, {
+      until: now + FAST_PATH_DOWNGRADE_TIMEOUT_MS,
+      reason: "timeout"
+    });
+  }
+  state.lastFailureAt = now;
+}
+function recordFastPathSuccess(filePath, durationMs, at) {
+  let state = fastPathHealth.get(filePath);
+  if (!state) {
+    state = {
+      successCount: 0,
+      failureCount: 0,
+      timeoutCount: 0,
+      lastSuccessAt: null,
+      lastFailureAt: null,
+      avgDurationMs: null,
+      durations: []
+    };
+    fastPathHealth.set(filePath, state);
+  }
+  state.successCount += 1;
+  state.lastSuccessAt = at;
+  if (durationMs >= 0) {
+    if (state.avgDurationMs === null) {
+      state.avgDurationMs = durationMs;
+    } else {
+      state.avgDurationMs = (state.avgDurationMs * (state.successCount - 1) + durationMs) / state.successCount;
+    }
+    state.durations.push(durationMs);
+    if (state.durations.length > 50) {
+      state.durations.shift();
+    }
   }
-  existing.count += 1;
-  existing.lastAt = now;
+}
+function resolveFastPathBaseTimeoutMs() {
+  return resolveNumberEnv(process.env.PYB_FAST_PATH_TIMEOUT_BASE_MS, FAST_PATH_TIMEOUT_MS);
+}
+function resolveFastPathTimeoutMinMs() {
+  return resolveNumberEnv(process.env.PYB_FAST_PATH_TIMEOUT_MIN_MS, 200);
+}
+function resolveFastPathTimeoutMaxMs() {
+  return resolveNumberEnv(process.env.PYB_FAST_PATH_TIMEOUT_MAX_MS, 2e3);
+}
+function resolveFastPathBytesPerMs() {
+  return resolveNumberEnv(process.env.PYB_FAST_PATH_TIMEOUT_BYTES_PER_MS, 4e3);
+}
+function resolveFastPathHistoryFactor() {
+  const raw = Number(process.env.PYB_FAST_PATH_TIMEOUT_HISTORY_FACTOR);
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  return 1.2;
+}
+function resolveFastPathHistoryMinSamples() {
+  return resolveNumberEnv(process.env.PYB_FAST_PATH_TIMEOUT_HISTORY_MIN_SAMPLES, 5);
+}
+function computeP95(values) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95));
+  return sorted[index];
+}
+function getFastPathTimeoutMs(filePath, contentLength) {
+  const base = resolveFastPathBaseTimeoutMs();
+  const bytesPerMs = resolveFastPathBytesPerMs();
+  const min = resolveFastPathTimeoutMinMs();
+  const max = resolveFastPathTimeoutMaxMs();
+  const sizeBudget = bytesPerMs > 0 ? Math.ceil(contentLength / bytesPerMs) : 0;
+  let timeout = base + sizeBudget;
+  const state = fastPathHealth.get(filePath);
+  const minSamples = resolveFastPathHistoryMinSamples();
+  if (state && state.durations.length >= minSamples) {
+    const p95 = computeP95(state.durations);
+    if (p95 !== null) {
+      const factor = resolveFastPathHistoryFactor();
+      timeout = Math.max(timeout, Math.ceil(p95 * factor));
+    }
+  }
+  if (timeout < min) return min;
+  if (timeout > max) return max;
+  return timeout;
 }
 function clearFastPathFailures(filePath) {
   fastPathFailures.delete(filePath);
   fastPathLastFallbackReason.delete(filePath);
 }
+function setFastPathLastFallback(filePath, reason, at) {
+  fastPathLastFallbackReason.set(filePath, { reason, at });
+}
 function recordOperationFallback(operation, filePath, reason) {
   let perOperation = operationFallbackReasons.get(operation);
   if (!perOperation) {
@@ -1838,7 +2649,7 @@ function getOperationFallbackSnapshot(operation) {
   }));
 }
 function computeContentHash(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash4("sha256").update(content).digest("hex");
 }
 function getCachedFastPathSymbols(filePath, hash, now) {
   const cached = fastPathSymbolCache.get(filePath);
@@ -1857,6 +2668,13 @@ function setCachedFastPathSymbols(filePath, hash, symbols, now) {
   });
 }
 function shouldSkipFastPath(filePath, now) {
+  const downgrade = fastPathDowngrade.get(filePath);
+  if (downgrade) {
+    if (now < downgrade.until) {
+      return downgrade.reason;
+    }
+    fastPathDowngrade.delete(filePath);
+  }
   const perFile = fastPathFailures.get(filePath);
   if (!perFile) return null;
   for (const [reason, state] of perFile.entries()) {
@@ -2001,11 +2819,57 @@ function resolveScopeStrategy() {
   return "tree-sitter";
 }
 function getDocumentSymbolFallbackSnapshot() {
-  return Array.from(fastPathLastFallbackReason.entries()).map(([filePath, reason]) => ({
+  return Array.from(fastPathLastFallbackReason.entries()).map(([filePath, fallback]) => ({
     filePath,
-    reason
+    reason: fallback.reason,
+    at: fallback.at
   }));
 }
+function getFastPathFailuresSummary() {
+  const summary = {
+    exception: { count: 0, lastAt: null },
+    empty: { count: 0, lastAt: null },
+    timeout: { count: 0, lastAt: null },
+    unsupported: { count: 0, lastAt: null }
+  };
+  for (const perFile of fastPathFailures.values()) {
+    for (const [reason, state] of perFile.entries()) {
+      const entry = summary[reason];
+      entry.count += state.count;
+      entry.lastAt = entry.lastAt === null ? state.lastAt : Math.max(entry.lastAt, state.lastAt);
+    }
+  }
+  for (const fallback of fastPathLastFallbackReason.values()) {
+    if (fallback.reason !== "unsupported") continue;
+    const entry = summary.unsupported;
+    entry.count += 1;
+    entry.lastAt = entry.lastAt === null ? fallback.at : Math.max(entry.lastAt, fallback.at);
+  }
+  return summary;
+}
+function getFastPathLastFallbackSnapshot() {
+  return Array.from(fastPathLastFallbackReason.entries()).map(([filePath, fallback]) => ({
+    filePath,
+    reason: fallback.reason,
+    at: fallback.at
+  }));
+}
+function getFastPathHealthSummary(now) {
+  return Array.from(fastPathHealth.entries()).map(([filePath, state]) => {
+    const downgrade = fastPathDowngrade.get(filePath);
+    const downgradeUntil = downgrade && now < downgrade.until ? downgrade.until : null;
+    return {
+      filePath,
+      successCount: state.successCount,
+      failureCount: state.failureCount,
+      timeoutCount: state.timeoutCount,
+      lastSuccessAt: state.lastSuccessAt,
+      lastFailureAt: state.lastFailureAt,
+      avgDurationMs: state.avgDurationMs,
+      downgradeUntil
+    };
+  });
+}
 function getScopeFallbackSnapshot() {
   return Array.from(scopeLastFallbackReason.entries()).map(([filePath, reason]) => ({
     filePath,
@@ -2465,82 +3329,108 @@ var LspFacade = {
       if (lspFirst) {
         try {
           const lspSymbols = await LspAPI.documentSymbolRaw(input.filePath, rootPath);
+          const lang = ParserRegistry.getLanguage(input.filePath);
+          if (lspSymbols !== null && lang && shouldSampleCompare()) {
+            void TreeSitterLspAdapter.compareDocumentSymbols(input.filePath).then((comparison) => recordCompareMetrics(input.filePath, comparison)).catch(() => {
+            });
+          }
           if (lspSymbols && Array.isArray(lspSymbols) && lspSymbols.length > 0) {
             return formatGenericDocumentSymbolResult(lspSymbols);
           }
           const now = Date.now();
-          const lang = ParserRegistry.getLanguage(input.filePath);
           if (!lang) {
-            fastPathLastFallbackReason.set(input.filePath, "unsupported");
+            setFastPathLastFallback(input.filePath, "unsupported", now);
           } else {
-            let contentHash = null;
-            try {
-              const content = await readFile4(input.filePath, "utf-8");
-              contentHash = computeContentHash(content);
-              const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
-              if (cached) {
-                clearFastPathFailures(input.filePath);
-                return formatTreeSitterDocumentSymbolResult(cached);
+            const skipReason = shouldSkipFastPath(input.filePath, now);
+            if (skipReason) {
+              setFastPathLastFallback(input.filePath, skipReason, now);
+            } else {
+              let contentHash = null;
+              let contentLength = 0;
+              try {
+                const start = Date.now();
+                const content = await readFile4(input.filePath, "utf-8");
+                contentLength = content.length;
+                contentHash = computeContentHash(content);
+                const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
+                if (cached) {
+                  clearFastPathFailures(input.filePath);
+                  recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
+                  return formatTreeSitterDocumentSymbolResult(cached);
+                }
+              } catch {
               }
-            } catch {
-            }
-            try {
-              const symbols = await withTimeout(
-                TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
-                FAST_PATH_TIMEOUT_MS
-              );
-              if (symbols.length > 0) {
-                clearFastPathFailures(input.filePath);
-                if (contentHash) {
-                  setCachedFastPathSymbols(input.filePath, contentHash, symbols, now);
+              try {
+                const start = Date.now();
+                const symbols = await withTimeout(
+                  TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
+                  getFastPathTimeoutMs(input.filePath, contentLength)
+                );
+                if (symbols.length > 0) {
+                  clearFastPathFailures(input.filePath);
+                  if (contentHash) {
+                    setCachedFastPathSymbols(input.filePath, contentHash, symbols, now);
+                  }
+                  recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
+                  return formatTreeSitterDocumentSymbolResult(symbols);
                 }
-                return formatTreeSitterDocumentSymbolResult(symbols);
+                recordFastPathFailure(input.filePath, "empty", now);
+                setFastPathLastFallback(input.filePath, "empty", now);
+              } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const reason = message.toLowerCase().includes("timeout") ? "timeout" : "exception";
+                recordFastPathFailure(input.filePath, reason, now);
+                setFastPathLastFallback(input.filePath, reason, now);
               }
-              recordFastPathFailure(input.filePath, "empty", now);
-              fastPathLastFallbackReason.set(input.filePath, "empty");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              const reason = message.toLowerCase().includes("timeout") ? "timeout" : "exception";
-              recordFastPathFailure(input.filePath, reason, now);
-              fastPathLastFallbackReason.set(input.filePath, reason);
             }
           }
         } catch {
           const now = Date.now();
           const lang = ParserRegistry.getLanguage(input.filePath);
           if (!lang) {
-            fastPathLastFallbackReason.set(input.filePath, "unsupported");
+            setFastPathLastFallback(input.filePath, "unsupported", now);
           } else {
-            let contentHash = null;
-            try {
-              const content = await readFile4(input.filePath, "utf-8");
-              contentHash = computeContentHash(content);
-              const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
-              if (cached) {
-                clearFastPathFailures(input.filePath);
-                return formatTreeSitterDocumentSymbolResult(cached);
+            const skipReason = shouldSkipFastPath(input.filePath, now);
+            if (skipReason) {
+              setFastPathLastFallback(input.filePath, skipReason, now);
+            } else {
+              let contentHash = null;
+              let contentLength = 0;
+              try {
+                const start = Date.now();
+                const content = await readFile4(input.filePath, "utf-8");
+                contentLength = content.length;
+                contentHash = computeContentHash(content);
+                const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
+                if (cached) {
+                  clearFastPathFailures(input.filePath);
+                  recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
+                  return formatTreeSitterDocumentSymbolResult(cached);
+                }
+              } catch {
               }
-            } catch {
-            }
-            try {
-              const symbols = await withTimeout(
-                TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
-                FAST_PATH_TIMEOUT_MS
-              );
-              if (symbols.length > 0) {
-                clearFastPathFailures(input.filePath);
-                if (contentHash) {
-                  setCachedFastPathSymbols(input.filePath, contentHash, symbols, now);
+              try {
+                const start = Date.now();
+                const symbols = await withTimeout(
+                  TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
+                  getFastPathTimeoutMs(input.filePath, contentLength)
+                );
+                if (symbols.length > 0) {
+                  clearFastPathFailures(input.filePath);
+                  if (contentHash) {
+                    setCachedFastPathSymbols(input.filePath, contentHash, symbols, now);
+                  }
+                  recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
+                  return formatTreeSitterDocumentSymbolResult(symbols);
                 }
-                return formatTreeSitterDocumentSymbolResult(symbols);
+                recordFastPathFailure(input.filePath, "empty", now);
+                setFastPathLastFallback(input.filePath, "empty", now);
+              } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const reason = message.toLowerCase().includes("timeout") ? "timeout" : "exception";
+                recordFastPathFailure(input.filePath, reason, now);
+                setFastPathLastFallback(input.filePath, reason, now);
               }
-              recordFastPathFailure(input.filePath, "empty", now);
-              fastPathLastFallbackReason.set(input.filePath, "empty");
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              const reason = message.toLowerCase().includes("timeout") ? "timeout" : "exception";
-              recordFastPathFailure(input.filePath, reason, now);
-              fastPathLastFallbackReason.set(input.filePath, reason);
             }
           }
         }
@@ -2548,42 +3438,48 @@ var LspFacade = {
         const lang = ParserRegistry.getLanguage(input.filePath);
         const now = Date.now();
         if (!lang) {
-          fastPathLastFallbackReason.set(input.filePath, "unsupported");
+          setFastPathLastFallback(input.filePath, "unsupported", now);
         } else {
           const skipReason = shouldSkipFastPath(input.filePath, now);
           if (skipReason) {
-            fastPathLastFallbackReason.set(input.filePath, skipReason);
+            setFastPathLastFallback(input.filePath, skipReason, now);
           } else {
             let contentHash = null;
+            let contentLength = 0;
             try {
+              const start = Date.now();
               const content = await readFile4(input.filePath, "utf-8");
+              contentLength = content.length;
               contentHash = computeContentHash(content);
               const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
               if (cached) {
                 clearFastPathFailures(input.filePath);
+                recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                 return formatTreeSitterDocumentSymbolResult(cached);
               }
             } catch {
             }
             try {
+              const start = Date.now();
               const symbols = await withTimeout(
                 TreeSitterLspAdapter.getDocumentSymbols(input.filePath),
-                FAST_PATH_TIMEOUT_MS
+                getFastPathTimeoutMs(input.filePath, contentLength)
               );
               if (symbols.length > 0) {
                 clearFastPathFailures(input.filePath);
                 if (contentHash) {
                   setCachedFastPathSymbols(input.filePath, contentHash, symbols, now);
                 }
+                recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                 return formatTreeSitterDocumentSymbolResult(symbols);
               }
               recordFastPathFailure(input.filePath, "empty", now);
-              fastPathLastFallbackReason.set(input.filePath, "empty");
+              setFastPathLastFallback(input.filePath, "empty", now);
             } catch (error) {
               const message = error instanceof Error ? error.message : String(error);
               const reason = message.toLowerCase().includes("timeout") ? "timeout" : "exception";
               recordFastPathFailure(input.filePath, reason, now);
-              fastPathLastFallbackReason.set(input.filePath, reason);
+              setFastPathLastFallback(input.filePath, reason, now);
             }
           }
         }
@@ -2723,6 +3619,7 @@ var LspFacade = {
     return {
       ...base,
       installNotices: getInstallNotices(),
+      parseCache: getParseCacheMetrics(),
       fallbacks: {
         documentSymbol: getDocumentSymbolFallbackSnapshot(),
         getScope: getScopeFallbackSnapshot(),
@@ -2732,6 +3629,11 @@ var LspFacade = {
         incomingCalls: getOperationFallbackSnapshot("incomingCalls"),
         outgoingCalls: getOperationFallbackSnapshot("outgoingCalls"),
         boundary: Array.from(LSP_FALLBACK_BOUNDARY.values())
+      },
+      fastPath: {
+        failuresSummary: getFastPathFailuresSummary(),
+        lastFallback: getFastPathLastFallbackSnapshot(),
+        healthSummary: getFastPathHealthSummary(Date.now())
       }
     };
   }
@@ -2740,12 +3642,42 @@ function __resetLspFastPathStateForTests() {
   fastPathFailures.clear();
   fastPathLastFallbackReason.clear();
   fastPathSymbolCache.clear();
+  fastPathHealth.clear();
+  fastPathDowngrade.clear();
 }
 function __resetLspOperationFallbackForTests() {
   operationFallbackReasons.clear();
 }
 function __getLspFastPathFallbackReasonForTests(filePath) {
-  return fastPathLastFallbackReason.get(filePath) ?? null;
+  return fastPathLastFallbackReason.get(filePath)?.reason ?? null;
+}
+function __getLspFastPathHealthForTests(filePath) {
+  return fastPathHealth.get(filePath) ?? null;
+}
+function __setLspFastPathDurationsForTests(filePath, durations) {
+  let state = fastPathHealth.get(filePath);
+  if (!state) {
+    state = {
+      successCount: 0,
+      failureCount: 0,
+      timeoutCount: 0,
+      lastSuccessAt: null,
+      lastFailureAt: null,
+      avgDurationMs: null,
+      durations: []
+    };
+    fastPathHealth.set(filePath, state);
+  }
+  state.durations = [...durations];
+  if (state.durations.length > 0) {
+    const total = state.durations.reduce((acc, value) => acc + value, 0);
+    state.avgDurationMs = total / state.durations.length;
+  } else {
+    state.avgDurationMs = null;
+  }
+}
+function __getFastPathTimeoutForTests(filePath, contentLength) {
+  return getFastPathTimeoutMs(filePath, contentLength);
 }
 function __resetScopeStateForTests() {
   scopeLastFallbackReason.clear();
@@ -2763,6 +3695,18 @@ function __getFallbackBoundaryForTests() {
 function __refreshLspFallbackBoundaryForTests() {
   refreshFallbackBoundaryFromEnv();
 }
+function __formatTreeSitterDocumentSymbolsForTests(symbols, options) {
+  if (symbols.length === 0) return "No symbols found.";
+  const maxNodes = resolveNumberEnv(String(options?.maxNodes ?? ""), 200);
+  const maxNames = resolveNumberEnv(String(options?.summaryMaxNames ?? ""), 6);
+  const summary = collectSymbolSummary(symbols);
+  const summaryText = formatSymbolSummary(summary, maxNames);
+  const rendered = renderSymbolTree(symbols, maxNodes);
+  const parts = [`Document symbols:`, summaryText, rendered.text].filter(Boolean);
+  const truncationLine = rendered.truncated ? `Truncated: showing ${rendered.rendered}/${rendered.total} symbols. Set PYB_TS_SYMBOLS_MAX_NODES to increase.` : "";
+  return truncationLine ? `${parts.join("\n")}
+${truncationLine}` : parts.join("\n");
+}
 
 export {
   formatDiagnosticsPretty,
@@ -2774,9 +3718,13 @@ export {
   __resetLspFastPathStateForTests,
   __resetLspOperationFallbackForTests,
   __getLspFastPathFallbackReasonForTests,
+  __getLspFastPathHealthForTests,
+  __setLspFastPathDurationsForTests,
+  __getFastPathTimeoutForTests,
   __resetScopeStateForTests,
   __getScopeFallbackReasonForTests,
   __getScopeStrategyForTests,
   __getFallbackBoundaryForTests,
-  __refreshLspFallbackBoundaryForTests
+  __refreshLspFallbackBoundaryForTests,
+  __formatTreeSitterDocumentSymbolsForTests
 };