pybao-cli 1.5.45 → 1.5.47

package/dist/{chunk-A3E3KOP5.js → chunk-VDLMXEHU.js}

@@ -1,25 +1,28 @@
 import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
+import {
+  emitTelemetryEvent
+} from "./chunk-TFHFYID3.js";
 import {
   LspServerRegistry,
   findNearestRoot,
   getInstallNotices
-} from "./chunk-BGT7XDPE.js";
+} from "./chunk-5OBGGU2O.js";
 import {
   levenshtein
 } from "./chunk-UZ34JEUK.js";
 import {
   debug
-} from "./chunk-ZJJR2GKA.js";
+} from "./chunk-MWL7Q5HG.js";
 import {
   getCwd,
   getSessionRoot
-} from "./chunk-HFEWWAXY.js";
+} from "./chunk-CN443EB5.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 { extname as extname3 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { readFile as readFile5 } from "fs/promises";
 import * as http from "http";
 import { createHash as createHash4 } from "crypto";
 
@@ -565,7 +568,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-XAPOPN44.js");
+      const { detectPythonVenv } = await import("./registry-A2AB7N66.js");
       const pythonPath = detectPythonVenv(resolvedRoot);
       if (pythonPath) {
         initOpts = { ...initOpts ?? {}, pythonPath };
@@ -660,12 +663,12 @@ var LspClientManager = class _LspClientManager {
       }
       return uri;
     };
