fix: orchestration hub ranking floor + event edge weights

Two fixes to symbol ranking, both identified by DEEP bakeoff LLM
assessments (alertmanager + prometheus scored symbol_ranking 2/5):

1. Orchestration floor: functions with out-degree >= 20 get minimum
   effective in-degree of sqrt(out) * 0.8.  Without this, within-file
   dampening (0.3x) and per-file cap (5) crushed alertmanager's `run`
   (in=9 all same-file, out=128) to effective_in=0.90, burying it at
   rank #45.  Now ranks #1.

2. Edge type weights: event_subscribes and event_publishes added at 0.8
   (were defaulting to 0.5); dispatches_to added at 0.6.  Event
   callbacks are call-equivalent edges and should weight like routes_to.

Signed-off-by: jgstern-agent <josh-agent@iterabloom.com>

Author: jgstern-agent

.ci/affected-tests.txt

@@ -1,15 +1,17 @@
 # Test selection manifest
-# Generated by smart-test at 2026-04-10T11:12:24-04:00
+# Generated by smart-test at 2026-04-10T12:07:46-04:00
 # Mode: targeted
 # Baseline: e2fb9e02102c793608778dce538cc121418600fc
-# Changed files: 7
-# Changed source files: 2
-# Selected tests: 50
+# Changed files: 9
+# Changed source files: 3
+# Selected tests: 54
 #
 # === CHANGED_SOURCE_FILES ===
 packages/hypergumbo-core/src/hypergumbo_core/cli.py
 packages/hypergumbo-core/src/hypergumbo_core/framework_patterns.py
+packages/hypergumbo-core/src/hypergumbo_core/ranking.py
 # === SELECTED_TESTS ===
+packages/hypergumbo-core/tests/BRANCHES_test_compact.py
 packages/hypergumbo-core/tests/BRANCHES_test_framework_patterns.py
 packages/hypergumbo-core/tests/test_build_grammars.py
 packages/hypergumbo-core/tests/test_cli_basic.py
@@ -25,6 +27,7 @@ packages/hypergumbo-core/tests/test_cli_search.py
 packages/hypergumbo-core/tests/test_cli_symbols.py
 packages/hypergumbo-core/tests/test_cli_test_coverage.py
 packages/hypergumbo-core/tests/test_cli_verify_claims.py
+packages/hypergumbo-core/tests/test_compact.py
 packages/hypergumbo-core/tests/test_fastapi_patterns.py
 packages/hypergumbo-core/tests/test_file_excludes.py
 packages/hypergumbo-core/tests/test_framework_patterns.py
@@ -34,10 +37,12 @@ packages/hypergumbo-core/tests/test_locale.py
 packages/hypergumbo-core/tests/test_max_tier.py
 packages/hypergumbo-core/tests/test_no_first_party_priority.py
 packages/hypergumbo-core/tests/test_profile.py
+packages/hypergumbo-core/tests/test_ranking.py
 packages/hypergumbo-core/tests/test_run_behavior_map.py
 packages/hypergumbo-core/tests/test_schema_compliance.py
 packages/hypergumbo-core/tests/test_sketch.py
 packages/hypergumbo-core/tests/test_sketch_sanity.py
+packages/hypergumbo-core/tests/test_slice.py
 packages/hypergumbo-core/tests/test_slice_tier_filter.py
 packages/hypergumbo-core/tests/test_stable_shape_ids.py
 packages/hypergumbo-core/tests/test_supply_chain.py

CHANGELOG.md

@@ -67,6 +67,11 @@ This changelog tracks the **tool version** (package releases). The **schema vers
 
 ### Fixed
 
+#### Symbol ranking
+
+- **Orchestration hub floor for high-out-degree functions**: functions with out-degree >= 20 (main/run/app orchestration hubs) get a minimum effective in-degree of `sqrt(out_degree) * 0.8`, preventing within-file dampening and per-file capping from burying them. On alertmanager, `run` (in=9 all same-file, out=128) was ranked #45 with effective_in=0.90 after 0.3x within-file weight and max_per_file_in=5; now ranks #1 with floor=9.05. Does not affect functions with fewer than 20 outgoing edges.
+- **`event_subscribes` and `event_publishes` added to `DEFAULT_EDGE_TYPE_WEIGHTS` at 0.8**: event-driven callback edges previously defaulted to 0.5 weight, under-counting the centrality of event handlers. Now weighted at 0.8, matching `routes_to` and `message_dispatch`. Also added `dispatches_to` at 0.6 for interface dispatch edges.
+
 #### Dead code analysis
 
 - **`dead-code-maybe` BFS follows `dispatches_to`, `routes_to`, and `wraps` edges**: the reachability BFS only followed `calls` edges, so interface dispatch targets (Go `Notifier.Notify` implementations), HTTP route handlers, and middleware-wrapped functions were all flagged as dead code. On alertmanager, this fix reduced false positives from 781 to 634 (147 functions correctly reclassified as reachable), and eliminated all 16 `Notifier.Notify` false positives. The BFS now follows the same call-flow edge types that the slice BFS uses.

packages/hypergumbo-core/src/hypergumbo_core/ranking.py

@@ -189,11 +189,14 @@ class RankedFile:
     "ipc_event": 0.9,
     "wasm_bridge": 0.9,
     "grpc_calls": 0.9,
+    "event_subscribes": 0.8,
+    "event_publishes": 0.8,
     "routes_to": 0.8,
     "crdt_publishes": 0.8,
     "message_dispatch": 0.8,
     "crypto_flow": 0.8,
     "renders_component": 0.7,
+    "dispatches_to": 0.6,
     "imports": 0.3,
     "imports_module": 0.2,
     "module_exports": 0.1,
@@ -255,6 +258,13 @@ def compute_centrality(
     prevents a utility function called 50 times from 2 files from outranking
     an architecturally important function called 15 times from 15 files.
 
+    **Orchestration floor:** symbols with out-degree >= 20 (orchestration
+    hubs like ``main``/``run``/``app``) get a minimum effective in-degree
+    of ``sqrt(out_degree) * 0.8``.  Without this, within-file dampening
+    and per-file capping crush hubs whose few in-edges all originate from
+    the same file (e.g., ``run`` called only from ``main()`` in the same
+    ``main.go``).
+
     Scores are normalized to 0-1 after computation.
 
     Args:
@@ -334,6 +344,20 @@ def compute_centrality(
         else:
             effective_in = ind
 
+        # Orchestration floor: genuinely high-out-degree functions
+        # (main/run/app — typically out >= 20) get a minimum effective
+        # in-degree proportional to their out-degree.  Without this,
+        # within-file dampening and per-file capping crush orchestration
+        # hubs: alertmanager's `run` (in=9 all same-file, out=128) got
+        # effective_in=0.90 after 0.3x within-file weight and
+        # max_per_file_in=5, burying it at rank 45 below symbols with
+        # moderate in-degree from many files.  The threshold prevents
+        # the floor from affecting normal functions with a few out-edges.
+        _ORCHESTRATION_OUT_THRESHOLD = 20
+        if outd >= _ORCHESTRATION_OUT_THRESHOLD:
+            orchestration_floor = math.sqrt(outd) * 0.8
+            effective_in = max(effective_in, orchestration_floor)
+
         # Pure sinks (out_degree=0) get a dampened multiplier (0.5) vs
         # the normal floor of 1.0.  This penalizes popular leaf utilities
         # (e.g., Elm map with in=71, out=0) that accumulate high in-degree

packages/hypergumbo-core/tests/test_ranking.py

@@ -3807,3 +3807,83 @@ def test_custom_weight(self):
             centrality, [gen_sym], generated_weight=0.1
         )
         assert result[gen_sym.id] == pytest.approx(0.1)
+
+
+class TestEventSubscribesEdgeWeight:
+    """event_subscribes edges should be weighted as call-flow edges, not defaults."""
+
+    def test_event_subscribes_in_default_weights(self):
+        """event_subscribes should be in DEFAULT_EDGE_TYPE_WEIGHTS at >= 0.8."""
+        from hypergumbo_core.ranking import DEFAULT_EDGE_TYPE_WEIGHTS
+
+        assert "event_subscribes" in DEFAULT_EDGE_TYPE_WEIGHTS
+        assert DEFAULT_EDGE_TYPE_WEIGHTS["event_subscribes"] >= 0.8
+
+    def test_event_publishes_in_default_weights(self):
+        """event_publishes should also be weighted."""
+        from hypergumbo_core.ranking import DEFAULT_EDGE_TYPE_WEIGHTS
+
+        assert "event_publishes" in DEFAULT_EDGE_TYPE_WEIGHTS
+        assert DEFAULT_EDGE_TYPE_WEIGHTS["event_publishes"] >= 0.8
+
+
+class TestOrchestrationHubRanking:
+    """Orchestration hubs (low in, very high out) should not be buried by dampening.
+
+    alertmanager's `run` function (in=9 all from same file, out=128) scored
+    raw centrality 5.27 vs NewAlertmanagerClient's 26.4 because within-file
+    dampening (0.3x) and per-file cap (5) crushed its effective in-degree
+    from 9 to 0.90.  The out-degree boost (ln-scale) couldn't compensate.
+    """
+
+    def test_orchestration_hub_ranks_above_moderate_connector(self):
+        """A function with out=128 and in=2 (cross-file) should rank higher
+        than one with in=8 (cross-file) and out=9."""
+        # Orchestration hub: called from 2 files, calls 50 others
+        hub = make_symbol("run", path="main.go", kind="function", language="go")
+        # Moderate connector: called from 8 different files, calls 9
+        connector = make_symbol("NewClient", path="client.go", kind="function",
+                                language="go")
+        # Create callers for both
+        targets = [make_symbol(f"t{i}", path=f"pkg{i}/mod.go", kind="function",
+                               language="go")
+                   for i in range(50)]
+
+        hub_callers = [
+            make_symbol("main", path="main.go", kind="function", language="go"),
+            make_symbol("init", path="init.go", kind="function", language="go"),
+        ]
+        conn_callers = [
+            make_symbol(f"caller{i}", path=f"pkg{i}/use.go", kind="function",
+                        language="go")
+            for i in range(8)
+        ]
+
+        all_symbols = [hub, connector] + targets + hub_callers + conn_callers
+
+        edges = []
+        # hub called by 2 callers (1 same-file, 1 cross-file)
+        edges.append(make_edge(hub_callers[0].id, hub.id))  # same-file (main.go)
+        edges.append(make_edge(hub_callers[1].id, hub.id))  # cross-file
+
+        # hub calls 50 targets
+        for t in targets:
+            edges.append(make_edge(hub.id, t.id))
+
+        # connector called by 8 callers (all cross-file)
+        for c in conn_callers:
+            edges.append(make_edge(c.id, connector.id))
+
+        # connector calls 9 targets
+        for t in targets[:9]:
+            edges.append(make_edge(connector.id, t.id))
+
+        ranked = rank_symbols(all_symbols, edges)
+        rank_by_name = {rs.symbol.name: rs.rank for rs in ranked}
+
+        # run (the orchestration hub) should rank higher (lower rank number)
+        # than NewClient
+        assert rank_by_name["run"] < rank_by_name["NewClient"], (
+            f"run rank={rank_by_name['run']} should be < "
+            f"NewClient rank={rank_by_name['NewClient']}"
+        )