diff --git a/gitnexus-shared/src/graph/types.ts b/gitnexus-shared/src/graph/types.ts
index d3dc816257..ede8bc9067 100644
--- a/gitnexus-shared/src/graph/types.ts
+++ b/gitnexus-shared/src/graph/types.ts
@@ -115,7 +115,23 @@ export type RelationshipType =
   | 'HANDLES_TOOL'
   | 'ENTRY_POINT_OF'
   | 'WRAPS'
-  | 'QUERIES';
+  | 'QUERIES'
+  /** Vue component event system: a handler function in a parent component is
+   *  bound to an event emitted by a child component (`@event="handlerFn"`).
+   *  Source = handler Function/Method node in the parent.
+   *  Target = the child component's File node.
+   *  `reason` encodes the event name: `vue-event: @<eventName>`.
+   *  Complements `EMITS_EVENT`; together they enable Cypher queries that
+   *  trace which handlers receive which component's emitted events. */
+  | 'BINDS_EVENT_HANDLER'
+  /** Vue component event system: a component calls `emit('eventName', ...)`
+   *  or `this.$emit('eventName', ...)`, advertising that it can emit that event.
+   *  Source = the component's own File node (self-referential annotation).
+   *  Target = the same File node.
+   *  `reason` encodes the event name: `vue-emit: <eventName>`.
+   *  Complements `BINDS_EVENT_HANDLER`; a Cypher query joining on the
+   *  component File node reveals all (emitter, handler) pairs. */
+  | 'EMITS_EVENT';
 
 export interface GraphNode {
   id: string;
diff --git a/gitnexus/scripts/run-parity.ts b/gitnexus/scripts/run-parity.ts
index f56db11bc3..6fbf35dc60 100644
--- a/gitnexus/scripts/run-parity.ts
+++ b/gitnexus/scripts/run-parity.ts
@@ -41,8 +41,15 @@ function envVarName(slug: string): string {
   return `REGISTRY_PRIMARY_${slug.toUpperCase().replace(/-/g, '_')}`;
 }
 
-function testFilePath(slug: string): string {
-  return `test/integration/resolvers/${slug}.test.ts`;
+function testFilePaths(slug: string): string[] {
+  const resolverDir = path.resolve(ROOT, 'test/integration/resolvers');
+  const files = fs.readdirSync(resolverDir);
+  const direct = `${slug}.test.ts`;
+  const prefixed = `${slug}-`;
+  return files
+    .filter((name) => name === direct || (name.startsWith(prefixed) && name.endsWith('.test.ts')))
+    .sort()
+    .map((name) => `test/integration/resolvers/${name}`);
 }
 
 function runVitest(testFile: string, env: Record<string, string>): boolean {
@@ -73,12 +80,12 @@ const languages = singleLang ? [singleLang] : [...MIGRATED_LANGUAGES].map(String
 
 // Verify test files exist before running
 const missingFiles: string[] = [];
+const filesByLanguage = new Map<string, string[]>();
 for (const lang of languages) {
-  const file = path.resolve(ROOT, testFilePath(lang));
-  try {
-    fs.accessSync(file);
-  } catch {
-    missingFiles.push(`${testFilePath(lang)} (${lang})`);
+  const files = testFilePaths(lang);
+  filesByLanguage.set(lang, files);
+  if (files.length === 0) {
+    missingFiles.push(`test/integration/resolvers/${lang}*.test.ts (${lang})`);
   }
 }
 
@@ -94,22 +101,26 @@ console.log(`Languages: ${languages.join(', ')}\n`);
 const failures: ParityFailure[] = [];
 
 for (const lang of languages) {
-  const file = testFilePath(lang);
+  const files = filesByLanguage.get(lang) ?? [];
   const envVar = envVarName(lang);
 
   console.log(`\n── ${lang} — legacy DAG (${envVar}=0) ──`);
-  if (!runVitest(file, { [envVar]: '0' })) {
-    failures.push({ lang, mode: 'legacy' });
+  for (const file of files) {
+    if (!runVitest(file, { [envVar]: '0' })) {
+      failures.push({ lang, mode: 'legacy' });
+    }
   }
 
   console.log(`\n── ${lang} — registry-primary (${envVar}=1) ──`);
-  if (!runVitest(file, { [envVar]: '1' })) {
-    failures.push({ lang, mode: 'registry-primary' });
+  for (const file of files) {
+    if (!runVitest(file, { [envVar]: '1' })) {
+      failures.push({ lang, mode: 'registry-primary' });
+    }
   }
 }
 
 // Summary
-const total = languages.length * 2;
+const total = [...filesByLanguage.values()].reduce((sum, files) => sum + files.length * 2, 0);
 const passed = total - failures.length;
 
 console.log('\n═══════════════════════════════════════');
diff --git a/gitnexus/src/core/ingestion/language-provider.ts b/gitnexus/src/core/ingestion/language-provider.ts
index 058710b2b3..9b68478017 100644
--- a/gitnexus/src/core/ingestion/language-provider.ts
+++ b/gitnexus/src/core/ingestion/language-provider.ts
@@ -426,6 +426,19 @@ interface LanguageProviderConfig {
      * MUST trigger a fresh parse.
      */
     cachedTree?: unknown,
+    /**
+     * Optional metadata about how `sourceText` was produced.
+     *
+     * Most providers ignore this and treat `sourceText` as full file content.
+     * Vue uses it to distinguish:
+     *   - `full-file`: full `.vue` SFC source
+     *   - `pre-extracted-script`: worker-preprocessed bare `<script>` content
+     *
+     * Default: `{ sourceKind: 'full-file' }`.
+     */
+    sourceMeta?: {
+      readonly sourceKind?: 'full-file' | 'pre-extracted-script';
+    },
   ) => readonly CaptureMatch[];
 
   /**
diff --git a/gitnexus/src/core/ingestion/languages/vue.ts b/gitnexus/src/core/ingestion/languages/vue.ts
index f08fe90509..e1657fc374 100644
--- a/gitnexus/src/core/ingestion/languages/vue.ts
+++ b/gitnexus/src/core/ingestion/languages/vue.ts
@@ -28,6 +28,17 @@ import { typescriptVariableConfig } from '../variable-extractors/configs/typescr
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import {
+  interpretTsImport,
+  interpretTsTypeBinding,
+  tsBindingScopeFor,
+  tsImportOwningScope,
+  tsReceiverBinding,
+  typescriptMergeBindings,
+  typescriptArityCompatibility,
+  resolveTsImportTarget,
+} from './typescript/index.js';
+import { emitVueScopeCaptures } from './vue/captures.js';
 
 const VUE_SPECIFIC_BUILT_INS = [
   'ref',
@@ -81,4 +92,14 @@ export const vueProvider = defineLanguage({
   classExtractor: vueClassExtractor,
   heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
   builtInNames: VUE_BUILT_INS,
+  // Scope-resolution pipeline hooks (RFC #909 Ring 3)
+  emitScopeCaptures: emitVueScopeCaptures,
+  interpretImport: interpretTsImport,
+  interpretTypeBinding: interpretTsTypeBinding,
+  bindingScopeFor: tsBindingScopeFor,
+  importOwningScope: tsImportOwningScope,
+  receiverBinding: tsReceiverBinding,
+  mergeBindings: (_scope, bindings) => typescriptMergeBindings(bindings),
+  arityCompatibility: typescriptArityCompatibility,
+  resolveImportTarget: resolveTsImportTarget,
 });
diff --git a/gitnexus/src/core/ingestion/languages/vue/captures.ts b/gitnexus/src/core/ingestion/languages/vue/captures.ts
new file mode 100644
index 0000000000..b8031fcdd0
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/vue/captures.ts
@@ -0,0 +1,67 @@
+/**
+ * Vue SFC scope captures (RFC #909 Ring 3, issue #940).
+ *
+ * Extracts the `<script>` / `<script setup>` block from the SFC source
+ * and delegates to `emitTsScopeCaptures`.  The parse-worker builds the
+ * cached tree from the extracted script content using the TypeScript
+ * grammar (see `[SupportedLanguages.Vue]: TypeScript.typescript` in
+ * `parse-worker.ts`), so passing that tree here keeps grammar identity
+ * consistent and avoids a redundant re-parse.
+ *
+ * Template expressions are intentionally out-of-scope: component-
+ * reference CALLS edges are already emitted by the legacy template
+ * extractor in the parse worker and would be double-counted here.
+ *
+ * Position note: all capture positions are relative to the *extracted*
+ * script block, not the full .vue file.  This is consistent with the
+ * cached tree and with how the scope model uses positions (only for
+ * scope-containment walks within a single file), so no offset
+ * translation is required for graph-edge correctness.
+ */
+
+import type { CaptureMatch } from 'gitnexus-shared';
+import { extractVueScript } from '../../vue-sfc-extractor.js';
+import { emitTsScopeCaptures } from '../typescript/captures.js';
+
+/**
+ * Emit scope captures for a Vue SFC.
+ *
+ * Handles three call-site shapes:
+ *
+ *   1. **Full SFC content** (sequential path, <15 files): `sourceText`
+ *      contains the whole `.vue` file with `<template>`, `<script>`, etc.
+ *      `extractVueScript` extracts the script block and we delegate to
+ *      `emitTsScopeCaptures` with that extracted content.
+ *
+ *   2. **Already-extracted script content** (worker-mode path, ≥15 files):
+ *      the parse worker calls `extractVueScript` itself before calling
+ *      `extractParsedFile`, so `sourceText` is already the bare TypeScript
+ *      text with no `<script>` tags. The caller marks this explicitly via
+ *      `sourceMeta.sourceKind === 'pre-extracted-script'`.
+ *
+ *   3. **Supporting TS/JS files** included in Vue scope-resolution runs:
+ *      when `filePath` is not `.vue`, delegate straight to TypeScript captures.
+ *
+ * Returns an empty array for render-function-only SFCs (no `<script>` block).
+ */
+export function emitVueScopeCaptures(
+  sourceText: string,
+  filePath: string,
+  cachedTree?: unknown,
+  sourceMeta?: { sourceKind?: 'full-file' | 'pre-extracted-script' },
+): readonly CaptureMatch[] {
+  // Vue resolver may include supporting TS/JS files in the same run to
+  // preserve cross-file import/type context for `.vue` callers. These are
+  // already plain script files, so no SFC extraction is needed.
+  if (!filePath.endsWith('.vue')) {
+    return emitTsScopeCaptures(sourceText, filePath, cachedTree);
+  }
+
+  if (sourceMeta?.sourceKind === 'pre-extracted-script') {
+    return emitTsScopeCaptures(sourceText, filePath, cachedTree);
+  }
+
+  const extracted = extractVueScript(sourceText);
+  if (extracted === null) return [];
+  return emitTsScopeCaptures(extracted.scriptContent, filePath, cachedTree);
+}
diff --git a/gitnexus/src/core/ingestion/languages/vue/import-target.ts b/gitnexus/src/core/ingestion/languages/vue/import-target.ts
new file mode 100644
index 0000000000..a16877459e
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/vue/import-target.ts
@@ -0,0 +1,81 @@
+/**
+ * Import-target resolver for Vue SFCs (RFC #909 Ring 3, issue #940).
+ *
+ * Vue `<script>` / `<script setup>` blocks are TypeScript (or plain
+ * JavaScript), so the resolver delegates to `resolveTsTarget` with
+ * `language: SupportedLanguages.TypeScript` to get:
+ *
+ *   - tsconfig path-alias rewriting (Vue projects universally use TS)
+ *   - `.ts` / `.tsx` / `.js` / `.jsx` extension-suffix fallback
+ *
+ * `.vue` imports are written with explicit extensions (`'./Button.vue'`),
+ * so no Vue-specific suffix guessing is required: the standard
+ * resolver finds them via the exact-path branch before any extension
+ * logic fires.
+ *
+ * Memoization mirrors the TypeScript adapter: workspace file-list
+ * arrays, the suffix index, and the per-pass resolve cache are rebuilt
+ * lazily when `allFilePaths` reference changes (once per workspace pass).
+ */
+
+import { SupportedLanguages } from 'gitnexus-shared';
+import { resolveTsTarget, type TsResolveContext } from '../typescript/import-target.js';
+import { buildSuffixIndex, type SuffixIndex } from '../../import-resolvers/utils.js';
+import type { TsconfigPaths } from '../../language-config.js';
+
+interface VueResolutionConfig {
+  readonly tsconfigPaths: TsconfigPaths | null;
+}
+
+interface PassCache {
+  readonly key: ReadonlySet<string>;
+  readonly allFilePaths: Set<string>;
+  readonly allFileList: readonly string[];
+  readonly normalizedFileList: readonly string[];
+  readonly index: SuffixIndex;
+  readonly resolveCache: Map<string, string | null>;
+}
+
+/**
+ * Build a memoized `resolveImportTarget` adapter for Vue SFCs.
+ *
+ * Uses `SupportedLanguages.TypeScript` so tsconfig path-alias resolution
+ * and `.ts`/`.tsx` extension guessing fire for relative and bare-specifier
+ * imports inside `<script>` blocks.
+ */
+export function makeVueResolveImportTarget(): (
+  targetRaw: string,
+  fromFile: string,
+  allFilePaths: ReadonlySet<string>,
+  resolutionConfig?: unknown,
+) => string | readonly string[] | null {
+  let cached: PassCache | null = null;
+
+  return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+    if (cached === null || cached.key !== allFilePaths) {
+      const allFileList = Array.from(allFilePaths);
+      const normalizedFileList = allFileList.map((f) => f.toLowerCase());
+      cached = {
+        key: allFilePaths,
+        allFilePaths: new Set(allFilePaths),
+        allFileList,
+        normalizedFileList,
+        index: buildSuffixIndex(normalizedFileList, allFileList),
+        resolveCache: new Map(),
+      };
+    }
+
+    const cfg = resolutionConfig as VueResolutionConfig | undefined;
+    const ws: TsResolveContext = {
+      fromFile,
+      language: SupportedLanguages.TypeScript,
+      allFilePaths: cached.allFilePaths,
+      allFileList: cached.allFileList,
+      normalizedFileList: cached.normalizedFileList,
+      index: cached.index,
+      resolveCache: cached.resolveCache,
+      tsconfigPaths: cfg?.tsconfigPaths ?? null,
+    };
+    return resolveTsTarget(targetRaw, ws);
+  };
+}
diff --git a/gitnexus/src/core/ingestion/languages/vue/index.ts b/gitnexus/src/core/ingestion/languages/vue/index.ts
new file mode 100644
index 0000000000..ed6ec8e836
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/vue/index.ts
@@ -0,0 +1,50 @@
+/**
+ * Vue SFC scope-resolution hooks (RFC #909 Ring 3, issue #940).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `captures.ts`       — `emitVueScopeCaptures` — extracts the
+ *                           `<script>` / `<script setup>` block and
+ *                           delegates to `emitTsScopeCaptures` (TypeScript
+ *                           grammar, same grammar the parse-worker uses).
+ *   - `import-target.ts`  — `makeVueResolveImportTarget` — memoized
+ *                           adapter using the TypeScript resolver with
+ *                           tsconfig path-alias support.
+ *   - `scope-resolver.ts` — `vueScopeResolver` wiring object.
+ *
+ * ## Known limitations
+ *
+ *   1. **Template expressions** — Full template AST parsing is not performed.
+ *      `vueScopeResolver.emitPostResolutionEdges` extracts five categories of
+ *      template-derived edges via lightweight regex, all emitted after standard
+ *      scope-resolution passes complete:
+ *        - PascalCase/kebab-case component references → `vue-template-component` `CALLS`
+ *        - `@event="handler"` on **native** elements → `vue-template-callback` `CALLS`
+ *        - `@event="handler"` on **component** elements → `vue-event: @<name>` `BINDS_EVENT_HANDLER`
+ *        - `emit(...)` / `this.$emit(...)` in script → `vue-emit: <name>` `EMITS_EVENT`
+ *        - `:prop="varName"` single-identifier bindings → `vue-template-attribute` `ACCESSES`
+ *      `BINDS_EVENT_HANDLER` and `EMITS_EVENT` are complementary "hanging" edges:
+ *      a Cypher query joining on the shared component File node reveals which
+ *      handlers receive which component's emitted events.
+ *      Complex inline expressions (`@click="toggle(item)"`, `{{ a + b }}`,
+ *      member-access bindings `:key="post.id"`) are intentionally excluded
+ *      because they cannot be resolved to a single call/access target without
+ *      a full template AST. Tracked in #1647.
+ *   2. **Options API `this` resolution** — `this.X()` in Options API
+ *      components does not resolve through type-binding when the component
+ *      uses a plain object literal rather than a class. `fieldFallbackOnMethodLookup`
+ *      recovers common cases via field-name matching.
+ *   3. **`<script setup>` + `<script>` dual-block** — When both blocks are
+ *      present, only `<script setup>` is processed (per `extractVueScript`
+ *      priority). The non-setup block is skipped.
+ *   4. **JSX in `<template>`** — Vue's template compiler is not a
+ *      tree-sitter grammar; JSX-style bindings inside templates are not
+ *      processed by the scope-resolution pipeline.
+ */
+
+export { emitVueScopeCaptures } from './captures.js';
+export { makeVueResolveImportTarget } from './import-target.js';
+export { vueScopeResolver } from './scope-resolver.js';
diff --git a/gitnexus/src/core/ingestion/languages/vue/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/vue/scope-resolver.ts
new file mode 100644
index 0000000000..01ee0a9b97
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/vue/scope-resolver.ts
@@ -0,0 +1,324 @@
+/**
+ * Vue `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #940).
+ *
+ * ## Design rationale
+ *
+ * Vue SFCs compile down to TypeScript/JavaScript — the `<script>` /
+ * `<script setup>` block is pure TS/JS, parsed with the TypeScript
+ * grammar and captured by `emitVueScopeCaptures` (which delegates
+ * to `emitTsScopeCaptures`).  Because of this, nearly all hooks are
+ * identical to the TypeScript resolver:
+ *
+ *   - `mergeBindings` — TypeScript LEGB semantics apply in script blocks.
+ *   - `arityCompatibility` — same positional + rest rules.
+ *   - `buildMro` / `populateOwners` — shared with TypeScript.
+ *   - `isSuperReceiver` — `super(...)` / `super.foo` / `super[x]` pattern.
+ *   - `resolveImportTarget` — TypeScript resolver with `.vue` explicit-
+ *                             extension support; tsconfig paths loaded via
+ *                             `loadResolutionConfig`.
+ *
+ * ## Key differences from TypeScript
+ *
+ *   - `language: SupportedLanguages.Vue` — routes the resolver to Vue
+ *     files only; TypeScript files use the TypeScript resolver.
+ *   - `languageProvider: vueProvider` — the Vue-specific language
+ *     provider supplies the right built-ins and export checker for
+ *     `<script setup>` (all top-level bindings implicitly exported).
+ *   - `importEdgeReason: 'vue-scope: import'` — distinct tag for
+ *     debugging / edge provenance.
+ *   - `allowGlobalFreeCallFallback: false` — Vue uses explicit imports;
+ *     workspace-wide unique-name fallback is unnecessary and would
+ *     produce spurious edges for Vue built-ins (ref, reactive, …).
+ *
+ * ## Options API / this-binding
+ *
+ * Options API (`defineComponent({ methods: { … } })`) stores methods
+ * on the component instance, which tree-sitter sees as object property
+ * values.  `this.X()` inside a method resolves via the existing
+ * `tsReceiverBinding` hook (inherited from TypeScript), which walks to
+ * the enclosing Class scope.  For Options API the enclosing "class" is
+ * the `defineComponent({…})` object — not a true class — so `this`
+ * calls may not resolve through the type-binding layer.  `fieldFallbackOnMethodLookup`
+ * is therefore set to `true` so the field-name fallback catches common
+ * patterns even without an explicit type annotation.
+ *
+ * ## `<script setup>` macro calls
+ *
+ * `defineProps`, `defineEmits`, `defineExpose`, `withDefaults`, etc.
+ * are compiler macros available as globals inside `<script setup>`.
+ * They are listed in `vueProvider.builtInNames` and therefore treated
+ * as resolved without requiring an import edge.
+ */
+
+import type { ParsedFile } from 'gitnexus-shared';
+import { SupportedLanguages, getLanguageFromFilename } from 'gitnexus-shared';
+import { generateId } from '../../../../lib/utils.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import { vueProvider } from '../vue.js';
+import { loadTsconfigPaths } from '../../language-config.js';
+import { typescriptArityCompatibility, typescriptMergeBindings } from '../typescript/index.js';
+import { makeVueResolveImportTarget } from './import-target.js';
+import { extractVueTemplateEdgeData } from '../../vue-sfc-extractor.js';
+import { extractParsedFile } from '../../scope-extractor-bridge.js';
+
+// Languages whose files may be pulled into the Vue scope-resolution pass
+// as import-closure context (`.vue` → `.ts` / `.js` cross-file resolution).
+const VUE_SCOPE_CONTEXT_LANGUAGES = new Set<SupportedLanguages>([
+  SupportedLanguages.Vue,
+  SupportedLanguages.TypeScript,
+  SupportedLanguages.JavaScript,
+]);
+
+function isVueScopeContextLanguage(lang: SupportedLanguages | null): boolean {
+  return lang !== null && VUE_SCOPE_CONTEXT_LANGUAGES.has(lang);
+}
+
+const vueScopeResolver: ScopeResolver = {
+  language: SupportedLanguages.Vue,
+  languageProvider: vueProvider,
+  importEdgeReason: 'vue-scope: import',
+
+  resolveImportTarget: makeVueResolveImportTarget(),
+
+  // Vue projects universally use TypeScript — load tsconfig so path
+  // aliases (`@/`, `~/`, `#/`) resolve through the standard branch.
+  loadResolutionConfig: async (repoPath: string) => ({
+    tsconfigPaths: await loadTsconfigPaths(repoPath),
+  }),
+
+  // TypeScript LEGB semantics apply inside `<script>` / `<script setup>`.
+  mergeBindings: (existing, incoming) => [...typescriptMergeBindings([...existing, ...incoming])],
+
+  // Adapter: typescriptArityCompatibility uses (def, callsite); contract is (callsite, def).
+  arityCompatibility: (callsite, def) => typescriptArityCompatibility(def, callsite),
+
+  buildMro: (graph, parsedFiles, nodeLookup) =>
+    buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+
+  populateOwners: (parsed: ParsedFile) => populateClassOwnedMembers(parsed),
+
+  isSuperReceiver: (text) => /^super(\s*\(|\s*\.|\s*\[|\s*$)/.test(text.trim()),
+
+  // Options API `this.X()` calls may not resolve through the type-binding
+  // layer (no formal class declaration), so enable the field-fallback
+  // heuristic to catch them via declared field names.
+  fieldFallbackOnMethodLookup: true,
+
+  // Return-type propagation mirrors TypeScript.
+  propagatesReturnTypesAcrossImports: true,
+  hoistTypeBindingsToModule: true,
+
+  // Vue uses explicit imports for all external symbols; no global free-
+  // call fallback needed (would produce spurious edges for built-ins).
+  allowGlobalFreeCallFallback: false,
+
+  /**
+   * Expand the scope-resolution file universe for Vue by performing a
+   * transitive closure over imports starting from the primary `.vue` files.
+   *
+   * Vue SFCs import TypeScript/JavaScript modules (`import { fn } from './api'`),
+   * and those modules must be included in the Vue resolution pass for cross-file
+   * IMPORTS/CALLS edges to resolve correctly.  Without this expansion, only
+   * `.vue` files would be processed and all TS/JS imports would remain
+   * unresolved.
+   *
+   * Keeping this logic here (rather than hard-coding it in `phase.ts`) ensures
+   * that shared pipeline code remains language-agnostic.
+   */
+  collectScopeContextPaths({
+    primaryFilePaths,
+    preExtractedByPath,
+    entryFileContents,
+    allScannedPaths,
+    resolutionConfig,
+  }) {
+    const resolveTargets = (targetRaw: string, fromFile: string): readonly string[] => {
+      const resolved = vueScopeResolver.resolveImportTarget(
+        targetRaw,
+        fromFile,
+        allScannedPaths,
+        resolutionConfig,
+      );
+      if (resolved === null) return [];
+      if (typeof resolved === 'string') return [resolved];
+      return resolved;
+    };
+
+    const visited = new Set<string>(primaryFilePaths);
+    const queue = [...primaryFilePaths];
+    const fallbackParsed = new Map<string, ParsedFile>();
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === undefined) break;
+      let parsed = preExtractedByPath.get(current) ?? fallbackParsed.get(current) ?? undefined;
+      if (parsed === undefined) {
+        const source = entryFileContents.get(current);
+        if (source !== undefined) {
+          parsed = extractParsedFile(vueProvider, source, current);
+          if (parsed !== undefined) fallbackParsed.set(current, parsed);
+        }
+      }
+      if (parsed === undefined) continue;
+
+      for (const parsedImport of parsed.parsedImports) {
+        if (parsedImport.targetRaw.trim().length === 0) continue;
+        for (const targetPath of resolveTargets(parsedImport.targetRaw, current)) {
+          if (!allScannedPaths.has(targetPath)) continue;
+          if (!isVueScopeContextLanguage(getLanguageFromFilename(targetPath))) continue;
+          if (visited.has(targetPath)) continue;
+          visited.add(targetPath);
+          queue.push(targetPath);
+        }
+      }
+    }
+
+    return visited;
+  },
+
+  /**
+   * Emit template-derived edges after standard scope-resolution passes.
+   *
+   * Six edge categories (all scoped to `.vue` files only):
+   *
+   *   1. **CALLS** (`vue-template-component`)
+   *      PascalCase component elements → the imported component's File node.
+   *      Source = the parent file (File node).
+   *
+   *   2. **CALLS** (`vue-template-callback`) — reserved for future use
+   *      (see category 3 below).
+   *
+   *   3. **CALLS** (`vue-template-callback`)
+   *      `@event="handler"` on a **native** HTML element (`<button>`, `<input>`).
+   *      Source = the parent file (File node). Target = handler Function/Method.
+   *
+   *   4. **BINDS_EVENT_HANDLER** (`vue-event: @<eventName>`)
+   *      `@event="handler"` on a **component** element.
+   *      Source = the handler Function/Method node in the parent file.
+   *      Target = the child component's File node.
+   *
+   *   5. **EMITS_EVENT** (`vue-emit: <eventName>`)
+   *      `emit('eventName', …)` / `this.$emit('eventName', …)` in script block.
+   *      Source = the file's own File node (self-referential annotation).
+   *      Target = the same File node.
+   *      These "hanging" edges join with BINDS_EVENT_HANDLER via Cypher query
+   *      on the shared component File node to reveal handler/emitter pairs.
+   *
+   *   6. **ACCESSES** (`vue-template-attribute`)
+   *      `:prop="varName"` bound-attribute references.
+   *      Source = the file's File node. Target = resolved variable node.
+   */
+  emitPostResolutionEdges(graph, parsedFiles, nodeLookup, indexes, ctx) {
+    for (const parsedFile of parsedFiles) {
+      if (!parsedFile.filePath.endsWith('.vue')) continue;
+      const content = ctx.fileContents.get(parsedFile.filePath);
+      if (!content) continue;
+
+      const fileId = generateId('File', parsedFile.filePath);
+
+      // Build localName → resolved targetFile from finalized import edges.
+      const importTargetByName = new Map<string, string>();
+      for (const [scopeId, edges] of indexes.imports) {
+        const scope = indexes.scopeTree.getScope(scopeId);
+        if (scope?.filePath !== parsedFile.filePath) continue;
+        for (const edge of edges) {
+          if (edge.targetFile !== null && edge.localName) {
+            importTargetByName.set(edge.localName, edge.targetFile);
+          }
+        }
+      }
+
+      // Extract all template/script edge data in a single pass — avoids
+      // re-running TEMPLATE_RE for each individual extractor call.
+      const {
+        templateComponents,
+        nativeEventHandlers,
+        componentEventBindings,
+        scriptEmitCalls,
+        templateAttributeBindings,
+      } = extractVueTemplateEdgeData(content, { sourceKind: 'full-sfc' });
+
+      // 1 — Component-reference CALLS
+      for (const componentName of templateComponents) {
+        const targetFile = importTargetByName.get(componentName);
+        if (!targetFile) continue;
+        const targetFileId = generateId('File', targetFile);
+        if (!graph.getNode(targetFileId)) continue;
+        graph.addRelationship({
+          id: generateId('CALLS', `${fileId}:${componentName}->${targetFileId}`),
+          sourceId: fileId,
+          targetId: targetFileId,
+          type: 'CALLS',
+          confidence: 0.9,
+          reason: 'vue-template-component',
+        });
+      }
+
+      // 3 — Native-element event-handler CALLS (@click="method" on <button> etc.)
+      for (const handlerName of nativeEventHandlers) {
+        const handlerNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, handlerName));
+        if (!handlerNodeId) continue;
+        graph.addRelationship({
+          id: generateId('CALLS', `${fileId}:@native:${handlerName}->${handlerNodeId}`),
+          sourceId: fileId,
+          targetId: handlerNodeId,
+          type: 'CALLS',
+          confidence: 0.9,
+          reason: 'vue-template-callback',
+        });
+      }
+
+      // 4 — BINDS_EVENT_HANDLER: component event bindings (@event="handler" on component elements)
+      for (const { componentName, eventName, handlerName } of componentEventBindings) {
+        const targetFile = importTargetByName.get(componentName);
+        if (!targetFile) continue;
+        const targetFileId = generateId('File', targetFile);
+        if (!graph.getNode(targetFileId)) continue;
+
+        const handlerNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, handlerName));
+        if (!handlerNodeId) continue;
+
+        graph.addRelationship({
+          id: generateId('BINDS_EVENT_HANDLER', `${handlerNodeId}:@${eventName}->${targetFileId}`),
+          sourceId: handlerNodeId,
+          targetId: targetFileId,
+          type: 'BINDS_EVENT_HANDLER',
+          confidence: 0.9,
+          reason: `vue-event: @${eventName}`,
+        });
+      }
+
+      // 5 — EMITS_EVENT: emit() / this.$emit() calls (self-referential annotation)
+      for (const { eventName } of scriptEmitCalls) {
+        graph.addRelationship({
+          id: generateId('EMITS_EVENT', `${fileId}:emit:${eventName}`),
+          sourceId: fileId,
+          targetId: fileId,
+          type: 'EMITS_EVENT',
+          confidence: 0.9,
+          reason: `vue-emit: ${eventName}`,
+        });
+      }
+
+      // 6 — ACCESSES: bound-attribute references (:prop="varName")
+      for (const varName of templateAttributeBindings) {
+        const varNodeId = nodeLookup.get(simpleKey(parsedFile.filePath, varName));
+        if (!varNodeId) continue;
+        graph.addRelationship({
+          id: generateId('ACCESSES', `${fileId}:bind:${varName}->${varNodeId}`),
+          sourceId: fileId,
+          targetId: varNodeId,
+          type: 'ACCESSES',
+          confidence: 0.8,
+          reason: 'vue-template-attribute',
+        });
+      }
+    }
+  },
+};
+
+export { vueScopeResolver };
diff --git a/gitnexus/src/core/ingestion/registry-primary-flag.ts b/gitnexus/src/core/ingestion/registry-primary-flag.ts
index fc2dcdeb1f..9d5c082fb9 100644
--- a/gitnexus/src/core/ingestion/registry-primary-flag.ts
+++ b/gitnexus/src/core/ingestion/registry-primary-flag.ts
@@ -84,6 +84,7 @@ export const MIGRATED_LANGUAGES: ReadonlySet<SupportedLanguages> = new Set<Suppo
   SupportedLanguages.Cobol,
   SupportedLanguages.Swift,
   SupportedLanguages.Dart,
+  SupportedLanguages.Vue,
 ]);
 
 /**
diff --git a/gitnexus/src/core/ingestion/scope-extractor-bridge.ts b/gitnexus/src/core/ingestion/scope-extractor-bridge.ts
index 41a50193de..626f837289 100644
--- a/gitnexus/src/core/ingestion/scope-extractor-bridge.ts
+++ b/gitnexus/src/core/ingestion/scope-extractor-bridge.ts
@@ -31,6 +31,7 @@ import type { LanguageProvider } from './language-provider.js';
 import { logger } from '../logger.js';
 /** Callback used to report scope-extraction warnings to the host (worker or direct). */
 export type ScopeBridgeWarn = (message: string) => void;
