feat: disclose verified organization labels on Global Ask (v2.21.0)

ARCHITECTURE.md

@@ -865,7 +865,10 @@ Grounded in SKOS `skos:altLabel`/`skos:prefLabel` (Miles & Bechhofer,
 2009). Wired into `backend/app/keyman_ingestion.py`'s affiliation loop
 and the offline synthetic-batch script's paced re-implementation of it
 (the batch script's own copy was also missing `role_title` persistence
-entirely -- fixed alongside this).
+entirely -- fixed alongside this). Global Ask discloses corroborated
+raw→canonical pairs on cited-post evidence after ABAC and names opening
+Event Lineage as the next action; pending and uncorroborated aliases
+stay hidden ([ADR 0107](docs/adr/0107-verified-organization-label-evidence.md)).
 
 Also fixed while running this against synthetic embedded-image fixtures:
 `image_content.py`'s `_parse_description` required an exact single-pass

CHANGELOG.d/2.21.0-verified-organization-label-evidence.md

@@ -0,0 +1,12 @@
+# 2.21.0 — Disclose corroborated organization labels on Global Ask
+
+- Global Ask now shows search-corroborated raw→canonical organization
+  labels on cited-post evidence (for example `DC → Demo Corp`) after
+  ABAC-visible posts are selected.
+- Pending and uncorroborated aliases stay excluded from nomination and
+  disclosure.
+- Verified aliases now join the catalog through a stable entity id, so
+  same-named organizations cannot cross-match through display labels; existing
+  Compose volumes replay the required migrations.
+- When a corroborated label matched, Ask names opening a cited post to
+  read Event Lineage as the next action (ADR 0107 / ADR 0008).

CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.21.0] - 2026-08-20
+
+### Added
+
+- Global Ask now discloses search-corroborated organization labels on
+  cited-post evidence (for example `DC → Demo Corp`) and names opening
+  a cited post to read Event Lineage as the next action. Pending and
+  uncorroborated aliases stay hidden. No TEPP theta is invented
+  (ADR 0107 / ADR 0008 / ADR 0106).
+- Verified aliases join the catalog through a stable entity id rather than a
+  display-name match, and existing Compose volumes replay the identity
+  migration (ADR 0122).
+
 ## [2.19.0] - 2026-08-20
 
 ### Added

CLAUDE.md

@@ -114,3 +114,10 @@ current and moves focus to the Keyman heading once Keyman rows have
 settled (ADR 0100). The report-member auto-land chain to related nodes
 and Ask is not used for GNB origins. A home-list open does not gain that
  focus. Do not invent a theta.
+
+## Verified organization labels on Global Ask (v2.21.0)
+
+Ask a corroborated synthetic alias such as `DC`. Cited-post evidence
+names `DC → Demo Corp` and tells the buyer to open that cited post to
+read Event Lineage (ADR 0107). Pending and uncorroborated aliases stay
+hidden. Do not invent a theta.

backend/app/global_ask_retrieval.py

@@ -43,6 +43,102 @@
 _TOKEN = re.compile(r"[^\W_]+(?:-[^\W_]+)*", re.UNICODE)
 _EVIDENCE_POST_IDS = re.compile(r"\[evidence_post_id=([^]]+)\]")
 
+VERIFIED_ORGANIZATION_LABEL_PREFIX = "verified organization label:"
+VERIFIED_ORGANIZATION_LABEL_NEXT_ACTION = (
+    "Corroborated organization labels are current. Open a cited post to read Event Lineage."
+)
+
+
+def verified_organization_label_fact(
+    raw_organization_name: str,
+    resolved_organization_name: str,
+) -> str:
+    """Return one buyer-visible SKOS altLabel → prefLabel pair."""
+
+    return (
+        f"{VERIFIED_ORGANIZATION_LABEL_PREFIX} {raw_organization_name} → "
+        f"{resolved_organization_name}"
+    )
+
+
+async def verified_organization_label_facts(
+    conn: asyncpg.Connection,
+    question: str | None,
+    post_ids: list[str],
+    *,
+    maximum_terms: int = 8,
+) -> dict[str, tuple[str, ...]]:
+    """Disclose corroborated raw→canonical labels for already-visible posts.
+
+    Pending and uncorroborated aliases never appear. Nomination remains
+    identifier-only; this query runs after ABAC-visible post ids are known.
+    """
+
+    if not post_ids:
+        return {}
+    terms = global_ask_query_terms(question, maximum_terms=maximum_terms)
+    if not terms:
+        return {}
+    rows = await conn.fetch(
+        """
+        with query_terms as (
+            select unnest($1::text[]) as term
+        ), nominated_post as (
+            select unnest($2::uuid[]) as post_id
+        ), verified_organization as (
+            select distinct
+                   entity.corporate_entity_id,
+                   resolution.raw_organization_name,
+                   resolution.resolved_organization_name
+              from organization_name_resolution resolution
+              join corporate_entity entity
+                on resolution.resolved_corporate_entity_id = entity.corporate_entity_id
+              join query_terms term
+                on resolution.raw_organization_name ilike '%' || term.term || '%'
+                or resolution.resolved_organization_name ilike '%' || term.term || '%'
+             where resolution.verification_status_code = 'verify_corroborated'
+        ), matched_organization_label as (
+            select distinct
+                   mention.post_id,
+                   organization.raw_organization_name,
+                   organization.resolved_organization_name
+              from post_organization_mention mention
+              join verified_organization organization
+                on organization.corporate_entity_id = mention.corporate_entity_id
+              join nominated_post nominated
+                on nominated.post_id = mention.post_id
+            union
+            select distinct
+                   mention.post_id,
+                   organization.raw_organization_name,
+                   organization.resolved_organization_name
+              from post_person_mention mention
+              join person_affiliation affiliation
+                on affiliation.person_id = mention.person_id
+              join verified_organization organization
+                on organization.corporate_entity_id = affiliation.affiliated_corporate_entity_id
+              join nominated_post nominated
+                on nominated.post_id = mention.post_id
+        )
+        select post_id::text as post_id,
+               raw_organization_name,
+               resolved_organization_name
+          from matched_organization_label
+         order by post_id, raw_organization_name, resolved_organization_name
+        """,
+        list(terms),
+        list(post_ids),
+    )
+    facts: dict[str, list[str]] = {}
+    for row in rows:
+        facts.setdefault(str(row["post_id"]), []).append(
+            verified_organization_label_fact(
+                row["raw_organization_name"],
+                row["resolved_organization_name"],
+            )
+        )
+    return {post_id: tuple(dict.fromkeys(values)) for post_id, values in facts.items()}
+
 
 def global_ask_query_terms(question: str | None, *, maximum_terms: int = 8) -> tuple[str, ...]:
     """Return bounded, de-duplicated lexical terms from a Global Ask query."""
