feat: keep GNB Event Lineage focus on a linked DAG node (v2.17.0)

AGENTS.md

@@ -179,6 +179,8 @@ Opening a Customer master related post uses the same focus path (ADR 0095).
 Do not invent a week, a theta, a cutoff body, a CalDAV event, or a customer.
 Opening an Ask Agent cited post uses the same focus path (ADR 0096). Do not
 invent a cited post.
+A linked Event Lineage node opened from that focused popup keeps the
+originating flags (ADR 0097). Do not invent a cited post.
 
 
 ## Tests

ARCHITECTURE.md

@@ -285,7 +285,8 @@ rebuild), the post list with a named Weekly VOC ISO-8601 week filter
 Calendar commitments use the same Event Lineage focus path (ADR 0094),
 Customer master related posts use the same Event Lineage focus path
 (ADR 0095). Ask Agent cited posts use the same Event Lineage focus path
-(ADR 0096), and the full detail popup includes Korean
+(ADR 0096). A linked Event Lineage node opened from a focused popup keeps
+those flags (ADR 0097), and the full detail popup includes Korean
 summary/key-events/R&R, VOC evidence excerpts, an Event Lineage panel
 (direct vs. indirect links; a link opens that post), the Keyman
 affiliate tree (resolved ancestors plus unresolved org roots), Keyman +

CHANGELOG.d/2.17.0-event-lineage-node-keeps-gnb-focus.md

@@ -0,0 +1,9 @@
+# 2.17.0 A linked Event Lineage node keeps GNB focus
+
+Opening a linked Event Lineage DAG node from a GNB-focused popup keeps
+Event Lineage focused and names Keyman and evaluation next. A home-list
+DAG walk does not. No TEPP theta is invented.
+
+Ask Agent now replaces an expired saved session once, then stores the new
+session. The Event Lineage timeline heading, list, and post-button
+accessibility labels are translated in the supported locales.

CHANGELOG.d/2.17.0-image-and-summary-boundaries.md

@@ -0,0 +1,8 @@
+# 2.17.0 — Preserve table image boundaries and avoid duplicate summaries
+
+## Fixed
+
+- Inline or invalid images no longer split a table row or surrounding
+  paragraph into disconnected semantic units.
+- Opening a post requests its summary once; the explicit retry action remains
+  the only path that requests another summary.

CHANGELOG.md

@@ -4,6 +4,16 @@ 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.17.0] - 2026-08-19
+
+### Added
+
+- Opening a linked Event Lineage DAG node from a GNB-focused popup now
+  keeps Event Lineage focused and names Keyman and evaluation as the next
+  read. A home-list DAG walk does not add that focus or copy. No TEPP
+  theta is invented. No cited post, customer, week, or cutoff body is
+  invented (ADR 0097 / ADR 0096 / ADR 0016).
+
 ## [2.16.0] - 2026-08-19
 
 ### Added

CLAUDE.md

@@ -99,3 +99,9 @@ Open Ask Agent. After an authorized answer, cited posts are current. Open
 a cited post: Event Lineage takes focus and names Keyman and evaluation
 next (ADR 0096). A home-list open does not. Do not invent a theta or a
 cited post.
+
+## Event Lineage DAG walk (v2.17.0)
+
+From a GNB-focused popup, open a linked Event Lineage node: Event Lineage
+stays focused and names the new post as current (ADR 0097). A home-list
+DAG walk does not. Do not invent a theta.

backend/app/activity_stream.py

@@ -29,6 +29,10 @@ def _stream_key(post_id: str) -> str:
     return f"activity:{post_id}"
 
 
+def _operation_stream_key(account_id: str) -> str:
+    return f"operation:{account_id}"
+
+
 def ticket_created_summary(ticket_title: str) -> str:
     """The ``summary`` field ``ticket_created`` producers must share."""
     return f"Ticket created: {ticket_title}"
@@ -74,6 +78,21 @@ async def publish_activity_event(
     )
 
 
+async def publish_operation_event(
+    client: redis.Redis,
+    actor_account_id: str,
+    event_type: str,
+    summary: str,
+) -> str:
+    """Register an account operation that has no single owning post."""
+    return await client.xadd(
+        _operation_stream_key(actor_account_id),
+        _activity_fields(event_type, actor_account_id, summary),
+        maxlen=1000,
+        approximate=True,
+    )
+
+
 def publish_activity_event_sync(
     client: Any,
     post_id: str,

backend/app/entity_relationship_ingestion.py

@@ -22,6 +22,9 @@
     OrganizationRelationship,
 )
 
