@@ -235,9 +235,19 @@ def resolve_callable(self, name: str, *, in_class: str | None = None, in_module:
             in_module: Disambiguate by module — the repo-relative ``.go`` path, or the package's
                 dotted name.
 
+        **A Go signature is not always a unique address.** Several files in one package may each
+        declare their own ``init()``, so one signature can name several *different* callables with
+        different bodies and different dataflow (3 such collisions on the analyzer's own corpus).
+        Both backends hand the shared policy one candidate **per declaration**, so the ambiguity is
+        reported rather than silently resolved to whichever won, and ``in_module=`` naming one of
+        the declaring paths is what picks one.
+
         Raises:
             AmbiguousName: More than one callable matched; the candidates are carried.
             SelectorNotInGraph: Nothing matched, or a keyword excluded every match.
+            ValueError: The resolved signature is declared in several files and the keywords given
+                do not single one out. The message names the paths, because passing one of them is
+                the way out.
         """
 
     @abstractmethod
@@ -292,11 +302,20 @@ def get_cfg(self, callable: str, *, in_class: str | None = None, page_size: int
             Endpoints are the body nodes' own ``can://`` ids, the spelling :meth:`get_source`
             accepts.
 
+            **An empty page for a library stand-in is an answer, not a gap.** ``callable`` may
+            resolve to one (``database/sql.DB.Query``), and a stand-in has no statements — the
+            analyzer synthesizes only its ``formal_in``/``formal_out`` ports — so all three graphs
+            are legitimately empty there. That is distinct from the level gate below, where empty
+            *would* be indistinguishable from "no dependence" because the pass never ran; here the
+            pass ran and the absence is a fact about what a stand-in is. Its ports are still real
+            vertices, so the slices and :meth:`taint` do cross it.
+
         Raises:
             AmbiguousName: ``callable`` named more than one callable.
             SelectorNotInGraph: Nothing matched.
-            ValueError: ``page_size`` below 1, or ``cursor`` not from a previous page of this
-                accessor and this callable.
+            ValueError: ``page_size`` below 1, ``cursor`` not from a previous page of this accessor
+                and this callable, or the signature is declared in several files (see
+                :meth:`resolve_callable`).
             CodeanalyzerUsageException: (local backend) built below ``-a 3``.
         """
 
 
@@ -68,7 +68,7 @@
     VIA,
     GoAnalysisBackend,
 )
-from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names
+from cldk.analysis.go.ids import body_node_id, callable_match_names, external_signature, go_value_names, pick_declaration
 from cldk.models.go import (
     GoAnalysis,
     GoApplication,
@@ -526,7 +526,7 @@ def _slice_node(self, ref: str) -> SliceNode | None:
 
     # -----[ addressing ]-----
     @cached_property
-    def _candidates(self) -> Tuple[List[CallableCandidate], Dict[str, Tuple[object, str | None, str]], FrozenSet[str]]:
+    def _candidates(self) -> Tuple[List[CallableCandidate], Dict[str, List[Tuple[object, str | None, str]]]]:
         """``(candidates, {signature: owner}, colliding signatures)`` for :meth:`resolve_callable`.
 
         **The library stand-ins are in the domain**, and they have to be: spec §7's own worked
@@ -542,28 +542,33 @@ def _candidates(self) -> Tuple[List[CallableCandidate], Dict[str, Tuple[object,
         than matching one through a path derivation that would be meaningless here (the same
         distinction Java's J-2 records).
 
-        Two callables sharing a signature collapse into one entry, and the resolver would then hand
-        back whichever won with no signal — so the collisions are recorded and a name resolving onto
-        one raises. Checked on the *answer* rather than eagerly, so a duplicate elsewhere does not
-        break every unrelated resolution.
+        **One candidate per declaration, not per signature.** A Go signature is not a unique
+        address: several files in one package may each declare their own ``init()``, so
+        ``example.com/x/initclosure.init`` names two different callables with different bodies (3
+        such collisions on the analyzer's own corpus). Keying the candidate list by signature
+        collapsed those into one entry, which hid the ambiguity from the shared policy — so it
+        could neither report it (the Neo4j backend, whose rows are per declaration, raised
+        ``AmbiguousName`` where this raised a bare ``ValueError``) nor let ``in_module=`` narrow it.
+        Emitting one candidate per declaration is what makes the two backends hand the policy the
+        same domain, which is the only way they can agree on both the answer and the failure.
+
+        ``declarations`` therefore maps a signature to *every* callable carrying it, and
+        :func:`~cldk.analysis.go.ids.pick_declaration` re-applies the caller's keywords to choose
+        among them once the policy has resolved the signature.
         """
-        found: Dict[str, Tuple[object, str | None, str]] = {}
-        collisions: set = set()
+        declarations: Dict[str, List[Tuple[object, str | None, str]]] = {}
         for c, tid, path in self._iter_callables():
-            if c.signature in found:
-                collisions.add(c.signature)
-            found[c.signature] = (c, tid, path)
+            declarations.setdefault(c.signature, []).append((c, tid, path))
         cands = [
             CallableCandidate(sig, tid, path, match_names=callable_match_names(sig), module_names=(pkg,) if (pkg := self._package_of(path)) else ())
-            for sig, (_c, tid, path) in found.items()
+            for sig, entries in declarations.items()
+            for _c, tid, path in entries
         ]
         for sym in self.application.external_symbols.values():
             sig = external_signature(sym.module, sym.signature, sym.name)
-            if sig in found:
-                collisions.add(sig)
-            found[sig] = (sym, None, "")
+            declarations.setdefault(sig, []).append((sym, None, ""))
             cands.append(CallableCandidate(sig, None, "", match_names=callable_match_names(sig), module_names=()))
-        return cands, found, frozenset(collisions)
+        return cands, declarations
 
     def _package_of(self, path: str) -> str | None:
         """The ``package`` clause of the module at ``path`` — what ``in_module=`` matches a Go
@@ -585,11 +590,14 @@ def resolve_callable(self, name: str, *, in_class: str | None = None, in_module:
         "both backends resolve over the same set". The Go receiver spellings come from
         :func:`~cldk.analysis.go.ids.callable_match_names`, which is shared with the Neo4j backend.
         """
-        cands, found, collisions = self._candidates
+        cands, declarations = self._candidates
         sig = resolve_callable_signature(name, cands, in_class=in_class, in_module=in_module, by_full_name="more of the import path")
-        if sig in collisions:
-            raise ValueError(f"{sig!r} is carried by more than one analysed callable; neither can be addressed unambiguously")
-        c, _tid, path = found[sig]
+        entries = declarations[sig]
+        # A signature can name several declarations (same-package multi-file ``init()``), so the
+        # keywords are re-applied to choose among them -- see ``pick_declaration`` for why the
+        # policy's own answer is one step short of an address here.
+        chosen = pick_declaration(sig, [(path, tid) for _c, tid, path in entries], in_class=in_class, in_module=in_module)
+        c, _tid, path = next((obj, tid, p) for obj, tid, p in entries if p == chosen)
         if not c.id:
             raise KeyError(f"{sig!r} carries no usable address (id={c.id!r})")
         # A stand-in has no file and no span, so it is described as an external rather than given a
@@ -629,17 +637,31 @@ def resolve_value(self, name: str, *, within: str) -> SliceNode:
         return SliceNode(file=owner.file, line=owner.line, callable=owner.callable, kind=kind, name=leaf, defined_in=defined_in, source=None, ref=body_node_id(c.id, key))
 
     # -----[ per-callable graphs ]-----
-    def _graphs_of(self, name: str, in_class: str | None, page_size: int) -> GoCallable:
-        """The callable ``name`` resolves to, once this backend is deep enough to have dataflow.
+    def _graphs_of(self, name: str, in_class: str | None, page_size: int) -> Tuple[str, GoCallable | None]:
+        """``(signature, callable)`` for ``name``, once this backend is deep enough to have dataflow.
 
         ``page_size`` is validated **first**, before the level guard and before resolution, so a
         malformed argument is a ``ValueError`` before anything else — the order the Neo4j backend
         applies too, so the two cannot answer the same bad call with different exceptions.
+
+        **The callable is ``None`` for a library stand-in**, which is a real resolution target here
+        (spec §7's own example, ``database/sql.DB.Query``, is one) and has no intraprocedural flow
+        to report: the analyzer synthesizes only ``formal_in``/``formal_out`` ports for it, so
+        :class:`~cldk.models.go.GoExternalSymbol` carries no ``cfg``/``cdg``/``ddg`` field at all.
+        Returning ``None`` is what lets the three accessors answer with an **empty page**, which is
+        both the honest answer — the pass ran and a stand-in has no statements — and the answer the
+        Neo4j backend already gives, since its Cypher simply matches no rows on an external node.
+        Reading the field blindly raised ``AttributeError`` instead, which was neither.
+
+        This is **not** the D7 case the level gate guards: there, empty would be indistinguishable
+        from "no dependence" because the pass never ran. Here the pass ran and the absence is a
+        fact about what a stand-in *is*.
         """
         check_page_size(page_size)
         self._require_dataflow()
         node = self.resolve_callable(name, in_class=in_class)
-        return self._dataflow_owners[node.ref][0]
+        owner = self._dataflow_owners[node.ref][0]
+        return node.callable, owner if isinstance(owner, GoCallable) else None
 
     def get_cfg(self, callable: str, *, in_class: str | None = None, page_size: int = DEFAULT_PAGE_SIZE, cursor: str | None = None) -> EdgePage[GoCfgEdge]:
         """One page of control flow within one callable (see :meth:`GoAnalysisBackend.get_cfg`).
@@ -650,21 +672,21 @@ def get_cfg(self, callable: str, *, in_class: str | None = None, page_size: int
         the one the Neo4j backend would return. The join happens *before* the sort, because the
         order is over the ids a caller sees, not over the local keys.
         """
-        c = self._graphs_of(callable, in_class, page_size)
-        edges = [GoCfgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst), kind=e.kind) for e in c.cfg or []]
-        return edge_page(GoCfgEdge, c.signature, edges, CFG_ORDER, page_size, cursor)
+        sig, c = self._graphs_of(callable, in_class, page_size)
+        edges = [] if c is None else [GoCfgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst), kind=e.kind) for e in c.cfg or []]
+        return edge_page(GoCfgEdge, sig, edges, CFG_ORDER, page_size, cursor)
 
     def get_cdg(self, callable: str, *, in_class: str | None = None, page_size: int = DEFAULT_PAGE_SIZE, cursor: str | None = None) -> EdgePage[GoCdgEdge]:
         """One page of control dependence within one callable (see :meth:`GoAnalysisBackend.get_cdg`)."""
-        c = self._graphs_of(callable, in_class, page_size)
-        edges = [GoCdgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst)) for e in c.cdg or []]
-        return edge_page(GoCdgEdge, c.signature, edges, CDG_ORDER, page_size, cursor)
+        sig, c = self._graphs_of(callable, in_class, page_size)
+        edges = [] if c is None else [GoCdgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst)) for e in c.cdg or []]
+        return edge_page(GoCdgEdge, sig, edges, CDG_ORDER, page_size, cursor)
 
     def get_ddg(self, callable: str, *, in_class: str | None = None, page_size: int = DEFAULT_PAGE_SIZE, cursor: str | None = None) -> EdgePage[GoDdgEdge]:
         """One page of data dependence within one callable (see :meth:`GoAnalysisBackend.get_ddg`)."""
-        c = self._graphs_of(callable, in_class, page_size)
-        edges = [GoDdgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst), var=e.var, prov=list(e.prov or [])) for e in c.ddg or []]
-        return edge_page(GoDdgEdge, c.signature, edges, DDG_ORDER, page_size, cursor)
+        sig, c = self._graphs_of(callable, in_class, page_size)
+        edges = [] if c is None else [GoDdgEdge(src=body_node_id(c.id, e.src), dst=body_node_id(c.id, e.dst), var=e.var, prov=list(e.prov or [])) for e in c.ddg or []]
+        return edge_page(GoDdgEdge, sig, edges, DDG_ORDER, page_size, cursor)
 
     # -----[ slicing and reachability ]-----
     def _reach(self, ref: str, direction: str, depth: int | None) -> set:
 
@@ -28,7 +28,7 @@
 
 from typing import Iterable, List, Sequence, Tuple
 
-from cldk.analysis.commons.resolve import value_candidate
+from cldk.analysis.commons.resolve import segment_match, value_candidate
 
 #: The marker the analyzer puts in a library stand-in's **callable** id, before any vertex ``@``:
 #: ``can://<ns>/<app>/@external/bytes/Buffer.Read``. Its leading ``@`` is why
@@ -196,6 +196,53 @@ def external_signature(module: str, signature: str, name: str) -> str:
     return f"{module}.{signature or name}"
 
 
+def pick_declaration(sig: str, declarations: Sequence[Tuple[str, "str | None"]], *, in_class: "str | None", in_module: "str | None") -> str:
+    """The one declaration path of ``sig``, re-narrowed by the keywords that resolved it.
+
+    **Why this exists.** Go lets several files in one package each declare their own ``init()``, so
+    one signature can name several *different* callables with different bodies and different
+    dataflow — ``example.com/x/initclosure.init`` is declared in both ``a.go`` and ``b.go`` on the
+    analyzer's own corpus (3 such collisions there). A signature is therefore not a unique address
+    in Go the way it is in Python, and both backends have to agree on that.
+
+    :func:`~cldk.analysis.commons.resolve.resolve_callable_signature` returns a *signature string*,
+    which is one step short of an address when the signature collides: the keyword that narrowed the
+    candidate set is not re-applied to the declarations behind it, so a caller who wrote
+    ``in_module="a.go"`` and got past the policy would still face two declarations. This re-applies
+    exactly the policy's own predicates — :func:`segment_match` on the owning type for ``in_class``,
+    and on the repo-relative path with ``/`` for ``in_module`` — so a keyword that disambiguated the
+    candidates disambiguates the declaration too.
+
+    Args:
+        sig: The signature the policy resolved to.
+        declarations: ``(path, owning type id)`` for every callable carrying ``sig``.
+        in_class / in_module: The keywords as the caller passed them.
+
+    Returns:
+        The single matching declaration's path.
+
+    Raises:
+        ValueError: ``sig`` is carried by more than one declaration and the keywords given do not
+            single one out. The message names the paths, because the way out is to pass one of
+            them — a caller cannot act on "it is ambiguous" alone.
+    """
+    if len(declarations) == 1:
+        return declarations[0][0]
+    kept = list(declarations)
+    if in_class is not None:
+        kept = [(path, tid) for path, tid in kept if tid and segment_match(in_class, tid)]
+    if in_module is not None:
+        kept = [(path, tid) for path, tid in kept if segment_match(in_module, path, sep="/")]
+    if len(kept) == 1:
+        return kept[0][0]
+    paths = sorted(path for path, _tid in (kept or declarations))
+    raise ValueError(
+        f"{sig!r} is declared in {len(paths)} files ({', '.join(paths)}) — Go allows several files in one "
+        f"package to declare the same signature, so it is not a unique address here. Narrow it with "
+        f"in_module= naming one of those paths."
+    )
+
+
 def value_display(var: str) -> Tuple[str, str, "str | None"]:
     """``(kind, leaf, defined_in)`` for a ``formal_in`` vertex's ``var``, in the caller's vocabulary.
 
 
@@ -74,7 +74,7 @@
     VIA,
     GoAnalysisBackend,
 )
-from cldk.analysis.go.ids import callable_match_names, external_signature, go_value_names
+from cldk.analysis.go.ids import callable_match_names, external_signature, go_value_names, pick_declaration
 from cldk.analysis.go.neo4j import reconstruct as R
 from cldk.models.go import (
     GoApplication,
@@ -600,30 +600,37 @@ def resolve_callable(self, name: str, *, in_class: str | None = None, in_module:
         The shared policy runs over the same unfiltered domain the local backend hands it, which is
         the strongest form of "both backends resolve over the same set"; the Go receiver spellings
         come from the shared :func:`~cldk.analysis.go.ids.callable_match_names`.
+
+        A signature that names several declarations (same-package multi-file ``init()``) is
+        narrowed by :func:`~cldk.analysis.go.ids.pick_declaration`, the same function and the same
+        keywords the local backend applies. Re-looking-up on the bare signature and refusing on
+        ``len(rows) > 1`` — what this did before — threw away the narrowing the policy had just
+        done, so ``in_module=`` could not disambiguate even when it had matched.
         """
         sig = resolve_callable_signature(name, self._callable_candidates, in_class=in_class, in_module=in_module, by_full_name="more of the import path")
         if sig in self._external_signatures:
             ref = self._external_signatures[sig]
             return SliceNode(file="", line=0, callable=sig, kind="external", name=sig.rpartition(".")[2], source=None, ref=ref)
         rows = self._run(
-            "MATCH (c:GoCallable {signature:$sig}) WHERE c.id STARTS WITH $pre RETURN c.id AS ref, c.span_json AS span",
+            "MATCH (c:GoCallable {signature:$sig}) WHERE c.id STARTS WITH $pre "
+            "OPTIONAL MATCH (t:GoType)-[:GO_HAS_METHOD]->(c) "
+            "RETURN c.id AS ref, c.span_json AS span, t.id AS type_id ORDER BY c.id",
             sig=sig,
             pre=self._scope_prefix,
         )
         if not rows:
             raise KeyError(f"{sig!r} resolved but no :GoCallable node carries it in application {self.application_name!r}")
-        if len(rows) > 1:
-            raise ValueError(f"{sig!r} is carried by more than one analysed callable; neither can be addressed unambiguously")
-        ref = rows[0]["ref"]
-        span = json.loads(rows[0]["span"]) if rows[0]["span"] else None
+        chosen = pick_declaration(sig, [(self._path_of(r["ref"]), r["type_id"]) for r in rows], in_class=in_class, in_module=in_module)
+        row = next(r for r in rows if self._path_of(r["ref"]) == chosen)
+        span = json.loads(row["span"]) if row["span"] else None
         return SliceNode(
-            file=self._path_of(ref),
+            file=chosen,
             line=span["start"][0] if span else 0,
             callable=sig,
             kind="callable",
             name=sig.rpartition(".")[2],
             source=None,
-            ref=ref,
+            ref=row["ref"],
         )
 
     def resolve_value(self, name: str, *, within: str) -> SliceNode: