@@ -760,6 +760,59 @@ call_site_unresolved(site, caller, r, kind) :-
     site_class(site, "ambiguous_unknown"), site_caller(site, caller),
     site_reason(site, r), invocation_site(site, kind).
 
+// ── unresolved_value_callee(SiteKey, Binding) ────────────────────────────────
+// An unresolved call whose callee is a VALUE, not a name: `cb()` on a parameter, `f()`
+// on a loop or comprehension variable, `table[k]()`, `hook()` on what getattr returned,
+// `self.cb()` on a function stored in a field. Nothing about the name narrows what it
+// calls, so a question that finds no chain from its caller must answer "unknown", never
+// "independent" (the same relation, and the same Binding words, as the JavaScript rules).
+// A call on an untyped receiver (`obj.save()`) is not one: its name is the lead the
+// by-name search follows.
+// `cls(...)` in a classmethod constructs the class or a subclass of it, never an arbitrary
+// function, so it is not one.
+value_callee_site(site, c) :-
+    site_class(site, "ambiguous_unknown"), call_callee_is_value(site), call_callee_expr(site, c),
+    !expr_node("client", "CLS_REFERENCE", _, _, c).
+value_callee_binding(site, origin, kind, b2) :-
+    value_callee_site(site, c), expr_binding("client", b, ctx, c), ctx != "STORE",
+    binding_lookup("client", b, b2), binding_decl("client", _, _, kind, origin, b2).
+// what a local was assigned, when that is a getattr call: the attribute is picked by a
+// name the program computes
+value_callee_from_getattr(site) :-
+    value_callee_binding(site, _, _, b2), expr_binding("client", b2, "STORE", tgt),
+    assign_pair("client", tgt, val), call_of_expr(val, g), call_name(g, "getattr").
+value_callee_from_getattr(site) :-
+    value_callee_site(site, c), call_of_expr(c, g), call_name(g, "getattr").
+unresolved_value_callee(site, "getattr") :- value_callee_from_getattr(site).
+unresolved_value_callee(site, "parameter") :-
+    value_callee_binding(site, origin, _, _), (origin = "PARAMETER" ; origin = "LAMBDA_PARAM").
+unresolved_value_callee(site, "loop_variable") :-
+    value_callee_binding(site, origin, _, _), (origin = "FOR_TARGET" ; origin = "COMPREHENSION_TARGET").
+value_callee_names_value(origin) :- binding_decl("client", _, _, _, origin, _),
+    origin != "PARAMETER", origin != "LAMBDA_PARAM", origin != "FOR_TARGET", origin != "COMPREHENSION_TARGET",
+    origin != "FUNCTION_DEF", origin != "CLASS_DEF", origin != "IMPORT", origin != "TYPE_PARAM",
+    origin != "TYPE_ALIAS", origin != "MULTIPLE".
+unresolved_value_callee(site, "local") :-
+    value_callee_binding(site, origin, "LOCAL", _), value_callee_names_value(origin),
+    !value_callee_from_getattr(site).
+unresolved_value_callee(site, "module_variable") :-
+    value_callee_binding(site, origin, kind, _), kind != "LOCAL", value_callee_names_value(origin),
+    !value_callee_from_getattr(site).
+// `table[k]()`: an element of a collection
+unresolved_value_callee(site, "computed") :-
+    value_callee_site(site, c), expr_node("client", "SUBSCRIPT", _, _, c).
+// `make()()`, `(a or b)()`: the callee is what an expression evaluates to
+unresolved_value_callee(site, "expression") :-
+    value_callee_site(site, c), expr_node("client", k, _, _, c),
+    k != "NAME_REFERENCE", k != "SUBSCRIPT", k != "CLS_REFERENCE", k != "ATTRIBUTE_ACCESS",
+    !value_callee_from_getattr(site).
+// `self.cb()` where the class gives `cb` a field and no method: the function stored
+// there is whatever the constructor or a setter was handed
+unresolved_value_callee(site, "field") :-
+    site_class(site, "ambiguous_unknown"), invocation_site(site, "SELF_CALL"),
+    call_name(site, n), call_enclosing_type(site, t),
+    type_defines_field("client", t, n, _), !mro_lookup("client", t, n, _).
+
 // ── method_has_unknown_call(CallerMethodHash, SiteKey) ───────────────────────
 method_has_unknown_call(caller, site) :-
     site_class(site, "ambiguous_unknown"), site_caller(site, caller).
 
