diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 96b775ba5..caeb1b434 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -862,12 +862,16 @@ new table needed. `lineageweave/knowledge_graph.py`'s
 (`edge_mention_team`, `edge_team_affiliation`, `edge_mention_organization`);
 `backend/app/post_summary_ingestion.py`'s `persist_post_summary` now
 resolves each R&R actor's identity, stores that id on
-`post_summary_role` (ADR 0019 — `entity_name` is not unique), and calls
-the same `persist_edges_for_post` Keyman ingestion already uses. A person R&R
-actor is opportunistically joined to an existing `cataloged_person` row
-by name (never originated by R&R itself -- documented gap in the ADR:
-`cataloged_person` needs `person_side_code`, which R&R's prompt does
-not currently capture).
+`post_summary_role` (ADR 0019 — `entity_name` and `person_name` are not
+unique), and calls the same `persist_edges_for_post` Keyman ingestion
+already uses. A person R&R actor is opportunistically joined to an
+existing `cataloged_person` row by name, ordered by `created_at` then
+`person_id` (never originated by R&R itself -- documented gap in the
+ADR: `cataloged_person` needs `person_side_code`, which R&R's prompt
+does not currently capture). Fetch returns `cataloged_person_id` as
+`catalog_node_id` so a person chip walks the stored row even when
+Keyman was not extracted on that post. Historical backfill leaves a
+role unbound when two same-named mentions already exist.
 
 ## Phase 12: a real counterparty organization is auto-created, not left permanently unresolved
 
diff --git a/CHANGELOG.d/0.88.1-role-person-catalog-identity.md b/CHANGELOG.d/0.88.1-role-person-catalog-identity.md
new file mode 100644
index 000000000..6577afff9
--- /dev/null
+++ b/CHANGELOG.d/0.88.1-role-person-catalog-identity.md
@@ -0,0 +1,2 @@
+R&R person chips read the stored catalog id. Historical person
+backfill leaves homonym mentions unbound.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 42239b071..8833a8ddd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,17 @@ 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).
 
+## [0.88.1] - 2026-08-16
+
+### Fixed
+
+- An R&R person chip now walks the catalog id stored on that role row
+  (ADR 0019). Two catalog people can share a display name; persist
+  orders by `created_at`, then `person_id`, and fetch does not rejoin
+  by `person_name`. Open a post whose R&R names a cataloged person
+  even when Keyman was not extracted on that post — the chip is a
+  button. Historical backfill leaves two same-named mentions unbound.
+
 ## [0.88.0] - 2026-08-16
 
 ### Added
diff --git a/CLAUDE.md b/CLAUDE.md
index 5096a8ea5..2c786c1de 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -35,3 +35,8 @@ cutoff before treating the body as reconstructed evidence (ADR 0016).
 cutoff capture (ADR 0017). `POST /api/analysis-runs/{id}/start`
 reconstructs that frozen cutoff bag (ADR 0021) and does not invent a
 theta. Hover the Result prefix to read the parent-choice digest.
