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/components/chat/revertedMessageDockState.ts

@@ -0,0 +1,73 @@
+import type { Message, Part } from '@opencode-ai/sdk/v2/client';
+import type { State } from '@/sync/types';
+
+export type RevertedMessageRecord = {
+    message: Message & { role: 'user' };
+    parts: Part[];
+};
+
+export type RevertedMessageDockState = {
+    revertMessageID?: string;
+    records: RevertedMessageRecord[];
+};
+
+const EMPTY_PARTS: Part[] = [];
+const EMPTY_REVERTED_RECORDS: RevertedMessageRecord[] = [];
+
+export const EMPTY_REVERTED_MESSAGE_DOCK_STATE: RevertedMessageDockState = {
+    revertMessageID: undefined,
+    records: EMPTY_REVERTED_RECORDS,
+};
+
+const isUserMessage = (message: Message): message is Message & { role: 'user' } => {
+    return message.role === 'user';
+};
+
+const areRecordsEqual = (left: RevertedMessageRecord[], right: RevertedMessageRecord[]): boolean => {
+    if (left === right) return true;
+    if (left.length !== right.length) return false;
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index]?.message !== right[index]?.message || left[index]?.parts !== right[index]?.parts) {
+            return false;
+        }
+    }
+    return true;
+};
+
+export const buildRevertedMessageDockState = (
+    state: Pick<State, 'session' | 'message' | 'part'>,
+    sessionId: string | null,
+    previous: RevertedMessageDockState = EMPTY_REVERTED_MESSAGE_DOCK_STATE,
+): RevertedMessageDockState => {
+    if (!sessionId) {
+        return EMPTY_REVERTED_MESSAGE_DOCK_STATE;
+    }
+
+    const session = state.session.find((item) => item.id === sessionId);
+    const revertMessageID = (session as { revert?: { messageID?: string } } | undefined)?.revert?.messageID;
+    if (!revertMessageID) {
+        return EMPTY_REVERTED_MESSAGE_DOCK_STATE;
+    }
+
+    const messages = state.message[sessionId] ?? [];
+    const records: RevertedMessageRecord[] = [];
+    for (const message of messages) {
+        if (!isUserMessage(message) || message.id < revertMessageID) {
+            continue;
+        }
+        records.push({
+            message,
+            parts: state.part[message.id] ?? EMPTY_PARTS,
+        });
+    }
+
+    const next = records.length === 0 ? EMPTY_REVERTED_RECORDS : records;
+    if (previous.revertMessageID === revertMessageID && areRecordsEqual(previous.records, next)) {
+        return previous;
+    }
+
+    return {
+        revertMessageID,
+        records: next,
+    };
+};