@mrclrchtr/supi-code-intelligence 1.6.0 → 1.7.0

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "SuPi Tree-sitter extension — structural AST analysis for pi",
   "license": "MIT",
   "repository": {
@@ -24,7 +24,7 @@
   ],
   "dependencies": {
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-core": "1.6.0"
+    "@mrclrchtr/supi-core": "1.7.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "SuPi Code Intelligence extension — architecture briefs, caller/callee analysis, impact assessment, and pattern search for pi",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,9 @@
     "src/**/*.ts"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "1.6.0",
-    "@mrclrchtr/supi-lsp": "1.6.0",
-    "@mrclrchtr/supi-tree-sitter": "1.6.0"
+    "@mrclrchtr/supi-core": "1.7.0",
+    "@mrclrchtr/supi-tree-sitter": "1.7.0",
+    "@mrclrchtr/supi-lsp": "1.7.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core",

package/src/actions/affected-action.ts

@@ -8,22 +8,15 @@ import {
   summarizePrioritySignalsForFiles,
 } from "../prioritization-signals.ts";
 import { getSemanticService } from "../providers/semantic-provider.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import { resolveTarget } from "../resolve-target.ts";
-import {
-  escapeRegex,
-  filterOutDeclaration,
-  isInProjectPath,
-  normalizePath,
-  runRipgrep,
-  uriToFile,
-} from "../search-helpers.ts";
+import { filterOutDeclaration, isInProjectPath, uriToFile } from "../search-helpers.ts";
 import {
   dedupeFileLineRefs,
   highestConfidence,
   isResolvedTargetGroup,
 } from "../semantic-action-helpers.ts";
 import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
-import type { ActionParams } from "../tool-actions.ts";
 import type { AffectedDetails, CodeIntelResult, ConfidenceMode } from "../types.ts";
 
 export async function executeAffectedAction(
@@ -89,7 +82,15 @@ async function executeSingleAffected(
     cwd,
     analysis.affectedFiles.size > 0 ? [...analysis.affectedFiles] : [target.file],
   );
-  const content = formatAffectedOutput(symbolName, refs, analysis, params, prioritySignals);
+  const content = formatAffectedOutput(
+    symbolName,
+    refs,
+    analysis,
+    params,
+    prioritySignals,
+    target,
+    cwd,
+  );
   const details: AffectedDetails = {
     confidence: analysis.confidence,
     directCount: refs.refs.length,
@@ -98,10 +99,7 @@ async function executeSingleAffected(
     checkNext: analysis.checkNext,
     likelyTests: analysis.likelyTests,
     omittedCount: computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, params),
-    nextQueries: [
-      "`code_intel brief` on the most-affected module for deeper context",
-      `\`code_intel callers\` with \`symbol: "${symbolName}"\` for grouped call-site detail`,
-    ],
+    nextQueries: buildAffectedNextQueries(target, symbolName, cwd),
     prioritySignals,
   };
   return { content, details: { type: "affected" as const, data: details } };
@@ -160,7 +158,7 @@ async function executeFileLevelAffected(
   addCheckNextSection(lines, analysis.checkNext);
   addTestsSection(lines, analysis.likelyTests);
   lines.push("## Next");
-  lines.push("- `code_intel brief` on the most-affected module for deeper context");
+  lines.push("- `code_brief` on the most-affected module for deeper context");
   lines.push("- Use `file` + coordinates to inspect one exported target precisely");
   lines.push("");
 
@@ -173,7 +171,7 @@ async function executeFileLevelAffected(
     likelyTests: analysis.likelyTests,
     omittedCount: computeOmittedCount(analysis.externalRefs, analysis.affectedFiles.size, params),
     nextQueries: [
-      "`code_intel brief` on the most-affected module for deeper context",
+      "`code_brief` on the most-affected module for deeper context",
       "Use `file` + coordinates to inspect one exported target precisely",
     ],
     prioritySignals,
@@ -182,45 +180,40 @@ async function executeFileLevelAffected(
   return { content: lines.join("\n"), details: { type: "affected" as const, data: details } };
 }
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: multi-source reference gathering with fallback logic
 async function gatherReferences(
   target: ResolvedTarget,
-  params: ActionParams,
+  _params: ActionParams,
   cwd: string,
 ): Promise<{ refs: GatheredRef[]; confidence: ConfidenceMode; externalCount: number }> {
   const lsp = await getSemanticService(cwd, { waitForReady: true });
+  if (!lsp) {
+    return { refs: [], confidence: "unavailable", externalCount: 0 };
+  }
+
+  const lspRefs = await lsp.references(target.file, target.position);
+  if (lspRefs === null) {
+    return { refs: [], confidence: "unavailable", externalCount: 0 };
+  }
+
   const refs: GatheredRef[] = [];
   let externalCount = 0;
+  const filtered = filterOutDeclaration(lspRefs, target.file, target.position);
 
-  if (lsp) {
-    const lspRefs = await lsp.references(target.file, target.position);
-    if (lspRefs && lspRefs.length > 0) {
-      const filtered = filterOutDeclaration(lspRefs, target.file, target.position);
-      for (const ref of filtered) {
-        const filePath = uriToFile(ref.uri);
-        if (isInProjectPath(filePath, cwd)) {
-          refs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
-        } else {
-          externalCount++;
-        }
-      }
-      return { refs, confidence: "semantic", externalCount };
+  for (const ref of lspRefs) {
+    const filePath = uriToFile(ref.uri);
+    if (!isInProjectPath(filePath, cwd)) {
+      externalCount++;
     }
   }
 
-  if (target.name) {
-    const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
-    const pattern = `\\b${escapeRegex(target.name)}\\b`;
-    const matches = runRipgrep(pattern, scopePath, cwd, { maxMatches: 30 });
-    for (const m of matches) {
-      if (!isDeclarationMatch(m.file, m.line, target, cwd)) {
-        refs.push({ file: path.relative(cwd, path.resolve(cwd, m.file)), line: m.line });
-      }
+  for (const ref of filtered) {
+    const filePath = uriToFile(ref.uri);
+    if (isInProjectPath(filePath, cwd)) {
+      refs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
     }
-    return { refs, confidence: "heuristic", externalCount: 0 };
   }
 
-  return { refs, confidence: "unavailable", externalCount: 0 };
+  return { refs, confidence: "semantic", externalCount };
 }
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: impact analysis with downstream module traversal
@@ -303,6 +296,8 @@ function formatAffectedOutput(
   analysis: ImpactAnalysis,
   params: ActionParams,
   prioritySignals: import("../prioritization-signals.ts").PrioritySignalsSummary | null,
+  target: ResolvedTarget,
+  cwd: string,
 ): string {
   const totalRefs = result.refs.length + analysis.externalRefs;
   const lines: string[] = [];
@@ -328,7 +323,12 @@ function formatAffectedOutput(
   appendPrioritySignalsSection(lines, prioritySignals);
   addCheckNextSection(lines, analysis.checkNext);
   addTestsSection(lines, analysis.likelyTests);
-  addAffectedNextQueries(lines, symbolName, analysis);
+  addAffectedNextQueries(lines, {
+    target,
+    symbolName,
+    showBriefQuery: analysis.checkNext.length > 0,
+    cwd,
+  });
 
   return lines.join("\n");
 }
@@ -416,24 +416,37 @@ function formatFileLevelAffectedHeader(
 
 function addAffectedNextQueries(
   lines: string[],
-  symbolName: string,
-  analysis: ImpactAnalysis,
+  options: {
+    target: ResolvedTarget;
+    symbolName: string;
+    showBriefQuery: boolean;
+    cwd: string;
+  },
 ): void {
   lines.push("## Next");
-  if (analysis.checkNext.length > 0) {
-    lines.push("- `code_intel brief` on the most-affected module for deeper context");
+  const nextQueries = buildAffectedNextQueries(options.target, options.symbolName, options.cwd);
+  if (options.showBriefQuery) {
+    lines.push(`- ${nextQueries[0]}`);
   }
-  lines.push(
-    `- \`code_intel callers\` with \`symbol: "${symbolName}"\` for grouped call-site detail`,
-  );
+  lines.push(`- ${nextQueries[1]}`);
   lines.push("");
 }
 
-function isDeclarationMatch(
-  file: string,
-  line: number,
+function buildAffectedNextQueries(
   target: ResolvedTarget,
+  symbolName: string,
   cwd: string,
-): boolean {
-  return path.resolve(cwd, file) === target.file && line === target.displayLine;
+): [string, string] {
+  const briefQuery = "`code_brief` on the most-affected module for deeper context";
+  if (target.name) {
+    return [
+      briefQuery,
+      `\`code_relations\` with \`kind: "callers"\` and \`symbol: "${symbolName}"\` for grouped call-site detail`,
+    ];
+  }
+
+  return [
+    briefQuery,
+    `\`code_relations\` with \`kind: "callers"\`, \`file: "${path.relative(cwd, target.file)}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for grouped call-site detail`,
+  ];
 }

package/src/actions/brief-action.ts

@@ -6,8 +6,13 @@ import type { TreeSitterService } from "@mrclrchtr/supi-tree-sitter/api";
 import { buildArchitectureModel, findModuleForPath } from "../architecture.ts";
 import { generateFocusedBrief, generateProjectBrief } from "../brief.ts";
 import { withStructuralSession } from "../providers/structural-provider.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import { normalizePath } from "../search-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
+import {
+  type ResolvedTarget,
+  resolveSymbolTarget,
+  type TargetResolutionResult,
+} from "../target-resolution.ts";
 import type { CodeIntelResult } from "../types.ts";
 
 export async function executeBriefAction(
@@ -52,14 +57,18 @@ export async function executeBriefAction(
           dependencySummary: mod && model ? { moduleCount: 1, edgeCount: 0 } : null,
           omittedCount: 0,
           nextQueries: [
-            `\`code_intel callers\` with \`file: "${relPath}", line: ${params.line}, character: ${params.character}\` for call sites`,
-            `\`code_intel affected\` with \`file: "${relPath}", line: ${params.line}, character: ${params.character}\` for impact analysis`,
+            `\`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${params.line}\`, and \`character: ${params.character}\` for call sites`,
+            `\`code_affected\` with \`file: "${relPath}"\`, \`line: ${params.line}\`, and \`character: ${params.character}\` for impact analysis`,
           ],
         },
       },
     };
   }
 
+  if (params.symbol) {
+    return executeSymbolBrief(params, cwd, model);
+  }
+
   if (params.path) {
     const result = generateFocusedBrief(model, normalizePath(params.path, cwd));
     return { content: result.content, details: { type: "brief" as const, data: result.details } };
@@ -74,6 +83,29 @@ export async function executeBriefAction(
   return { content: result.content, details: { type: "brief" as const, data: result.details } };
 }
 
+async function executeSymbolBrief(
+  params: ActionParams,
+  cwd: string,
+  model: NonNullable<Awaited<ReturnType<typeof buildArchitectureModel>>>,
+): Promise<CodeIntelResult> {
+  const symbol = params.symbol ?? "";
+  const resolved = await resolveSymbolTarget(symbol, cwd, { path: params.path });
+
+  if (resolved.kind === "error") {
+    return createUnavailableSymbolBriefResult(symbol, resolved.message);
+  }
+
+  if (resolved.kind === "disambiguation") {
+    return createUnavailableSymbolBriefResult(
+      symbol,
+      formatBriefDisambiguation(symbol, resolved),
+      resolved.omittedCount,
+    );
+  }
+
+  return buildResolvedSymbolBriefResult(resolved.target, cwd, model);
+}
+
 async function executeAnchoredBrief(
   params: ActionParams,
   cwd: string,
@@ -99,6 +131,63 @@ async function executeAnchoredBrief(
   return lines.join("\n");
 }
 
+async function buildResolvedSymbolBriefResult(
+  target: ResolvedTarget,
+  cwd: string,
+  model: NonNullable<Awaited<ReturnType<typeof buildArchitectureModel>>>,
+): Promise<CodeIntelResult> {
+  const relPath = path.relative(cwd, target.file);
+  const content = await executeResolvedSymbolBrief(target, cwd, model);
+  const mod = findModuleForPath(model, target.file);
+
+  return {
+    content,
+    details: {
+      type: "brief" as const,
+      data: {
+        confidence: target.confidence,
+        focusTarget: `${target.name ?? relPath}:${target.displayLine}:${target.displayCharacter}`,
+        startHere: [],
+        publicSurfaces: [],
+        dependencySummary: mod ? { moduleCount: 1, edgeCount: 0 } : null,
+        omittedCount: 0,
+        nextQueries: [
+          `\`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for call sites`,
+          `\`code_affected\` with \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for impact analysis`,
+        ],
+      },
+    },
+  };
+}
+
+async function executeResolvedSymbolBrief(
+  target: ResolvedTarget,
+  cwd: string,
+  model: NonNullable<Awaited<ReturnType<typeof buildArchitectureModel>>>,
+): Promise<string> {
+  const relPath = path.relative(cwd, target.file);
+  const lines: string[] = [];
+
+  lines.push(`# Symbol Brief: ${target.name ?? relPath}`);
+  lines.push("");
+  lines.push(
+    `**Resolved to:** \`${relPath}:${target.displayLine}:${target.displayCharacter}\`${target.kind ? ` (${target.kind})` : ""}`,
+  );
+  lines.push("");
+
+  await addTreeSitterContext({
+    lines,
+    relPath,
+    line1: target.displayLine,
+    char1: target.displayCharacter,
+    cwd,
+  });
+  addModuleContext(lines, model, target.file);
+  addNextQueries(lines, relPath, target.displayLine, target.displayCharacter);
+
+  return lines.join("\n");
+}
+
 interface TreeSitterContextInput {
   lines: string[];
   relPath: string;
@@ -232,10 +321,58 @@ function addModuleContext(
 function addNextQueries(lines: string[], relPath: string, line1: number, char1: number): void {
   lines.push("## Next");
   lines.push(
-    `- \`code_intel callers\` with \`file: "${relPath}", line: ${line1}, character: ${char1}\` for call sites`,
+    `- \`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${line1}\`, and \`character: ${char1}\` for call sites`,
+  );
+  lines.push(
+    `- \`code_affected\` with \`file: "${relPath}"\`, \`line: ${line1}\`, and \`character: ${char1}\` for impact analysis`,
   );
+  lines.push("");
+}
+
+function createUnavailableSymbolBriefResult(
+  symbol: string,
+  content: string,
+  omittedCount = 0,
+): CodeIntelResult {
+  return {
+    content,
+    details: {
+      type: "brief" as const,
+      data: {
+        confidence: "unavailable",
+        focusTarget: symbol,
+        startHere: [],
+        publicSurfaces: [],
+        dependencySummary: null,
+        omittedCount,
+        nextQueries: [
+          "Use `file` + coordinates for a precise symbol brief, or enable LSP and retry",
+        ],
+      },
+    },
+  };
+}
+
+function formatBriefDisambiguation(
+  symbol: string,
+  result: Extract<TargetResolutionResult, { kind: "disambiguation" }>,
+): string {
+  const lines: string[] = [];
+  lines.push(`# Disambiguation needed for \`${symbol}\``);
+  lines.push("");
+  const omitNote = result.omittedCount > 0 ? ` (+${result.omittedCount} more)` : "";
   lines.push(
-    `- \`code_intel affected\` with \`file: "${relPath}", line: ${line1}, character: ${char1}\` for impact analysis`,
+    `Found ${result.candidates.length} candidates${omitNote}. Rerun with anchored coordinates:`,
   );
   lines.push("");
+
+  for (const candidate of result.candidates) {
+    const kind = candidate.kind ? ` (${candidate.kind})` : "";
+    const container = candidate.container ? ` in ${candidate.container}` : "";
+    lines.push(
+      `${candidate.rank}. **${candidate.name}**${kind}${container} — \`${candidate.file}\`:${candidate.line}:${candidate.character}`,
+    );
+  }
+
+  return lines.join("\n");
 }

package/src/actions/callees-action.ts

@@ -4,9 +4,9 @@
 
 import * as path from "node:path";
 import { withStructuralSession } from "../providers/structural-provider.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import { resolveTarget } from "../resolve-target.ts";
 import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
 import type { CodeIntelResult, SearchDetails } from "../types.ts";
 
 export async function executeCalleesAction(

package/src/actions/callers-action.ts

@@ -2,22 +2,15 @@
 
 import * as path from "node:path";
 import { getSemanticService } from "../providers/semantic-provider.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import { resolveTarget } from "../resolve-target.ts";
-import {
-  escapeRegex,
-  filterOutDeclaration,
-  isInProjectPath,
-  normalizePath,
-  runRipgrep,
-  uriToFile,
-} from "../search-helpers.ts";
+import { filterOutDeclaration, isInProjectPath, uriToFile } from "../search-helpers.ts";
 import {
   dedupeFileLineRefs,
   highestConfidence,
   isResolvedTargetGroup,
 } from "../semantic-action-helpers.ts";
 import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
-import type { ActionParams } from "../tool-actions.ts";
 import type { CodeIntelResult, ConfidenceMode, SearchDetails } from "../types.ts";
 
 export async function executeCallersAction(
@@ -59,8 +52,8 @@ export async function executeCallersAction(
       candidateCount: result.candidateCount,
       omittedCount: result.externalCount,
       nextQueries: [
-        "`code_intel affected` for impact analysis",
-        "`code_intel pattern` with broader scope for additional matches",
+        "`code_affected` for impact analysis",
+        "Use `code_pattern` only when you explicitly want text-search hints",
       ],
     };
     return { content, details: { type: "search" as const, data: details } };
@@ -76,7 +69,7 @@ export async function executeCallersAction(
           scope: params.path ?? null,
           candidateCount: 0,
           omittedCount: 0,
-          nextQueries: ["Enable LSP for `semantic` caller accuracy"],
+          nextQueries: ["Use `code_affected` before editing a broadly referenced target"],
         },
       },
     };
@@ -84,7 +77,7 @@ export async function executeCallersAction(
 
   const relPath = path.relative(cwd, target.file);
   return {
-    content: `No caller data available for ${relPath}:${target.displayLine}:${target.displayCharacter}. LSP may not be active.\n\nTry \`code_intel pattern\` with the symbol name for text-search matches.`,
+    content: `No caller data available for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
     details: {
       type: "search" as const,
       data: {
@@ -92,7 +85,7 @@ export async function executeCallersAction(
         scope: params.path ?? null,
         candidateCount: 0,
         omittedCount: 0,
-        nextQueries: ["Enable LSP for semantic caller resolution, or try `code_intel pattern`"],
+        nextQueries: ["Enable LSP for semantic caller resolution or use `code_pattern` explicitly"],
       },
     },
   };
@@ -124,8 +117,8 @@ async function executeFileLevelCallers(
 
   const withRefs = perTarget.filter((entry) => entry.result.refs.length > 0);
   const uniqueRefs = dedupeFileLineRefs(withRefs.flatMap((entry) => entry.result.refs));
-  const confidence = highestConfidence(withRefs.map((entry) => entry.result.confidence));
-  const externalCount = withRefs.reduce((sum, entry) => sum + entry.result.externalCount, 0);
+  const confidence = highestConfidence(perTarget.map((entry) => entry.result.confidence));
+  const externalCount = perTarget.reduce((sum, entry) => sum + entry.result.externalCount, 0);
 
   const lines: string[] = [];
   lines.push(`# Callers in \`${targetGroup.displayName}\``);
@@ -155,7 +148,7 @@ async function executeFileLevelCallers(
     candidateCount: uniqueRefs.length,
     omittedCount: externalCount,
     nextQueries: [
-      "`code_intel affected` for impact analysis",
+      "`code_affected` for impact analysis",
       "Use `file` + coordinates to drill into one symbol precisely",
     ],
   };
@@ -163,58 +156,45 @@ async function executeFileLevelCallers(
   return { content: lines.join("\n"), details: { type: "search" as const, data: details } };
 }
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: LSP-first caller collection with fallback and declaration filtering is clearest in one helper
 async function collectCallerRefs(
   target: ResolvedTarget,
-  params: ActionParams,
+  _params: ActionParams,
   cwd: string,
 ): Promise<CallerCollection> {
   const lsp = await getSemanticService(cwd, { waitForReady: true });
-
-  if (lsp) {
-    const refs = await lsp.references(target.file, target.position);
-    if (refs && refs.length > 0) {
-      const filtered = filterOutDeclaration(refs, target.file, target.position);
-      const projectRefs: CallerRef[] = [];
-      let externalCount = 0;
-      for (const ref of refs) {
-        const filePath = uriToFile(ref.uri);
-        if (!isInProjectPath(filePath, cwd)) {
-          externalCount++;
-        }
-      }
-      for (const ref of filtered) {
-        const filePath = uriToFile(ref.uri);
-        if (isInProjectPath(filePath, cwd)) {
-          projectRefs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
-        }
-      }
-      if (projectRefs.length > 0) {
-        return {
-          refs: projectRefs,
-          confidence: "semantic",
-          externalCount,
-          candidateCount: projectRefs.length,
-        };
-      }
-    }
+  if (!lsp) {
+    return { refs: [], confidence: "unavailable", externalCount: 0, candidateCount: 0 };
   }
 
-  if (!target.name) {
+  const refs = await lsp.references(target.file, target.position);
+  if (refs === null) {
     return { refs: [], confidence: "unavailable", externalCount: 0, candidateCount: 0 };
   }
 
-  const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
-  const pattern = `\\b${escapeRegex(target.name)}\\b`;
-  const matches = runRipgrep(pattern, scopePath, cwd, { maxMatches: (params.maxResults ?? 8) * 3 });
-  const refs = matches
-    .filter((match) => !isDeclarationMatch(match.file, match.line, target, cwd))
-    .map((match) => ({
-      file: path.relative(cwd, path.resolve(cwd, match.file)),
-      line: match.line,
-    }));
+  const filtered = filterOutDeclaration(refs, target.file, target.position);
+  const projectRefs: CallerRef[] = [];
+  let externalCount = 0;
+
+  for (const ref of refs) {
+    const filePath = uriToFile(ref.uri);
+    if (!isInProjectPath(filePath, cwd)) {
+      externalCount++;
+    }
+  }
+
+  for (const ref of filtered) {
+    const filePath = uriToFile(ref.uri);
+    if (isInProjectPath(filePath, cwd)) {
+      projectRefs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
+    }
+  }
 
-  return { refs, confidence: "heuristic", externalCount: 0, candidateCount: refs.length };
+  return {
+    refs: projectRefs,
+    confidence: "semantic",
+    externalCount,
+    candidateCount: projectRefs.length,
+  };
 }
 
 function formatTargetCallers(
@@ -271,12 +251,3 @@ function groupRefsByFile(refs: CallerRef[], _cwd: string): Map<string, number[]>
   }
   return byFile;
 }
-
-function isDeclarationMatch(
-  file: string,
-  line: number,
-  target: ResolvedTarget,
-  cwd: string,
-): boolean {
-  return path.resolve(cwd, file) === target.file && line === target.displayLine;
-}