perf: isolate chat streaming renders and reduce sidebar render cost (#1672)

Reworks the chat and session-sidebar render paths to cut render cascades, memory
  churn, and UI jank on large sessions and big session trees. Behavior is preserved;
  the changes are about *when* and *how much* the UI re-renders.

  ## Chat streaming
  - Freeze the streaming message's parts in the bulk turn projection during streaming,
    and re-inject live parts only in an isolated tail leaf, so a ~60/sec delta stream
    no longer re-runs the whole-session projection or re-renders unrelated rows.
    session with referential reuse of unchanged turns.
  - Memoize message rows with field-aware comparators instead of reference equality.
  - Replace the manual child-session polling in the task tool with the live SSE
    stream + a one-shot load, removing a fetch/settle state machine.

  ## History loading & scroll
  - Load an initial page fast, then prepend one older page in the background so the
    scroll container has headroom and "load older on scroll-up" fires before the user
    hits the absolute top.
  - Compensate scroll synchronously (in a layout effect, before paint) for prepends —
    including background prepends that don't originate from a user scroll — so the
    viewport stays stable instead of judder-correcting on the next frame.

  ## Markdown rendering
  - Render markdown synchronously *styled* on first paint (paragraphs, lists, code
    cards, tables, inline code) instead of raw escaped text; the async pass then only
    upgrades syntax-highlight colors. Eliminates the flash of full-width raw text.
  - Load KaTeX CSS eagerly with the main bundle instead of inside the lazy markdown
    chunk, avoiding a late stylesheet injection on first render.

  ## Sidebar
  - Hoist per-row recursive tree walks out of row comparators into per-group
    precomputed sets/keys; batch live-session lookups into a single map; add a
    group-level memo boundary.
  - Isolate rename drafts so per-keystroke typing doesn't repaint the row tree.

  ## Sync layer
  - Add a staleness guard so a slow message fetch can't repopulate a session the user
    navigated away from.
  - Throw on fetch failure for authoritative loaders so a transient blip can't read as
    an empty server response.

  ## Cleanup
  - Remove dead code (unused hooks, params, duplicated inline types) surfaced while
    reworking the above.

  ## Known issue
  - A rare, purely cosmetic first-paint width flash can still appear on large sessions;
    it has no behavioral or data impact and is tracked for a follow-up runtime trace.

packages/ui/src/sync/session-actions.ts

@@ -13,7 +13,10 @@ import { mergeSessionDirectoryMetadata, useGlobalSessionsStore } from "@/stores/
 import { useConfigStore } from "@/stores/useConfigStore"
 import { registerSessionDirectory } from "./sync-refs"
 import { isSyntheticPart } from "@/lib/messages/synthetic"
-import { materializeSessionSnapshots } from "./materialization"
+import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
+import { retry } from "./retry"
+import { isVSCodeRuntime } from "@/lib/desktop"
+import { isMobileSurfaceRuntime } from "@/lib/runtimeSurface"
 import { stripMessageDiffSnapshots, stripSessionDiffSnapshots } from "./sanitize"
 import { sessionEvents } from "@/lib/sessionEvents"
 import {
@@ -24,7 +27,7 @@ import {
   type SessionMetadataRecord,
 } from "@/lib/sessionReviewMetadata"
 
-const MESSAGE_REFETCH_LIMIT = 200
+const MESSAGE_REFETCH_LIMIT = 100
 const MESSAGE_REFETCH_SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const UNREVERT_REFETCH_ATTEMPTS = 3
 const UNREVERT_REFETCH_RETRY_MS = 150
@@ -1037,3 +1040,71 @@ export async function forkFromMessage(sessionId: string, messageId: string): Pro
   // Clear existing attachments and restore file parts from the forked message.
   restoreFilePartsToInput(fileParts)
 }
+
+// ---------------------------------------------------------------------------
+// Imperative fetch path — starts message loading on the same tick as
+// setCurrentSession, before the React commit cycle fires useEffect.
+// ---------------------------------------------------------------------------
+
+const FETCH_MESSAGES_LOADING = new Set<string>()
+const DESKTOP_INITIAL_PAGE_SIZE = 50
+const CONSTRAINED_INITIAL_PAGE_SIZE = 30
+
+const getFetchPageSize = () => {
+  if (isVSCodeRuntime() || isMobileSurfaceRuntime()) return CONSTRAINED_INITIAL_PAGE_SIZE
+  return DESKTOP_INITIAL_PAGE_SIZE
+}
+
+export async function fetchMessagesForSession(sessionID: string, directory?: string | null): Promise<void> {
+  const resolvedDir = directory ?? dir()
+  if (!resolvedDir) return
+
+  const s = sdk()
+  const store = directory
+    ? dirStoreForDirectory(directory)
+    : dirStore()
+
+  if (getSessionMaterializationStatus(store.getState(), sessionID).renderable) return
+
+  const loadingKey = `${resolvedDir}:${sessionID}`
+  if (FETCH_MESSAGES_LOADING.has(loadingKey)) return
+
+  FETCH_MESSAGES_LOADING.add(loadingKey)
+
+  try {
+    const result = await retry(async () => {
+      const response = await s.session.messages({
+        sessionID,
+        directory: resolvedDir,
+        limit: getFetchPageSize(),
+      })
+      return response
+    })
+
+    const records = (assertSdkSuccess(result, "session.messages") ?? [])
+      .filter((record: { info?: { id?: string } }) => !!record?.info?.id)
+    if (records.length === 0) return
+
+    // Staleness guard: a rapid session switch may have moved the user off this
+    // session while the fetch was in flight. Skip the write so a slow fetch
+    // can't repopulate (and un-evict) a session already navigated away from.
+    if (useSessionUIStore.getState().currentSessionId !== sessionID) return
+
+    store.setState((state) => {
+      const materialized = materializeSessionSnapshots(
+        state,
+        sessionID,
+        records.map((record: { info: Message; parts?: Part[] }) => ({
+          info: stripMessageDiffSnapshots(record.info),
+          parts: record.parts ?? [],
+        })),
+        { skipPartTypes: MESSAGE_REFETCH_SKIP_PARTS },
+      )
+      return { message: materialized.message, part: materialized.part }
+    })
+  } catch {
+    // Transient failure — the reactive path in ChatContainer will retry
+  } finally {
+    FETCH_MESSAGES_LOADING.delete(loadingKey)
+  }
+}