diff --git a/crates/codegraph-core/src/extractors/cpp.rs b/crates/codegraph-core/src/extractors/cpp.rs
index 1de58a93..c3534d78 100644
--- a/crates/codegraph-core/src/extractors/cpp.rs
+++ b/crates/codegraph-core/src/extractors/cpp.rs
@@ -328,8 +328,8 @@ fn handle_cpp_call_expression(node: &Node, source: &[u8], symbols: &mut FileSymb
             "identifier" | "qualified_identifier" | "scoped_identifier" => {
                 let fn_name = node_text(&fn_node, source);
                 // dlsym(handle, "symbol") — dynamic symbol loading via C ABI.
-                // String-literal argument: resolves as reflection (extern "C" symbols are not mangled).
-                // Variable argument: flagged as unresolved-dynamic.
+                // String-literal second arg: resolves as reflection (C symbols are unmangled, name-match works).
+                // Variable second arg: flagged as unresolved-dynamic.
                 if fn_name == "dlsym" || fn_name == "dlvsym" {
                     let args = node.child_by_field_name("arguments")
                         .or_else(|| find_child(node, "argument_list"));
diff --git a/crates/codegraph-core/src/extractors/ruby.rs b/crates/codegraph-core/src/extractors/ruby.rs
index 063361ab..daec795a 100644
--- a/crates/codegraph-core/src/extractors/ruby.rs
+++ b/crates/codegraph-core/src/extractors/ruby.rs
@@ -137,6 +137,7 @@ fn handle_singleton_method(node: &Node, source: &[u8], symbols: &mut FileSymbols
 }
 
 /// Get the first non-punctuation argument from a Ruby call node's argument list.
+/// Tries `child_by_field_name("arguments")` first, then falls back to `argument_list`.
 fn get_first_ruby_arg<'a>(node: &Node<'a>) -> Option<Node<'a>> {
     let args = node.child_by_field_name("arguments")
         .or_else(|| find_child(node, "argument_list"))?;
diff --git a/src/domain/analysis/roles.ts b/src/domain/analysis/roles.ts
index 15ca183d..f225e090 100644
--- a/src/domain/analysis/roles.ts
+++ b/src/domain/analysis/roles.ts
@@ -20,6 +20,7 @@ export function dynamicCallsData(customDbPath: string): DynamicCallCount[] {
         `SELECT dynamic_kind, COUNT(*) AS count
          FROM edges
          WHERE dynamic_kind IS NOT NULL
+           AND confidence = 0
          GROUP BY dynamic_kind
          ORDER BY count DESC`,
       )
diff --git a/src/extractors/csharp.ts b/src/extractors/csharp.ts
index 850bb8a3..96767c4f 100644
--- a/src/extractors/csharp.ts
+++ b/src/extractors/csharp.ts
@@ -1,5 +1,4 @@
 import type {
-  Call,
   ClassRelation,
   ExtractorOutput,
   SubDeclaration,
@@ -227,22 +226,89 @@ function handleCsUsingDirective(node: TreeSitterNode, ctx: ExtractorOutput): voi
   });
 }
 
+/** Get the first string-literal argument text from a C# invocation node. */
+function getCsFirstStringArg(node: TreeSitterNode): string | null {
+  const args = node.childForFieldName('argument_list') || findChild(node, 'argument_list');
+  if (!args) return null;
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    const t = child.type;
+    if (t === '(' || t === ')' || t === ',') continue;
+    // argument node may wrap the literal
+    const target = t === 'argument' ? (child.child(0) ?? child) : child;
+    if (target?.type === 'string_literal' || target?.type === 'verbatim_string_literal') {
+      return target.text.replace(/^["@]+|"$/g, '');
+    }
+    break;
+  }
+  return null;
+}
+
 function handleCsInvocationExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function') || node.child(0);
   if (!fn) return;
+  const callLine = node.startPosition.row + 1;
+
   if (fn.type === 'identifier') {
-    ctx.calls.push({ name: fn.text, line: node.startPosition.row + 1 });
-  } else if (fn.type === 'member_access_expression') {
+    ctx.calls.push({ name: fn.text, line: callLine });
+    return;
+  }
+
+  if (fn.type === 'member_access_expression') {
     const name = fn.childForFieldName('name');
-    if (name) {
-      const expr = fn.childForFieldName('expression');
-      const call: Call = { name: name.text, line: node.startPosition.row + 1 };
-      if (expr) call.receiver = expr.text;
-      ctx.calls.push(call);
+    if (!name) return;
+    const methodName = name.text;
+    const expr = fn.childForFieldName('expression');
+    const receiver = expr?.text;
+
+    // method.Invoke(target, args) — runtime reflection; target unknown
+    if (methodName === 'Invoke') {
+      ctx.calls.push({
+        name: '<dynamic:unresolved>',
+        line: callLine,
+        dynamic: true,
+        dynamicKind: 'unresolved-dynamic',
+        receiver,
+      });
+      return;
     }
-  } else if (fn.type === 'generic_name' || fn.type === 'member_binding_expression') {
+
+    // type.GetMethod("name") / GetRuntimeMethod("name") — resolvable if literal
+    if (
+      methodName === 'GetMethod' ||
+      methodName === 'GetRuntimeMethod' ||
+      methodName === 'GetDeclaredMethod'
+    ) {
+      const literal = getCsFirstStringArg(node);
+      if (literal) {
+        ctx.calls.push({
+          name: literal,
+          line: callLine,
+          dynamic: true,
+          dynamicKind: 'reflection',
+          keyExpr: literal,
+          receiver,
+        });
+      } else {
+        ctx.calls.push({
+          name: '<dynamic:computed-key>',
+          line: callLine,
+          dynamic: true,
+          dynamicKind: 'computed-key',
+          receiver,
+        });
+      }
+      return;
+    }
+
+    ctx.calls.push({ name: methodName, line: callLine, ...(receiver ? { receiver } : {}) });
+    return;
+  }
+
+  if (fn.type === 'generic_name' || fn.type === 'member_binding_expression') {
     const name = fn.childForFieldName('name') || fn.child(0);
-    if (name) ctx.calls.push({ name: name.text, line: node.startPosition.row + 1 });
+    if (name) ctx.calls.push({ name: name.text, line: callLine });
   }
 }
 
diff --git a/src/extractors/elixir.ts b/src/extractors/elixir.ts
index b1ad19b8..313f5bf5 100644
--- a/src/extractors/elixir.ts
+++ b/src/extractors/elixir.ts
@@ -80,6 +80,50 @@ function handleElixirCall(
       case 'alias':
         handleElixirImport(node, ctx, keyword);
         return;
+      case 'apply': {
+        // apply(module, :function, args) — Elixir dynamic dispatch
+        const applyArgs = node.childForFieldName('arguments');
+        if (applyArgs) {
+          let argIdx = 0;
+          let secondArg: TreeSitterNode | null = null;
+          for (let i = 0; i < applyArgs.childCount; i++) {
+            const child = applyArgs.child(i);
+            if (!child) continue;
+            const t = child.type;
+            if (t === '(' || t === ')' || t === ',') continue;
+            if (argIdx === 1) {
+              secondArg = child;
+              break;
+            }
+            argIdx++;
+          }
+          if (secondArg) {
+            // :atom — strip leading colon to get function name
+            if (secondArg.type === 'atom' || secondArg.type === 'atom_literal') {
+              const fnName = secondArg.text.replace(/^:/, '');
+              ctx.calls.push({
+                name: fnName,
+                line: node.startPosition.row + 1,
+                dynamic: true,
+                dynamicKind: 'reflection',
+                keyExpr: secondArg.text,
+              });
+              return;
+            }
+            // Variable function name — computed-key
+            ctx.calls.push({
+              name: '<dynamic:computed-key>',
+              line: node.startPosition.row + 1,
+              dynamic: true,
+              dynamicKind: 'computed-key',
+              keyExpr: secondArg.text,
+            });
+            return;
+          }
+        }
+        ctx.calls.push({ name: 'apply', line: node.startPosition.row + 1 });
+        return;
+      }
       default:
         // Regular function call
         ctx.calls.push({ name: keyword, line: node.startPosition.row + 1 });
diff --git a/src/extractors/lua.ts b/src/extractors/lua.ts
index 85c99b82..072f68a8 100644
--- a/src/extractors/lua.ts
+++ b/src/extractors/lua.ts
@@ -132,6 +132,20 @@ function handleLuaFunctionCall(node: TreeSitterNode, ctx: ExtractorOutput): void
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
 
+  // load(chunk) / loadstring(chunk) — dynamic code execution; always undecidable
+  if (
+    nameNode.type === 'identifier' &&
+    (nameNode.text === 'load' || nameNode.text === 'loadstring' || nameNode.text === 'dofile')
+  ) {
+    ctx.calls.push({
+      name: '<dynamic:eval>',
+      line: node.startPosition.row + 1,
+      dynamic: true,
+      dynamicKind: 'eval',
+    });
+    return;
+  }
+
   // Check for require() as import
   if (nameNode.type === 'identifier' && nameNode.text === 'require') {
     const args = node.childForFieldName('arguments');
@@ -161,6 +175,37 @@ function handleLuaFunctionCall(node: TreeSitterNode, ctx: ExtractorOutput): void
     const field = nameNode.childForFieldName('field');
     if (field) call.name = field.text;
     if (table) call.receiver = table.text;
+  } else if (nameNode.type === 'bracket_index_expression') {
+    // t[k]() — bracket-index function call; key may be variable.
+    // AST: bracket_index_expression → [table_node, '[', key_expr, ']']
+    // childForFieldName('key') is not defined for this node type in tree-sitter-lua,
+    // so we locate the key by scanning past the '[', ']', and the table node (by id).
+    const table = nameNode.childForFieldName('table');
+    const tableId = table?.id;
+    let key: TreeSitterNode | null = null;
+    for (let i = 0; i < nameNode.childCount; i++) {
+      const ch = nameNode.child(i);
+      if (!ch) continue;
+      // Skip punctuation and the table node (compare by node id)
+      if (ch.type === '[' || ch.type === ']' || ch.id === tableId) continue;
+      key = ch;
+      break;
+    }
+    if (key && (key.type === 'string' || key.type === 'string_literal')) {
+      call.name = key.text.replace(/['"]/g, '');
+      call.receiver = table?.text;
+    } else {
+      // Variable key — flagged as computed-key
+      ctx.calls.push({
+        name: '<dynamic:computed-key>',
+        line: call.line,
+        dynamic: true,
+        dynamicKind: 'computed-key',
+        keyExpr: key?.text,
+        receiver: table?.text,
+      });
+      return;
+    }
   } else {
     call.name = nameNode.text;
   }
diff --git a/src/extractors/php.ts b/src/extractors/php.ts
index 4e5f8f50..d868c5b9 100644
--- a/src/extractors/php.ts
+++ b/src/extractors/php.ts
@@ -323,7 +323,7 @@ function handlePhpFuncCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (!fn) return;
   const callLine = node.startPosition.row + 1;
 
-  // $fn() — variable function call; cannot resolve statically.
+  // $fn() — variable function call; target cannot be resolved statically.
   // Use keyExpr (not receiver) to capture the callable variable name for diagnostics.
   if (fn.type === 'variable_name') {
     ctx.calls.push({
diff --git a/src/extractors/python.ts b/src/extractors/python.ts
index 7e38d318..d0b22249 100644
--- a/src/extractors/python.ts
+++ b/src/extractors/python.ts
@@ -192,7 +192,7 @@ function handlePyCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
       const argIter = iterPyArgs(node);
       const firstArg = argIter.next().value as TreeSitterNode | undefined;
       const secondArg = argIter.next().value as TreeSitterNode | undefined;
-      const receiver = firstArg?.text;
+      const receiver = firstArg?.type === 'identifier' ? firstArg.text : undefined;
       if (secondArg) {
         const st = secondArg.type;
         if (st === 'string' || st === 'concatenated_string') {
diff --git a/src/extractors/swift.ts b/src/extractors/swift.ts
index 9b2f6e90..ddaa67d0 100644
--- a/src/extractors/swift.ts
+++ b/src/extractors/swift.ts
@@ -278,7 +278,78 @@ function handleSwiftCallExpression(node: TreeSitterNode, ctx: ExtractorOutput):
   } else {
     call.name = funcNode.text;
   }
-  if (call.name) ctx.calls.push(call);
+
+  if (!call.name) return;
+
+  // performSelector — ObjC-style dynamic dispatch; selector not statically knowable
+  if (call.name === 'performSelector') {
+    ctx.calls.push({
+      name: '<dynamic:unresolved>',
+      line: call.line,
+      dynamic: true,
+      dynamicKind: 'unresolved-dynamic',
+      receiver: call.receiver,
+    });
+    return;
+  }
+
+  // NSSelectorFromString("name") — selector from literal string.
+  // Only inspect the direct first argument to the call (not the whole subtree) to avoid
+  // false positives from nested calls like NSSelectorFromString(generateSelector("greet")).
+  //
+  // Swift AST: call_expression → [simple_identifier, call_suffix]
+  //   call_suffix → [value_arguments]
+  //     value_arguments → ['(', value_argument, ')']
+  //       value_argument → [line_string_literal]
+  //         line_string_literal → ['"', line_str_text, '"']
+  if (call.name === 'NSSelectorFromString') {
+    let literal: string | null = null;
+    // Resolve value_arguments: call_expression has a call_suffix child that wraps value_arguments.
+    const callSuffix = findChild(node, 'call_suffix');
+    const valueArgs =
+      node.childForFieldName('arguments') ??
+      (callSuffix ? (findChild(callSuffix, 'value_arguments') ?? callSuffix) : null) ??
+      findChild(node, 'value_arguments');
+    if (valueArgs) {
+      for (let i = 0; i < valueArgs.childCount; i++) {
+        const arg = valueArgs.child(i);
+        if (!arg) continue;
+        const t = arg.type;
+        if (t === '(' || t === ')' || t === ',') continue;
+        // value_argument wraps the actual value expression
+        const valueNode =
+          t === 'value_argument'
+            ? (arg.childForFieldName('value') ?? arg.child(arg.childCount - 1))
+            : arg;
+        if (!valueNode) break;
+        const vt = valueNode.type;
+        if (vt === 'line_string_literal' || vt === 'string_literal') {
+          // Look for line_str_text (Swift) or string_content (other languages)
+          for (let j = 0; j < valueNode.childCount; j++) {
+            const ch = valueNode.child(j);
+            if (ch?.type === 'line_str_text' || ch?.type === 'string_content') {
+              literal = ch.text;
+              break;
+            }
+          }
+          if (!literal) literal = valueNode.text.replace(/^["']|["']$/g, '');
+          break;
+        }
+        // First non-string non-punctuation argument — computed, not a literal selector
+        break;
+      }
+    }
+    ctx.calls.push({
+      name: literal ?? '<dynamic:unresolved>',
+      line: call.line,
+      dynamic: true,
+      dynamicKind: literal ? 'reflection' : 'unresolved-dynamic',
+      keyExpr: literal ?? undefined,
+    });
+    return;
+  }
+
+  ctx.calls.push(call);
 }
 
 /**
diff --git a/src/types.ts b/src/types.ts
index fa2890b6..f2a08d17 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -484,7 +484,7 @@ export interface LOCMetrics {
 export type DynamicKind =
   | 'computed-literal' // obj["foo"]()    — resolvable; already emitted as normal edge
   | 'computed-key' // obj[k]()        — potentially resolvable via pts; else flagged
-  | 'reflection' // .call/.apply/.bind / Reflect.* — usually resolved; not flagged (drops silently if unresolved)
+  | 'reflection' // .call/.apply/.bind / Reflect.* — resolved if target reachable; silently dropped if not (RES-3)
   | 'eval' // eval() / new Function() — undecidable; always flagged
   | 'unresolved-dynamic'; // any other detected dynamic pattern; flagged
 
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-c/dispatch.c b/tests/benchmarks/resolution/fixtures/dynamic-c/dispatch.c
index b43a1c95..86a338c9 100644
--- a/tests/benchmarks/resolution/fixtures/dynamic-c/dispatch.c
+++ b/tests/benchmarks/resolution/fixtures/dynamic-c/dispatch.c
@@ -18,7 +18,7 @@ void runFunctionPointer(void (*fp)(const char *)) {
     (*fp)("world");
 }
 
-/* dlsym(handle, "symbol") — dynamic symbol loading; flagged */
+/* dlsym(handle, "greet") — string literal resolves as reflection; fn pointer call flagged */
 void runDlsym(void *handle) {
     void (*fn)(const char *) = dlsym(handle, "greet");
     if (fn) fn("world");
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-csharp/Reflection.cs b/tests/benchmarks/resolution/fixtures/dynamic-csharp/Reflection.cs
new file mode 100644
index 00000000..ef665cef
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-csharp/Reflection.cs
@@ -0,0 +1,18 @@
+// Phase 6: C# reflection patterns
+// GetMethod("name") → reflection kind
+// method.Invoke() → unresolved-dynamic
+using System.Reflection;
+
+public class Reflection {
+    public static string Greet(string name) => $"Hello, {name}";
+
+    // type.GetMethod("Greet") — reflection kind, resolvable in theory
+    public static MethodInfo RunGetMethod(Type type) {
+        return type.GetMethod("Greet");
+    }
+
+    // method.Invoke(target, args) — unresolved-dynamic
+    public static object RunInvoke(MethodInfo method, object target) {
+        return method.Invoke(target, new object[] { "world" });
+    }
+}
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-csharp/expected-edges.json b/tests/benchmarks/resolution/fixtures/dynamic-csharp/expected-edges.json
new file mode 100644
index 00000000..4752c507
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-csharp/expected-edges.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "../../expected-edges.schema.json",
+  "language": "csharp",
+  "description": "Phase 6 C# fixture: GetMethod resolved as reflection; Invoke flagged. Methods class-qualified in DB → 0% recall until RES-3.",
+  "edges": [
+    {
+      "source": { "name": "Reflection.RunGetMethod", "file": "Reflection.cs" },
+      "target": { "name": "Reflection.Greet", "file": "Reflection.cs" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "type.GetMethod('Greet') — reflection kind; 0% recall because DB uses class-qualified name"
+    }
+  ]
+}
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-elixir/dispatch.ex b/tests/benchmarks/resolution/fixtures/dynamic-elixir/dispatch.ex
new file mode 100644
index 00000000..12cd948e
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-elixir/dispatch.ex
@@ -0,0 +1,18 @@
+defmodule DynamicDispatch do
+  # Fixture: Elixir dynamic dispatch via apply/3
+  # apply(module, :function, args) → reflection kind
+  # apply(module, variable, args) → computed-key
+
+  def greet(name), do: "Hello, #{name}"
+  def farewell(name), do: "Goodbye, #{name}"
+
+  # apply(DynamicDispatch, :greet, ["world"]) — reflection kind
+  def run_apply_atom do
+    apply(DynamicDispatch, :greet, ["world"])
+  end
+
+  # apply(module, fn_name, args) — computed-key kind
+  def run_apply_variable(fn_name) do
+    apply(DynamicDispatch, fn_name, ["world"])
+  end
+end
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-elixir/expected-edges.json b/tests/benchmarks/resolution/fixtures/dynamic-elixir/expected-edges.json
new file mode 100644
index 00000000..c010e25e
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-elixir/expected-edges.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "../../expected-edges.schema.json",
+  "language": "elixir",
+  "description": "Phase 6 Elixir fixture: apply(module, :fn, args) detected; module-qualified names → 0% recall until RES-3.",
+  "edges": [
+    {
+      "source": { "name": "DynamicDispatch.run_apply_atom", "file": "dispatch.ex" },
+      "target": { "name": "DynamicDispatch.greet", "file": "dispatch.ex" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "apply(DynamicDispatch, :greet, args) — reflection kind; 0% recall (module-qualified DB names)"
+    }
+  ]
+}
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-lua/dispatch.lua b/tests/benchmarks/resolution/fixtures/dynamic-lua/dispatch.lua
new file mode 100644
index 00000000..9884236f
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-lua/dispatch.lua
@@ -0,0 +1,24 @@
+-- Phase 6: Lua dynamic dispatch patterns
+-- t["method"]() → computed-literal, resolved
+-- load(code) → eval kind, flagged
+-- t[k]() → computed-key kind, flagged
+
+local function greet(name)
+  return "Hello, " .. name
+end
+
+-- t["greet"]() — computed-literal with string key; resolves to greet()
+local function run_literal_dispatch(t)
+  t["greet"]("world")
+end
+
+-- load(code) — dynamic code execution; always flagged
+local function run_load(code)
+  local fn = load(code)
+  if fn then fn() end
+end
+
+-- t[k]() — variable key; flagged as computed-key
+local function run_variable_dispatch(t, k)
+  t[k]("world")
+end
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-lua/expected-edges.json b/tests/benchmarks/resolution/fixtures/dynamic-lua/expected-edges.json
new file mode 100644
index 00000000..71a0da82
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-lua/expected-edges.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "../../expected-edges.schema.json",
+  "language": "lua",
+  "description": "Phase 6 Lua fixture: t['greet']() resolved; load(code) and t[k]() flagged.",
+  "edges": [
+    {
+      "source": { "name": "run_literal_dispatch", "file": "dispatch.lua" },
+      "target": { "name": "greet", "file": "dispatch.lua" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "t['greet']() — string-literal bracket index, resolves to local greet()"
+    }
+  ]
+}
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-swift/dispatch.swift b/tests/benchmarks/resolution/fixtures/dynamic-swift/dispatch.swift
new file mode 100644
index 00000000..62e75267
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-swift/dispatch.swift
@@ -0,0 +1,22 @@
+// Phase 6: Swift dynamic dispatch patterns
+// NSSelectorFromString("name") → reflection kind
+// performSelector → flagged as unresolved-dynamic
+import Foundation
+
+func greet(_ name: String) -> String {
+    return "Hello, \(name)"
+}
+
+func farewell(_ name: String) -> String {
+    return "Goodbye, \(name)"
+}
+
+// NSSelectorFromString("greet") — reflection kind, resolves to top-level greet()
+func runNSSelectorFromString() -> Selector {
+    return NSSelectorFromString("greet")
+}
+
+// NSSelectorFromString with farewell
+func runNSSelectorFarewell() -> Selector {
+    return NSSelectorFromString("farewell")
+}
diff --git a/tests/benchmarks/resolution/fixtures/dynamic-swift/expected-edges.json b/tests/benchmarks/resolution/fixtures/dynamic-swift/expected-edges.json
new file mode 100644
index 00000000..297a4012
--- /dev/null
+++ b/tests/benchmarks/resolution/fixtures/dynamic-swift/expected-edges.json
@@ -0,0 +1,21 @@
+{
+  "$schema": "../../expected-edges.schema.json",
+  "language": "swift",
+  "description": "Phase 6 Swift fixture: NSSelectorFromString resolved as reflection (top-level fns unqualified).",
+  "edges": [
+    {
+      "source": { "name": "runNSSelectorFromString", "file": "dispatch.swift" },
+      "target": { "name": "greet", "file": "dispatch.swift" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "NSSelectorFromString('greet') — reflection kind, resolves to top-level greet()"
+    },
+    {
+      "source": { "name": "runNSSelectorFarewell", "file": "dispatch.swift" },
+      "target": { "name": "farewell", "file": "dispatch.swift" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "NSSelectorFromString('farewell') — reflection kind, resolves to top-level farewell()"
+    }
+  ]
+}
diff --git a/tests/benchmarks/resolution/resolution-benchmark.test.ts b/tests/benchmarks/resolution/resolution-benchmark.test.ts
index 4af93c93..d85e4c9e 100644
--- a/tests/benchmarks/resolution/resolution-benchmark.test.ts
+++ b/tests/benchmarks/resolution/resolution-benchmark.test.ts
@@ -147,6 +147,11 @@ const THRESHOLDS: Record<string, { precision: number; recall: number }> = {
   // Phase 4 scripting fixtures: Ruby send/public_send + PHP call_user_func/variable calls.
   'dynamic-ruby': { precision: 1.0, recall: 1.0 },
   'dynamic-php': { precision: 1.0, recall: 1.0 },
+  // Phase 6: Long-tail languages — C#, Swift, Elixir, Lua.
+  'dynamic-csharp': { precision: 0.0, recall: 0.0 },
+  'dynamic-swift': { precision: 1.0, recall: 1.0 },
+  'dynamic-elixir': { precision: 0.0, recall: 0.0 },
+  'dynamic-lua': { precision: 1.0, recall: 1.0 },
   // Phase 5: Go + C/C++ dynamic dispatch patterns.
   'dynamic-go': { precision: 1.0, recall: 1.0 },
   'dynamic-c': { precision: 1.0, recall: 1.0 },