@@ -1672,14 +1672,14 @@ def flows_to_argument(self, src: str, callee: str, arg: str, *, within: str, dep
     #: are one, its interior the other). The ``:PyBodyNode`` and ``:PyExternal`` arms return
     #: ``null`` code deliberately: the graph carries no text below callable granularity, and a
     #: ghost was never analysed, so those rows say "found, and there is nothing to read", which is
-    #: what keeps that apart from "not found" (see :meth:`PythonAnalysisBackend.describe`). Only
-    #: the callable arm carries the prefix predicate: a body-node id and a ghost id both embed the
-    #: application, while a signature does not.
+    #: what keeps that apart from "not found" (see :meth:`PythonAnalysisBackend.describe`). All
+    #: three arms carry the prefix predicate: a ref naming another application's node must read as
+    #: "not found" here, not as "found, with nothing to read".
     _SOURCES = (
         "MATCH (c:PyCallable) WHERE c.id STARTS WITH $prefix AND (c.id IN $refs OR c.signature IN $refs) "
         "RETURN c.id AS id, c.signature AS sig, c.code AS code "
-        "UNION MATCH (b:PyBodyNode) WHERE b.id IN $refs RETURN b.id AS id, null AS sig, null AS code "
-        "UNION MATCH (e:PyExternal) WHERE e.id IN $refs RETURN e.id AS id, null AS sig, null AS code"
+        "UNION MATCH (b:PyBodyNode) WHERE b.id STARTS WITH $prefix AND b.id IN $refs RETURN b.id AS id, null AS sig, null AS code "
+        "UNION MATCH (e:PyExternal) WHERE e.id STARTS WITH $prefix AND e.id IN $refs RETURN e.id AS id, null AS sig, null AS code"
     )
 
     def _sources_for(self, refs: Sequence[str]) -> Dict[str, "str | None"]:
 
@@ -45,8 +45,10 @@
 
 from __future__ import annotations
 
+import ast
 import inspect
 import re
+from collections import defaultdict
 from typing import Any, Dict, List
 
 import pytest
@@ -79,8 +81,8 @@ def _node(module: str, key: str, **props: Any) -> Dict[str, Any]:
     "class_methods": (
         CLASS_SIG,
         {
-            APP_A_MODULE: _node(APP_A_MODULE, "Widget/render", signature=METHOD_SIG, name="alpha_method", path=APP_A_MODULE),
-            APP_B_MODULE: _node(APP_B_MODULE, "Widget/render", signature=METHOD_SIG, name="beta_method", path=APP_B_MODULE),
+            APP_A_MODULE: _node(APP_A_MODULE, "Widget/render", signature=METHOD_SIG, name="alpha_method", path=APP_A_MODULE, code="alpha code"),
+            APP_B_MODULE: _node(APP_B_MODULE, "Widget/render", signature=METHOD_SIG, name="beta_method", path=APP_B_MODULE, code="beta code"),
         },
     ),
     "class_attributes": (
@@ -145,6 +147,14 @@ def _node(module: str, key: str, **props: Any) -> Dict[str, Any]:
     _node(APP_B_MODULE, "Widget", signature=CLASS_SIG, name="Widget", path=APP_B_MODULE),
 ]
 
+#: What ``_SOURCES`` (``describe``) may be handed, per label and per application: the shared method
+#: (by signature), each application's one call-site body node, and one ``@external`` ghost each.
+_SOURCE_NODES: Dict[str, List[Dict[str, Any]]] = {
+    "PyCallable": list(_CHILDREN["class_methods"][1].values()),
+    "PyBodyNode": list(_CHILDREN["callable_callsites"][1].values()),
+    "PyExternal": [{"id": f"can://python/{app}/@external/os/path", "name": "path", "module": "os"} for app in (APP_A, APP_B)],
+}
+
 #: The three spellings of the application scope a statement may carry: the whole application
 #: (``$prefix``); for a narrowed bulk fetch, a list of per-module prefixes (``$prefixes``); and for
 #: ``locate``, one module's own prefix per position (``pos.module_prefix``, minted from the same
@@ -198,6 +208,14 @@ def _in_scope(query: str, params: Dict[str, Any], props: Dict[str, Any]) -> bool
 
 def _fake_two_app_cypher(query: str, **params: Any) -> List[Dict[str, Any]]:
     """Answer the statements a class reconstruction issues, honestly (see :func:`_in_scope`)."""
+    if "UNION MATCH (b:PyBodyNode)" in query:  # _SOURCES: three arms, each judged on its own predicate
+        rows = []
+        for arm in query.split(" UNION "):
+            label = re.search(r"MATCH \(\w+:(\w+)\)", arm)[1]
+            for props in _SOURCE_NODES[label]:
+                if (props["id"] in params["refs"] or props.get("signature") in params["refs"]) and _in_scope(arm, params, props):
+                    rows.append({"id": props["id"], "sig": props.get("signature"), "code": props.get("code")})
+        return rows
     bucket = _bucket_of(query)
     if bucket == "module_functions":
         # Keyed by file_key: the per-parent twin names it (``$fk``), the bulk twin lists the scope
@@ -307,6 +325,18 @@ def test_a_module_key_shared_by_two_applications_does_not_leak(bulk: bool):
     assert set(module.functions) == {"alpha_fn"}, "the module-keyed fetch leaked another application's function"
 
 
+def test_describe_does_not_find_another_applications_body_nodes_or_ghosts():
+    """``_SOURCES`` answers ``describe`` for callables, body nodes and ghosts in one statement. A
+    body-node or ghost id embeds its application, but "found, with nothing to read" and "not found"
+    are different answers, and a ref from another application must get the second -- so every arm
+    carries the prefix, not only the callable one, and the shared signature resolves to A's code."""
+    backend = _two_app_backend()
+    a_body, b_body = (n["id"] for n in _SOURCE_NODES["PyBodyNode"])
+    a_ghost, b_ghost = (n["id"] for n in _SOURCE_NODES["PyExternal"])
+    found = backend._sources_for([METHOD_SIG, a_body, b_body, a_ghost, b_ghost])
+    assert found == {METHOD_SIG: "alpha code", a_body: None, a_ghost: None}
+
+
 def test_every_child_statement_carries_the_application_scope():
     """The four module-keyed collections cannot be caught by the fixture above (see the module
     docstring), so they are caught here: every statement either path issues to fetch children is
@@ -345,13 +375,107 @@ def _class_level_statements() -> Dict[str, str]:
     }
 
 
+def _inline_statements() -> Dict[str, str]:
+    """The Cypher written *inline* at every ``self._run(`` site, keyed ``<method>@<line>`` -- the
+    statements the class-attribute enumeration cannot see (about twenty of the 44 sites).
+
+    Reassembled from the class's own source: string constants verbatim; f-strings and ``+`` chains
+    joined; ``.format(...)`` unwrapped to its receiver; ``self.<ATTR>`` replaced by the class-level
+    string it names; a local name replaced by every assignment to it in the enclosing method, in
+    order (``query += " AND ..."``); anything else becomes ``{…}``. A site whose first argument is
+    a bare parameter or a lookup resolves to ``{…}`` alone -- ``_children`` (its callers' literals
+    are judged by the child walk above), ``_collect`` (``_BULK_CHILD_QUERIES``, judged directly)
+    and ``_paths`` (``_PATHS`` / ``_CALL_PATHS``, class-level) -- and is reported as such.
+    """
+    class_strings = {name: value for name, value in vars(PyNeo4jBackend).items() if isinstance(value, str)}
+    out: Dict[str, str] = {}
+    for fn in ast.walk(ast.parse(inspect.getsource(PyNeo4jBackend))):
+        if not isinstance(fn, ast.FunctionDef):
+            continue
+        assigned: Dict[str, List[ast.expr]] = defaultdict(list)
+        for node in ast.walk(fn):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        assigned[target.id].append(node.value)
+            elif isinstance(node, ast.AugAssign) and isinstance(node.target, ast.Name):
+                assigned[node.target.id].append(node.value)
+
+        def text(e: ast.expr, depth: int = 0) -> str:
+            if depth > 8:
+                return "{…}"
+            if isinstance(e, ast.Constant) and isinstance(e.value, str):
+                return e.value
+            if isinstance(e, ast.JoinedStr):
+                return "".join(text(v.value if isinstance(v, ast.FormattedValue) else v, depth + 1) for v in e.values)
+            if isinstance(e, ast.BinOp) and isinstance(e.op, ast.Add):
+                return text(e.left, depth + 1) + text(e.right, depth + 1)
+            if isinstance(e, ast.Call) and isinstance(e.func, ast.Attribute) and e.func.attr == "format":
+                return text(e.func.value, depth + 1)
+            if isinstance(e, ast.Attribute) and isinstance(e.value, ast.Name) and e.value.id == "self" and e.attr in class_strings:
+                return class_strings[e.attr]
+            if isinstance(e, ast.Name) and e.id in assigned:
+                return "".join(text(v, depth + 1) for v in assigned[e.id])
+            return "{…}"
+
+        for call in ast.walk(fn):
+            if isinstance(call, ast.Call) and isinstance(call.func, ast.Attribute) and call.func.attr == "_run" and isinstance(call.func.value, ast.Name) and call.func.value.id == "self" and call.args:
+                out.setdefault(f"{fn.name}@{call.lineno}", text(call.args[0]))
+    return out
+
+
+#: The four ways a statement stays inside one application. ``introspection`` is the server, not
+#: the data (``CALL db.relationshipTypes()``, ``CALL dbms.components()``); ``application`` walks out
+#: from ``(:PyApplication {name: $app})`` and cannot leave it; ``prefix`` and ``id`` are the two
+#: ``can://``-stamped forms the docstring below explains. Anything else is unscoped.
+_INTROSPECTION = re.compile(r"^\s*CALL (db|dbms)\.")
+_ANCHORED_ON_THE_APPLICATION = re.compile(r"\(\w*:PyApplication \{name: \$app\}\)")
+
+
+def _scope_kind(statement: str) -> str | None:
+    if _INTROSPECTION.match(statement):
+        return "introspection"
+    if _is_scoped(statement):
+        return "prefix"
+    if _ANCHORED_ON_THE_APPLICATION.search(statement):
+        return "application"
+    if _MATCHES_BY_ID.search(statement):
+        return "id"
+    return None
+
+
+def _every_statement() -> Dict[str, str]:
+    """Class-level statements (minus fragments) plus every inline one that resolved to Cypher."""
+    inline = {name: s for name, s in _inline_statements().items() if s != "{…}"}
+    return {**{n: s for n, s in _class_level_statements().items() if n not in _FRAGMENTS}, **inline}
+
+
 def test_the_audit_sees_the_dataflow_statements_too():
     names = set(_class_level_statements())
     for expected in ("_REACHES", "_CONE", "_PATHS", "_CALL_PATHS", "_VALUE_REACHES", "_CALLEE_VALUES", "_SOURCES", "_SLICE", "_CALLERS", "_CALLEES", "_OWN_EDGES", "_LOCATE_QUERY", "_OVERVIEW_PROJECTION"):
         assert expected in names, f"{expected} is not a class-level statement any more; move it back or extend the audit"
 
 
-@pytest.mark.parametrize("name", sorted(set(_class_level_statements()) - _FRAGMENTS))
+def test_the_audit_sees_every_inline_statement_too():
+    """One harvested statement per ``self._run(`` in the source -- a site the harvester cannot
+    reassemble shows up as ``{…}`` and must be one of the three known indirections, so a new
+    ``self._run(some_variable)`` cannot slip past unjudged."""
+    inline = _inline_statements()
+    assert len(inline) == inspect.getsource(PyNeo4jBackend).count("self._run("), "a self._run( site the harvester did not see"
+    indirect = sorted(name.split("@")[0] for name, s in inline.items() if s == "{…}")
+    assert indirect == ["_children", "_collect", "_paths"], f"unjudged statements passed through a variable: {indirect}"
+    assert all(re.match(r"(MATCH|OPTIONAL MATCH|UNWIND|CALL)\b", s.lstrip()) for s in inline.values() if s != "{…}"), "an inline statement does not start with a Cypher clause"
+    for expected in ("get_source", "get_class", "get_python_file", "get_method_bodies", "resolve_value", "_call_rows", "_bounded_call_rows", "_get_module_functions", "get_callsites_for", "get_config_uses", "get_config_readers", "get_decorated_callables", "get_entrypoints", "get_entrypoint_classes", "_probe_resolution_edges", "_own_edges", "get_dependencies"):
+        assert any(name.startswith(expected + "@") for name in inline), f"{expected}'s statement is not harvested"
+
+
+def test_no_statement_names_pycannode():
+    """1.4.1's ``:PyCanNode`` label was measured and rejected as a seek anchor (the spec's F2 table)
+    and does not exist on 1.4.0 graphs; a statement naming it would match nothing there."""
+    assert [name for name, s in _every_statement().items() if "PyCanNode" in s] == []
+
+
+@pytest.mark.parametrize("name", sorted(_every_statement()))
 def test_every_statement_is_application_scoped_or_keyed_by_an_application_stamped_id(name):
     """Two ways a statement stays inside one application, and every statement must use one.
 
@@ -361,14 +485,16 @@ def test_every_statement_is_application_scoped_or_keyed_by_an_application_stampe
     A body-node or ghost **id** embeds the application (``can://python/<app>/…``) and the emitter
     only ever links nodes from its own run, so a statement keyed *only* by id is scoped by
     construction and may omit the predicate -- ``_SLICE``, ``_PATHS`` and ``_VALUE_REACHES`` do,
-    for the measured cost of testing 195,784 reached nodes against a list. A statement keyed by
-    neither would be unscoped and fails here.
+    for the measured cost of testing 195,784 reached nodes against a list. A statement anchored
+    on ``(:PyApplication {name: $app})`` walks out from the application node and cannot leave it
+    (the module list, artifacts, config keys, the entrypoint report). A statement keyed by none
+    of these would be unscoped and fails here -- class-level and inline alike.
     """
-    statement = _class_level_statements()[name]
-    by_signature, by_id, scoped = bool(_MATCHES_BY_SIGNATURE.search(statement)), bool(_MATCHES_BY_ID.search(statement)), _is_scoped(statement)
-    assert scoped or by_id, f"{name} carries no application scope and is not keyed by an application-stamped id"
-    if by_signature:
-        assert scoped, f"{name} matches by signature without the application scope"
+    statement = _every_statement()[name]
+    kind = _scope_kind(statement)
+    assert kind is not None, f"{name} carries no application scope and is not keyed by an application-stamped id: {statement[:160]!r}"
+    if _MATCHES_BY_SIGNATURE.search(statement):
+        assert kind == "prefix", f"{name} matches by signature without the application prefix"
 
 
 def test_the_overview_projection_is_only_ever_appended_to_a_scoped_match():