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/session/sidebar/hooks/useProjectRepoStatus.ts

@@ -61,6 +61,16 @@ export const useProjectRepoStatus = (args: Args): void => {
   // any single project's branch settles (the old N² cascade).
   const resolvedInputKeyByProjectId = React.useRef<Map<string, string>>(new Map());
 
+  // TTL cache: when a project's `gitRepoStatus` refreshes (it can fire on
+  // every background poll even if the branch is unchanged), skip the
+  // `getRootBranch` re-resolution if we resolved the same input within
+  // the TTL window. 5 minutes matches the polling interval that typically
+  // drives these refreshes, so we always serve cached results on
+  // background updates and only re-resolve on cold start or actual
+  // branch changes (those still invalidate via the input-key check).
+  const rootBranchCacheRef = React.useRef<Map<string, { branch: string; at: number }>>(new Map());
+  const ROOT_BRANCH_TTL_MS = 5 * 60_000;
+
   React.useEffect(() => {
     let cancelled = false;
 
@@ -73,13 +83,16 @@ export const useProjectRepoStatus = (args: Args): void => {
         for (const id of resolvedInputKeyByProjectId.current.keys()) {
           if (!validIds.has(id)) {
             resolvedInputKeyByProjectId.current.delete(id);
+            rootBranchCacheRef.current.delete(id);
           }
         }
 
+        const now = Date.now();
         const pending = normalizedProjects.filter((project) => {
           const status = gitRepoStatus.get(project.normalizedPath);
           if (status?.isGitRepo === false) {
             resolvedInputKeyByProjectId.current.delete(project.id);
+            rootBranchCacheRef.current.delete(project.id);
             return false;
           }
           if (status?.isGitRepo !== true || status.branch === null) {
@@ -88,7 +101,21 @@ export const useProjectRepoStatus = (args: Args): void => {
           const currentBranch = status.branch.trim();
           const currentInputKey = `${project.normalizedPath}\0${currentBranch}`;
           const lastInputKey = resolvedInputKeyByProjectId.current.get(project.id);
-          return lastInputKey === undefined || lastInputKey !== currentInputKey;
+          if (lastInputKey === currentInputKey) {
+            // We've already resolved this exact (path, branch) pair.
+            // The TTL cache is just an extra protection for the case
+            // where the input key was reset by a transient blip —
+            // keep the existing map entry fresh so future re-renders
+            // hit the cache instead of refetching.
+            const cached = rootBranchCacheRef.current.get(project.id);
+            if (cached) cached.at = now;
+            return false;
+          }
+          // Same input? Serve from TTL cache if it's still warm.
+          if (lastInputKey !== undefined && now - (rootBranchCacheRef.current.get(project.id)?.at ?? 0) < ROOT_BRANCH_TTL_MS) {
+            return false;
+          }
+          return true;
         });
 
         if (pending.length === 0) {
@@ -113,6 +140,7 @@ export const useProjectRepoStatus = (args: Args): void => {
           return;
         }
 
+        const nowAfter = Date.now();
         setProjectRootBranches((prev) => {
           const next = new Map(prev);
           resolved.forEach(({ id, branch }) => {
@@ -122,8 +150,11 @@ export const useProjectRepoStatus = (args: Args): void => {
           });
           return next;
         });
-        resolved.forEach(({ id, inputKey }) => {
+        resolved.forEach(({ id, inputKey, branch }) => {
           resolvedInputKeyByProjectId.current.set(id, inputKey);
+          if (branch) {
+            rootBranchCacheRef.current.set(id, { branch, at: nowAfter });
+          }
         });
       };
       void run();
@@ -133,5 +164,9 @@ export const useProjectRepoStatus = (args: Args): void => {
       cancelled = true;
       clearTimeout(timer);
     };
+    // ROOT_BRANCH_TTL_MS is a module-level constant; intentionally not
+    // in the deps array since it never changes during the component
+    // lifetime.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [normalizedProjects, projectGitBranchesKey, gitRepoStatus, setProjectRootBranches]);
 };