+export type ScopeCaptureSourceKind = 'full-file' | 'pre-extracted-script';
 
 /**
  * Produce a `ParsedFile` for the given file, or `undefined` when the
@@ -43,11 +44,12 @@ export function extractParsedFile(
   filePath: string,
   onWarn?: ScopeBridgeWarn,
   cachedTree?: unknown,
+  sourceKind: ScopeCaptureSourceKind = 'full-file',
 ): ParsedFile | undefined {
   if (provider.emitScopeCaptures === undefined) return undefined;
   if (sourceText.trim().length === 0) return undefined;
   try {
-    const captures = provider.emitScopeCaptures(sourceText, filePath, cachedTree);
+    const captures = provider.emitScopeCaptures(sourceText, filePath, cachedTree, { sourceKind });
     return extractScope(captures, filePath, provider);
   } catch (err) {
     const message = `scope extraction failed for ${filePath}: ${
diff --git a/gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts b/gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts
index 35ce18c6e2..b3a84beb22 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts
@@ -915,6 +915,72 @@ export interface ScopeResolver {
     },
   ) => void;
 
+  /**
+   * Optional hook to expand the set of file paths handed to the scope-
+   * resolution run for this language.
+   *
+   * Called once per language with:
+   *   - `primaryFilePaths`      — files whose `getLanguageFromFilename` === this
+   *                               resolver's `language` (e.g. all `.vue` files).
+   *   - `preExtractedByPath`    — ParsedFile cache from the parse phase.
+   *   - `entryFileContents`     — raw source text of the primary files.
+   *   - `allScannedPaths`       — complete set of paths in the repository.
+   *   - `resolutionConfig`      — language-specific config (tsconfig paths, …).
+   *
+   * Return value: the full set of paths to include in the scope-resolution
+   * run.  May be a superset of `primaryFilePaths`.
+   *
+   * Vue uses this hook to collect the transitive TS/JS import closure of
+   * every `.vue` file so that cross-file imports (`import { fn } from './api'`)
+   * resolve correctly within a single Vue scope-resolution pass.
+   *
+   * This hook keeps language-specific scope-context policy inside the language
+   * module, preventing shared pipeline code (`phase.ts`) from naming individual
+   * languages.
+   *
+   * Default: undefined (use only `primaryFilePaths`).
+   */
+  readonly collectScopeContextPaths?: (options: {
+    readonly primaryFilePaths: readonly string[];
+    readonly preExtractedByPath: ReadonlyMap<string, import('gitnexus-shared').ParsedFile>;
+    readonly entryFileContents: ReadonlyMap<string, string>;
+    readonly allScannedPaths: ReadonlySet<string>;
+    readonly resolutionConfig: unknown;
+  }) => Set<string>;
+
+  /**
+   * Optional post-resolution hook for emitting language-specific graph edges
+   * that cannot be derived from scope captures or import resolution alone.
+   *
+   * Runs AFTER all standard edge-emission passes (receiver-bound CALLS,
+   * free-call fallback, references-via-lookup, and import edges). Receives
+   * the fully-resolved graph, all ParsedFiles, the node lookup, the finalized
+   * scope indexes, and the raw file-content map.
+   *
+   * Vue uses this hook to emit:
+   *   - `CALLS` (`vue-template-component`) for PascalCase component elements
+   *   - `BINDS_EVENT_HANDLER` for `@event="handler"` on component elements
+   *   - `EMITS_EVENT` for `emit('eventName', …)` calls in script blocks
+   *   - `ACCESSES` (`vue-template-attribute`) for `:prop="var"` bindings
+   *
+   * Unlike `emitImplicitImportEdges` and `emitHeritageEdges` (which run
+   * before MRO construction), this hook runs last, after the full graph is
+   * populated, so it can safely query node existence and resolved import
+   * targets via `indexes.imports`.
+   *
+   * Default: undefined (no supplementary edges needed).
+   */
+  readonly emitPostResolutionEdges?: (
+    graph: KnowledgeGraph,
+    parsedFiles: readonly ParsedFile[],
+    nodeLookup: GraphNodeLookup,
+    indexes: ScopeResolutionIndexes,
+    ctx: {
+      readonly fileContents: ReadonlyMap<string, string>;
+      readonly resolutionConfig?: unknown;
+    },
+  ) => void;
+
   /**
    * Optional post-resolution pass: emit CALLS edges for member-call sites
    * whose receiver cannot be typed by the scope chain (no `TypeRef`).
diff --git a/gitnexus/src/core/ingestion/scope-resolution/pipeline/phase.ts b/gitnexus/src/core/ingestion/scope-resolution/pipeline/phase.ts
index ae7847e68b..d5018057e8 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/pipeline/phase.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/pipeline/phase.ts
@@ -146,8 +146,11 @@ export const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput> = {
 
     // Pre-count files and languages for progress reporting. This avoids
     // a frozen progress bar during long scope-resolution runs (#1741).
+    // Uses primary-language file counts only; languages that expand their
+    // context via collectScopeContextPaths may process more files than shown.
     let totalScopeFiles = 0;
     let totalScopeLangs = 0;
+    const allScannedPaths = new Set(scannedFiles.map((f) => f.path));
     for (const [lang] of SCOPE_RESOLVERS) {
       if (!isRegistryPrimary(lang)) continue;
       const count = scannedFiles.filter((f) => getLanguageFromFilename(f.path) === lang).length;
@@ -180,16 +183,9 @@ export const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput> = {
       // SCOPE_RESOLVERS.
       if (provider.languageProvider.parseStrategy === 'standalone') continue;
 
-      const langFiles = scannedFiles.filter((f) => getLanguageFromFilename(f.path) === lang);
-      if (langFiles.length === 0) continue;
-
-      const filePaths = langFiles.map((f) => f.path);
-      const contents = await readFileContents(ctx.repoPath, filePaths);
-      const files: { path: string; content: string }[] = [];
-      for (const fp of filePaths) {
-        const content = contents.get(fp);
-        if (content !== undefined) files.push({ path: fp, content });
-      }
+      const primaryLangFiles = scannedFiles.filter((f) => getLanguageFromFilename(f.path) === lang);
+      if (primaryLangFiles.length === 0) continue;
+      const primaryFilePaths = primaryLangFiles.map((f) => f.path);
 
       // Load per-language import-resolution config (tsconfig paths,
       // composer.json autoload, go.mod, ...). One I/O round trip per
@@ -200,6 +196,40 @@ export const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput> = {
           ? await provider.loadResolutionConfig(ctx.repoPath)
           : undefined;
 
+      // Some languages (e.g. Vue) expand their file universe beyond the
+      // primary-language files via the `collectScopeContextPaths` hook.
+      // The hook receives raw source contents of the primary files so it
+      // can trace import closures without a second tree-sitter parse.
+      //
+      // To avoid reading primary files twice (once for the hook, once for
+      // the resolution pass), we read them upfront and merge with the
+      // extra context paths the hook may add.
+      let scopeFilePaths: Set<string>;
+      let contents: Map<string, string>;
+      if (provider.collectScopeContextPaths !== undefined) {
+        const entryFileContents = await readFileContents(ctx.repoPath, primaryFilePaths);
+        scopeFilePaths = provider.collectScopeContextPaths({
+          primaryFilePaths,
+          preExtractedByPath,
+          entryFileContents,
+          allScannedPaths,
+          resolutionConfig,
+        });
+        // Read only the extra context files (TS/JS etc.) not already loaded.
+        const extraPaths = [...scopeFilePaths].filter((p) => !entryFileContents.has(p));
+        const extraContents = await readFileContents(ctx.repoPath, extraPaths);
+        contents = new Map([...entryFileContents, ...extraContents]);
+      } else {
+        scopeFilePaths = new Set(primaryFilePaths);
+        contents = await readFileContents(ctx.repoPath, primaryFilePaths);
+      }
+      const filePaths = [...scopeFilePaths];
+      const files: { path: string; content: string }[] = [];
+      for (const fp of filePaths) {
+        const content = contents.get(fp);
+        if (content !== undefined) files.push({ path: fp, content });
+      }
+
       const langFileCount = files.length;
       const langLabel = lang.charAt(0).toUpperCase() + lang.slice(1);
       currentLangIdx++;
@@ -279,6 +309,10 @@ export const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput> = {
       // to reduce memory pressure. For large codebases (16K+ PHP files),
       // holding all source code simultaneously with scope trees causes OOM.
       // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+      //
+      // Use `filePaths` (not `primaryFilePaths`) so that any context files
+      // added by `collectScopeContextPaths` (e.g. TS/JS files pulled in for
+      // Vue cross-file resolution) are also evicted and not held until GC.
       files.length = 0;
       contents.clear();
       for (const fp of filePaths) {
diff --git a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
index 2dc09c26a2..0b5edf464f 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
@@ -26,6 +26,7 @@ import { rubyScopeResolver } from '../../languages/ruby/scope-resolver.js';
 import { cobolScopeResolver } from '../../languages/cobol/scope-resolver.js';
 import { swiftScopeResolver } from '../../languages/swift/scope-resolver.js';
 import { dartScopeResolver } from '../../languages/dart/scope-resolver.js';
+import { vueScopeResolver } from '../../languages/vue/scope-resolver.js';
 
 /** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
  *  this map intersected with `MIGRATED_LANGUAGES` (the per-language
@@ -50,4 +51,5 @@ export const SCOPE_RESOLVERS: ReadonlyMap<SupportedLanguages, ScopeResolver> = n
   [SupportedLanguages.Cobol, cobolScopeResolver],
   [SupportedLanguages.Swift, swiftScopeResolver],
   [SupportedLanguages.Dart, dartScopeResolver],
+  [SupportedLanguages.Vue, vueScopeResolver],
 ]);
diff --git a/gitnexus/src/core/ingestion/scope-resolution/pipeline/run.ts b/gitnexus/src/core/ingestion/scope-resolution/pipeline/run.ts
index 8882885c45..9d8d738f8d 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/pipeline/run.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/pipeline/run.ts
@@ -592,6 +592,16 @@ export function runScopeResolution(
     provider.importEdgeReason,
   );
 
+  // Language-specific supplementary edges (e.g. Vue template-derived
+  // BINDS_EVENT_HANDLER / EMITS_EVENT / CALLS / ACCESSES edges).
+  // Runs last so the full graph — including import edges — is visible.
+  if (provider.emitPostResolutionEdges !== undefined) {
+    provider.emitPostResolutionEdges(graph, parsedFiles, postHeritageNodeLookup, indexes, {
+      fileContents: getFileContents(),
+      resolutionConfig,
+    });
+  }
+
   if (PROF) {
     const tEnd = process.hrtime.bigint();
     const ns = (a: bigint, b: bigint): number => Number(b - a) / 1_000_000;
diff --git a/gitnexus/src/core/ingestion/vue-sfc-extractor.ts b/gitnexus/src/core/ingestion/vue-sfc-extractor.ts
index f36a85ab41..1f899fa821 100644
--- a/gitnexus/src/core/ingestion/vue-sfc-extractor.ts
+++ b/gitnexus/src/core/ingestion/vue-sfc-extractor.ts
@@ -42,10 +42,22 @@ interface ScriptBlock {
 // attribute axes; this expression closes both at once.
 const SCRIPT_RE = /<script(\s[^>]*)?>([^]*?)<\/script[^>]*>/gi;
 const TEMPLATE_COMPONENT_RE = /<([A-Z][A-Za-z0-9]+)/g;
+const TEMPLATE_KEBAB_COMPONENT_RE = /<([a-z][a-z0-9]*(?:-[a-z0-9]+)+)\b/g;
 // Greedy: matches from the first <template> to the *last* </template>.
 // This is intentional — nested <template v-slot:...> tags are valid Vue
 // syntax and we want the entire outermost template body.
 const TEMPLATE_RE = /<template(\s[^>]*)?>([^]*)<\/template>/;
+const VUE_BUILTIN_KEBAB_TAGS = new Set<string>([
+  'router-view',
+  'router-link',
+  'transition',
+  'transition-group',
+  'keep-alive',
+  'teleport',
+  'suspense',
+  'component',
+  'slot',
+]);
 
 function countNewlines(text: string): number {
   let count = 0;
@@ -55,6 +67,160 @@ function countNewlines(text: string): number {
   return count;
 }
 
+function kebabToPascal(name: string): string {
+  return name
+    .split('-')
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function isBuiltinKebabTag(tagName: string): boolean {
+  return VUE_BUILTIN_KEBAB_TAGS.has(tagName);
+}
+
+/**
+ * Extract bare `emit('event')` / `$emit('event')` calls from script text.
+ *
+ * Uses a lightweight lexer state-machine (code vs comments/strings), so:
+ * - ignores `emit(...)` in comments and string literals
+ * - ignores property calls like `socket.emit(...)` / `this.$emit(...)`
+ * - captures only literal-string event names
+ */
+function collectBareEmitEventNames(input: string): string[] {
+  enum Mode {
+    Code,
+    SingleQuote,
+    DoubleQuote,
+    Template,
+    LineComment,
+    BlockComment,
+  }
+
+  const events: string[] = [];
+  const seen = new Set<string>();
+  let mode = Mode.Code;
+
+  const isIdentChar = (c: string): boolean => /[A-Za-z0-9_$]/.test(c);
+  const skipSpaces = (idx: number): number => {
+    let i = idx;
+    while (i < input.length && /\s/.test(input[i])) i++;
+    return i;
+  };
+
+  /**
+   * Return true if the token immediately before the `.` at `dotIdx` is the
+   * keyword `this` and is not itself a property access (e.g. not `foo.this`).
+   * Used to allow `this.$emit(...)` while blocking `socket.emit(...)`.
+   */
+  const lookbackIsThis = (dotIdx: number): boolean => {
+    let j = dotIdx - 1; // step past the '.'
+    while (j >= 0 && /\s/.test(input[j])) j--;
+    if (j < 3) return false;
+    if (input.slice(j - 3, j + 1) !== 'this') return false;
+    // Ensure 'this' is not itself a property target (e.g. foo.this)
+    const prevOfThis = j >= 4 ? input[j - 4] : '';
+    return !(prevOfThis.length > 0 && (isIdentChar(prevOfThis) || prevOfThis === '.'));
+  };
+
+  const tryConsumeEmitCall = (idx: number): number => {
+    const hasDollar = input[idx] === '$';
+    const name = hasDollar ? '$emit' : 'emit';
+    if (!input.startsWith(name, idx)) return idx;
+    const prev = idx > 0 ? input[idx - 1] : '';
+    if (prev.length > 0 && isIdentChar(prev)) return idx;
+    if (prev === '.') {
+      // Allow `this.$emit(...)` / `this.emit(...)` but block `socket.emit(...)`.
+      if (!lookbackIsThis(idx - 1)) return idx;
+    }
+    const afterName = idx + name.length;
+    const next = afterName < input.length ? input[afterName] : '';
+    if (next.length > 0 && isIdentChar(next)) return idx;
+
+    let i = skipSpaces(afterName);
+    if (input[i] !== '(') return idx;
+    i = skipSpaces(i + 1);
+    const quote = input[i];
+    if (quote !== "'" && quote !== '"') return idx;
+
+    let eventName = '';
+    i++;
+    while (i < input.length) {
+      const ch = input[i];
+      if (ch === '\\') {
+        i += 2;
+        continue;
+      }
+      if (ch === quote) break;
+      eventName += ch;
+      i++;
+    }
+    if (i >= input.length) return idx;
+    // Allow simple names ("save"), hyphenated names ("user-loaded"), and
+    // update modifier patterns ("update:modelValue", "update:model-value").
+    if (/^[A-Za-z$_][A-Za-z0-9:_$-]*$/.test(eventName) && !seen.has(eventName)) {
+      seen.add(eventName);
+      events.push(eventName);
+    }
+    return i;
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const next = i + 1 < input.length ? input[i + 1] : '';
+
+    if (mode === Mode.Code) {
+      const consumedAt = tryConsumeEmitCall(i);
+      if (consumedAt !== i) {
+        i = consumedAt;
+        continue;
+      }
+      if (ch === "'" || ch === '"' || ch === '`') {
+        mode = ch === "'" ? Mode.SingleQuote : ch === '"' ? Mode.DoubleQuote : Mode.Template;
+        continue;
+      }
+      if (ch === '/' && next === '/') {
+        mode = Mode.LineComment;
+        i++;
+      } else if (ch === '/' && next === '*') {
+        mode = Mode.BlockComment;
+        i++;
+      }
+      continue;
+    }
+
+    if (mode === Mode.LineComment) {
+      if (ch === '\n') {
+        mode = Mode.Code;
+      }
+      continue;
+    }
+
+    if (mode === Mode.BlockComment) {
+      if (ch === '*' && next === '/') {
+        i++;
+        mode = Mode.Code;
+      }
+      continue;
+    }
+
+    if (ch === '\\') {
+      i++;
+      continue;
+    }
+
+    if (
+      (mode === Mode.SingleQuote && ch === "'") ||
+      (mode === Mode.DoubleQuote && ch === '"') ||
+      (mode === Mode.Template && ch === '`')
+    ) {
+      mode = Mode.Code;
+    }
+  }
+
+  return events;
+}
+
 function parseScriptBlock(
   attrs: string | undefined,
   content: string,
@@ -138,5 +304,318 @@ export function extractTemplateComponents(vueContent: string): string[] {
     components.add(componentMatch[1]);
   }
 
+  TEMPLATE_KEBAB_COMPONENT_RE.lastIndex = 0;
+  while ((componentMatch = TEMPLATE_KEBAB_COMPONENT_RE.exec(templateContent)) !== null) {
+    if (isBuiltinKebabTag(componentMatch[1])) continue;
+    components.add(kebabToPascal(componentMatch[1]));
+  }
+
   return [...components];
 }
+
+// ── Per-element event binding extraction ──────────────────────────────────
+//
+// Three sibling regexes capture opening tags distinguished by PascalCase
+// (Vue components), kebab-case (Vue components in kebab form), and simple
+// lowercase (native HTML elements). All stop their attribute-block capture
+// at the first `>` with a bounded span of at most 512 characters to avoid
+// pathological backtracking on large template files (ReDoS mitigation).
+// Multi-line tags whose attribute block contains a literal `>` are documented
+// as a known limitation (#1647).
+//
+// NATIVE_TAG_RE uses `(?![A-Za-z0-9-])` to prevent matching the `post` prefix
+// of a kebab-case component tag like `<post-list>` — such tags are handled by
+// KEBAB_COMPONENT_TAG_RE, not NATIVE_TAG_RE.
+const COMPONENT_TAG_RE = /<([A-Z][A-Za-z0-9]+)([^>]{0,512}?)(?:\/>|>)/g;
+const KEBAB_COMPONENT_TAG_RE = /<([a-z][a-z0-9]*(?:-[a-z0-9]+)+)([^>]{0,512}?)(?:\/>|>)/g;
+const NATIVE_TAG_RE = /<([a-z][a-z0-9]*)(?![A-Za-z0-9-])([^>]{0,512}?)(?:\/>|>)/g;
+
+// Within any tag's attribute block: matches Vue event bindings.
+//   @action="handleAction"
+//   @keyup.enter="submit"
+//   @user-loaded="onLoaded"        — hyphenated event names
+//   @update:model-value="onChange" — update modifier with colon
+//   v-on:click="onClick"
+const TAG_EVENT_RE = /(?:@|v-on:)([\w:.-]+)\s*=\s*["']([A-Za-z_$][A-Za-z0-9_$]*)["']/g;
+
+// ── Script emit() call extraction ─────────────────────────────────────────
+
+// Matches simple variable references in Vue bound-attribute values.
+// Captures only bare identifiers — not member-access (":key=\"post.id\""),
+// literals (":id=\"1\""), or expressions (":val=\"a + b\"").
+//
+//   :userId="currentUserId"      → "currentUserId"
+//   :posts="allPosts"            → "allPosts"
+//   v-bind:disabled="isLoading"  → "isLoading"
+//   :key="post.id"               — skipped (member access)
+//   :id="1"                      — skipped (literal)
+const BOUND_ATTR_RE = /(?::[\w-]+|v-bind:[\w-]+)\s*=\s*["']([A-Za-z_$][A-Za-z0-9_$]*)["']/g;
+
+export interface ComponentEventBinding {
+  /** PascalCase name of the child component element (e.g. `"PostList"`). */
+  componentName: string;
+  /** Vue event name without the `@` prefix (e.g. `"select"`, `"keyup.enter"`). */
+  eventName: string;
+  /** Bare identifier of the parent handler function (e.g. `"onPostSelected"`). */
+  handlerName: string;
+}
+
+/**
+ * Extract Vue component event bindings from a `<template>` block.
+ *
+ * Scans PascalCase component elements (e.g. `<PostList>`, `<UserCard>`) and
+ * returns each `@event="handler"` binding found in the element's attribute
+ * block. Native HTML element event handlers (`@click` on `<button>`, etc.)
+ * are intentionally excluded — only component-to-component event bindings
+ * that go through Vue's `emit()` / `defineEmits` system are included.
+ *
+ * **Limitation:** component tags whose attribute block spans multiple lines
+ * and contains a `>` inside an attribute value are not captured (the regex
+ * stops at the first `>`). Full template AST parsing would be required for
+ * those edge cases (tracked in #1647).
+ */
+export function extractComponentEventBindings(vueContent: string): ComponentEventBinding[] {
+  const templateMatch = TEMPLATE_RE.exec(vueContent);
+  if (!templateMatch) return [];
+
+  const templateContent = templateMatch[2];
+  const bindings: ComponentEventBinding[] = [];
+  const seen = new Set<string>();
+
+  COMPONENT_TAG_RE.lastIndex = 0;
+  let tagMatch: RegExpExecArray | null;
+  while ((tagMatch = COMPONENT_TAG_RE.exec(templateContent)) !== null) {
+    const componentName = tagMatch[1];
+    const attrs = tagMatch[2];
+
+    TAG_EVENT_RE.lastIndex = 0;
+    let eventMatch: RegExpExecArray | null;
+    while ((eventMatch = TAG_EVENT_RE.exec(attrs)) !== null) {
+      const eventName = eventMatch[1];
+      const handlerName = eventMatch[2];
+      const key = `${componentName}::${eventName}::${handlerName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      bindings.push({ componentName, eventName, handlerName });
+    }
+  }
+
+  KEBAB_COMPONENT_TAG_RE.lastIndex = 0;
+  while ((tagMatch = KEBAB_COMPONENT_TAG_RE.exec(templateContent)) !== null) {
+    if (isBuiltinKebabTag(tagMatch[1])) continue;
+    const componentName = kebabToPascal(tagMatch[1]);
+    const attrs = tagMatch[2];
+
+    TAG_EVENT_RE.lastIndex = 0;
+    let eventMatch: RegExpExecArray | null;
+    while ((eventMatch = TAG_EVENT_RE.exec(attrs)) !== null) {
+      const eventName = eventMatch[1];
+      const handlerName = eventMatch[2];
+      const key = `${componentName}::${eventName}::${handlerName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      bindings.push({ componentName, eventName, handlerName });
+    }
+  }
+
+  return bindings;
+}
+
+/**
+ * Extract event handler names bound to native HTML elements in the template.
+ *
+ * Only processes lowercase-named elements (`<button>`, `<input>`, `<div>`,
+ * etc.) — PascalCase component elements are handled by
+ * `extractComponentEventBindings`. Returns bare handler identifiers only;
+ * inline expressions with arguments or arrow functions are excluded.
+ *
+ * These handlers represent direct DOM-event→function relationships and
+ * are emitted as `CALLS` edges (not `BINDS_EVENT_HANDLER`), because native
+ * events are synchronous browser callbacks, not Vue's component-event system.
+ */
+export function extractNativeElementEventHandlers(vueContent: string): string[] {
+  const templateMatch = TEMPLATE_RE.exec(vueContent);
+  if (!templateMatch) return [];
+
+  const templateContent = templateMatch[2];
+  const handlers: string[] = [];
+
+  NATIVE_TAG_RE.lastIndex = 0;
+  let tagMatch: RegExpExecArray | null;
+  while ((tagMatch = NATIVE_TAG_RE.exec(templateContent)) !== null) {
+    const attrs = tagMatch[2];
+
+    TAG_EVENT_RE.lastIndex = 0;
+    let eventMatch: RegExpExecArray | null;
+    while ((eventMatch = TAG_EVENT_RE.exec(attrs)) !== null) {
+      handlers.push(eventMatch[2]);
+    }
+  }
+
+  return handlers;
+}
+
+export interface ScriptEmitCall {
+  /** Vue event name passed to `emit()` (e.g. `"action"`, `"update"`). */
+  eventName: string;
+}
+
+export interface ExtractScriptEmitCallsOptions {
+  /**
+   * How to interpret the input text.
+   * - `full-sfc` (default): input is a full `.vue` SFC string.
+   * - `pre-extracted-script`: input is already the bare script text.
+   */
+  sourceKind?: 'full-sfc' | 'pre-extracted-script';
+}
+
+/**
+ * Extract `emit('eventName', ...)` calls from a Vue SFC's `<script>` block.
+ *
+ * Scans the raw SFC source (full `.vue` file), extracts the script content,
+ * then finds bare `emit('...')` calls. Only captures literal string event
+ * names — dynamic expressions (`emit(eventName)`) are excluded.
+ *
+ * Returns deduplicated emit declarations.
+ */
+export function extractScriptEmitCalls(
+  vueContent: string,
+  options: ExtractScriptEmitCallsOptions = {},
+): ScriptEmitCall[] {
+  const sourceKind = options.sourceKind ?? 'full-sfc';
+  const scriptText =
+    sourceKind === 'pre-extracted-script'
+      ? vueContent
+      : (extractVueScript(vueContent)?.scriptContent ?? null);
+  if (!scriptText) return [];
+  return collectBareEmitEventNames(scriptText).map((eventName) => ({ eventName }));
+}
+
+/**
+ * Extract variable identifiers from Vue template bound-attribute values.
+ *
+ * Covers `:prop="varName"` and `v-bind:prop="varName"` patterns where
+ * the value is a single plain identifier.  Member-access expressions
+ * (`:key="post.id"`) and literals are excluded by design.
+ *
+ * Returns deduplicated identifier names.
+ */
+export function extractTemplateAttributeBindings(vueContent: string): string[] {
+  const templateMatch = TEMPLATE_RE.exec(vueContent);
+  if (!templateMatch) return [];
+
+  const templateContent = templateMatch[2];
+  const vars = new Set<string>();
+  let match: RegExpExecArray | null;
+
+  BOUND_ATTR_RE.lastIndex = 0;
+  while ((match = BOUND_ATTR_RE.exec(templateContent)) !== null) {
+    vars.add(match[1]);
+  }
+
+  return [...vars];
+}
+
+export interface VueTemplateEdgeData {
+  /** PascalCase component names referenced in the template. */
+  readonly templateComponents: readonly string[];
+  /** Handler names on native elements (@click="fn"). */
+  readonly nativeEventHandlers: readonly string[];
+  /** Component event bindings (@event="handler" on component elements). */
+  readonly componentEventBindings: readonly ComponentEventBinding[];
+  /** Event names from emit() / this.$emit() calls in the script block. */
+  readonly scriptEmitCalls: readonly ScriptEmitCall[];
+  /** Bound attribute variable names (:prop="varName"). */
+  readonly templateAttributeBindings: readonly string[];
+}
+
+/**
+ * Extract all template-derived edge data from a Vue SFC in a single pass.
+ *
+ * Parses the `<template>` block once and the `<script>` block once, then
+ * runs all five extractors on the pre-parsed content rather than repeating
+ * the regex on every individual call.  Used by `emitPostResolutionEdges`
+ * to avoid multiple full-file scans per `.vue` file.
+ */
+export function extractVueTemplateEdgeData(
+  vueContent: string,
+  options: ExtractScriptEmitCallsOptions = {},
+): VueTemplateEdgeData {
+  // Extract template content once.
+  const templateMatch = TEMPLATE_RE.exec(vueContent);
+  const tmpl = templateMatch ? templateMatch[2] : '';
+
+  // Template components (PascalCase + kebab-case).
+  const componentSet = new Set<string>();
+  if (tmpl) {
+    TEMPLATE_COMPONENT_RE.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = TEMPLATE_COMPONENT_RE.exec(tmpl)) !== null) componentSet.add(m[1]);
+    TEMPLATE_KEBAB_COMPONENT_RE.lastIndex = 0;
+    while ((m = TEMPLATE_KEBAB_COMPONENT_RE.exec(tmpl)) !== null) {
+      if (!isBuiltinKebabTag(m[1])) componentSet.add(kebabToPascal(m[1]));
+    }
+  }
+
+  // Native element event handlers.
+  const nativeHandlers: string[] = [];
+  if (tmpl) {
+    NATIVE_TAG_RE.lastIndex = 0;
+    let tagM: RegExpExecArray | null;
+    while ((tagM = NATIVE_TAG_RE.exec(tmpl)) !== null) {
+      TAG_EVENT_RE.lastIndex = 0;
+      let evM: RegExpExecArray | null;
+      while ((evM = TAG_EVENT_RE.exec(tagM[2])) !== null) nativeHandlers.push(evM[2]);
+    }
+  }
+
+  // Component event bindings.
+  const componentBindings: ComponentEventBinding[] = [];
+  const bindingSeen = new Set<string>();
+  const processComponentAttrs = (componentName: string, attrs: string): void => {
+    TAG_EVENT_RE.lastIndex = 0;
+    let evM: RegExpExecArray | null;
+    while ((evM = TAG_EVENT_RE.exec(attrs)) !== null) {
+      const key = `${componentName}::${evM[1]}::${evM[2]}`;
+      if (!bindingSeen.has(key)) {
+        bindingSeen.add(key);
+        componentBindings.push({ componentName, eventName: evM[1], handlerName: evM[2] });
+      }
+    }
+  };
+  if (tmpl) {
+    COMPONENT_TAG_RE.lastIndex = 0;
+    let tagM: RegExpExecArray | null;
+    while ((tagM = COMPONENT_TAG_RE.exec(tmpl)) !== null) processComponentAttrs(tagM[1], tagM[2]);
+    KEBAB_COMPONENT_TAG_RE.lastIndex = 0;
+    while ((tagM = KEBAB_COMPONENT_TAG_RE.exec(tmpl)) !== null) {
+      if (!isBuiltinKebabTag(tagM[1])) processComponentAttrs(kebabToPascal(tagM[1]), tagM[2]);
+    }
+  }
+
+  // Script emit() calls.
+  const sourceKind = options.sourceKind ?? 'full-sfc';
+  const scriptText =
+    sourceKind === 'pre-extracted-script'
+      ? vueContent
+      : (extractVueScript(vueContent)?.scriptContent ?? null);
+  const scriptEmitCalls: ScriptEmitCall[] = scriptText
+    ? collectBareEmitEventNames(scriptText).map((eventName) => ({ eventName }))
+    : [];
+
+  // Bound attribute bindings.
+  const attrVars = new Set<string>();
+  if (tmpl) {
+    BOUND_ATTR_RE.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = BOUND_ATTR_RE.exec(tmpl)) !== null) attrVars.add(m[1]);
+  }
+
+  return {
+    templateComponents: [...componentSet],
+    nativeEventHandlers: nativeHandlers,
+    componentEventBindings: componentBindings,
+    scriptEmitCalls,
+    templateAttributeBindings: [...attrVars],
+  };
+}
diff --git a/gitnexus/src/core/ingestion/workers/parse-worker.ts b/gitnexus/src/core/ingestion/workers/parse-worker.ts
index 2bb2ea0439..e53ec3ab0d 100644
--- a/gitnexus/src/core/ingestion/workers/parse-worker.ts
+++ b/gitnexus/src/core/ingestion/workers/parse-worker.ts
@@ -98,7 +98,7 @@ import {
 import { extractTemplateArguments, templateArgumentsIdTag } from '../utils/template-arguments.js';
 import type { LanguageProvider } from '../language-provider.js';
 import type { ParsedFile } from 'gitnexus-shared';
-import { extractParsedFile } from '../scope-extractor-bridge.js';
+import { extractParsedFile, type ScopeCaptureSourceKind } from '../scope-extractor-bridge.js';
 import { extractLaravelRoutes, type ExtractedRoute } from '../route-extractors/laravel.js';
 
 import { logger } from '../../logger.js';
@@ -1111,12 +1111,14 @@ const processFileGroup = (
 
     // Vue SFC preprocessing: extract <script> block content
     let parseContent = file.content;
+    let scopeSourceKind: ScopeCaptureSourceKind = 'full-file';
     let lineOffset = 0;
     let isVueSetup = false;
     if (language === SupportedLanguages.Vue) {
       const extracted = extractVueScript(file.content);
       if (!extracted) continue; // skip .vue files with no script block
       parseContent = extracted.scriptContent;
+      scopeSourceKind = 'pre-extracted-script';
       lineOffset = extracted.lineOffset;
       isVueSetup = extracted.isSetup;
     }
@@ -1174,6 +1176,7 @@ const processFileGroup = (
         }
       },
       tree,
+      scopeSourceKind,
     );
     if (parsedFile !== undefined) result.parsedFiles.push(parsedFile);
 