@@ -90,7 +186,7 @@ async def semantic_candidate_post_ids(
             select distinct entity.corporate_entity_id
               from organization_name_resolution resolution
               join corporate_entity entity
-                on entity.entity_name = resolution.resolved_organization_name
+                on resolution.resolved_corporate_entity_id = entity.corporate_entity_id
               join query_terms term
                 on resolution.raw_organization_name ilike '%' || term.term || '%'
                 or resolution.resolved_organization_name ilike '%' || term.term || '%'
@@ -233,8 +329,12 @@ def _public_semantic_fact(fact: str) -> str:
 
 
 __all__ = [
+    "VERIFIED_ORGANIZATION_LABEL_NEXT_ACTION",
+    "VERIFIED_ORGANIZATION_LABEL_PREFIX",
     "global_ask_query_terms",
     "graph_fact_evidence_post_ids",
     "public_external_claim_facts",
     "semantic_candidate_post_ids",
+    "verified_organization_label_fact",
+    "verified_organization_label_facts",
 ]

backend/app/keyman_ingestion.py

@@ -71,7 +71,10 @@
 
 from .corporate_entity_ingestion import get_or_create_corporate_entity
 from .knowledge_graph import persist_edges_for_post
-from .organization_name_resolution_ingestion import resolve_organization_name
+from .organization_name_resolution_ingestion import (
+    link_verified_organization_entity,
+    resolve_organization_name,
+)
 
 
 async def _load_corporate_entity_candidates(conn: asyncpg.Connection) -> list[CorporateEntityCandidate]:
@@ -288,6 +291,13 @@ async def ingest_post_keymen(
                     corporate_entity_id,
                     mention.job_title,
                 )
+                if corporate_entity_id is not None:
+                    await link_verified_organization_entity(
+                        conn,
+                        organization_name,
+                        post_body,
+                        corporate_entity_id,
+                    )
                 if resolved_name not in resolved_names:
                     resolved_names.append(resolved_name)
             normalized_mentions.append(

backend/app/main.py

@@ -88,6 +88,7 @@
     cited_post_summaries,
     render_global_ask_context,
 )
+from backend.app.global_ask_retrieval import VERIFIED_ORGANIZATION_LABEL_NEXT_ACTION
 from lineageweave.post_content_normalization import normalize_post_body
 from lineageweave.post_evaluation import (
     ContextualOrchestratorPostEvaluationClient,
@@ -2708,6 +2709,21 @@ def _verification_next_action(
     }.get(status_code, "Inspect the authorized cited posts and their evidence.")
 
 
+def _ask_next_action(
+    status_code: str,
+    cited_evidence: list[dict[str, object]],
+) -> str:
+    """Name Event Lineage when a corroborated organization label nominated the cite."""
+
+    if any(
+        isinstance(fact, dict) and fact.get("kind") == "verified_organization_label"
+        for item in cited_evidence
+        for fact in item.get("facts", [])
+    ):
+        return VERIFIED_ORGANIZATION_LABEL_NEXT_ACTION
+    return _verification_next_action(status_code)
+
+
 async def _verify_public_claims(
     question: str,
     sources: list[ChatSourceDocument],
@@ -2960,6 +2976,7 @@ async def ask_agent(
         cited_ids,
         verify_external=request.verify_external,
     )
+    evidence = cited_post_evidence(sources, cited_ids)
     async with pool.acquire() as conn:
         await persist_global_ask_turn(
             conn,
@@ -2979,12 +2996,12 @@ async def ask_agent(
         "answer_text": answer.answer_text,
         "cited_post_ids": cited_ids,
         "cited_posts": cited_post_summaries(sources, cited_ids),
-        "cited_post_evidence": cited_post_evidence(sources, cited_ids),
+        "cited_post_evidence": evidence,
         "source_post_ids": [source.post_id for source in sources],
         "timeline": global_ask_timeline(sources),
         "external_verification_status": verification_status,
         "external_claims": [claim.to_payload() for claim in external_claims],
-        "next_action": _verification_next_action(verification_status),
+        "next_action": _ask_next_action(verification_status, evidence),
     }
 
 

backend/app/organization_name_resolution_ingestion.py

@@ -23,6 +23,33 @@ def _context_sha256(context_text: str) -> str:
     return hashlib.sha256(context_text.encode("utf-8")).hexdigest()
 
 
+async def link_verified_organization_entity(
+    conn: asyncpg.Connection,
+    raw_name: str,
+    context_text: str,
+    corporate_entity_id: str,
+) -> None:
+    """Attach a corroborated resolution to its stable catalog entity id.
+
+    Display names are not identity keys: two catalog entities may legitimately
+    share one name. Only the exact raw-name/context cache row is linked, and
+    only after external verification has corroborated the resolution.
+    """
+    await conn.execute(
+        """
+        update organization_name_resolution
+           set resolved_corporate_entity_id = $1,
+               resolved_at = now()
+         where raw_organization_name = $2
+           and context_sha256 = $3
+           and verification_status_code = 'verify_corroborated'
+        """,
+        corporate_entity_id,
+        raw_name,
+        _context_sha256(context_text),
+    )
+
+
 async def resolve_organization_name(
     conn: asyncpg.Connection,
     resolution_client: OrganizationNameResolutionClient,