@mrclrchtr/supi-code-intelligence 6.3.0 → 7.0.0

package/node_modules/@mrclrchtr/supi-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   "dependencies": {
     "jiti": "^2.7.0",
     "web-tree-sitter": "^0.27.0",
-    "@mrclrchtr/supi-code-runtime": "6.3.0",
-    "@mrclrchtr/supi-core": "6.3.0"
+    "@mrclrchtr/supi-core": "7.0.0",
+    "@mrclrchtr/supi-code-runtime": "7.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/node_modules/@mrclrchtr/supi-tree-sitter/src/provider/tree-sitter-provider.ts

@@ -145,7 +145,9 @@ function mapCalleesAtResult(result: CalleesAtResult): CalleesData {
     },
     callees: result.callees.map((c) => ({
       name: c.name,
+      ...(c.displayName === undefined ? {} : { displayName: c.displayName }),
       startLine: c.range.startLine,
+      startCharacter: c.range.startCharacter,
     })),
     depth: result.depth,
   };

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callee-display-name.ts

@@ -0,0 +1,165 @@
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { GrammarId } from "../types.ts";
+import { normalizeCallName } from "./call-name.ts";
+
+type CalleeSyntaxChild = SyntaxNodeLike & {
+  readonly isExtra: boolean;
+};
+
+type CalleeSyntaxNode = SyntaxNodeLike & {
+  readonly namedChildren: CalleeSyntaxChild[];
+};
+
+type SourcePoint = { row: number; column: number };
+
+type TextReplacement = { start: number; end: number };
+
+type CalleeDisplayNameOptions = {
+  node: SyntaxNodeLike;
+  grammarId: GrammarId;
+  nodeType: string;
+  source: string;
+  sourceLineStarts: readonly number[];
+};
+
+const CALL_NODE_TYPES = new Set([
+  "call_expression",
+  "call",
+  "method_invocation",
+  "new_expression",
+  "object_creation_expression",
+]);
+
+const ARGUMENT_LIST_TYPES = new Set(["arguments", "argument_list", "value_arguments"]);
+
+const RECEIVER_FIELDS = [
+  "function",
+  "constructor",
+  "object",
+  "receiver",
+  "operand",
+  "value",
+  "lhs",
+  "argument",
+] as const;
+
+const RECEIVER_WRAPPER_TYPES = new Set(["navigation_expression", "parenthesized_expression"]);
+
+/**
+ * Create a syntax-shortened label for one structural callee capture.
+ *
+ * The full normalized name remains the identity-bearing value. This helper
+ * only replaces argument-list nodes on the receiver chain with `(…)`; it does
+ * not inspect arbitrary expression text to find parentheses.
+ */
+export function createCalleeDisplayName({
+  node,
+  grammarId,
+  nodeType,
+  source,
+  sourceLineStarts,
+}: CalleeDisplayNameOptions): string | undefined {
+  const replacements: TextReplacement[] = [];
+  collectReceiverArgumentLists(node, replacements, sourceLineStarts);
+  const selected = selectNonOverlappingReplacements(replacements);
+  const start = sourceOffset(node.startPosition, sourceLineStarts);
+  const end = sourceOffset(node.endPosition, sourceLineStarts);
+  if (start < 0 || end < start || end > source.length) return undefined;
+
+  let rendered = source.slice(start, end);
+  for (let index = selected.length - 1; index >= 0; index -= 1) {
+    const replacement = selected[index];
+    if (!replacement || replacement.start < start || replacement.end > end) continue;
+    const relativeStart = replacement.start - start;
+    const relativeEnd = replacement.end - start;
+    rendered = `${rendered.slice(0, relativeStart)}(…)${rendered.slice(relativeEnd)}`;
+  }
+
+  const displayName = normalizeCallName(rendered, grammarId, nodeType);
+  return displayName.length > 0 ? displayName : undefined;
+}
+
+function collectReceiverArgumentLists(
+  node: SyntaxNodeLike,
+  replacements: TextReplacement[],
+  sourceLineStarts: readonly number[],
+): void {
+  const argumentList = findArgumentList(node);
+  if (argumentList && hasNamedChildren(argumentList)) {
+    const start = sourceOffset(argumentList.startPosition, sourceLineStarts);
+    const end = sourceOffset(argumentList.endPosition, sourceLineStarts);
+    if (start >= 0 && end >= start) replacements.push({ start, end });
+  }
+
+  for (const receiver of receiverNodes(node)) {
+    collectReceiverArgumentLists(receiver, replacements, sourceLineStarts);
+  }
+}
+
+function findArgumentList(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  if (!CALL_NODE_TYPES.has(node.type)) return null;
+
+  const field = node.childForFieldName("arguments");
+  if (field) return field;
+
+  const directArgumentList = node.children.find((child) => ARGUMENT_LIST_TYPES.has(child.type));
+  if (directArgumentList) return directArgumentList;
+
+  if (node.type !== "call_expression") return null;
+  const callSuffix = node.children.find((child) => child.type === "call_suffix");
+  return callSuffix?.children.find((child) => child.type === "value_arguments") ?? null;
+}
+
+function receiverNodes(node: SyntaxNodeLike): SyntaxNodeLike[] {
+  for (const fieldName of RECEIVER_FIELDS) {
+    const field = node.childForFieldName(fieldName);
+    if (field) return [field];
+  }
+
+  if (node.type === "call_expression") {
+    return namedChildren(node).filter(
+      (child) => child.type !== "call_suffix" && !ARGUMENT_LIST_TYPES.has(child.type),
+    );
+  }
+
+  if (!RECEIVER_WRAPPER_TYPES.has(node.type)) return [];
+  return namedChildren(node).filter((child) => !ARGUMENT_LIST_TYPES.has(child.type));
+}
+
+function namedChildren(node: SyntaxNodeLike): CalleeSyntaxChild[] {
+  return (node as CalleeSyntaxNode).namedChildren ?? [];
+}
+
+function hasNamedChildren(node: SyntaxNodeLike): boolean {
+  return namedChildren(node).some((child) => !child.isExtra);
+}
+
+function selectNonOverlappingReplacements(
+  replacements: readonly TextReplacement[],
+): TextReplacement[] {
+  const selected: TextReplacement[] = [];
+  const ordered = [...replacements].sort(
+    (left, right) => left.start - right.start || right.end - left.end,
+  );
+
+  for (const replacement of ordered) {
+    const previous = selected[selected.length - 1];
+    if (previous && replacement.start < previous.end) continue;
+    selected.push(replacement);
+  }
+  return selected;
+}
+
+/** Build source offsets for Tree-sitter rows without decoding expression text. */
+export function createSourceLineStarts(source: string): number[] {
+  const lineStarts = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === "\n") lineStarts.push(index + 1);
+  }
+  return lineStarts;
+}
+
+function sourceOffset(point: SourcePoint, lineStarts: readonly number[]): number {
+  const lineStart = lineStarts[point.row];
+  return lineStart === undefined ? -1 : lineStart + point.column;
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callees.ts

@@ -1,11 +1,14 @@
+// biome-ignore-all lint/style/noExcessiveLinesPerFile: callee scope filtering and syntax display mapping stay together.
 // Structural callee extraction — enclosing-scope lookup with per-language queries.
 
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import { validatePublicPositionBounds } from "../coordinates.ts";
 import { detectGrammar } from "../language.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { GrammarId, SourceRange, TreeSitterResult } from "../types.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
 import { normalizeCallName } from "./call-name.ts";
+import { createCalleeDisplayName, createSourceLineStarts } from "./callee-display-name.ts";
 import { extractScopeName } from "./scope.ts";
 
 /** Result shape returned by lookupCalleesAt. */
@@ -16,6 +19,7 @@ export interface CalleesAtResult {
   };
   callees: Array<{
     name: string;
+    displayName?: string;
     range: SourceRange;
   }>;
   depth: "direct" | "deep";
@@ -138,7 +142,7 @@ function findEnclosingScope(
  * 3. Runs a grammar-specific callee query.
  * 4. Filters to captures within that enclosing scope.
  * 5. Excludes nested function/method/callback scopes that do not contain the anchor.
- * 6. Deduplicates by name.
+ * 6. Deduplicates identical capture ranges and returns captures in source order.
  */
 // biome-ignore lint/complexity/useMaxParams: provider function needs runtime + coordinates + depth
 export async function lookupCalleesAt(
@@ -212,6 +216,7 @@ export async function lookupCalleesAt(
       scopes,
       tsPoint,
       depth,
+      source,
     );
 
     const enclosingRange = nodeToSourceRange(enclosingNode);
@@ -318,7 +323,8 @@ function filterCalleeCaptures(
   scopeTypes: ReadonlySet<string>,
   anchor: { row: number; column: number },
   depth: "direct" | "deep" = "direct",
-): Array<{ name: string; range: SourceRange }> {
+  source: string,
+): Array<{ name: string; displayName?: string; range: SourceRange }> {
   const excludeRanges: Array<{
     startRow: number;
     startColumn: number;
@@ -329,8 +335,11 @@ function filterCalleeCaptures(
     collectInnerScopes(enclosingNode, scopeTypes, anchor, excludeRanges);
   }
 
-  const seen = new Set<string>();
-  const callees: Array<{ name: string; range: SourceRange }> = [];
+  const seenRanges = new Set<string>();
+  const callees: Array<{ name: string; displayName?: string; range: SourceRange }> = [];
+  const sourceLineStarts = createSourceLineStarts(source);
+  const syntaxNodes = new Map<string, SyntaxNodeLike>();
+  indexSyntaxNodes(enclosingNode as NamedSyntaxNode, syntaxNodes);
 
   const enclosingStartRow = enclosingNode.startPosition.row;
   const enclosingEndRow = enclosingNode.endPosition.row;
@@ -366,17 +375,66 @@ function filterCalleeCaptures(
     }
 
     const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
-    if (name.length === 0 || seen.has(name)) continue;
-    seen.add(name);
-
-    callees.push({ name, range: capture.range });
+    const rangeKey = sourceRangeKey(capture.range);
+    if (name.length === 0 || seenRanges.has(rangeKey)) continue;
+    seenRanges.add(rangeKey);
+
+    const syntaxNode = syntaxNodes.get(captureNodeKey(capture));
+    const displayName = syntaxNode
+      ? createCalleeDisplayName({
+          node: syntaxNode,
+          grammarId,
+          nodeType: capture.nodeType,
+          source,
+          sourceLineStarts,
+        })
+      : undefined;
+    callees.push({
+      name,
+      ...(displayName === undefined ? {} : { displayName }),
+      range: capture.range,
+    });
   }
 
-  return callees;
+  return callees.sort((left, right) => compareSourceRanges(left.range, right.range));
 }
 
 // ── Internal helpers ──────────────────────────────────────────────────
 
+function sourceRangeKey(range: SourceRange): string {
+  return `${range.startLine}:${range.startCharacter}:${range.endLine}:${range.endCharacter}`;
+}
+
+type NamedSyntaxNode = SyntaxNodeLike & { namedChildren: NamedSyntaxNode[] };
+
+/** Query captures use named nodes. Skip anonymous tokens and avoid recursive indexing. */
+function indexSyntaxNodes(node: NamedSyntaxNode, index: Map<string, SyntaxNodeLike>): void {
+  const pending = [node];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current) break;
+    index.set(syntaxNodeKey(current), current);
+    for (const child of current.namedChildren) pending.push(child);
+  }
+}
+
+function syntaxNodeKey(node: SyntaxNodeLike): string {
+  return `${node.type}:${node.startPosition.row}:${node.startPosition.column}:${node.endPosition.row}:${node.endPosition.column}`;
+}
+
+function captureNodeKey(capture: { nodeType: string; range: SourceRange }): string {
+  return `${capture.nodeType}:${capture.range.startLine - 1}:${capture.range.startCharacter - 1}:${capture.range.endLine - 1}:${capture.range.endCharacter - 1}`;
+}
+
+function compareSourceRanges(left: SourceRange, right: SourceRange): number {
+  return (
+    left.startLine - right.startLine ||
+    left.startCharacter - right.startCharacter ||
+    left.endLine - right.endLine ||
+    left.endCharacter - right.endCharacter
+  );
+}
+
 /** Convert a tree-sitter node to a SourceRange using the source text for
  * UTF-16 column conversion. */
 function nodeToSourceRange(node: {

package/node_modules/@mrclrchtr/supi-tree-sitter/src/types.ts

@@ -56,6 +56,8 @@ export interface CalleesAtResult {
   };
   callees: Array<{
     name: string;
+    /** Optional syntax-shortened label for presentation; does not replace `name`. */
+    displayName?: string;
     range: SourceRange;
   }>;
   depth: "direct" | "deep";

package/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -64,46 +64,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;

package/node_modules/yaml/browser/dist/nodes/Alias.js

@@ -43,38 +43,40 @@ class Alias extends NodeBase {
             if (node.anchor === this.source)
                 found = node;
         }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
-        const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        let data = anchors.get(source);
-        if (!data) {
-            // Resolve anchors for Node.prototype.toJS()
-            toJS(source, null, ctx);
-            data = anchors.get(source);
-        }
-        /* istanbul ignore if */
-        if (data?.res === undefined) {
-            const msg = 'This should not happen: Alias anchor was not resolved?';
-            throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-            data.count += 1;
-            if (data.aliasCount === 0)
-                data.aliasCount = getAliasCount(doc, source, anchors);
-            if (data.count * data.aliasCount > maxAliasCount) {
-                const msg = 'Excessive alias count indicates a resource exhaustion attack';
-                throw new ReferenceError(msg);
-            }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
     }
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;

package/node_modules/yaml/dist/compose/resolve-flow-scalar.js

@@ -66,46 +66,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;

package/node_modules/yaml/dist/nodes/Alias.js

@@ -45,38 +45,40 @@ class Alias extends Node.NodeBase {
             if (node.anchor === this.source)
                 found = node;
         }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS.toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
-        const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        let data = anchors.get(source);
-        if (!data) {
-            // Resolve anchors for Node.prototype.toJS()
-            toJS.toJS(source, null, ctx);
-            data = anchors.get(source);
-        }
-        /* istanbul ignore if */
-        if (data?.res === undefined) {
-            const msg = 'This should not happen: Alias anchor was not resolved?';
-            throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-            data.count += 1;
-            if (data.aliasCount === 0)
-                data.aliasCount = getAliasCount(doc, source, anchors);
-            if (data.count * data.aliasCount > maxAliasCount) {
-                const msg = 'Excessive alias count indicates a resource exhaustion attack';
-                throw new ReferenceError(msg);
-            }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
     }
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;

package/node_modules/yaml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "license": "ISC",
   "author": "Eemeli Aro <eemeli@gmail.com>",
   "funding": "https://github.com/sponsors/eemeli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "description": "LSP and AST navigation, search, diagnostics, and refactoring",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-code-runtime": "6.3.0",
-    "@mrclrchtr/supi-core": "6.3.0",
-    "@mrclrchtr/supi-tree-sitter": "6.3.0",
-    "@mrclrchtr/supi-lsp": "6.3.0"
+    "@mrclrchtr/supi-code-runtime": "7.0.0",
+    "@mrclrchtr/supi-lsp": "7.0.0",
+    "@mrclrchtr/supi-core": "7.0.0",
+    "@mrclrchtr/supi-tree-sitter": "7.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/health/diagnostics.ts

@@ -312,8 +312,7 @@ function evidenceIsComplete(
 function diagnosticEvidenceReason(evidence: DiagnosticEvidenceSummary): string {
   let reason = `Diagnostic evidence is partial: ${evidence.requested} requested, ${evidence.confirmed} confirmed, ${evidence.unconfirmed} unconfirmed, ${evidence.failed} failed, ${evidence.removed} removed.`;
   if (evidence.unconfirmed > 0) {
-    reason +=
-      " Unconfirmed documents await a later diagnostic republish before their evidence can be confirmed (ADR 0021).";
+    reason += " Unconfirmed documents have no request-based confirmation.";
   }
   return reason;
 }

package/src/analysis/health/file-scope.ts

@@ -16,6 +16,7 @@ import {
   type DiagnosticEvidenceSummary,
   type FileScopeDecision,
   getFileScopeDecision,
+  isTsconfigApplicableFile,
   TENTATIVE_PUSH_UNAVAILABLE_REASON,
   type WorkspaceLspRuntime,
 } from "@mrclrchtr/supi-lsp/api";
@@ -26,7 +27,7 @@ import type {
   HealthDiagnosticScope,
 } from "../../session/health-types.ts";
 
-/** Collect a live per-file diagnostic pull with its tsconfig scope decision. */
+/** Collect a live per-file diagnostic pull with an applicable config scope decision. */
 export async function collectScopedFileDiagnostics(options: {
   service: WorkspaceLspRuntime;
   scope: Extract<HealthDiagnosticScope, { kind: "file" }>;
@@ -87,6 +88,8 @@ export async function collectScopedFileDiagnostics(options: {
  * a failure to compute never fails the diagnostic request.
  */
 export function fileScopeStatus(filePath: string, cwd: string): FileScopeDecision | null {
+  if (!isTsconfigApplicableFile(filePath)) return null;
+
   try {
     return getFileScopeDecision(filePath, cwd);
   } catch {