diff --git a/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/App.vue b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/App.vue
new file mode 100644
index 0000000000..eaa93d33a7
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/App.vue
@@ -0,0 +1,20 @@
+<template>
+  <div id="app">
+    <UserProfile :userId="currentUserId" />
+    <PostList :posts="allPosts" @select="onPostSelected" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue';
+import type { Post } from './types';
+import UserProfile from './UserProfile.vue';
+import PostList from './PostList.vue';
+
+const currentUserId = ref(1);
+const allPosts = ref<Post[]>([]);
+
+function onPostSelected(post: Post) {
+  console.log('selected', post.id);
+}
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/PostList.vue b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/PostList.vue
new file mode 100644
index 0000000000..5334b754e4
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/PostList.vue
@@ -0,0 +1,33 @@
+<template>
+  <div class="post-list">
+    <div v-for="post in posts" :key="post.id" class="post-item">
+      <h3>{{ post.title }}</h3>
+      <button @click="selectPost(post)">View</button>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue';
+import type { Post } from './types';
+import { formatPost } from './types';
+
+const props = defineProps<{
+  posts: Post[];
+}>();
+
+const emit = defineEmits<{
+  select: [post: Post];
+}>();
+
+const selectedPost = ref<Post | null>(null);
+
+function selectPost(post: Post) {
+  selectedPost.value = post;
+  emit('select', post);
+}
+
+function getLabel(post: Post): string {
+  return formatPost(post);
+}
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/UserProfile.vue b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/UserProfile.vue
new file mode 100644
index 0000000000..208dd5ed5f
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/UserProfile.vue
@@ -0,0 +1,43 @@
+<template>
+  <div class="user-profile">
+    <h1>{{ displayName }}</h1>
+    <p>{{ user?.email }}</p>
+    <button @click="handleSave">Save</button>
+    <ul>
+      <li v-for="post in posts" :key="post.id">{{ formatPost(post) }}</li>
+    </ul>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted } from 'vue';
+import type { User, Post } from './types';
+import { formatUser, formatPost } from './types';
+import { fetchUser, fetchPosts, saveUser } from './api';
+
+const props = defineProps<{
+  userId: number;
+}>();
+
+const user = ref<User | null>(null);
+const posts = ref<Post[]>([]);
+
+const displayName = computed(() => {
+  if (user.value === null) return 'Loading...';
+  return formatUser(user.value);
+});
+
+async function loadData() {
+  user.value = await fetchUser(props.userId);
+  posts.value = await fetchPosts(props.userId);
+}
+
+async function handleSave() {
+  if (user.value === null) return;
+  user.value = await saveUser(user.value);
+}
+
+onMounted(() => {
+  loadData();
+});
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/api.ts b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/api.ts
new file mode 100644
index 0000000000..6489105072
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/api.ts
@@ -0,0 +1,18 @@
+import type { User, Post } from './types';
+
+export async function fetchUser(id: number): Promise<User> {
+  const response = await fetch(`/api/users/${id}`);
+  return response.json() as Promise<User>;
+}
+
+export async function fetchPosts(userId: number): Promise<Post[]> {
+  const response = await fetch(`/api/users/${userId}/posts`);
+  return response.json() as Promise<Post[]>;
+}
+
+export function saveUser(user: User): Promise<User> {
+  return fetch('/api/users', {
+    method: 'POST',
+    body: JSON.stringify(user),
+  }).then((r) => r.json() as Promise<User>);
+}
diff --git a/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/types.ts b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/types.ts
new file mode 100644
index 0000000000..7661c225dd
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-composition-api/src/types.ts
@@ -0,0 +1,19 @@
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+export interface Post {
+  id: number;
+  title: string;
+  authorId: number;
+}
+
+export function formatUser(user: User): string {
+  return `${user.name} <${user.email}>`;
+}
+
+export function formatPost(post: Post): string {
+  return `[${post.id}] ${post.title}`;
+}
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/App.vue b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/App.vue
new file mode 100644
index 0000000000..483e5a79ad
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/App.vue
@@ -0,0 +1,20 @@
+<template>
+  <div id="app">
+    <UserCard :userId="1" @loaded="onUserLoaded" />
+    <PostCard :postId="42" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useUserList } from './composables/useUser';
+import { UserModel } from './models';
+import UserCard from './components/UserCard.vue';
+import PostCard from './components/PostCard.vue';
+
+const { users, addUser } = useUserList();
+
+function onUserLoaded(userId: number) {
+  const u = new UserModel(userId, 'Loaded', 'user');
+  addUser(u);
+}
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/PostCard.vue b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/PostCard.vue
new file mode 100644
index 0000000000..63d82445f6
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/PostCard.vue
@@ -0,0 +1,22 @@
+<template>
+  <div class="post-card">
+    <h3>{{ title }}</h3>
+    <p>{{ summary }}</p>
+    <small>Words: {{ wordCount }}</small>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { usePost } from '../composables/usePost';
+
+const props = defineProps<{ postId: number }>();
+
+const { post, loadPost, getSummary } = usePost();
+
+loadPost(props.postId);
+
+const title = computed(() => post.value?.title ?? '');
+const summary = getSummary();
+const wordCount = computed(() => post.value?.wordCount() ?? 0);
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/UserCard.vue b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/UserCard.vue
new file mode 100644
index 0000000000..3a783113ad
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/components/UserCard.vue
@@ -0,0 +1,23 @@
+<template>
+  <div class="user-card">
+    <h2>{{ displayName }}</h2>
+    <span v-if="isAdmin" class="badge">Admin</span>
+    <button @click="reload">Reload</button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useUser } from '../composables/useUser';
+
+const props = defineProps<{ userId: number }>();
+const emit = defineEmits<{ loaded: [userId: number] }>();
+
+const { user, isAdmin, loadUser, getDisplayName } = useUser(props.userId);
+
+const displayName = getDisplayName();
+
+async function reload() {
+  await loadUser(props.userId);
+  emit('loaded', props.userId);
+}
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/usePost.ts b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/usePost.ts
new file mode 100644
index 0000000000..85b336948b
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/usePost.ts
@@ -0,0 +1,18 @@
+import { ref } from 'vue';
+import { PostModel } from '../models';
+
+export function usePost() {
+  const post = ref<PostModel | null>(null);
+
+  function loadPost(id: number): PostModel {
+    const p = new PostModel(id, 'Hello World', 'Content here', 1);
+    post.value = p;
+    return p;
+  }
+
+  function getSummary(): string {
+    return post.value?.summary() ?? '';
+  }
+
+  return { post, loadPost, getSummary };
+}
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/useUser.ts b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/useUser.ts
new file mode 100644
index 0000000000..fb50ac126a
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/composables/useUser.ts
@@ -0,0 +1,34 @@
+import { ref, computed } from 'vue';
+import type { Ref } from 'vue';
+import { UserModel } from '../models';
+
+export function useUser(initialId: number) {
+  const user = ref<UserModel | null>(null);
+  const loading = ref(false);
+
+  const isAdmin = computed(() => user.value?.isAdmin() ?? false);
+
+  async function loadUser(id: number): Promise<UserModel> {
+    loading.value = true;
+    const u = new UserModel(id, 'Alice', 'admin');
+    user.value = u;
+    loading.value = false;
+    return u;
+  }
+
+  function getDisplayName(): string {
+    return user.value?.displayName() ?? 'Unknown';
+  }
+
+  return { user, loading, isAdmin, loadUser, getDisplayName };
+}
+
+export function useUserList(): { users: Ref<UserModel[]>; addUser: (u: UserModel) => void } {
+  const users = ref<UserModel[]>([]);
+
+  function addUser(u: UserModel) {
+    users.value.push(u);
+  }
+
+  return { users, addUser };
+}
diff --git a/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/models.ts b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/models.ts
new file mode 100644
index 0000000000..d3f3ae17a8
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-cross-file/src/models.ts
@@ -0,0 +1,32 @@
+export class UserModel {
+  constructor(
+    public id: number,
+    public name: string,
+    public role: 'admin' | 'user',
+  ) {}
+
+  isAdmin(): boolean {
+    return this.role === 'admin';
+  }
+
+  displayName(): string {
+    return `${this.name} (${this.role})`;
+  }
+}
+
+export class PostModel {
+  constructor(
+    public id: number,
+    public title: string,
+    public content: string,
+    public authorId: number,
+  ) {}
+
+  summary(): string {
+    return this.title.substring(0, 100);
+  }
+
+  wordCount(): number {
+    return this.content.split(' ').length;
+  }
+}
diff --git a/gitnexus/test/fixtures/vue-scope/vue-options-api/src/App.vue b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/App.vue
new file mode 100644
index 0000000000..449772d021
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/App.vue
@@ -0,0 +1,17 @@
+<template>
+  <div id="app">
+    <Counter :initialValue="0" :step="1" />
+    <TodoList />
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+import Counter from './Counter.vue';
+import TodoList from './TodoList.vue';
+
+export default defineComponent({
+  name: 'App',
+  components: { Counter, TodoList },
+});
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-options-api/src/Counter.vue b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/Counter.vue
new file mode 100644
index 0000000000..edc0184244
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/Counter.vue
@@ -0,0 +1,42 @@
+<template>
+  <div class="counter">
+    <button @click="decrement">-</button>
+    <span>{{ count }}</span>
+    <button @click="increment">+</button>
+    <button @click="reset">Reset</button>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  name: 'Counter',
+  props: {
+    initialValue: {
+      type: Number,
+      default: 0,
+    },
+    step: {
+      type: Number,
+      default: 1,
+    },
+  },
+  data() {
+    return {
+      count: this.initialValue,
+    };
+  },
+  methods: {
+    increment() {
+      this.count += this.step;
+    },
+    decrement() {
+      this.count -= this.step;
+    },
+    reset() {
+      this.count = this.initialValue;
+    },
+  },
+});
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-options-api/src/TodoList.vue b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/TodoList.vue
new file mode 100644
index 0000000000..cca9ce1d86
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/TodoList.vue
@@ -0,0 +1,51 @@
+<template>
+  <div class="todo-list">
+    <input v-model="newTodoText" @keyup.enter="addTodo" />
+    <ul>
+      <li v-for="todo in pendingTodos" :key="todo.id" @click="toggleItem(todo)">
+        {{ todo.text }}
+      </li>
+    </ul>
+    <p>Done: {{ doneCount }}</p>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+import type { Todo } from './utils';
+import { createTodo, toggleTodo, filterDone, filterPending } from './utils';
+
+export default defineComponent({
+  name: 'TodoList',
+  data() {
+    return {
+      newTodoText: '',
+      todos: [] as Todo[],
+    };
+  },
+  computed: {
+    doneCount(): number {
+      return filterDone(this.todos).length;
+    },
+    pendingTodos(): Todo[] {
+      return filterPending(this.todos);
+    },
+  },
+  methods: {
+    addTodo() {
+      if (this.newTodoText.trim() === '') return;
+      this.todos.push(createTodo(this.newTodoText));
+      this.newTodoText = '';
+    },
+    toggleItem(todo: Todo) {
+      const idx = this.todos.findIndex((t) => t.id === todo.id);
+      if (idx !== -1) {
+        this.todos[idx] = toggleTodo(todo);
+      }
+    },
+    clearDone() {
+      this.todos = filterPending(this.todos);
+    },
+  },
+});
+</script>
diff --git a/gitnexus/test/fixtures/vue-scope/vue-options-api/src/utils.ts b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/utils.ts
new file mode 100644
index 0000000000..19b5bcd1a6
--- /dev/null
+++ b/gitnexus/test/fixtures/vue-scope/vue-options-api/src/utils.ts
@@ -0,0 +1,21 @@
+export interface Todo {
+  id: number;
+  text: string;
+  done: boolean;
+}
+
+export function createTodo(text: string): Todo {
+  return { id: Date.now(), text, done: false };
+}
+
+export function toggleTodo(todo: Todo): Todo {
+  return { ...todo, done: !todo.done };
+}
+
+export function filterDone(todos: Todo[]): Todo[] {
+  return todos.filter((t) => t.done);
+}
+
+export function filterPending(todos: Todo[]): Todo[] {
+  return todos.filter((t) => !t.done);
+}
diff --git a/gitnexus/test/integration/resolvers/helpers.ts b/gitnexus/test/integration/resolvers/helpers.ts
index ae07af5012..09aa997eb0 100644
--- a/gitnexus/test/integration/resolvers/helpers.ts
+++ b/gitnexus/test/integration/resolvers/helpers.ts
@@ -160,6 +160,55 @@ const LEGACY_RESOLVER_PARITY_EXPECTED_FAILURES: Readonly<Record<string, Readonly
     // propagation in the legacy DAG.
     'resolves caller.fooService.getUser() to FooService.getUser via constructor-inferred typeBinding',
     'resolves caller.fooService.getUser() through the factory chain to FooService.getUser',
