Tighten consistency, explainability, and deterministic exports for public records Space

__pycache__/public_space_app.cpython-311.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:af1f987a2e3a2ed9596d9bc3620aa02adf88bdbdddfd35eea9728cb2b7ad3289
-size 111283
+oid sha256:0b7fd4155ab406455d61abeab73be9fdb3d4f85e5ebdb4a63b9cdbe78f832505
+size 170984

dataset_bundle/evidence_audit/consistency_report.json

@@ -1,5 +1,5 @@
 {
-  "generated_at": "2026-04-19T09:21:59-04:00",
+  "generated_at": "2026-04-19T19:38:57-04:00",
   "event_provenance": {
     "event_count": 3918,
     "events_with_artifacts": 3878,

dataset_bundle/network_graph/graph_config.json

@@ -14,15 +14,16 @@
     "unresolved": 1808,
     "linked": 1117,
     "needs_review": 119,
-    "acceptable_with_label": 800,
-    "release_ok": 713
+    "acceptable_with_label": 1174,
+    "release_ok": 339
   },
   "default_filters": {
     "relationship_family": "sector",
     "review_status": "stronger",
-    "max_edges": 60,
+    "max_edges": 30,
     "hide_unresolved_only": true,
-    "overview_member_limit": 8
+    "overview_member_limit": 5,
+    "default_member_search": "Josh Gottheimer"
   },
   "example_member_searches": [
     "Josh Gottheimer",

dataset_bundle/public_release_manifest.json

@@ -1,7 +1,7 @@
 {
   "public_version": "congress-public-records-slice-2026-04-v1",
   "title": "Congress Public Records Slice",
-  "release_date": "2026-04-19T09:22:53-04:00",
+  "release_date": "2026-04-19T19:40:15-04:00",
   "slice_description": "A neutral, review-oriented slice of House public-record linkages across financial disclosures, sector overlap, and community project funding recipient relationships.",
   "source_run_name": "house_all_baseline_20260418_v21_recipienthardening",
   "dataset_repo_id": "cjc0013/cmp-data",

public_copy.json

@@ -1,5 +1,5 @@
 {
-  "public_version": "congress-public-records-slice-2026-04-v1-private-spacefix",
+  "public_version": "congress-public-records-slice-2026-04-v1",
   "title": "Congress Public Records Slice",
   "subtitle": "Neutral Records explorer for a public-record slice of congressional money-and-power linkages.",
   "dataset_repo_id": "cjc0013/cmp-data",

public_space_app.py

@@ -899,31 +899,353 @@ def _stronger_support_count(row: Dict[str, Any]) -> int:
     )
 
 
-def _edge_evidence_chips(row: Dict[str, Any]) -> list[str]:
-    urls = _split_pipe_values(row.get("source_urls", ""), limit=12)
-    reason_codes = set(_split_pipe_values(row.get("reason_codes", ""), limit=20))
+TOPIC_AREA_PREFERRED_BILL_HINTS = {
+    "finance": ("billstatus-118hr2891.xml",),
+}
+
+
+def _relationship_target_key(value: Any) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", "_", str(value or "").strip().lower()).strip("_")
+    return normalized
+
+
+def _display_target_label(row: Dict[str, Any]) -> str:
+    label = str(row.get("target_label") or "").strip()
+    if str(row.get("relationship_family") or "") != "sector" or not label:
+        return label
+    words = re.sub(r"[_-]+", " ", label).strip()
+    return f"{words.title()} topic area"
+
+
+def _plain_link_type(value: str) -> str:
+    normalized = str(value or "").strip().lower()
+    mapping = {
+        "trade_disclosure_to_sector": "Trade disclosure to topic-area mapping",
+        "annual_financial_disclosure_to_sector": "Annual financial disclosure to topic-area mapping",
+        "member_to_sector_profile": "Member profile or committee-context mapping",
+        "member_to_earmark_request": "Funding-recipient linkage",
+        "member_to_earmark_request_unresolved": "Funding-recipient linkage still needing more review",
+    }
+    return mapping.get(normalized, normalized.replace("_", " ").title() or "Released relationship row")
+
+
+def _source_family_for_url(url: str) -> str:
+    normalized = str(url or "").strip().lower()
+    if "/financial-pdfs/" in normalized:
+        return "annual disclosure"
+    if "/ptr-pdfs/" in normalized:
+        return "trade disclosure"
+    if "committee_info" in normalized:
+        return "committee roster"
+    if "lda.senate.gov" in normalized:
+        return "lobbying activity"
+    if "govinfo.gov/bulkdata/billstatus" in normalized:
+        return "bill record"
+    if "/evs/" in normalized or "rollcall" in normalized:
+        return "vote activity"
+    if "usaspending.gov/award/" in normalized:
+        return "funding award"
+    if "memberdata.xml" in normalized or ".house.gov/" in normalized:
+        return "member profile"
+    return "published source support"
+
+
+def _edge_evidence_chips(row: Dict[str, Any], url_values: list[str] | None = None) -> list[str]:
+    urls = url_values if url_values is not None else _split_pipe_values(row.get("source_urls", ""), limit=12)
     chips: list[str] = []
-    if any("/ptr-pdfs/" in url for url in urls):
-        chips.append("trade disclosure")
-    if any("/financial-pdfs/" in url for url in urls):
-        chips.append("annual disclosure")
-    if any("govinfo.gov/bulkdata/BILLSTATUS" in url for url in urls):
-        chips.append("bill record")
-    if any("usaspending.gov/award/" in url for url in urls):
-        chips.append("funding award")
-    if any("committee_info" in url for url in urls):
-        chips.append("committee roster")
-    if "major_vote_overlap" in reason_codes or "vote_density_support" in reason_codes:
-        chips.append("vote activity")
-    if "lobbying_issue_overlap" in reason_codes or "lobbying_density_support" in reason_codes:
-        chips.append("lobbying activity")
-    if int(row.get("profile_link_count", 0) or 0) > 0:
-        chips.append("member profile")
-    deduped: list[str] = []
-    for chip in chips:
-        if chip not in deduped:
-            deduped.append(chip)
-    return deduped[:6]
+    for url in urls:
+        chip = _source_family_for_url(url)
+        if chip not in chips:
+            chips.append(chip)
+    return chips[:6]
+
+
+def _relationship_constituents(
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    row: Dict[str, Any],
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    empty_links = links.head(0).copy()
+    empty_events = events.head(0).copy()
+    if not row:
+        return empty_links, empty_events
+    member_slug = str(row.get("member_slug") or "").strip()
+    family = str(row.get("relationship_family") or "").strip()
+    target_key = str(row.get("target_key") or _relationship_target_key(row.get("target_label")))
+    if not member_slug or not family or not target_key:
+        return empty_links, empty_events
+
+    link_rows = empty_links
+    if not links.empty:
+        link_mask = links["member_slug"].fillna("").astype(str).eq(member_slug)
+        if "link_family" in links.columns:
+            link_mask &= links["link_family"].fillna("").astype(str).eq(family)
+        link_target_series = links.get("relationship_target", pd.Series("", index=links.index)).fillna("").astype(str)
+        if family == "recipient":
+            fallback_series = links.get("recipient_name", pd.Series("", index=links.index)).fillna("").astype(str)
+        else:
+            fallback_series = links.get("sector", pd.Series("", index=links.index)).fillna("").astype(str)
+        link_target_series = link_target_series.where(link_target_series.str.strip() != "", fallback_series)
+        link_mask &= link_target_series.map(_relationship_target_key).eq(target_key)
+        link_rows = links[link_mask].copy()
+
+    event_rows = empty_events
+    if not events.empty:
+        event_mask = events["member_slug"].fillna("").astype(str).eq(member_slug)
+        if family == "sector":
+            event_mask &= events["event_type"].fillna("").astype(str).eq("sector_overlap_event")
+            event_target_series = events.get("sector", pd.Series("", index=events.index)).fillna("").astype(str)
+        else:
+            event_mask &= events["event_type"].fillna("").astype(str).eq("recipient_overlap_event")
+            event_target_series = events.get("recipient_name", pd.Series("", index=events.index)).fillna("").astype(str)
+            if "relationship_target" in events.columns:
+                relationship_target_series = events.get("relationship_target", pd.Series("", index=events.index)).fillna("").astype(str)
+                event_target_series = relationship_target_series.where(relationship_target_series.str.strip() != "", event_target_series)
+        event_mask &= event_target_series.map(_relationship_target_key).eq(target_key)
+        event_rows = events[event_mask].copy()
+    return link_rows, event_rows
+
+
+def _collect_pipe_values(frame: pd.DataFrame, column: str, *, limit: int = 20) -> list[str]:
+    if frame.empty or column not in frame.columns:
+        return []
+    items: list[str] = []
+    for value in frame[column].fillna("").tolist():
+        for item in _split_pipe_values(value, limit=limit):
+            if item not in items:
+                items.append(item)
+    return items
+
+
+def _relationship_reason_labels(link_rows: pd.DataFrame, event_rows: pd.DataFrame, row: Dict[str, Any]) -> list[str]:
+    labels = [
+        _plain_reason_code(item)
+        for item in _collect_pipe_values(link_rows, "reason_codes", limit=20)
+        + _collect_pipe_values(event_rows, "reason_codes", limit=20)
+    ]
+    if not labels:
+        labels = [_plain_reason_code(item) for item in _split_pipe_values(row.get("reason_codes", ""), limit=20)]
+    ordered: list[str] = []
+    for label in labels:
+        if label and label not in ordered:
+            ordered.append(label)
+    return ordered[:10]
+
+
+def _relationship_strengtheners(link_rows: pd.DataFrame, event_rows: pd.DataFrame) -> list[str]:
+    labels = [
+        _plain_strengthener(item)
+        for item in _collect_pipe_values(link_rows, "missing_to_strengthen", limit=20)
+        + _collect_pipe_values(event_rows, "missing_to_strengthen", limit=20)
+    ]
+    ordered: list[str] = []
+    for label in labels:
+        if label and label not in ordered:
+            ordered.append(label)
+    return ordered[:10]
+
+
+def _relationship_sha_values(link_rows: pd.DataFrame, event_rows: pd.DataFrame) -> list[str]:
+    values = _collect_pipe_values(link_rows, "sha256_values", limit=40) + _collect_pipe_values(event_rows, "sha256_values", limit=40)
+    ordered: list[str] = []
+    for value in values:
+        if value and value not in ordered:
+            ordered.append(value)
+    return ordered
+
+
+def _relationship_link_type_mix(link_rows: pd.DataFrame) -> list[str]:
+    if link_rows.empty or "link_type" not in link_rows.columns:
+        return []
+    ordered: list[str] = []
+    for value in link_rows["link_type"].fillna("").astype(str).tolist():
+        label = _plain_link_type(value)
+        if label and label not in ordered:
+            ordered.append(label)
+    return ordered
+
+
+def _source_record_priority(record: Dict[str, Any], target_label: str) -> tuple[Any, ...]:
+    family_rank = {
+        "annual disclosure": 0,
+        "trade disclosure": 1,
+        "committee roster": 2,
+        "lobbying activity": 3,
+        "bill record": 4,
+        "vote activity": 5,
+        "funding award": 6,
+        "member profile": 7,
+        "published source support": 8,
+    }.get(str(record.get("family") or ""), 9)
+    score_label = str(record.get("score_label") or "")
+    score_rank = {
+        "strong_sector_overlap": 0,
+        "earmark_recipient_linked": 0,
+        "weak_sector_overlap": 1,
+    }.get(score_label, 2)
+    reason_codes = set(record.get("reason_codes") or [])
+    reason_rank = 3
+    for candidate, rank in (
+        ("issuer_match", 0),
+        ("legislative_relevance_match", 0),
+        ("bill_sponsor_overlap", 1),
+        ("major_vote_overlap", 2),
+    ):
+        if candidate in reason_codes:
+            reason_rank = rank
+            break
+    normalized_target = _relationship_target_key(target_label)
+    preferred_bill_rank = 9
+    if str(record.get("family") or "") in {"bill record", "vote activity"}:
+        hints = TOPIC_AREA_PREFERRED_BILL_HINTS.get(normalized_target, ())
+        for index, hint in enumerate(hints):
+            if hint in str(record.get("url") or "").lower():
+                preferred_bill_rank = index
+                break
+    origin_rank = 0 if str(record.get("origin") or "") == "event" else 1
+    return (
+        family_rank,
+        preferred_bill_rank,
+        score_rank,
+        reason_rank,
+        origin_rank,
+        str(record.get("url") or ""),
+    )
+
+
+def _relationship_source_records(link_rows: pd.DataFrame, event_rows: pd.DataFrame, target_label: str) -> list[Dict[str, Any]]:
+    raw_records: list[Dict[str, Any]] = []
+    for origin, frame in (("link", link_rows), ("event", event_rows)):
+        if frame.empty:
+            continue
+        for record in frame.to_dict("records"):
+            reason_codes = set(_split_pipe_values(record.get("reason_codes", ""), limit=20))
+            score_label = str(record.get("score_label") or "")
+            for url in _split_pipe_values(record.get("source_urls", ""), limit=24):
+                raw_records.append(
+                    {
+                        "url": url,
+                        "family": _source_family_for_url(url),
+                        "origin": origin,
+                        "score_label": score_label,
+                        "reason_codes": reason_codes,
+                    }
+                )
+    best_by_url: Dict[str, Dict[str, Any]] = {}
+    for record in sorted(raw_records, key=lambda item: _source_record_priority(item, target_label)):
+        best_by_url.setdefault(str(record.get("url") or ""), record)
+    return list(best_by_url.values())
+
+
+def _select_example_urls(
+    row: Dict[str, Any],
+    link_rows: pd.DataFrame,
+    event_rows: pd.DataFrame,
+    *,
+    limit: int = 6,
+) -> list[str]:
+    records = _relationship_source_records(link_rows, event_rows, str(row.get("target_label") or ""))
+    selected: list[str] = []
+    selected_set: set[str] = set()
+
+    def choose_one(family_name: str) -> None:
+        candidates = [
+            record
+            for record in records
+            if str(record.get("family") or "") == family_name and str(record.get("url") or "") not in selected_set
+        ]
+        if not candidates:
+            return
+        chosen = sorted(candidates, key=lambda item: _source_record_priority(item, str(row.get("target_label") or "")))[0]
+        url = str(chosen.get("url") or "")
+        selected.append(url)
+        selected_set.add(url)
+
+    choose_one("annual disclosure")
+    choose_one("trade disclosure")
+
+    combined_reason_codes = set(_collect_pipe_values(link_rows, "reason_codes", limit=20) + _collect_pipe_values(event_rows, "reason_codes", limit=20))
+    if "committee_jurisdiction_match" in combined_reason_codes:
+        choose_one("committee roster")
+    if any(str(record.get("family") or "") == "lobbying activity" for record in records):
+        choose_one("lobbying activity")
+
+    fallback_records = [
+        record
+        for record in records
+        if str(record.get("url") or "") not in selected_set
+    ]
+    family_order = {
+        "bill record": 0,
+        "vote activity": 1,
+        "funding award": 2,
+        "committee roster": 3,
+        "member profile": 4,
+        "published source support": 5,
+        "annual disclosure": 6,
+        "trade disclosure": 7,
+        "lobbying activity": 8,
+    }
+    for record in sorted(
+        fallback_records,
+        key=lambda item: (
+            family_order.get(str(item.get("family") or ""), 9),
+            _source_record_priority(item, str(row.get("target_label") or "")),
+        ),
+    ):
+        url = str(record.get("url") or "")
+        if not url or url in selected_set:
+            continue
+        selected.append(url)
+        selected_set.add(url)
+        if len(selected) >= int(limit):
+            break
+    return selected[: int(limit)]
+
+
+def _relationship_context(
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str,
+) -> Dict[str, Any] | None:
+    row = _select_edge_row(edges, relationship_id)
+    if not row:
+        return None
+    link_rows, event_rows = _relationship_constituents(links, events, row)
+    raw_score = _relationship_score(row)
+    relative_score = _relative_relationship_score(row, _member_activity_baselines(edges))
+    normalized_mode = str(ranking_mode or "raw").strip().lower()
+    display_score = relative_score if normalized_mode == "relative" else raw_score
+    surfaced_urls = _select_example_urls(row, link_rows, event_rows, limit=6)
+    all_urls = [record.get("url", "") for record in sorted(_relationship_source_records(link_rows, event_rows, str(row.get("target_label") or "")), key=lambda item: _source_record_priority(item, str(row.get("target_label") or "")))]
+    all_urls = [url for url in all_urls if url]
+    reason_labels = _relationship_reason_labels(link_rows, event_rows, row)
+    strengtheners = _relationship_strengtheners(link_rows, event_rows)
+    sha_values = _relationship_sha_values(link_rows, event_rows)
+    evidence_chips = _edge_evidence_chips(row, surfaced_urls)
+    link_type_mix = _relationship_link_type_mix(link_rows)
+    return {
+        "row": row,
+        "raw_score": raw_score,
+        "relative_score": relative_score,
+        "display_score": display_score,
+        "surfaced_urls": surfaced_urls,
+        "all_urls": all_urls,
+        "reason_labels": reason_labels,
+        "strengtheners": strengtheners,
+        "sha_values": sha_values,
+        "integrity_count": len(sha_values),
+        "evidence_chips": evidence_chips,
+        "link_type_mix": link_type_mix,
+        "display_target_label": _display_target_label(row),
+        "topic_area_note": (
+            "Topic-area links combine several public-record signals. They do not claim that every supporting bill is narrowly about that sector."
+            if str(row.get("relationship_family") or "") == "sector"
+            else ""
+        ),
+    }
 
 
 def _window_overlap_text(row: Dict[str, Any]) -> str:
@@ -1034,7 +1356,7 @@ def _rank_relationships(edges: pd.DataFrame, ranking_mode: str = "raw") -> pd.Da
             {
                 "relationship_id": str(row.get("edge_id") or ""),
                 "member": str(row.get("member_name") or row.get("member_slug") or ""),
-                "counterparty / sector": str(row.get("target_label") or ""),
+                "counterparty / sector": _display_target_label(row),
                 "overall score": display_score,
                 "raw score": raw_score,
                 "relative score": relative_score,
@@ -1188,19 +1510,26 @@ def _select_edge_row(edges: pd.DataFrame, relationship_id: str) -> Dict[str, Any
     return matched.head(1).to_dict("records")[0]
 
 
-def _relationship_detail_markdown(edges: pd.DataFrame, relationship_id: str, ranking_mode: str = "raw") -> str:
-    row = _select_edge_row(edges, relationship_id)
-    if not row:
+def _relationship_detail_markdown(
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str = "raw",
+) -> str:
+    context = _relationship_context(edges, links, events, relationship_id, ranking_mode)
+    if not context:
         return "Select a relationship to inspect why it appears in this released slice."
+    row = context["row"]
     family = str(row.get("relationship_family", "") or "")
-    chips = _edge_evidence_chips(row)
-    reason_codes = [_plain_reason_code(item) for item in _split_pipe_values(row.get("reason_codes", ""), limit=8)]
-    urls = _split_pipe_values(row.get("source_urls", ""), limit=5)
-    raw_score = _relationship_score(row)
-    relative_score = _relative_relationship_score(row, _member_activity_baselines(edges))
-    display_score = relative_score if str(ranking_mode or "raw").strip().lower() == "relative" else raw_score
+    chips = context["evidence_chips"]
+    reason_codes = context["reason_labels"]
+    urls = context["surfaced_urls"]
+    raw_score = int(context["raw_score"])
+    relative_score = int(context["relative_score"])
+    display_score = int(context["display_score"])
     lines = [
-        f"### {row.get('member_name') or row.get('member_slug')} -> {row.get('target_label')}",
+        f"### {row.get('member_name') or row.get('member_slug')} -> {context['display_target_label']}",
         "",
         f"- Relationship view: `{_plain_family_label(family)}`",
         f"- Strength label: `{_plain_status_label(str(row.get('relationship_status', '') or ''))}`",
@@ -1210,14 +1539,22 @@ def _relationship_detail_markdown(edges: pd.DataFrame, relationship_id: str, ran
         f"- Supporting relationship rows: `{int(row.get('link_count', 0) or 0)}`",
         f"- Stronger-support rows: `{int(row.get('linked_count', 0) or 0) if family == 'recipient' else int(row.get('strong_event_count', 0) or 0)}`",
         f"- Caution / weaker rows: `{int(row.get('review_count', 0) or 0) if family == 'recipient' else int(row.get('weak_event_count', 0) or 0)}`",
-        f"- Integrity-checked source records attached: `{int(row.get('sha_backed_source_artifact_count', 0) or 0)}`",
+        f"- Integrity-checked source records attached: `{int(context['integrity_count'])}`",
         f"- Unresolved source refs still counted: `{int(row.get('unresolved_source_ref_count', 0) or 0)}`",
         f"- Evidence signals: `{', '.join(chips) if chips else 'published source support'}`",
         f"- Time-window overlap: `{_window_overlap_text(row)}`",
     ]
+    if context["link_type_mix"]:
+        lines.append(f"- Released row kinds involved: `{'; '.join(context['link_type_mix'])}`")
+    if context["topic_area_note"]:
+        lines.append(f"- Topic-area note: {context['topic_area_note']}")
     if reason_codes:
         lines.extend(["", "#### Why it is linked in this slice", ""])
         lines.extend(f"- {item}" for item in reason_codes)
+        lines.append("- Note: one released row can contribute multiple signals, so the signal list can be longer than the supporting-row count.")
+    if context["strengtheners"]:
+        lines.extend(["", "#### What would strengthen it", ""])
+        lines.extend(f"- {item}" for item in context["strengtheners"])
     if urls:
         lines.extend(["", "#### Example published source URLs", ""])
         lines.extend(f"- [{item}]({item})" for item in urls)
@@ -1227,17 +1564,12 @@ def _relationship_detail_markdown(edges: pd.DataFrame, relationship_id: str, ran
             "#### Integrity note",
             "",
             "- `Integrity-checked` means the release includes a cryptographic fingerprint to help show a published record has not been altered.",
+            "",
+            "#### Ranking note",
+            "",
+            "- Raw score is the default public ranking. The relative score is experimental and changes with the current filtered comparison set.",
         ]
     )
-    if str(ranking_mode or "raw").strip().lower() == "relative":
-        lines.extend(
-            [
-                "",
-                "#### Ranking note",
-                "",
-                "- This view is using the experimental relative score, which compares this relationship to the same member's other visible links in the current filtered view.",
-            ]
-        )
     return "\n".join(lines)
 
 
@@ -1246,15 +1578,20 @@ def _safe_export_stem(value: str) -> str:
     return slug or "relationship-export"
 
 
-def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking_mode: str) -> list[dict[str, Any]]:
-    row = _select_edge_row(edges, relationship_id)
-    if not row:
+def _relationship_export_rows(
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str,
+) -> list[dict[str, Any]]:
+    context = _relationship_context(edges, links, events, relationship_id, ranking_mode)
+    if not context:
         return []
-    raw_score = _relationship_score(row)
-    relative_score = _relative_relationship_score(row, _member_activity_baselines(edges))
-    display_score = relative_score if str(ranking_mode or "raw").strip().lower() == "relative" else raw_score
-    reason_codes = [_plain_reason_code(item) for item in _split_pipe_values(row.get("reason_codes", ""), limit=8)]
-    urls = _split_pipe_values(row.get("source_urls", ""), limit=8)
+    row = context["row"]
+    raw_score = int(context["raw_score"])
+    relative_score = int(context["relative_score"])
+    display_score = int(context["display_score"])
     export_rows: list[dict[str, Any]] = [
         {
             "relationship_id": str(row.get("edge_id") or ""),
@@ -1271,7 +1608,24 @@ def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking
             "item_detail": "Top-level relationship summary for export.",
         }
     ]
-    for chip in _edge_evidence_chips(row):
+    for row_kind in context["link_type_mix"]:
+        export_rows.append(
+            {
+                "relationship_id": str(row.get("edge_id") or ""),
+                "member_name": str(row.get("member_name") or row.get("member_slug") or ""),
+                "target_label": str(row.get("target_label") or ""),
+                "relationship_family": _plain_family_label(str(row.get("relationship_family", "") or "")),
+                "strength_label": _plain_status_label(str(row.get("relationship_status", "") or "")),
+                "ranking_mode": str(ranking_mode or "raw"),
+                "displayed_score": display_score,
+                "raw_score": raw_score,
+                "relative_score": relative_score,
+                "item_type": "released_row_kind",
+                "item_label": "Released row kind",
+                "item_detail": row_kind,
+            }
+        )
+    for chip in context["evidence_chips"]:
         export_rows.append(
             {
                 "relationship_id": str(row.get("edge_id") or ""),
@@ -1288,7 +1642,7 @@ def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking
                 "item_detail": _evidence_chip_help(chip),
             }
         )
-    for reason in sorted(reason_codes):
+    for reason in context["reason_labels"]:
         export_rows.append(
             {
                 "relationship_id": str(row.get("edge_id") or ""),
@@ -1305,7 +1659,7 @@ def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking
                 "item_detail": reason,
             }
         )
-    for item in sorted(_plain_strengthener(value) for value in _split_pipe_values(row.get("missing_to_strengthen", ""), limit=12)):
+    for item in context["strengtheners"]:
         export_rows.append(
             {
                 "relationship_id": str(row.get("edge_id") or ""),
@@ -1322,7 +1676,7 @@ def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking
                 "item_detail": item,
             }
         )
-    for url in sorted(urls):
+    for url in context["all_urls"]:
         export_rows.append(
             {
                 "relationship_id": str(row.get("edge_id") or ""),
@@ -1342,14 +1696,21 @@ def _relationship_export_rows(edges: pd.DataFrame, relationship_id: str, ranking
     return export_rows
 
 
-def _relationship_handoff_rows(edges: pd.DataFrame, relationship_id: str, ranking_mode: str) -> list[dict[str, Any]]:
-    row = _select_edge_row(edges, relationship_id)
-    if not row:
+def _relationship_handoff_rows(
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str,
+) -> list[dict[str, Any]]:
+    context = _relationship_context(edges, links, events, relationship_id, ranking_mode)
+    if not context:
         return []
+    row = context["row"]
     family = str(row.get("relationship_family", "") or "")
-    raw_score = _relationship_score(row)
-    relative_score = _relative_relationship_score(row, _member_activity_baselines(edges))
-    display_score = relative_score if str(ranking_mode or "raw").strip().lower() == "relative" else raw_score
+    raw_score = int(context["raw_score"])
+    relative_score = int(context["relative_score"])
+    display_score = int(context["display_score"])
     handoff_rows: list[dict[str, Any]] = []
 
     def add(section: str, label: str, explanation: str, source_url: str = "") -> None:
@@ -1363,34 +1724,52 @@ def _relationship_handoff_rows(edges: pd.DataFrame, relationship_id: str, rankin
         )
 
     add("Summary", "Member", str(row.get("member_name") or row.get("member_slug") or ""))
-    add("Summary", "Target", str(row.get("target_label") or ""))
+    add("Summary", "Target", context["display_target_label"])
     add("Summary", "Relationship view", _plain_family_label(family))
     add("Summary", "Strength label", _plain_status_label(str(row.get("relationship_status", "") or "")))
     add("Summary", "Displayed score", str(display_score))
     add("Summary", "Raw score", str(raw_score))
     add("Summary", "Relative-to-baseline score (experimental)", str(relative_score))
+    add(
+        "Summary",
+        "Relative score note",
+        "Raw score is the default public ranking. Relative score is experimental and changes with the current filtered comparison set.",
+    )
     add("Summary", "Supporting relationship rows", str(int(row.get("link_count", 0) or 0)))
     add("Summary", "Stronger-support rows", str(_stronger_support_count(row)))
     add("Summary", "Caution / weaker rows", str(int(row.get("review_count", 0) or 0) if family == "recipient" else int(row.get("weak_event_count", 0) or 0)))
-    add("Summary", "Integrity-checked source records attached", str(int(row.get("sha_backed_source_artifact_count", 0) or 0)))
+    add("Summary", "Integrity-checked source records attached", str(int(context["integrity_count"])))
     add("Summary", "Unresolved source refs still counted", str(int(row.get("unresolved_source_ref_count", 0) or 0)))
     add("Summary", "Evidence window", _window_overlap_text(row))
+    if context["topic_area_note"]:
+        add("Summary", "Topic-area note", context["topic_area_note"])
+    for row_kind in context["link_type_mix"]:
+        add("Summary", "Released row kind", row_kind)
 
-    for chip in sorted(_edge_evidence_chips(row)):
+    for chip in context["evidence_chips"]:
         add("Evidence signals", chip.title(), _evidence_chip_help(chip))
-    for reason in sorted(_plain_reason_code(item) for item in _split_pipe_values(row.get("reason_codes", ""), limit=8)):
+    add(
+        "Why this link appears",
+        "Signal-count note",
+        "One released row can contribute multiple signals, so the signal list can be longer than the supporting-row count.",
+    )
+    for reason in context["reason_labels"]:
         add("Why this link appears", reason, reason)
-    for item in sorted(_plain_strengthener(value) for value in _split_pipe_values(row.get("missing_to_strengthen", ""), limit=12)):
+    for item in context["strengtheners"]:
         add("What would strengthen it", "Needs stronger support", item)
-    for url in sorted(_split_pipe_values(row.get("source_urls", ""), limit=20)):
+    for url in context["surfaced_urls"]:
         add("Published source URLs", urlparse(url).netloc or "Published source URL", "Open this published record directly.", url)
     return handoff_rows
 
 
 def _write_relationship_export_bundle(
-    edges: pd.DataFrame, relationship_id: str, ranking_mode: str
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str,
 ) -> tuple[str, str | None, str | None, str | None]:
-    export_rows = _relationship_export_rows(edges, relationship_id, ranking_mode)
+    export_rows = _relationship_export_rows(edges, links, events, relationship_id, ranking_mode)
     if not export_rows:
         return "Pick one relationship to generate exportable evidence files.", None, None, None
     relationship_id_value = str(export_rows[0]["relationship_id"] or relationship_id)
@@ -1421,7 +1800,7 @@ def _write_relationship_export_bundle(
         for export_row in export_rows:
             writer.writerow({name: export_row.get(name, "") for name in fieldnames})
 
-    handoff_rows = _relationship_handoff_rows(edges, relationship_id, ranking_mode)
+    handoff_rows = _relationship_handoff_rows(edges, links, events, relationship_id, ranking_mode)
     handoff_fieldnames = ["section", "label", "explanation", "source_url"]
     with handoff_csv_path.open("w", encoding="utf-8", newline="") as handle:
         writer = csv.DictWriter(handle, fieldnames=handoff_fieldnames)
@@ -1429,7 +1808,8 @@ def _write_relationship_export_bundle(
         for export_row in handoff_rows:
             writer.writerow({name: export_row.get(name, "") for name in handoff_fieldnames})
 
-    title = f"{export_rows[0]['member_name']} -> {export_rows[0]['target_label']}"
+    context = _relationship_context(edges, links, events, relationship_id, ranking_mode)
+    title = f"{export_rows[0]['member_name']} -> {context['display_target_label'] if context else export_rows[0]['target_label']}"
     pdf = canvas.Canvas(str(pdf_path), pagesize=LETTER, invariant=1)
     width, height = LETTER
     left = 54
@@ -1488,20 +1868,27 @@ def _timeline_window_from_url(url: str) -> tuple[int, str, str]:
     return (60, "Published source", urlparse(normalized).netloc if normalized.startswith("http") else "Published source")
 
 
-def _relationship_timeline_html(edges: pd.DataFrame, relationship_id: str) -> str:
-    row = _select_edge_row(edges, relationship_id)
-    if not row:
+def _relationship_timeline_html(
+    edges: pd.DataFrame,
+    links: pd.DataFrame,
+    events: pd.DataFrame,
+    relationship_id: str,
+    ranking_mode: str = "raw",
+) -> str:
+    context = _relationship_context(edges, links, events, relationship_id, ranking_mode)
+    if not context:
         return "<div style=\"padding: 1rem; border: 1px solid #d6d0c4; background: #fffdf8; color: #3a3a3a;\">Choose a relationship to see its evidence window.</div>"
+    row = context["row"]
     entries: list[tuple[int, str, str, str]] = []
     seen: set[tuple[str, str, str]] = set()
-    for url in _split_pipe_values(row.get("source_urls", ""), limit=8):
+    for url in context["surfaced_urls"]:
         sort_key, window_label, track_label = _timeline_window_from_url(url)
         detail = url
         dedupe_key = (window_label, track_label, detail)
         if dedupe_key not in seen:
             seen.add(dedupe_key)
             entries.append((sort_key, window_label, track_label, detail))
-    if int(row.get("profile_link_count", 0) or 0) > 0:
+    if any("Member profile" in item for item in context.get("link_type_mix", [])):
         entries.append((70, "Undated support", "Member profile support", "Profile-based support is included in this relationship summary."))
     if int(row.get("unresolved_source_ref_count", 0) or 0) > 0:
         entries.append((80, "Partly unresolved", "Some official references remain unresolved", f"{int(row.get('unresolved_source_ref_count', 0) or 0)} unresolved refs are still counted in this released row."))
@@ -1614,7 +2001,15 @@ def _filter_graph(
     if score_label != "all":
         filtered = filtered[filtered["score_labels"].fillna("").str.contains(score_label, case=False, na=False)]
     if review_status == "stronger":
-        filtered = filtered[filtered["relationship_status"].isin(["linked", "release_ok"])]
+        stronger_mask = (
+            ((filtered["relationship_family"] == "recipient") & (filtered["relationship_status"] == "linked"))
+            | (
+                (filtered["relationship_family"] == "sector")
+                & (filtered["relationship_status"] == "release_ok")
+                & (filtered["strong_event_count"].fillna(0).astype(int) > 0)
+            )
+        )
+        filtered = filtered[stronger_mask]
     elif review_status != "all":
         filtered = filtered[filtered["relationship_status"] == review_status]
     if hide_unresolved_only:
@@ -1708,11 +2103,14 @@ def _render_graph(nodes: pd.DataFrame, edges: pd.DataFrame) -> str:
         if not node:
             continue
         node_type = str(node.get("node_type", ""))
-        title_lines = [f"<b>{html.escape(str(node.get('label', '')))}</b>"]
+        display_label = str(node.get("label", "") or "")
+        if node_type == "sector":
+            display_label = f"{re.sub(r'[_-]+', ' ', display_label).strip().title()} topic area"
+        title_lines = [f"<b>{html.escape(display_label)}</b>"]
         role_label = {
             "member": "House member",
             "recipient": "Funding recipient",
-            "sector": "Sector",
+            "sector": "Topic area",
         }.get(node_type, node_type.title())
         title_lines.append(f"Role: {html.escape(role_label)}")
         if node_type == "member":
@@ -1723,7 +2121,7 @@ def _render_graph(nodes: pd.DataFrame, edges: pd.DataFrame) -> str:
         title_lines.append(f"Released relationships in graph data: {int(node.get('connected_edge_count', 0) or 0)}")
         network.add_node(
             node_id,
-            label=str(node.get("label", "")),
+            label=display_label,
             title="<br>".join(title_lines),
             color=color_map.get(str(node.get("node_type", "")), "#6e6e6e"),
             shape="dot",
@@ -1741,7 +2139,7 @@ def _render_graph(nodes: pd.DataFrame, edges: pd.DataFrame) -> str:
             if ":" in part
         ]
         title_lines = [
-            f"<b>{html.escape(str(row.get('member_name', '') or row.get('member_slug', '')))} -> {html.escape(str(row.get('target_label', '')))}</b>",
+            f"<b>{html.escape(str(row.get('member_name', '') or row.get('member_slug', '')))} -> {html.escape(_display_target_label(row))}</b>",
             f"Relationship type: {html.escape(family_label)}",
             f"Presentation tier: {html.escape(_plain_status_label(status))}",
             html.escape(_plain_status_explainer(status)),
@@ -1832,6 +2230,7 @@ def build_app(copy_path: str | Path):
     data = load_release_data(copy_path)
     manifest = data["manifest"]
     events = data["events"]
+    links = data["links"]
     nodes = data["graph_nodes"]
     edges = data["graph_edges"]
     provenance = data["event_provenance"]
@@ -1888,7 +2287,7 @@ def build_app(copy_path: str | Path):
         valid_ids = {value for _, value in options}
         selected = relationship_id if relationship_id in valid_ids else (options[0][1] if options else None)
         export_note, export_csv, export_handoff_csv, export_pdf = _write_relationship_export_bundle(
-            filtered_edges, selected or "", ranking_mode
+            filtered_edges, links, events, selected or "", ranking_mode
         )
         return (
             _overview_summary_markdown(
@@ -1908,8 +2307,8 @@ def build_app(copy_path: str | Path):
                 ranking_mode=ranking_mode,
             ),
             gr.update(choices=options, value=selected),
-            _relationship_detail_markdown(filtered_edges, selected or "", ranking_mode),
-            _relationship_timeline_html(filtered_edges, selected or ""),
+            _relationship_detail_markdown(filtered_edges, links, events, selected or "", ranking_mode),
+            _relationship_timeline_html(filtered_edges, links, events, selected or "", ranking_mode),
             export_note,
             export_csv,
             export_handoff_csv,
@@ -1926,11 +2325,11 @@ def build_app(copy_path: str | Path):
     ):
         filtered_edges = _overview_edges(member_query, family, only_strong, int(top_n))
         export_note, export_csv, export_handoff_csv, export_pdf = _write_relationship_export_bundle(
-            filtered_edges, relationship_id, ranking_mode
+            filtered_edges, links, events, relationship_id, ranking_mode
         )
         return (
-            _relationship_detail_markdown(filtered_edges, relationship_id, ranking_mode),
-            _relationship_timeline_html(filtered_edges, relationship_id),
+            _relationship_detail_markdown(filtered_edges, links, events, relationship_id, ranking_mode),
+            _relationship_timeline_html(filtered_edges, links, events, relationship_id, ranking_mode),
             export_note,
             export_csv,
             export_handoff_csv,