perf(sessions): faster task open, less render churn and memory

[richardsolomou]

Problem

The agent session transcript is the app's hot path, and the renderer did redundant per-token work and grew memory unbounded over a session:

• Every streamed event fired 2–4 separate store notifications — roughly one render cycle per token.
• The root-mounted sidebar re-rendered on every token, and several hot components (the transcript container, the session view) re-rendered every event just to read one field off the whole session.
• immer's autofreeze deep-walked the whole, ever-growing events array on every append.
• A session's transcript stayed fully resident after you navigated away.
• On each turn end the conversation builder discarded its state and re-parsed every event.
• Code-block highlighting re-parsed on every remount; streaming-markdown re-split each render; a 20 Hz elapsed-timer re-rendered twice as often as it displayed.
• Resizing a panel wrote the whole layout to localStorage on every drag frame.
• The code-review surface was pulled into the initial bundle even when never opened.

Changes

Each fix is its own commit:

• Batch streamed events into one flush per frame instead of processing (and re-rendering) per token. Order preserved; flushes before permission handling and on teardown.
• Sidebar: subscribe to a signature of just the fields it renders (render-count test: 20 → 0). Plus narrow primitive selectors (useSessionIsCloud, useSessionHandoffInProgress) so the transcript container and session view stop re-rendering every event to read one flag.
• Disable immer autofreeze on the session store. Autofreeze re-walked the entire events array on every append (O(n) per event); events stay individually frozen for immutability, which is O(1) each.
• Evict backgrounded transcripts ~20s after their view unmounts, rehydrating from disk on return. Only disconnected, idle sessions are eligible; rehydration only restores when the transcript is still empty (a reconnect wins) and clears the evicted flag only on success so a transient read failure retries.
• Finalize the conversation builder in place on turn end instead of re-parsing every event, falling back to a full rebuild when the append-only prefix is invalid or events are out of ts-order.
• Cache code-block syntax highlighting across mounts (bounded LRU, collision-checked) so virtualized scroll stops re-parsing.
• Memoize the streaming-markdown block split.
• Halve the generating-indicator tick (20 → 10 updates/sec).
• Debounce panel-layout persistence (~60 writes/drag → 1; flushes on pagehide).
• Cap diff tokenization line length to guard minified/single-giant-line files.
• Lazy-load the code-review surface so it splits out of the initial bundle.
• Open a big task by painting the log tail first. Opening read + transferred + parsed the entire ndjson log before any paint (~540ms for an 18.5MB real task, dominated by disk read + IPC transfer). Now the open path paints the last ~1.5MB immediately (tens of ms) and the full read + reconnect replaces it with the authoritative session. New readLocalLogsTail RPC + a throwaway fast-paint; the full connect path is unchanged.

Overlaps with, and is intended to supersede, @KarloAldrete's open PRs #2957 (pre-freeze + eviction) and #2710 (sidebar).

Considered and left out: the active-turn row-context split — largely subsumed by event batching (rows now re-render per frame, not per token).

How did you test this?

• Unit tests added: event batching (order + flush-on-teardown), sidebar render-count + signature purity, highlight-cache reuse, debounced storage, evict/rehydrate residency (incl. rehydrate-from-disk and retry-after-failed-read), finalize-in-place equivalence across every scenario, the log tail read, and the tail-first paint.

• Full suites pass: @posthog/core 1859, @posthog/ui 1135; all 22 packages typecheck.

• Measured impact — isolated deterministic micro-benchmarks (main behavior vs branch), plus an on-app before/after over CDP:

  Fix	Before	After	Delta
  Open a big task — time to first content (18.5MB / 9k-event task, on-app cold)	3527ms	114ms	~31x
  Append 10k events (immer autofreeze walk)	2290ms	56ms	41x
  Re-highlight a 400-line block on remount (cache)	19.2ms	0.04ms	~520x
  Store updates per 100-event in-frame burst	100	1	100x
  Turn-end rebuild (3k events)	0.30ms	0.04ms	6.9x (sub-ms)

  Notes: fast-open v1 improves perceived latency (the tail paints at 114ms) — the full read still completes behind it (~3.5s cold), so total work isn't reduced yet (tail-only + backfill is the follow-up). The batching figure is best-case for a full in-frame burst; sparse streams coalesce less. Idle transcript scroll held 120fps / 0 dropped frames.

Automatic notifications

• Publish to changelog?
• Alert Sales and Marketing teams?

[github-actions]

React Doctor found no issues in the changed files. 🎉

_{Reviewed by React Doctor for commit 5c8aa00.}

[greptile-apps]

_{Reviews (1): Last reviewed commit: "perf(sessions): evict backgrounded trans..." | Re-trigger Greptile}

[greptile-apps]

_{Reviews (2): Last reviewed commit: "perf(sessions): narrow hot single-field ..." | Re-trigger Greptile}