fix(scope): address Codex adversarial review findings on PR #1050

Four findings from the Codex adversarial review broke registry-primary
TypeScript resolution for common patterns. All four now have unit and
integration regression coverage that pass under both
`REGISTRY_PRIMARY_TYPESCRIPT=0` (legacy DAG) and the default
registry-primary path.

[high] tsconfig path aliases dropped:
Threaded `tsconfigPaths` through ScopeResolver via a new opaque
`resolutionConfig` parameter and a `loadResolutionConfig(repoPath)`
hook. The orchestrator (`scopeResolutionPhase` + `runScopeResolution`)
loads it once per workspace pass and forwards into every
`resolveImportTarget` call. TypeScript resolver now resolves
`@/services/user` style imports through the standard resolver's alias
branch.

[high] TSX parsed with the wrong grammar:
`emitTsScopeCaptures` now picks the parser/query by `filePath`
(`.tsx` -> TSX grammar) and validates cached trees against the
expected grammar via the new exported `tsCachedTreeMatchesGrammar`
helper. Stale TS-grammar trees for `.tsx` files no longer leak through
the scope query.

[medium] Literal dynamic imports never linked:
Added `kind: 'dynamic-resolved'` to `ParsedImport` and `ImportEdge`.
The decomposer emits a synthetic `@import.literal` capture for
string-literal dynamic imports; the interpreter maps that to
`dynamic-resolved`; finalize pre-finalizes it as a file-level terminal
(same shape as `side-effect`). `import('./feature')` now produces a
real IMPORTS edge under the registry-primary path. Legacy DAG keeps
its existing behavior — the new integration assertion is gated behind
the flag.

[medium] Namespace re-exports invisible from barrels:
The decomposer now emits TWO captures for `export * as ns from './m'`
— the existing `reexport-namespace` import draft AND a synthetic
`@declaration.namespace` capture (via `buildNamespaceDeclarationMatch`).
The latter creates a Namespace `SymbolDefinition` in the barrel's
`localDefs`, so downstream `import { ns } from './barrel'` resolves
through `findExportByName`.

Regression fixtures under `gitnexus/test/fixtures/lang-resolution/`:
- typescript-tsconfig-aliases (`@/` alias)
- typescript-tsx-jsx (Button.tsx + App.tsx with JSX)
- typescript-dynamic-import (`await import('./feature')`)
- typescript-reexport-namespace (`export * as Models from './base'`)

Validation:
- gitnexus-shared builds clean
- gitnexus typecheck clean
- 385/385 TS scope-resolution tests pass under both
  `REGISTRY_PRIMARY_TYPESCRIPT=0` and default

Made-with: Cursor

gitnexus-shared/src/scope-resolution/finalize-algorithm.ts

@@ -354,22 +354,23 @@ function makeEdgeDraft(
 
   // Resolvable at the file level; intra-SCC fixpoint may still fail to fill
   // in `targetDefId` (e.g., symbol not exported from target). Side-effect
-  // imports are terminal at the file level — no `targetDefId` needed since
-  // they materialize no `BindingRef`. Pre-finalize them here so the
-  // fixpoint loop skips them entirely.
+  // and resolved-dynamic imports are terminal at the file level — no
+  // `targetDefId` needed since they materialize no `BindingRef`. Pre-
+  // finalize them here so the fixpoint loop skips them entirely.
   const base: ImportEdge = {
     localName: extractLocalName(parsed),
     targetFile,
     targetExportedName: extractExportedName(parsed),
     kind: edgeKindFor(parsed),
   };
+  const isFileLevelTerminal = parsed.kind === 'side-effect' || parsed.kind === 'dynamic-resolved';
   return {
     source: parsed,
     fromFile: file.filePath,
     fromScope: file.moduleScope,
     targetFile,
     base,
-    finalized: parsed.kind === 'side-effect' ? base : null,
+    finalized: isFileLevelTerminal ? base : null,
   };
 }
 
