address PR-B review: omit async from RouteCaller until PR-C

Stop labeling Symbol-backed async callers as client in find_route_callers
and trace_request_flow; surface caller_client_id on trace_flow HTTP hops;
strengthen UC9 test via compute_risk; fix neighbors mock for Client callers.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: HumanBean17

kuzu_queries.py

@@ -116,9 +116,10 @@ class ViaEdge:
     in the same chain (e.g. `INJECTS` vs `IMPLEMENTS` vs `CALLS`) and at what hop
     from the frontier they were reached.
     """
-    edge_type: str  # INJECTS | EXTENDS | IMPLEMENTS | CALLS
+    edge_type: str  # INJECTS | EXTENDS | IMPLEMENTS | CALLS | HTTP_CALLS | ASYNC_CALLS
     from_fqn: str
     hop: int  # 1 = direct neighbour of previous-stage frontier
+    caller_node_id: str = ""  # Client id when edge_type is HTTP_CALLS (SCHEMA v2)
 
 
 @dataclass
@@ -1281,6 +1282,7 @@ def _ingest_flow_row(
                         edge_type=str(row.get("edge_type") or ""),
                         from_fqn=str(row.get("from_fqn") or ""),
                         hop=hop,
+                        caller_node_id=str(row.get("caller_client_id") or ""),
                     )
                     existing = stage_results.get(sym.fqn)
                     if existing is None:
@@ -1342,7 +1344,8 @@ def _ingest_flow_row(
                         "AND n.resolved AND n.kind IN ['class','interface','enum','record','annotation'] "
                         "AND e.confidence >= $mc AND root.microservice <> n.microservice "
                         f"{scrf} "
-                        f"RETURN {_symbol_return_for('n')}, 'HTTP_CALLS' AS edge_type, root.fqn AS from_fqn "
+                        f"RETURN {_symbol_return_for('n')}, 'HTTP_CALLS' AS edge_type, "
+                        f"root.fqn AS from_fqn, c.id AS caller_client_id "
                         f"LIMIT {max(1, remaining * 4)}"
                     )
                     for row in self._rows(qrf, params_rf):
@@ -1352,14 +1355,14 @@ def _ingest_flow_row(
                     if len(stage_results) < stage_limit:
                         remaining = stage_limit - len(stage_results)
                         qrf_async = (
-                        "MATCH (root:Symbol)-[:DECLARES]->(m1:Symbol)-[e:ASYNC_CALLS]->(rt:Route)"
-                        "<-[:EXPOSES]-(handler:Symbol)<-[:DECLARES]-(n:Symbol) "
-                        "WHERE root.fqn IN $fqns AND n.role IN $roles "
-                        "AND n.resolved AND n.kind IN ['class','interface','enum','record','annotation'] "
-                        "AND e.confidence >= $mc AND root.microservice <> n.microservice "
-                        f"{scrf} "
-                        f"RETURN {_symbol_return_for('n')}, 'ASYNC_CALLS' AS edge_type, root.fqn AS from_fqn "
-                        f"LIMIT {max(1, remaining * 4)}"
+                            "MATCH (root:Symbol)-[:DECLARES]->(m1:Symbol)-[e:ASYNC_CALLS]->(rt:Route)"
+                            "<-[:EXPOSES]-(handler:Symbol)<-[:DECLARES]-(n:Symbol) "
+                            "WHERE root.fqn IN $fqns AND n.role IN $roles "
+                            "AND n.resolved AND n.kind IN ['class','interface','enum','record','annotation'] "
+                            "AND e.confidence >= $mc AND root.microservice <> n.microservice "
+                            f"{scrf} "
+                            f"RETURN {_symbol_return_for('n')}, 'ASYNC_CALLS' AS edge_type, root.fqn AS from_fqn "
+                            f"LIMIT {max(1, remaining * 4)}"
                         )
                         for row in self._rows(qrf_async, params_rf):
                             _ingest_flow_row(row, filter_external_fqn=True)
@@ -1488,6 +1491,7 @@ def find_route_callers(
         path_template: str = "",
         method: str = "",
     ) -> list[RouteCaller]:
+        """HTTP callers via Client (two-hop). Async callers omitted until PR-C (Producer)."""
         rid = route_id or ""
         if not rid:
             params: dict[str, Any] = {
@@ -1514,12 +1518,6 @@ def find_route_callers(
             "ORDER BY e.confidence DESC, c.id",
             {"rid": rid},
         )
-        async_rows = self._rows(
-            "MATCH (s:Symbol)-[e:ASYNC_CALLS]->(r:Route {id: $rid}) "
-            "RETURN s.id AS caller_node_id, s.microservice AS caller_microservice, "
-            "s.id AS declaring_symbol_id, e.confidence AS confidence, e.match AS match",
-            {"rid": rid},
-        )
         out: list[RouteCaller] = []
         for row in http_rows:
             out.append(
@@ -1534,22 +1532,10 @@ def find_route_callers(
                     raw_uri=str(row.get("raw_uri") or ""),
                 ),
             )
-        for row in async_rows:
-            sym_id = str(row.get("caller_node_id") or "")
-            out.append(
-                RouteCaller(
-                    caller_node_id=sym_id,
-                    caller_node_kind="client",
-                    caller_microservice=str(row.get("caller_microservice") or ""),
-                    declaring_symbol_id=str(row.get("declaring_symbol_id") or ""),
-                    confidence=float(row.get("confidence") or 0.0),
-                    match=str(row.get("match") or ""),
-                ),
-            )
-        out.sort(key=lambda c: (-c.confidence, c.caller_node_id))
         return out
 
     def trace_request_flow(self, entry_route_id: str, max_hops: int = 5) -> dict[str, Any]:
+        """Inbound HTTP via Client two-hop. Async inbound omitted until PR-C (Producer)."""
         hops = max(1, min(int(max_hops), 8))
         inbound_http = self._rows(
             f"MATCH (entry:Route {{id: $rid}})<-[e:HTTP_CALLS]-(caller:Client)"
@@ -1562,17 +1548,7 @@ def trace_request_flow(self, entry_route_id: str, max_hops: int = 5) -> dict[str
             "ORDER BY confidence DESC, caller_node_id",
             {"rid": entry_route_id},
         )
-        inbound_async = self._rows(
-            f"MATCH (entry:Route {{id: $rid}})<-[e:ASYNC_CALLS]-(caller:Symbol) "
-            f"OPTIONAL MATCH (origin:Symbol)-[:CALLS*0..{hops}]->(caller) "
-            "RETURN DISTINCT caller.id AS caller_node_id, 'client' AS caller_node_kind, "
-            "caller.id AS declaring_symbol_id, caller.fqn AS declaring_symbol_fqn, "
-            "caller.microservice AS microservice, e.confidence AS confidence, "
-            "e.match AS match, origin.id AS origin_symbol_id, origin.fqn AS origin_fqn "
-            "ORDER BY confidence DESC, caller_node_id",
-            {"rid": entry_route_id},
-        )
-        inbound = inbound_http + inbound_async
+        inbound = inbound_http
         outbound = self._rows(
             f"MATCH (handler:Symbol)-[:EXPOSES]->(entry:Route {{id: $rid}}) "
             f"OPTIONAL MATCH (handler)-[:CALLS*0..{hops}]->(next:Symbol) "

tests/test_mcp_v2.py

@@ -420,7 +420,28 @@ def _rows(self, query: str, params: dict[str, Any] | None = None) -> list[dict[s
                 and "WHERE a.id" in query
                 and "RETURN b.id AS other_id" in query
             ):
-                return [{"other_id": "sym:caller", "edge_type": "HTTP_CALLS", "confidence": 0.8, "match": "cross_service"}]
+                return [{"other_id": "client:caller", "edge_type": "HTTP_CALLS", "confidence": 0.8, "match": "cross_service"}]
+            if "MATCH (n:Client)" in query:
+                return [
+                    {
+                        "id": "client:caller",
+                        "client_kind": "feign_method",
+                        "target_service": "chat-core",
+                        "method": "POST",
+                        "path": "/chat/joinOperator",
+                        "path_template": "/chat/joinOperator",
+                        "path_regex": "",
+                        "member_fqn": "com.example.Caller#call()",
+                        "member_id": "sym:caller",
+                        "microservice": "chat-core",
+                        "module": "chat-app",
+                        "filename": "Caller.java",
+                        "start_line": 1,
+                        "end_line": 2,
+                        "resolved": True,
+                        "source_layer": "builtin",
+                    }
+                ]
             if "MATCH (n:Symbol)" in query:
                 return [
                     {
@@ -455,6 +476,8 @@ def _rows(self, query: str, params: dict[str, Any] | None = None) -> list[dict[s
     )
     assert out.success is True
     assert len(out.results) == 1
+    assert out.results[0].other.id == "client:caller"
+    assert out.results[0].other.kind == "client"
 
 
 def test_neighbors_batch_ids_carries_origin_id(kuzu_graph) -> None:

tests/test_pr_analysis.py

@@ -308,13 +308,37 @@ def test_pr_analysis_changed_methods_finds_routes_via_declares_client(
 ) -> None:
     from kuzu_queries import KuzuGraph
 
+    from pr_analysis import ChangedSymbol, compute_risk
+
     g = KuzuGraph(str(kuzu_db_path_cross_service_smoke))
-    rows = g._rows(  # noqa: SLF001
-        "MATCH (s:Symbol)-[:DECLARES_CLIENT]->(c:Client)-[e:HTTP_CALLS]->(r:Route) "
-        "WHERE e.match = 'cross_service' RETURN count(*) AS n",
+    route_rows = g._rows(  # noqa: SLF001
+        "MATCH (r:Route) "
+        "WHERE r.microservice = 'svc-b' AND r.path_template = '/chat/joinOperator' "
+        "AND r.method = 'POST' RETURN r.id AS id LIMIT 1",
         {},
     )
-    assert int(rows[0].get("n") or 0) >= 1
+    assert route_rows
+    rid = str(route_rows[0]["id"])
+    handler_rows = g._rows(  # noqa: SLF001
+        "MATCH (s:Symbol)-[:EXPOSES]->(r:Route {id: $rid}) RETURN s.id AS id, s.fqn AS fqn LIMIT 1",
+        {"rid": rid},
+    )
+    assert handler_rows
+    rep = compute_risk(
+        g,
+        [
+            ChangedSymbol(
+                symbol_id=str(handler_rows[0]["id"]),
+                fqn=str(handler_rows[0]["fqn"]),
+                kind="method",
+                change_type="modified",
+                file="",
+                hunk_lines=[1],
+            ),
+        ],
+    )
+    assert rep.changed_symbols
+    assert rep.changed_symbols[0].cross_service_callers_count >= 1
 
 
 def test_36_removed_symbol_from_minus_only_hunk(kuzu_graph) -> None: