@@ -169,7 +169,19 @@ def get_callees(self, callable_id: str) -> List[GoCallGraphEdge]:
     # -----[ source + whole-program ]-----
     @abstractmethod
     def get_source(self, node_id: str) -> str:
-        """The source text of the node ``node_id`` — ``module.source[node.span.bytes]``."""
+        """The source text of the node ``node_id`` — ``module.source[node.span.bytes]``.
+
+        ``node_id`` is a durable id (type, callable, field) **or a body-node id** —
+        ``"<callable can:// id>@<body key>"``, the analyzer's own, round-tripped and never composed
+        by the caller. The body-node form is what every edge endpoint and every
+        :class:`~cldk.analysis.commons.results.SliceNode` carries, so accepting it is what lets a
+        caller read an id off a ``get_ddg`` page or a slice and then read its text.
+
+        Raises:
+            CodeanalyzerExecutionException: nothing in this application owns that id, or the node
+                exists and carries no span — a parameter-passing vertex is a dataflow position,
+                not a region of the file, and has no text on either backend.
+        """
 
     @abstractmethod
     def get_call_graph_json(self) -> str:
@@ -463,7 +475,7 @@ def get_degraded(self) -> List[GoDegraded]:
         **Read this before trusting an absence.** A non-empty list means some L4 step fell back to
         a coarser result (``range_func``, ``unmapped_ssa``, ``no_vta``, …), so a path that *is*
         returned is still a real may-flow, but "no path" is not a proof over the affected packages
-        and callables. :meth:`taint` reports this on its own ledger rather than making the judgement
+        and callables. :meth:`taint` reports this on its own ledger rather than making the judgment
         for the caller; this accessor is how a caller inspects it directly.
         """
 
@@ -509,7 +521,7 @@ def taint(
         ``unresolved``.
 
         **Sources, sinks and sanitizers are the caller's to supply.** This SDK ships no Go framework
-        catalogue and derives no default set: a per-language vocabulary of taint sources is policy
+        catalog and derives no default set: a per-language vocabulary of taint sources is policy
         that rots, and this accessor is the mechanism.
 
         **A sanitizer is two mechanisms wearing one word**, told apart by shape. A bare ``str`` cuts
 
@@ -68,7 +68,7 @@
     VIA,
     GoAnalysisBackend,
 )
-from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names, pick_declaration
+from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names, pick_declaration, split_body_node_id
 from cldk.models.go import (
     GoAnalysis,
     GoApplication,
@@ -339,17 +339,27 @@ def get_functions(self) -> Dict[str, GoCallable]:
         return self._functions
 
     def get_source(self, node_id: str) -> str:
-        """The source text of ``node_id`` — ``module.source`` sliced by ``node.span.bytes`` — for a
-        durable-id node (type, callable, field).
+        """The source text of ``node_id`` — ``module.source`` sliced by ``node.span.bytes``.
+
+        ``node_id`` is a durable-id node (type, callable, field) **or a body-node id**: a statement,
+        a call site or a vertex, named by the analyzer's own
+        ``"<callable can:// id>@<body key>"``. The body-node form is what every edge endpoint and
+        every :class:`~cldk.analysis.commons.results.SliceNode` carries, so without it a caller
+        could read an id off a ``get_ddg`` page and then not use it — and the Neo4j backend accepts
+        it (its ``:GoCanNode`` lookup does not care which kind of node it found), which made this
+        a parity gap rather than a shared limitation. Python's ``get_source`` names the same two
+        forms in its own contract.
 
         ``span.bytes`` are **UTF-8 byte** offsets, so a non-ASCII module is sliced on the encoded
         bytes and decoded back (an ASCII module is indexed directly, paying nothing), the same way
         the TS ``_Spanned.code`` property does. Slicing the ``str`` by character index would drift
         on any file with a multibyte character before the span.
         """
-        entry = self._source_of.get(node_id)
+        entry = self._source_of.get(node_id) or self._body_source_of(node_id)
         if entry is None:
-            raise CodeanalyzerExecutionException(f"no source for {node_id!r}: not a type, callable or field of application " f"{self.application_name!r}")
+            raise CodeanalyzerExecutionException(
+                f"no source for {node_id!r}: not a type, callable, field or body node of application {self.application_name!r}"
+            )
         mod, node = entry
         if node.span is None:
             raise CodeanalyzerExecutionException(f"node {node_id!r} carries no span, so it has no source text")
@@ -362,6 +372,31 @@ def get_source(self, node_id: str) -> str:
             self._module_bytes[mod.id] = encoded
         return encoded[b0:b1].decode("utf-8")
 