+    // HOC-wrapped variable declarations (typescript-hoc-wrapped.test.ts).
+    // The legacy DAG's `tsExtractFunctionName` only walks `pair` /
+    // `variable_declarator` parents — `arguments` parents fall through with
+    // `funcName = null`, so HOC-wrapped const declarations (forwardRef, memo,
+    // useCallback, useMemo, observer, debounce) are anonymous in legacy and
+    // their inner calls are attributed to the File node or not at all.
+    // The scope-resolver names these via `@declaration.function` matching on
+    // `lexical_declaration > variable_declarator > call_expression > arguments
+    // > arrow_function`. Scope-resolver-only correctness wins; backporting the
+    // HOC-wrapping traversal to the legacy DAG is out of scope.
+    'React.forwardRef: Button → cn and Button → helper (member-expression callee)',
+    'memo (bare identifier): Card → cn and Card → helper',
+    'useCallback: handleClick → doStuff and handleClick → fmt',
+    'useCallback: handleSubmit → doStuff (sibling const, separate caller)',
+    'useMemo: computed → doStuff (returns-a-value variant)',
+    'observer (MobX): Item → helper',
+    'debounce: debouncedSearch → doStuff (utility-HOC form)',
+    'bare statement-level HOC calls do not produce phantom Functions',
+    'handleClick and handleSubmit do not cross-attribute (no first-sibling-wins)',
+    'nested HOCs: helper() call inside the deepest arrow does NOT source from Function:Wrapped',
+    'export default HOC: calls attribute to the file-derived function name',
+    // HOF-callback CALLS edges (typescript-hof-callbacks.test.ts).
+    // The legacy DAG attributed calls inside pair-arrow / executor / .map
+    // callbacks to the outermost module scope instead of the named arrow
+    // function. The scope-resolver uses `pass2AttachDeclarations` to place
+    // the Function def on the inner arrow, correctly attributing inner calls.
+    // Scope-resolver-only correctness wins; backporting the pair-arrow / HOF
+    // attribution fix to the legacy DAG is out of scope.
+    'control: direct (x) => transform(x) emits direct → transform',
+    'Promise.all(map(...)) emits fanOut → transform (call inside .map callback)',
+    'new Promise((resolve) => { ... }) emits wrap → transform (call inside executor)',
+    'useQuery({ queryFn: () => fetchData() }) emits queryFn → fetchData (call inside named pair-arrow)',
+    'useQuery({ queryFn: () => fetchData() }) emits useFeature → useQuery (direct call in body)',
+    'Zustand module-level calls source from the File node (not a sibling Function)',
+    'transform is reachable from at least 3 of {direct, fanOut, wrap}',
+    'multi-action store: addItem → doA (calls inside addItem attribute to addItem, not first sibling)',
+    'multi-action store: removeItem → doB (NOT addItem → doB)',
+    'multi-action store: fetchData → doC (third action also attributes correctly)',
+    'multi-action store: each action attributes calls to itself (no cross-sibling leakage)',
+    // JSX-as-call CALLS edges (typescript-jsx-as-call.test.ts).
+    // The legacy DAG had no `jsx_*` patterns in the TS scope query, so
+    // `<Foo />` / `<Foo>...</Foo>` produced no CALLS edges. The scope-resolver
+    // added `jsx_self_closing_element` and `jsx_opening_element` captures.
+    // Scope-resolver-only correctness wins; backporting JSX capture to the
+    // legacy DAG query is out of scope.
+    'self-closing <Foo /> emits useFoo → Foo',
+    'paired <Bar>...</Bar> emits useBar → Bar (closing tag does NOT double-count)',
+    'nested <Outer><Inner /></Outer> emits both useNested → Outer AND useNested → Inner',
+    'combined HOF + JSX: const Wrapped = () => <Foo /> emits exactly one Wrapped → Foo',
   ]),
   javascript: new Set([
     // Mirrors the TypeScript class-instance and factory-pattern singleton
@@ -334,6 +383,30 @@ const LEGACY_RESOLVER_PARITY_EXPECTED_FAILURES: Readonly<Record<string, Readonly
     // the `self.base()` call unresolved for this fixture.
     'resolves self.base() inside added() to Bar.base (self == Bar), not Foo',
   ]),