@@ -596,6 +596,11 @@
 .decl site_is_decorator(c0:symbol)
 .decl call_chain_edge(c0:symbol,c1:symbol,c2:symbol,c3:symbol,c4:symbol,c5:symbol,c6:symbol)
 .decl call_site_unresolved(c0:symbol,c1:symbol,c2:symbol,c3:symbol)
+.decl value_callee_site(c0:symbol,c1:symbol)
+.decl value_callee_binding(c0:symbol,c1:symbol,c2:symbol,c3:symbol)
+.decl value_callee_from_getattr(c0:symbol)
+.decl value_callee_names_value(c0:symbol)
+.decl unresolved_value_callee(c0:symbol,c1:symbol)
 .decl method_has_unknown_call(c0:symbol,c1:symbol)
 .decl call_chain_summary(c0:symbol,c1:number)
 .decl module_is_stub(c0:symbol,c1:symbol)
 
@@ -1,5 +1,6 @@
 call_chain_edge	call-chain-edges.csv
 call_site_unresolved	call-site-unresolved.csv
+unresolved_value_callee	unresolved-value-callee.csv
 call_chain_summary	call-chain-summary.csv
 mro_position	resolution-mro-position.csv
 mro_tie	resolution-mro-tie.csv
 
@@ -79,7 +79,11 @@
                 # framework hop -- the registration decorator, the dispatch method, the
                 # route table, the marker -- are catalogues in config-resolution/knobs.dl,
                 # which is the one file a reviewer reads to see every name assumed.
-                "framework_edge(", "framework_unjoined(")
+                "framework_edge(", "framework_unjoined(",
+                # unresolved_value_callee's second column is `binding`: WHAT the callee of an
+                # unresolved call is ("parameter", "loop_variable", "field", ...), the same words
+                # the JavaScript rules write. Written into the output and never joined on.
+                "unresolved_value_callee(")
 
 
 GROUND_FACT = re.compile(r'^[a-z_]+\((?:\s*"[^"]*"\s*,?)+\)\.\s*$')
 
@@ -1589,8 +1589,13 @@ def path(g, a, b, show_all=False, limit=10, every=False, max_paths=20):
            'field': 'a function stored in a field',
            'instance_member': 'a function stored on the instance from outside the class',
            'parameter_member': 'a member of a parameter', 'expression': 'computed by an expression',
+           'getattr': 'an attribute looked up by a name computed at run time',
            'imported_variable': "another module's exported variable, which that module reassigns"}
     for lx, rows in opaque:
+        # the sites that make the answer unknown, in --json too: a consumer reading only `answers` saw "no chain"
+        RESULT['value_calls'] = RESULT.get('value_calls', []) + [
+            {'side': lx, 'caller': g.disp(r['c']), 'callee': r['n'] or '', 'at': f"{g.site_file(r['f'])}:{r['ln']}",
+             'callee_is': WHY.get(r['why'], r['why'])} for r in rows[:50]]
         print(f"  {lx} reaches {len(rows)} call(s) through a value:")
         for r in rows[:4]:
             print(f"    `{r['n'] or '[…]'}()` in {g.disp(r['c'])} at {g.site_file(r['f'])}:{r['ln']} — the callee is {WHY.get(r['why'], r['why'])}")
 
@@ -0,0 +1,211 @@
+{
+ "lang": "python",
+ "src": "src",
+ "checks": [
+  {
+   "why": "invoke calls a parameter: the callee can be any function handed to it, so path says unknown and names the site",
+   "run": [
+    "path",
+    "invoke",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`cb()` in invoke at src/handlers.py:23 — the callee is a parameter"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "run_list calls a loop variable",
+   "run": [
+    "path",
+    "run_list",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`f()` in run_list at src/handlers.py:28 — the callee is a loop variable"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "dispatch calls an element of a collection (table[key]())",
+   "run": [
+    "path",
+    "dispatch",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "in dispatch at src/handlers.py:32 — the callee is a computed member"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "via_local calls a local that holds whatever a lookup returned",
+   "run": [
+    "path",
+    "via_local",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`fn()` in via_local at src/handlers.py:37 — the callee is a local"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "fire calls a local holding getattr(self, f'on_{event}'): the site is named, and the target is not called independent",
+   "run": [
+    "path",
+    "Machine.fire",
+    "Machine.on_go"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`hook()` in Machine.fire at src/handlers.py:44 — the callee is an attribute looked up by a name computed at run time"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "control: getattr(self, 'on_' + event)() is resolved through its literal prefix, so it is a chain, not an unknown",
+   "run": [
+    "path",
+    "Machine.fire_now",
+    "Machine.on_go"
+   ],
+   "want": [
+    "Machine.fire_now → Machine.on_go: 1 of 1 target(s) reached"
+   ],
+   "avoid": [
+    "connection is UNKNOWN, not absent"
+   ]
+  },
+  {
+   "why": "assess calls each element of a stored collection of callables inside a comprehension",
+   "run": [
+    "path",
+    "Scoring.assess",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`scorer()` in Scoring.assess at src/handlers.py:58 — the callee is a loop variable"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "run calls a function stored in a field by the constructor",
+   "run": [
+    "path",
+    "Hooked.run",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`cb()` in Hooked.run at src/handlers.py:66 — the callee is a function stored in a field"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "the reverse question is the same connection: the value call is on the other side",
+   "run": [
+    "path",
+    "alpha",
+    "invoke"
+   ],
+   "expect_error": true,
+   "want": [
+    "connection is UNKNOWN, not absent",
+    "`cb()` in invoke"
+   ],
+   "avoid": [
+    "the two are independent in this graph"
+   ]
+  },
+  {
+   "why": "control: a function that calls nothing stays independent",
+   "run": [
+    "path",
+    "pure",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "the two are independent in this graph"
+   ],
+   "avoid": [
+    "connection is UNKNOWN, not absent",
+    "through a value"
+   ]
+  },
+  {
+   "why": "control: a call on an imported module's member names a library function, not a value",
+   "run": [
+    "path",
+    "joins",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "the two are independent in this graph"
+   ],
+   "avoid": [
+    "connection is UNKNOWN, not absent",
+    "through a value"
+   ]
+  },
+  {
+   "why": "control: cls(...) in a classmethod constructs the class, so it is not a call through a value even when the class has a library base",
+   "run": [
+    "path",
+    "Money.of",
+    "alpha"
+   ],
+   "expect_error": true,
+   "want": [
+    "no chain of resolved calls connects Money.of and alpha"
+   ],
+   "avoid": [
+    "connection is UNKNOWN, not absent",
+    "through a value",
+    "`cls()`"
+   ]
+  },
+  {
+   "why": "control: a resolved call is still a chain",
+   "run": [
+    "path",
+    "direct",
+    "alpha"
+   ],
+   "want": [
+    "direct → alpha: 1 of 1 target(s) reached"
+   ],
+   "avoid": [
+    "connection is UNKNOWN, not absent"
+   ]
+  }
+ ]
+}
@@ -0,0 +1,74 @@
+import os
+
+from pydantic import BaseModel
+
+
+def alpha():
+    return 1
+
+
+def pure():
+    return 2
+
+
+def direct():
+    return alpha()
+
+
+def joins(parts):
+    return os.path.join(*parts)
+
+
+def invoke(cb):
+    return cb()
+
+
+def run_list(fns):
+    for f in fns:
+        f()
+
+
+def dispatch(table, key):
+    return table[key]()
+
+
+def via_local(name):
+    fn = globals().get(name)
+    return fn()
+
+
+class Machine:
+    def fire(self, event):
+        hook = getattr(self, f"on_{event}", None)
+        if hook is not None:
+            hook()
+
+    def fire_now(self, event):
+        return getattr(self, "on_" + event)()
+
+    def on_go(self):
+        return 3
+
+
+class Scoring:
+    def __init__(self, scorers):
+        self.scorers = scorers
+
+    def assess(self, ctx):
+        return [scorer(ctx) for scorer in self.scorers]
+
+
+class Hooked:
+    def __init__(self, cb):
+        self.cb = cb
+
+    def run(self):
+        return self.cb()
+
+
+class Money(BaseModel):
+    amount: int
+
+    @classmethod
+    def of(cls, amount: int) -> "Money":
+        return cls(amount=amount)