perf(tui): memoize subagent nodes per session

detail_subagents re-ran store.workflow_nodes (a recursive CTE or a
backend parse) on every paint of the Subagents tab -- every scroll step
and every 200ms toast repaint. Cache the rows per session in
_nodes_by_session, the _tool_by_session/_turns_by_session pattern,
cleared in the same reload/source-switch places; the export dataset
reads through the same memo.

Author: Gheat1

src/opentab/tui/app.py

@@ -177,6 +177,9 @@ def __init__(self, store: Store, args: argparse.Namespace, source_key: str = "")
         # Per-turn timeline (OpenCode + Claude), same lazy/cached-per-session deal as
         # the tool rows above -- a cheap per-session scan, never loaded at startup.
         self._turns_by_session: dict[str, list[dict]] = {}
+        # Subagent tree per session (workflow_nodes: a recursive CTE / backend parse),
+        # same lazy/cached-per-session deal -- the Subagents tab repaints every frame.
+        self._nodes_by_session: dict[str, list[dict]] = {}
         # Active range: custom bounds from CLI take precedence, else a day window
         # (None = all). Default is all time so the Months panel is actually useful.
         self.custom_since = args.since
@@ -1061,6 +1064,18 @@ def _scale_demo_turns(self, workflow_id: str, rows: list[dict]) -> list[dict]:
             r["cost"] = round(r.get("cost", 0) * k, 4)
         return rows
 
+    def session_node_rows(self, workflow_id: str) -> list[dict]:
+        # Subagent tree for one session, fetched once and cached. The store call is the
+        # heavy bit (a recursive CTE / backend parse) and detail_subagents runs on every
+        # paint, so memoize like session_tool_rows; the store already demo-scales nodes,
+        # and _priced_nodes copies rows before repricing, so the memo stays pristine.
+        cached = self._nodes_by_session.get(workflow_id)
+        if cached is not None:
+            return cached
+        rows = [dict(r) for r in self.store.workflow_nodes(workflow_id)]
+        self._nodes_by_session[workflow_id] = rows
+        return rows
+
     def _snapshot_real_costs(self) -> None:
         # Freshly loaded rows carry only real cost; seed the real/api snapshots so
         # _apply_price_mode is safe even before the (deferred) model scan runs.
@@ -1213,6 +1228,7 @@ def reload(self) -> None:
         self._resolve_project_roots()
         self._tool_by_session.clear()
         self._turns_by_session.clear()
+        self._nodes_by_session.clear()
         self._load_model_cache()
         self.zoom_project = None
         self.workflow_index = min(self.workflow_index, max(0, len(self.workflows) - 1))
@@ -1378,6 +1394,7 @@ def _reload_for_source(self, restore: dict | None = None) -> None:
         self._models_loaded = False
         self._tool_by_session.clear()
         self._turns_by_session.clear()
+        self._nodes_by_session.clear()
         self._load_model_cache()
         self._invalidate_workflow_cache()
         if restore:
@@ -1779,7 +1796,7 @@ def _models_dataset(rows: list) -> tuple[str, list[str], list[list]]:
 
     def _subagents_dataset(self, session: Workflow) -> tuple[str, list[str], list[list]]:
         nodes = self._priced_nodes(
-            [r for r in self.store.workflow_nodes(session.id) if r["depth"] > 0]
+            [r for r in self.session_node_rows(session.id) if r["depth"] > 0]
         )
         header = ["depth", "agent", "model", "cost", "tokens", "title"]
         rows = [

src/opentab/tui/renderer.py

@@ -1768,7 +1768,7 @@ def detail_models(self, workflow: Workflow, width: int) -> list[str]:
 
     def detail_subagents(self, workflow: Workflow, width: int) -> list[str]:
         rows = self._priced_nodes(
-            [row for row in self.store.workflow_nodes(workflow.id) if row["depth"] > 0]
+            [row for row in self.session_node_rows(workflow.id) if row["depth"] > 0]
         )
         if not rows:
             return ["# Subagents", "No subagents used in this workflow."]

test_opentab.py

@@ -7461,6 +7461,46 @@ def test_records_cost_probe_runs_lazily_not_at_construction():
         assert sub.records_cost is False
 
 
+def test_subagent_nodes_memoized_per_session():
+    def node(workflow_id, depth, agent, title):
+        return {
+            "id": f"{workflow_id}:{depth}",
+            "depth": depth,
+            "agent": agent,
+            "title": title,
+            "created_at": "",
+            "cost": 1.0,
+            "model_name": "anthropic/x",
+            "tokens_input": 1,
+            "tokens_output": 1,
+            "tokens_reasoning": 0,
+            "tokens_cache_read": 0,
+            "tokens_cache_write": 0,
+            "tokens_total": 2,
+        }
+
+    class NodeStore(FakeStore):
+        node_calls = 0
+
+        def workflow_nodes(self, workflow_id):
+            self.node_calls += 1
+            return [node(workflow_id, 0, "-", "root"), node(workflow_id, 1, "task", "sub")]
+
+    args = type("Args", (), {"since": None, "until": None, "days": None})()
+    app = ot.App(NodeStore([workflow("s1", "2026-06-01 12:00:00")]), args)
+    rows1 = app.session_node_rows("s1")
+    rows2 = app.session_node_rows("s1")
+    assert app.store.node_calls == 1  # every repaint after the first is memo-served
+    assert rows1 is rows2 and [r["depth"] for r in rows1] == [0, 1]
+    # The Subagents export dataset reads through the same memo (no new store call).
+    kind, header, rows = app._subagents_dataset(app.loaded[0])
+    assert kind == "subagents" and app.store.node_calls == 1
+    assert [r[0] for r in rows] == [1]  # depth-0 root filtered out, subagent kept
+    # Reload drops the memo -- the underlying data may have changed.
+    app.reload()
+    app.session_node_rows("s1")
+    assert app.store.node_calls == 2
+
 
 def test_wsl_mount_root_and_windows_path_mapping():
     with tempfile.TemporaryDirectory() as tmp: