hypergumbo-core 2.7.0__tar.gz → 3.0.0__tar.gz

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/.gitignore

@@ -42,6 +42,7 @@ autonomous_intent.txt
 .agent/.transcript-sync-state.*.json
 .agent/.transcript-poll-state.*
 .agent/.transcript-injection-state.*.json
+.agent/.transcript-injection-state.*.lock
 .agent/.last_session_transcript.jsonl
 .agent/.second_to_last_transcript.jsonl
 .agent/.last_injection_history.jsonl

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypergumbo-core
-Version: 2.7.0
+Version: 3.0.0
 Summary: Core infrastructure for hypergumbo repo behavior map generator
 Author: Hypergumbo contributors
 License: AGPL-3.0-or-later

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypergumbo-core"
-version = "2.7.0"
+version = "3.0.0"
 description = "Core infrastructure for hypergumbo repo behavior map generator"
 readme = "README.md"
 requires-python = ">=3.10"

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/src/hypergumbo_core/__init__.py

@@ -23,6 +23,6 @@ format has breaking changes, while the tool version changes with any release.
 See ADR-0010 for the modular package architecture.
 """
 __all__ = ["PASS_VERSION", "__version__", "make_pass_id"]
-__version__ = "2.7.0"
+__version__ = "3.0.0"
 
 from .ir import PASS_VERSION, make_pass_id

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/src/hypergumbo_core/analyze/all_analyzers.py

@@ -21,6 +21,7 @@ from ..discovery import set_global_on_file_skipped
 from ..ir import Edge, Symbol, UsageContext
 from ..limits import Limits
 from ..paths import normalize_path
+from .base import synthesize_file_symbols_for_dangling_edges
 from .registry import (
     RegisteredAnalyzer,
     clear_registry,
@@ -174,6 +175,16 @@ def run_all_analyzers(
             deduped_edges.append(edge)
     all_edges = deduped_edges
 
+    # WI-ramuv: synthesize real file Symbols for any edge endpoint matching
+    # ``make_file_id`` shape that has no producer-side Symbol. Without this,
+    # ``ir.create_boundary_nodes`` would treat these dangling endpoints as
+    # external boundaries even though the file is first-party. Doing it
+    # here at the orchestrator chokepoint covers every analyzer in one
+    # place and obviates per-analyzer fixes.
+    all_symbols.extend(
+        synthesize_file_symbols_for_dangling_edges(all_symbols, all_edges)
+    )
+
     # Normalize paths: some analyzers produce absolute paths instead of
     # paths relative to repo_root.  Stripping the repo_root prefix ensures
     # consistent tier classification, test-file detection, and

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/src/hypergumbo_core/analyze/base.py

@@ -306,6 +306,73 @@ def make_file_id(lang: str, path: str) -> str:
     return f"{lang}:{path}:1-1:file:file"
 
 
+_FILE_ID_SUFFIX = ":1-1:file:file"
+
+
+def synthesize_file_symbols_for_dangling_edges(
+    symbols: list[Symbol],
+    edges: list[Edge],
+) -> list[Symbol]:
+    """Synthesize real file Symbols for any ``make_file_id``-shape dangling edge endpoint.
+
+    WI-ramuv chokepoint: many analyzers emit import / module-level edges
+    whose ``src`` (and occasionally ``dst``) is :func:`make_file_id` shape
+    (``{lang}:{path}:1-1:file:file``) without emitting a matching producer-
+    side ``kind="file"`` Symbol. ``ir.create_boundary_nodes`` then turns
+    every such dangling endpoint into an external boundary node, which is
+    structurally wrong (the file IS first-party) and forces Plan A
+    canonical-id collapsing as a band-aid.
+
+    This helper runs at the orchestrator (after analyzer result
+    aggregation, before boundary-node synthesis) and emits one real
+    ``kind="file"`` Symbol per distinct dangling ``make_file_id`` id, so
+    those edges land on real producer-side Symbols and never enter the
+    boundary pipeline.
+
+    Args:
+        symbols: All Symbols collected from analyzers (mutated only via
+            return value — this function is non-destructive).
+        edges: All Edges collected from analyzers.
+
+    Returns:
+        List of new Symbols (one per previously-dangling
+        ``make_file_id`` id). The caller appends these to the global
+        Symbol list.
+    """
+    existing_ids = {s.id for s in symbols}
+    synthesized: dict[str, Symbol] = {}
+
+    for edge in edges:
+        for endpoint in (edge.src, edge.dst):
+            if not endpoint.endswith(_FILE_ID_SUFFIX):
+                continue
+            if endpoint in existing_ids or endpoint in synthesized:
+                continue
+            # Canonical make_file_id shape is "{lang}:{path}:1-1:file:file".
+            # path may itself contain colons (e.g. dart "dart:io"), so we
+            # split off the language at the first colon and strip the
+            # fixed suffix. Anything that doesn't match this shape was
+            # filtered above.
+            head = endpoint[: -len(_FILE_ID_SUFFIX)]
+            colon = head.find(":")
+            if colon < 0:  # pragma: no cover
+                continue
+            language = head[:colon]
+            path = head[colon + 1 :]
+            synthesized[endpoint] = Symbol(
+                id=endpoint,
+                name=path,
+                kind="file",
+                language=language,
+                path=path,
+                span=Span(start_line=1, start_col=0, end_line=1, end_col=0),
+                origin="orchestrator_file_symbol_synthesis",
+                origin_run_id="",
+            )
+
+    return list(synthesized.values())
+
+
 def make_unresolved_edge(
     lang: str,
     src_id: str,
@@ -1079,6 +1146,164 @@ def iter_tree_with_context(
 # ---------------------------------------------------------------------------
 
 
+def emit_module_attribute_refs(
+    root: "tree_sitter.Node",
+    source: bytes,
+    imports: dict[str, str],
+    caller_symbol: Symbol,
+    lang: str,
+    edges_out: list[Edge],
+    *,
+    node_kinds: tuple[str, ...],
+    object_field_names: tuple[str, ...],
+    property_field_names: tuple[str, ...],
+    call_node_kinds: tuple[str, ...] = ("call_expression", "call",),
+    call_function_field_names: tuple[str, ...] = ("function", "callee",),
+    scoped_path: bool = False,
+) -> None:
+    """Emit ``module_attr_ref`` edges for attribute reads on imported modules.
+
+    This is the tree-sitter counterpart of the per-language helper that
+    ships inside ``py.py`` (see WI-guhok).  It targets bare attribute
+    accesses like ``process.env.PATH`` (JS), ``System.out`` (Java), or
+    ``os.Stdout`` (Go) — an imported-or-global module name followed by
+    one or more attribute accesses whose leftmost access is NOT itself
+    the callee of a function call.  Callee attribute accesses such as
+    ``os.getenv("X")`` or ``System.out.println("x")`` already produce
+    ``calls`` edges and would be double-counted if emitted here.
+
+    The emission pairs with ``attributes:`` entries in
+    ``io_primitives/*.yaml`` (WI-guhok for Python; this helper extends
+    the same mechanism to all tree-sitter-based analyzers — WI-gapam).
+    Without an edge to match, ``io-boundaries`` silently under-reports
+    ``env_read`` / ``ipc_send`` / ``ipc_recv`` chains on any attribute
+    primitive.
+
+    Args:
+        root: The tree-sitter node to walk.  Pass the file root for
+            module-level reads, or a function body for per-function
+            emission.
+        source: Raw source bytes used for ``node_text``.
+        imports: Map of local-alias name to the fully-qualified module
+            name (e.g. ``{"process": "process"}`` in JS,
+            ``{"os": "os"}`` in Go).  Base names that are not in this
+            map are skipped.
+        caller_symbol: The symbol containing the attribute read (used
+            as the edge ``src``).
+        lang: Language tag for the synthetic edge destination
+            (e.g. ``"javascript"`` / ``"java"`` / ``"go"``) — matches
+            the ``language`` field of module-attribute sink IDs.
+        edges_out: The edge list to append to — mutated in place.
+        node_kinds: Tree-sitter node types that represent
+            attribute-access nodes in this language.  Tuple because
+            some languages use more than one (e.g. JS ``member_expression``
+            handles both ``a.b`` and ``a["b"]`` via an ``index_expression``
+            sibling that the caller may also want to include).
+        object_field_names: Child-field names to try for the base
+            (receiver) of the attribute access, in order.  Some grammars
+            expose ``object``, others ``value`` or ``operand``.
+        property_field_names: Child-field names to try for the attribute
+            name.
+        call_node_kinds: Tree-sitter node types that represent function
+            calls; the helper excludes attribute-access nodes that are
+            the callee of such a call so ``calls`` edges are not
+            duplicated.
+        call_function_field_names: Child-field names to try for the
+            callee of a call node.
+        scoped_path: When True, switches the helper to a left-recursive
+            path-walk model used by languages whose scoped access is
+            not a binary ``object`` / ``property`` pair.  Rust's
+            ``scoped_identifier`` and C++'s ``qualified_identifier``
+            parse ``std::env::consts::OS`` as a nested chain of
+            ``path`` + ``name`` children — the helper walks left via
+            the path field to find the leftmost identifier, checks it
+            against the imports map, and emits edges using
+            dot-normalized module paths (``::`` replaced with ``.``)
+            so the resulting edge ID survives downstream ``:``-split
+            parsing.  Catalog matching still works because
+            ``IoBoundaryCatalog`` registers both ``::`` and ``.``
+            forms in its qualified-name index.
+    """
+    # tree-sitter's Python bindings return a fresh wrapper object on each
+    # accessor call, so `id()` is unstable across two walks of the same
+    # tree.  The underlying node carries a stable integer ``.id`` — use
+    # that as the key for the callee-detection set.
+    callee_attr_ids: set[int] = set()
+    for node in iter_tree(root):
+        if node.type not in call_node_kinds:
+            continue
+        callee = None
+        for fname in call_function_field_names:
+            callee = node.child_by_field_name(fname)
+            if callee is not None:
+                break
+        if callee is None:
+            continue
+        if callee.type in node_kinds:
+            callee_attr_ids.add(callee.id)
+
+    for node in iter_tree(root):
+        if node.type not in node_kinds:
+            continue
+        if node.id in callee_attr_ids:
+            continue
+        base = None
+        for fname in object_field_names:
+            base = node.child_by_field_name(fname)
+            if base is not None:
+                break
+        prop = None
+        for fname in property_field_names:
+            prop = node.child_by_field_name(fname)
+            if prop is not None:
+                break
+        if base is None or prop is None:
+            continue
+        base_text = node_text(base, source)
+        attr_name = node_text(prop, source)
+        if scoped_path:
+            # Left-recursive walk: the base may itself be a scoped_identifier
+            # (``std::env`` inside ``std::env::consts``).  Walk left via the
+            # first object_field_name until we bottom out at a terminal
+            # identifier — that's the alias we check against imports.
+            leftmost = base
+            while leftmost.type in node_kinds:
+                inner = None
+                for fname in object_field_names:
+                    inner = leftmost.child_by_field_name(fname)
+                    if inner is not None:
+                        break
+                if inner is None:  # pragma: no cover
+                    # Grammar variation guard: a node whose type is in
+                    # node_kinds but whose ``object_field_names`` resolve
+                    # to nothing is malformed — the outer node check would
+                    # have failed too.  Break to avoid an infinite loop.
+                    break
+                leftmost = inner
+            leftmost_text = node_text(leftmost, source)
+            if leftmost_text not in imports:
+                continue
+            # Replace the leftmost alias with its real module, then
+            # dot-normalize ``::`` to ``.`` so the resulting edge ID
+            # survives ``:``-split parsing in io_boundary.
+            real_leftmost = imports[leftmost_text]
+            real_module_raw = real_leftmost + base_text[len(leftmost_text):]
+            real_module = real_module_raw.replace("::", ".")
+        else:
+            if base_text not in imports:
+                continue
+            real_module = imports[base_text]
+        qname = f"{real_module}.{attr_name}"
+        edges_out.append(Edge.create(
+            src=caller_symbol.id,
+            dst=f"{lang}:{real_module}:0-0:{qname}:attribute",
+            edge_type="module_attr_ref",
+            line=node.start_point[0] + 1,
+            confidence=0.85,
+            evidence_type="module_attribute_reference",
+        ))
+
+
 def make_file_finder(patterns: list[str]) -> Callable[[Path], Iterator[Path]]:  # pragma: no cover
     """Create a file finder function for specific patterns.
 

{hypergumbo_core-2.7.0 → hypergumbo_core-3.0.0}/src/hypergumbo_core/cli.py

@@ -105,7 +105,11 @@ import hypergumbo_core.linkers.kafka_streams_dispatch as _kafka_streams_dispatch
 import hypergumbo_core.linkers.django_orm_dispatch as _django_orm_dispatch_linker  # noqa: F401
 import hypergumbo_core.linkers.rust_trait_dispatch as _rust_trait_dispatch_linker  # noqa: F401
 from .entrypoints import EntrypointKind, detect_entrypoints
-from .ir import Symbol, Edge, UsageContext, create_boundary_nodes, deduplicate_edges
+from .ir import (
+    Symbol, Edge, UsageContext, apply_external_id_remap, create_boundary_nodes,
+    deduplicate_edges,
+    is_external_boundary,
+)
 from .metrics import compute_metrics
 from .profile import detect_profile
 from .schema import new_behavior_map
@@ -1524,6 +1528,11 @@ def cmd_search(args: argparse.Namespace) -> int:
     matches = []
 
     for node in nodes:
+        # Skip synthetic boundary nodes — they have no source location
+        # and would surface as confusing "<external>" rows. Users searching
+        # for `urlopen` want their fetch() call site, not the placeholder.
+        if is_external_boundary(node):
+            continue
         name = node.get("name", "")
         # Check if pattern matches name (fuzzy substring match)
         if pattern in name.lower():
@@ -3094,9 +3103,13 @@ def cmd_compact(args: argparse.Namespace) -> int:
 def cmd_io_boundaries(args: argparse.Namespace) -> int:
     """Display I/O boundary map for a repository (ADR-0016).
 
-    Identifies call edges that reach I/O primitives (filesystem, network,
-    subprocess, environment) and groups them by boundary type. Loads a
-    cached behavior map or auto-runs analysis if needed.
+    Identifies call edges that reach I/O primitives and groups them by
+    boundary type: ``fs_read``, ``fs_write``, ``net_send``, ``net_recv``,
+    ``subprocess``, ``env_read``, ``env_write``, ``ipc_send``, ``ipc_recv``,
+    ``browser_storage_write``, ``browser_storage_read``, ``db_read``,
+    ``db_write``, ``process_send``, ``logging``. Attribute-style primitives
+    (``os.environ``, ``sys.argv``) are included via ``module_attr_ref``
+    edges. Loads a cached behavior map or auto-runs analysis if needed.
     """
     repo_root = Path(args.path).resolve()
 
@@ -3169,12 +3182,21 @@ def cmd_io_boundaries(args: argparse.Namespace) -> int:
         for ep in behavior_map.get("entrypoints", [])
     }
 
-    # Compute boundary map with entrypoint tracing
-    bmap = compute_boundary_map(edges, catalogs, entrypoint_ids=entrypoint_ids or None)
-
-    # Build node lookup for human-readable caller names
+    # Build node lookup for human-readable caller names AND for IoChain
+    # tier surfacing — passing nodes_by_id into compute_boundary_map lets
+    # each chain carry its dst's supply_chain.tier so verify-claims /
+    # sketch / external consumers can distinguish "first-party calls
+    # first-party I/O" from "first-party calls tier-3 wrapper that may
+    # reach the network" without per-library catalog growth.
     nodes_by_id: Dict[str, Any] = {n["id"]: n for n in behavior_map.get("nodes", [])}
 
+    # Compute boundary map with entrypoint tracing AND tier lookup
+    bmap = compute_boundary_map(
+        edges, catalogs,
+        entrypoint_ids=entrypoint_ids or None,
+        nodes_by_id=nodes_by_id,
+    )
+
     # Apply boundary/primitive/exclude-tests filters
     boundary_filter = getattr(args, "boundary", None)
     primitive_filter = getattr(args, "primitive", None)
@@ -3183,7 +3205,25 @@ def cmd_io_boundaries(args: argparse.Namespace) -> int:
     # CLI users do the same via --include-tests.
     exclude_tests = getattr(args, "exclude_tests", True)
 
-    from .io_boundary import BoundaryMapEntry
+    from .io_boundary import (
+        BoundaryMapEntry,
+        _build_reverse_graph,
+        compute_leaf_rollups,
+    )
+
+    # WI-rubir: when the filter path rebuilds BoundaryMapEntry it must
+    # also recompute the WI-darad leaf-caller roll-ups for the surviving
+    # chain subset; otherwise leaf_callers / entry_points_per_leaf are
+    # silently dropped (they default to empty on the dataclass), and
+    # because exclude_tests=True is the default, every normal CLI
+    # invocation hits this path.
+    reverse_graph_for_filter: Optional[Dict[str, set[str]]] = None
+
+    def _ensure_reverse_graph() -> Dict[str, set[str]]:
+        nonlocal reverse_graph_for_filter
+        if reverse_graph_for_filter is None:
+            reverse_graph_for_filter = _build_reverse_graph(edges)
+        return reverse_graph_for_filter
 
     filtered_entries: Dict[str, BoundaryMapEntry] = {}
     for btype, entry in bmap.entries.items():
@@ -3209,11 +3249,18 @@ def cmd_io_boundaries(args: argparse.Namespace) -> int:
             continue
 
         if primitive_filter or exclude_tests:
+            leaf_callers, entry_points_per_leaf = compute_leaf_rollups(
+                chains,
+                _ensure_reverse_graph(),
+                entrypoint_ids or None,
+            )
             filtered_entries[btype] = BoundaryMapEntry(
                 boundary=entry.boundary,
                 chains=chains,
                 entry_points=sorted({ep for c in chains for ep in c.entry_points}),
                 primitives_used=sorted({c.primitive for c in chains}),
+                leaf_callers=leaf_callers,
+                entry_points_per_leaf=entry_points_per_leaf,
             )
         else:
             filtered_entries[btype] = entry
@@ -3351,7 +3398,24 @@ def _print_io_boundaries_by_type(
             print(f"    {prim} ({count}){risk_flag}")
             for chain in chains_by_prim[prim]:
                 caller = _format_io_caller(chain.io_edge_src, nodes_by_id, repo_root)
-                print(f"      <- {caller}")
+                # Surface dst supply-chain tier so the user can tell apart
+                # "first-party calls first-party I/O" from "first-party
+                # calls a tier-3 wrapper that may reach the network."
+                # Only annotate when the dst is an external boundary —
+                # the common case for stdlib / npm / third-party deps.
+                tier_tag = ""
+                if chain.dst_external_boundary and chain.dst_tier_name:
+                    tier_tag = f"  [tier-{chain.dst_tier} {chain.dst_tier_name}]"
+                # Plan C, PR C: external_potential chains for in_progress
+                # source languages flag the absence-of-catalog-hit as
+                # unreliable so the user knows the language's stdlib is
+                # not yet provenance-validated.
+                unreliable_tag = (
+                    "  [unreliable]"
+                    if chain.dst_classification_unreliable
+                    else ""
+                )
+                print(f"      <- {caller}{tier_tag}{unreliable_tag}")
                 if chain.entry_points:
                     ep_names = [
                         _format_io_caller(ep, nodes_by_id, repo_root)
@@ -3414,6 +3478,28 @@ def cmd_verify_claims(args: argparse.Namespace) -> int:
     taint-flow analysis if needed, and checks each claim. Returns exit
     code 1 if any claim is violated. Supports boundary constraints
     (ADR-0016) and taint-flow constraints (ADR-0017).
+
+    Trust zones checked: ``host_fs``, ``network``, ``host_env``, ``ipc``,
+    ``browser_storage``, ``relay``. Built-in taint labels: ``host_secret``,
+    ``untrusted_input``, ``plaintext``, ``key_material``, ``ciphertext``,
+    ``derived_key``. The source and sink catalogs are derived automatically
+    from ``io_primitives/*.yaml`` (every write-side primitive is a sink at
+    ``trust_level=untrusted``; ``env_read``, ``net_recv``, and ``ipc_recv``
+    primitives are sources). YAML files under ``taint_sources/``,
+    ``taint_sinks/``, ``taint_sanitizers/`` contribute cryptographic labels
+    and sanitizer transforms that the auto-layer cannot express.
+
+    Project-local catalogs (WI-votan): the ``--taint-sources``,
+    ``--taint-sinks``, and ``--taint-sanitizers`` flags each accept a YAML
+    file or a directory of YAMLs and are repeatable; the claims YAML may
+    carry the same paths under a top-level ``extra_catalogs:`` key with
+    ``sources``/``sinks``/``sanitizers`` sub-lists (paths resolve relative
+    to the claims-file directory).  User entries whose
+    ``(module, name, kind)`` triple matches an auto-derived or built-in
+    source/sink replace it; user sanitizers concatenate.  This is the
+    supported extension point for declaring project-specific trust zones,
+    raising ``trust_level`` on a sink that is safe in context, or adding
+    a domain-specific taint source label.
     """
     repo_root = Path(args.path).resolve()
     claims_path = Path(args.claims)
@@ -3497,11 +3583,51 @@ def cmd_verify_claims(args: argparse.Namespace) -> int:
     unsupported_taint_languages: list[str] = []
     has_taint_claims = any(c.constraint_taint_flow is not None for c in claims)
     if has_taint_claims:
-        from .taint import load_builtin_taint_catalog, propagate_taint_structural
-        taint_catalog = load_builtin_taint_catalog()
+        from .taint import load_full_taint_catalog, propagate_taint_structural
+        from .verify_claims import load_extra_catalog_paths
+
+        # Assemble project-local taint catalog paths from CLI flags and the
+        # ``extra_catalogs:`` key in the claims YAML (WI-votan).  CLI paths
+        # come first so users invoking on the command line keep control
+        # even when a claims file declares its own defaults; merge
+        # semantics are order-independent because (module, name, kind)
+        # conflicts between two user entries would be a bug regardless.
+        cli_sources = [Path(p) for p in (getattr(args, "taint_sources", None) or [])]
+        cli_sinks = [Path(p) for p in (getattr(args, "taint_sinks", None) or [])]
+        cli_sanitizers = [
+            Path(p) for p in (getattr(args, "taint_sanitizers", None) or [])
+        ]
+        claims_sources, claims_sinks, claims_sanitizers = (
+            load_extra_catalog_paths(claims_path)
+        )
+        extra_source_paths = cli_sources + claims_sources
+        extra_sink_paths = cli_sinks + claims_sinks
+        extra_sanitizer_paths = cli_sanitizers + claims_sanitizers
+
+        try:
+            taint_catalog = load_full_taint_catalog(
+                extra_source_paths=extra_source_paths,
+                extra_sink_paths=extra_sink_paths,
+                extra_sanitizer_paths=extra_sanitizer_paths,
+            )
+        except FileNotFoundError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
 
-        # Also load project-local taint catalogs if specified in claims file
-        # (future: --taint-sources, --taint-sinks, --taint-sanitizers args)
+        if (
+            extra_source_paths
+            or extra_sink_paths
+            or extra_sanitizer_paths
+        ):
+            print(
+                "Loaded project-local taint catalog: "
+                f"{len(extra_source_paths)} source path(s), "
+                f"{len(extra_sink_paths)} sink path(s), "
+                f"{len(extra_sanitizer_paths)} sanitizer path(s). "
+                "User entries override auto-derived defaults on "
+                "(module, name, kind) match.",
+                file=sys.stderr,
+            )
 
         # Collect all sources, sinks, sanitizers across languages
         all_sources = []
@@ -5823,6 +5949,39 @@ are excluded by default — pass --include-tests to see them. See ADR-0016."""
         dest="json_output",
         help="Output as JSON",
     )
+    p_vc.add_argument(
+        "--taint-sources",
+        action="append",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Project-local taint source YAML file or directory. "
+            "Repeatable. Entries whose (module, name, kind) matches an "
+            "auto-derived or built-in source are overridden. (WI-votan)"
+        ),
+    )
+    p_vc.add_argument(
+        "--taint-sinks",
+        action="append",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Project-local taint sink YAML file or directory. "
+            "Repeatable. Entries whose (module, name, kind) matches an "
+            "auto-derived or built-in sink are overridden. (WI-votan)"
+        ),
+    )
+    p_vc.add_argument(
+        "--taint-sanitizers",
+        action="append",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Project-local taint sanitizer YAML file or directory. "
+            "Repeatable. User sanitizers concatenate onto the built-in "
+            "list. (WI-votan)"
+        ),
+    )
     p_vc.set_defaults(func=cmd_verify_claims)
 
     # Assign subcommands to groups for help formatting
@@ -6491,11 +6650,17 @@ def run_behavior_map(
     # Create boundary nodes for dangling edge endpoints (WI-sikur / INV-miniz).
     # Edges to external functions (stdlib, npm packages, etc.) would otherwise
     # break slice traversal by pointing to nonexistent nodes.
-    boundary = create_boundary_nodes(
+    # WI-fozoh: synthesizer collapses dangling refs by (lang, name, kind) and
+    # returns an id_remap so we can rewrite edges to point at the canonical
+    # boundary Symbols. Without this rewrite, edges would still reference the
+    # original (now-absent) per-reference dangling ids.
+    boundary, id_remap = create_boundary_nodes(
         all_symbols, all_edges, dependency_manifest=dependency_manifest,
     )
     if boundary:
         all_symbols.extend(boundary)
+    if id_remap:
+        all_edges = apply_external_id_remap(all_edges, id_remap)
     _log_memory("after boundary nodes")
 
     # Apply supply chain classification to all symbols
@@ -6539,7 +6704,7 @@ def run_behavior_map(
         removed_symbol_ids = {
             s.id for s in all_symbols
             if s.id not in filtered_symbol_ids
-            and not (s.meta and s.meta.get("external_boundary"))
+            and not is_external_boundary(s)
         }
 
         def _is_valid_edge_src(src: str) -> bool:
@@ -6578,14 +6743,28 @@ def run_behavior_map(
             # CSS structural (degree-0 in behavior maps)
             "class_selector", "id_selector", "rule_set",
             "property", "media", "keyframes", "font_face",
-            "variable",     # CSS custom properties / SCSS variables (zero edges)
             # Config metadata (degree-0 across all tested repos)
             "pattern",      # .gitignore entries
             "script",       # npm scripts / pyproject.toml entry points
             "requirement",  # pip requirements.txt entries
         })
-        noise_ids = {s.id for s in all_symbols if s.kind in _NOISE_KINDS}
-        all_symbols = [s for s in all_symbols if s.kind not in _NOISE_KINDS]
+        # CSS-family `variable` (custom properties, SCSS / Sass variables) is
+        # zero-edge noise and stays excluded. WI-gafog E2: in any other
+        # language, `variable` is a real top-level binding (Python module
+        # constants, Go top-level `var`, YAML / Make variables) and must
+        # remain in the output for cross-file `from <mod> import NAME`
+        # resolution.
+        _CSS_LANGUAGES = frozenset({"css", "scss", "sass", "less"})
+
+        def _is_noise(sym: "Symbol") -> bool:
+            if sym.kind in _NOISE_KINDS:
+                return True
+            if sym.kind == "variable" and sym.language in _CSS_LANGUAGES:
+                return True
+            return False
+
+        noise_ids = {s.id for s in all_symbols if _is_noise(s)}
+        all_symbols = [s for s in all_symbols if not _is_noise(s)]
         all_edges = [
             e for e in all_edges
             if e.src not in noise_ids and e.dst not in noise_ids
@@ -6601,16 +6780,15 @@ def run_behavior_map(
     ranked_symbols = [r.symbol for r in ranked]
     del ranked  # Free RankedSymbol wrappers
 
-    # Filter boundary nodes from output.  They exist in `all_symbols` to make
-    # edge endpoints resolvable for slice traversal, but shouldn't appear in
-    # the behavior map output — they're synthetic, have no source code, and
-    # would inflate node counts.  Edges pointing to boundary node IDs are
-    # retained (consumers can detect them by the "<external>" path or
-    # external_boundary meta flag).
-    ranked_symbols = [
-        s for s in ranked_symbols
-        if not (s.meta and s.meta.get("external_boundary"))
-    ]
+    # Boundary nodes (synthetic Symbols for unresolved external edge endpoints
+    # created by ir.create_boundary_nodes per WI-sikur / INV-miniz) are kept
+    # in the output. Display surfaces (sketch / compact / search /
+    # dead-code / explain) filter them via ir.is_external_boundary so the
+    # presentation stays focused on first-party code, but the JSON exposes
+    # them so disk-load consumers (slice / verify-claims / test-coverage)
+    # can resolve every edge endpoint to a node and reason over the
+    # boundary's supply_chain.tier (e.g., tier-3 wrappers that may reach
+    # the network).
 
     # Convert to dicts for output (in ranked order)
     all_nodes = [s.to_dict() for s in ranked_symbols]