+R&R chips read the catalog id stored on `post_summary_role`
+(ADR 0019), including `cataloged_person_id`. Do not rejoin
+`corporate_entity` by `entity_name` or `cataloged_person` by
+`person_name`. Historical backfill leaves a role unbound when two
+same-named mentions already exist on the post.
diff --git a/backend/app/post_summary_ingestion.py b/backend/app/post_summary_ingestion.py
index 3febf9b21..5ab802a33 100644
--- a/backend/app/post_summary_ingestion.py
+++ b/backend/app/post_summary_ingestion.py
@@ -1,14 +1,16 @@
 """Persist and load the popup's Korean summary / key events / R&R.
 
 ADR 0009 / 0019: an R&R actor is not just per-post free text -- when it
-is a team or organization, it is resolved to a shared catalog identity
-(``cataloged_team`` / ``corporate_entity``) stored on the role row and
-a Knowledge Graph mention edge is written, so the same "설계팀" or
-organization named across two posts becomes one linkable node. Fetch
-never reconstructs that id by ``entity_name``; that column is not unique.
-A person actor is opportunistically joined to an *existing*
-``cataloged_person`` row by name when Keyman extraction has already
-cataloged that name. The R&R evidence is written to
+is a team, organization, or already-cataloged person, it is resolved to
+a shared catalog identity (``cataloged_team`` / ``corporate_entity`` /
+``cataloged_person``) stored on the role row and a Knowledge Graph
+mention edge is written, so the same "설계팀", organization, or person
+named across two posts becomes one linkable node. Fetch never
+reconstructs that id by ``entity_name`` or ``person_name``; those
+columns are not unique. A person actor is opportunistically joined to
+an *existing* ``cataloged_person`` row by name when Keyman extraction
+has already cataloged that name, ordered by ``created_at`` then
+``person_id``. The R&R evidence is written to
 ``post_summary_person_mention`` rather than Keyman's
 ``post_person_mention`` so either extractor can replace its own result
 without leaving or deleting the other's evidence.
@@ -35,7 +37,11 @@
     NullCorporateHierarchyInferenceClient,
 )
 from lineageweave.fixtures import fixture_thread_cast
-from lineageweave.knowledge_graph import NODE_CORPORATE_ENTITY, NODE_TEAM
+from lineageweave.knowledge_graph import (
+    NODE_CORPORATE_ENTITY,
+    NODE_PERSON,
+    NODE_TEAM,
+)
 from lineageweave.ontology import ontology_annotations
 from lineageweave.post_summary import (
     ACTOR_TYPE_ORGANIZATION,
@@ -62,7 +68,7 @@ async def fetch_persisted_summary(
 
     ``catalog_node_id`` comes from the role row's catalog foreign keys
     (ADR 0019). This function does not join ``corporate_entity`` by
-    ``entity_name``.
+    ``entity_name`` or ``cataloged_person`` by ``person_name``.
     """
     header = await conn.fetchrow(
         "select korean_summary from post_summary_result where post_id = $1",
@@ -79,7 +85,8 @@ async def fetch_persisted_summary(
         select role.actor_name, role.responsibility, role.actor_type_code,
                role.affiliated_organization_name,
                role.cataloged_team_id,
-               role.cataloged_corporate_entity_id
+               role.cataloged_corporate_entity_id,
+               role.cataloged_person_id
           from post_summary_role role
          where role.post_id = $1
          order by role.actor_name
@@ -96,6 +103,9 @@ async def fetch_persisted_summary(
         elif row["cataloged_corporate_entity_id"] is not None:
             catalog_node_id = str(row["cataloged_corporate_entity_id"])
             catalog_node_type_code = NODE_CORPORATE_ENTITY
+        elif row["cataloged_person_id"] is not None:
+            catalog_node_id = str(row["cataloged_person_id"])
+            catalog_node_type_code = NODE_PERSON
         payload_roles.append(
             {
                 "actor_name": row["actor_name"],
@@ -215,6 +225,7 @@ async def _replace_summary_projection(
     for role_index, role in enumerate(summary.roles_and_responsibilities):
         cataloged_team_id = None
         cataloged_corporate_entity_id = None
+        cataloged_person_id = None
         if role.actor_type_code == ACTOR_TYPE_TEAM:
             cataloged_team_id = await upsert_team(
                 conn,
@@ -226,12 +237,16 @@ async def _replace_summary_projection(
             cataloged_corporate_entity_id = resolved_organization_ids.get(
                 role_index
             )
+        elif role.actor_type_code == ACTOR_TYPE_PERSON:
+            cataloged_person_id = await _existing_cataloged_person_id(
+                conn, role.actor_name
+            )
         await conn.execute(
             "insert into post_summary_role "
             "(post_id, actor_name, responsibility, actor_type_code, "
             "affiliated_organization_name, cataloged_team_id, "
-            "cataloged_corporate_entity_id) values "
-            "($1, $2, $3, $4, $5, $6, $7)",
+            "cataloged_corporate_entity_id, cataloged_person_id) values "
+            "($1, $2, $3, $4, $5, $6, $7, $8)",
             post_id,
             role.actor_name,
             role.responsibility,
@@ -239,6 +254,7 @@ async def _replace_summary_projection(
             role.affiliated_organization_name,
             cataloged_team_id,
             cataloged_corporate_entity_id,
+            cataloged_person_id,
         )
         if cataloged_team_id is not None:
             await conn.execute(
@@ -255,21 +271,37 @@ async def _replace_summary_projection(
                 post_id,
                 cataloged_corporate_entity_id,
             )
-        elif role.actor_type_code == ACTOR_TYPE_PERSON:
-            person_row = await conn.fetchrow(
-                "select person_id from cataloged_person where person_name = $1 limit 1",
-                role.actor_name,
+        elif cataloged_person_id is not None:
+            await conn.execute(
+                "insert into post_summary_person_mention (post_id, person_id) "
+                "values ($1, $2) on conflict do nothing",
+                post_id,
+                cataloged_person_id,
             )
-            if person_row is not None:
-                await conn.execute(
-                    "insert into post_summary_person_mention (post_id, person_id) "
-                    "values ($1, $2) on conflict do nothing",
-                    post_id,
-                    str(person_row["person_id"]),
-                )
     await persist_edges_for_post(conn, post_id)
 
 
+async def _existing_cataloged_person_id(
+    conn: asyncpg.Connection, person_name: str
+) -> str | None:
+    """Return the earliest existing catalog person for ``person_name``.
+
+    R&R does not create a ``cataloged_person`` row (ADR 0009). Two
+    people can share a display name, so this query orders by
+    ``created_at``, then ``person_id``, instead of ``LIMIT 1`` without
+    ``ORDER BY``.
+    """
+    person_row = await conn.fetchrow(
+        "select person_id from cataloged_person "
+        "where person_name = $1 "
+        "order by created_at, person_id limit 1",
+        person_name,
+    )
+    if person_row is None:
+        return None
+    return str(person_row["person_id"])
+
+
 def seeded_demo_summary() -> PostSummary:
     """Synthetic Korean summary for the demo public post -- not an LLM result."""
     return PostSummary(
diff --git a/docker/postgres-init/Dockerfile b/docker/postgres-init/Dockerfile
index 71e9fc733..49b257a9e 100644
--- a/docker/postgres-init/Dockerfile
+++ b/docker/postgres-init/Dockerfile
@@ -28,6 +28,7 @@ COPY migrations/0019_role_catalog_identity.sql /docker-entrypoint-initdb.d/20-ro
 COPY migrations/0020_analysis_run_retention_purge.sql /docker-entrypoint-initdb.d/21-analysis-run-retention-purge.sql
 COPY migrations/0021_analysis_run_reconstruction.sql /docker-entrypoint-initdb.d/22-analysis-run-reconstruction.sql
 COPY migrations/0022_analysis_source_snapshot_member.sql /docker-entrypoint-initdb.d/23-analysis-source-snapshot-member.sql
+COPY migrations/0023_role_person_catalog_identity.sql /docker-entrypoint-initdb.d/24-role-person-catalog-identity.sql
 # Official image already drops to this account at runtime; declare it so
 # the Dockerfile itself satisfies DS-0002 (explicit non-root USER).
 USER postgres
diff --git a/docs/adr/0009-cross-post-actor-identity.md b/docs/adr/0009-cross-post-actor-identity.md
index 7bdbfa091..ad10e6c56 100644
--- a/docs/adr/0009-cross-post-actor-identity.md
+++ b/docs/adr/0009-cross-post-actor-identity.md
@@ -121,7 +121,9 @@ Depends on [ADR 0006](0006-role-responsibility-agent-ontology.md) and
 [ADR 0007](0007-team-actor-type.md) (actor *type*) and
 `lineageweave.corporate_hierarchy_resolution` (Bhattacharya & Getoor,
 2007, cited there) for the organization-matching this ADR reuses rather
-than re-deriving.
+than re-deriving. [ADR 0019](0019-role-catalog-identity.md) stores the
+resolved catalog id on `post_summary_role` so fetch does not rejoin by
+display name.
 
 ## References (APA 7th)
 
diff --git a/docs/adr/0018-related-nodes-team-org-walk.md b/docs/adr/0018-related-nodes-team-org-walk.md
index ae0a1c331..137e07420 100644
--- a/docs/adr/0018-related-nodes-team-org-walk.md
+++ b/docs/adr/0018-related-nodes-team-org-walk.md
@@ -49,6 +49,9 @@ Thread-group run list visibility requires at least one ABAC-visible
   organization chip.
 - A later public post in a thread group no longer lists a January run
   that could not have known that post.
+- Catalog ids on those chips come from `post_summary_role` (ADR 0019).
+  Do not rejoin `corporate_entity` by `entity_name` or
+  `cataloged_person` by `person_name`.
 
 ## References
 
diff --git a/docs/adr/0019-role-catalog-identity.md b/docs/adr/0019-role-catalog-identity.md
index 32b5d0a09..e2e1d2c5c 100644
--- a/docs/adr/0019-role-catalog-identity.md
+++ b/docs/adr/0019-role-catalog-identity.md
@@ -24,26 +24,42 @@ normal form (Codd, 1970; Date, 2019).
 
 Team identity is already unique on
 `(team_name, affiliated_organization_name)`. Organization identity is
-not.
+not. Person display names are not unique either: two `cataloged_person`
+rows can share `person_name`. A fetch join on that name, or
+`LIMIT 1` without `ORDER BY`, can attach a later homonym.
 
 ## Decision
 
 `post_summary_role` stores the resolved catalog foreign keys
-(`cataloged_team_id`, `cataloged_corporate_entity_id`) written during
-`persist_post_summary`. `fetch_persisted_summary` reads those columns.
-It does not join `corporate_entity` by `entity_name`.
-
-Migration `0019_role_catalog_identity.sql` backfills existing rows from
-a post-scoped mention only when the name match is unique on that post.
-Two same-named mentions stay unbound rather than guessing.
+(`cataloged_team_id`, `cataloged_corporate_entity_id`,
+`cataloged_person_id`) written during `persist_post_summary`.
+`fetch_persisted_summary` reads those columns. It does not join
+`corporate_entity` by `entity_name` or `cataloged_person` by
+`person_name`. At most one catalog foreign key is set, and the set
+column must match `actor_type_code`.
+
+Person lookup, when it still resolves by name, orders by `created_at`,
+then `person_id`. It still does not create a `cataloged_person` row
+(ADR 0009 gap).
+
+Migration `0019_role_catalog_identity.sql` backfills team and
+organization rows from a post-scoped mention only when the name match
+is unique on that post. Migration `0023_role_person_catalog_identity.sql`
+does the same for people (`HAVING count(*) = 1`). Two same-named
+mentions stay unbound rather than guessing a UUID (Fellegi & Sunter,
+1969).
 
 ## Consequences
 
 - Open a post whose R&R names an organization that shares a display
   name with another catalog row. The button walks the resolved id, not
   the homonym.
-- Clicking that name still uses `GET /api/corporate-entities/{id}/related`
-  or `GET /api/teams/{id}/related`. Authz stays person/entity-parity:
+- Open a post whose R&R names a cataloged person. The chip is a button
+  even when Keyman extraction was not run on that post. Click it to
+  walk that person, not a later same-named row.
+- Clicking a team or organization name still uses
+  `GET /api/corporate-entities/{id}/related` or
+  `GET /api/teams/{id}/related`. Authz stays person/entity-parity:
   a team mentioned only on another corp's private post is 403; an
   unknown UUID is 404.
 
@@ -57,6 +73,10 @@ Date, C. J. (2019). *Database design and relational theory: Normal forms
 and all that jazz* (2nd ed.). Apress.
 https://doi.org/10.1007/978-1-4842-5540-7
 
+Fellegi, I. P., & Sunter, A. B. (1969). A theory for record linkage.
+*Journal of the American Statistical Association, 64*(328), 1183–1210.
+https://doi.org/10.1080/01621459.1969.10501049
+
 International Organization for Standardization. (2023). *ISO/IEC
 11179-1:2023: Information technology—Metadata registries (MDR)—Part 1:
 Framework*.
diff --git a/docs/doctoring/ROLE_CATALOG_IDENTITY_REFERENCES.md b/docs/doctoring/ROLE_CATALOG_IDENTITY_REFERENCES.md
new file mode 100644
index 000000000..bccfbae1f
--- /dev/null
+++ b/docs/doctoring/ROLE_CATALOG_IDENTITY_REFERENCES.md
@@ -0,0 +1,22 @@
+# R&R catalog identity — doctoring
+
+These are the standards and papers that ground ADR 0019. Cite them in
+APA 7th when you extend role identity binding or related-node
+authorization.
+
+Bhattacharya, I., & Getoor, L. (2007). Collective entity resolution in
+relational data. *ACM Transactions on Knowledge Discovery from Data,
+1*(1), Article 5. https://doi.org/10.1145/1217299.1217304
+
+Fellegi, I. P., & Sunter, A. B. (1969). A theory for record linkage.
+*Journal of the American Statistical Association, 64*(328), 1183–1210.
+https://doi.org/10.1080/01621459.1969.10501049
+
+Hu, V. C., Ferraiolo, D., Kuhn, R., Schnitzer, A., Sandlin, K.,
+Miller, R., & Scarfone, K. (2014). *Guide to attribute based access
+control (ABAC) definition and considerations* (NIST Special Publication
+800-162). National Institute of Standards and Technology.
+https://doi.org/10.6028/NIST.SP.800-162
+
+Reynolds, D. (Ed.). (2014). *The organization ontology*. World Wide Web
+Consortium. https://www.w3.org/TR/vocab-org/
diff --git a/frontend/package.json b/frontend/package.json
index 4c66c7205..16983140e 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,7 +1,7 @@
 {
   "name": "frontend",
   "private": true,
-  "version": "0.88.0",
+  "version": "0.88.1",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index b06693250..3953cbbed 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -789,6 +789,8 @@ describe("App, authenticated", () => {
                 responsibility: "고객 측 수신",
                 actor_type_code: "prov_person",
                 affiliated_organization_name: "Northridge Grid",
+                catalog_node_id: "person-priya",
+                catalog_node_type_code: "node_person",
               },
               {
                 actor_name: "당사",
@@ -1209,6 +1211,7 @@ describe("App, authenticated", () => {
     expect(screen.getByText("첫 번째 이벤트")).toBeInTheDocument();
     expect(screen.getByText(/우리 측 후속/)).toBeInTheDocument();
     expect(screen.getByRole("button", { name: "R&R Keyman: Ada West" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "R&R person: Priya Nair" })).toBeInTheDocument();
     expect(screen.getByText("당사").closest("li")).toHaveTextContent("Organization");
     expect(screen.queryByRole("button", { name: "R&R Keyman: 당사" })).not.toBeInTheDocument();
     await waitFor(() => expect(screen.getByText("간접")).toBeInTheDocument());
@@ -1388,6 +1391,17 @@ describe("App, authenticated", () => {
     );
   });
 
+  it("opens related nodes from an R&R person catalog id", async () => {
+    stubBackend();
+    render(<App />);
+    await userEvent.click(await screen.findByRole("button", { name: "View post: Public post" }));
+    await userEvent.click(await screen.findByRole("button", { name: "R&R person: Priya Nair" }));
+    await waitFor(() => expect(screen.getByText("Related to Priya Nair")).toBeInTheDocument());
+    expect(screen.getByText("Related to Priya Nair").closest(".related-keymen")).toHaveTextContent(
+      "Ada West (Our side)",
+    );
+  });
+
   it("opens related Keyman nodes from an R&R person", async () => {
     stubBackend();
     render(<App />);
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 0296fb6ba..6328200fd 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1278,7 +1278,24 @@ function PostDetailPopup({
                           const catalogId = rr.catalog_node_id;
                           const catalogType = rr.catalog_node_type_code;
                           let actorName: ReactNode = <strong>{rr.actor_name}</strong>;
-                          if (person) {
+                          if (catalogType === NODE_PERSON && catalogId) {
+                            actorName = (
+                              <button
+                                className="keyman-select"
+                                aria-label={`R&R person: ${rr.actor_name}`}
+                                onClick={() => {
+                                  setFocusEntity(null);
+                                  setFocusTeam(null);
+                                  setFocusPerson({
+                                    personId: catalogId,
+                                    personName: rr.actor_name,
+                                  });
+                                }}
+                              >
+                                <strong>{rr.actor_name}</strong>
+                              </button>
+                            );
+                          } else if (person) {
                             actorName = (
                               <button
                                 className="keyman-select"
diff --git a/lineageweave/__init__.py b/lineageweave/__init__.py
index 036dca1fa..e46585d99 100644
--- a/lineageweave/__init__.py
+++ b/lineageweave/__init__.py
@@ -55,4 +55,4 @@
     "sentence_excerpts",
 ]
 
-__version__ = "0.88.0"
+__version__ = "0.88.1"
diff --git a/lineageweave/fixtures.py b/lineageweave/fixtures.py
index b2a1e90a0..a65a9c7b4 100644
--- a/lineageweave/fixtures.py
+++ b/lineageweave/fixtures.py
@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from .models import Record
 
@@ -51,6 +51,43 @@ class FixtureThreadCast:
     body: str | None = None
 
 
+@dataclass(frozen=True)
+class HomonymPersonCatalogRow:
+    """One synthetic catalog person who shares a display name with another."""
+
+    person_name: str
+    person_side_code: str
+    last_known_job_title: str
+    created_at: datetime
+
+
+def homonym_person_catalog_rows() -> tuple[
+    HomonymPersonCatalogRow, HomonymPersonCatalogRow
+]:
+    """Two people who share a common Korean display name.
+
+    The name is not identifying. The earlier row is our-side sales; the
+    later row is a counterparty purchaser. A persist that uses
+    ``LIMIT 1`` without ``ORDER BY`` can bind either row. The designed
+    bind is the earlier ``created_at``, then ``person_id``.
+    """
+    shared_name = "Kim Cheolsu"
+    return (
+        HomonymPersonCatalogRow(
+            person_name=shared_name,
+            person_side_code="our_side",
+            last_known_job_title="Sales Manager",
+            created_at=datetime(2024, 1, 1, tzinfo=timezone.utc),
+        ),
+        HomonymPersonCatalogRow(
+            person_name=shared_name,
+            person_side_code="counterparty",
+            last_known_job_title="Purchasing Lead",
+            created_at=datetime(2024, 6, 1, tzinfo=timezone.utc),
+        ),
+    )
+
+
 def fixture_thread_cast(title: str) -> FixtureThreadCast | None:
     """Return the Keyman/VOC cast for a reconstruct or calendar fixture.
 
diff --git a/migrations/0001_initial_schema.sql b/migrations/0001_initial_schema.sql
index a94b05a0c..5b2a5b9a0 100644
--- a/migrations/0001_initial_schema.sql
+++ b/migrations/0001_initial_schema.sql
@@ -412,13 +412,36 @@ create table post_organization_mention (
 );
 
 -- ADR 0019: store the resolved catalog id on the role row itself.
--- corporate_entity.entity_name is not unique, and mention tables are
--- post-scoped, so reconstructing identity by name is not 3NF.
+-- corporate_entity.entity_name and cataloged_person.person_name are
+-- not unique, and mention tables are post-scoped, so reconstructing
+-- identity by name is not 3NF.
 alter table post_summary_role
     add column cataloged_team_id uuid references cataloged_team (team_id);
 alter table post_summary_role
     add column cataloged_corporate_entity_id uuid
         references corporate_entity (corporate_entity_id);
+alter table post_summary_role
+    add column cataloged_person_id uuid
+        references cataloged_person (person_id);
+alter table post_summary_role
+    add constraint post_summary_role_one_catalog_chk check (
+        (cataloged_team_id is not null)::int
+        + (cataloged_corporate_entity_id is not null)::int
+        + (cataloged_person_id is not null)::int
+        <= 1
+    );
+alter table post_summary_role
+    add constraint post_summary_role_catalog_type_chk check (
+        (cataloged_team_id is null or actor_type_code = 'prov_team')
+        and (
+            cataloged_corporate_entity_id is null
+            or actor_type_code = 'prov_organization'
+        )
+        and (
+            cataloged_person_id is null
+            or actor_type_code = 'prov_person'
+        )
+    );
 
 -- ---------------------------------------------------------------------
 -- Knowledge graph: person/company/post nodes, typed edges. The type
diff --git a/migrations/0023_role_person_catalog_identity.sql b/migrations/0023_role_person_catalog_identity.sql
new file mode 100644
index 000000000..299843f75
--- /dev/null
+++ b/migrations/0023_role_person_catalog_identity.sql
@@ -0,0 +1,65 @@
+-- ADR 0019 completion: persist the person catalog id resolved for an
+-- R&R actor. Fetching by person_name is not identifying -- two people
+-- can share a display name. Write-time persist orders by created_at,
+-- then person_id. Historical backfill copies a mention only when
+-- exactly one mentioned person on that post has this role's actor_name.
+
+alter table post_summary_role
+    add column if not exists cataloged_person_id uuid
+        references cataloged_person (person_id);
+
+do $$
+begin
+    if not exists (
+        select 1
+          from pg_constraint
+         where conname = 'post_summary_role_one_catalog_chk'
+    ) then
+        alter table post_summary_role
+            add constraint post_summary_role_one_catalog_chk check (
+                (cataloged_team_id is not null)::int
+                + (cataloged_corporate_entity_id is not null)::int
+                + (cataloged_person_id is not null)::int
+                <= 1
+            );
+    end if;
+    if not exists (
+        select 1
+          from pg_constraint
+         where conname = 'post_summary_role_catalog_type_chk'
+    ) then
+        alter table post_summary_role
+            add constraint post_summary_role_catalog_type_chk check (
+                (cataloged_team_id is null or actor_type_code = 'prov_team')
+                and (
+                    cataloged_corporate_entity_id is null
+                    or actor_type_code = 'prov_organization'
+                )
+                and (
+                    cataloged_person_id is null
+                    or actor_type_code = 'prov_person'
+                )
+            );
+    end if;
+end
+$$;
+
+-- People: copy a mention only when exactly one mentioned person on
+-- that post has this role's actor_name. Two same-named mentions stay
+-- unbound rather than guessing a UUID (Fellegi & Sunter, 1969).
+update post_summary_role role
+   set cataloged_person_id = matched.person_id
+  from (
+        select mention.post_id,
+               person.person_name,
+               min(person.person_id) as person_id
+          from post_summary_person_mention mention
+          join cataloged_person person
+            on person.person_id = mention.person_id
+         group by mention.post_id, person.person_name
+        having count(*) = 1
+       ) matched
+ where role.actor_type_code = 'prov_person'
+   and role.cataloged_person_id is null
+   and role.post_id = matched.post_id
+   and role.actor_name = matched.person_name;
diff --git a/migrations/rollback/0023_role_person_catalog_identity.sql b/migrations/rollback/0023_role_person_catalog_identity.sql
new file mode 100644
index 000000000..c61532db8
--- /dev/null
+++ b/migrations/rollback/0023_role_person_catalog_identity.sql
@@ -0,0 +1,9 @@
+-- Fail-closed rollback for migration 0023.
+--
+-- Drops the persisted person catalog identity on post_summary_role.
+-- Team and organization columns from 0019 remain.
+
+alter table if exists post_summary_role
+    drop constraint if exists post_summary_role_catalog_type_chk,
+    drop constraint if exists post_summary_role_one_catalog_chk,
+    drop column if exists cataloged_person_id;
diff --git a/pyproject.toml b/pyproject.toml
index 5a4aa12bc..b24e4f8e3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "lineageweave"
-version = "0.88.0"
+version = "0.88.1"
 description = "Reconstructs git-branch-style lineage DAGs from scattered short records using multi-channel score fusion and LLM adjudication."
 readme = "README.md"
 license = { text = "MIT" }
diff --git a/scripts/seed_demo_data.py b/scripts/seed_demo_data.py
index 8cb1f0ea1..f34cbe0d2 100644
--- a/scripts/seed_demo_data.py
+++ b/scripts/seed_demo_data.py
@@ -124,6 +124,7 @@ def seed(
             cur.execute((migrations / "0020_analysis_run_retention_purge.sql").read_text())
             cur.execute((migrations / "0021_analysis_run_reconstruction.sql").read_text())
             cur.execute((migrations / "0022_analysis_source_snapshot_member.sql").read_text())
+            cur.execute((migrations / "0023_role_person_catalog_identity.sql").read_text())
             cur.execute(
                 """
                 insert into common_lookup_value (lookup_category, lookup_code, lookup_label, display_order) values
diff --git a/tests/test_analysis_run_registry_schema.py b/tests/test_analysis_run_registry_schema.py
index 6041d3090..82ffd60f0 100644
--- a/tests/test_analysis_run_registry_schema.py
+++ b/tests/test_analysis_run_registry_schema.py
@@ -278,6 +278,7 @@ def test_registry_contract_is_normalized_and_has_one_temporal_authority() -> Non
     assert "0020_analysis_run_retention_purge.sql" in dockerfile
     assert "0021_analysis_run_reconstruction.sql" in dockerfile
     assert "0022_analysis_source_snapshot_member.sql" in dockerfile
+    assert "0023_role_person_catalog_identity.sql" in dockerfile
     seed = (_ROOT / "scripts" / "seed_demo_data.py").read_text(encoding="utf-8")
     assert seed.index("0019_role_catalog_identity.sql") < seed.index(
         "0020_analysis_run_retention_purge.sql"
@@ -288,6 +289,9 @@ def test_registry_contract_is_normalized_and_has_one_temporal_authority() -> Non
     assert seed.index("0021_analysis_run_reconstruction.sql") < seed.index(
         "0022_analysis_source_snapshot_member.sql"
     )
+    assert seed.index("0022_analysis_source_snapshot_member.sql") < seed.index(
+        "0023_role_person_catalog_identity.sql"
+    )
     assert "analysis_run_registry_not_empty" in rollback
     retention = _RETENTION_MIGRATION.read_text(encoding="utf-8")
     retention_rollback = _RETENTION_ROLLBACK.read_text(encoding="utf-8")
diff --git a/tests/test_documentation_hygiene.py b/tests/test_documentation_hygiene.py
index 6dc89dff8..ba7258159 100644
--- a/tests/test_documentation_hygiene.py
+++ b/tests/test_documentation_hygiene.py
@@ -8,6 +8,11 @@
 
 _ROOT = Path(__file__).resolve().parents[1]
 _ADR_DIRECTORY = _ROOT / "docs" / "adr"
+_ROLE_CATALOG_COLUMNS = (
+    "cataloged_team_id",
+    "cataloged_corporate_entity_id",
+    "cataloged_person_id",
+)
 _ADR_NAME = re.compile(r"^(?P<number>[0-9]{4})-.+\.md$")
 _FORBIDDEN_MARKERS = (
     "PLACEHOLDER_DO_NOT_WRITE",
@@ -37,3 +42,52 @@ def test_adr_numbers_are_unique_and_documents_are_not_placeholders() -> None:
     counts = Counter(number for number, _ in numbered_paths)
     duplicates = sorted(number for number, count in counts.items() if count > 1)
     assert duplicates == [], f"duplicate ADR numbers: {duplicates}"
+
+
+def test_fetch_persisted_summary_reads_stored_catalog_ids() -> None:
+    """ADR 0019: fetch must not rejoin the catalog by a non-unique name."""
+
+    source = (_ROOT / "backend" / "app" / "post_summary_ingestion.py").read_text(
+        encoding="utf-8"
+    )
+    assert "org.entity_name = role.actor_name" not in source
+    assert "role.cataloged_team_id" in source
+    assert "role.cataloged_corporate_entity_id" in source
+    assert "role.cataloged_person_id" in source
+    assert "order by created_at, person_id limit 1" in source
+    assert "where person_name = $1 limit 1" not in source
+
+
+def test_role_catalog_identity_migration_is_wired() -> None:
+    """Fresh stacks and seed must apply the catalog-identity columns."""
+
+    dockerfile = (_ROOT / "docker" / "postgres-init" / "Dockerfile").read_text(
+        encoding="utf-8"
+    )
+    seed = (_ROOT / "scripts" / "seed_demo_data.py").read_text(encoding="utf-8")
+    migration_0019 = (_ROOT / "migrations" / "0019_role_catalog_identity.sql").read_text(
+        encoding="utf-8"
+    )
+    migration_0023 = (
+        _ROOT / "migrations" / "0023_role_person_catalog_identity.sql"
+    ).read_text(encoding="utf-8")
+    initial = (_ROOT / "migrations" / "0001_initial_schema.sql").read_text(
+        encoding="utf-8"
+    )
+    assert "0019_role_catalog_identity.sql" in dockerfile
+    assert "0023_role_person_catalog_identity.sql" in dockerfile
+    assert "0019_role_catalog_identity.sql" in seed
+    assert "0023_role_person_catalog_identity.sql" in seed
+    assert seed.index("0022_analysis_source_snapshot_member.sql") < seed.index(
+        "0023_role_person_catalog_identity.sql"
+    )
+    assert "cataloged_team_id" in migration_0019
+    assert "cataloged_corporate_entity_id" in migration_0019
+    assert "cataloged_person_id" in migration_0023
+    assert "cataloged_person_id" in initial
+    for column_name in _ROLE_CATALOG_COLUMNS:
+        assert len(column_name.split("_")) >= 2
+    assert "having count(*) = 1" in migration_0019
+    assert "having count(*) = 1" in migration_0023
+    assert "distinct on" not in migration_0019.lower()
+    assert "distinct on" not in migration_0023.lower()
diff --git a/tests/test_ingestion_transaction_contracts.py b/tests/test_ingestion_transaction_contracts.py
index d2994e2c4..85229454f 100644
--- a/tests/test_ingestion_transaction_contracts.py
+++ b/tests/test_ingestion_transaction_contracts.py
@@ -211,6 +211,7 @@ async def fetch(self, query: str, *args: Any) -> list[dict[str, Any]]:
         if "from post_summary_role" in compact:
             assert "entity_name" not in compact
             assert "cataloged_corporate_entity_id" in compact
+            assert "cataloged_person_id" in compact
             return [
                 {
                     "actor_name": "Synthetic Design Team",
@@ -219,6 +220,7 @@ async def fetch(self, query: str, *args: Any) -> list[dict[str, Any]]:
                     "affiliated_organization_name": "Synthetic Energy",
                     "cataloged_team_id": None,
                     "cataloged_corporate_entity_id": None,
+                    "cataloged_person_id": None,
                 }
             ]
         raise AssertionError(f"unexpected fetch query: {compact}")
@@ -502,8 +504,15 @@ def test_role_catalog_identity_is_stored_on_the_role_row() -> None:
     fetch_sql = fetch_source.split("async def fetch_persisted_summary", 1)[1]
     fetch_sql = fetch_sql.split("async def persist_post_summary", 1)[0]
     assert "org.entity_name = role.actor_name" not in fetch_sql
+    person_upgrade = (
+        root / "migrations" / "0023_role_person_catalog_identity.sql"
+    ).read_text(encoding="utf-8")
     assert "cataloged_corporate_entity_id" in fetch_sql
+    assert "cataloged_person_id" in fetch_sql
     assert "cataloged_team_id" in initial
+    assert "cataloged_person_id" in initial
     assert "cataloged_corporate_entity_id" in upgrade
+    assert "cataloged_person_id" in person_upgrade
     assert "0019_role_catalog_identity.sql" in dockerfile
+    assert "0023_role_person_catalog_identity.sql" in dockerfile
     assert "ADR 0019" in changelog
diff --git a/tests/test_person_mention_projection.py b/tests/test_person_mention_projection.py
index 81e63a75f..c8318878a 100644
--- a/tests/test_person_mention_projection.py
+++ b/tests/test_person_mention_projection.py
@@ -41,8 +41,10 @@
     NODE_POST,
     NODE_TEAM,
 )
+from lineageweave.fixtures import homonym_person_catalog_rows
 from lineageweave.post_summary import (
     ACTOR_TYPE_ORGANIZATION,
+    ACTOR_TYPE_PERSON,
     PostSummary,
     RoleResponsibility,
 )
@@ -542,3 +544,183 @@ def test_homonym_organization_role_binds_the_resolved_catalog_id(
 
     database_dsn, post_id, _summary_person_id = projection_database.split("|")
     asyncio.run(_exercise_homonym_organization_role_binding(database_dsn, post_id))
+
+
+async def _exercise_same_name_person_catalog_order(
+    database_dsn: str,
+    post_id: str,
+) -> None:
+    """Two people with the same name must bind the earlier catalog row."""
+
+    earlier, later = homonym_person_catalog_rows()
+    connection = await asyncpg.connect(database_dsn)
+    try:
+        earlier_id = str(
+            await connection.fetchval(
+                """
+                insert into cataloged_person
+                    (person_name, person_side_code, last_known_job_title, created_at)
+                values ($1, $2, $3, $4)
+                returning person_id
+                """,
+                earlier.person_name,
+                earlier.person_side_code,
+                earlier.last_known_job_title,
+                earlier.created_at,
+            )
+        )
+        later_id = str(
+            await connection.fetchval(
+                """
+                insert into cataloged_person
+                    (person_name, person_side_code, last_known_job_title, created_at)
+                values ($1, $2, $3, $4)
+                returning person_id
+                """,
+                later.person_name,
+                later.person_side_code,
+                later.last_known_job_title,
+                later.created_at,
+            )
+        )
+        await persist_post_summary(
+            connection,
+            post_id,
+            PostSummary(
+                korean_summary="김철수가 후속을 맡았다.",
+                roles_and_responsibilities=(
+                    RoleResponsibility(
+                        actor_name=earlier.person_name,
+                        responsibility="후속",
+                        actor_type_code=ACTOR_TYPE_PERSON,
+                    ),
+                ),
+            ),
+        )
+        payload = await fetch_persisted_summary(connection, post_id)
+        assert payload is not None
+        roles = payload["roles_and_responsibilities"]
+        assert len(roles) == 1
+        stored_id = str(
+            await connection.fetchval(
+                """
+                select cataloged_person_id
+                  from post_summary_role
+                 where post_id = $1 and actor_name = $2
+                """,
+                post_id,
+                earlier.person_name,
+            )
+        )
+        assert stored_id == earlier_id
+        assert stored_id != later_id
+        assert roles[0]["catalog_node_id"] == earlier_id
+        assert roles[0]["catalog_node_type_code"] == NODE_PERSON
+    finally:
+        await connection.close()
+
+
+def test_same_name_person_roles_bind_the_earliest_catalog_row(
+    projection_database: str,
+) -> None:
+    """ADR 0019: R&R person lookup must order by created_at, then person_id."""
+
+    database_dsn, post_id, _summary_person_id = projection_database.split("|")
+    asyncio.run(_exercise_same_name_person_catalog_order(database_dsn, post_id))
+
+
+async def _exercise_homonym_person_backfill_stays_unbound(
+    database_dsn: str,
+    post_id: str,
+) -> None:
+    """Two same-named mentions on one post must not guess a UUID at backfill."""
+
+    earlier, later = homonym_person_catalog_rows()
+    connection = await asyncpg.connect(database_dsn)
+    try:
+        earlier_id = str(
+            await connection.fetchval(
+                """
+                insert into cataloged_person
+                    (person_name, person_side_code, last_known_job_title, created_at)
+                values ($1, $2, $3, $4)
+                returning person_id
+                """,
+                earlier.person_name,
+                earlier.person_side_code,
+                earlier.last_known_job_title,
+                earlier.created_at,
+            )
+        )
+        later_id = str(
+            await connection.fetchval(
+                """
+                insert into cataloged_person
+                    (person_name, person_side_code, last_known_job_title, created_at)
+                values ($1, $2, $3, $4)
+                returning person_id
+                """,
+                later.person_name,
+                later.person_side_code,
+                later.last_known_job_title,
+                later.created_at,
+            )
+        )
+        await connection.execute(
+            """
+            insert into post_summary_result (post_id, korean_summary)
+            values ($1, '동명이인 후속')
+            on conflict (post_id) do update
+            set korean_summary = excluded.korean_summary
+            """,
+            post_id,
+        )
+        await connection.execute(
+            "delete from post_summary_role where post_id = $1",
+            post_id,
+        )
+        await connection.execute(
+            """
+            insert into post_summary_role
+                (post_id, actor_name, responsibility, actor_type_code)
+            values ($1, $2, '후속', 'prov_person')
+            """,
+            post_id,
+            earlier.person_name,
+        )
+        await connection.execute(
+            """
+            insert into post_summary_person_mention (post_id, person_id)
+            values ($1, $2), ($1, $3)
+            """,
+            post_id,
+            earlier_id,
+            later_id,
+        )
+        backfill = (
+            Path(__file__).resolve().parents[1]
+            / "migrations"
+            / "0023_role_person_catalog_identity.sql"
+        ).read_text(encoding="utf-8")
+        await connection.execute(backfill)
+        stored_id = await connection.fetchval(
+            """
+            select cataloged_person_id
+              from post_summary_role
+             where post_id = $1 and actor_name = $2
+            """,
+            post_id,
+            earlier.person_name,
+        )
+        assert stored_id is None
+    finally:
+        await connection.close()
+
+
+def test_homonym_person_backfill_leaves_the_role_unbound(
+    projection_database: str,
+) -> None:
+    """ADR 0019: HAVING count(*) = 1 refuses a two-person name collision."""
+
+    database_dsn, post_id, _summary_person_id = projection_database.split("|")
+    asyncio.run(_exercise_homonym_person_backfill_stays_unbound(database_dsn, post_id))
diff --git a/tests/test_voc_evidence.py b/tests/test_voc_evidence.py
index 3c7ebc98a..0b99befa3 100644
--- a/tests/test_voc_evidence.py
+++ b/tests/test_voc_evidence.py
@@ -2,7 +2,11 @@
 
 from __future__ import annotations
 
-from lineageweave.fixtures import fixture_thread_cast, sample_records
+from lineageweave.fixtures import (
+    fixture_thread_cast,
+    homonym_person_catalog_rows,
+    sample_records,
+)
 from lineageweave.voc_evidence import first_excerpt_for, sentence_excerpts
 
 _BODY = (
@@ -65,3 +69,15 @@ def test_proj_alpha_cast_names_northridge_and_uncast_stays_empty() -> None:
     alpha = [rec.label for rec in sample_records() if rec.secondary_key == "proj-alpha"]
     assert len(alpha) == 5
     assert all(fixture_thread_cast(title) is not None for title in alpha)
+
+
+def test_homonym_person_catalog_rows_share_a_name_and_order_by_created_at() -> None:
+    """Two catalog people can share a display name; the earlier row is first."""
+
+    earlier, later = homonym_person_catalog_rows()
+    assert earlier.person_name == later.person_name
+    assert earlier.person_name == "Kim Cheolsu"
+    assert earlier.created_at < later.created_at
+    assert earlier.person_side_code == "our_side"
+    assert later.person_side_code == "counterparty"
+    assert earlier.last_known_job_title != later.last_known_job_title
diff --git a/uv.lock b/uv.lock
index 6915a3531..526cf4741 100644
--- a/uv.lock
+++ b/uv.lock
@@ -454,7 +454,7 @@ wheels = [
 
 [[package]]
 name = "lineageweave"
-version = "0.87.0"
+version = "0.88.1"
 source = { virtual = "." }
 dependencies = [
     { name = "certifi" },