@optave/codegraph 3.11.1 → 3.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optave/codegraph",
-  "version": "3.11.1",
+  "version": "3.12.0",
   "description": "Local code graph CLI — parse codebases with tree-sitter, build dependency graphs, query them",
   "type": "module",
   "main": "dist/index.js",
@@ -76,7 +76,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=22.6"
+    "node": ">=22.12.0"
   },
   "scripts": {
     "build": "tsc && node -e \"require('fs').writeFileSync('dist/index.cjs',require('fs').readFileSync('src/index.cjs','utf8').replaceAll('./index.ts','./index.js'))\"",
@@ -119,7 +119,7 @@
   "homepage": "https://github.com/optave/ops-codegraph-tool#readme",
   "dependencies": {
     "better-sqlite3": "^12.6.2",
-    "commander": "^14.0.3",
+    "commander": "^15.0.0",
     "web-tree-sitter": "^0.26.5"
   },
   "peerDependencies": {
@@ -132,12 +132,12 @@
   },
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@optave/codegraph-darwin-arm64": "3.11.1",
-    "@optave/codegraph-darwin-x64": "3.11.1",
-    "@optave/codegraph-linux-arm64-gnu": "3.11.1",
-    "@optave/codegraph-linux-x64-gnu": "3.11.1",
-    "@optave/codegraph-linux-x64-musl": "3.11.1",
-    "@optave/codegraph-win32-x64-msvc": "3.11.1"
+    "@optave/codegraph-darwin-arm64": "3.12.0",
+    "@optave/codegraph-darwin-x64": "3.12.0",
+    "@optave/codegraph-linux-arm64-gnu": "3.12.0",
+    "@optave/codegraph-linux-x64-gnu": "3.12.0",
+    "@optave/codegraph-linux-x64-musl": "3.12.0",
+    "@optave/codegraph-win32-x64-msvc": "3.12.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",

package/src/db/migrations.ts

@@ -256,6 +256,13 @@ export const MIGRATIONS: Migration[] = [
       CREATE INDEX IF NOT EXISTS idx_edges_kind_source ON edges(kind, source_id);
     `,
   },
+  {
+    version: 17,
+    up: `
+      ALTER TABLE edges ADD COLUMN technique TEXT;
+      CREATE INDEX IF NOT EXISTS idx_edges_technique ON edges(technique);
+    `,
+  },
 ];
 
 interface PragmaColumnInfo {

package/src/domain/analysis/module-map.ts

@@ -163,6 +163,26 @@ function getEmbeddingsInfo(db: BetterSqlite3Database) {
   return null;
 }
 
+function countCallEdgesByTechnique(
+  db: BetterSqlite3Database,
+  testFilter: string,
+): Record<string, number> {
+  // testFilter uses n.file — join source node to apply the same file-scope as
+  // the rest of computeQualityMetrics so --no-tests is consistent.
+  const rows = db
+    .prepare(
+      `SELECT e.technique, COUNT(*) as c
+       FROM edges e
+       JOIN nodes n ON e.source_id = n.id
+       WHERE e.kind = 'calls' AND e.technique IS NOT NULL ${testFilter}
+       GROUP BY e.technique`,
+    )
+    .all() as Array<{ technique: string; c: number }>;
+  const byTechnique: Record<string, number> = {};
+  for (const r of rows) byTechnique[r.technique] = r.c;
+  return byTechnique;
+}
+
 function computeQualityMetrics(
   db: BetterSqlite3Database,
   testFilter: string,
@@ -205,13 +225,16 @@ function computeQualityMetrics(
   const falsePositiveRatio = totalCallEdges > 0 ? fpEdgeCount / totalCallEdges : 0;
 
   const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
+  const byTechnique = countCallEdgesByTechnique(db, testFilter);
 
   return {
     score,
     callerCoverage: {
       ratio: callerCoverage,
+      percentage: Math.round(callerCoverage * 100),
       covered: callableWithCallers,
       total: totalCallable,
+      byTechnique: Object.keys(byTechnique).length > 0 ? byTechnique : undefined,
     },
     callConfidence: {
       ratio: callConfidence,
@@ -388,6 +411,7 @@ function buildStatsFromNative(
   db: BetterSqlite3Database,
   nativeStats: NativeGraphStats,
   config: any,
+  noTests: boolean,
   jsSections: {
     files: ReturnType<typeof countFilesByLanguage>;
     fileCycles: unknown[];
@@ -413,6 +437,8 @@ function buildStatsFromNative(
   for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
   const falsePositiveRatio = s.quality.callEdges > 0 ? fpEdgeCount / s.quality.callEdges : 0;
   const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
+  const testFilter = testFilterSQL('n.file', noTests);
+  const byTechnique = countCallEdgesByTechnique(db, testFilter);
 
   return {
     nodes: { total: s.totalNodes, byKind: nodesByKind },
@@ -432,8 +458,10 @@ function buildStatsFromNative(
       score,
       callerCoverage: {
         ratio: callerCoverage,
+        percentage: Math.round(callerCoverage * 100),
         covered: s.quality.callableWithCallers,
         total: s.quality.callableTotal,
+        byTechnique: Object.keys(byTechnique).length > 0 ? byTechnique : undefined,
       },
       callConfidence: {
         ratio: callConfidence,
@@ -508,7 +536,7 @@ export function statsData(customDbPath: string, opts: { noTests?: boolean; confi
 
     const nativeStats = nativeDb?.getGraphStats?.(noTests);
     return nativeStats
-      ? buildStatsFromNative(db, nativeStats, config, jsSections)
+      ? buildStatsFromNative(db, nativeStats, config, noTests, jsSections)
       : buildStatsFromJs(db, noTests, config, jsSections);
   } finally {
     close();

package/src/domain/graph/builder/call-resolver.ts

@@ -0,0 +1,351 @@
+/**
+ * Shared call-edge resolution — used by both the full build pipeline
+ * (build-edges.ts) and the incremental watch path (incremental.ts).
+ *
+ * Both callers supply a `CallNodeLookup` adapter that abstracts their
+ * node-lookup mechanism (pre-loaded Maps vs. per-query SQLite statements).
+ * The resolution logic lives here exactly once.
+ */
+import { computeConfidence } from '../resolve.js';
+
+// ── Public interface ─────────────────────────────────────────────────────
+
+export interface CallNodeLookup {
+  byNameAndFile(
+    name: string,
+    file: string,
+  ): ReadonlyArray<{ id: number; file: string; kind?: string }>;
+  byName(name: string): ReadonlyArray<{ id: number; file: string; kind?: string }>;
+  isBarrel(file: string): boolean;
+  resolveBarrel(barrelFile: string, symbolName: string): string | null;
+  nodeId(name: string, kind: string, file: string, line: number): { id: number } | undefined;
+}
+
+export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
+
+/**
+ * Languages where bare `foo()` calls inside a class method are lexically scoped
+ * to the module, not the class — there is no implicit this/class binding.
+ * For these languages, the same-class fallback must not run for bare (no-receiver)
+ * calls that found no exact same-file match.
+ */
+const MODULE_SCOPED_BARE_CALL_EXTENSIONS = new Set([
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.jsx',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+]);
+
+export function isModuleScopedLanguage(relPath: string): boolean {
+  const ext = relPath.slice(relPath.lastIndexOf('.'));
+  return MODULE_SCOPED_BARE_CALL_EXTENSIONS.has(ext);
+}
+
+// ── Shared resolution functions ──────────────────────────────────────────
+
+export function findCaller(
+  lookup: CallNodeLookup,
+  call: { line: number },
+  definitions: ReadonlyArray<{
+    name: string;
+    kind: string;
+    line: number;
+    endLine?: number | null;
+  }>,
+  relPath: string,
+  fileNodeRow: { id: number },
+): { id: number; callerName: string | null } {
+  let caller: { id: number } | null = null;
+  let callerName: string | null = null;
+  let callerSpan = Infinity;
+  for (const def of definitions) {
+    if (def.line <= call.line) {
+      const end = def.endLine || Infinity;
+      if (call.line <= end) {
+        const span = end - def.line;
+        if (span < callerSpan) {
+          const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+          if (row) {
+            caller = row;
+            callerName = def.name;
+            callerSpan = span;
+          }
+        }
+      }
+    }
+  }
+  return { ...(caller ?? fileNodeRow), callerName };
+}
+
+export function resolveByMethodOrGlobal(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver?: string | null },
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  callerName?: string | null,
+): ReadonlyArray<{ id: number; file: string }> {
+  if (call.receiver) {
+    // Strip "this." so `this.repo.method()` resolves via typeMap["repo"]
+    // (or the "this.repo" key seeded directly by the TSC property-declaration enricher).
+    const effectiveReceiver = call.receiver.startsWith('this.')
+      ? call.receiver.slice('this.'.length)
+      : call.receiver;
+    // For this.prop receivers, also try the class-scoped key (ClassName.prop) seeded by
+    // handlePropWriteTypeMap — prevents false edges when multiple classes define the same
+    // property name (issue #1323).
+    let typeEntry =
+      typeMap.get(effectiveReceiver) ??
+      typeMap.get(call.receiver) ??
+      // Phase 8.3f: callee-scoped rest-param key (`callee::restName`) to avoid
+      // same-name rest-binding collision across functions in the same file (#1358).
+      (callerName ? typeMap.get(`${callerName}::${effectiveReceiver}`) : undefined);
+    if (!typeEntry && call.receiver.startsWith('this.') && callerName) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        const callerClass = callerName.slice(0, dotIdx);
+        typeEntry = typeMap.get(`${callerClass}.${effectiveReceiver}`);
+      }
+    }
+    let typeName = typeEntry
+      ? typeof typeEntry === 'string'
+        ? typeEntry
+        : (typeEntry as { type?: string }).type
+      : null;
+
+    // Belt-and-suspenders fallback for inline new-expression receivers that
+    // extractReceiverName did not normalise (e.g. raw text leaked from an
+    // unhandled AST node type).  extractReceiverName already handles the common
+    // `new_expression` / `parenthesized_expression(new_expression)` shapes by
+    // returning the constructor name directly, so this branch is exercised only
+    // by future node types or constructs that fall through to the raw-text path.
+    // The uppercase-initial restriction ([A-Z_$]) is a heuristic to distinguish
+    // constructors (PascalCase) from regular functions and avoids false positives
+    // on `(new xmlParser()).parse()` style calls.
+    if (!typeName && call.receiver) {
+      const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
+      if (m?.[1]) typeName = m[1];
+    }
+
+    if (typeName) {
+      const typed = lookup
+        .byName(`${typeName}.${call.name}`)
+        .filter((n) => n.kind === 'method' && computeConfidence(relPath, n.file, null) >= 0.5);
+      if (typed.length > 0) return typed;
+
+      // Prototype alias: `Foo.prototype.bar = identifier` seeds typeMap['Foo.bar'] = { type: identifier }.
+      // Checked after the symbol-DB lookup so an actual method definition always wins.
+      const protoEntry = typeMap.get(`${typeName}.${call.name}`);
+      const protoTarget = protoEntry
+        ? typeof protoEntry === 'string'
+          ? protoEntry
+          : (protoEntry as { type?: string }).type
+        : null;
+      if (protoTarget) {
+        const resolved = lookup
+          .byName(protoTarget)
+          .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+        if (resolved.length > 0) return resolved;
+      }
+    }
+
+    // Direct qualified method lookup: ClassName.staticMethod() or ClassName.instanceMethod()
+    // when the receiver is a class name with no typeMap entry. Handles static method calls
+    // like `C6.staticMethod()` or `D.d()` where the receiver IS the class.
+    // Matches both 'method' and 'function' kinds to cover field-initializer synthetic defs.
+    if (!typeName) {
+      const qualifiedName = `${effectiveReceiver}.${call.name}`;
+      const direct = lookup
+        .byName(qualifiedName)
+        .filter(
+          (n) =>
+            (n.kind === 'method' || n.kind === 'function') &&
+            computeConfidence(relPath, n.file, null) >= 0.5,
+        );
+      if (direct.length > 0) return direct;
+    }
+
+    // Phase 8.3d: composite pts key — `obj.prop = fn` seeds typeMap['obj.prop'] = { type: 'fn' }.
+    // When a call site references `obj.prop` as a callback, resolve directly to the target fn.
+    const compositeEntry = typeMap.get(`${call.receiver}.${call.name}`);
+    const ptsTarget = compositeEntry
+      ? typeof compositeEntry === 'string'
+        ? compositeEntry
+        : (compositeEntry as { type?: string }).type
+      : null;
+    if (ptsTarget) {
+      const resolved = lookup
+        .byName(ptsTarget)
+        .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+      if (resolved.length > 0) return resolved;
+    }
+  }
+  if (
+    !call.receiver ||
+    call.receiver === 'this' ||
+    call.receiver === 'self' ||
+    call.receiver === 'super'
+  ) {
+    // Phase 8.3f: accessor this-dispatch via Object.defineProperty.
+    // When a plain function (no class prefix) is registered as a get/set accessor for `obj`
+    // via Object.defineProperty, typeMap seeds 'callerName:this' = 'obj'.
+    // We then resolve this.method() → typeMap['obj.method'] → the concrete definition.
+    // This runs before the broad exact-name lookup to avoid false positives from
+    // unrelated same-file definitions.
+    if (call.receiver === 'this' && callerName && !callerName.includes('.')) {
+      const accessorThisEntry = typeMap.get(`${callerName}:this`);
+      const objName = accessorThisEntry
+        ? typeof accessorThisEntry === 'string'
+          ? accessorThisEntry
+          : (accessorThisEntry as { type?: string }).type
+        : null;
+      if (objName) {
+        const objMethodEntry = typeMap.get(`${objName}.${call.name}`);
+        const targetFn = objMethodEntry
+          ? typeof objMethodEntry === 'string'
+            ? objMethodEntry
+            : (objMethodEntry as { type?: string }).type
+          : null;
+        if (targetFn) {
+          const resolved = lookup
+            .byName(targetFn)
+            .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+          if (resolved.length > 0) return resolved;
+        }
+      }
+    }
+
+    const exact = lookup
+      .byName(call.name)
+      .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+    if (exact.length > 0) return exact;
+
+    // Try same-class method lookup via callerName.
+    // e.g. `this.area()` inside `Shape.describe` → try `Shape.area`.
+    // Also covers no-receiver calls inside class methods, e.g. `IsValidEmail(x)` inside
+    // `Validators.ValidateUser` → try `Validators.IsValidEmail` (C#/Java static siblings).
+    // This seeds the initial edge that runChaPostPass later expands to subclass overrides.
+    //
+    // For JS/TS, bare (no-receiver) calls are module-scoped — there is no implicit class
+    // binding. Skip the same-class fallback for bare calls in those languages to prevent
+    // false positives (e.g. `flush()` inside `Processor.run` must not resolve to
+    // `Processor.flush`). this.method() calls are unaffected: they still reach the fallback
+    // because `call.receiver === 'this'` is truthy, not a bare call.
+    const isBareCall = !call.receiver;
+    if (callerName && !(isBareCall && isModuleScopedLanguage(relPath))) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        // Extract only the segment immediately before the method name so that
+        // 'Namespace.ClassName.method' yields 'ClassName', not 'Namespace.ClassName'.
+        // Symbols are stored under their bare class name, not their qualified path.
+        const prevDot = callerName.lastIndexOf('.', dotIdx - 1);
+        const callerClass = callerName.slice(prevDot + 1, dotIdx);
+        const qualifiedName = `${callerClass}.${call.name}`;
+        const sameClass = lookup
+          .byName(qualifiedName)
+          .filter((t) => t.kind === 'method' && computeConfidence(relPath, t.file, null) >= 0.5);
+        if (sameClass.length > 0) return sameClass;
+      }
+    }
+    return exact; // empty
+  }
+  return [];
+}
+
+export function resolveCallTargets(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver?: string | null },
+  relPath: string,
+  importedNames: Map<string, string>,
+  typeMap: Map<string, unknown>,
+  callerName?: string | null,
+): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
+  const importedFrom = importedNames.get(call.name);
+  let targets: ReadonlyArray<{ id: number; file: string }> | undefined;
+
+  if (importedFrom) {
+    targets = lookup.byNameAndFile(call.name, importedFrom);
+    if (targets.length === 0 && lookup.isBarrel(importedFrom)) {
+      const actualSource = lookup.resolveBarrel(importedFrom, call.name);
+      if (actualSource) {
+        targets = lookup.byNameAndFile(call.name, actualSource);
+      }
+    }
+  }
+
+  if (!targets || targets.length === 0) {
+    targets = lookup.byNameAndFile(call.name, relPath);
+    if (targets.length === 0) {
+      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap, callerName);
+    }
+  }
+
+  const resolved = [...(targets ?? [])];
+  if (resolved.length > 1) {
+    resolved.sort((a, b) => {
+      const confA = computeConfidence(relPath, a.file, importedFrom ?? null);
+      const confB = computeConfidence(relPath, b.file, importedFrom ?? null);
+      return confB - confA;
+    });
+  }
+  return { targets: resolved, importedFrom };
+}
+
+/**
+ * Resolve the receiver-type edge for a call site.
+ * Returns the edge tuple to insert, or null if nothing matched or the edge
+ * was already seen.  Callers are responsible for the actual DB/array insert.
+ *
+ * Receiver resolution collects all same-file candidates first (no kind
+ * filter), falls back to global candidates only when the same-file set is
+ * entirely empty, then filters the chosen set by RECEIVER_KINDS.  This
+ * matches the native Rust build path: if a file imports a name that happens
+ * to be emitted as `kind='function'` in the importer, the same-file set is
+ * non-empty and blocks the global fallback, so no receiver edge is emitted.
+ * Keeping this behaviour identical to the Rust path maintains engine parity.
+ */
+export function resolveReceiverEdge(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver: string },
+  caller: { id: number },
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  seenCallEdges: Set<string>,
+): { callerId: number; receiverId: number; confidence: number } | null {
+  const typeEntry = typeMap.get(call.receiver);
+  const typeName = typeEntry
+    ? typeof typeEntry === 'string'
+      ? typeEntry
+      : ((typeEntry as { type?: string }).type ?? null)
+    : null;
+  const typeConfidence =
+    typeEntry && typeof typeEntry !== 'string'
+      ? ((typeEntry as { confidence?: number }).confidence ?? null)
+      : null;
+  const effectiveReceiver = typeName || call.receiver;
+  // Filter-before: apply RECEIVER_KINDS to same-file candidates first, then
+  // fall back to global candidates (also filtered) only when same-file yields
+  // nothing.  This prevents an imported name emitted as kind='function' in the
+  // importing file from blocking the fallback to the actual class/struct/etc.
+  // node in the defining file.
+  const sameFileCandidates = lookup
+    .byNameAndFile(effectiveReceiver, relPath)
+    .filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
+  const candidates =
+    sameFileCandidates.length > 0
+      ? sameFileCandidates
+      : lookup.byName(effectiveReceiver).filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
+  if (candidates.length === 0) return null;
+  const recvTarget = candidates[0]!;
+  const recvKey = `recv|${caller.id}|${recvTarget.id}`;
+  if (seenCallEdges.has(recvKey)) return null;
+  seenCallEdges.add(recvKey);
+  return {
+    callerId: caller.id,
+    receiverId: recvTarget.id,
+    confidence: typeConfidence ?? (typeName ? 0.9 : 0.7),
+  };
+}

package/src/domain/graph/builder/cha.ts

@@ -0,0 +1,175 @@
+/**
+ * Phase 8.5: Class Hierarchy Analysis (CHA) + Rapid Type Analysis (RTA)
+ *
+ * CHA resolves virtual/interface method dispatch to all known concrete
+ * implementations.  RTA refines the CHA set by filtering out types that are
+ * never instantiated in the program (no `new X()` anywhere in the codebase).
+ *
+ * Used by:
+ *   - buildFileCallEdges (WASM/JS path) — inline during per-file edge building
+ *   - buildChaPostPass (native path)    — JS post-pass on top of native edges
+ */
+
+import type { ExtractorOutput } from '../../../types.js';
+import type { CallNodeLookup } from './call-resolver.js';
+
+// ── CHA context ──────────────────────────────────────────────────────────────
+
+export interface ChaContext {
+  /** interface/class name → concrete classes that implement or extend it */
+  readonly implementors: ReadonlyMap<string, readonly string[]>;
+  /** class name → direct parent class name (from `extends`) */
+  readonly parents: ReadonlyMap<string, string>;
+  /** RTA: class names that appear in `new X()` anywhere in the project */
+  readonly instantiatedTypes: ReadonlySet<string>;
+}
+
+export const EMPTY_CHA_CONTEXT: ChaContext = {
+  implementors: new Map(),
+  parents: new Map(),
+  instantiatedTypes: new Set(),
+};
+
+/**
+ * Build the CHA context from all parsed file symbols.
+ *
+ * Must be called AFTER cross-file return-type propagation so that typeMap
+ * confidence values reflect propagated types (used for RTA seeding).
+ */
+export function buildChaContext(fileSymbols: ReadonlyMap<string, ExtractorOutput>): ChaContext {
+  const implementors = new Map<string, string[]>();
+  const parents = new Map<string, string>();
+  const instantiatedTypes = new Set<string>();
+
+  for (const symbols of fileSymbols.values()) {
+    for (const cls of symbols.classes) {
+      if (cls.implements) {
+        let list = implementors.get(cls.implements);
+        if (!list) {
+          list = [];
+          implementors.set(cls.implements, list);
+        }
+        if (!list.includes(cls.name)) list.push(cls.name);
+      }
+      if (cls.extends) {
+        // child → parent (for this/super hierarchy walking)
+        if (!parents.has(cls.name)) parents.set(cls.name, cls.extends);
+        // parent → children (for CHA dispatch expansion via extends)
+        let list = implementors.get(cls.extends);
+        if (!list) {
+          list = [];
+          implementors.set(cls.extends, list);
+        }
+        if (!list.includes(cls.name)) list.push(cls.name);
+      }
+    }
+
+    // RTA: Phase 8.5 dedicated newExpressions list (all `new X()` in the file)
+    if (symbols.newExpressions) {
+      for (const typeName of symbols.newExpressions) {
+        instantiatedTypes.add(typeName);
+      }
+    }
+    // RTA fallback: constructor-confidence typeMap entries (confidence >= 0.9)
+    // covers codebases that haven't been re-parsed since Phase 8.5 was added.
+    if (symbols.typeMap instanceof Map) {
+      for (const entry of symbols.typeMap.values()) {
+        if (typeof entry !== 'string' && entry.confidence >= 0.9) {
+          instantiatedTypes.add(entry.type);
+        }
+      }
+    }
+  }
+
+  return { implementors, parents, instantiatedTypes };
+}
+
+// ── this / self / super resolution ──────────────────────────────────────────
+
+/**
+ * Resolve `this.method()`, `self.method()`, or `super.method()` through the
+ * class hierarchy of the calling method.
+ *
+ * callerName must be a qualified method name ("ClassName.callerFn") for the
+ * class context to be determinable.  Returns [] for plain functions.
+ *
+ * For `super`, resolution starts from the parent of the caller's class.
+ * For `this`/`self`, resolution starts from the caller's own class and walks
+ * up the inheritance chain (supporting inherited method lookup).
+ */
+export function resolveThisDispatch(
+  methodName: string,
+  callerName: string | null,
+  receiver: 'this' | 'self' | 'super',
+  chaCtx: ChaContext,
+  lookup: CallNodeLookup,
+): ReadonlyArray<{ id: number; file: string }> {
+  if (!callerName) return [];
+  const dotIdx = callerName.indexOf('.');
+  if (dotIdx === -1) return [];
+
+  const callerClass = callerName.slice(0, dotIdx);
+  const startClass = receiver === 'super' ? chaCtx.parents.get(callerClass) : callerClass;
+  if (!startClass) return [];
+
+  // Walk up the hierarchy; the visited set guards against cycles in malformed data.
+  let current: string | undefined = startClass;
+  const visited = new Set<string>();
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const qualified = `${current}.${methodName}`;
+    const found = lookup.byName(qualified).filter((n) => n.kind === 'method');
+    if (found.length > 0) return found;
+    current = chaCtx.parents.get(current);
+  }
+  return [];
+}
+
+// ── CHA dispatch expansion ───────────────────────────────────────────────────
+
+/**
+ * CHA + RTA: given a receiver type (class or interface), return all concrete
+ * method implementations reachable via the class hierarchy.
+ *
+ * Only returns methods on types that are actually instantiated somewhere in
+ * the project (RTA filter).  Returns [] when no concrete instantiated type
+ * overrides the given method.
+ *
+ * BFS over the implementors map handles multi-level hierarchies (e.g.
+ * IFoo → AbstractFoo → ConcreteFoo) so that abstract intermediate classes
+ * are transparently skipped while their concrete subclasses are still reached.
+ */
+export function resolveChaTargets(
+  typeName: string,
+  methodName: string,
+  chaCtx: ChaContext,
+  lookup: CallNodeLookup,
+): ReadonlyArray<{ id: number; file: string }> {
+  const results: Array<{ id: number; file: string }> = [];
+
+  const queue: string[] = [typeName];
+  const visited = new Set<string>();
+  visited.add(typeName);
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const children = chaCtx.implementors.get(current);
+    if (!children?.length) continue;
+
+    for (const cls of children) {
+      if (visited.has(cls)) continue;
+      visited.add(cls);
+
+      if (chaCtx.instantiatedTypes.has(cls)) {
+        const qualified = `${cls}.${methodName}`;
+        const found = lookup.byName(qualified).filter((n) => n.kind === 'method');
+        results.push(...found);
+      }
+
+      // Traverse even non-instantiated classes — they may have instantiated subclasses.
+      queue.push(cls);
+    }
+  }
+
+  return results;
+}

package/src/domain/graph/builder/context.ts

@@ -68,6 +68,8 @@ export class PipelineContext {
   batchResolved!: Map<string, string> | null;
   reexportMap!: Map<string, unknown[]>;
   barrelOnlyFiles!: Set<string>;
+  /** Phase 8.4: cache for resolveBarrelExport results keyed as "barrelPath|symbolName". */
+  barrelExportCache: Map<string, string | null> = new Map();
 
   // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
   nodesByName!: Map<string, NodeRow[]>;
@@ -88,6 +90,7 @@ export class PipelineContext {
     edgeKind: string;
     confidence: number;
     dynamic: number;
+    technique: string | null;
   }> = [];
 
   // ── Misc state ─────────────────────────────────────────────────────