perf: optimize session loading and desktop startup (#2545)

* perf: optimize session loading and startup

* fix(chat): stabilize history prepend virtualization

* perf: unblock first session open from startup network contention

Opening the first session after app start waited seconds for its message
fetch. Three independent contributors, each measured via CDP network
capture and Chromium net-log against the packaged desktop app:

- The active-session watchdog fired an uncapped per-directory status poll
  and child-session discovery burst at startup, and other subsystems
  (git checks, global session pages, command/skill discovery) fanned out
  alongside it, saturating the browser's ~6 HTTP/1.1 sockets per origin.
  Add a shared background-network gate (concurrency 3) and route the
  watchdog, poll-shaped git reads (also priority: low), global session
  pages, command/skill loads, and the background update check through it.

- The packaged renderer is cross-origin to the loopback backend, so every
  API call needs a CORS preflight; a few slow OpenCode-proxied requests
  held the whole pool while preflights and interactive traffic queued
  behind them. Lift Chromium's per-host connection cap for loopback via
  ignore-connections-limit in the Electron shell.

- OpenCode initializes each directory lazily on its first request, so the
  first click paid that cost interactively. Warm the last-used directory
  and the three most recently opened projects right after OpenCode
  readiness, sequentially and best-effort, overlapping UI startup.

Validation: new background-network tests, lifecycle warmup test, focused
store/sync tests, UI type-check and lint, dead-code report, node --check
plus electron type-check/lint, and CDP first-open measurements on the
packaged app (message fetch socket queue 5.4s -> 0.03s).

* fix(ui): keep interactive git reads out of background queue

---------

Co-authored-by: Bohdan Triapitsyn <artmore@protonmail.com>

packages/ui/src/components/session/SessionSidebar.tsx

@@ -96,6 +96,7 @@ import { buildSessionBootstrapDemands } from './sidebar/sessionBootstrapDemands'
 import { recordWorktreesSeen } from './sidebar/worktreeFirstSeen';
 import { getRuntimeKey } from '@/lib/runtime-switch';
 import { streamPerfCount, streamPerfMark } from '@/stores/utils/streamDebug';
+import { runBackgroundNetworkTask } from '@/lib/background-network';
 
 const PROJECT_COLLAPSE_STORAGE_KEY = 'oc.sessions.projectCollapse';
 const GROUP_ORDER_STORAGE_KEY = 'oc.sessions.groupOrder';
@@ -583,17 +584,18 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
           const projectPath = normalizePath(project.path);
           if (!projectPath) continue;
           try {
-            // Use store-cached isGitRepo when available; fall back to
-            // a direct check for projects the Git store hasn't seen yet.
-            // Forcing `ensureStatus` here also warms the store so the
-            // PR/render paths downstream can read isGitRepo for free.
-            const cachedIsGitRepo = useGitStore.getState().directories.get(projectPath)?.isGitRepo;
-            const isGitRepo = cachedIsGitRepo ?? await checkIsGitRepository(projectPath);
-            if (!isGitRepo) {
+            const worktrees = await runBackgroundNetworkTask(async () => {
+              // Use store-cached isGitRepo when available; fall back to
+              // a direct check for projects the Git store hasn't seen yet.
+              const cachedIsGitRepo = useGitStore.getState().directories.get(projectPath)?.isGitRepo;
+              const isGitRepo = cachedIsGitRepo ?? await checkIsGitRepository(projectPath);
+              if (!isGitRepo) return null;
+              return listProjectWorktrees({ id: project.id, path: projectPath });
+            });
+            if (worktrees === null) {
               worktreesByProject.delete(projectPath);
               continue;
             }
-            const worktrees = await listProjectWorktrees({ id: project.id, path: projectPath });
             if (cancelled) return;
             if (worktrees.length === 0) {
               worktreesByProject.delete(projectPath);

packages/ui/src/components/session/sidebar/hooks/useProjectRepoStatus.ts

@@ -3,6 +3,7 @@ import { getRootBranch } from '@/lib/worktrees/worktreeStatus';
 import { mapWithConcurrency } from '@/lib/concurrency';
 import { useGitStore } from '@/stores/useGitStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import { runBackgroundNetworkTask } from '@/lib/background-network';
 
 type Project = { id: string; path: string; normalizedPath: string };
 const ROOT_BRANCH_TTL_MS = 5 * 60_000;
@@ -36,7 +37,7 @@ export const useProjectRepoStatus = (args: Args): void => {
 
     // Trigger ensureStatus for each project to populate store
     normalizedProjects.forEach((project) => {
-      void ensureStatus(project.normalizedPath, git);
+      void runBackgroundNetworkTask(() => ensureStatus(project.normalizedPath, git));
     });
   }, [enabled, normalizedProjects, git, ensureStatus, setProjectRepoStatus]);
 
@@ -129,9 +130,11 @@ export const useProjectRepoStatus = (args: Args): void => {
         const entries = await mapWithConcurrency(pending, 2, async (project) => {
           const inputBranch = gitRepoStatus.get(project.normalizedPath)?.branch?.trim() ?? '';
           const inputKey = `${project.normalizedPath}\0${inputBranch}`;
-          const branch = await getRootBranch(
-            project.normalizedPath,
-            inputBranch ? { knownBranch: inputBranch } : undefined,
+          const branch = await runBackgroundNetworkTask(() =>
+            getRootBranch(
+              project.normalizedPath,
+              inputBranch ? { knownBranch: inputBranch } : undefined,
+            )
           ).catch(() => null);
           return { id: project.id, inputKey, branch };
         });