+    def _body_source_of(self, node_id: str) -> "tuple | None":
+        """``(module, body node)`` for a body-node id, or ``None`` if nothing owns it.
+
+        The owner is found with :func:`~cldk.analysis.go.ids.split_body_node_id` rather than by
+        splitting on ``@`` — trap 1: a library stand-in's own id holds ``/@external/`` before the
+        vertex ``@``. A stand-in has no module and so no text, which this reports as "not found"
+        rather than as a module lookup that would fail further on.
+
+        Not indexed eagerly: the body-node ids outnumber the durable ones by a wide margin (3,324
+        against 319 on the analyzer's own corpus), and ``get_source`` on one is the uncommon case,
+        so the prefix walk is paid per call instead of the index being paid per application.
+        """
+        hit = split_body_node_id(node_id, self._dataflow_owners)
+        if hit is None:
+            return None
+        cid, key = hit
+        owner, _tid, path = self._dataflow_owners[cid]
+        if not path:  # a stand-in: synthesized, so there is no source file behind it
+            return None
+        node = (owner.body or {}).get(key) or (owner.body or {}).get(key.lstrip("@"))
+        if node is None:
+            return None
+        entry = self._source_of.get(cid)
+        return (entry[0], node) if entry else None
+
     # =====================================================================================
     # L3/L4 DATAFLOW. See :class:`~cldk.analysis.go.backend.GoAnalysisBackend` for the contract and
     # for the four Go-specific traps; the id/name grammar those traps need is in
@@ -392,7 +427,7 @@ def _require_dataflow(self) -> None:
 
         One guard for the per-callable graphs and the slices: they come from the same analyzer pass
         and go dark together. It **raises** rather than returning empty because at a shallower level
-        an empty answer would mean "not analysed" while looking exactly like "no dependence" (D7).
+        an empty answer would mean "not analyzed" while looking exactly like "no dependence" (D7).
         """
         if self._level < self._DATAFLOW_LEVEL:
             raise CodeanalyzerUsageException(
 
@@ -257,7 +257,7 @@ def taint(
         m sources against n sinks in one traversal, reporting per pair: the witnesses in ``paths``,
         the pairs an absence claim can be built on in ``exhausted``, and everything else in
         ``unresolved``. The source/sink/sanitizer vocabulary is the caller's — no Go framework
-        catalogue ships. A non-empty :meth:`get_degraded` voids every ``exhausted`` certification,
+        catalog ships. A non-empty :meth:`get_degraded` voids every ``exhausted`` certification,
         because absence of a path is not a proof over an approximated graph.
         """
         return self.backend.taint(sources, sinks, sanitizers, depth=depth, max_paths=max_paths)
 
@@ -102,7 +102,7 @@ def _slice_node(row: Dict[str, Any], module_key: Callable[[str], str]) -> SliceN
 
     The local twin is ``GoCodeanalyzer._slice_node``; the two share
     :func:`~cldk.analysis.commons.resolve.body_node_kind`, so a vertex a caller addressed through
-    ``resolve_value`` as a ``global`` comes back from a slice labelled a ``global`` on either
+    ``resolve_value`` as a ``global`` comes back from a slice labeled a ``global`` on either
     backend, and they differ only in where the fields are read from.
 
     ``row["var"]`` is the graph's name for the JSON's ``of`` (see
@@ -480,7 +480,7 @@ def get_source(self, node_id: str) -> str:
     # the value a vertex stands for arrives under the name the shared helpers expect.
     #
     # A STAND-IN IS A FIRST-CLASS VERTEX. ``:GoExternal`` nodes carry ``GO_HAS_BODY_NODE`` body
-    # nodes at L4, so the traversals must not be labelled ``:GoCallable``-only on the interior or
+    # nodes at L4, so the traversals must not be labeled ``:GoCallable``-only on the interior or
     # a flow *through* ``database/sql.DB.Query`` would be invisible — which is the very flow the
     # httpsql fixture gates. ``:GoCallable|GoExternal`` is therefore deliberate everywhere below.
     # =====================================================================================
@@ -1051,20 +1051,41 @@ def get_degraded(self) -> List[GoDegraded]:
     def describe(self, nodes: Sequence[object]) -> List[SliceNode]:
         """Fill in ``source`` for these positions (see :meth:`GoAnalysisBackend.describe`).
 
-        One query for the batch rather than one per node. A vertex with no span gets ``None``: it is
-        a dataflow position, not a region of the file, and there is nothing to read on either
-        backend.
+        A vertex with no span gets ``None``: it is a dataflow position, not a region of the file,
+        and there is nothing to read on either backend.
+
+        **A bare ``can://`` id is accepted as well as a resolved node**, because the local backend
+        accepts one and silently *dropping* it here was the worse half of that divergence: a caller
+        passing ids got a short list back with no signal, where the local backend answered. The
+        documented argument is a :class:`~cldk.analysis.commons.results.SliceNode`; an id is
+        resolved to one first rather than refused, so neither backend is the lenient outlier.
         """
         out: List[SliceNode] = []
         for n in nodes:
             if not isinstance(n, SliceNode):
-                continue
+                n = self._describe_id(str(n))
+                if n is None:
+                    continue
             try:
                 out.append(n.model_copy(update={"source": self.get_source(n.ref)}))
             except CodeanalyzerExecutionException:
                 out.append(n.model_copy(update={"source": None}))
         return out
 
+    def _describe_id(self, node_id: str) -> "SliceNode | None":
+        """One body-node id as a :class:`SliceNode`, or ``None`` if this graph holds no such node.
+
+        The local twin is ``GoCodeanalyzer._slice_node``; both route the node's ``kind``/``var``
+        through :func:`~cldk.analysis.commons.resolve.body_node_kind`, so an id described here and
+        one described in process carry the same caller-facing vocabulary.
+        """
+        rows = self._run(
+            f"MATCH (b:GoBodyNode {{id:$id}}) OPTIONAL MATCH (c:{self._OWNER})-[:GO_HAS_BODY_NODE]->(b) "
+            "RETURN b.id AS ref, b.kind AS kind, b.var AS var, b.span_json AS span, c.signature AS callable, c.span_json AS c_span",
+            id=node_id,
+        )
+        return _slice_node(self._span_lines(rows[0]), self._module_key) if rows else None
+
     # -----[ artifact / dependency / config layer — reserved-but-unemitted on this projection ]-----
     def get_artifacts(self) -> Dict[str, PyArtifact]:
         raise CodeanalyzerExecutionException(ARTIFACT_LAYER_UNAVAILABLE.format(app=self.application_name))
 
@@ -555,6 +555,21 @@ Five Go-specific facts, each one a thing that will mislead you if you don't know
   `exhausted` certification in a `taint` result and file an `analysis_degraded` diagnostic saying
   why. `complete` goes `False` with it.
 
+**Reading text back off a position.** `get_source(node_id)` takes a durable id (type, callable,
+field) **or a body-node id** — `"<callable can:// id>@<body key>"`, which is what every edge
+endpoint and every `SliceNode.ref` carries. So an id read off a `get_ddg` page or a slice can be
+turned into source directly:
+
+```python
+page = go.get_ddg("sqlRepo.Find")
+go.get_source(page.edges[0].src)          # 'return s.db.Query("SELECT …")'
+```
+
+A parameter-passing vertex has no span — it is a dataflow position, not a region of the file — so
+it raises rather than returning `""`, on both backends. `describe(nodes)` is the batch form: it
+takes the `SliceNode`s a slice or path handed you, and also accepts bare ids, returning `source=None`
+for a position that has no text rather than raising.
+
 **The port-connectivity gate.** `slice_*`, `paths_between`, `flows_to_*` and `taint` refuse — naming
 the gap rather than returning a false empty — when no `formal_in` vertex in the attached analysis has
 an outgoing dependence edge. Same rule as Java's, and the probe reads the *data*, never a version
 
@@ -5,7 +5,7 @@
 gated analyzer-side by ``TestGateL4_HTTPToSQLPath``; ``four_type_kinds.json`` is one declaration of
 each ``GoType.kind`` at ``-a 1``.
 
-**What is asserted and what is not.** These tests pin *behaviour a caller depends on* — that the
+**What is asserted and what is not.** These tests pin *behavior a caller depends on* — that the
 gated flow is found, that the four Go id/name traps are handled, that a refutation is only made
 where one is warranted. They deliberately do not pin edge counts: those move with every analyzer
 release and a test that fails on an improvement teaches nothing. Where a count appears it is
@@ -329,7 +329,7 @@ def test_paging_is_a_prefix_of_one_total_order(httpsql):
 
 def test_a_shallow_analysis_refuses_rather_than_answering_empty(tmp_path, monkeypatch):
     """At a level below the dataflow pass the three lists are absent, and an empty page there would
-    mean "not analysed" while looking exactly like "no dependence" (D7). So it raises, naming the
+    mean "not analyzed" while looking exactly like "no dependence" (D7). So it raises, naming the
     level to rebuild at."""
     shallow = _facade(tmp_path, monkeypatch, FOUR_KINDS, app="kinds", level=AnalysisLevel.symbol_table)
     with pytest.raises(CodeanalyzerUsageException, match="level 3"):