+# Keep the relationship-network response bounded independently of frontend caps.
+_RELATIONSHIP_NETWORK_LIMIT = 100
+
 
 async def ingest_post_entity_relationships(
     conn: asyncpg.Connection,
@@ -90,7 +93,67 @@ def attach_resolved_entity_ids(
     ]
 
 
-async def fetch_post_counterparties(conn: asyncpg.Connection, post_id: str) -> list[dict[str, Any]]:
+def merge_relationship_network_rows(
+    rows: Sequence[Mapping[str, Any]],
+    candidates: Sequence[CorporateEntityCandidate],
+) -> list[dict[str, Any]]:
+    """Merge raw-name variants only when they share one unique catalog id."""
+    candidate_names = {candidate.corporate_entity_id: candidate.entity_name for candidate in candidates}
+    merged: dict[tuple[str, str], dict[str, Any]] = {}
+    for row in rows:
+        raw_name = str(row["counterparty_entity_name"])
+        corporate_entity_id = resolve_corporate_entity(raw_name, candidates)
+        key = ("entity", corporate_entity_id) if corporate_entity_id else ("name", raw_name)
+        entry = merged.setdefault(
+            key,
+            {
+                "counterparty_entity_name": candidate_names.get(corporate_entity_id, raw_name),
+                "corporate_entity_id": corporate_entity_id,
+                "total_post_count": 0,
+                "relationship_counts": {},
+            },
+        )
+        entry["total_post_count"] += int(row["total_post_count"])
+        relationships = row["relationships"]
+        if isinstance(relationships, str):
+            relationships = json.loads(relationships)
+        for relationship in relationships:
+            relationship_key = (
+                relationship["relationship_type_code"],
+                relationship["relationship_label"],
+            )
+            counts = entry["relationship_counts"]
+            counts[relationship_key] = counts.get(relationship_key, 0) + int(relationship["post_count"])
+
+    result: list[dict[str, Any]] = []
+    for entry in merged.values():
+        relationships = [
+            {
+                "relationship_type_code": code,
+                "relationship_label": label,
+                "post_count": post_count,
+            }
+            for (code, label), post_count in entry["relationship_counts"].items()
+        ]
+        relationships.sort(key=lambda relationship: (-relationship["post_count"], relationship["relationship_type_code"]))
+        result.append(
+            {
+                "counterparty_entity_name": entry["counterparty_entity_name"],
+                "corporate_entity_id": entry["corporate_entity_id"],
+                "total_post_count": entry["total_post_count"],
+                "relationships": relationships,
+                "multi_role": len(relationships) > 1,
+            }
+        )
+    result.sort(key=lambda entry: (-entry["total_post_count"], entry["counterparty_entity_name"]))
+    return result[:_RELATIONSHIP_NETWORK_LIMIT]
+
+
+async def fetch_post_counterparties(
+    conn: asyncpg.Connection,
+    post_id: str,
+    authorized_corporate_entity_ids: Sequence[str] = (),
+) -> list[dict[str, Any]]:
     """Classified counterparties with a cataloged org id when the name resolves.
 
     Unresolved names keep ``corporate_entity_id`` null -- a missing
@@ -108,7 +171,15 @@ async def fetch_post_counterparties(conn: asyncpg.Connection, post_id: str) -> l
         """,
         post_id,
     )
-    candidate_rows = await conn.fetch("select corporate_entity_id, entity_name from corporate_entity")
+    candidate_rows = (
+        await conn.fetch(
+            "select corporate_entity_id, entity_name from corporate_entity "
+            "where corporate_entity_id = any($1::uuid[])",
+            list(authorized_corporate_entity_ids),
+        )
+        if authorized_corporate_entity_ids
+        else []
+    )
     candidates = [
         CorporateEntityCandidate(str(row["corporate_entity_id"]), row["entity_name"])
         for row in candidate_rows
@@ -232,27 +303,13 @@ async def fetch_relationship_network(
         """,
         list(corporate_entity_ids),
     )
-    candidate_rows = await conn.fetch("select corporate_entity_id, entity_name from corporate_entity")
+    candidate_rows = await conn.fetch(
+        "select corporate_entity_id, entity_name from corporate_entity "
+        "where corporate_entity_id = any($1::uuid[])",
+        list(corporate_entity_ids),
+    )
     candidates = [
         CorporateEntityCandidate(str(row["corporate_entity_id"]), row["entity_name"])
         for row in candidate_rows
     ]
-    network: list[dict[str, Any]] = []
-    for row in rows:
-        relationships = (
-            json.loads(row["relationships"])
-            if isinstance(row["relationships"], str)
-            else row["relationships"]
-        )
-        network.append(
-            {
-                "counterparty_entity_name": row["counterparty_entity_name"],
-                "corporate_entity_id": resolve_corporate_entity(
-                    row["counterparty_entity_name"], candidates
-                ),
-                "total_post_count": row["total_post_count"],
-                "relationships": relationships,
-                "multi_role": len(relationships) > 1,
-            }
-        )
-    return network
+    return merge_relationship_network_rows(rows, candidates)

backend/app/five_w1h_ingestion.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from typing import Any
 
 import asyncpg
@@ -18,6 +18,7 @@ async def load_five_w1h_slots(
     conn: asyncpg.Connection,
     post_id: str,
     can_see_post: Callable[[asyncpg.Record], bool],
+    authorized_corporate_entity_ids: Sequence[str] = (),
 ) -> dict[str, Any]:
     """Build 5W1H from stored projections and visible lineage only."""
     summary = await fetch_persisted_summary(conn, post_id) or {}
@@ -41,7 +42,9 @@ async def load_five_w1h_slots(
         )
         linked_titles = [row["post_title"] for row in rows if can_see_post(row)]
 
-    counterparties = await fetch_post_counterparties(conn, post_id)
+    counterparties = await fetch_post_counterparties(
+        conn, post_id, authorized_corporate_entity_ids
+    )
     slots = assemble_five_w1h_slots(
         roles=summary.get("roles_and_responsibilities", []),
         key_events=summary.get("key_events", []),