From e8bde35ed53e347fc514785ecff12872b5b15c22 Mon Sep 17 00:00:00 2001
From: L0garithmic <L0garithmic@users.noreply.github.com>
Date: Sun, 27 Sep 2026 18:21:14 -0500
Subject: [PATCH 1/2] fix(vue,explore): index template bindings; rank exact
 identifiers above plain words

Vue SFC templates were indexed only for component tags. Identifiers a
template binds (`:prop="x"`, `@event="save"`, `v-if`, `v-for` sources,
`{{ mustache }}`) produced no edge, so "where is myLinkBrandingLocked
used" had no answer and explore never rendered the template lines that
bind a named symbol. The Vue extractor now emits `calls` for template
calls and handler names and `references` for bare identifiers the
<script> blocks declare or import, skipping v-for/slot locals, object
keys, member tails, globals and $-helpers. Explore renders same-file
use sites of a named symbol (the component envelope was dropped).

Explore: once a precise query token resolves to a named seed, a file
whose only claim is a plain query word (no seed, no precise term, no
symbol one edge from a seed) loses entry-file gate protection and
centrality and sorts last, so it only takes leftover budget.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   4 +
 .../explore-nl-stopword-collision.test.ts     |  49 +++++
 __tests__/extraction.test.ts                  |  44 +++++
 src/extraction/vue-extractor.ts               | 184 +++++++++++++++++-
 src/mcp/tools.ts                              |  73 ++++++-
 5 files changed, 349 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3d562a5ea6..ac2dbb3ec3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -145,6 +145,10 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixes
 
+- Vue templates are indexed as uses: `:prop="x"`, `@event="save"`, `v-if` / `v-for` / `v-model` values and `{{ mustache }}` expressions now link to the script state, functions and imports they bind, so "where is `myLinkBrandingLocked` used" answers from the graph and `codegraph_explore` shows the template lines that bind a symbol you named.
+
+- `codegraph_explore` no longer spends its budget on files that match only a plain word in the query when the query also names a symbol exactly: after the named symbol's file, files wired to that symbol come before an unrelated file that shares a word like "section".
+
 - The Claude Code prompt hook no longer runs on the task-notification messages Claude Code injects when a background agent finishes, removing a multi-second stall on every such turn. (#1832)
 
 - Rust calls on `self` now stay with the enclosing type instead of linking to an unrelated type’s same-named method. Thanks @L4XB. (#1861)
diff --git a/__tests__/explore-nl-stopword-collision.test.ts b/__tests__/explore-nl-stopword-collision.test.ts
index df67b016f2..579eb49f44 100644
--- a/__tests__/explore-nl-stopword-collision.test.ts
+++ b/__tests__/explore-nl-stopword-collision.test.ts
@@ -174,3 +174,52 @@ describe('codegraph_explore — interface members never corroborate a bare word'
     expect(files[0]).toBe('src/extensionHostProcess.ts');
   });
 });