-    const flattenSymbols = (items, output = []) => {
+    const flattenSymbols2 = (items, output = []) => {
       for (const item of items) {
         if (!item || typeof item !== "object") continue;
         output.push(item);
         if (Array.isArray(item.children) && item.children.length > 0) {
-          flattenSymbols(item.children, output);
+          flattenSymbols2(item.children, output);
         }
       }
       return output;
@@ -687,7 +690,7 @@ var LspClientManager = class _LspClientManager {
           documentSymbols = await this.documentSymbol(filePath, rootPath) ?? [];
           documentCache.set(filePath, documentSymbols);
         }
-        const flat = flattenSymbols(documentSymbols);
+        const flat = flattenSymbols2(documentSymbols);
         for (const sym of symbols) {
           let match = flat.find(
             (item) => item?.name === sym.name && (sym.kind === void 0 || item?.kind === sym.kind)
@@ -1416,7 +1419,8 @@ function formatGenericDiagnosticsResult(diagnostics) {
     return { formatted: "No diagnostics found.", resultCount: 0, fileCount: 0 };
   }
   const lines = diagnostics.map((d) => {
-    return `[${d.severity === 1 ? "Error" : d.severity === 2 ? "Warning" : "Info"}] Line ${d.range.start.line + 1}: ${d.message}`;
+    const suggestion = d.hint ? ` Suggestion: ${d.hint}` : "";
+    return `[${d.severity === 1 ? "Error" : d.severity === 2 ? "Warning" : "Info"}] Line ${d.range.start.line + 1}: ${d.message}${suggestion}`;
   });
   return {
     formatted: ["Diagnostics:", ...lines].join("\n"),
@@ -2416,9 +2420,234 @@ var ScopeAnalyzer = class {
   }
 };
 
+// src/lsp/fallbackResult.ts
+function inferQuality(source) {
+  if (source === "lsp" || source === "hybrid") return "full";
+  if (source === "tree-sitter") return "partial";
+  return "minimal";
+}
+function inferConfidence(source) {
+  if (source === "lsp" || source === "hybrid" || source === "tree-sitter") return "high";
+  if (source === "token-scan") return "low";
+  return "low";
+}
+function buildEnhancedFallbackResult(input) {
+  return {
+    ...input,
+    quality: input.quality ?? inferQuality(input.source),
+    confidence: input.confidence ?? inferConfidence(input.source)
+  };
+}
+function toLspFallbackResultEvent(input) {
+  return {
+    channel: "lsp",
+    phase: "LSP_FALLBACK_RESULT",
+    timestamp: input.timestamp ?? Date.now(),
+    data: {
+      operation: input.operation,
+      source: input.result.source ?? "none",
+      quality: input.result.quality ?? "minimal",
+      confidence: input.result.confidence ?? "low",
+      reason: input.result.fallbackReason ?? "UNKNOWN",
+      language: input.language,
+      duration: input.duration
+    }
+  };
+}
+
+// src/lsp/treeSitterFallback/index.ts
+function formatFallbackNotice(operation, reason, capability, detail) {
+  const base = `Fallback ${operation} (reason: ${reason}, capability: ${capability})`;
+  return detail ? `${base} ${detail}` : base;
+}
+function buildFallbackResult(input) {
+  return buildEnhancedFallbackResult({
+    formatted: formatFallbackNotice(
+      input.operation,
+      input.reason,
+      input.capability,
+      input.detail
+    ),
+    resultCount: input.resultCount ?? 0,
+    fileCount: input.fileCount ?? 0,
+    source: input.source,
+    fallbackReason: input.reason,
+    fallbackSuggestion: input.fallbackSuggestion
+  });
+}
+
+// src/lsp/treeSitterFallback/diagnosticsHints.ts
+var INCLUDE_PATTERNS = [
+  /missing.*bracket/i,
+  /missing.*brace/i,
+  /missing.*semicolon/i,
+  /unclosed.*string/i,
+  /missing.*keyword/i
+];
+var EXCLUDE_PATTERNS = [
+  /type.*mismatch/i,
+  /undefined/i,
+  /unused/i,
+  /import.*not.*found/i
+];
+function inferDiagnosticsHint(message) {
+  const text = String(message ?? "");
+  if (!text) return void 0;
+  if (EXCLUDE_PATTERNS.some((pattern) => pattern.test(text))) {
+    return void 0;
+  }
+  if (/missing.*semicolon/i.test(text)) {
+    return "Insert a semicolon at the end of the statement.";
+  }
+  if (/missing.*bracket/i.test(text)) {
+    return "Add the missing bracket to complete the expression.";
+  }
+  if (/missing.*brace/i.test(text)) {
+    return "Add the missing brace to close the current block.";
+  }
+  if (/unclosed.*string/i.test(text)) {
+    return "Close the string literal with a matching quote.";
+  }
+  if (/missing.*keyword/i.test(text)) {
+    return "Add the required language keyword to complete the statement.";
+  }
+  if (INCLUDE_PATTERNS.some((pattern) => pattern.test(text))) {
+    return "Apply the syntax fix near this location and rerun diagnostics.";
+  }
+  return void 0;
+}
+function attachDiagnosticsHints(diagnostics) {
+  return diagnostics.map((item) => {
+    const hint = inferDiagnosticsHint(String(item.message ?? ""));
+    if (!hint) return item;
+    return {
+      ...item,
+      hint
+    };
+  });
+}
+
+// src/lsp/treeSitterFallback/workspaceSymbolIndex.ts
+import { extname as extname2 } from "node:path";
+import { readdir as readdir3, readFile as readFile4, stat } from "node:fs/promises";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var DEFAULT_MAX_FILES = 500;
+var DEFAULT_MAX_FILE_SIZE_BYTES = 100 * 1024;
+var DEFAULT_MAX_INDEX_TIME_MS = 3e4;
+var DEFAULT_EXCLUDE = ["node_modules", "dist", ".git", ".pyb"];
+var KIND_TO_LSP = {
+  Class: 5,
+  Function: 12,
+  Interface: 11,
+  Enum: 10,
+  Variable: 13
+};
+function getAllowedExtensions() {
+  return /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"]);
+}
+function shouldExcludePath(pathLike) {
+  const lower = pathLike.toLowerCase();
+  return DEFAULT_EXCLUDE.some((item) => lower.includes(`\\${item.toLowerCase()}\\`) || lower.endsWith(`\\${item.toLowerCase()}`));
+}
+function normalizeRegexResult(match) {
+  if (!match) return null;
+  const name = String(match[1] ?? "").trim();
+  return name.length > 0 ? name : null;
+}
+function parseSymbolsFromContent(content, uri) {
+  const lines = content.split("\n");
+  const symbols = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const className = normalizeRegexResult(/(?:export\s+)?class\s+([A-Za-z_]\w*)/.exec(line));
+    if (className) {
+      symbols.push({ name: className, kind: "Class", line: i, character: line.indexOf(className), uri });
+    }
+    const functionName = normalizeRegexResult(/(?:export\s+)?function\s+([A-Za-z_]\w*)/.exec(line));
+    if (functionName) {
+      symbols.push({ name: functionName, kind: "Function", line: i, character: line.indexOf(functionName), uri });
+    }
+    const interfaceName = normalizeRegexResult(/(?:export\s+)?interface\s+([A-Za-z_]\w*)/.exec(line));
+    if (interfaceName) {
+      symbols.push({ name: interfaceName, kind: "Interface", line: i, character: line.indexOf(interfaceName), uri });
+    }
+    const enumName = normalizeRegexResult(/(?:export\s+)?enum\s+([A-Za-z_]\w*)/.exec(line));
+    if (enumName) {
+      symbols.push({ name: enumName, kind: "Enum", line: i, character: line.indexOf(enumName), uri });
+    }
+    const variableName = normalizeRegexResult(/(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)/.exec(line));
+    if (variableName) {
+      symbols.push({ name: variableName, kind: "Variable", line: i, character: line.indexOf(variableName), uri });
+    }
+  }
+  return symbols;
+}
+async function collectFiles(rootPath, maxFiles, maxIndexTimeMs) {
+  const files = [];
+  const queue = [rootPath];
+  const allowed = getAllowedExtensions();
+  const startedAt = Date.now();
+  while (queue.length > 0 && files.length < maxFiles) {
+    if (Date.now() - startedAt > maxIndexTimeMs) break;
+    const current = queue.shift();
+    if (!current) continue;
+    if (shouldExcludePath(current)) continue;
+    const entries = await readdir3(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const next = `${current}\\${entry.name}`;
+      if (shouldExcludePath(next)) continue;
+      if (entry.isDirectory()) {
+        queue.push(next);
+      } else if (entry.isFile() && allowed.has(extname2(entry.name).toLowerCase())) {
+        files.push(next);
+        if (files.length >= maxFiles) break;
+      }
+    }
+  }
+  return files;
+}
+async function searchWorkspaceSymbolsWithLightweightIndex(input) {
+  const query = String(input.query ?? "").trim().toLowerCase();
+  if (!query) return [];
+  const maxFiles = input.maxFiles ?? Number(process.env.PYB_TS_WORKSPACE_SYMBOL_MAX_FILES ?? DEFAULT_MAX_FILES);
+  const maxFileSizeBytes = input.maxFileSizeBytes ?? Number(process.env.PYB_TS_WORKSPACE_SYMBOL_MAX_FILE_SIZE ?? DEFAULT_MAX_FILE_SIZE_BYTES);
+  const maxIndexTimeMs = input.maxIndexTimeMs ?? Number(process.env.PYB_TS_WORKSPACE_SYMBOL_MAX_INDEX_TIME_MS ?? DEFAULT_MAX_INDEX_TIME_MS);
+  const files = await collectFiles(input.rootPath, maxFiles, maxIndexTimeMs);
+  const matched = [];
+  const startedAt = Date.now();
+  for (const filePath of files) {
+    if (Date.now() - startedAt > maxIndexTimeMs) break;
+    const fileStat = await stat(filePath);
+    if (fileStat.size > maxFileSizeBytes) continue;
+    const content = await readFile4(filePath, "utf8");
+    const uri = pathToFileURL2(filePath).toString();
+    const symbols = parseSymbolsFromContent(content, uri);
+    for (const symbol of symbols) {
+      if (!symbol.name.toLowerCase().includes(query)) continue;
+      matched.push({
+        name: symbol.name,
+        kind: KIND_TO_LSP[symbol.kind],
+        uri: symbol.uri,
+        location: {
+          uri: symbol.uri,
+          range: {
+            start: { line: symbol.line, character: Math.max(0, symbol.character) },
+            end: { line: symbol.line, character: Math.max(0, symbol.character + symbol.name.length) }
+          }
+        },
+        range: {
+          start: { line: symbol.line, character: Math.max(0, symbol.character) },
+          end: { line: symbol.line, character: Math.max(0, symbol.character + symbol.name.length) }
+        }
+      });
+    }
+  }
+  return matched;
+}
+
 // src/lsp/index.ts
 function normalizeUri(filePath) {
-  let uri = pathToFileURL2(filePath).href;
+  let uri = pathToFileURL3(filePath).href;
   if (process.platform === "win32") {
     uri = uri.replace(/^file:\/\/\/([a-zA-Z]):\//, (_match, drive) => {
       return `file:///${drive.toLowerCase()}%3A/`;
@@ -2566,9 +2795,39 @@ ${truncationLine}` : parts.join("\n");
     fileCount: 1
   };
 }
-function formatFallbackNotice(operation, reason, capability, detail) {
-  const base = `Fallback ${operation} (reason: ${reason}, capability: ${capability})`;
-  return detail ? `${base} ${detail}` : base;
+function formatFallbackNotice2(operation, reason, capability, detail) {
+  return formatFallbackNotice(operation, reason, capability, detail);
+}
+function emitFallbackTelemetry(operation, filePath, startedAt, result) {
+  emitTelemetryEvent(
+    toLspFallbackResultEvent({
+      operation,
+      language: ParserRegistry.getLanguage(filePath) ?? "unknown",
+      duration: Date.now() - startedAt,
+      result
+    })
+  );
+}
+function finalizeFallbackResult(operation, filePath, startedAt, result) {
+  emitFallbackTelemetry(operation, filePath, startedAt, result);
+  return result;
+}
+function isWorkspaceSymbolFallbackEnabled() {
+  const raw = String(process.env.PYB_TS_WORKSPACE_SYMBOL_FALLBACK ?? "").trim().toLowerCase();
+  return raw === "1" || raw === "true";
+}
+function toDocumentSymbolTreeSitterFallback(filePath, fallbackReason, formatted) {
+  return buildEnhancedFallbackResult({
+    ...formatted,
+    formatted: formatFallbackNotice2(
+      "documentSymbol",
+      fallbackReason,
+      "tree-sitter symbols",
+      formatted.formatted
+    ),
+    source: "tree-sitter",
+    fallbackReason
+  });
 }
 var fastPathFailures = /* @__PURE__ */ new Map();
 var fastPathLastFallbackReason = /* @__PURE__ */ new Map();
@@ -2887,11 +3146,156 @@ function findSymbolAtPosition(symbols, line, character) {
   for (const sym of symbols) visit(sym);
   return matched;
 }
+function flattenSymbols(symbols) {
+  const result = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    result.push(node);
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        visit(child);
+      }
+    }
+  };
+  for (const symbol of symbols) {
+    visit(symbol);
+  }
+  return result;
+}
+function getSymbolLocation(symbol, filePath) {
+  const range = symbol?.selectionRange ?? symbol?.range ?? symbol?.location?.range;
+  if (!range) return null;
+  return {
+    uri: normalizeUri(filePath),
+    range
+  };
+}
+function pickNearestSymbolByLine(symbols, line) {
+  if (!symbols.length) return null;
+  return [...symbols].sort((a, b) => {
+    const aLine = a?.selectionRange?.start?.line ?? a?.range?.start?.line ?? 0;
+    const bLine = b?.selectionRange?.start?.line ?? b?.range?.start?.line ?? 0;
+    return Math.abs(aLine - line) - Math.abs(bLine - line);
+  })[0];
+}
+async function buildGoToDefinitionUnavailableFallback(input) {
+  const content = await readFile5(input.filePath, "utf-8");
+  const lines = content.split("\n");
+  const zeroLine = input.line - 1;
+  const zeroChar = input.character - 1;
+  const token = extractTokenAtPosition(lines, zeroLine, zeroChar);
+  const symbols = await TreeSitterLspAdapter.getDocumentSymbols(input.filePath);
+  const flat = flattenSymbols(symbols).filter((sym) => typeof sym?.name === "string");
+  if (token) {
+    const exactMatches = flat.filter((sym) => sym.name === token);
+    if (exactMatches.length === 1) {
+      const location = getSymbolLocation(exactMatches[0], input.filePath);
+      if (location) {
+        const formatted = formatGenericDefinitionResult(location);
+        return buildEnhancedFallbackResult({
+          ...formatted,
+          source: "tree-sitter",
+          fallbackReason: input.fallbackReason,
+          fallbackSuggestion: "Enable LSP for cross-file definition resolution.",
+          confidence: "high"
+        });
+      }
+    }
+    if (exactMatches.length > 1) {
+      const selected = pickNearestSymbolByLine(exactMatches, zeroLine);
+      const location = selected ? getSymbolLocation(selected, input.filePath) : null;
+      if (location) {
+        const formatted = formatGenericDefinitionResult(location);
+        return buildEnhancedFallbackResult({
+          ...formatted,
+          source: "tree-sitter",
+          fallbackReason: input.fallbackReason,
+          fallbackSuggestion: "Multiple same-name symbols found; enable LSP for precise semantic disambiguation.",
+          confidence: "medium"
+        });
+      }
+    }
+    const tokenMatches = findTokenOccurrencesInLines(token, lines);
+    if (tokenMatches.length > 0) {
+      const selected = [...tokenMatches].sort((a, b) => a.line - b.line || a.start - b.start)[0];
+      const formatted = formatGenericDefinitionResult({
+        uri: normalizeUri(input.filePath),
+        range: {
+          start: { line: selected.line, character: selected.start },
+          end: { line: selected.line, character: selected.end }
+        }
+      });
+      return buildEnhancedFallbackResult({
+        ...formatted,
+        source: "token-scan",
+        fallbackReason: input.fallbackReason,
+        fallbackSuggestion: "Token match fallback is low confidence; enable LSP for semantic accuracy.",
+        confidence: "low"
+      });
+    }
+  }
+  return buildFallbackResult({
+    operation: "goToDefinition",
+    reason: input.fallbackReason,
+    capability: "none",
+    source: "none",
+    detail: "No same-file definition candidate found.",
+    fallbackSuggestion: "Retry with LSP enabled or provide a narrower symbol context."
+  });
+}
+async function buildHoverUnavailableFallback(input) {
+  const symbols = await TreeSitterLspAdapter.getDocumentSymbols(input.filePath);
+  const symbol = findSymbolAtPosition(symbols, input.line - 1, input.character - 1);
+  if (symbol) {
+    const range = symbol?.range;
+    const rangeText = range ? `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}` : "unknown";
+    const hoverFormatted = formatGenericHoverResult(
+      {
+        contents: `name: ${symbol.name}
+kind: ${symbol.kind}
+range: ${rangeText}`
+      },
+      input.line,
+      input.character
+    );
+    return buildEnhancedFallbackResult({
+      ...hoverFormatted,
+      source: "tree-sitter",
+      fallbackReason: input.fallbackReason,
+      fallbackSuggestion: "Enable LSP to get full type and documentation hover content.",
+      confidence: "high"
+    });
+  }
+  const content = await readFile5(input.filePath, "utf-8");
+  const token = extractTokenAtPosition(content.split("\n"), input.line - 1, input.character - 1);
+  if (token) {
+    const hoverFormatted = formatGenericHoverResult(
+      { contents: `token: ${token}` },
+      input.line,
+      input.character
+    );
+    return buildEnhancedFallbackResult({
+      ...hoverFormatted,
+      source: "token-scan",
+      fallbackReason: input.fallbackReason,
+      fallbackSuggestion: "Token-only hover is minimal; enable LSP for semantic hover details.",
+      confidence: "low"
+    });
+  }
+  return buildFallbackResult({
+    operation: "hover",
+    reason: input.fallbackReason,
+    capability: "none",
+    source: "none",
+    detail: "No hover candidate found.",
+    fallbackSuggestion: "Retry with LSP enabled for full hover support."
+  });
+}
 async function getTreeSitterDiagnostics(filePath) {
   const lang = ParserRegistry.getLanguage(filePath);
   if (!lang) return [];
   const parser = await loadLanguage(lang);
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   const tree = parser.parse(content);
   if (!tree) return [];
   const diagnostics = [];
@@ -2905,9 +3309,24 @@ async function getTreeSitterDiagnostics(filePath) {
       };
       const key = `${range.start.line}:${range.start.character}:${range.end.line}:${range.end.character}:${node.type}`;
       if (!seen.has(key)) {
+        const lowerType = String(node.type ?? "").toLowerCase();
+        let message = `Syntax error near ${node.type}`;
+        if (node.isMissing) {
+          if (lowerType.includes(";")) {
+            message = "missing semicolon near statement";
+          } else if (lowerType.includes(")") || lowerType.includes("(")) {
+            message = "missing bracket near expression";
+          } else if (lowerType.includes("}") || lowerType.includes("{")) {
+            message = "missing brace near block";
+          } else if (lowerType.includes("string") || lowerType.includes('"') || lowerType.includes("'")) {
+            message = "unclosed string literal";
+          } else {
+            message = `missing keyword near ${node.type}`;
+          }
+        }
         diagnostics.push({
           range,
-          message: `Syntax error near ${node.type}`,
+          message,
           severity: 1
         });
         seen.add(key);
@@ -2918,7 +3337,7 @@ async function getTreeSitterDiagnostics(filePath) {
     }
   };
   visit(tree.rootNode);
-  return diagnostics;
+  return attachDiagnosticsHints(diagnostics);
 }
 function sortWorkspaceSymbols(symbols) {
   return [...symbols].sort((a, b) => {
@@ -3049,7 +3468,7 @@ var LspAPI = {
       input.filePath,
       rootPath
     );
-    const ext = extname2(input.filePath);
+    const ext = extname3(input.filePath);
     const fallbackServer = LspServerRegistry.getInstance().getServerForExtension(ext);
     const serverId = client ? client.serverId ?? fallbackServer?.id ?? "unknown" : fallbackServer?.id ?? "unknown";
     const recordAttempt = (operation) => {
@@ -3275,8 +3694,56 @@ var LspAPI = {
       }
     }
     const fallbackOperation = input.operation;
+    const fallbackStartedAt = Date.now();
     recordAttempt(input.operation);
     recordFailure(input.operation, "unavailable");
+    if (fallbackOperation === "workspaceSymbol") {
+      const query = String(input.query ?? "").trim();
+      if (!isWorkspaceSymbolFallbackEnabled()) {
+        return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+          operation: "workspaceSymbol",
+          reason: "lsp-unavailable",
+          capability: "none",
+          source: "none",
+          detail: `No LSP server available for file type: ${ext}. Workspace fallback is disabled.`,
+          fallbackSuggestion: "Set PYB_TS_WORKSPACE_SYMBOL_FALLBACK=1 to enable lightweight index fallback."
+        }));
+      }
+      try {
+        const symbols = await searchWorkspaceSymbolsWithLightweightIndex({
+          rootPath,
+          query
+        });
+        if (symbols.length > 0) {
+          const formatted = formatGenericDocumentSymbolResult(symbols);
+          const fileCount = new Set(symbols.map((item) => String(item.uri ?? item.location?.uri ?? ""))).size;
+          return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildEnhancedFallbackResult({
+            ...formatted,
+            fileCount,
+            source: "tree-sitter",
+            fallbackReason: "lsp-unavailable",
+            fallbackSuggestion: "Lightweight index fallback is partial; enable LSP for full workspace semantics."
+          }));
+        }
+        return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+          operation: "workspaceSymbol",
+          reason: "lsp-unavailable",
+          capability: "tree-sitter index",
+          source: "none",
+          detail: `No workspace symbols matched query "${query}".`,
+          fallbackSuggestion: "Broaden the query or enable LSP for richer workspace symbol resolution."
+        }));
+      } catch {
+        return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+          operation: "workspaceSymbol",
+          reason: "lsp-unavailable",
+          capability: "none",
+          source: "none",
+          detail: "Workspace symbol lightweight index failed.",
+          fallbackSuggestion: "Retry with narrower scope or enable LSP."
+        }));
+      }
+    }
     if (LSP_FALLBACK_BOUNDARY.has(fallbackOperation)) {
       const lang = ParserRegistry.getLanguage(input.filePath);
       const fallbackReason = lang ? "lsp-unavailable" : "unsupported";
@@ -3288,33 +3755,33 @@ var LspAPI = {
           try {
             const diagnostics = await getTreeSitterDiagnostics(input.filePath);
             const formatted = formatGenericDiagnosticsResult(diagnostics);
-            return {
-              formatted: formatFallbackNotice(
+            return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildEnhancedFallbackResult({
+              formatted: formatFallbackNotice2(
                 "diagnostics",
                 fallbackReason,
                 "tree-sitter diagnostics",
                 formatted.formatted
               ),
               resultCount: formatted.resultCount,
-              fileCount: formatted.fileCount
-            };
+              fileCount: formatted.fileCount,
+              source: "tree-sitter",
+              fallbackReason
+            }));
           } catch {
-            return {
-              formatted: formatFallbackNotice(
-                "diagnostics",
-                fallbackReason,
-                "none",
-                `LSP unavailable for ${ext}. Static analysis not available.`
-              ),
-              resultCount: 0,
-              fileCount: 0
-            };
+            return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+              operation: "diagnostics",
+              reason: fallbackReason,
+              capability: "none",
+              source: "none",
+              detail: `LSP unavailable for ${ext}. Static analysis not available.`,
+              fallbackSuggestion: "Retry after LSP is ready or run diagnostics with a supported language server."
+            }));
           }
         }
         if (fallbackOperation === "findReferences") {
           if (input.line !== void 0 && input.character !== void 0) {
             try {
-              const content = await readFile4(input.filePath, "utf-8");
+              const content = await readFile5(input.filePath, "utf-8");
               const lines = content.split("\n");
               const token = extractTokenAtPosition(
                 lines,
@@ -3333,31 +3800,32 @@ var LspAPI = {
                 }));
                 if (refs.length > 0) {
                   const formatted = formatGenericReferencesResult(refs);
-                  return {
-                    formatted: formatFallbackNotice(
+                  return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildEnhancedFallbackResult({
+                    formatted: formatFallbackNotice2(
                       "findReferences",
                       fallbackReason,
                       "token scan",
                       formatted.formatted
                     ),
                     resultCount: formatted.resultCount,
-                    fileCount: formatted.fileCount
-                  };
+                    fileCount: formatted.fileCount,
+                    source: "token-scan",
+                    fallbackReason,
+                    fallbackSuggestion: "Use narrower symbol names or enable LSP for higher precision references."
+                  }));
                 }
               }
             } catch {
             }
           }
-          return {
-            formatted: formatFallbackNotice(
-              "findReferences",
-              fallbackReason,
-              "token scan",
-              `LSP unavailable for ${ext}. Returning 0 references.`
-            ),
-            resultCount: 0,
-            fileCount: 0
-          };
+          return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+            operation: "findReferences",
+            reason: fallbackReason,
+            capability: "token scan",
+            source: "token-scan",
+            detail: `LSP unavailable for ${ext}. Returning 0 references.`,
+            fallbackSuggestion: "Retry with LSP enabled for cross-file reference accuracy."
+          }));
         }
         if (fallbackOperation === "prepareCallHierarchy") {
           if (input.line !== void 0 && input.character !== void 0) {
@@ -3377,50 +3845,51 @@ var LspAPI = {
                   selectionRange: symbol.range
                 };
                 const formatted = formatGenericCallHierarchyItemsResult([item]);
-                return {
-                  formatted: formatFallbackNotice(
+                return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildEnhancedFallbackResult({
+                  formatted: formatFallbackNotice2(
                     "prepareCallHierarchy",
                     fallbackReason,
                     "tree-sitter symbols",
                     formatted.formatted
                   ),
                   resultCount: formatted.resultCount,
-                  fileCount: formatted.fileCount
-                };
+                  fileCount: formatted.fileCount,
+                  source: "tree-sitter",
+                  fallbackReason
+                }));
               }
             } catch {
             }
           }
-          return {
-            formatted: formatFallbackNotice(
-              "prepareCallHierarchy",
-              fallbackReason,
-              "tree-sitter symbols",
-              `LSP unavailable for ${ext}. Returning 0 items.`
-            ),
-            resultCount: 0,
-            fileCount: 0
-          };
+          return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+            operation: "prepareCallHierarchy",
+            reason: fallbackReason,
+            capability: "tree-sitter symbols",
+            source: "tree-sitter",
+            detail: `LSP unavailable for ${ext}. Returning 0 items.`,
+            fallbackSuggestion: "Enable LSP to retrieve full call hierarchy."
+          }));
         }
         if (fallbackOperation === "incomingCalls" || fallbackOperation === "outgoingCalls") {
-          return {
-            formatted: formatFallbackNotice(
-              fallbackOperation,
-              fallbackReason,
-              "none",
-              `LSP unavailable for ${ext}. Returning 0 items.`
-            ),
-            resultCount: 0,
-            fileCount: 0
-          };
+          return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+            operation: fallbackOperation,
+            reason: fallbackReason,
+            capability: "none",
+            source: "none",
+            detail: `LSP unavailable for ${ext}. Returning 0 items.`,
+            fallbackSuggestion: "Enable LSP for incoming/outgoing calls support."
+          }));
         }
       }
     }
-    return {
-      formatted: `No LSP server available for file type: ${ext}`,
-      resultCount: 0,
-      fileCount: 0
-    };
+    return finalizeFallbackResult(fallbackOperation, input.filePath, fallbackStartedAt, buildFallbackResult({
+      operation: fallbackOperation,
+      reason: "unsupported",
+      capability: "none",
+      source: "none",
+      detail: `No LSP server available for file type: ${ext}`,
+      fallbackSuggestion: "Use a supported language extension or configure an LSP server for this file type."
+    }));
   },
   async runAll(inputs) {
     return Promise.all(inputs.map((input) => this.run(input)));
@@ -3535,7 +4004,7 @@ var LspFacade = {
               let contentLength = 0;
               try {
                 const start = Date.now();
-                const content = await readFile4(input.filePath, "utf-8");
+                const content = await readFile5(input.filePath, "utf-8");
                 contentLength = content.length;
                 contentHash = computeContentHash(content);
                 const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
@@ -3544,15 +4013,13 @@ var LspFacade = {
                   recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                   const formatted = formatTreeSitterDocumentSymbolResult(cached);
                   if (fallbackReason) {
-                    return {
-                      ...formatted,
-                      formatted: formatFallbackNotice(
-                        "documentSymbol",
-                        fallbackReason,
-                        "tree-sitter symbols",
-                        formatted.formatted
-                      )
-                    };
+                    const fallback = toDocumentSymbolTreeSitterFallback(
+                      input.filePath,
+                      fallbackReason,
+                      formatted
+                    );
+                    emitFallbackTelemetry("documentSymbol", input.filePath, now, fallback);
+                    return fallback;
                   }
                   return formatted;
                 }
@@ -3572,15 +4039,13 @@ var LspFacade = {
                   recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                   const formatted = formatTreeSitterDocumentSymbolResult(symbols);
                   if (fallbackReason) {
-                    return {
-                      ...formatted,
-                      formatted: formatFallbackNotice(
-                        "documentSymbol",
-                        fallbackReason,
-                        "tree-sitter symbols",
-                        formatted.formatted
-                      )
-                    };
+                    const fallback = toDocumentSymbolTreeSitterFallback(
+                      input.filePath,
+                      fallbackReason,
+                      formatted
+                    );
+                    emitFallbackTelemetry("documentSymbol", input.filePath, now, fallback);
+                    return fallback;
                   }
                   return formatted;
                 }
@@ -3609,7 +4074,7 @@ var LspFacade = {
               let contentLength = 0;
               try {
                 const start = Date.now();
-                const content = await readFile4(input.filePath, "utf-8");
+                const content = await readFile5(input.filePath, "utf-8");
                 contentLength = content.length;
                 contentHash = computeContentHash(content);
                 const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
@@ -3618,15 +4083,13 @@ var LspFacade = {
                   recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                   const formatted = formatTreeSitterDocumentSymbolResult(cached);
                   if (fallbackReason) {
-                    return {
-                      ...formatted,
-                      formatted: formatFallbackNotice(
-                        "documentSymbol",
-                        fallbackReason,
-                        "tree-sitter symbols",
-                        formatted.formatted
-                      )
-                    };
+                    const fallback = toDocumentSymbolTreeSitterFallback(
+                      input.filePath,
+                      fallbackReason,
+                      formatted
+                    );
+                    emitFallbackTelemetry("documentSymbol", input.filePath, now, fallback);
+                    return fallback;
                   }
                   return formatted;
                 }
@@ -3646,15 +4109,13 @@ var LspFacade = {
                   recordFastPathSuccess(input.filePath, Date.now() - start, Date.now());
                   const formatted = formatTreeSitterDocumentSymbolResult(symbols);
                   if (fallbackReason) {
-                    return {
-                      ...formatted,
-                      formatted: formatFallbackNotice(
-                        "documentSymbol",
-                        fallbackReason,
-                        "tree-sitter symbols",
-                        formatted.formatted
-                      )
-                    };
+                    const fallback = toDocumentSymbolTreeSitterFallback(
+                      input.filePath,
+                      fallbackReason,
+                      formatted
+                    );
+                    emitFallbackTelemetry("documentSymbol", input.filePath, now, fallback);
+                    return fallback;
                   }
                   return formatted;
                 }
@@ -3690,7 +4151,7 @@ var LspFacade = {
             let contentLength = 0;
             try {
               const start = Date.now();
-              const content = await readFile4(input.filePath, "utf-8");
+              const content = await readFile5(input.filePath, "utf-8");
               contentLength = content.length;
               contentHash = computeContentHash(content);
               const cached = getCachedFastPathSymbols(input.filePath, contentHash, now);
@@ -3750,7 +4211,7 @@ var LspFacade = {
         }
         const effectiveStrategy = strategy === "lsp" ? "tree-sitter" : strategy;
         scopeStrategyUsed.set(input.filePath, effectiveStrategy);
-        const code = await readFile4(input.filePath, "utf-8");
+        const code = await readFile5(input.filePath, "utf-8");
         const scope = await ScopeAnalyzer.getScope(input.filePath, code, {
           row: input.line - 1,
           column: input.character - 1
@@ -3792,11 +4253,15 @@ var LspFacade = {
           rootPath
         });
         if (!touched) {
-          return {
-            formatted: `No LSP server available for file type: ${extname2(input.filePath)}`,
+          const fallback = buildEnhancedFallbackResult({
+            formatted: `No LSP server available for file type: ${extname3(input.filePath)}`,
             resultCount: 0,
-            fileCount: 0
-          };
+            fileCount: 0,
+            source: "none",
+            fallbackReason: "lsp-unavailable"
+          });
+          emitFallbackTelemetry("diagnostics", input.filePath, Date.now(), fallback);
+          return fallback;
         }
         if (shouldWait) {
           const ready = await LspClientManager.getInstance().waitForReadiness(
@@ -3805,11 +4270,15 @@ var LspFacade = {
             timeoutMs
           );
           if (!ready) {
-            return {
+            const fallback = buildEnhancedFallbackResult({
               formatted: `Diagnostics timeout after ${timeoutMs}ms`,
               resultCount: 0,
-              fileCount: 0
-            };
+              fileCount: 0,
+              source: "none",
+              fallbackReason: "lsp-timeout"
+            });
+            emitFallbackTelemetry("diagnostics", input.filePath, Date.now(), fallback);
+            return fallback;
           }
         }
       } else {
@@ -3819,11 +4288,43 @@ var LspFacade = {
           rootPath
         });
         if (!touched) {
-          return {
-            formatted: `No LSP server available for file type: ${extname2(input.filePath)}`,
+          if (input.operation === "goToDefinition" && input.line !== void 0 && input.character !== void 0) {
+            const startedAt = Date.now();
+            try {
+              const fallback2 = await buildGoToDefinitionUnavailableFallback({
+                filePath: input.filePath,
+                line: input.line,
+                character: input.character,
+                fallbackReason: "lsp-unavailable"
+              });
+              emitFallbackTelemetry("goToDefinition", input.filePath, startedAt, fallback2);
+              return fallback2;
+            } catch {
+            }
+          }
+          if (input.operation === "hover" && input.line !== void 0 && input.character !== void 0) {
+            const startedAt = Date.now();
+            try {
+              const fallback2 = await buildHoverUnavailableFallback({
+                filePath: input.filePath,
+                line: input.line,
+                character: input.character,
+                fallbackReason: "lsp-unavailable"
+              });
+              emitFallbackTelemetry("hover", input.filePath, startedAt, fallback2);
+              return fallback2;
+            } catch {
+            }
+          }
+          const fallback = buildEnhancedFallbackResult({
+            formatted: `No LSP server available for file type: ${extname3(input.filePath)}`,
             resultCount: 0,
-            fileCount: 0
-          };
+            fileCount: 0,
+            source: "none",
+            fallbackReason: "lsp-unavailable"
+          });
+          emitFallbackTelemetry(input.operation, input.filePath, Date.now(), fallback);
+          return fallback;
         }
       }
     }
@@ -3832,7 +4333,15 @@ var LspFacade = {
       const symbols = await LspAPI.workspaceSymbol(query, { rootPath });
       const normalized = symbols.map(normalizeWorkspaceSymbol).filter(Boolean);
       const sorted = sortWorkspaceSymbols(normalized);
-      return formatGenericDocumentSymbolResult(sorted);
+      if (sorted.length > 0) {
+        return formatGenericDocumentSymbolResult(sorted);
+      }
+      return LspAPI.run({
+        operation: "workspaceSymbol",
+        filePath: input.filePath,
+        query,
+        rootPath
+      });
     }
     if (input.operation === "diagnostics") {
       const diagnostics = await LspAPI.diagnostics(input.filePath, rootPath);