+  vue: new Set<string>([
+    // Template-derived edges are emitted via `emitPostResolutionEdges` on the
+    // registry-primary path. The legacy resolver never runs this hook, so
+    // these edges are absent on the REGISTRY_PRIMARY_VUE=0 path.
+    'emits CALLS edge from @click="handleSave" in UserProfile.vue template',
+    'emits CALLS edge from @keyup.enter="addTodo" in TodoList.vue template',
+    'emits ACCESSES edge for :userId="currentUserId" in App.vue template',
+    'emits ACCESSES edge for :posts="allPosts" in App.vue template',
+    // Component event-system edges (BINDS_EVENT_HANDLER / EMITS_EVENT) are
+    // registry-primary-only — the legacy resolver has no equivalent.
+    'emits BINDS_EVENT_HANDLER from onPostSelected to PostList (component event)',
+    'emits BINDS_EVENT_HANDLER from onUserLoaded to UserCard (component event)',
+    'emits EMITS_EVENT from PostList.vue for emit("select")',
+    'emits EMITS_EVENT from UserCard.vue for emit("loaded")',
+    // Legacy DAG over-resolves this via import/global fallback from the
+    // composable return object; registry-primary keeps this unresolved.
+    'does not currently emit CALLS edge to addUser returned from useUserList',
+    // <script setup> implicit-export detection: the scope-based path marks
+    // all top-level <script setup> bindings as exported; the legacy path
+    // relies on per-node isExported flags from the parse worker which may
+    // not propagate correctly through the legacy resolver flow.
+    'marks <script setup> top-level functions as exported',
+    'marks <script setup> top-level functions in PostList as exported',
+  ]),
   cpp: new Set<string>([
     // The legacy DAG path has no scope-aware filtering on the global
     // free-call fallback, so `#include`d headers still leak class
diff --git a/gitnexus/test/integration/resolvers/typescript-hoc-wrapped.test.ts b/gitnexus/test/integration/resolvers/typescript-hoc-wrapped.test.ts
index f5b86ec2df..35f864ad36 100644
--- a/gitnexus/test/integration/resolvers/typescript-hoc-wrapped.test.ts
+++ b/gitnexus/test/integration/resolvers/typescript-hoc-wrapped.test.ts
@@ -36,9 +36,10 @@
  * Each test fixture below isolates one wrapper shape with the call
  * target defined in `helpers.ts` (cross-file resolution).
  */
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, expect, beforeAll } from 'vitest';
 import path from 'path';
 import {
+  createResolverParityIt,
   FIXTURES,
   getRelationships,
   edgeSet,
@@ -48,6 +49,8 @@ import {
   type PipelineResult,
 } from './helpers.js';
 
+const it = createResolverParityIt('typescript');
+
 describe('TypeScript HOC-wrapped variable declarations', () => {
   let result: PipelineResult;
 
diff --git a/gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts b/gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts
index f23df9c111..77f8966766 100644
--- a/gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts
+++ b/gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts
@@ -34,16 +34,19 @@
  * Each test fixture below isolates one HOF-callback shape from the bug
  * report with both caller and callee defined in-fixture.
  */
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, expect, beforeAll } from 'vitest';
 import path from 'path';
 import {
   FIXTURES,
   getRelationships,
   edgeSet,
   runPipelineFromRepo,
+  createResolverParityIt,
   type PipelineResult,
 } from './helpers.js';
 
+const it = createResolverParityIt('typescript');
+
 describe('TypeScript HOF-callback CALLS edges', () => {
   let result: PipelineResult;
 
diff --git a/gitnexus/test/integration/resolvers/typescript-jsx-as-call.test.ts b/gitnexus/test/integration/resolvers/typescript-jsx-as-call.test.ts
index d1fef45596..9f33bcb580 100644
--- a/gitnexus/test/integration/resolvers/typescript-jsx-as-call.test.ts
+++ b/gitnexus/test/integration/resolvers/typescript-jsx-as-call.test.ts
@@ -21,16 +21,19 @@
  *   - HTML-only `<div>`/`<span>`       — html-only.tsx (negative test)
  *   - HOF + JSX `const F = () => <X/>` — hof-jsx.tsx (combined-fix probe)
  */
-import { describe, it, expect, beforeAll } from 'vitest';
+import { describe, expect, beforeAll } from 'vitest';
 import path from 'path';
 import {
   FIXTURES,
   getRelationships,
   edgeSet,
   runPipelineFromRepo,
+  createResolverParityIt,
   type PipelineResult,
 } from './helpers.js';
 
+const it = createResolverParityIt('typescript');
+
 describe('TypeScript JSX-as-call CALLS edges', () => {
   let result: PipelineResult;
 
diff --git a/gitnexus/test/integration/resolvers/vue-scope.test.ts b/gitnexus/test/integration/resolvers/vue-scope.test.ts
new file mode 100644
index 0000000000..acc05af871
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/vue-scope.test.ts
@@ -0,0 +1,482 @@
+/**
+ * Vue SFC: scope-based resolution (RFC #909 Ring 3, issue #940).
+ *
+ * Three fixture repos covering the main Vue SFC patterns:
+ *
+ *   - vue-composition-api — `<script setup lang="ts">` with cross-file
+ *     imports, computed refs, defineProps/defineEmits macros.
+ *   - vue-options-api     — `<script lang="ts">` with defineComponent,
+ *     data()/methods/computed; `this.X()` method calls.
+ *   - vue-cross-file      — composable functions, class models, multi-
+ *     component app with cross-file CALLS chains.
+ *
+ * The `createResolverParityIt` wrapper runs each test under BOTH the
+ * legacy DAG path (REGISTRY_PRIMARY_VUE=0) and the registry-primary
+ * path (default) so the CI scope-parity gate can compare them.
+ */
+
+import { describe, expect, beforeAll } from 'vitest';
+import path from 'path';
+import {
+  getRelationships,
+  getNodesByLabel,
+  getNodesByLabelFull,
+  runPipelineFromRepo,
+  createResolverParityIt,
+  type PipelineResult,
+} from './helpers.js';
+
+const VUE_SCOPE_FIXTURES = path.resolve(__dirname, '..', '..', 'fixtures', 'vue-scope');
+
+const it = createResolverParityIt('vue');
+
+// ─── Composition API (`<script setup lang="ts">`) ───────────────────────────
+
+describe('Vue Composition API (<script setup>)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(
+      path.join(VUE_SCOPE_FIXTURES, 'vue-composition-api'),
+      () => {},
+    );
+  }, 60000);
+
+  // Symbol extraction --------------------------------------------------------
+
+  it('extracts Function nodes from <script setup> components', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('loadData');
+    expect(fns).toContain('handleSave');
+    expect(fns).toContain('selectPost');
+    expect(fns).toContain('getLabel');
+    expect(fns).toContain('onPostSelected');
+  });
+
+  it('extracts Function nodes from .ts utility files', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('formatUser');
+    expect(fns).toContain('formatPost');
+    expect(fns).toContain('fetchUser');
+    expect(fns).toContain('fetchPosts');
+    expect(fns).toContain('saveUser');
+  });
+
+  it('extracts Interface nodes from .ts files', () => {
+    const ifaces = getNodesByLabel(result, 'Interface');
+    expect(ifaces).toContain('User');
+    expect(ifaces).toContain('Post');
+  });
+
+  // Import resolution --------------------------------------------------------
+
+  it('resolves value imports from UserProfile.vue to types.ts', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    // File-level IMPORTS edge: multiple imported symbols collapse to one edge.
+    const vueToTypes = imports.filter(
+      (e) => e.sourceFilePath.endsWith('UserProfile.vue') && e.targetFilePath.endsWith('types.ts'),
+    );
+    expect(vueToTypes.length).toBe(1);
+  });
+
+  it('resolves value imports from UserProfile.vue to api.ts', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    // File-level IMPORTS edge: multiple imported symbols collapse to one edge.
+    const vueToApi = imports.filter(
+      (e) => e.sourceFilePath.endsWith('UserProfile.vue') && e.targetFilePath.endsWith('api.ts'),
+    );
+    expect(vueToApi.length).toBe(1);
+  });
+
+  it('resolves default import from App.vue to UserProfile.vue', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    // import UserProfile from './UserProfile.vue' → 1 default-import edge
+    const vueToVue = imports.filter(
+      (e) => e.sourceFilePath.endsWith('App.vue') && e.targetFilePath.endsWith('UserProfile.vue'),
+    );
+    expect(vueToVue.length).toBe(1);
+  });
+
+  // CALLS edges --------------------------------------------------------------
+
+  it('emits CALLS edge from <script setup> to imported formatUser', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toFormatUser = calls.filter(
+      (e) => e.sourceFilePath.endsWith('UserProfile.vue') && e.target === 'formatUser',
+    );
+    expect(toFormatUser.length).toBe(1);
+  });
+
+  it('emits CALLS edge from <script setup> to imported fetchUser', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toFetchUser = calls.filter(
+      (e) => e.sourceFilePath.endsWith('UserProfile.vue') && e.target === 'fetchUser',
+    );
+    expect(toFetchUser.length).toBe(1);
+  });
+
+  it('emits CALLS edge from <script setup> to imported saveUser', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toSaveUser = calls.filter(
+      (e) => e.sourceFilePath.endsWith('UserProfile.vue') && e.target === 'saveUser',
+    );
+    expect(toSaveUser.length).toBe(1);
+  });
+
+  it('emits CALLS edge from PostList.vue to formatPost', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toFormatPost = calls.filter(
+      (e) => e.sourceFilePath.endsWith('PostList.vue') && e.target === 'formatPost',
+    );
+    expect(toFormatPost.length).toBe(1);
+  });
+
+  // <script setup> top-level export ------------------------------------------
+
+  it('marks <script setup> top-level functions as exported', () => {
+    const allFns = getNodesByLabelFull(result, 'Function');
+    const loadData = allFns.find(
+      (n) => n.properties.name === 'loadData' && n.properties.filePath.endsWith('UserProfile.vue'),
+    );
+    expect(loadData).toBeDefined();
+    expect(loadData!.properties.isExported).toBe(true);
+  });
+
+  it('marks <script setup> top-level functions in PostList as exported', () => {
+    const allFns = getNodesByLabelFull(result, 'Function');
+    const selectPost = allFns.find(
+      (n) => n.properties.name === 'selectPost' && n.properties.filePath.endsWith('PostList.vue'),
+    );
+    expect(selectPost).toBeDefined();
+    expect(selectPost!.properties.isExported).toBe(true);
+  });
+
+  // Template event-handler CALLS --------------------------------------------
+
+  it('emits CALLS edge from @click="handleSave" in UserProfile.vue template', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const templateToSave = calls.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('UserProfile.vue') &&
+        e.target === 'handleSave' &&
+        e.rel.reason === 'vue-template-callback',
+    );
+    expect(templateToSave.length).toBe(1);
+  });
+
+  it('emits BINDS_EVENT_HANDLER from onPostSelected to PostList (component event)', () => {
+    const bindings = getRelationships(result, 'BINDS_EVENT_HANDLER');
+    const toPostList = bindings.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('App.vue') &&
+        e.source === 'onPostSelected' &&
+        e.targetFilePath.endsWith('PostList.vue') &&
+        e.rel.reason === 'vue-event: @select',
+    );
+    expect(toPostList.length).toBe(1);
+  });
+
+  it('emits EMITS_EVENT from PostList.vue for emit("select")', () => {
+    const emits = getRelationships(result, 'EMITS_EVENT');
+    const postListEmit = emits.filter(
+      (e) => e.sourceFilePath.endsWith('PostList.vue') && e.rel.reason === 'vue-emit: select',
+    );
+    expect(postListEmit.length).toBe(1);
+  });
+
+  // Template attribute-binding ACCESSES -------------------------------------
+
+  it('emits ACCESSES edge for :userId="currentUserId" in App.vue template', () => {
+    const accesses = getRelationships(result, 'ACCESSES');
+    const attrAccess = accesses.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('App.vue') &&
+        e.target === 'currentUserId' &&
+        e.rel.reason === 'vue-template-attribute',
+    );
+    expect(attrAccess.length).toBe(1);
+  });
+
+  it('emits ACCESSES edge for :posts="allPosts" in App.vue template', () => {
+    const accesses = getRelationships(result, 'ACCESSES');
+    const attrAccess = accesses.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('App.vue') &&
+        e.target === 'allPosts' &&
+        e.rel.reason === 'vue-template-attribute',
+    );
+    expect(attrAccess.length).toBe(1);
+  });
+
+  // File nodes ---------------------------------------------------------------
+
+  it('creates File nodes for .vue files', () => {
+    const files = getNodesByLabel(result, 'File');
+    expect(files.some((f) => f.endsWith('UserProfile.vue'))).toBe(true);
+    expect(files.some((f) => f.endsWith('PostList.vue'))).toBe(true);
+    expect(files.some((f) => f.endsWith('App.vue'))).toBe(true);
+  });
+});
+
+// ─── Options API (`<script lang="ts">` + defineComponent) ──────────────────
+
+describe('Vue Options API (defineComponent)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(VUE_SCOPE_FIXTURES, 'vue-options-api'), () => {});
+  }, 60000);
+
+  // Symbol extraction --------------------------------------------------------
+
+  it('extracts Method nodes from methods block', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('addTodo');
+    expect(methods).toContain('toggleItem');
+    expect(methods).toContain('clearDone');
+    expect(methods).toContain('increment');
+    expect(methods).toContain('decrement');
+    expect(methods).toContain('reset');
+  });
+
+  it('extracts utility functions from .ts file', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('createTodo');
+    expect(fns).toContain('toggleTodo');
+    expect(fns).toContain('filterDone');
+    expect(fns).toContain('filterPending');
+  });
+
+  it('extracts Interface node for Todo', () => {
+    const ifaces = getNodesByLabel(result, 'Interface');
+    expect(ifaces).toContain('Todo');
+  });
+
+  // Import resolution --------------------------------------------------------
+
+  it('resolves value imports from TodoList.vue to utils.ts', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    // File-level IMPORTS edge: multiple imported symbols collapse to one edge.
+    const vueToUtils = imports.filter(
+      (e) => e.sourceFilePath.endsWith('TodoList.vue') && e.targetFilePath.endsWith('utils.ts'),
+    );
+    expect(vueToUtils.length).toBe(1);
+  });
+
+  // CALLS edges --------------------------------------------------------------
+
+  it('emits CALLS edge from addTodo in TodoList.vue to createTodo', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toCreateTodo = calls.filter(
+      (e) => e.sourceFilePath.endsWith('TodoList.vue') && e.target === 'createTodo',
+    );
+    expect(toCreateTodo.length).toBe(1);
+  });
+
+  it('emits CALLS edge from TodoList.vue to filterDone (computed doneCount)', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toFilterDone = calls.filter(
+      (e) => e.sourceFilePath.endsWith('TodoList.vue') && e.target === 'filterDone',
+    );
+    expect(toFilterDone.length).toBe(1);
+  });
+
+  it('emits CALLS edge from TodoList.vue to filterPending (computed pendingTodos)', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toFilterPending = calls.filter(
+      (e) => e.sourceFilePath.endsWith('TodoList.vue') && e.target === 'filterPending',
+    );
+    // Two call sites in the same file: `pendingTodos` and `clearDone`.
+    expect(toFilterPending.length).toBe(2);
+  });
+
+  it('emits CALLS edge from clearDone to filterPending', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toClearDone = calls.filter(
+      (e) => e.source === 'clearDone' && e.target === 'filterPending',
+    );
+    expect(toClearDone.length).toBe(1);
+  });
+
+  // Non-setup scripts should not be implicitly exported ----------------------
+
+  it('does not mark non-setup <script> methods as implicitly exported', () => {
+    const allFns = getNodesByLabelFull(result, 'Function');
+    const addTodo = allFns.find(
+      (n) => n.properties.name === 'addTodo' && n.properties.filePath.endsWith('TodoList.vue'),
+    );
+    if (addTodo !== undefined) {
+      expect(addTodo.properties.isExported).toBe(false);
+    }
+  });
+
+  // Template event-handler CALLS --------------------------------------------
+
+  it('emits CALLS edge from @keyup.enter="addTodo" in TodoList.vue template', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const templateToAdd = calls.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('TodoList.vue') &&
+        e.target === 'addTodo' &&
+        e.rel.reason === 'vue-template-callback',
+    );
+    expect(templateToAdd.length).toBe(1);
+  });
+
+  // File nodes ---------------------------------------------------------------
+
+  it('creates File nodes for Options API .vue files', () => {
+    const files = getNodesByLabel(result, 'File');
+    expect(files.some((f) => f.endsWith('TodoList.vue'))).toBe(true);
+    expect(files.some((f) => f.endsWith('Counter.vue'))).toBe(true);
+  });
+});
+
+// ─── Cross-file: composables + class models ─────────────────────────────────
+
+describe('Vue cross-file composable and class resolution', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(VUE_SCOPE_FIXTURES, 'vue-cross-file'), () => {});
+  }, 60000);
+
+  // Symbol extraction --------------------------------------------------------
+
+  it('extracts Class nodes from .ts model file', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('UserModel');
+    expect(classes).toContain('PostModel');
+  });
+
+  it('extracts Method nodes from UserModel', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('isAdmin');
+    expect(methods).toContain('displayName');
+  });
+
+  it('extracts Method nodes from PostModel', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('summary');
+    expect(methods).toContain('wordCount');
+  });
+
+  it('extracts composable functions from useUser.ts', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('useUser');
+    expect(fns).toContain('useUserList');
+  });
+
+  it('extracts composable function usePost from usePost.ts', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('usePost');
+  });
+
+  // Import resolution --------------------------------------------------------
+
+  it('resolves import from useUser.ts to models.ts (1 named export: UserModel)', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const compToModel = imports.filter(
+      (e) => e.sourceFilePath.endsWith('useUser.ts') && e.targetFilePath.endsWith('models.ts'),
+    );
+    expect(compToModel.length).toBe(1);
+  });
+
+  it('resolves import from UserCard.vue to useUser.ts (1 named export: useUser)', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const vueToComp = imports.filter(
+      (e) => e.sourceFilePath.endsWith('UserCard.vue') && e.targetFilePath.endsWith('useUser.ts'),
+    );
+    expect(vueToComp.length).toBe(1);
+  });
+
+  it('resolves import from App.vue to useUser.ts (1 named export: useUserList)', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const appToComp = imports.filter(
+      (e) => e.sourceFilePath.endsWith('App.vue') && e.targetFilePath.endsWith('useUser.ts'),
+    );
+    expect(appToComp.length).toBe(1);
+  });
+
+  it('resolves import from App.vue to models.ts (1 named export: UserModel)', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const appToModel = imports.filter(
+      (e) => e.sourceFilePath.endsWith('App.vue') && e.targetFilePath.endsWith('models.ts'),
+    );
+    expect(appToModel.length).toBe(1);
+  });
+
+  // CALLS edges --------------------------------------------------------------
+
+  it('emits CALLS edge from UserCard.vue to useUser composable', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toUseUser = calls.filter(
+      (e) => e.sourceFilePath.endsWith('UserCard.vue') && e.target === 'useUser',
+    );
+    expect(toUseUser.length).toBe(1);
+  });
+
+  it('emits CALLS edge from PostCard.vue to usePost composable', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toUsePost = calls.filter(
+      (e) => e.sourceFilePath.endsWith('PostCard.vue') && e.target === 'usePost',
+    );
+    expect(toUsePost.length).toBe(1);
+  });
+
+  it('emits CALLS edge from App.vue to useUserList composable', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toUseUserList = calls.filter(
+      (e) => e.sourceFilePath.endsWith('App.vue') && e.target === 'useUserList',
+    );
+    expect(toUseUserList.length).toBe(1);
+  });
+
+  it('emits CALLS edge from useUser.ts to UserModel constructor', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toUserModel = calls.filter(
+      (e) => e.sourceFilePath.endsWith('useUser.ts') && e.target === 'UserModel',
+    );
+    expect(toUserModel.length).toBe(1);
+  });
+
+  it('does not currently emit CALLS edge to addUser returned from useUserList', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const toAddUser = calls.filter(
+      (e) => e.sourceFilePath.endsWith('App.vue') && e.target === 'addUser',
+    );
+    expect(toAddUser.length).toBe(0);
+  });
+
+  // Template event-handler CALLS --------------------------------------------
+
+  it('emits BINDS_EVENT_HANDLER from onUserLoaded to UserCard (component event)', () => {
+    const bindings = getRelationships(result, 'BINDS_EVENT_HANDLER');
+    const toUserCard = bindings.filter(
+      (e) =>
+        e.sourceFilePath.endsWith('App.vue') &&
+        e.source === 'onUserLoaded' &&
+        e.targetFilePath.endsWith('UserCard.vue') &&
+        e.rel.reason === 'vue-event: @loaded',
+    );
+    expect(toUserCard.length).toBe(1);
+  });
+
+  it('emits EMITS_EVENT from UserCard.vue for emit("loaded")', () => {
+    const emits = getRelationships(result, 'EMITS_EVENT');
+    const userCardEmit = emits.filter(
+      (e) => e.sourceFilePath.endsWith('UserCard.vue') && e.rel.reason === 'vue-emit: loaded',
+    );
+    expect(userCardEmit.length).toBe(1);
+  });
+
+  // File nodes ---------------------------------------------------------------
+
+  it('creates File nodes for all .vue and .ts files', () => {
+    const files = getNodesByLabel(result, 'File');
+    expect(files.some((f) => f.endsWith('UserCard.vue'))).toBe(true);
+    expect(files.some((f) => f.endsWith('PostCard.vue'))).toBe(true);
+    expect(files.some((f) => f.endsWith('useUser.ts'))).toBe(true);
+    expect(files.some((f) => f.endsWith('models.ts'))).toBe(true);
+  });
+});
diff --git a/gitnexus/test/integration/vue-pipeline-benchmark.test.ts b/gitnexus/test/integration/vue-pipeline-benchmark.test.ts
new file mode 100644
index 0000000000..a39776fdd8
--- /dev/null
+++ b/gitnexus/test/integration/vue-pipeline-benchmark.test.ts
@@ -0,0 +1,199 @@
+/**
+ * Vue SFC ingestion pipeline benchmark.
+ *
+ * Generates synthetic Vue codebases at increasing scales and measures
+ * wall-clock time and peak heap through the full pipeline — scanning,
+ * SFC script extraction, scope-based resolution, template-edge emission,
+ * and graph build.
+ *
+ * Run: GITNEXUS_BENCH=1 npx vitest run test/integration/vue-pipeline-benchmark.test.ts
+ *
+ * Each synthetic repo contains:
+ *   - A shared `utils.ts` exporting one utility function per component
+ *   - N `.vue` SFC files, each with a `<script setup>` importing from
+ *     `utils.ts` and one event-handler binding in the template
+ *   - An `App.vue` that imports and renders all components via props/events
+ *
+ * Per-component work is intentionally constant as `fileCount` grows.
+ * The node-ratio assertion below guards against accidental O(n²) patterns
+ * (e.g. every component importing from every other component).
+ */
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { runPipelineFromRepo } from '../../src/core/ingestion/pipeline.js';
+
+const BENCH_ENABLED = process.env.GITNEXUS_BENCH === '1';
+
+interface BenchResult {
+  fileCount: number;
+  componentCount: number;
+  elapsedMs: number;
+  peakHeapMB: number;
+  nodeCount: number;
+  edgeCount: number;
+}
+
+function generateVueFixture(componentCount: number): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `vue-bench-${componentCount}-`));
+  const srcDir = path.join(dir, 'src');
+  fs.mkdirSync(srcDir, { recursive: true });
+
+  // Shared utils.ts — one exported function per component
+  const utilExports = Array.from(
+    { length: componentCount },
+    (_, i) => `export function util${i + 1}(x: string): string { return x + '${i + 1}'; }`,
+  ).join('\n');
+  fs.writeFileSync(path.join(srcDir, 'utils.ts'), utilExports + '\n');
+
+  // Generate N .vue components
+  for (let i = 1; i <= componentCount; i++) {
+    const name = `Comp${i}`;
+    const content = [
+      `<template>`,
+      `  <div class="${name.toLowerCase()}">`,
+      `    <p>{{ label }}</p>`,
+      `    <button @click="handleClick">Action ${i}</button>`,
+      `  </div>`,
+      `</template>`,
+      ``,
+      `<script setup lang="ts">`,
+      `import { ref } from 'vue';`,
+      `import { util${i} } from './utils';`,
+      ``,
+      `const props = defineProps<{ value: string }>();`,
+      `const label = ref(util${i}(props.value));`,
+      ``,
+      `function handleClick() {`,
+      `  label.value = util${i}(label.value);`,
+      `}`,
+      `</script>`,
+    ].join('\n');
+    fs.writeFileSync(path.join(srcDir, `${name}.vue`), content);
+  }
+
+  // App.vue — imports and renders all components
+  const imports = Array.from(
+    { length: componentCount },
+    (_, i) => `import Comp${i + 1} from './Comp${i + 1}.vue';`,
+  ).join('\n');
+  const template = Array.from(
+    { length: componentCount },
+    (_, i) => `    <Comp${i + 1} :value="items[${i}]" @update="onUpdate" />`,
+  ).join('\n');
+  const appContent = [
+    `<template>`,
+    `  <div id="app">`,
+    template,
+    `  </div>`,
+    `</template>`,
+    ``,
+    `<script setup lang="ts">`,
+    `import { ref } from 'vue';`,
+    imports,
+    ``,
+    `const items = ref(Array.from({ length: ${componentCount} }, (_, i) => String(i)));`,
+    ``,
+    `function onUpdate(val: string) {`,
+    `  console.log(val);`,
+    `}`,
+    `</script>`,
+  ].join('\n');
+  fs.writeFileSync(path.join(srcDir, 'App.vue'), appContent);
+
+  return dir;
+}
+
+async function runBenchmark(componentCount: number, budgetMs: number): Promise<BenchResult> {
+  const dir = generateVueFixture(componentCount);
+
+  let peakHeapMB = 0;
+  const heapSampler = setInterval(() => {
+    const heap = process.memoryUsage().heapUsed / 1024 / 1024;
+    if (heap > peakHeapMB) peakHeapMB = heap;
+  }, 50);
+
+  try {
+    const start = Date.now();
+    const result = await Promise.race([
+      runPipelineFromRepo(dir, () => {}, { skipGraphPhases: true }),
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () =>
+            reject(new Error(`Pipeline exceeded ${budgetMs}ms at ${componentCount} components`)),
+          budgetMs,
+        ),
+      ),
+    ]);
+    const elapsedMs = Date.now() - start;
+
+    return {
+      fileCount: componentCount + 2, // N components + utils.ts + App.vue
+      componentCount,
+      elapsedMs,
+      peakHeapMB: Math.round(peakHeapMB),
+      nodeCount: result.graph.nodeCount,
+      edgeCount: result.graph.relationshipCount,
+    };
+  } finally {
+    clearInterval(heapSampler);
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function printResults(results: BenchResult[]) {
+  console.log('\nVue SFC Pipeline Benchmark');
+  console.log('┌────────────┬──────────┬───────────┬──────────┬───────┬───────┐');
+  console.log('│ Components │ Files    │ Time (ms) │ Heap MB  │ Nodes │ Edges │');
+  console.log('├────────────┼──────────┼───────────┼──────────┼───────┼───────┤');
+  for (const r of results) {
+    console.log(
+      `│ ${String(r.componentCount).padStart(10)} │ ${String(r.fileCount).padStart(8)} │ ${String(r.elapsedMs).padStart(9)} │ ${String(r.peakHeapMB).padStart(8)} │ ${String(r.nodeCount).padStart(5)} │ ${String(r.edgeCount).padStart(5)} │`,
+    );
+  }
+  console.log('└────────────┴──────────┴───────────┴──────────┴───────┴───────┘');
+
+  if (results.length >= 2) {
+    console.log('\nScaling ratios (time_ratio / component_ratio):');
+    for (let i = 1; i < results.length; i++) {
+      const compRatio = results[i].componentCount / results[i - 1].componentCount;
+      const timeRatio = results[i].elapsedMs / results[i - 1].elapsedMs;
+      const scaling = timeRatio / compRatio;
+      console.log(
+        `  ${results[i - 1].componentCount} → ${results[i].componentCount}: ${scaling.toFixed(2)}x (${scaling < 1.5 ? 'linear' : scaling < 3 ? 'superlinear' : 'WARNING: quadratic'})`,
+      );
+    }
+  }
+}
+
+describe.skipIf(!BENCH_ENABLED)('Vue pipeline benchmark', () => {
+  it('scales with component count', async () => {
+    const scales = [10, 25, 50, 100];
+    const results: BenchResult[] = [];
+
+    for (const componentCount of scales) {
+      const result = await runBenchmark(componentCount, 120_000);
+      results.push(result);
+      console.log(
+        `  ${componentCount} components: ${result.elapsedMs}ms, ${result.peakHeapMB}MB heap, ${result.nodeCount} nodes, ${result.edgeCount} edges`,
+      );
+    }
+
+    printResults(results);
+
+    for (let i = 1; i < results.length; i++) {
+      const compRatio = results[i].componentCount / results[i - 1].componentCount;
+      const timeRatio = results[i].elapsedMs / results[i - 1].elapsedMs;
+      // Wall-clock is noisy; allow a generous upper bound.
+      expect(timeRatio / compRatio).toBeLessThan(4);
+
+      // Node count grows linearly with component count (each component
+      // contributes a constant number of nodes: File + Function nodes +
+      // scope nodes). A large ratio here indicates accidental O(n²) growth
+      // (e.g. every component importing from every other component).
+      const nodeRatio = results[i].nodeCount / results[i - 1].nodeCount;
+      expect(nodeRatio / compRatio).toBeLessThan(1.5);
+    }
+  }, 600_000);
+});
diff --git a/gitnexus/test/unit/registry-primary-flag.test.ts b/gitnexus/test/unit/registry-primary-flag.test.ts
deleted file mode 100644
index 67d692baf2..0000000000
--- a/gitnexus/test/unit/registry-primary-flag.test.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-/**
- * Unit tests for `registry-primary-flag` (RFC #909 Ring 2 PKG #924).
- *
- * Flag is `REGISTRY_PRIMARY_<UPPER(lang)>`. Each test manipulates
- * `process.env` directly and restores it in `afterEach` — there is no
- * per-process cache to invalidate, so isolation is lexical.
- */
-
-import { describe, it, expect, afterEach, beforeEach } from 'vitest';
-import { SupportedLanguages } from 'gitnexus-shared';
-import {
-  envVarNameFor,
-  isRegistryPrimary,
-  primaryLanguages,
-  MIGRATED_LANGUAGES,
-} from '../../src/core/ingestion/registry-primary-flag.js';
-
-// ─── Test isolation ─────────────────────────────────────────────────────────
-//
-// Scrub every `REGISTRY_PRIMARY_*` env var before + after each test so
-// parallel vitest runs on the same process don't bleed state.
-
-function clearAllRegistryPrimaryVars(): void {
-  for (const key of Object.keys(process.env)) {
-    if (key.startsWith('REGISTRY_PRIMARY_')) delete process.env[key];
-  }
-}
-
-beforeEach(clearAllRegistryPrimaryVars);
-afterEach(clearAllRegistryPrimaryVars);
-
-// ─── envVarNameFor ─────────────────────────────────────────────────────────
-
-describe('envVarNameFor', () => {
-  it('produces upper-cased env-var names from the enum value', () => {
-    expect(envVarNameFor(SupportedLanguages.Python)).toBe('REGISTRY_PRIMARY_PYTHON');
-    expect(envVarNameFor(SupportedLanguages.TypeScript)).toBe('REGISTRY_PRIMARY_TYPESCRIPT');
-    expect(envVarNameFor(SupportedLanguages.JavaScript)).toBe('REGISTRY_PRIMARY_JAVASCRIPT');
-  });
-
-  it('uses the enum VALUE, not the key, for languages whose key differs from the value', () => {
-    // Key 'CPlusPlus' → value 'cpp' → env var 'REGISTRY_PRIMARY_CPP'.
-    // Users see the language by its canonical name, not its TS symbol.
-    expect(envVarNameFor(SupportedLanguages.CPlusPlus)).toBe('REGISTRY_PRIMARY_CPP');
-    expect(envVarNameFor(SupportedLanguages.CSharp)).toBe('REGISTRY_PRIMARY_CSHARP');
-  });
-
-  it('covers every member of SupportedLanguages', () => {
-    // Build env-var names for every language and assert no duplicates —
-    // catches a future enum-value collision or accidental renaming.
-    const names = new Set<string>();
-    for (const lang of Object.values(SupportedLanguages)) {
-      names.add(envVarNameFor(lang));
-    }
-    expect(names.size).toBe(Object.values(SupportedLanguages).length);
-  });
-});
-
-// ─── isRegistryPrimary ─────────────────────────────────────────────────────
-
-describe('isRegistryPrimary', () => {
-  it('returns MIGRATED_LANGUAGES membership by default (no env var set)', () => {
-    // Ring 3: languages in MIGRATED_LANGUAGES are registry-primary by
-    // default — operators don't need to set an env var for the rolled-out
-    // migration to take effect. Unmigrated languages default to false.
-    for (const lang of Object.values(SupportedLanguages)) {
-      expect(isRegistryPrimary(lang)).toBe(MIGRATED_LANGUAGES.has(lang));
-    }
-  });
-
-  it("returns true when the env var is 'true' (lowercase)", () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = 'true';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-  });
-
-  it("returns true when the env var is '1'", () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = '1';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-  });
-
-  it("returns true when the env var is 'yes'", () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = 'yes';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-  });
-
-  it('accepts mixed-case and whitespace-padded truthy values', () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = '  TRUE  ';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-    process.env['REGISTRY_PRIMARY_PYTHON'] = 'Yes';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-  });
-
-  it("returns false for falsy-looking values ('false', '0', empty, 'off')", () => {
-    for (const value of ['false', '0', '', 'off', 'no', 'disabled']) {
-      process.env['REGISTRY_PRIMARY_PYTHON'] = value;
-      expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(false);
-    }
-  });
-
-  it('returns false for unrecognized tokens (fail-safe on typos)', () => {
-    // User meant to type 'true' but fat-fingered — conservative: treat as off.
-    for (const value of ['ture', 'tru', 'yeah', 'enable', 'y']) {
-      process.env['REGISTRY_PRIMARY_PYTHON'] = value;
-      expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(false);
-    }
-  });
-
-  it('isolates flags per-language (one on does not affect others)', () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = 'true';
-    expect(isRegistryPrimary(SupportedLanguages.Python)).toBe(true);
-    // Vue is not in MIGRATED_LANGUAGES — default false stays
-    // false regardless of Python's flag.
-    expect(isRegistryPrimary(SupportedLanguages.Vue)).toBe(false);
-  });
-
-  it('respects a mid-process env-var mutation (no stale cache)', () => {
-    // Use Vue — not in MIGRATED_LANGUAGES — so the unset default is
-    // deterministically `false`, independent of which languages have
-    // been flipped to registry-primary.
-    expect(isRegistryPrimary(SupportedLanguages.Vue)).toBe(false);
-    process.env['REGISTRY_PRIMARY_VUE'] = 'true';
-    expect(isRegistryPrimary(SupportedLanguages.Vue)).toBe(true);
-    delete process.env['REGISTRY_PRIMARY_VUE'];
-    expect(isRegistryPrimary(SupportedLanguages.Vue)).toBe(false);
-  });
-
-  it('handles the CPlusPlus → REGISTRY_PRIMARY_CPP mapping correctly', () => {
-    process.env['REGISTRY_PRIMARY_CPP'] = 'true';
-    expect(isRegistryPrimary(SupportedLanguages.CPlusPlus)).toBe(true);
-    // Negative: the TS-key-style name is NOT read. CPlusPlus is now in
-    // MIGRATED_LANGUAGES, so we must explicitly opt it out via the
-    // canonical env var to verify the wrong-name var has no effect.
-    process.env['REGISTRY_PRIMARY_CPP'] = 'false';
-    process.env['REGISTRY_PRIMARY_CPLUSPLUS'] = 'true';
-    expect(isRegistryPrimary(SupportedLanguages.CPlusPlus)).toBe(false);
-  });
-});
-
-// ─── primaryLanguages ──────────────────────────────────────────────────────
-
-describe('primaryLanguages', () => {
-  it('returns MIGRATED_LANGUAGES when no flags are set', () => {
-    // Default-on for migrated languages (Ring 3); unmigrated stay off.
-    const enabled = primaryLanguages();
-    expect(enabled.size).toBe(MIGRATED_LANGUAGES.size);
-    for (const lang of MIGRATED_LANGUAGES) {
-      expect(enabled.has(lang)).toBe(true);
-    }
-  });
-
-  it('returns exactly the flipped languages (env opts in unmigrated, opts out migrated)', () => {
-    // Migrated languages are default-on; each must be opted out here when
-    // testing explicit env overrides. Ruby (unmigrated) opts in.
-    // Opt out every member of MIGRATED_LANGUAGES dynamically so this test
-    // does not have to be updated each time a new language ships its
-    // Ring 3 migration (C++ and PHP joined the set in their respective
-    // Ring 3 migrations; future Ring 3 additions land here without test churn).
-    for (const lang of MIGRATED_LANGUAGES) {
-      process.env[envVarNameFor(lang)] = 'false';
-    }
-    process.env['REGISTRY_PRIMARY_RUBY'] = '1';
-    const enabled = primaryLanguages();
-    expect(enabled.has(SupportedLanguages.Python)).toBe(false);
-    expect(enabled.has(SupportedLanguages.CSharp)).toBe(false);
-    expect(enabled.has(SupportedLanguages.Go)).toBe(false);
-    expect(enabled.has(SupportedLanguages.CPlusPlus)).toBe(false);
-    expect(enabled.has(SupportedLanguages.PHP)).toBe(false);
-    expect(enabled.has(SupportedLanguages.Ruby)).toBe(true);
-    // Only Ruby is on: migrated defaults overridden off, Ruby explicitly on.
-    expect(enabled.size).toBe(1);
-  });
-
-  it('returns a plain Set (not a frozen proxy) — consistent shape', () => {
-    process.env['REGISTRY_PRIMARY_PYTHON'] = 'true';
-    const enabled = primaryLanguages();
-    expect(enabled).toBeInstanceOf(Set);
-  });
-});
diff --git a/gitnexus/test/unit/vue-sfc-extractor.test.ts b/gitnexus/test/unit/vue-sfc-extractor.test.ts
index d26f2b9164..62ff990e18 100644
--- a/gitnexus/test/unit/vue-sfc-extractor.test.ts
+++ b/gitnexus/test/unit/vue-sfc-extractor.test.ts
@@ -2,6 +2,9 @@ import { describe, it, expect } from 'vitest';
 import {
   extractVueScript,
   extractTemplateComponents,
+  extractScriptEmitCalls,
+  extractComponentEventBindings,
+  extractNativeElementEventHandlers,
 } from '../../src/core/ingestion/vue-sfc-extractor.js';
 
 describe('extractVueScript', () => {
@@ -185,6 +188,140 @@ const x = 1;
     const components = extractTemplateComponents(vue);
     expect(components).toEqual(['MyComponent']);
   });