@@ -382,6 +383,7 @@ function extractLocalName(parsed: ParsedImport): string {
   switch (parsed.kind) {
     case 'wildcard':
     case 'side-effect':
+    case 'dynamic-resolved':
       return '';
     default:
       return parsed.localName;
@@ -397,6 +399,7 @@ function extractExportedName(parsed: ParsedImport): string {
       return parsed.importedName;
     case 'wildcard':
     case 'dynamic-unresolved':
+    case 'dynamic-resolved':
     case 'side-effect':
       return '';
   }

gitnexus-shared/src/scope-resolution/types.ts

@@ -183,6 +183,27 @@ export type ParsedImport =
       /** Source text of the unresolved expression when available; `null` otherwise. */
       readonly targetRaw: string | null;
     }
+  /**
+   * Lazy / dynamic import whose target IS a static string literal at parse
+   * time, so it can be linked to a concrete `targetFile`. No local name
+   * binding is materialized — `import('./m')` returns `Promise<Module>` and
+   * any consumer-visible names appear via subsequent `.then(({ X }) => …)`
+   * destructuring, which is outside the static-import surface. The edge
+   * exists for module-reachability and impact analysis (so editing `./m`
+   * still flags the dynamic importer as affected).
+   *
+   * Providers MUST only emit this kind when `targetRaw` is a literal
+   * string they can hand to `resolveImportTarget`; expression arguments
+   * stay `dynamic-unresolved`.
+   *
+   * Examples:
+   *   - JS `import('./feature')`                  → `{ kind: 'dynamic-resolved', targetRaw: './feature' }`
+   *   - JS `await import('@scope/pkg/sub')`       → `{ kind: 'dynamic-resolved', targetRaw: '@scope/pkg/sub' }`
+   */
+  | {
+      readonly kind: 'dynamic-resolved';
+      readonly targetRaw: string;
+    }
   /**
    * Bare-source / side-effect import that introduces no local name binding
    * but still establishes a file-level dependency. Resolves to a concrete
@@ -269,6 +290,7 @@ export interface ImportEdge {
     | 'wildcard-expanded'
     | 'reexport'
     | 'dynamic-unresolved'
+    | 'dynamic-resolved'
     | 'side-effect';
   /** Re-export chain, for provenance (e.g., `['./y']` when re-exported via `./y`). */
   readonly transitiveVia?: readonly string[];

gitnexus/src/core/ingestion/languages/typescript/captures.ts

@@ -33,7 +33,7 @@ import {
   type SyntaxNode,
 } from '../../utils/ast-helpers.js';
 import { splitImportStatement } from './import-decomposer.js';
-import { getTsParser, getTsScopeQuery } from './query.js';
+import { getTsParser, getTsScopeQuery, tsCachedTreeMatchesGrammar } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { synthesizeTsReceiverBinding } from './receiver-binding.js';
 import { computeTsArityMetadata } from './arity-metadata.js';
@@ -97,22 +97,33 @@ function shouldEmitReadMember(memberNode: SyntaxNode): boolean {
 
 export function emitTsScopeCaptures(
   sourceText: string,
-  _filePath: string,
+  filePath: string,
   cachedTree?: unknown,
 ): readonly CaptureMatch[] {
   // Skip the parse when the caller (parse phase's scopeTreeCache) already
   // produced a Tree for this source. Cache miss = re-parse, same as before.
   // The cachedTree parameter is typed as `unknown` at the LanguageProvider
   // contract layer; cast here at the use site.
+  //
+  // Grammar selection: `.tsx` files are parsed with the TSX grammar,
+  // `.ts` files with the TypeScript grammar. The two grammars have
+  // separate node-type id spaces, so a Query compiled against one
+  // cannot match a Tree produced by the other. We validate the cached
+  // tree's grammar against the file extension and fall back to a
+  // fresh parse if they disagree (e.g. a worker-mode parse landed
+  // with the wrong grammar pinned).
   let tree = cachedTree as ReturnType<ReturnType<typeof getTsParser>['parse']> | undefined;
+  if (tree !== undefined && !tsCachedTreeMatchesGrammar(tree, filePath)) {
+    tree = undefined;
+  }
   if (tree === undefined) {
-    tree = getTsParser().parse(sourceText);
+    tree = getTsParser(filePath).parse(sourceText);
     recordCacheMiss();
   } else {
     recordCacheHit();
   }
 
-  const rawMatches = getTsScopeQuery().matches(tree.rootNode);
+  const rawMatches = getTsScopeQuery(filePath).matches(tree.rootNode);
   const out: CaptureMatch[] = [];
 
   for (const m of rawMatches) {

gitnexus/src/core/ingestion/languages/typescript/import-decomposer.ts

@@ -70,6 +70,9 @@ interface ImportSpec {
   readonly alias?: string;
   /** Node to anchor the synthesized captures (for range + match provenance). */
   readonly atNode: SyntaxNode;
+  /** Set on `dynamic` kind imports when the argument is a string literal —
+   *  enables `interpretTsImport` to emit `dynamic-resolved`. */
+  readonly literalSource?: boolean;
 }
 
 /**
@@ -244,8 +247,20 @@ function splitReexport(stmtNode: SyntaxNode): CaptureMatch[] {
 
   // `export * as ns from './m'` — tree-sitter-typescript emits a
   // `namespace_export` child whose identifier is the local re-export
-  // name. We bind the namespace to the source module so that
-  // consumers of this module can reach `ns.X` via the target's exports.
+  // name. Two facts are emitted:
+  //
+  //   1. An `@import.statement` (kind `reexport-namespace`) so finalize
+  //      knows the barrel imports `./m` as `ns` (binds `ns` locally
+  //      inside the barrel for consumers like `barrel.ts` calling
+  //      `ns.X()`).
+  //   2. A synthetic `@declaration.namespace` so the central
+  //      scope-extractor adds a `Namespace` SymbolDefinition for `ns`
+  //      to the barrel's `localDefs`. Without this, downstream files
+  //      doing `import { ns } from './barrel'` cannot resolve `ns`:
+  //      `findExportByName` and `followReexportChain` only look at
+  //      `localDefs` / `reexport` / `wildcard` drafts, never at
+  //      `namespace`-kind imports. The synthetic declaration fixes that
+  //      without growing the shared finalizer's surface.
   const namespaceExport = findChild(stmtNode, 'namespace_export');
   if (namespaceExport !== null) {
     const aliasId = findChild(namespaceExport, 'identifier');
@@ -258,6 +273,7 @@ function splitReexport(stmtNode: SyntaxNode): CaptureMatch[] {
           alias: aliasId.text,
           atNode: namespaceExport,
         }),
+        buildNamespaceDeclarationMatch(namespaceExport, aliasId),
       ];
     }
   }
@@ -345,6 +361,7 @@ function splitDynamicImport(callNode: SyntaxNode): CaptureMatch[] {
         source,
         name: '',
         atNode: callNode,
+        literalSource: true,
       }),
     ];
   }
@@ -408,5 +425,22 @@ function buildImportMatch(stmtNode: SyntaxNode, spec: ImportSpec): CaptureMatch
   if (spec.alias !== undefined) {
     m['@import.alias'] = syntheticCapture('@import.alias', spec.atNode, spec.alias);
   }
+  if (spec.literalSource === true) {
+    m['@import.literal'] = syntheticCapture('@import.literal', spec.atNode, '');
+  }
   return m;
 }
+
+/** Synthesize a `@declaration.namespace` match for `export * as ns from './m'`.
+ *  The central scope-extractor turns this into a `SymbolDefinition` of type
+ *  `Namespace` in the barrel's `localDefs`, which makes `findExportByName`
+ *  resolve `ns` for downstream `import { ns } from './barrel'` consumers. */
+function buildNamespaceDeclarationMatch(
+  namespaceExportNode: SyntaxNode,
+  aliasId: SyntaxNode,
+): CaptureMatch {
+  return {
+    '@declaration.namespace': nodeToCapture('@declaration.namespace', namespaceExportNode),
+    '@declaration.name': nodeToCapture('@declaration.name', aliasId),
+  };
+}

gitnexus/src/core/ingestion/languages/typescript/interpret.ts

@@ -122,10 +122,16 @@ export function interpretTsImport(captures: CaptureMatch): ParsedImport | null {
       };
     }
     case 'dynamic': {
-      // `import('./m')` / `import(x)`. When the argument is a string
-      // literal, we have a resolvable `targetRaw`; when it's a runtime
-      // expression, we pass through the source text for diagnostics
-      // and finalize marks the edge unresolved.
+      // `import('./m')` / `import(x)`. The decomposer marks literal-
+      // string arguments with `@import.literal` so we can promote them
+      // to `dynamic-resolved` here — that lets the shared finalizer
+      // produce a file-level IMPORTS edge for lazy-loaded modules.
+      // Non-literal arguments stay `dynamic-unresolved` (target is
+      // runtime-computed and unreachable to the static finalizer).
+      const isLiteral = captures['@import.literal'] !== undefined;
+      if (isLiteral && sourceCap !== undefined) {
+        return { kind: 'dynamic-resolved', targetRaw: sourceCap.text };
+      }
       return {
         kind: 'dynamic-unresolved',
         localName: '',

gitnexus/src/core/ingestion/languages/typescript/query.ts

@@ -54,13 +54,26 @@
 import Parser from 'tree-sitter';
 import TS from 'tree-sitter-typescript';
 
-// tree-sitter-typescript exports both `typescript` and `tsx` grammars on the
-// default export. The package's `.d.ts` types the default export loosely; we
-// narrow at the use site. The `.typescript` grammar covers both `.ts` and
-// `.tsx` syntax for the scope-query purposes (we only consume structural
-// constructs, not JSX-specific nodes).
+// tree-sitter-typescript exports both `typescript` and `tsx` grammars on
+// the default export. The package's `.d.ts` types the default export
+// loosely; we narrow at the use site. The two grammars are NOT
+// interchangeable: feeding a `.tsx` source to the `typescript` grammar
+// mis-parses JSX as a sequence of less-than/greater-than expressions
+// and silently drops every capture inside JSX elements. We therefore
+// pick the grammar by file extension.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const TS_GRAMMAR = (TS as any).typescript as Parameters<Parser['setLanguage']>[0];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const TSX_GRAMMAR = (TS as any).tsx as Parameters<Parser['setLanguage']>[0];
+
+/** True when the file should be parsed with the TSX grammar. The TSX
+ *  grammar is a superset of TypeScript that adds JSX productions; it
+ *  parses plain `.ts` files correctly too, but we keep `.ts` on the
+ *  `typescript` grammar so the parser cache stays small and so any
+ *  subtle TSX-only mis-parses don't bleed into non-TSX files. */
+function isTsxFile(filePath: string): boolean {
+  return filePath.endsWith('.tsx');
+}
 
 const TYPESCRIPT_SCOPE_QUERY = `
 ;; Scopes — module / namespace / class-likes / function-likes
@@ -710,20 +723,63 @@ const TYPESCRIPT_SCOPE_QUERY = `
   property: (property_identifier) @reference.name) @reference.read.member
 `;
 
-let _parser: Parser | null = null;
-let _query: Parser.Query | null = null;
+let _tsParser: Parser | null = null;
+let _tsxParser: Parser | null = null;
+let _tsQuery: Parser.Query | null = null;
+let _tsxQuery: Parser.Query | null = null;
 
-export function getTsParser(): Parser {
-  if (_parser === null) {
-    _parser = new Parser();
-    _parser.setLanguage(TS_GRAMMAR);
+/**
+ * Return the right tree-sitter parser for `filePath` (or the TS parser
+ * when no path is given — the legacy callsite shape).
+ */
+export function getTsParser(filePath?: string): Parser {
+  if (filePath !== undefined && isTsxFile(filePath)) {
+    if (_tsxParser === null) {
+      _tsxParser = new Parser();
+      _tsxParser.setLanguage(TSX_GRAMMAR);
+    }
+    return _tsxParser;
   }
-  return _parser;
+  if (_tsParser === null) {
+    _tsParser = new Parser();
+    _tsParser.setLanguage(TS_GRAMMAR);
+  }
+  return _tsParser;
 }
 
-export function getTsScopeQuery(): Parser.Query {
-  if (_query === null) {
-    _query = new Parser.Query(TS_GRAMMAR, TYPESCRIPT_SCOPE_QUERY);
+/**
+ * Return the right tree-sitter Query (compiled against the same grammar
+ * as the parser). A Query bound to the `typescript` grammar can NOT be
+ * executed against a Tree produced by the `tsx` grammar — tree-sitter
+ * matches by node-type id, and the two grammars have separate id
+ * spaces.
+ */
+export function getTsScopeQuery(filePath?: string): Parser.Query {
+  if (filePath !== undefined && isTsxFile(filePath)) {
+    if (_tsxQuery === null) {
+      _tsxQuery = new Parser.Query(TSX_GRAMMAR, TYPESCRIPT_SCOPE_QUERY);
+    }
+    return _tsxQuery;
   }
-  return _query;
+  if (_tsQuery === null) {
+    _tsQuery = new Parser.Query(TS_GRAMMAR, TYPESCRIPT_SCOPE_QUERY);
+  }
+  return _tsQuery;
+}
+
+/**
+ * Validate that a cached `Tree` was produced by the grammar matching
+ * `filePath` (TSX vs TypeScript). The runtime tree-sitter `Tree` exposes
+ * `getLanguage()` (returning the grammar object the parser was bound
+ * to); the .d.ts is incomplete, so we reach via a cast. Identity
+ * comparison against `TSX_GRAMMAR` / `TS_GRAMMAR` is exact: the same
+ * module instance produces both. If `getLanguage` is unavailable for
+ * any reason, return true to keep behavior backwards-compatible (the
+ * original code never validated grammar at all).
+ */
+export function tsCachedTreeMatchesGrammar(tree: unknown, filePath: string): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const lang = (tree as any)?.getLanguage?.();
+  if (lang === undefined || lang === null) return true;
+  return isTsxFile(filePath) ? lang === TSX_GRAMMAR : lang === TS_GRAMMAR;
 }

gitnexus/src/core/ingestion/languages/typescript/scope-resolver.ts

@@ -18,6 +18,7 @@ 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 { typescriptProvider } from '../typescript.js';
+import { loadTsconfigPaths, type TsconfigPaths } from '../../language-config.js';
 import {
   typescriptArityCompatibility,
   typescriptMergeBindings,
@@ -25,6 +26,11 @@ import {
   type TsResolveContext,
 } from './index.js';
 
+/** Shape the orchestrator threads in via `RunScopeResolutionInput.resolutionConfig`. */
+interface TypescriptResolutionConfig {
+  readonly tsconfigPaths: TsconfigPaths | null;
+}
+
 /**
  * Build a `resolveImportTarget` adapter that memoizes the workspace
  * file list, the lower-cased file list, and the per-pass `resolveCache`
@@ -45,7 +51,7 @@ function makeTsResolveImportTarget(): ScopeResolver['resolveImportTarget'] {
   let cachedNormalizedFileList: readonly string[] | null = null;
   let cachedResolveCache: Map<string, string | null> | null = null;
 
-  return (targetRaw, fromFile, allFilePaths) => {
+  return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
     if (cachedAllFilePaths !== allFilePaths) {
       cachedAllFilePaths = allFilePaths;
       cachedSet = new Set(allFilePaths);
@@ -54,12 +60,14 @@ function makeTsResolveImportTarget(): ScopeResolver['resolveImportTarget'] {
       cachedResolveCache = new Map();
     }
 
+    const cfg = resolutionConfig as TypescriptResolutionConfig | undefined;
     const ws: TsResolveContext = {
       fromFile,
       allFilePaths: cachedSet!,
       allFileList: cachedAllFileList!,
       normalizedFileList: cachedNormalizedFileList!,
       resolveCache: cachedResolveCache!,
+      tsconfigPaths: cfg?.tsconfigPaths ?? null,
     };
     return resolveTsTarget(targetRaw, ws);
   };
@@ -72,6 +80,14 @@ const typescriptScopeResolver: ScopeResolver = {
 
   resolveImportTarget: makeTsResolveImportTarget(),
 
+  // Threaded into `resolveImportTarget` so tsconfig path aliases
+  // (`@/services/user`, `~/x`, …) resolve through the same standard
+  // resolver branch the legacy DAG uses. One I/O round-trip per
+  // workspace pass; the orchestrator awaits this once.
+  loadResolutionConfig: async (repoPath: string) => ({
+    tsconfigPaths: await loadTsconfigPaths(repoPath),
+  }),
+
   // TypeScript declaration merging + LEGB: local > import > wildcard,
   // separated by declaration space (value / type / namespace). The
   // per-scope id is unused (shadowing is computed from origin + def.type),

gitnexus/src/core/ingestion/scope-resolution/contract/scope-resolver.ts

@@ -271,13 +271,39 @@ export interface ScopeResolver {
    * resolvers that must distinguish "this module exists in the repo"
    * from "this module is external" (Python's fallback resolver, for
    * example).
+   *
+   * `resolutionConfig` is the opaque value returned by
+   * `loadResolutionConfig` (loaded once per workspace pass by the
+   * orchestrator). TypeScript uses this to thread `tsconfig.json` path
+   * aliases through to the standard resolver. Languages that don't
+   * need any extra config ignore the parameter.
    */
   resolveImportTarget(
     targetRaw: string,
     fromFile: string,
     allFilePaths: ReadonlySet<string>,
+    resolutionConfig?: unknown,
   ): string | null;
 
+  /**
+   * Optional one-shot loader for cross-file import-resolution config
+   * (e.g. tsconfig path aliases for TypeScript, go.mod paths for Go,
+   * composer.json autoload for PHP). The orchestrator calls this once
+   * per workspace pass with the repo root and threads the result into
+   * every subsequent `resolveImportTarget` call as the
+   * `resolutionConfig` parameter.
+   *
+   * Languages that don't need any per-workspace config leave this
+   * undefined; the orchestrator threads `undefined` to
+   * `resolveImportTarget` in that case. Returning `null` is also
+   * supported and equivalent to "no config available".
+   *
+   * May be sync or async — the orchestrator awaits the result. The
+   * shape is opaque to the orchestrator (`unknown`); the per-language
+   * `resolveImportTarget` casts it to the language's expected shape.
+   */
+  loadResolutionConfig?(repoPath: string): Promise<unknown> | unknown;
+
   /**
    * Per-scope binding-merge precedence. The shared finalize pass
    * collects bindings from multiple sources (local declarations,

gitnexus/src/core/ingestion/scope-resolution/pipeline/phase.ts

@@ -126,12 +126,22 @@ export const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput> = {
         if (content !== undefined) files.push({ path: fp, content });
       }
 
+      // Load per-language import-resolution config (tsconfig paths,
+      // composer.json autoload, go.mod, ...). One I/O round trip per
+      // workspace pass — cached implicitly by the result handed to
+      // every `resolveImportTarget` call below.
+      const resolutionConfig =
+        provider.loadResolutionConfig !== undefined
+          ? await provider.loadResolutionConfig(ctx.repoPath)
+          : undefined;
+
       const stats = runScopeResolution(
         {
           graph: ctx.graph,
           model,
           files,
           treeCache: scopeTreeCache,
+          resolutionConfig,
           onWarn: (msg) => {
             if (isDev) console.warn(`[scope-resolution:${lang}] ${msg}`);
           },

gitnexus/src/core/ingestion/scope-resolution/pipeline/run.ts

@@ -62,6 +62,14 @@ interface RunScopeResolutionInput {
    * is safe — falls back to a fresh parse inside the provider.
    */
   readonly treeCache?: { get(filePath: string): unknown };
+  /**
+   * Opaque per-language import-resolution config (e.g. tsconfig path
+   * aliases for TypeScript). Loaded once by the caller via
+   * `provider.loadResolutionConfig(repoPath)` and threaded into every
+   * `provider.resolveImportTarget` call. `undefined` when the
+   * provider doesn't supply a config loader.
+   */
+  readonly resolutionConfig?: unknown;
 }
 
 interface RunScopeResolutionStats {
@@ -135,10 +143,11 @@ export function runScopeResolution(
   const nodeLookup = buildGraphNodeLookup(graph);
   const mroByClassDefId = provider.buildMro(graph, parsedFiles, nodeLookup);
 
+  const resolutionConfig = input.resolutionConfig;
   const finalized = finalizeScopeModel(parsedFiles, {
     hooks: {
       resolveImportTarget: (targetRaw, fromFile) =>
-        provider.resolveImportTarget(targetRaw, fromFile, allFilePaths),
+        provider.resolveImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig),
       mergeBindings: (existing, incoming, scopeId) =>
         provider.mergeBindings(existing, incoming, scopeId),
     },

gitnexus/test/fixtures/lang-resolution/typescript-dynamic-import/src/app.ts

@@ -0,0 +1,5 @@
+export async function loadFeature(): Promise<void> {
+  const mod = await import('./feature');
+  const feature = new mod.Feature();
+  feature.activate();
+}

gitnexus/test/fixtures/lang-resolution/typescript-dynamic-import/src/feature.ts

@@ -0,0 +1,5 @@
+export class Feature {
+  activate(): void {
+    console.log('activated');
+  }
+}

gitnexus/test/fixtures/lang-resolution/typescript-reexport-namespace/src/app.ts

@@ -0,0 +1,6 @@
+import { Models } from './barrel';
+
+export function main(): void {
+  const u = new Models.User();
+  u.save();
+}

gitnexus/test/fixtures/lang-resolution/typescript-reexport-namespace/src/barrel.ts

@@ -0,0 +1 @@
+export * as Models from './base';

gitnexus/test/fixtures/lang-resolution/typescript-reexport-namespace/src/base.ts

@@ -0,0 +1,11 @@
+export class User {
+  save(): void {
+    console.log('saving user');
+  }
+}
+
+export class Repo {
+  persist(): void {
+    console.log('persisting repo');
+  }
+}

gitnexus/test/fixtures/lang-resolution/typescript-tsconfig-aliases/src/app.ts

@@ -0,0 +1,6 @@
+import { UserService } from '@/services/user';
+
+export function main(): void {
+  const svc = new UserService();
+  svc.save();
+}

gitnexus/test/fixtures/lang-resolution/typescript-tsconfig-aliases/src/services/user.ts

@@ -0,0 +1,5 @@
+export class UserService {
+  save(): void {
+    console.log('saving user');
+  }
+}

gitnexus/test/fixtures/lang-resolution/typescript-tsconfig-aliases/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  }
+}

gitnexus/test/fixtures/lang-resolution/typescript-tsx-jsx/src/App.tsx

@@ -0,0 +1,9 @@
+import { Button } from './Button';
+
+export function App() {
+  return (
+    <div>
+      <Button label="hello" />
+    </div>
+  );
+}

gitnexus/test/fixtures/lang-resolution/typescript-tsx-jsx/src/Button.tsx

@@ -0,0 +1,5 @@
+type Props = { label: string };
+
+export function Button(props: Props) {
+  return <button>{props.label}</button>;
+}

gitnexus/test/integration/resolvers/typescript.test.ts

@@ -2672,3 +2672,146 @@ describe('TypeScript Child extends Parent — inherited method resolution (SM-9)
     expect(parentMethodCall!.source).toBe('run');
   });
 });
+
+// ---------------------------------------------------------------------------
+// PR #1050: tsconfig path alias resolution under registry-primary path
+// (Adversarial review Finding 1 — `@/services/user` must resolve via tsconfig
+//  paths even when imports go through ScopeResolver.resolveImportTarget.)
+// ---------------------------------------------------------------------------
+
+describe('TypeScript tsconfig path alias resolution (registry-primary)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(
+      path.join(FIXTURES, 'typescript-tsconfig-aliases'),
+      () => {},
+    );
+  }, 60000);
+
+  it('detects UserService class in src/services/user.ts', () => {
+    expect(getNodesByLabel(result, 'Class')).toContain('UserService');
+  });
+
+  it('emits IMPORTS edge from app.ts to services/user.ts via @/ alias', () => {
+    const imports = getRelationships(result, 'IMPORTS').filter(
+      (e) => e.sourceFilePath === 'src/app.ts',
+    );
+    expect(imports.map((e) => e.targetFilePath).sort()).toEqual(['src/services/user.ts']);
+  });
+
+  it('resolves new UserService() through alias to services/user.ts', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const ctor = calls.find((c) => c.target === 'UserService' && c.targetLabel === 'Class');
+    expect(ctor).toBeDefined();
+    expect(ctor!.source).toBe('main');
+    expect(ctor!.targetFilePath).toBe('src/services/user.ts');
+  });
+
+  it('resolves svc.save() through alias to services/user.ts', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const save = calls.find((c) => c.target === 'save');
+    expect(save).toBeDefined();
+    expect(save!.source).toBe('main');
+    expect(save!.targetFilePath).toBe('src/services/user.ts');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PR #1050: TSX files parsed with the TSX tree-sitter grammar (not TS).
+// (Adversarial review Finding 2 — JSX must parse so component definitions
+//  and imports are captured.)
+// ---------------------------------------------------------------------------
+
+describe('TypeScript TSX/JSX scope extraction (registry-primary)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'typescript-tsx-jsx'), () => {});
+  }, 60000);
+
+  it('detects Button and App functions in .tsx files (JSX did not break parsing)', () => {
+    const fns = getNodesByLabel(result, 'Function');
+    expect(fns).toContain('Button');
+    expect(fns).toContain('App');
+  });
+
+  it('emits IMPORTS edge from App.tsx to Button.tsx', () => {
+    const imports = getRelationships(result, 'IMPORTS').filter(
+      (e) => e.sourceFilePath === 'src/App.tsx',
+    );
+    expect(imports.map((e) => e.targetFilePath)).toContain('src/Button.tsx');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PR #1050: literal `import('./feature')` resolves to a target file.
+// (Adversarial review Finding 3 — dynamic-resolved emits a real IMPORTS edge.)
+// ---------------------------------------------------------------------------
+
+describe('TypeScript literal dynamic import resolution (registry-primary)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'typescript-dynamic-import'), () => {});
+  }, 60000);
+
+  it('detects Feature class in feature.ts', () => {
+    expect(getNodesByLabel(result, 'Class')).toContain('Feature');
+  });
+
+  it('emits IMPORTS edge from app.ts to feature.ts via `await import("./feature")`', () => {
+    const imports = getRelationships(result, 'IMPORTS').filter(
+      (e) => e.sourceFilePath === 'src/app.ts',
+    );
+    // Literal dynamic-import resolution is a registry-primary feature
+    // (interpreter emits `dynamic-resolved`, finalize pre-finalizes it
+    // as a file-level terminal). The legacy DAG path
+    // (`REGISTRY_PRIMARY_TYPESCRIPT=0`) does not link literal
+    // `import('…')` calls to a target file — accept that here so the
+    // CI parity gate stays green; the registry-primary path remains the
+    // authoritative guarantee.
+    if (process.env['REGISTRY_PRIMARY_TYPESCRIPT'] !== '0') {
+      expect(imports.map((e) => e.targetFilePath)).toContain('src/feature.ts');
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PR #1050: `export * as ns from './m'` namespace barrel re-export.
+// (Adversarial review Finding 4 — barrel must expose `ns` as a binding so
+//  `import { ns } from './barrel'` resolves through to the namespace target.)
+// ---------------------------------------------------------------------------
+
+describe('TypeScript namespace re-export barrel (registry-primary)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(
+      path.join(FIXTURES, 'typescript-reexport-namespace'),
+      () => {},
+    );
+  }, 60000);
+
+  it('detects User and Repo classes in base.ts', () => {
+    expect(getNodesByLabel(result, 'Class')).toEqual(['Repo', 'User']);
+  });
+
+  // The synthetic Namespace `SymbolDefinition` lives in barrel.ts's
+  // `localDefs` so `findExportByName` can satisfy a downstream
+  // `import { Models } from './barrel'`. Unit coverage for the synthetic
+  // capture lives in `typescript-captures.test.ts`. The graph-bridge does
+  // not materialize a Namespace node for `export * as` — that's why this
+  // suite asserts on the chain edges, not on a `Namespace` graph node.
+  it('emits IMPORTS edges along the barrel chain: app.ts→barrel.ts and barrel.ts→base.ts', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const fromApp = imports
+      .filter((e) => e.sourceFilePath === 'src/app.ts')
+      .map((e) => e.targetFilePath);
+    const fromBarrel = imports
+      .filter((e) => e.sourceFilePath === 'src/barrel.ts')
+      .map((e) => e.targetFilePath);
+    expect(fromApp).toContain('src/barrel.ts');
+    expect(fromBarrel).toContain('src/base.ts');
+  });
+});

gitnexus/test/unit/scope-resolution/typescript/typescript-captures.test.ts

@@ -290,6 +290,27 @@ describe('emitTsScopeCaptures — imports (decomposed)', () => {
     expect(m!['@import.kind'].text).toBe('dynamic');
     expect(m!['@import.source'].text).toBe('./m');
   });
+
+  it('marks literal dynamic imports with @import.literal so the interpreter can flag them resolvable', () => {
+    const src = "const m = import('./m');";
+    const m = findMatch(src, (t) => t.includes('@import.statement'));
+    expect(m).toBeDefined();
+    expect(m!['@import.literal']).toBeDefined();
+  });
+
+  it('does NOT mark non-literal dynamic imports with @import.literal', () => {
+    const src = 'const m = import(spec);';
+    const m = findMatch(src, (t) => t.includes('@import.statement'));
+    expect(m).toBeDefined();
+    expect(m!['@import.literal']).toBeUndefined();
+  });
+
+  it('emits a synthetic @declaration.namespace for `export * as ns from "./m"` (barrel binding)', () => {
+    const src = "export * as Models from './base';";
+    const m = findMatch(src, (t) => t.includes('@declaration.namespace'));
+    expect(m).toBeDefined();
+    expect(m!['@declaration.name'].text).toBe('Models');
+  });
 });
 
 describe('emitTsScopeCaptures — type bindings', () => {

gitnexus/test/unit/scope-resolution/typescript/typescript-imports.test.ts

@@ -191,16 +191,15 @@ describe('interpretTsImport — re-exports', () => {
 });
 
 describe('interpretTsImport — dynamic imports', () => {
-  it('literal argument: `import("./m")` → dynamic-unresolved with targetRaw', () => {
+  it('literal argument: `import("./m")` → dynamic-resolved (targetRaw is a literal path)', () => {
     const [imp] = importsFor('const p = import("./m");');
     expect(imp).toEqual({
-      kind: 'dynamic-unresolved',
-      localName: '',
+      kind: 'dynamic-resolved',
       targetRaw: './m',
     });
   });
 
-  it('non-literal argument: `import(expr)` preserves the expr text', () => {
+  it('non-literal argument: `import(expr)` stays dynamic-unresolved', () => {
     const [imp] = importsFor('const p = import(x);');
     expect(imp?.kind).toBe('dynamic-unresolved');
     expect((imp as { targetRaw: string | null }).targetRaw).toBe('x');
@@ -211,6 +210,14 @@ describe('interpretTsImport — dynamic imports', () => {
     expect(imp?.kind).toBe('dynamic-unresolved');
     expect((imp as { targetRaw: string | null }).targetRaw).toContain('name');
   });
+
+  it('await + literal: `await import("./m")` → dynamic-resolved', () => {
+    const [imp] = importsFor('async function f() { return await import("./m"); }');
+    expect(imp).toEqual({
+      kind: 'dynamic-resolved',
+      targetRaw: './m',
+    });
+  });
 });
 
 describe('resolveTsImportTarget — standard suffix + alias resolution', () => {
@@ -301,10 +308,9 @@ describe('resolveTsImportTarget — standard suffix + alias resolution', () => {
     expect(result).toBe(null);
   });
 
-  it('resolves dynamic-unresolved with a literal targetRaw same as a static import', () => {
+  it('resolves dynamic-resolved (literal dynamic import) the same as a static import', () => {
     const parsed: ParsedImport = {
-      kind: 'dynamic-unresolved',
-      localName: '',
+      kind: 'dynamic-resolved',
       targetRaw: './a',
     };
     const result = resolveTsImportTarget(parsed, ctx('src/main.ts', ['src/main.ts', 'src/a.ts']));