+
+describe('codegraph_explore — precise-before-plain file tier', () => {
+  let testDir: string;
+  let cg: CodeGraph;
+
+  afterEach(() => {
+    cg?.destroy();
+    if (testDir && fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('a file tied to the exactly-named symbol outranks files that match only a plain query word', async () => {
+    // `WorkspaceMyLinkView appearance section myLinkBrandingLocked` rendered the
+    // view first and then filled the budget with a PHP layout class that matched
+    // only "section", ahead of everything wired to `myLinkBrandingLocked`.
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-precise-first-'));
+    const profile = path.join(testDir, 'src', 'profile');
+    const layout = path.join(testDir, 'src', 'layout');
+    fs.mkdirSync(profile, { recursive: true });
+    fs.mkdirSync(layout, { recursive: true });
+    fs.writeFileSync(path.join(profile, 'branding.ts'),
+      'export function myLinkBrandingLocked(plan: string): boolean {\n' +
+      "  return plan !== 'pro';\n" +
+      '}\n');
+    fs.writeFileSync(path.join(profile, 'panel.ts'),
+      "import { myLinkBrandingLocked } from './branding';\n" +
+      'export function drawOwnDomainPanel(plan: string): string {\n' +
+      "  return myLinkBrandingLocked(plan) ? 'upgrade' : 'edit';\n" +
+      '}\n');
+    // A dense mesh of `section` symbols: FTS roots for the plain word "section".
+    fs.writeFileSync(path.join(layout, 'sections.ts'),
+      'export function section(name: string): string {\n  return renderSection(name);\n}\n' +
+      'export function renderSection(name: string): string {\n  return sectionHeader(name) + sectionBody(name);\n}\n' +
+      'export function sectionHeader(name: string): string {\n  return `<h2>${name}</h2>`;\n}\n' +
+      'export function sectionBody(name: string): string {\n  return section.name + name;\n}\n' +
+      'export function sectionList(names: string[]): string {\n  return names.map(section).join("");\n}\n');
+    cg = CodeGraph.initSync(testDir);
+    await cg.indexAll();
+
+    const res = await new ToolHandler(cg).execute('codegraph_explore', {
+      query: 'myLinkBrandingLocked appearance section',
+    });
+    const files = sourcedFiles(res.content[0].text as string);
+    const panel = files.indexOf('src/profile/panel.ts');
+    const sections = files.indexOf('src/layout/sections.ts');
+    expect(files[0]).toBe('src/profile/branding.ts');
+    expect(panel).toBeGreaterThan(0);
+    if (sections !== -1) expect(panel).toBeLessThan(sections);
+  });
+});
diff --git a/__tests__/extraction.test.ts b/__tests__/extraction.test.ts
index 46a3cc3d54..1c95a90937 100644
--- a/__tests__/extraction.test.ts
+++ b/__tests__/extraction.test.ts
@@ -9219,6 +9219,50 @@ import MyButton from './MyButton.vue';
     expect(refs).not.toContain('Span');
   });
 
+  it('should extract identifiers the Vue template binds, skipping locals, keys and globals', () => {
+    const code = `<template>
+  <section v-if="!myLinkBrandingLocked" :class="{ active: isActive }">
+    <OwnDomainSection
+      :locked="myLinkBrandingLocked"
+      @save="saveDomain"
+    />
+    <li v-for="(item, index) in domains" :key="item.id">{{ formatDomain(item) }} {{ Math.max(index, 1) }}</li>
+    <Row #default="{ row }">{{ row.label }}</Row>
+    <p>{{ $t('label') }} {{ 'isActive' }}</p>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+import OwnDomainSection from './OwnDomainSection.vue';
+import { formatDomain } from './format';
+
+const isActive = ref(false);
+const domains = ref<string[]>([]);
+const myLinkBrandingLocked = computed(() => false);
+function saveDomain() {}
+</script>
+`;
+    const result = extractFromSource('WorkspaceMyLinkView.vue', code);
+    const templateRefs = result.unresolvedReferences.filter((r) => r.line <= 11);
+    const named = (kind: string) => templateRefs.filter((r) => r.referenceKind === kind).map((r) => r.referenceName);
+
+    // Bound script state is a reference, on the template line that binds it.
+    const locked = templateRefs.filter((r) => r.referenceName === 'myLinkBrandingLocked');
+    expect(locked.map((r) => r.line).sort()).toEqual([2, 4]);
+    expect(named('references')).toContain('isActive');
+    expect(named('references')).toContain('domains');
+    // A bare event handler and a template call are calls.
+    expect(named('calls')).toContain('saveDomain');
+    expect(named('calls')).toContain('formatDomain');
+    // Locals, object keys, member tails, globals, $-helpers and string contents bind nothing.
+    const all = templateRefs.map((r) => r.referenceName);
+    for (const absent of ['item', 'index', 'row', 'active', 'id', 'label', 'Math', 'max', '$t']) {
+      expect(all).not.toContain(absent);
+    }
+    expect(templateRefs.filter((r) => r.referenceName === 'isActive')).toHaveLength(1);
+  });
+
   it('should extract from both <script> and <script setup> blocks', () => {
     const code = `<template>
   <div>{{ msg }}</div>
diff --git a/src/extraction/vue-extractor.ts b/src/extraction/vue-extractor.ts
index 862f17c793..6f1ee0bbee 100644
--- a/src/extraction/vue-extractor.ts
+++ b/src/extraction/vue-extractor.ts
@@ -18,6 +18,50 @@ const VUE_BUILTIN_COMPONENTS = new Set([
   'Slot',
 ]);
 
+/** Keywords and literals a template expression can contain that bind nothing. */
+const TEMPLATE_NON_BINDINGS = new Set([
+  'true', 'false', 'null', 'undefined', 'this', 'in', 'of', 'typeof', 'instanceof',
+  'new', 'void', 'delete', 'await', 'async', 'return', 'if', 'else', 'let', 'const',
+  'var', 'function', 'class', 'NaN', 'Infinity',
+]);
+
+/** Globals Vue exposes to templates; a call to one is not a call into the repo. */
+const JS_GLOBALS = new Set([
+  'Math', 'JSON', 'Object', 'Array', 'Number', 'String', 'Boolean', 'Date', 'RegExp',
+  'Map', 'Set', 'Promise', 'Symbol', 'BigInt', 'Intl', 'Error', 'console', 'window',
+  'document', 'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'encodeURI',
+  'encodeURIComponent', 'decodeURI', 'decodeURIComponent', 'require',
+]);
+
+/**
+ * Local names a `<script>` block's ES imports bind: `Foo` from `import Foo`,
+ * `a` and `c` from `import { a, b as c }`, `ns` from `import * as ns`.
+ * Type-only imports bind nothing a template can use.
+ */
+function importedLocalNames(script: string): string[] {
+  const names: string[] = [];
+  const importRegex = /(?:^|[\n;])\s*import\s+(?!type\s)([^'";]+?)\s+from\s*['"]/g;
+  let m: RegExpExecArray | null;
+  while ((m = importRegex.exec(script)) !== null) {
+    const clause = m[1]!;
+    const braces = /\{([\s\S]*)\}/.exec(clause);
+    const outside = braces ? clause.replace(braces[0], '') : clause;
+    for (const part of outside.split(',')) {
+      const ns = /\*\s*as\s+([A-Za-z_$][\w$]*)/.exec(part);
+      const id = ns ? ns[1] : /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(part)?.[1];
+      if (id) names.push(id);
+    }
+    if (braces) {
+      for (const spec of braces[1]!.split(',')) {
+        if (/^\s*type\s/.test(spec)) continue;
+        const id = /([A-Za-z_$][\w$]*)\s*$/.exec(spec.trim())?.[1];
+        if (id) names.push(id);
+      }
+    }
+  }
+  return names;
+}
+
 /** `my-component` → `MyComponent` (Vue allows either form in templates). */
 function kebabToPascal(name: string): string {
   return name
@@ -61,8 +105,12 @@ export class VueExtractor {
       // Extract and process script blocks
       const scriptBlocks = this.extractScriptBlocks();
 
+      // Names the <script> blocks bind (declarations + imports) — the only
+      // names a template identifier can reach in Vue besides globals.
+      const scriptBindings = new Set<string>();
       for (const block of scriptBlocks) {
-        this.processScriptBlock(block, componentNode.id);
+        for (const name of this.processScriptBlock(block, componentNode.id)) scriptBindings.add(name);
+        for (const name of importedLocalNames(block.content)) scriptBindings.add(name);
       }
 
       // Extract component usages from the <template> (<ComponentName>).
@@ -70,6 +118,13 @@ export class VueExtractor {
       // markup (incl. through a barrel import) is invisible to callers /
       // impact (#629 follow-up).
       this.extractTemplateComponents(componentNode.id);
+
+      // Extract identifiers the template binds (`:prop="x"`, `@click="save"`,
+      // `v-if="locked"`, `{{ label }}`). This is where a component's state is
+      // actually rendered, so without it "where is `myLinkBrandingLocked`
+      // used" had no answer from the graph and explore never reached the
+      // template lines that bind it.
+      this.extractTemplateBindings(componentNode.id, scriptBindings);
     } catch (error) {
       this.errors.push({
         message: `Vue extraction error: ${error instanceof Error ? error.message : String(error)}`,
@@ -171,7 +226,7 @@ export class VueExtractor {
   private processScriptBlock(
     block: { content: string; startLine: number; isSetup: boolean; isTypeScript: boolean },
     componentNodeId: string
-  ): void {
+  ): string[] {
     const scriptLanguage: Language = block.isTypeScript ? 'typescript' : 'javascript';
 
     // Check if the script language parser is available
@@ -180,7 +235,7 @@ export class VueExtractor {
         message: `Parser for ${scriptLanguage} not available, cannot parse Vue script block`,
         severity: 'warning',
       });
-      return;
+      return [];
     }
 
     // Delegate to TreeSitterExtractor
@@ -226,6 +281,129 @@ export class VueExtractor {
       }
       this.errors.push(error);
     }
+
+    return result.nodes
+      .filter((n) => n.kind !== 'import' && n.kind !== 'export')
+      .map((n) => n.name);
+  }
+
+  /**
+   * Extract the identifiers a Vue `<template>` binds as references.
+   *
+   * Scans directive values (`:prop` / `v-bind:`, `@event` / `v-on:`, `v-if`,
+   * `v-show`, `v-model`, `v-for`'s source, ...) and `{{ mustache }}`
+   * interpolations. In each expression:
+   *
+   * - `fn(...)` is a `calls` reference (as the Svelte extractor does for
+   *   `{fn(...)}`), unless `fn` is a JS global, a `$`-prefixed Vue instance
+   *   helper (`$emit`, `$t`) or a template-local.
+   * - A bare identifier is a `references` reference ONLY when a `<script>`
+   *   block declares or imports that name. Template scope is exactly those
+   *   bindings plus globals, so the restriction drops nothing real, and it
+   *   keeps object-literal keys and props-only names from name-matching a
+   *   same-named symbol elsewhere in the repo (silent beats wrong).
+   * - An `@event="save"` handler that is a bare name is a `calls` reference:
+   *   Vue invokes it.
+   *
+   * `v-for` aliases and slot props (`v-slot="{ item }"`, `#row="{ item }"`)
+   * are template-locals and never emitted.
+   */
+  private extractTemplateBindings(componentNodeId: string, scriptBindings: Set<string>): void {
+    // Blank out <script>/<style> blocks and HTML comments, keeping every
+    // newline, so offsets in the masked text are offsets in the file.
+    const blank = (m: string) => m.replace(/[^\n]/g, ' ');
+    const masked = this.source
+      .replace(/<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1>/g, blank)
+      .replace(/<!--[\s\S]*?-->/g, blank);
+
+    const lineStarts: number[] = [0];
+    for (let i = 0; i < masked.length; i++) if (masked[i] === '\n') lineStarts.push(i + 1);
+    const lineOf = (offset: number): number => {
+      let lo = 0;
+      let hi = lineStarts.length - 1;
+      while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid]! <= offset) lo = mid;
+        else hi = mid - 1;
+      }
+      return lo; // 0-indexed
+    };
+
+    // Directive attributes: `:x`, `@x`, `#x`, `v-xxx[:arg][.mod]`, with a quoted value.
+    const directiveRegex = /\s((?:v-[a-z][\w-]*|[:@#])[^\s=>"']*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    const expressions: Array<{ text: string; offset: number; handler: boolean }> = [];
+    const templateLocals = new Set<string>();
+    let m: RegExpExecArray | null;
+    while ((m = directiveRegex.exec(masked)) !== null) {
+      const name = m[1]!;
+      const value = m[2] ?? m[3] ?? '';
+      const valueOffset = m.index + m[0].length - value.length - 1;
+      if (name.startsWith('#') || name.startsWith('v-slot')) {
+        // Slot props declare template-locals; they reference nothing.
+        for (const id of value.match(/[A-Za-z_$][\w$]*/g) ?? []) templateLocals.add(id);
+        continue;
+      }
+      if (name === 'v-for') {
+        // `(item, index) in items` / `item of items`: aliases are locals,
+        // the source expression is a reference.
+        const split = /^\s*([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)$/.exec(value);
+        if (split) {
+          for (const id of split[1]!.match(/[A-Za-z_$][\w$]*/g) ?? []) templateLocals.add(id);
+          expressions.push({ text: split[2]!, offset: valueOffset + value.length - split[2]!.length, handler: false });
+        }
+        continue;
+      }
+      const handler = name.startsWith('@') || name.startsWith('v-on');
+      expressions.push({ text: value, offset: valueOffset, handler });
+    }
+    const mustacheRegex = /\{\{([\s\S]*?)\}\}/g;
+    while ((m = mustacheRegex.exec(masked)) !== null) {
+      expressions.push({ text: m[1]!, offset: m.index + 2, handler: false });
+    }
+
+    const seen = new Set<string>();
+    const emit = (name: string, kind: 'calls' | 'references', offset: number) => {
+      const line = lineOf(offset);
+      const key = `${kind}:${name}:${line}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      this.unresolvedReferences.push({
+        fromNodeId: componentNodeId,
+        referenceName: name,
+        referenceKind: kind,
+        line: line + 1, // 1-indexed
+        column: offset - lineStarts[line]! + 1,
+        filePath: this.filePath,
+        language: 'vue',
+      });
+    };
+
+    for (const expr of expressions) {
+      // Blank string literals (keeping length) so their words aren't read as identifiers.
+      const text = expr.text.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, blank);
+      const handlerName = expr.handler ? /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(text)?.[1] : undefined;
+      const idRegex = /[A-Za-z_$][\w$]*/g;
+      let id: RegExpExecArray | null;
+      while ((id = idRegex.exec(text)) !== null) {
+        const name = id[0];
+        const start = id.index;
+        const before = text.slice(0, start).replace(/\s+$/, '');
+        // A member (`obj.name`, `obj?.name`) is not a template binding; its head is.
+        if (before.endsWith('.')) continue;
+        // The tail of a number literal (`1e5`), not an identifier.
+        if (start > 0 && /[\w$]/.test(text[start - 1]!)) continue;
+        if (name.startsWith('$') || TEMPLATE_NON_BINDINGS.has(name) || templateLocals.has(name)) continue;
+        const after = text.slice(start + name.length);
+        // Object-literal key (`{ active: isActive }`), not a reference.
+        if (/^\s*:(?!:)/.test(after) && /[{,]$/.test(before)) continue;
+        const offset = expr.offset + start;
+        if (/^\s*\(/.test(after)) {
+          if (!JS_GLOBALS.has(name)) emit(name, 'calls', offset);
+        } else if (scriptBindings.has(name)) {
+          emit(name, name === handlerName ? 'calls' : 'references', offset);
+        }
+      }
+    }
   }
 
   /**
diff --git a/src/mcp/tools.ts b/src/mcp/tools.ts
index 0455afbed8..325c17bd1d 100644
--- a/src/mcp/tools.ts
+++ b/src/mcp/tools.ts
@@ -3962,6 +3962,10 @@ export class ToolHandler {
     // Files declaring a TYPE the query named by name — the counter-case guard
     // for the declaration-only penalty (CG-28). Populated in the token loop.
     const namedTypeFiles = new Set<string>();
+    // The query's shape-precise tokens (camelCase, PascalCase, snake_case,
+    // qualified), lowercased and split at `.`/`::`/`/`. Populated in the token
+    // loop; read by the precise-before-plain file tier below.
+    const preciseQueryTerms = new Set<string>();
     {
       const FILE_EXT = /\.(?:java|kt|kts|ts|tsx|js|jsx|mjs|cjs|cs|py|go|rb|php|swift|rs|cpp|cc|cxx|c|h|hpp|scala|lua|dart|vue|svelte|astro|erl|hrl)$/i;
       const CALLABLE = new Set(['method', 'function', 'component', 'constructor']);
@@ -4011,6 +4015,12 @@ export class ToolHandler {
       const lcTokens = new Set(tokens.map((x) => x.toLowerCase()));
       const isPreciseToken = (x: string) =>
         /[._$]|::|\//.test(x) || /[a-z][A-Z]/.test(x) || /^[A-Z]/.test(x);
+      for (const t of tokens) {
+        if (!isPreciseToken(t)) continue;
+        for (const part of t.toLowerCase().split(/::|[./]/)) {
+          if (part.length >= 3) preciseQueryTerms.add(part);
+        }
+      }
       const fileNameSets = new Map<string, Set<string>>();
       const coNamedInFile = (t: string, fp: string): boolean => {
         let names = fileNameSets.get(fp);
@@ -4437,6 +4447,42 @@ export class ToolHandler {
       fileTermHits.set(fp, hits);
     }
 
+    // Precise-before-plain: once a precise token resolved to a named seed, a
+    // file whose only claim is a PLAIN query word is an English-word collision.
+    // `WorkspaceMyLinkView appearance section myLinkBrandingLocked` spent the
+    // budget after the view on a PHP layout class that matched only "section":
+    // as an FTS root the entry-file gate protected it. A word-only file holds
+    // no named seed, matches no precise term, and has no symbol one edge from
+    // a seed; it loses gate protection and centrality and sorts last, so it
+    // only takes leftover budget. Inert when no precise token resolved.
+    const wordOnlyFiles = new Set<string>();
+    if (tierSeedIds.size > 0 && preciseQueryTerms.size > 0) {
+      const seedFiles = new Set<string>();
+      const seedNeighbourFiles = new Set<string>();
+      for (const id of tierSeedIds) {
+        const seed = subgraph.nodes.get(id) ?? cg.getNode(id);
+        if (!seed) continue;
+        seedFiles.add(seed.filePath);
+        let edges: Edge[] = [];
+        try {
+          edges = [...cg.getIncomingEdges(id), ...cg.getOutgoingEdges(id)];
+        } catch { /* a probe failure only means fewer neighbours are protected */ }
+        for (const e of edges.slice(0, 400)) {
+          if (e.kind === 'contains') continue;
+          const otherId = e.source === id ? e.target : e.source;
+          const other = subgraph.nodes.get(otherId) ?? cg.getNode(otherId);
+          if (other) seedNeighbourFiles.add(other.filePath);
+        }
+      }
+      for (const [fp, group] of relevantFiles) {
+        if (pinnedSet.has(fp) || seedFiles.has(fp) || seedNeighbourFiles.has(fp)) continue;
+        const hay = fp.toLowerCase() + ' ' + group.nodes.map((n) => n.name.toLowerCase()).join(' ');
+        let precise = false;
+        for (const t of preciseQueryTerms) if (hay.includes(t)) { precise = true; break; }
+        if (!precise) wordOnlyFiles.add(fp);
+      }
+    }
+
     // PRIMARY relevance: graph connectivity (Random-Walk-with-Restart from the
     // matched seeds — see computeGraphRelevance). Aggregate each file's nodes'
     // walk mass. This is the signal text search lacks: the real cluster
@@ -4493,7 +4539,7 @@ export class ToolHandler {
     // falls to generous full-method sectioning — never a whole dump).
     const centralFiles = new Set(
       [...fileGraphScore.entries()]
-        .filter(([fp, g]) => g > 0 && (fileTermHits.get(fp) ?? 0) >= 1)
+        .filter(([fp, g]) => g > 0 && (fileTermHits.get(fp) ?? 0) >= 1 && !wordOnlyFiles.has(fp))
         .sort((a, b) => b[1] - a[1] || (fileTermHits.get(b[0]) ?? 0) - (fileTermHits.get(a[0]) ?? 0))
         .slice(0, 2)
         .map(([f]) => f),
@@ -4551,7 +4597,7 @@ export class ToolHandler {
         pinnedSet.has(fp)
         || (fileGraphScore.get(fp) ?? 0) >= maxGraph * 0.06
         || centralFiles.has(fp)
-        || entryFiles.has(fp)
+        || (entryFiles.has(fp) && !wordOnlyFiles.has(fp))
         || changeSurfaceFiles.has(fp)
         || (fileTermHits.get(fp) ?? 0) >= 2,
       );
@@ -4618,6 +4664,11 @@ export class ToolHandler {
       const bNamed = namedSeedFiles.has(b[0]) ? 1 : 0;
       if (aNamed !== bNamed) return bNamed - aNamed;
 
+      // Word-only files (see precise-before-plain above) after everything else.
+      const aWord = wordOnlyFiles.has(a[0]) ? 1 : 0;
+      const bWord = wordOnlyFiles.has(b[0]) ? 1 : 0;
+      if (aWord !== bWord) return aWord - bWord;
+
       // Corroborated (entry/central + ≥2 terms) tier, above the graph signal.
       const aCorr = isCorroborated(a[0]) ? 1 : 0;
       const bCorr = isCorroborated(b[0]) ? 1 : 0;
@@ -6016,6 +6067,24 @@ export class ToolHandler {
         }
       }
 
+      // Same-file USE sites of a symbol the agent named: a Vue/Svelte template
+      // binding (`:locked="myLinkBrandingLocked"`) is where that state renders,
+      // and its source is the whole-file component node, dropped above as an
+      // envelope, so the loop above never sees it.
+      for (const n of rangeNodes.values()) {
+        if (!entryNodeIds.has(n.id) && !flow.namedNodeIds.has(n.id)) continue;
+        let incoming: Edge[] = [];
+        try { incoming = cg.getIncomingEdges(n.id); } catch { continue; }
+        for (const edge of incoming.slice(0, 40)) {
+          if (!edge.line || edge.line <= 0 || edge.kind === 'contains') continue;
+          if (cg.getNode(edge.source)?.filePath !== filePath) continue;
+          const key = `${edge.line}:${edge.target}`;
+          if (edgeLines.has(key)) continue;
+          edgeLines.add(key);
+          ranges.push({ start: edge.line, end: edge.line, name: n.name, kind: edge.kind, importance: 8, spine: false });
+        }
+      }
+
       // Line spans the agent anchored in this file (`lines 900-1003`) are exact
       // targets too — rendered as exactly the span asked for, not as the
       // symbols around it.

From de08fa411db5bcd23c36958afcf0a024bcdc5022 Mon Sep 17 00:00:00 2001
From: L0garithmic <L0garithmic@users.noreply.github.com>
Date: Sun, 27 Sep 2026 20:05:30 -0500
Subject: [PATCH 2/2] fix(explore): a caller of the exactly-named seed is
 exempt from the allocation cliff

The precise-before-plain tier sorted src/profile/panel.ts (calls the named
seed) above the word-only file, but allocateExploreBudget cliffed it to a
pointer: it matches no query word, so its score (3.5) sat under the cliff
(7.5) while the word-only file kept its bytes. Seed-neighbour files now
carry an `anchored` flag that exempts them from the cliff only (weight and
share unchanged), set only while a word-only file exists. The neighbour set
is hoisted so the relevance gate also keeps them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/mcp/tools.ts | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/mcp/tools.ts b/src/mcp/tools.ts
index 325c17bd1d..d36d030c34 100644
--- a/src/mcp/tools.ts
+++ b/src/mcp/tools.ts
@@ -706,6 +706,12 @@ export interface ExploreAllocationCandidate {
    * share stands, bounded only by the pool.
    */
   named?: boolean;
+  /**
+   * One edge from a symbol the query named exactly, while a file that matched
+   * only a plain query word is also in the running (precise-before-plain).
+   * Exempt from the cliff only; its weight, and so its share, is unchanged.
+   */
+  anchored?: boolean;
 }
 
 export interface ExploreAllocation {
@@ -775,7 +781,7 @@ export function allocateExploreBudget(
   const cliffed: string[] = [];
   let admitted: ExploreAllocationCandidate[] = [];
   for (const c of candidates) {
-    if (!c.spine && !c.pinned && (weights.get(c.path) ?? 0) < cliffAt) cliffed.push(c.path);
+    if (!c.spine && !c.pinned && !c.anchored && (weights.get(c.path) ?? 0) < cliffAt) cliffed.push(c.path);
     else admitted.push(c);
   }
   // Never cliff every candidate: an empty response costs a whole round-trip.
@@ -4456,9 +4462,12 @@ export class ToolHandler {
     // a seed; it loses gate protection and centrality and sorts last, so it
     // only takes leftover budget. Inert when no precise token resolved.
     const wordOnlyFiles = new Set<string>();
+    // Files one edge from a named seed (its callers and callees). The relevance
+    // gate below keeps them: a caller of the exact symbol the agent named is the
+    // answer to "where is X used", even when it matches no query word itself.
+    const seedNeighbourFiles = new Set<string>();
     if (tierSeedIds.size > 0 && preciseQueryTerms.size > 0) {
       const seedFiles = new Set<string>();
-      const seedNeighbourFiles = new Set<string>();
       for (const id of tierSeedIds) {
         const seed = subgraph.nodes.get(id) ?? cg.getNode(id);
         if (!seed) continue;
@@ -4598,6 +4607,7 @@ export class ToolHandler {
         || (fileGraphScore.get(fp) ?? 0) >= maxGraph * 0.06
         || centralFiles.has(fp)
         || (entryFiles.has(fp) && !wordOnlyFiles.has(fp))
+        || seedNeighbourFiles.has(fp)
         || changeSurfaceFiles.has(fp)
         || (fileTermHits.get(fp) ?? 0) >= 2,
       );
@@ -4848,6 +4858,10 @@ export class ToolHandler {
           || anchorSpans.has(fp),
         pinned: pinnedSet.has(fp),
         named: namedSeedFiles.has(fp),
+        // A caller of the named seed matches no query word, so it scores low and
+        // would fall under the cliff while a word-only file below it keeps its
+        // bytes. Only while such a file exists: otherwise the cliff is unchanged.
+        anchored: wordOnlyFiles.size > 0 && seedNeighbourFiles.has(fp),
       })),
       budget,
       maxFiles,