+
+  it('treats kebab-case component tags as component candidates', () => {
+    const vue = `<template>
+  <div>
+    <post-list />
+    <user-card />
+  </div>
+</template>`;
+    const components = extractTemplateComponents(vue);
+    expect(components).toContain('PostList');
+    expect(components).toContain('UserCard');
+  });
+});
+
+describe('extractScriptEmitCalls', () => {
+  it('extracts bare emit() event names', () => {
+    const vue = `<script setup lang="ts">
+const emit = defineEmits(['select']);
+emit('select', { id: 1 });
+</script>`;
+    expect(extractScriptEmitCalls(vue).map((c) => c.eventName)).toEqual(['select']);
+  });
+
+  it('ignores property emits and commented/string emit text', () => {
+    const vue = `<script setup lang="ts">
+const socket = createSocket();
+socket.emit('message');
+// emit('commented')
+const text = "emit('inside-string')";
+emit('actual');
+</script>`;
+    expect(extractScriptEmitCalls(vue).map((c) => c.eventName)).toEqual(['actual']);
+  });
+});
+
+describe('extractComponentEventBindings', () => {
+  it('captures kebab-case component event bindings', () => {
+    const vue = `<template>
+  <post-list @select="onPostSelected" />
+</template>`;
+    expect(extractComponentEventBindings(vue)).toEqual([
+      { componentName: 'PostList', eventName: 'select', handlerName: 'onPostSelected' },
+    ]);
+  });
+
+  it('captures hyphenated event names (@user-loaded)', () => {
+    const vue = `<template>
+  <UserCard @user-loaded="onUserLoaded" />
+</template>`;
+    const bindings = extractComponentEventBindings(vue);
+    expect(bindings).toContainEqual({
+      componentName: 'UserCard',
+      eventName: 'user-loaded',
+      handlerName: 'onUserLoaded',
+    });
+  });
+
+  it('captures update:model-value style event names', () => {
+    const vue = `<template>
+  <MyInput @update:model-value="onChange" />
+</template>`;
+    const bindings = extractComponentEventBindings(vue);
+    expect(bindings).toContainEqual({
+      componentName: 'MyInput',
+      eventName: 'update:model-value',
+      handlerName: 'onChange',
+    });
+  });
+});
+
+describe('extractNativeElementEventHandlers', () => {
+  it('captures handlers from native elements', () => {
+    const vue = `<template>
+  <button @click="handleSave" />
+  <form @submit.prevent="onSubmit" />
+</template>`;
+    const handlers = extractNativeElementEventHandlers(vue);
+    expect(handlers).toContain('handleSave');
+    expect(handlers).toContain('onSubmit');
+  });
+
+  it('does not emit handlers for kebab-case component tags', () => {
+    // <post-list> is a Vue component, not a native element.
+    // The NATIVE_TAG_RE negative lookahead must prevent matching `post` as a native tag.
+    const vue = `<template>
+  <post-list @select="onSelect" />
+  <button @click="handleClick" />
+</template>`;
+    const handlers = extractNativeElementEventHandlers(vue);
+    expect(handlers).not.toContain('onSelect');
+    expect(handlers).toContain('handleClick');
+  });
+});
+
+describe('extractScriptEmitCalls — Options API this.$emit', () => {
+  it('captures this.$emit() in Options API components', () => {
+    const vue = `<script lang="ts">
+export default {
+  methods: {
+    save() {
+      this.$emit('save');
+      this.$emit('update:modelValue', this.value);
+    },
+  },
+};
+</script>`;
+    const events = extractScriptEmitCalls(vue).map((c) => c.eventName);
+    expect(events).toContain('save');
+    expect(events).toContain('update:modelValue');
+  });
+
+  it('does NOT capture socket.emit() or eventBus.emit() as component events', () => {
+    const vue = `<script setup lang="ts">
+const socket = getSocket();
+socket.emit('message');
+eventBus.emit('data');
+emit('actual');
+</script>`;
+    const events = extractScriptEmitCalls(vue).map((c) => c.eventName);
+    expect(events).toEqual(['actual']);
+    expect(events).not.toContain('message');
+    expect(events).not.toContain('data');
+  });
+
+  it('captures update:modelValue style event names with colon', () => {
+    const vue = `<script setup lang="ts">
+const emit = defineEmits(['update:modelValue', 'user-loaded']);
+emit('update:modelValue', newVal);
+emit('user-loaded');
+</script>`;
+    const events = extractScriptEmitCalls(vue).map((c) => c.eventName);
+    expect(events).toContain('update:modelValue');
+    expect(events).toContain('user-loaded');
+  });
 });
 
 // ---------------------------------------------------------------------------