From 85400459e980272d2f3fe7846b10db841df6b646 Mon Sep 17 00:00:00 2001
From: Bohdan Triapitsyn <artmore@protonmail.com>
Date: Tue, 21 Jul 2026 20:52:20 +0300
Subject: [PATCH] perf: overhaul session loading, caching, and runtime
 isolation (#2360)

Improve OpenChamber responsiveness under large session workloads while fixing
cache, synchronization, and persistence correctness across runtimes, projects,
directories, and worktrees.

- prioritize selected and visible sessions during bootstrap and defer
  non-critical enrichment work
- reduce redundant message loading, event processing, store publication, and
  hidden sidebar work
- prevent stale session and message requests from overwriting newer
  authoritative state
- preserve existing data when authoritative fetches fail instead of treating
  failures as successful empty responses
- scope session materialization, messages, drafts, queues, todos, pins,
  permissions, folders, tabs, Git state, and pull request data by runtime and
  directory identity
- harden runtime switching, reconnect, cleanup, mutation reconciliation, and
  persisted-state ordering
- preserve live subagent Task linkage when metadata arrives after an older
  message request or while streaming parts are suspended
- coalesce overlapping tail refreshes without losing newer refresh demand
- improve cold-session loading by moving deferrable work out of the critical
  bootstrap path
- isolate URL authentication, mobile credentials, native secrets, and other
  runtime-owned state across endpoint changes
- bound long-lived caches and remove avoidable allocations from event and
  rendering hot paths
- limit virtualization to archive collections where it improves rendering
  without disrupting active sidebar layout
- stabilize session folders, pin ordering, expanded state, and persisted
  sidebar behavior
- open skill files through the same secure editor and outside-workspace grant
  flow used by file navigation, including worktree sessions
- expand regression coverage for stale completions, runtime collisions,
  reconnect behavior, persistence races, authoritative empty results, and
  subagent refresh ordering
- document the updated synchronization, cache ownership, performance, and
  runtime-isolation invariants
---
 .../openchamber-change-discipline/SKILL.md    |   2 +-
 .../skills/performance-engineering/SKILL.md   |  24 +
 .agents/skills/sync-state-invariants/SKILL.md |  31 +
 .gitignore                                    |   1 +
 bun.lock                                      |  11 +-
 package.json                                  |   1 +
 packages/electron/README.md                   |   9 +-
 packages/electron/main.mjs                    |   8 +-
 .../NotificationService.swift                 |  11 +
 .../App/OpenChamberWidget/WidgetShared.swift  |   3 +-
 packages/ui/src/apps/MobileChangesSurface.tsx |   4 +-
 .../ui/src/apps/mobileConnections.test.ts     |  14 +-
 packages/ui/src/apps/mobileConnections.ts     |  41 +-
 packages/ui/src/apps/mobileWidgetSnapshot.ts  |   5 +-
 packages/ui/src/apps/runtimeEndpointReset.ts  |  12 +
 .../ui/src/components/chat/ChatContainer.tsx  | 151 ++--
 packages/ui/src/components/chat/ChatInput.tsx | 291 +++----
 .../ui/src/components/chat/ChatMessage.tsx    |  22 +-
 .../components/chat/MarkdownRendererImpl.tsx  |  70 +-
 .../ui/src/components/chat/MessageList.tsx    |   4 +-
 .../chat/MobileSessionStatusBar.test.ts       |  18 +
 .../chat/MobileSessionStatusBar.tsx           |  60 +-
 .../ui/src/components/chat/ModelControls.tsx  |  10 +-
 .../components/chat/QueuedMessageChips.tsx    |  33 +-
 packages/ui/src/components/chat/StatusRow.tsx |  12 +-
 .../components/chat/hooks/useTurnRecords.ts   |  10 +-
 .../chat/lib/turns/turnProjectionCache.ts     |   9 +-
 .../chat/message/parts/ProgressiveGroup.tsx   |  14 +-
 .../comments/useInlineCommentController.ts    |  55 +-
 .../ui/src/components/layout/ContextPanel.tsx |  25 +-
 packages/ui/src/components/layout/Header.tsx  | 125 ++-
 .../ui/src/components/layout/MainLayout.tsx   |  10 +-
 .../components/layout/SidebarFilesTree.tsx    |  16 +-
 .../ui/src/components/layout/VSCodeLayout.tsx |  10 +-
 .../mainLayoutMobileSidebarMount.test.ts      |  15 +-
 .../src/components/session/SessionSidebar.tsx | 456 ++++++-----
 .../session/sidebar/DOCUMENTATION.md          |  29 +-
 .../session/sidebar/SessionGroupSection.tsx   | 132 ++--
 .../session/sidebar/SessionNodeItem.tsx       | 158 ++--
 .../sidebar/SidebarActivitySections.tsx       |  28 +-
 .../session/sidebar/SidebarProjectsList.tsx   |   6 +-
 .../sidebar/authoritativeSessionCleanup.ts    |  31 +
 .../sidebar/hooks/pinnedSessionCleanup.ts     |  20 -
 .../sidebar/hooks/useArchivedAutoFolders.ts   |  12 +-
 .../useAuthoritativeSessionCleanup.test.ts    |  44 ++
 .../hooks/useAuthoritativeSessionCleanup.ts   |  35 +
 .../sidebar/hooks/useProjectRepoStatus.ts     |  18 +-
 .../hooks/useProjectSessionSelection.ts       |  36 +-
 .../sidebar/hooks/useSessionActions.ts        |  21 +-
 .../sidebar/hooks/useSessionFolderCleanup.ts  |  80 --
 .../sidebar/hooks/useSessionPrefetch.ts       | 124 +--
 .../sidebar/hooks/useSessionSearchEffects.ts  |  10 +-
 .../hooks/useSessionSidebarSections.ts        |  71 +-
 .../hooks/useSidebarPersistence.test.ts       |  26 -
 .../sidebar/hooks/useSidebarPersistence.ts    |  69 +-
 .../sidebar/hooks/useStickyProjectHeaders.ts  |  17 +-
 .../sidebar/sessionBootstrapDemands.test.ts   |  47 ++
 .../sidebar/sessionBootstrapDemands.ts        |  77 ++
 .../sidebar/sessionNodeItemUtils.test.ts      | 125 +++
 .../session/sidebar/sessionNodeItemUtils.ts   |  86 +-
 .../components/session/sidebar/utils.test.ts  |  51 +-
 .../src/components/session/sidebar/utils.tsx  |  29 +-
 .../ui/src/components/ui/CommandPalette.tsx   |   6 +-
 packages/ui/src/components/views/ChatView.tsx |   5 +-
 packages/ui/src/components/views/DiffView.tsx |   7 +-
 .../ui/src/components/views/FilesView.tsx     |  26 +-
 .../ui/src/components/views/TerminalView.tsx  |   7 +-
 .../views/git/PullRequestSection.tsx          |   4 +-
 .../ui/src/contexts/RuntimeAPIProvider.tsx    | 156 +---
 .../ui/src/contexts/ThemeSystemContext.tsx    |  23 +-
 .../src/contexts/content-cache-owner.test.ts  |  74 ++
 .../ui/src/contexts/content-cache-owner.ts    | 134 ++++
 packages/ui/src/hooks/usePwaManifestSync.ts   |   5 +-
 .../hooks/useQueuedMessageAutoSend.test.ts    |   4 +-
 .../ui/src/hooks/useQueuedMessageAutoSend.ts  |  43 +-
 .../ui/src/hooks/useSessionAutoCleanup.ts     |  10 +-
 packages/ui/src/hooks/useTraySync.ts          |   2 +-
 .../ui/src/lib/chatDraftPersistence.test.ts   |  92 +++
 packages/ui/src/lib/chatDraftPersistence.ts   | 125 +++
 packages/ui/src/lib/gitApiHttp.ts             |  40 +-
 packages/ui/src/lib/i18n/messages/en.ts       |   6 +
 packages/ui/src/lib/i18n/messages/es.ts       |   6 +
 packages/ui/src/lib/i18n/messages/fr.ts       |   6 +
 packages/ui/src/lib/i18n/messages/ja.ts       |   6 +
 packages/ui/src/lib/i18n/messages/ko.ts       |   6 +
 packages/ui/src/lib/i18n/messages/pl.ts       |   6 +
 packages/ui/src/lib/i18n/messages/pt-BR.ts    |   6 +
 packages/ui/src/lib/i18n/messages/uk.ts       |   6 +
 packages/ui/src/lib/i18n/messages/zh-CN.ts    |   6 +
 packages/ui/src/lib/i18n/messages/zh-TW.ts    |   6 +
 packages/ui/src/lib/modelPrefsAutoSave.ts     |  14 +
 .../src/lib/opencode/provider-tracker.test.ts |  18 +
 .../ui/src/lib/opencode/provider-tracker.ts   |  31 +-
 packages/ui/src/lib/persistence.test.ts       |  84 ++
 packages/ui/src/lib/persistence.ts            | 232 +++++-
 packages/ui/src/lib/runtime-auth.test.ts      |  51 ++
 packages/ui/src/lib/runtime-auth.ts           |  77 +-
 packages/ui/src/lib/runtime-url.test.ts       |   2 +-
 .../ui/src/lib/shiki/appThemeRegistry.test.ts |  33 +
 packages/ui/src/lib/shiki/appThemeRegistry.ts |  22 +-
 packages/ui/src/stores/DOCUMENTATION.md       |  43 +-
 packages/ui/src/stores/globalSessions.test.ts |  25 +
 packages/ui/src/stores/globalSessions.ts      |  52 +-
 .../ui/src/stores/messageQueueStore.test.ts   |  51 ++
 packages/ui/src/stores/messageQueueStore.ts   | 127 ++-
 .../ui/src/stores/permissionStore.test.ts     |  54 +-
 packages/ui/src/stores/permissionStore.ts     | 122 ++-
 packages/ui/src/stores/useConfigStore.ts      |  61 +-
 .../ui/src/stores/useFileSearchStore.test.ts  |  19 +
 packages/ui/src/stores/useFileSearchStore.ts  |  13 +-
 .../src/stores/useFilesViewTabsStore.test.ts  |  14 +-
 .../ui/src/stores/useFilesViewTabsStore.ts    |  92 ++-
 .../src/stores/useGitHubPrStatusStore.test.ts | 139 ++++
 .../ui/src/stores/useGitHubPrStatusStore.ts   | 132 +++-
 packages/ui/src/stores/useGitStore.test.ts    |  72 +-
 packages/ui/src/stores/useGitStore.ts         | 243 +++++-
 .../useGlobalSessionsStore-races.test.ts      | 126 +++
 .../src/stores/useGlobalSessionsStore.test.ts |  94 ++-
 .../ui/src/stores/useGlobalSessionsStore.ts   | 260 ++++--
 ...seInlineCommentDraftStore.terminal.test.ts |  73 +-
 .../src/stores/useInlineCommentDraftStore.ts  | 398 +++++-----
 .../ui/src/stores/useProjectsStore.test.ts    |  21 +
 packages/ui/src/stores/useProjectsStore.ts    |  19 -
 .../src/stores/useSessionFoldersStore.test.ts |  58 +-
 .../ui/src/stores/useSessionFoldersStore.ts   | 278 ++++---
 .../src/stores/useSessionPinnedStore.test.ts  |  46 ++
 .../ui/src/stores/useSessionPinnedStore.ts    | 135 +++-
 .../src/stores/useTodosPersistStore.test.ts   |  51 ++
 .../ui/src/stores/useTodosPersistStore.ts     |  45 +-
 .../ui/src/stores/utils/safeStorage.test.ts   |  60 ++
 packages/ui/src/stores/utils/safeStorage.ts   | 221 ++----
 packages/ui/src/stores/utils/streamDebug.ts   |  35 +-
 packages/ui/src/sync/DOCUMENTATION.md         |  96 ++-
 .../sync/__tests__/materialization.test.ts    |  58 +-
 .../__tests__/session-prefetch-cache.test.ts  |  32 -
 .../sync-context-session-events.test.ts       |  73 ++
 packages/ui/src/sync/bootstrap.test.ts        | 111 +++
 packages/ui/src/sync/bootstrap.ts             |  65 +-
 packages/ui/src/sync/child-store.test.ts      | 362 ++++++++-
 packages/ui/src/sync/child-store.ts           | 515 +++++++++++-
 packages/ui/src/sync/content-cache.ts         |  76 --
 packages/ui/src/sync/event-pipeline.test.ts   |  79 ++
 packages/ui/src/sync/event-pipeline.ts        |  49 +-
 packages/ui/src/sync/event-reducer.ts         |  30 +-
 .../ui/src/sync/global-session-status.test.ts |  45 ++
 packages/ui/src/sync/global-session-status.ts |  37 +-
 .../sync/live-aggregate-performance.test.ts   |  29 +
 packages/ui/src/sync/live-aggregate.ts        |  15 +-
 packages/ui/src/sync/materialization.ts       |  40 +-
 .../ui/src/sync/performance-diagnostics.ts    | 126 +++
 packages/ui/src/sync/persist-cache.test.ts    | 179 +++++
 packages/ui/src/sync/persist-cache.ts         | 169 +++-
 .../ui/src/sync/reconnect-recovery.test.ts    |  46 ++
 packages/ui/src/sync/reconnect-recovery.ts    |  67 +-
 packages/ui/src/sync/session-actions.test.ts  |  92 +++
 packages/ui/src/sync/session-actions.ts       | 212 +++--
 .../src/sync/session-deletion-cleanup.test.ts |  78 ++
 .../ui/src/sync/session-deletion-cleanup.ts   |  24 +
 packages/ui/src/sync/session-event-router.ts  |  60 +-
 .../ui/src/sync/session-load-performance.ts   |  62 ++
 .../src/sync/session-message-loader.test.ts   | 175 +++++
 .../ui/src/sync/session-message-loader.ts     | 619 +++++++++++++++
 .../src/sync/session-message-records.test.ts  |  33 +
 .../src/sync/session-prefetch-cache.test.ts   |  50 ++
 .../ui/src/sync/session-prefetch-cache.ts     |  97 +--
 packages/ui/src/sync/session-ui-store.test.js |  18 +
 packages/ui/src/sync/session-ui-store.ts      |  67 +-
 packages/ui/src/sync/streaming.test.ts        |  85 +-
 packages/ui/src/sync/streaming.ts             | 146 +++-
 packages/ui/src/sync/sync-context.tsx         | 737 +++++++++++++-----
 packages/ui/src/sync/types.ts                 |   8 +
 packages/ui/src/sync/use-sync.ts              | 556 +++----------
 .../src/sync/worktree-topology-cache.test.ts  |  47 ++
 .../ui/src/sync/worktree-topology-cache.ts    |  99 +++
 packages/vscode/src/DOCUMENTATION.md          |   2 +-
 ...dge-permission-auto-accept-runtime.test.ts |  28 +-
 .../bridge-permission-auto-accept-runtime.ts  |  45 +-
 packages/vscode/src/opencodeAuth.ts           |   7 +-
 packages/vscode/webview/main.tsx              |   8 +-
 packages/web/server/index.js                  |   5 +-
 .../web/server/lib/github/DOCUMENTATION.md    |   1 +
 .../web/server/lib/opencode/DOCUMENTATION.md  |   4 +
 .../web/server/lib/opencode/env-runtime.js    |  10 +-
 .../server/lib/opencode/env-runtime.test.js   |  10 +-
 .../server/lib/opencode/session-runtime.js    |  63 +-
 .../lib/opencode/session-runtime.test.js      |  80 ++
 .../server/lib/opencode/settings-helpers.js   |   4 +
 .../lib/opencode/settings-helpers.test.js     |   1 +
 .../server/lib/opencode/settings-runtime.js   |   8 +-
 .../lib/opencode/settings-runtime.test.js     |  12 +
 .../lib/permission-auto-accept/runtime.js     |   5 +-
 .../permission-auto-accept/runtime.test.js    |  11 +-
 .../web/server/lib/session-folders/routes.js  | 106 ++-
 .../server/lib/session-folders/routes.test.js | 143 +++-
 packages/web/src/api/settings.ts              |   8 +-
 scripts/profile-browser.md                    |  54 ++
 scripts/profile-browser.mjs                   | 515 ++++++++++++
 197 files changed, 10835 insertions(+), 3400 deletions(-)
 create mode 100644 packages/ui/src/components/chat/MobileSessionStatusBar.test.ts
 create mode 100644 packages/ui/src/components/session/sidebar/authoritativeSessionCleanup.ts
 delete mode 100644 packages/ui/src/components/session/sidebar/hooks/pinnedSessionCleanup.ts
 create mode 100644 packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.test.ts
 create mode 100644 packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.ts
 delete mode 100644 packages/ui/src/components/session/sidebar/hooks/useSessionFolderCleanup.ts
 delete mode 100644 packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.test.ts
 create mode 100644 packages/ui/src/components/session/sidebar/sessionBootstrapDemands.test.ts
 create mode 100644 packages/ui/src/components/session/sidebar/sessionBootstrapDemands.ts
 create mode 100644 packages/ui/src/components/session/sidebar/sessionNodeItemUtils.test.ts
 create mode 100644 packages/ui/src/contexts/content-cache-owner.test.ts
 create mode 100644 packages/ui/src/contexts/content-cache-owner.ts
 create mode 100644 packages/ui/src/lib/chatDraftPersistence.test.ts
 create mode 100644 packages/ui/src/lib/chatDraftPersistence.ts
 create mode 100644 packages/ui/src/lib/opencode/provider-tracker.test.ts
 create mode 100644 packages/ui/src/lib/shiki/appThemeRegistry.test.ts
 create mode 100644 packages/ui/src/stores/messageQueueStore.test.ts
 create mode 100644 packages/ui/src/stores/useGitHubPrStatusStore.test.ts
 create mode 100644 packages/ui/src/stores/useGlobalSessionsStore-races.test.ts
 create mode 100644 packages/ui/src/stores/useProjectsStore.test.ts
 create mode 100644 packages/ui/src/stores/useSessionPinnedStore.test.ts
 create mode 100644 packages/ui/src/stores/useTodosPersistStore.test.ts
 delete mode 100644 packages/ui/src/sync/__tests__/session-prefetch-cache.test.ts
 create mode 100644 packages/ui/src/sync/bootstrap.test.ts
 delete mode 100644 packages/ui/src/sync/content-cache.ts
 create mode 100644 packages/ui/src/sync/global-session-status.test.ts
 create mode 100644 packages/ui/src/sync/live-aggregate-performance.test.ts
 create mode 100644 packages/ui/src/sync/performance-diagnostics.ts
 create mode 100644 packages/ui/src/sync/persist-cache.test.ts
 create mode 100644 packages/ui/src/sync/session-deletion-cleanup.test.ts
 create mode 100644 packages/ui/src/sync/session-deletion-cleanup.ts
 create mode 100644 packages/ui/src/sync/session-load-performance.ts
 create mode 100644 packages/ui/src/sync/session-message-loader.test.ts
 create mode 100644 packages/ui/src/sync/session-message-loader.ts
 create mode 100644 packages/ui/src/sync/session-prefetch-cache.test.ts
 create mode 100644 packages/ui/src/sync/worktree-topology-cache.test.ts
 create mode 100644 packages/ui/src/sync/worktree-topology-cache.ts
 create mode 100644 scripts/profile-browser.md
 create mode 100644 scripts/profile-browser.mjs

diff --git a/.agents/skills/openchamber-change-discipline/SKILL.md b/.agents/skills/openchamber-change-discipline/SKILL.md
index aac28f1b..7f3adc37 100644
--- a/.agents/skills/openchamber-change-discipline/SKILL.md
+++ b/.agents/skills/openchamber-change-discipline/SKILL.md
@@ -82,7 +82,7 @@ Use `package.json` scripts as the command source of truth.
 | Executable source | Focused tests plus package-scoped type-check and lint |
 | Cross-workspace/shared contract | Workspace-wide type-check and lint plus affected builds/tests |
 | Added/deleted/renamed source file, export/type/entrypoint/import shape | `bun run dead-code` in addition to relevant checks |
-| Persisted or external contract | Compatibility and round-trip tests; conversion/malformed-old-data tests when old data needs migration; failed-write/migration rollback tests |
+| Persisted or external contract | Compatibility and round-trip tests plus the applicable failure/ordering cases: missing-versus-empty, malformed data, stale reads versus newer mutations, out-of-order writes, lifecycle handling for debounced writes, conversion, and failed-write/migration rollback |
 | Dependency or lockfile | Workspace-wide checks and affected builds |
 | Generated asset | Regeneration check plus consumer build/test |
 | Docs-only or isolated config | Narrow syntax/schema/link validation; do not run unrelated full suites |
diff --git a/.agents/skills/performance-engineering/SKILL.md b/.agents/skills/performance-engineering/SKILL.md
index ef992029..6bcd7123 100644
--- a/.agents/skills/performance-engineering/SKILL.md
+++ b/.agents/skills/performance-engineering/SKILL.md
@@ -37,6 +37,8 @@ Do not optimize against a toy fixture when the report provides production scale.
 
 Do not infer a bottleneck from code appearance when a trace or counter can identify it.
 
+Profiling identifies where time is spent; it does not prove behavioral equivalence. Separately verify the applicable state, identity, layout, and lifecycle transitions for every structural optimization.
+
 ### 2. Write The Cost Equation
 
 Name every multiplying dimension:
@@ -109,6 +111,9 @@ Prefer indexes keyed by stable IDs. Keep high-frequency runtime state out of met
 - Preserve references for unaffected entities and buckets.
 - Keep streaming state out of broadly consumed stores.
 - Never rely on `React.memo`, `useMemo`, or Zustand equality to prevent selector execution upstream.
+- Treat every custom memo/equality comparator as a correctness boundary. Inventory every render-relevant value that comparator gates and observe its canonical identity or an explicit semantic version covering the same semantics.
+- Do not compare a proxy, aggregate, fallback, or differently resolved identity when the gated render path uses another source. Stable entity IDs do not imply stable rendered content; changes to comparator-gated semantics under the same ID must invalidate affected consumers, while semantically equivalent replacements may remain stable.
+- Prefer leaf subscriptions for isolated high-frequency state over threading broad state through custom comparators. Keep comparator work bounded so render fanout is not merely replaced by recursive comparison fanout.
 - Do not sort structural lists from token/delta-frequency fields.
 - Coalesce repeated same-entity events and skip no-op reducer updates.
 - Ensure hidden or disabled surfaces perform no ongoing work.
@@ -117,6 +122,20 @@ Prefer indexes keyed by stable IDs. Keep high-frequency runtime state out of met
 - Avoid textarea auto-size shrink/expand cycles when content only grows.
 - Freeze structural ordering during high-frequency updates and reorder at an explicit lifecycle edge.
 
+## Virtualization Contracts
+
+Virtualization changes layout, mounting, measurement, focus, and scroll semantics. It is not behaviorally equivalent merely because steady-state visible rows look the same.
+
+Before virtualizing a collection, define:
+
+- the actual scrolling element and whether it directly contains the virtualizer or is an ancestor;
+- how total virtual height and the final item remain reachable from that scroller;
+- estimated versus measured sizes, including expanded, nested, and dynamically resized items;
+- initialization, remount, and activation-threshold behavior;
+- interactions that depend on mounted DOM, including incremental reveal, focus, selection, drag-and-drop, menus, and accessibility traversal.
+
+When activation is threshold-based, test threshold minus one, threshold, and threshold plus one. Also test applicable collapsed/expanded, hidden/visible, filtered/unfiltered, and short/long transitions. If the current DOM or scroll topology cannot expose the virtual tail reliably, correct that topology or retain normal rendering rather than virtualizing solely by item count.
+
 ## Caching Rules
 
 Add a cache only when all are explicit:
@@ -141,6 +160,9 @@ Require both correctness and performance guards:
 - repeated-event test for streaming/polling paths;
 - no-op and unrelated-entity update tests;
 - reference-stability test for unaffected buckets;
+- when custom comparators change, tests proving both directions: unrelated or semantically equivalent updates preserve the boundary, while changes to comparator-gated identity, membership, content, and source semantics invalidate it;
+- when memoized tree/list consumers change, same-ID replacements and rebuilt-container fixtures covering both semantic change and semantic equivalence;
+- when virtualization changes, tests using the real scrolling ancestor that prove final-item/control reachability and stable scroll, focus, and interactions; include activation-boundary cases when such a boundary exists;
 - failure, partial-data, empty-success, and stale-async-completion tests;
 - memory/cache growth check for long-running paths;
 - production build or equivalent runtime profile for UI interactions.
@@ -181,4 +203,6 @@ If the interaction remains above budget, do not call the mitigation the complete
 - [ ] Partial failure cannot trigger destructive cleanup.
 - [ ] Representative benchmark meets the stated budget.
 - [ ] Operation-count or repeated-event regression test prevents recurrence.
+- [ ] Structural optimizations have transition-focused correctness coverage independent of performance measurements.
+- [ ] When mount topology or activation boundaries change, instrumentation distinguishes those transitions from steady state.
 - [ ] Correctness, type, lint, and relevant runtime validations pass.
diff --git a/.agents/skills/sync-state-invariants/SKILL.md b/.agents/skills/sync-state-invariants/SKILL.md
index 58f574fb..9aa3fec0 100644
--- a/.agents/skills/sync-state-invariants/SKILL.md
+++ b/.agents/skills/sync-state-invariants/SKILL.md
@@ -35,6 +35,14 @@ Never swallow an SDK/API error into `[]`, `{}`, or another valid empty success.
 
 Track completeness at the smallest entity/scope. One failed project or directory blocks destructive work for itself, not for unrelated complete scopes.
 
+Inferring destructive cleanup from disappearance between snapshots requires an established authoritative baseline. This is separate from applying a complete snapshot whose contract explicitly authorizes first-load replacement.
+
+- Never infer a disappearance event from the first snapshot, startup-empty state, filtered/visible subsets, or partially loaded scopes.
+- Compare two complete authoritative snapshots from the same runtime and logical scope before treating disappearance as removal.
+- Key disappearance by stable entity identity. Owner, directory, grouping, category, or presentation moves are not deletion unless the authoritative contract says so.
+- Reset the baseline when runtime identity or authoritative scope changes.
+- Prefer explicit deletion events; snapshot-difference cleanup is a fallback that requires completeness guarantees.
+
 ## Live And Historical State
 
 - Use historical state to restore context, not to infer ongoing execution.
@@ -61,6 +69,10 @@ For streaming-frequency work, also load `performance-engineering`.
 - Treat startup 502/503 as transient with bounded retry/recovery.
 - A retry loop requires a real failure signal; swallowed errors disable retries.
 - Preserve previous authoritative state during transient bootstrap/reconnect failures.
+- Distinguish stale-scope rejection from same-scope mutation reconciliation. A generation token rejects obsolete owners but does not protect mutations made while a still-valid request is in flight.
+- Capture a mutation revision when an authoritative load starts. At commit time, read current state and preserve or overlay entity mutations newer than that revision.
+- Record removals as mutations even when the entity is already absent, so an in-flight response cannot resurrect it.
+- Return committed reconciled state, not the raw fetched snapshot, when callers depend on the result.
 
 ## Optimistic Updates
 
@@ -85,6 +97,18 @@ For streaming-frequency work, also load `performance-engineering`.
 - Key runtime-scoped caches by runtime identity when IDs or paths can collide.
 - Clean optimistic and local cache state after partial failures.
 
+## Persisted Snapshot Ordering
+
+When state exists in memory and one or more persistent stores, define an explicit authority and ordering protocol:
+
+- Distinguish a missing snapshot from authoritative empty data, malformed data, and read failure.
+- Preserve mutation order independently per owner by serializing writes or attaching monotonic revisions and rejecting stale writes. Do not rely on uncontrolled wall-clock timestamps.
+- Capture runtime/owner identity with every debounced or asynchronous operation and verify it again before commit.
+- Pending writes must complete against their captured owner, drain before an owner switch, or be canceled only under an explicit durability/data-loss contract. Apply the strongest available guarantee at page hide/freeze and shutdown boundaries.
+- During hydration, capture the local mutation revision and do not replace state after newer local mutations.
+- Validate persisted payload shape before granting authority. Malformed data is failure, not empty success.
+- Define retention explicitly; never silently evict older owner namespaces unless bounded retention and resulting data loss are intentional contracts.
+
 ## Verification
 
 Cover the relevant lifecycle, not only static state:
@@ -97,6 +121,10 @@ Cover the relevant lifecycle, not only static state:
 - create, stream, abort, permission, archive/delete, and revisit when session behavior changes;
 - partial multi-directory/project failure;
 - runtime or worktree switch with dynamic directory resolution.
+- snapshot-difference cleanup establishing its first authoritative baseline without deletion, then cleaning a later authoritative disappearance exactly once;
+- identity-preserving moves/category changes and runtime/scope changes resetting cleanup baselines;
+- create, update, move, archive, and delete mutations surviving responses started before those mutations;
+- missing versus empty persistence, malformed payloads, out-of-order writes, hydration races, and lifecycle durability behavior.
 
 ## Red Flags
 
@@ -107,3 +135,6 @@ Cover the relevant lifecycle, not only static state:
 - Queue reads current model/agent at send time.
 - New session lookup assumes SSE already indexed it.
 - Optimistic data has no shadow entry or rollback.
+- Snapshot-difference cleanup treats its first startup snapshot as a disappearance event.
+- Missing or malformed persistence becomes authoritative empty state.
+- Debounced writes are canceled on owner/lifecycle change without completing against the captured owner or an explicit durability/data-loss contract.
diff --git a/.gitignore b/.gitignore
index 8a344a6b..525d0eff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,4 @@ workspaces/
 *.pid
 .worktrees/
 test-results/
+artifacts/browser-profile-*/
diff --git a/bun.lock b/bun.lock
index 2537858a..0debc2ed 100644
--- a/bun.lock
+++ b/bun.lock
@@ -97,7 +97,7 @@
     },
     "packages/electron": {
       "name": "@openchamber/electron",
-      "version": "1.16.1",
+      "version": "1.16.2",
       "dependencies": {
         "@openchamber/web": "workspace:*",
         "electron-context-menu": "^4.1.2",
@@ -133,7 +133,7 @@
     },
     "packages/ui": {
       "name": "@openchamber/ui",
-      "version": "1.16.1",
+      "version": "1.16.2",
       "dependencies": {
         "@aparajita/capacitor-secure-storage": "^8.0.0",
         "@base-ui/react": "^1.4.0",
@@ -237,7 +237,7 @@
     },
     "packages/vscode": {
       "name": "openchamber",
-      "version": "1.16.1",
+      "version": "1.16.2",
       "dependencies": {
         "@openchamber/ui": "workspace:*",
         "@opencode-ai/sdk": "1.18.3",
@@ -260,7 +260,7 @@
     },
     "packages/web": {
       "name": "@openchamber/web",
-      "version": "1.16.1",
+      "version": "1.16.2",
       "bin": {
         "openchamber": "./bin/cli.js",
       },
@@ -347,6 +347,9 @@
       },
     },
   },
+  "trustedDependencies": [
+    "electron",
+  ],
   "patchedDependencies": {
     "@tanstack/virtual-core@3.17.3": "bun-patches/@tanstack+virtual-core+3.17.3.patch",
   },
diff --git a/package.json b/package.json
index 77e712da..46e8813b 100644
--- a/package.json
+++ b/package.json
@@ -72,6 +72,7 @@
     "docs:validate": "node scripts/docs/validate-docs.mjs",
     "dead-code": "bunx knip@5.80.0 --no-exit-code --include files,exports,nsExports,types,nsTypes,enumMembers,duplicates",
     "doctor": "node scripts/react-doctor.mjs",
+    "profile:browser": "node scripts/profile-browser.mjs",
     "icons:sprite": "node scripts/generate-file-type-sprite.mjs",
     "icons:generate": "bun run scripts/generate-icon-sprite.mjs",
     "themes:port:opencode": "tsx scripts/port-opencode-theme.ts",
diff --git a/packages/electron/README.md b/packages/electron/README.md
index 9d42437b..afccf5d5 100644
--- a/packages/electron/README.md
+++ b/packages/electron/README.md
@@ -96,9 +96,12 @@ Packaged Desktop builds include the official OpenCode CLI that matches the pinne
 
 Managed local Desktop startup prefers OpenCode binaries in this order:
 
-1. Explicit overrides: `settings.opencodeBinary`, `OPENCODE_BINARY`, `OPENCODE_PATH`, `OPENCHAMBER_OPENCODE_PATH`, or `OPENCHAMBER_OPENCODE_BIN`.
-2. The bundled Desktop CLI in `process.resourcesPath/opencode-cli`.
-3. System installs discovered from PATH and known npm/Bun/Scoop/Chocolatey locations.
+1. `settings.opencodeBinary`.
+2. Environment overrides: `OPENCODE_BINARY`, `OPENCODE_PATH`, `OPENCHAMBER_OPENCODE_PATH`, or `OPENCHAMBER_OPENCODE_BIN`.
+3. The bundled Desktop CLI in `process.resourcesPath/opencode-cli`.
+4. System installs discovered from PATH.
+5. Known npm/Bun/Homebrew/Scoop/Chocolatey and other standard install locations.
+6. Platform discovery through `where opencode` on Windows or a login shell on macOS/Linux.
 
 Use an explicit override when testing a different OpenCode CLI build or when a user needs to point Desktop at a custom binary. The configured path must point to the standalone CLI, not the OpenCode Desktop app executable.
 
diff --git a/packages/electron/main.mjs b/packages/electron/main.mjs
index 100532e0..cfb83696 100644
--- a/packages/electron/main.mjs
+++ b/packages/electron/main.mjs
@@ -490,12 +490,16 @@ const readJsonFile = (filePath) => {
 };
 
 const writeJsonFile = async (filePath, data) => {
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  const directory = path.dirname(filePath);
+  await fsp.mkdir(directory, { recursive: true, mode: 0o700 });
+  if (process.platform !== 'win32') await fsp.chmod(directory, 0o700);
   // Atomic: write to a temp file then rename. Readers never see a partial
   // JSON file that could parse-error and get coerced to {}.
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  await fsp.writeFile(tmp, JSON.stringify(data, null, 2));
+  await fsp.writeFile(tmp, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+  if (process.platform !== 'win32') await fsp.chmod(tmp, 0o600);
   await fsp.rename(tmp, filePath);
+  if (process.platform !== 'win32') await fsp.chmod(filePath, 0o600);
 };
 
 const readSettingsRoot = () => {
diff --git a/packages/mobile/ios/App/OpenChamberNotificationService/NotificationService.swift b/packages/mobile/ios/App/OpenChamberNotificationService/NotificationService.swift
index ed29076a..8489b66c 100644
--- a/packages/mobile/ios/App/OpenChamberNotificationService/NotificationService.swift
+++ b/packages/mobile/ios/App/OpenChamberNotificationService/NotificationService.swift
@@ -37,6 +37,7 @@ class NotificationService: UNNotificationServiceExtension {
         guard let defaults = UserDefaults(suiteName: Self.appGroup) else { return }
 
         var snapshot: [String: Any] = [
+            "runtimeKey": request.content.userInfo["runtimeKey"] as? String ?? "",
             "attentionCount": 0,
             "recentSessions": [],
         ]
@@ -46,6 +47,16 @@ class NotificationService: UNNotificationServiceExtension {
             snapshot = stored
         }
 
+        if let pushRuntimeKey = request.content.userInfo["runtimeKey"] as? String,
+           !pushRuntimeKey.isEmpty,
+           snapshot["runtimeKey"] as? String != pushRuntimeKey {
+            snapshot = [
+                "runtimeKey": pushRuntimeKey,
+                "attentionCount": 0,
+                "recentSessions": [],
+            ]
+        }
+
         // Attention count: authoritative server value carried in aps.badge.
         if let badge = request.content.badge as? Int {
             snapshot["attentionCount"] = badge
diff --git a/packages/mobile/ios/App/OpenChamberWidget/WidgetShared.swift b/packages/mobile/ios/App/OpenChamberWidget/WidgetShared.swift
index e98e08e5..b32caf6a 100644
--- a/packages/mobile/ios/App/OpenChamberWidget/WidgetShared.swift
+++ b/packages/mobile/ios/App/OpenChamberWidget/WidgetShared.swift
@@ -17,10 +17,11 @@ struct WidgetSession: Codable, Identifiable, Hashable {
 /// The session overview snapshot. Mirrors MobileWidgetSnapshot (same field names) so the
 /// JSON the app stores decodes directly.
 struct WidgetSnapshot: Codable {
+    var runtimeKey: String?
     let attentionCount: Int
     let recentSessions: [WidgetSession]
 
-    static let empty = WidgetSnapshot(attentionCount: 0, recentSessions: [])
+    static let empty = WidgetSnapshot(runtimeKey: nil, attentionCount: 0, recentSessions: [])
 }
 
 enum WidgetStore {
diff --git a/packages/ui/src/apps/MobileChangesSurface.tsx b/packages/ui/src/apps/MobileChangesSurface.tsx
index 6818fec3..9c861bfe 100644
--- a/packages/ui/src/apps/MobileChangesSurface.tsx
+++ b/packages/ui/src/apps/MobileChangesSurface.tsx
@@ -21,6 +21,7 @@ import {
   useIsGitRepo,
   useGitLoadingStatus,
 } from '@/stores/useGitStore';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 type SyncAction = 'fetch' | 'pull' | 'push' | 'sync' | null;
 type CommitAction = 'commit' | 'commitAndPush' | null;
@@ -202,6 +203,7 @@ export const MobileChangesSurface: React.FC<MobileChangesSurfaceProps> = ({ onCl
     }
 
     let cancelled = false;
+    const runtimeKey = getRuntimeKey();
     setDiffLoadError(null);
     void git.getGitFileDiff(currentDirectory, { path: route.path, staged: route.staged || undefined })
       .then((response) => {
@@ -210,7 +212,7 @@ export const MobileChangesSurface: React.FC<MobileChangesSurfaceProps> = ({ onCl
           original: response.original ?? '',
           modified: response.modified ?? '',
           isBinary: response.isBinary,
-        });
+        }, runtimeKey);
       })
       .catch((error) => {
         if (cancelled) return;
diff --git a/packages/ui/src/apps/mobileConnections.test.ts b/packages/ui/src/apps/mobileConnections.test.ts
index 0d918711..d5ba3ecb 100644
--- a/packages/ui/src/apps/mobileConnections.test.ts
+++ b/packages/ui/src/apps/mobileConnections.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, mock, test } from 'bun:test';
 
-import { loadMobileConnections, upsertMobileConnection, validateMobileConnectionSession, type MobileRelayConfig } from './mobileConnections';
+import { loadMobileConnections, migrateLegacyInlineTokenRecords, upsertMobileConnection, validateMobileConnectionSession, type MobileRelayConfig } from './mobileConnections';
 
 const originalFetch = globalThis.fetch;
 const originalWindow = globalThis.window;
@@ -40,6 +40,18 @@ const testRelay: MobileRelayConfig = {
 };
 
 describe('mobile connection storage', () => {
+  test('removes inline tokens only after each secure migration succeeds', async () => {
+    const result = await migrateLegacyInlineTokenRecords([
+      { id: 'ok', url: 'http://ok.example', clientToken: 'token-ok' },
+      { id: 'failed', url: 'http://failed.example', clientToken: 'token-failed' },
+    ], async (url) => url.includes('ok.example'));
+
+    expect(result.migrated).toBe(1);
+    expect(result.failed).toBe(1);
+    expect(result.records[0]).toEqual({ id: 'ok', url: 'http://ok.example', hasToken: true });
+    expect(result.records[1]).toEqual({ id: 'failed', url: 'http://failed.example', clientToken: 'token-failed' });
+  });
+
   test('entries persisted before candidates migrate to a single direct candidate', async () => {
     try {
       installTestWindow();
diff --git a/packages/ui/src/apps/mobileConnections.ts b/packages/ui/src/apps/mobileConnections.ts
index 697acf9a..eb7654d7 100644
--- a/packages/ui/src/apps/mobileConnections.ts
+++ b/packages/ui/src/apps/mobileConnections.ts
@@ -691,6 +691,30 @@ const deleteSecureToken = async (key: string): Promise<void> => {
 
 // One-time migration: a legacy localStorage record on native might still carry an
 // inline `clientToken`. Move it into the secure store and strip the metadata.
+export const migrateLegacyInlineTokenRecords = async (
+  records: unknown[],
+  migrateToken: (url: string, token: string) => Promise<boolean>,
+): Promise<{ records: unknown[]; migrated: number; failed: number }> => {
+  let migrated = 0;
+  let failed = 0;
+  const next = await Promise.all(records.map(async (item) => {
+    if (!item || typeof item !== 'object') return item;
+    const record = item as Record<string, unknown>;
+    const url = typeof record.url === 'string' ? record.url : null;
+    const token = typeof record.clientToken === 'string' ? record.clientToken.trim() : '';
+    if (!url || !token) return item;
+    if (!await migrateToken(url, token)) {
+      failed += 1;
+      return item;
+    }
+    migrated += 1;
+    const { clientToken: _removed, ...metadata } = record;
+    void _removed;
+    return { ...metadata, hasToken: true };
+  }));
+  return { records: next, migrated, failed };
+};
+
 const migrateLegacyInlineTokens = async (): Promise<void> => {
   if (typeof window === 'undefined' || !isCapacitorApp()) return;
   let parsed: unknown;
@@ -707,11 +731,20 @@ const migrateLegacyInlineTokens = async (): Promise<void> => {
     && Boolean((item as { clientToken: string }).clientToken.trim()));
   if (legacy.length === 0) return;
   logStorage('secure:migrate-start', { count: legacy.length });
-  for (const { url, clientToken } of legacy) {
-    await writeSecureToken(getConnectionStorageKey(url), clientToken);
+  const result = await migrateLegacyInlineTokenRecords(parsed, async (url, token) => {
+    const key = getConnectionStorageKey(url);
+    if (!await writeSecureToken(key, token)) return false;
+    return await readSecureToken(key) === token;
+  });
+  if (result.migrated > 0) {
+    try {
+      window.localStorage.setItem(MOBILE_CONNECTIONS_STORAGE_KEY, JSON.stringify(result.records));
+    } catch (error) {
+      console.warn('[mobile-storage] failed to finalize secure token migration', error);
+      return;
+    }
   }
-  writeConnections(readConnections());
-  logStorage('secure:migrate-done', { count: legacy.length });
+  logStorage('secure:migrate-done', { migrated: result.migrated, failed: result.failed });
 };
 
 export const loadMobileConnections = async (): Promise<MobileSavedConnection[]> => {
diff --git a/packages/ui/src/apps/mobileWidgetSnapshot.ts b/packages/ui/src/apps/mobileWidgetSnapshot.ts
index 4ea1406e..eed0e318 100644
--- a/packages/ui/src/apps/mobileWidgetSnapshot.ts
+++ b/packages/ui/src/apps/mobileWidgetSnapshot.ts
@@ -5,6 +5,7 @@ import { useUIStore } from '@/stores/useUIStore';
 import { resolveGlobalSessionDirectory, useGlobalSessionsStore } from '@/stores/useGlobalSessionsStore';
 import { useProjectsStore } from '@/stores/useProjectsStore';
 import { useNotificationStore } from '@/sync/notification-store';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 /**
  * Builds the lightweight session overview the native iOS widgets render (home medium,
@@ -26,6 +27,8 @@ export interface MobileWidgetSession {
 }
 
 export interface MobileWidgetSnapshot {
+  /** Runtime instance that owns all session IDs and paths in this snapshot. */
+  runtimeKey: string;
   /** Count of sessions needing attention — same signal that drives the app-icon badge. */
   attentionCount: number;
   /** Most-recently-updated top-level sessions, newest first (capped for the medium widget). */
@@ -97,7 +100,7 @@ export const buildMobileWidgetSnapshot = (): MobileWidgetSnapshot => {
     .slice(0, RECENT_LIMIT)
     .map(({ id, title, unread, project }) => ({ id, title, unread, project }));
 
-  return { attentionCount, recentSessions };
+  return { runtimeKey: getRuntimeKey(), attentionCount, recentSessions };
 };
 
 const SNAPSHOT_GLOBAL_KEY = '__OPENCHAMBER_WIDGET_SNAPSHOT__';
diff --git a/packages/ui/src/apps/runtimeEndpointReset.ts b/packages/ui/src/apps/runtimeEndpointReset.ts
index 9a9ebe86..e66e52f5 100644
--- a/packages/ui/src/apps/runtimeEndpointReset.ts
+++ b/packages/ui/src/apps/runtimeEndpointReset.ts
@@ -7,9 +7,15 @@ import { useGlobalSessionsStore } from '@/stores/useGlobalSessionsStore';
 import { useAutoReviewStore } from '@/stores/useAutoReviewStore';
 import { useUIStore } from '@/stores/useUIStore';
 import { usePermissionStore } from '@/stores/permissionStore';
+import { useFileSearchStore } from '@/stores/useFileSearchStore';
+import { useGitStore } from '@/stores/useGitStore';
+import { useGitHubPrStatusStore } from '@/stores/useGitHubPrStatusStore';
+import { useSessionFoldersStore } from '@/stores/useSessionFoldersStore';
+import { useFilesViewTabsStore } from '@/stores/useFilesViewTabsStore';
 import { useTerminalStore } from '@/stores/useTerminalStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { resetStreamingState } from '@/sync/streaming';
+import { useGlobalSessionStatusStore } from '@/sync/global-session-status';
 import { syncDesktopSettings } from '@/lib/persistence';
 
 // Same-device transport switch (LAN⇄relay for one paired device): rebind the SDK
@@ -47,7 +53,13 @@ export const resetAppForRuntimeEndpointChange = (detail: RuntimeEndpointChangedD
   // Cross-project session list (mobile sessions sheet & co) belongs to the
   // previous instance — drop it so stale sessions can't linger after a switch.
   useGlobalSessionsStore.getState().resetForRuntimeSwitch();
+  useGlobalSessionStatusStore.setState({ statusById: new Map() });
   usePermissionStore.getState().reset();
+  useFileSearchStore.getState().resetForRuntimeSwitch();
+  useGitStore.getState().resetForRuntimeSwitch(detail.runtimeKey);
+  useGitHubPrStatusStore.getState().resetForRuntimeSwitch();
+  useSessionFoldersStore.getState().resetForRuntimeSwitch(detail.runtimeKey);
+  useFilesViewTabsStore.getState().resetForRuntimeSwitch(detail.runtimeKey);
   useSessionUIStore.getState().restoreForRuntimeSwitch(detail.runtimeKey);
   useUIStore.getState().restoreForRuntimeSwitch(detail.runtimeKey);
   resetStreamingState();
diff --git a/packages/ui/src/components/chat/ChatContainer.tsx b/packages/ui/src/components/chat/ChatContainer.tsx
index 034e5b13..7b4469be 100644
--- a/packages/ui/src/components/chat/ChatContainer.tsx
+++ b/packages/ui/src/components/chat/ChatContainer.tsx
@@ -36,16 +36,15 @@ import { useStreamingStore } from '@/sync/streaming';
 import {
     useSessionMessageCount,
     useSessionMessageRecords,
+    useSessionMessageLoadState,
     useSyncDirectory,
-    useDirectorySync,
+    useSessionRenderable,
     useSessionStatus,
     useScopedBlockingPermissions,
     useScopedBlockingQuestions,
     useParentSession,
 } from '@/sync/sync-context';
 import { useSync } from '@/sync/use-sync';
-import { getSessionPrefetch, subscribeSessionPrefetch } from '@/sync/session-prefetch-cache';
-import { getSessionMaterializationStatus } from '@/sync/materialization';
 import { usePlanDetection } from '@/hooks/usePlanDetection';
 import { useI18n } from '@/lib/i18n';
 import { isMobileSurfaceRuntime } from '@/lib/runtimeSurface';
@@ -215,6 +214,11 @@ const ChatViewport = React.memo(({
     // Shell-mode prompts show their extracted command; cache by message id so
     // the parts array reference is stable while the command is unchanged.
     const shellPreviewCache = React.useRef(new Map<string, { command: string; parts: Part[] }>());
+    const shellPreviewSessionRef = React.useRef(currentSessionId);
+    if (shellPreviewSessionRef.current !== currentSessionId) {
+        shellPreviewSessionRef.current = currentSessionId;
+        shellPreviewCache.current.clear();
+    }
     const promptPreviewsByTurnId = React.useMemo(() => {
         const next = new Map<string, Part[]>();
         for (let index = 0; index < renderedMessages.length; index += 1) {
@@ -339,6 +343,7 @@ const ChatViewport = React.memo(({
                             </div>
                         )}
                         <MessageList
+                            key={currentSessionId}
                             ref={messageListRef}
                             sessionKey={currentSessionId}
                             disableStaging={pendingRevealWork}
@@ -487,12 +492,42 @@ const renderDraftTitle = (title: string, projectLabel: string | null): React.Rea
     );
 };
 
+const DraftWelcome: React.FC = () => {
+    const { t } = useI18n();
+    const selectedProjectId = useSessionUIStore((state) => state.newSessionDraft.selectedProjectId ?? null);
+    const projectLabel = useProjectsStore(React.useCallback((state) => {
+        const projectId = selectedProjectId ?? state.activeProjectId;
+        const project = (projectId
+            ? state.projects.find((candidate) => candidate.id === projectId)
+            : null) ?? state.projects[0] ?? null;
+        return project ? getProjectDisplayLabel(project) : null;
+    }, [selectedProjectId]));
+
+    return (
+        <div className="oc-draft-center flex min-h-0 flex-1 flex-col items-center justify-center px-6 text-center">
+            <h1 className="text-balance text-3xl font-normal tracking-tight text-foreground">
+                {renderDraftTitle(
+                    projectLabel
+                        ? t('chat.emptyState.draftTitleWithProject', { project: projectLabel })
+                        : t('chat.emptyState.draftTitle'),
+                    projectLabel,
+                )}
+            </h1>
+            <DraftPresetChips
+                onSubmit={(text) => useInputStore.getState().requestPresetSubmit(text)}
+                className="oc-draft-starters mt-8 max-w-md"
+            />
+        </div>
+    );
+};
+
 type ChatContainerProps = {
+    active?: boolean;
     autoOpenDraft?: boolean;
     readOnly?: boolean;
 };
 
-export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = true, readOnly = false }) => {
+export const ChatContainer: React.FC<ChatContainerProps> = ({ active = true, autoOpenDraft = true, readOnly = false }) => {
     const { t } = useI18n();
     // Session UI state
     const currentSessionId = useSessionUIStore((s) => s.currentSessionId);
@@ -500,16 +535,14 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     const openNewSessionDraft = useSessionUIStore((s) => s.openNewSessionDraft);
     const setCurrentSession = useSessionUIStore((s) => s.setCurrentSession);
     const newSessionDraft = useSessionUIStore((s) => s.newSessionDraft);
-    const projects = useProjectsStore((s) => s.projects);
-    const activeProjectId = useProjectsStore((s) => s.activeProjectId);
 
     // Sync actions
     const sync = useSync();
     const syncDirectory = useSyncDirectory();
     const effectiveSessionDirectory = currentSessionDirectory ?? syncDirectory;
     const ensureSessionRenderable = React.useCallback(
-        (sessionId: string) => sync.ensureSessionRenderable(sessionId),
-        [sync],
+        (sessionId: string) => sync.ensureSessionRenderable(sessionId, false, effectiveSessionDirectory),
+        [effectiveSessionDirectory, sync],
     );
     const loadMoreMessages = React.useCallback(
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -542,31 +575,17 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
         ),
     );
     const sessionMessageCount = useSessionMessageCount(currentSessionId ?? '', effectiveSessionDirectory);
-    const hasRenderableSessionSnapshot = useDirectorySync(
-        React.useCallback(
-            (state) => (currentSessionId ? getSessionMaterializationStatus(state, currentSessionId).renderable : false),
-            [currentSessionId],
-        ),
-        effectiveSessionDirectory,
-    );
+    const hasRenderableSessionSnapshot = useSessionRenderable(currentSessionId ?? '', effectiveSessionDirectory);
     // Messages from sync system
     const sessionMessageRecords = useSessionMessageRecords(currentSessionId ?? '', effectiveSessionDirectory, {
+        enabled: active,
         suspendPartUpdates: Boolean(streamingMessageId),
         suspendPartUpdatesForMessageId: streamingMessageId,
     });
     const sessionMessages = currentSessionId ? sessionMessageRecords : EMPTY_MESSAGES;
-    const sessionPrefetchInfo = React.useSyncExternalStore(
-        React.useCallback(
-            (notify) => currentSessionId
-                ? subscribeSessionPrefetch(effectiveSessionDirectory, currentSessionId, notify)
-                : () => undefined,
-            [currentSessionId, effectiveSessionDirectory],
-        ),
-        React.useCallback(
-            () => currentSessionId ? getSessionPrefetch(effectiveSessionDirectory, currentSessionId) : undefined,
-            [currentSessionId, effectiveSessionDirectory],
-        ),
-        React.useCallback(() => undefined, []),
+    const sessionMessageLoadState = useSessionMessageLoadState(
+        currentSessionId ?? '',
+        effectiveSessionDirectory,
     );
 
     // Plan detection - watches messages for plan creation and signals store
@@ -643,20 +662,12 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     // History metadata — use sync's hasMore/isLoading
     const historyMeta = React.useMemo(() => {
         if (!currentSessionId) return null;
-        // Sync's meta is authoritative once a fetch has confirmed the history
-        // is fully loaded — a stale prefetch-cache entry (cursor recorded at
-        // the initial page) must not keep the "load older" affordance alive
-        // after the user has already reached the top.
-        const syncComplete = sync.isComplete(currentSessionId);
-        const prefetchHasMore = !syncComplete
-            && Boolean(sessionPrefetchInfo?.cursor)
-            && sessionPrefetchInfo?.complete !== true;
         return {
             limit: sessionMessages.length,
-            complete: syncComplete || !(sync.hasMore(currentSessionId) || prefetchHasMore),
-            loading: sync.isLoading(currentSessionId),
+            complete: sessionMessageLoadState.complete || !sessionMessageLoadState.cursor,
+            loading: sessionMessageLoadState.status === 'loading',
         };
-    }, [currentSessionId, sessionMessages.length, sessionPrefetchInfo, sync]);
+    }, [currentSessionId, sessionMessageLoadState.complete, sessionMessageLoadState.cursor, sessionMessageLoadState.status, sessionMessages.length]);
 
     const { isMobile } = useDeviceInfo();
     const isVSCode = isVSCodeRuntime();
@@ -668,17 +679,6 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     const isDesktopExpandedInput = isExpandedInput;
     const useCompactDraftLayout = isMobile || isVSCode || chatSurfaceMode === 'mini-chat';
     const messageListRef = React.useRef<MessageListHandle | null>(null);
-    const draftProjectLabel = React.useMemo(() => {
-        const selectedProject = newSessionDraft?.selectedProjectId
-            ? projects.find((project) => project.id === newSessionDraft.selectedProjectId) ?? null
-            : null;
-        const activeProject = activeProjectId
-            ? projects.find((project) => project.id === activeProjectId) ?? null
-            : null;
-        const project = selectedProject ?? activeProject ?? projects[0] ?? null;
-        return project ? getProjectDisplayLabel(project) : null;
-    }, [activeProjectId, newSessionDraft?.selectedProjectId, projects]);
-
     const parentSession = useParentSession(currentSessionId, effectiveSessionDirectory);
 
     // In the embedded session-chat iframe, hide "Return to parent" when
@@ -942,9 +942,13 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     const isSessionHydrating =
         Boolean(currentSessionId)
         && !hasRenderableSessionSnapshot;
+    const retrySessionLoad = React.useCallback(() => {
+        if (!active || !currentSessionId) return;
+        void sync.ensureSessionRenderable(currentSessionId, true, effectiveSessionDirectory);
+    }, [active, currentSessionId, effectiveSessionDirectory, sync]);
 
     React.useEffect(() => {
-        if (!currentSessionId) return;
+        if (!active || !currentSessionId) return;
         if (lastScrolledSessionRef.current === currentSessionId) return;
 
         const hasHashTarget = typeof window !== 'undefined' && window.location.hash.length > 0;
@@ -963,14 +967,13 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
         } else {
             window.requestAnimationFrame(run);
         }
-    }, [currentSessionId, releaseAutoFollow, restoreSnapshot]);
+    }, [active, currentSessionId, releaseAutoFollow, restoreSnapshot]);
 
     React.useEffect(() => {
-        if (!currentSessionId) return;
+        if (!active || !currentSessionId) return;
         if (hasRenderableSessionSnapshot) return;
-        if (effectiveSessionDirectory !== syncDirectory) return;
         void ensureSessionRenderable(currentSessionId);
-    }, [currentSessionId, effectiveSessionDirectory, ensureSessionRenderable, hasRenderableSessionSnapshot, syncDirectory]);
+    }, [active, currentSessionId, ensureSessionRenderable, hasRenderableSessionSnapshot]);
 
 	if (!currentSessionId && !draftOpen) {
 		// With auto-open, the draft welcome opens on the next tick (effect below),
@@ -993,22 +996,7 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
 			// the fullscreen composer's position:fixed visual-viewport pinning in
 			// mobile browsers (see ChatInput's composerFormRef effect).
 			<div className="relative flex h-full flex-col bg-background">
-				{useCompactDraftLayout && !isDesktopExpandedInput ? (
-					<div className="oc-draft-center flex min-h-0 flex-1 flex-col items-center justify-center px-6 text-center">
-						<h1 className="text-balance text-3xl font-normal tracking-tight text-foreground">
-							{renderDraftTitle(
-								draftProjectLabel
-									? t('chat.emptyState.draftTitleWithProject', { project: draftProjectLabel })
-									: t('chat.emptyState.draftTitle'),
-								draftProjectLabel,
-							)}
-						</h1>
-						<DraftPresetChips
-							onSubmit={(text) => useInputStore.getState().requestPresetSubmit(text)}
-							className="oc-draft-starters mt-8 max-w-md"
-						/>
-					</div>
-				) : null}
+				{useCompactDraftLayout && !isDesktopExpandedInput ? <DraftWelcome /> : null}
 				<div
 					className={cn(
 						'relative z-10 flex min-h-0',
@@ -1030,6 +1018,28 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
     }
 
 	if (isSessionHydrating && sessionMessages.length === 0 && !sessionIsWorking) {
+		if (sessionMessageLoadState.status === 'error') {
+			return (
+				<div className="relative flex h-full flex-col bg-background">
+					{returnToParentButton}
+					<div className="flex min-h-0 flex-1 items-center justify-center px-6">
+						<div className="max-w-sm text-center">
+							<div className="mx-auto mb-3 flex size-9 items-center justify-center rounded-full bg-[color-mix(in_srgb,var(--status-error)_10%,transparent)] text-[var(--status-error)]">
+								<Icon name="error-warning" className="size-4" />
+							</div>
+							<p className="typography-ui-label font-medium text-foreground">{t('chat.container.sessionLoadError.title')}</p>
+							<p className="typography-meta mt-1 text-muted-foreground">{t('chat.container.sessionLoadError.description')}</p>
+							<Button variant="outline" size="sm" className="mt-4" onClick={retrySessionLoad}>
+								{t('chat.container.sessionLoadError.retry')}
+							</Button>
+						</div>
+					</div>
+					<div className="relative z-10 bg-background">
+						{promptReadOnly ? <ReadOnlyPromptBanner /> : <ChatInput scrollToBottom={scrollToBottomOnSend} />}
+					</div>
+				</div>
+			);
+		}
 		return (
 			<div className="relative flex flex-col h-full bg-background">
 				{returnToParentButton}
@@ -1124,7 +1134,6 @@ export const ChatContainer: React.FC<ChatContainerProps> = ({ autoOpenDraft = tr
 		<div className="relative flex flex-col h-full bg-background">
 			{returnToParentButton}
 			<ChatViewport
-				key={currentSessionId}
 				currentSessionId={currentSessionId}
                 isDesktopExpandedInput={isDesktopExpandedInput}
                 isMobile={isMobile}
diff --git a/packages/ui/src/components/chat/ChatInput.tsx b/packages/ui/src/components/chat/ChatInput.tsx
index 924fcbfa..6e054d8f 100644
--- a/packages/ui/src/components/chat/ChatInput.tsx
+++ b/packages/ui/src/components/chat/ChatInput.tsx
@@ -6,7 +6,7 @@ import { ComposerDictation } from '@/components/dictation/ComposerDictation';
 // sessionStore removed — currentSessionId comes from useSessionUIStore
 import { useConfigStore } from '@/stores/useConfigStore';
 import { useUIStore } from '@/stores/useUIStore';
-import { useMessageQueueStore, type QueuedMessage } from '@/stores/messageQueueStore';
+import { createMessageQueueTarget, getMessageQueueKey, useMessageQueueStore, type QueuedMessage } from '@/stores/messageQueueStore';
 import { useAutoReviewStore } from '@/stores/useAutoReviewStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSelectionStore } from '@/sync/selection-store';
@@ -14,12 +14,21 @@ import { useInputStore } from '@/sync/input-store';
 import type { AttachedFile } from '@/stores/types/sessionTypes';
 import * as sessionActions from '@/sync/session-actions';
 import { useDirectorySync, useUserMessageHistory } from '@/sync/sync-context';
-import { useInlineCommentDraftStore, type InlineCommentDraft } from '@/stores/useInlineCommentDraftStore';
+import { getInlineCommentDraftKey, useInlineCommentDraftStore, type InlineCommentDraft, type InlineCommentDraftTarget } from '@/stores/useInlineCommentDraftStore';
 import { useSnippetsStore } from '@/stores/useSnippetsStore';
 import { appendInlineComments } from '@/lib/messages/inlineComments';
 import { renderMagicPrompt } from '@/lib/magicPrompts';
 import { startReviewFlow } from '@/lib/reviewFlow';
 import { getRuntimeKey } from '@/lib/runtime-switch';
+import {
+    createChatDraftIdentity,
+    getChatDraftIdentityKey,
+    readChatDraft,
+    subscribeChatDraftDeletion,
+    writeChatDraft,
+    type ChatDraftIdentity,
+    type ChatDraftSnapshot,
+} from '@/lib/chatDraftPersistence';
 import { ReviewFlowDialog, type ReviewFlowExecution } from '@/components/session/ReviewFlowDialog';
 import { AttachedFilesList, AttachedVSCodeFileChips, ActiveEditorFileSuggestion } from './FileAttachment';
 import ToolOutputDialog from './message/ToolOutputDialog';
@@ -111,6 +120,9 @@ const FILE_MENTION_TOKEN = /^@[^\s]+$/;
 const PASTE_LINK_URL_PATTERN = /^(https?:\/\/|mailto:)\S+$/i;
 const INLINE_SKILL_TOKEN_PATTERN = /(^|\s)\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)/g;
 const CHAT_DRAFT_PERSIST_DEBOUNCE_MS = 500;
+const getChatDraftSnapshotSignature = (text: string, confirmedMentions: Iterable<string>): string => (
+    `${text}\u0000${[...confirmedMentions].sort().join('\u0000')}`
+);
 const COMPACT_CHAT_PLACEHOLDER_MAX_WIDTH = 560;
 const VS_CODE_DROP_DATA_TYPES = [
     'CodeFiles',
@@ -918,81 +930,35 @@ type AutocompleteOverlayPosition = {
     maxHeight: number;
 };
 
-// Per-session draft key — preserves in-progress messages across project switches
-const getDraftKey = (sessionId: string | null): string =>
-    `openchamber_chat_input_draft_${sessionId ?? 'new'}`;
-
-// Helper to safely read from localStorage for a given session
-const getStoredDraft = (sessionId: string | null): string => {
-    try {
-        return localStorage.getItem(getDraftKey(sessionId)) ?? '';
-    } catch {
-        return '';
-    }
-};
-
-// Helper to safely write/clear a per-session draft
-const saveStoredDraft = (sessionId: string | null, draft: string): void => {
-    try {
-        if (draft) {
-            localStorage.setItem(getDraftKey(sessionId), draft);
-        } else {
-            localStorage.removeItem(getDraftKey(sessionId));
-        }
-    } catch {
-        // Ignore localStorage errors
-    }
-};
-
-// Per-session confirmed mentions key — tracks which @mentions are confirmed (blue) vs plain text
-const getConfirmedMentionsKey = (sessionId: string | null): string =>
-    `openchamber_chat_confirmed_mentions_${sessionId ?? 'new'}`;
-
-const saveConfirmedMentions = (sessionId: string | null, mentions: Set<string>): void => {
-    try {
-        if (mentions.size > 0) {
-            localStorage.setItem(getConfirmedMentionsKey(sessionId), JSON.stringify([...mentions]));
-        } else {
-            localStorage.removeItem(getConfirmedMentionsKey(sessionId));
-        }
-    } catch {
-        // Ignore localStorage errors
-    }
-};
-
-const loadConfirmedMentions = (sessionId: string | null): Set<string> => {
-    try {
-        const raw = localStorage.getItem(getConfirmedMentionsKey(sessionId));
-        if (raw) {
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                return new Set(parsed.filter((v): v is string => typeof v === 'string'));
-            }
-        }
-    } catch {
-        // Ignore localStorage errors
-    }
-    return new Set();
+const resolveChatDraftIdentity = (sessionId: string | null): ChatDraftIdentity | null => {
+    const sessionState = useSessionUIStore.getState();
+    const newSessionDirectory = sessionState.newSessionDraft?.open
+        ? sessionState.newSessionDraft.bootstrapPendingDirectory ?? sessionState.newSessionDraft.directoryOverride
+        : null;
+    const directory = sessionId
+        ? sessionState.getDirectoryForSession(sessionId) ?? sessionState.currentSessionDirectory
+        : newSessionDirectory ?? useDirectoryStore.getState().currentDirectory;
+    return createChatDraftIdentity(getRuntimeKey(), directory, sessionId);
 };
 
 const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollToBottom }) => {
     const { t } = useI18n();
     // Track if we restored a draft on mount (for text selection)
     const initialDraftRef = React.useRef<string | null>(null);
-    // Track initial session ID (captured at mount time for draft restoration)
-    const initialSessionIdRef = React.useRef<string | null>(null);
+    const initialDraftIdentityRef = React.useRef<ChatDraftIdentity | null>(null);
+    const initialDraftSnapshotRef = React.useRef<ChatDraftSnapshot>({ text: '', confirmedMentions: new Set() });
     const [message, setMessage] = React.useState(() => {
-        // Read per-session draft at mount time using the current session from the store
         const sessionId = useSessionUIStore.getState().currentSessionId;
-        initialSessionIdRef.current = sessionId;
-        const draft = getStoredDraft(sessionId);
-        if (draft) {
-            initialDraftRef.current = draft;
+        const identity = resolveChatDraftIdentity(sessionId);
+        const snapshot = readChatDraft(identity);
+        initialDraftIdentityRef.current = identity;
+        initialDraftSnapshotRef.current = snapshot;
+        if (snapshot.text) {
+            initialDraftRef.current = snapshot.text;
         }
-        return draft;
+        return snapshot.text;
     });
-    // Restore confirmed mentions from localStorage on mount
-    const confirmedMentionsRef = React.useRef<Set<string>>(loadConfirmedMentions(initialSessionIdRef.current));
+    const confirmedMentionsRef = React.useRef<Set<string>>(initialDraftSnapshotRef.current.confirmedMentions);
     // Helper: check if a mention path looks like a file/folder (has path separators, extension, or was explicitly confirmed)
     const isConfirmedFilePath = (text: string): boolean =>
         text.includes('/') || text.includes('\\') || text.includes('.') || confirmedMentionsRef.current.has(text);
@@ -1070,7 +1036,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     const draftPersistTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
     const skipNextDraftPersistRef = React.useRef(false);
     const lastPersistedDraftRef = React.useRef<Map<string, string>>(new Map());
-    const currentSessionIdForDraftRef = React.useRef<string | null>(null);
+    const currentChatDraftIdentityRef = React.useRef<ChatDraftIdentity | null>(initialDraftIdentityRef.current);
     const pendingPastedAttachmentFilenamesRef = React.useRef<Set<string>>(new Set());
 
     // TODO: port sendMessage to session-actions (complex — creates sessions, handles attachments, etc.)
@@ -1084,6 +1050,15 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     const currentSessionDirectoryForSync = useSessionUIStore(
         React.useCallback((s) => currentSessionId ? s.getDirectoryForSession(currentSessionId) : null, [currentSessionId]),
     );
+    const activeRuntimeKey = getRuntimeKey();
+    const chatDraftIdentity = React.useMemo(
+        () => createChatDraftIdentity(
+            activeRuntimeKey,
+            currentSessionDirectoryForSync ?? currentDirectory,
+            currentSessionId,
+        ),
+        [activeRuntimeKey, currentDirectory, currentSessionDirectoryForSync, currentSessionId],
+    );
     const newSessionDraft = useSessionUIStore((s) => s.newSessionDraft);
     const newSessionDraftOpen = Boolean(newSessionDraft?.open);
     const draftPermissionAutoAcceptEnabled = useSessionUIStore((s) => (
@@ -1487,14 +1462,18 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     } | null>(null);
 
     // Message queue
+    const messageQueueTarget = currentSessionId
+        ? createMessageQueueTarget(currentSessionId, currentSessionDirectoryForSync ?? currentDirectory)
+        : null;
+    const messageQueueKey = messageQueueTarget ? getMessageQueueKey(messageQueueTarget) : null;
     const followUpBehavior = useMessageQueueStore((state) => state.followUpBehavior);
     const queuedMessages = useMessageQueueStore(
         React.useCallback(
             (state) => {
-                if (!currentSessionId) return EMPTY_QUEUE;
-                return state.queuedMessages[currentSessionId] ?? EMPTY_QUEUE;
+                if (!messageQueueKey) return EMPTY_QUEUE;
+                return state.queuedMessages[messageQueueKey] ?? EMPTY_QUEUE;
             },
-            [currentSessionId]
+            [messageQueueKey]
         )
     );
     const addToQueue = useMessageQueueStore((state) => state.addToQueue);
@@ -1502,21 +1481,27 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     const removeFromQueue = useMessageQueueStore((state) => state.removeFromQueue);
 
     // Inline comment drafts
+    const inlineDraftSessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : '');
+    const inlineDraftDirectory = currentSessionDirectoryForSync ?? currentDirectory;
+    const inlineDraftTarget = React.useMemo<InlineCommentDraftTarget | null>(
+        () => inlineDraftSessionKey && inlineDraftDirectory
+            ? { directory: inlineDraftDirectory, sessionKey: inlineDraftSessionKey }
+            : null,
+        [inlineDraftDirectory, inlineDraftSessionKey],
+    );
+    const inlineDraftKey = inlineDraftTarget
+        ? getInlineCommentDraftKey(activeRuntimeKey, inlineDraftTarget.directory, inlineDraftTarget.sessionKey)
+        : null;
     const draftCount = useInlineCommentDraftStore(
         React.useCallback(
-            (state) => {
-                const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : '');
-                if (!sessionKey) return 0;
-                return (state.drafts[sessionKey] ?? []).length;
-            },
-            [currentSessionId, newSessionDraftOpen]
+            (state) => inlineDraftKey ? (state.drafts[inlineDraftKey] ?? []).length : 0,
+            [inlineDraftKey]
         )
     );
     const draftSourceKey = useInlineCommentDraftStore(
         React.useCallback(
             (state) => {
-                const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : '');
-                const drafts = sessionKey ? (state.drafts[sessionKey] ?? []) : [];
+                const drafts = inlineDraftKey ? (state.drafts[inlineDraftKey] ?? []) : [];
                 let previewConsole = 0;
                 let previewAnnotation = 0;
                 let review = 0;
@@ -1529,7 +1514,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
                 }
                 return `${previewConsole}:${previewAnnotation}:${review}:${terminal}`;
             },
-            [currentSessionId, newSessionDraftOpen]
+            [inlineDraftKey]
         )
     );
     const consumeDrafts = useInlineCommentDraftStore((state) => state.consumeDrafts);
@@ -1537,29 +1522,27 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     const hasDrafts = draftCount > 0;
     const [previewConsoleCount, previewAnnotationCount, reviewCount, terminalContextCount] = draftSourceKey.split(':').map((entry) => Number(entry) || 0);
     const terminalContextDrafts = terminalContextCount > 0
-        ? (useInlineCommentDraftStore.getState().drafts[currentSessionId ?? (newSessionDraftOpen ? 'draft' : '')] ?? []).filter((draft) => draft.source === 'terminal')
+        ? (inlineDraftKey ? useInlineCommentDraftStore.getState().drafts[inlineDraftKey] ?? [] : []).filter((draft) => draft.source === 'terminal')
         : [];
     const removePreviewDrafts = React.useCallback((source: 'preview-console' | 'preview-annotation') => {
-        const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : '');
-        if (!sessionKey) return;
-        const drafts = useInlineCommentDraftStore.getState().drafts[sessionKey] ?? [];
+        if (!inlineDraftTarget) return;
+        const drafts = useInlineCommentDraftStore.getState().getDrafts(inlineDraftTarget);
         for (const draft of drafts) {
             if (draft.source === source) {
-                removeInlineCommentDraft(sessionKey, draft.id);
+                removeInlineCommentDraft(inlineDraftTarget, draft.id);
             }
         }
-    }, [currentSessionId, newSessionDraftOpen, removeInlineCommentDraft]);
+    }, [inlineDraftTarget, removeInlineCommentDraft]);
     // Review comments are the inline-comment drafts that aren't preview sources.
     const removeReviewDrafts = React.useCallback(() => {
-        const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : '');
-        if (!sessionKey) return;
-        const drafts = useInlineCommentDraftStore.getState().drafts[sessionKey] ?? [];
+        if (!inlineDraftTarget) return;
+        const drafts = useInlineCommentDraftStore.getState().getDrafts(inlineDraftTarget);
         for (const draft of drafts) {
             if (draft.source !== 'preview-console' && draft.source !== 'preview-annotation' && draft.source !== 'terminal') {
-                removeInlineCommentDraft(sessionKey, draft.id);
+                removeInlineCommentDraft(inlineDraftTarget, draft.id);
             }
         }
-    }, [currentSessionId, newSessionDraftOpen, removeInlineCommentDraft]);
+    }, [inlineDraftTarget, removeInlineCommentDraft]);
 
     // User message history for up/down arrow navigation.
     // Keep this on a narrow hook instead of full session message records.
@@ -1571,17 +1554,12 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     }, [message]);
 
     React.useEffect(() => {
-        currentSessionIdForDraftRef.current = currentSessionId;
-    }, [currentSessionId]);
+        currentChatDraftIdentityRef.current = chatDraftIdentity;
+    }, [chatDraftIdentity]);
 
-    const persistDraftImmediately = React.useCallback((sessionId: string | null, draft: string) => {
-        const key = getDraftKey(sessionId);
-        const lastPersisted = lastPersistedDraftRef.current.get(key);
-        if (lastPersisted === draft) {
-            return;
-        }
-
-        saveStoredDraft(sessionId, draft);
+    const persistDraftImmediately = React.useCallback((identity: ChatDraftIdentity | null, draft: string) => {
+        if (!identity) return;
+        const key = getChatDraftIdentityKey(identity);
         // Only persist confirmed mentions that are actually present in the draft text
         const activeMentions = new Set<string>();
         for (const mention of confirmedMentionsRef.current) {
@@ -1590,8 +1568,13 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
             }
         }
         confirmedMentionsRef.current = activeMentions;
-        saveConfirmedMentions(sessionId, activeMentions);
-        lastPersistedDraftRef.current.set(key, draft);
+        const signature = getChatDraftSnapshotSignature(draft, activeMentions);
+        const lastPersisted = lastPersistedDraftRef.current.get(key);
+        if (lastPersisted === signature) {
+            return;
+        }
+        writeChatDraft(identity, draft, activeMentions);
+        lastPersistedDraftRef.current.set(key, signature);
     }, []);
 
     const clearPendingDraftPersist = React.useCallback(() => {
@@ -1614,11 +1597,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
         if (!persistChatDraft) {
             // Setting disabled - clear the restored draft
             setMessage('');
-            try {
-                localStorage.removeItem(getDraftKey(initialSessionIdRef.current));
-            } catch {
-                // Ignore
-            }
+            writeChatDraft(initialDraftIdentityRef.current, '', []);
         } else {
             // Setting enabled - select all text
             requestAnimationFrame(() => {
@@ -1627,24 +1606,24 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
         }
     }, [persistChatDraft]);
 
-    // Handle session switching: save draft for old session, restore draft for new session
-    const prevSessionIdRef = React.useRef(currentSessionId);
+    // Handle identity switching: save the old draft and restore the new runtime/directory/session draft.
+    const prevChatDraftIdentityRef = React.useRef<ChatDraftIdentity | null>(initialDraftIdentityRef.current);
     React.useEffect(() => {
-        if (prevSessionIdRef.current !== currentSessionId) {
-            const oldSessionId = prevSessionIdRef.current;
-            prevSessionIdRef.current = currentSessionId;
+        const previousIdentity = prevChatDraftIdentityRef.current;
+        const previousKey = previousIdentity ? getChatDraftIdentityKey(previousIdentity) : null;
+        const currentKey = chatDraftIdentity ? getChatDraftIdentityKey(chatDraftIdentity) : null;
+        if (previousKey !== currentKey) {
+            prevChatDraftIdentityRef.current = chatDraftIdentity;
             setInputMode('normal');
             clearPendingDraftPersist();
             skipNextDraftPersistRef.current = true;
 
             if (persistChatDraft) {
-                // Save current draft for the session we're leaving
-                persistDraftImmediately(oldSessionId, messageRef.current);
-                // Restore draft for the session we're entering
-                const newDraft = getStoredDraft(currentSessionId);
-                setMessage(newDraft);
-                confirmedMentionsRef.current = loadConfirmedMentions(currentSessionId);
-                if (newDraft) {
+                persistDraftImmediately(previousIdentity, messageRef.current);
+                const nextSnapshot = readChatDraft(chatDraftIdentity);
+                setMessage(nextSnapshot.text);
+                confirmedMentionsRef.current = nextSnapshot.confirmedMentions;
+                if (nextSnapshot.text) {
                     requestAnimationFrame(() => {
                         textareaRef.current?.select();
                     });
@@ -1655,7 +1634,19 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
                 confirmedMentionsRef.current = new Set();
             }
         }
-    }, [clearPendingDraftPersist, currentSessionId, persistChatDraft, persistDraftImmediately]);
+    }, [chatDraftIdentity, clearPendingDraftPersist, persistChatDraft, persistDraftImmediately]);
+
+    React.useEffect(() => subscribeChatDraftDeletion((deletedIdentity) => {
+        const deletedKey = getChatDraftIdentityKey(deletedIdentity);
+        lastPersistedDraftRef.current.set(deletedKey, getChatDraftSnapshotSignature('', []));
+        const currentIdentity = currentChatDraftIdentityRef.current;
+        if (!currentIdentity || getChatDraftIdentityKey(currentIdentity) !== deletedKey) return;
+        clearPendingDraftPersist();
+        skipNextDraftPersistRef.current = true;
+        messageRef.current = '';
+        confirmedMentionsRef.current = new Set();
+        setMessage('');
+    }), [clearPendingDraftPersist]);
 
     // Focus textarea when new session draft is opened
     const prevNewSessionDraftOpenRef = React.useRef(newSessionDraftOpen);
@@ -1678,7 +1669,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     React.useEffect(() => {
         if (!persistChatDraft) {
             clearPendingDraftPersist();
-            persistDraftImmediately(currentSessionId, '');
+            persistDraftImmediately(chatDraftIdentity, '');
             return;
         }
 
@@ -1689,24 +1680,37 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
 
         clearPendingDraftPersist();
         const draftSnapshot = message;
-        const sessionSnapshot = currentSessionId;
+        const identitySnapshot = chatDraftIdentity;
         draftPersistTimerRef.current = setTimeout(() => {
             draftPersistTimerRef.current = null;
-            persistDraftImmediately(sessionSnapshot, draftSnapshot);
+            persistDraftImmediately(identitySnapshot, draftSnapshot);
         }, CHAT_DRAFT_PERSIST_DEBOUNCE_MS);
 
         return () => {
             clearPendingDraftPersist();
         };
-    }, [clearPendingDraftPersist, currentSessionId, message, persistChatDraft, persistDraftImmediately]);
+    }, [chatDraftIdentity, clearPendingDraftPersist, message, persistChatDraft, persistDraftImmediately]);
 
     React.useEffect(() => {
-        return () => {
+        const flushCurrentDraft = () => {
             clearPendingDraftPersist();
             if (persistChatDraft) {
-                persistDraftImmediately(currentSessionIdForDraftRef.current, messageRef.current);
+                persistDraftImmediately(currentChatDraftIdentityRef.current, messageRef.current);
             }
         };
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'hidden') flushCurrentDraft();
+        };
+
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        document.addEventListener('freeze', flushCurrentDraft);
+        window.addEventListener('pagehide', flushCurrentDraft);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+            document.removeEventListener('freeze', flushCurrentDraft);
+            window.removeEventListener('pagehide', flushCurrentDraft);
+            flushCurrentDraft();
+        };
     }, [clearPendingDraftPersist, persistChatDraft, persistDraftImmediately]);
 
     // Session activity for queue availability and controls
@@ -1782,9 +1786,9 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
     // Add message to queue instead of sending
     const handleQueueMessage = React.useCallback(() => {
         const inputSnapshot = getCurrentInputSnapshot();
-        if (!inputSnapshot.hasContent || !currentSessionId) return;
+        if (!inputSnapshot.hasContent || !currentSessionId || !messageQueueTarget) return;
 
-        const drafts = consumeDrafts(currentSessionId);
+        const drafts = inlineDraftTarget ? consumeDrafts(inlineDraftTarget) : [];
 
         let messageToQueue = inputSnapshot.message.replace(/^\n+|\n+$/g, '');
         if (drafts.length > 0) {
@@ -1792,7 +1796,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
         }
         const attachmentsToQueue = sanitizeAttachmentsForSend(sendableAttachedFiles);
 
-        addToQueue(currentSessionId, {
+        addToQueue(messageQueueTarget, {
             content: messageToQueue,
             attachments: attachmentsToQueue.length > 0 ? attachmentsToQueue : undefined,
             sendConfig: currentProviderId && currentModelId ? {
@@ -1815,7 +1819,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
         if (!isMobile) {
             textareaRef.current?.focus();
         }
-    }, [getCurrentInputSnapshot, currentSessionId, sendableAttachedFiles, sanitizeAttachmentsForSend, addToQueue, clearAttachedFiles, isMobile, consumeDrafts, currentProviderId, currentModelId, currentAgentName, currentVariant]);
+    }, [getCurrentInputSnapshot, currentSessionId, messageQueueTarget, inlineDraftTarget, sendableAttachedFiles, sanitizeAttachmentsForSend, addToQueue, clearAttachedFiles, isMobile, consumeDrafts, currentProviderId, currentModelId, currentAgentName, currentVariant]);
 
     const handleQueuedMessageEdit = React.useCallback((content: string) => {
         setMessage(content);
@@ -1974,10 +1978,10 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
             }
         }
 
-        const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : null);
+        const consumedDraftTarget = inlineDraftTarget;
         let drafts: InlineCommentDraft[] = [];
-        if (!queuedOnly && sessionKey) {
-            drafts = consumeDrafts(sessionKey);
+        if (!queuedOnly && consumedDraftTarget) {
+            drafts = consumeDrafts(consumedDraftTarget);
         }
 
         if (drafts.length > 0) {
@@ -2032,17 +2036,16 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
         if (!primaryText && primaryAttachments.length === 0 && additionalParts.length === 0) return;
 
         // Clear queue and input
-        if (currentSessionId && queuedMessageId) {
-            removeFromQueue(currentSessionId, queuedMessageId);
-        } else if (currentSessionId && hasQueuedMessages) {
-            clearQueue(currentSessionId);
+        if (messageQueueTarget && queuedMessageId) {
+            removeFromQueue(messageQueueTarget, queuedMessageId);
+        } else if (messageQueueTarget && hasQueuedMessages) {
+            clearQueue(messageQueueTarget);
         }
         if (!queuedOnly) {
             setMessage('');
             confirmedMentionsRef.current.clear();
             // Clear per-session draft on submit
-            saveStoredDraft(currentSessionId, '');
-            saveConfirmedMentions(currentSessionId, confirmedMentionsRef.current);
+            persistDraftImmediately(chatDraftIdentity, '');
             // Reset message history navigation state
             setHistoryIndex(-1);
             setDraftMessage('');
@@ -2333,8 +2336,8 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
             sendMessageOptions,
         );
         const restoreConsumedDrafts = () => {
-            if (sessionKey && drafts.length > 0) {
-                useInlineCommentDraftStore.getState().restoreDrafts(sessionKey, drafts);
+            if (consumedDraftTarget && drafts.length > 0) {
+                useInlineCommentDraftStore.getState().restoreDrafts(consumedDraftTarget, drafts);
             }
         };
 
@@ -2369,7 +2372,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
             const currentInput = textareaRef.current?.value ?? messageRef.current;
             if (newSessionDraftOpen && inputSnapshot.message && (!currentInput || currentInput === inputSnapshot.message)) {
                 setMessage(inputSnapshot.message);
-                saveStoredDraft(null, inputSnapshot.message);
+                writeChatDraft(chatDraftIdentity, inputSnapshot.message, confirmedMentionsRef.current);
             }
 
             const isSoftNetworkError =
@@ -4667,7 +4670,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({ onOpenSettings, scrollTo
                                 <span className="truncate text-xs font-medium text-[var(--surface-mutedForeground)]">
                                     {t('chat.chatInput.terminalContext', { terminal: draft.fileLabel, start: draft.startLine, end: draft.endLine })}
                                 </span>
-                                <button type="button" className="ml-1 inline-flex h-4 w-4 items-center justify-center rounded-full text-[var(--surface-mutedForeground)] hover:bg-[var(--interactive-hover)] hover:text-[var(--surface-foreground)]" onClick={() => removeInlineCommentDraft(draft.sessionKey, draft.id)} aria-label={t('chat.chatInput.terminalContextRemove')} title={t('chat.chatInput.terminalContextRemove')}>
+                                <button type="button" className="ml-1 inline-flex h-4 w-4 items-center justify-center rounded-full text-[var(--surface-mutedForeground)] hover:bg-[var(--interactive-hover)] hover:text-[var(--surface-foreground)]" onClick={() => inlineDraftTarget && removeInlineCommentDraft(inlineDraftTarget, draft.id)} aria-label={t('chat.chatInput.terminalContextRemove')} title={t('chat.chatInput.terminalContextRemove')}>
                                     <Icon name="close" className="h-3 w-3" />
                                 </button>
                             </div>
diff --git a/packages/ui/src/components/chat/ChatMessage.tsx b/packages/ui/src/components/chat/ChatMessage.tsx
index 476e7457..a499a805 100644
--- a/packages/ui/src/components/chat/ChatMessage.tsx
+++ b/packages/ui/src/components/chat/ChatMessage.tsx
@@ -163,12 +163,8 @@ const ChatMessage: React.FC<ChatMessageProps> = ({
     const { currentTheme } = useThemeSystem();
     const messageContainerRef = React.useRef<HTMLDivElement | null>(null);
 
-    const currentSessionId = useSessionUIStore((s) => s.currentSessionId);
-
     const getAgentModelForSession = useSelectionStore((s) => s.getAgentModelForSession);
     const getSessionModelSelection = useSelectionStore((s) => s.getSessionModelSelection);
-    const revertToMessage = useSessionUIStore((s) => s.revertToMessage);
-    const forkFromMessage = useSessionUIStore((s) => s.forkFromMessage);
 
     streamPerfCount('ui.chat_message.render');
     if (isInActiveTurn) {
@@ -186,12 +182,6 @@ const ChatMessage: React.FC<ChatMessageProps> = ({
         }))
     );
 
-    React.useEffect(() => {
-        if (currentSessionId) {
-            MessageFreshnessDetector.getInstance().recordSessionStart(currentSessionId);
-        }
-    }, [currentSessionId]);
-
     const [copiedCode, setCopiedCode] = React.useState<string | null>(null);
     const [copiedMessage, setCopiedMessage] = React.useState(false);
     const [expandedTools, setExpandedTools] = React.useState<Set<string>>(() => readExpandedToolsCache(message.info.id));
@@ -580,8 +570,8 @@ const ChatMessage: React.FC<ChatMessageProps> = ({
     const shouldAnimateMessage = React.useMemo(() => {
         if (isUser) return false;
         const freshnessDetector = MessageFreshnessDetector.getInstance();
-        return freshnessDetector.shouldAnimateMessage(message.info, currentSessionId || message.info.sessionID);
-    }, [message.info, currentSessionId, isUser]);
+        return freshnessDetector.shouldAnimateMessage(message.info, message.info.sessionID);
+    }, [message.info, isUser]);
 
     const [hasStartedStreamingHeader, setHasStartedStreamingHeader] = React.useState(false);
 
@@ -794,14 +784,14 @@ const ChatMessage: React.FC<ChatMessageProps> = ({
 
     const handleRevert = React.useCallback(() => {
         if (!sessionId || !message.info.id) return;
-        revertToMessage(sessionId, message.info.id);
-    }, [sessionId, message.info.id, revertToMessage]);
+        useSessionUIStore.getState().revertToMessage(sessionId, message.info.id);
+    }, [sessionId, message.info.id]);
 
     // NEW: Fork handler
     const handleFork = React.useCallback(() => {
         if (!sessionId || !message.info.id) return;
-        forkFromMessage(sessionId, message.info.id);
-    }, [sessionId, message.info.id, forkFromMessage]);
+        useSessionUIStore.getState().forkFromMessage(sessionId, message.info.id);
+    }, [sessionId, message.info.id]);
 
     const handleToggleTool = React.useCallback((toolId: string) => {
         const isDefaultOpen = defaultOpenToolIds.has(toolId);
diff --git a/packages/ui/src/components/chat/MarkdownRendererImpl.tsx b/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
index f88450cb..77606013 100644
--- a/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
+++ b/packages/ui/src/components/chat/MarkdownRendererImpl.tsx
@@ -40,6 +40,7 @@ import {
   parseFileReference,
   type ParsedFileReference,
 } from './fileReferenceParser';
+import { streamPerfCount, streamPerfObserve } from '@/stores/utils/streamDebug';
 
 const useCurrentMermaidTheme = () => {
   const themeSystem = useOptionalThemeSystem();
@@ -754,69 +755,6 @@ const useMermaidInlineInteractions = ({
 // Rendering core: marked -> math -> shiki -> sanitize -> decorate -> morphdom
 // ---------------------------------------------------------------------------
 
-// Single tuning knob: the streaming reveal cadence. Lower = smoother but more
-// CPU (more re-parse steps/sec); higher = cheaper but chunkier. Step sizes are
-// auto-scaled from this so reveal throughput (chars/sec) stays constant no
-// matter the cadence — text always keeps up with the incoming stream.
-const TEXT_PACE_MS = 64;
-const PACE_BASELINE_MS = 24;
-const PACE_RATIO = TEXT_PACE_MS / PACE_BASELINE_MS;
-const TEXT_SNAP = /[\s.,!?;:)\]]/;
-
-const paceStep = (remaining: number): number => {
-  const base = remaining <= 12 ? 2 : remaining <= 48 ? 4 : remaining <= 96 ? 8 : Math.min(24, Math.ceil(remaining / 8));
-  return Math.max(1, Math.round(base * PACE_RATIO));
-};
-
-const nextRevealIndex = (text: string, start: number): number => {
-  const end = Math.min(text.length, start + paceStep(text.length - start));
-  for (let i = end; i < Math.min(text.length, end + 8); i += 1) {
-    if (TEXT_SNAP.test(text[i] ?? '')) return i + 1;
-  }
-  return end;
-};
-
-// Granular streaming reveal. Cheap because each step only re-runs the
-// marked->morphdom pipeline (patching changed DOM nodes), with no React tree
-// reconciliation of the markdown body.
-const usePacedText = (content: string, streaming: boolean): string => {
-  const [shown, setShown] = React.useState<number>(() => (streaming ? 0 : content.length));
-  const shownRef = React.useRef(shown);
-  shownRef.current = shown;
-
-  React.useEffect(() => {
-    if (!streaming || typeof window === 'undefined') {
-      setShown(content.length);
-      return;
-    }
-    if (shownRef.current > content.length) {
-      setShown(content.length);
-    }
-
-    let timer: number | null = null;
-    const tick = () => {
-      const current = Math.min(shownRef.current, content.length);
-      if (current >= content.length) {
-        timer = null;
-        return;
-      }
-      setShown(nextRevealIndex(content, current));
-      timer = window.setTimeout(tick, TEXT_PACE_MS);
-    };
-
-    if (shownRef.current < content.length) {
-      timer = window.setTimeout(tick, TEXT_PACE_MS);
-    }
-
-    return () => {
-      if (timer !== null) window.clearTimeout(timer);
-    };
-  }, [content, streaming]);
-
-  if (!streaming) return content;
-  return content.slice(0, Math.min(shown, content.length));
-};
-
 // Mermaid layout is expensive; `decorate` would otherwise re-render every
 // diagram on every paced-stream step (~40/sec). Memoize by theme+mode+source
 // so a stable diagram is laid out once and served from cache thereafter.
@@ -1094,6 +1032,9 @@ const MarkdownRendererImpl: React.FC<MarkdownRendererProps> = ({
   onShowPopup,
   enableFileReferences = true,
 }) => {
+  streamPerfCount('ui.markdown_renderer.render');
+  if (isStreaming) streamPerfCount('ui.markdown_renderer.render.streaming');
+  streamPerfObserve('ui.markdown_renderer.content_len', content.length);
   const currentTheme = useCurrentMermaidTheme();
   const { editor, runtime } = useRuntimeAPIs();
   const containerRef = React.useRef<HTMLDivElement>(null);
@@ -1106,7 +1047,6 @@ const MarkdownRendererImpl: React.FC<MarkdownRendererProps> = ({
   }, [effectiveDirectory, openContextPreview]);
 
   const live = isStreaming && !disableStreamAnimation;
-  const pacedText = usePacedText(content, live);
 
   useMermaidInlineInteractions({
     containerRef,
@@ -1127,7 +1067,7 @@ const MarkdownRendererImpl: React.FC<MarkdownRendererProps> = ({
   const ctx = useDecorateContext(currentTheme, live, effectiveDirectory ? handlePreviewLoopback : undefined, DEFAULT_MERMAID_CONTROLS);
   const cacheKey = `markdown-${part?.id ? `part-${part.id}` : `message-${messageId}`}`;
 
-  useMorphdomMarkdown({ containerRef, text: pacedText, streaming: live, cacheKey, syntaxVars, ctx });
+  useMorphdomMarkdown({ containerRef, text: content, streaming: live, cacheKey, syntaxVars, ctx });
 
   const markdownContent = (
     <div className={cn('break-words w-full min-w-0', className)} ref={containerRef}>
diff --git a/packages/ui/src/components/chat/MessageList.tsx b/packages/ui/src/components/chat/MessageList.tsx
index 6e43b76d..2ce4442e 100644
--- a/packages/ui/src/components/chat/MessageList.tsx
+++ b/packages/ui/src/components/chat/MessageList.tsx
@@ -16,7 +16,7 @@ import { useFeatureFlagsStore } from '@/stores/useFeatureFlagsStore';
 import { isHiddenUserMessage } from './message/hiddenUserMessage';
 import { FadeInDisabledProvider } from './message/FadeInOnReveal';
 import { hasPendingUserSendAnimation, consumePendingUserSendAnimation } from '@/lib/userSendAnimation';
-import { streamPerfCount, streamPerfMeasure } from '@/stores/utils/streamDebug';
+import { streamPerfCount, streamPerfMark, streamPerfMeasure } from '@/stores/utils/streamDebug';
 import type { StreamPhase } from './message/types';
 import { useGlobalSessionsStore } from '@/stores/useGlobalSessionsStore';
 import { useSessionParts } from '@/sync/sync-context';
@@ -885,6 +885,7 @@ const MessageListEntry = React.memo(({
     activeStreamingPhase,
     reviewTransferDirection,
 }: MessageListEntryProps) => {
+    streamPerfCount('ui.message_list_entry.render');
     if (entry.kind === 'ungrouped') {
         return (
             <UngroupedMessageRow
@@ -1264,6 +1265,7 @@ const MessageList = React.forwardRef<MessageListHandle, MessageListProps>(({
     scrollRef,
     directory,
 }, ref) => {
+    streamPerfMark('react.message_list_render');
     streamPerfCount('ui.message_list.render');
     const stickyUserHeader = useUIStore(state => state.stickyUserHeader);
     const chatRenderMode = useUIStore((state) => state.chatRenderMode);
diff --git a/packages/ui/src/components/chat/MobileSessionStatusBar.test.ts b/packages/ui/src/components/chat/MobileSessionStatusBar.test.ts
new file mode 100644
index 00000000..a0814fbd
--- /dev/null
+++ b/packages/ui/src/components/chat/MobileSessionStatusBar.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync(new URL('./MobileSessionStatusBar.tsx', import.meta.url), 'utf8');
+
+describe('MobileSessionStatusBar hidden work', () => {
+  test('does not mount session grouping and project derivation while the panel is closed', () => {
+    const wrapperStart = source.indexOf('export const MobileSessionStatusBar');
+    const openPanelStart = source.indexOf('const MobileSessionStatusOpenPanel');
+    const closedGuard = source.indexOf('if (!isMobile || !open) return null;', wrapperStart);
+    const openPanelMount = source.indexOf('<MobileSessionStatusOpenPanel', wrapperStart);
+
+    expect(openPanelStart).toBeGreaterThan(-1);
+    expect(closedGuard).toBeGreaterThan(wrapperStart);
+    expect(openPanelMount).toBeGreaterThan(closedGuard);
+    expect(source.indexOf('useSessionGrouping(', openPanelStart)).toBeLessThan(wrapperStart);
+  });
+});
diff --git a/packages/ui/src/components/chat/MobileSessionStatusBar.tsx b/packages/ui/src/components/chat/MobileSessionStatusBar.tsx
index fe47a173..f84dffc7 100644
--- a/packages/ui/src/components/chat/MobileSessionStatusBar.tsx
+++ b/packages/ui/src/components/chat/MobileSessionStatusBar.tsx
@@ -21,9 +21,7 @@ interface MobileSessionStatusBarProps {
 
 interface SessionWithStatus extends Session {
   _statusType?: 'busy' | 'retry' | 'idle';
-  _hasRunningChildren?: boolean;
   _runningChildrenCount?: number;
-  _childIndicators?: Array<{ session: Session; isRunning: boolean }>;
 }
 
 // Cross-project session source. Mirrors the dedicated MobileSessionsSheet:
@@ -84,12 +82,14 @@ function useSessionGrouping(
     const map = new Map<string, Session[]>();
     const allIds = new Set(sessions.map((s) => s.id));
 
-    sessions.forEach((session) => {
+    for (const session of sessions) {
       const parentID = (session as { parentID?: string }).parentID;
       if (parentID && allIds.has(parentID)) {
-        map.set(parentID, [...(map.get(parentID) || []), session]);
+        const children = map.get(parentID);
+        if (children) children.push(session);
+        else map.set(parentID, [session]);
       }
-    });
+    }
     return map;
   }, [sessions]);
 
@@ -99,24 +99,6 @@ function useSessionGrouping(
     return 'idle';
   }, [sessionStatus]);
 
-  const hasRunningChildren = React.useCallback((sessionId: string): boolean => {
-    const children = parentChildMap.get(sessionId) || [];
-    return children.some((child) => getStatusType(child.id) !== 'idle');
-  }, [parentChildMap, getStatusType]);
-
-  const getRunningChildrenCount = React.useCallback((sessionId: string): number => {
-    const children = parentChildMap.get(sessionId) || [];
-    return children.filter((child) => getStatusType(child.id) !== 'idle').length;
-  }, [parentChildMap, getStatusType]);
-
-  const getChildIndicators = React.useCallback((sessionId: string): Array<{ session: Session; isRunning: boolean }> => {
-    const children = parentChildMap.get(sessionId) || [];
-    return children
-      .filter((child) => getStatusType(child.id) !== 'idle')
-      .map((child) => ({ session: child, isRunning: true }))
-      .slice(0, 3);
-  }, [parentChildMap, getStatusType]);
-
   const processedSessions = React.useMemo(() => {
     const sessionIds = new Set(sessions.map((s) => s.id));
     const topLevel = sessions.filter((session) => {
@@ -129,20 +111,18 @@ function useSessionGrouping(
 
     topLevel.forEach((session) => {
       const statusType = getStatusType(session.id);
-      const hasRunning = hasRunningChildren(session.id);
+      const runningChildrenCount = (parentChildMap.get(session.id) ?? [])
+        .filter((child) => getStatusType(child.id) !== 'idle')
+        .length;
       const attention = (unseenCounts[session.id] ?? 0) > 0;
 
       const enriched: SessionWithStatus = {
         ...session,
         _statusType: statusType,
-        _hasRunningChildren: hasRunning,
-        _runningChildrenCount: getRunningChildrenCount(session.id),
-        _childIndicators: getChildIndicators(session.id),
+        _runningChildrenCount: runningChildrenCount,
       };
 
-      if (statusType !== 'idle' || hasRunning) {
-        running.push(enriched);
-      } else if (attention) {
+      if (statusType !== 'idle' || runningChildrenCount > 0 || attention) {
         running.push(enriched);
       } else {
         viewed.push(enriched);
@@ -159,7 +139,7 @@ function useSessionGrouping(
     viewed.sort(sortByUpdated);
 
     return [...running, ...viewed];
-  }, [sessions, getStatusType, hasRunningChildren, getRunningChildrenCount, getChildIndicators, unseenCounts]);
+  }, [sessions, getStatusType, parentChildMap, unseenCounts]);
 
   const totalRunning = processedSessions.reduce((sum, s) => {
     const selfRunning = s._statusType !== 'idle' ? 1 : 0;
@@ -188,7 +168,6 @@ function useSessionHelpers() {
 
 // Per-project status indicators (running / unread) for the filter chips.
 function useProjectStatus(
-  sessions: Session[],
   sessionStatus: Record<string, { type: string }> | undefined,
   currentSessionId: string | null
 ) {
@@ -450,12 +429,11 @@ export const MobileSessionPanelTrigger: React.FC<MobileSessionPanelTriggerProps>
   );
 };
 
-export const MobileSessionStatusBar: React.FC<MobileSessionStatusBarProps> = ({
+const MobileSessionStatusOpenPanel: React.FC<MobileSessionStatusBarProps> = ({
   onSessionSwitch,
 }) => {
   const { t } = useI18n();
   const { currentTheme } = useThemeSystem();
-  const isMobile = useUIStore((state) => state.isMobile);
   const sessions = useAllProjectSessions();
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const sessionStatus = useAllSessionStatuses();
@@ -469,7 +447,7 @@ export const MobileSessionStatusBar: React.FC<MobileSessionStatusBarProps> = ({
 
   const { sessions: sortedSessions, totalRunning, totalUnread } = useSessionGrouping(sessions, sessionStatus);
   const { getSessionTitle, needsAttention } = useSessionHelpers();
-  const getProjectStatus = useProjectStatus(sessions, sessionStatus, currentSessionId);
+  const getProjectStatus = useProjectStatus(sessionStatus, currentSessionId);
   const resolveProjectRoots = useProjectRootsResolver();
 
   // Project filter, persisted in the UI store so the choice survives closing and
@@ -605,10 +583,6 @@ export const MobileSessionStatusBar: React.FC<MobileSessionStatusBarProps> = ({
     </div>
   ), [t, totalRunning, totalUnread, projects, filterProjectId, setFilterProjectId, formatProjectLabel, currentTheme, getProjectStatus, handleNewChat, setOpen]);
 
-  if (!isMobile) {
-    return null;
-  }
-
   return (
     <MobileOverlayPanel
       open={open}
@@ -639,3 +613,11 @@ export const MobileSessionStatusBar: React.FC<MobileSessionStatusBarProps> = ({
     </MobileOverlayPanel>
   );
 };
+
+export const MobileSessionStatusBar: React.FC<MobileSessionStatusBarProps> = (props) => {
+  const isMobile = useUIStore((state) => state.isMobile);
+  const open = useUIStore((state) => state.mobileSessionPanelOpen);
+
+  if (!isMobile || !open) return null;
+  return <MobileSessionStatusOpenPanel {...props} />;
+};
diff --git a/packages/ui/src/components/chat/ModelControls.tsx b/packages/ui/src/components/chat/ModelControls.tsx
index efafb04d..a325b05d 100644
--- a/packages/ui/src/components/chat/ModelControls.tsx
+++ b/packages/ui/src/components/chat/ModelControls.tsx
@@ -29,9 +29,8 @@ import { useContextStore } from '@/stores/contextStore';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSelectionStore } from '@/sync/selection-store';
-import { useDirectorySync, useSessionMessages } from '@/sync/sync-context';
+import { useSessionMessages, useSessionRenderable } from '@/sync/sync-context';
 import { useSync } from '@/sync/use-sync';
-import { getSessionMaterializationStatus } from '@/sync/materialization';
 import { useUIStore } from '@/stores/useUIStore';
 import { useModelLists } from '@/hooks/useModelLists';
 import { useIsTextTruncated } from '@/hooks/useIsTextTruncated';
@@ -646,11 +645,8 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
     const latestLoadedUserChoiceRestoreRef = React.useRef<string | null>(null);
 
     const currentSessionDirectory = currentSessionId ? getDirectoryForSession(currentSessionId) : undefined;
-    const hasRenderableCurrentSessionSnapshot = useDirectorySync(
-        React.useCallback(
-            (state) => (currentSessionId ? getSessionMaterializationStatus(state, currentSessionId).renderable : false),
-            [currentSessionId],
-        ),
+    const hasRenderableCurrentSessionSnapshot = useSessionRenderable(
+        currentSessionId ?? '',
         currentSessionDirectory ?? undefined,
     );
     const currentSessionMessagesFromSync = useSessionMessages(currentSessionId ?? '', currentSessionDirectory ?? undefined);
diff --git a/packages/ui/src/components/chat/QueuedMessageChips.tsx b/packages/ui/src/components/chat/QueuedMessageChips.tsx
index e1605281..d49b1ae5 100644
--- a/packages/ui/src/components/chat/QueuedMessageChips.tsx
+++ b/packages/ui/src/components/chat/QueuedMessageChips.tsx
@@ -14,7 +14,7 @@ import {
     verticalListSortingStrategy,
 } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
-import { useMessageQueueStore, type QueuedMessage } from '@/stores/messageQueueStore';
+import { createMessageQueueTarget, getMessageQueueKey, useMessageQueueStore, type MessageQueueTarget, type QueuedMessage } from '@/stores/messageQueueStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useInputStore } from '@/sync/input-store';
 import { useI18n } from '@/lib/i18n';
@@ -24,12 +24,12 @@ import { cn } from '@/lib/utils';
 
 interface QueuedMessageChipProps {
     message: QueuedMessage;
-    sessionId: string;
+    target: MessageQueueTarget;
     onEdit: (message: QueuedMessage) => void;
     onSend: (message: QueuedMessage) => void;
 }
 
-const QueuedMessageChip = memo(({ message, sessionId, onEdit, onSend }: QueuedMessageChipProps) => {
+const QueuedMessageChip = memo(({ message, target, onEdit, onSend }: QueuedMessageChipProps) => {
     const { t } = useI18n();
     const removeFromQueue = useMessageQueueStore((state) => state.removeFromQueue);
     const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: message.id });
@@ -89,7 +89,7 @@ const QueuedMessageChip = memo(({ message, sessionId, onEdit, onSend }: QueuedMe
             </Button>
             <button
                 type="button"
-                onClick={() => removeFromQueue(sessionId, message.id)}
+                onClick={() => removeFromQueue(target, message.id)}
                 className="flex items-center justify-center h-6 w-6 flex-shrink-0 hover:bg-[var(--interactive-hover)] rounded-full transition-colors"
                 aria-label={t('chat.queuedMessage.removeAria')}
             >
@@ -111,13 +111,16 @@ const EMPTY_QUEUE: QueuedMessage[] = [];
 export const QueuedMessageChips = memo(({ onEditMessage, onSendMessage }: QueuedMessageChipsProps) => {
     const { t } = useI18n();
     const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
+    const currentSessionDirectory = useSessionUIStore((state) => state.currentSessionDirectory);
+    const target = currentSessionId ? createMessageQueueTarget(currentSessionId, currentSessionDirectory) : null;
+    const queueKey = target ? getMessageQueueKey(target) : null;
     const queuedMessages = useMessageQueueStore(
         React.useCallback(
             (state) => {
-                if (!currentSessionId) return EMPTY_QUEUE;
-                return state.queuedMessages[currentSessionId] ?? EMPTY_QUEUE;
+                if (!queueKey) return EMPTY_QUEUE;
+                return state.queuedMessages[queueKey] ?? EMPTY_QUEUE;
             },
-            [currentSessionId]
+            [queueKey]
         )
     );
     const popToInput = useMessageQueueStore((state) => state.popToInput);
@@ -132,14 +135,14 @@ export const QueuedMessageChips = memo(({ onEditMessage, onSendMessage }: Queued
 
     const handleDragEnd = React.useCallback((event: DragEndEvent) => {
         const { active, over } = event;
-        if (!over || active.id === over.id || !currentSessionId) return;
-        reorderQueue(currentSessionId, String(active.id), String(over.id));
-    }, [currentSessionId, reorderQueue]);
+        if (!over || active.id === over.id || !target) return;
+        reorderQueue(target, String(active.id), String(over.id));
+    }, [target, reorderQueue]);
 
     const handleEdit = React.useCallback((message: QueuedMessage) => {
-        if (!currentSessionId) return;
+        if (!target) return;
         
-        const popped = popToInput(currentSessionId, message.id);
+        const popped = popToInput(target, message.id);
         if (popped) {
             if (popped.attachments && popped.attachments.length > 0) {
                 const currentAttachments = useInputStore.getState().attachedFiles;
@@ -147,13 +150,13 @@ export const QueuedMessageChips = memo(({ onEditMessage, onSendMessage }: Queued
             }
             onEditMessage(popped.content, popped.attachments);
         }
-    }, [currentSessionId, popToInput, onEditMessage]);
+    }, [target, popToInput, onEditMessage]);
 
     const handleSend = React.useCallback((message: QueuedMessage) => {
         onSendMessage(message.id);
     }, [onSendMessage]);
 
-    if (queuedMessages.length === 0 || !currentSessionId) {
+    if (queuedMessages.length === 0 || !target) {
         return null;
     }
 
@@ -180,7 +183,7 @@ export const QueuedMessageChips = memo(({ onEditMessage, onSendMessage }: Queued
                                 <QueuedMessageChip
                                     key={message.id}
                                     message={message}
-                                    sessionId={currentSessionId}
+                                    target={target}
                                     onEdit={handleEdit}
                                     onSend={handleSend}
                                 />
diff --git a/packages/ui/src/components/chat/StatusRow.tsx b/packages/ui/src/components/chat/StatusRow.tsx
index ede1c1c1..1469e1cc 100644
--- a/packages/ui/src/components/chat/StatusRow.tsx
+++ b/packages/ui/src/components/chat/StatusRow.tsx
@@ -159,6 +159,12 @@ export const StatusRow: React.FC<StatusRowProps> = ({
   const { t } = useI18n();
   const [isExpanded, setIsExpanded] = React.useState(false);
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
+  const currentSessionDirectory = useSessionUIStore(
+    React.useCallback(
+      (state) => (currentSessionId ? state.getDirectoryForSession(currentSessionId) : null),
+      [currentSessionId],
+    ),
+  );
   const liveTodos = useDirectorySync(
     React.useCallback(
       (state) => {
@@ -170,8 +176,10 @@ export const StatusRow: React.FC<StatusRowProps> = ({
   );
   const persistedSessionTodos = useTodosPersistStore(
     React.useCallback(
-      (state) => (showTodos && currentSessionId ? state.sessions[currentSessionId]?.todos : undefined),
-      [currentSessionId, showTodos],
+      (state) => (showTodos && currentSessionId && currentSessionDirectory
+        ? state.getSessionTodos(currentSessionDirectory, currentSessionId)
+        : undefined),
+      [currentSessionDirectory, currentSessionId, showTodos],
     ),
   );
   const todos: TodoItem[] = React.useMemo(() => {
diff --git a/packages/ui/src/components/chat/hooks/useTurnRecords.ts b/packages/ui/src/components/chat/hooks/useTurnRecords.ts
index 8228ccc1..14e8f8a0 100644
--- a/packages/ui/src/components/chat/hooks/useTurnRecords.ts
+++ b/packages/ui/src/components/chat/hooks/useTurnRecords.ts
@@ -53,13 +53,14 @@ export const useTurnRecords = (
     const projection = React.useMemo(() => {
         const sessionKey = options.sessionKey ?? '';
         const mergeKey = options.planModeEnabled ? 'merge:plan' : 'merge';
-        const cached = getCachedProjection(
+        const cacheKey = buildProjectionCacheKey(
             sessionKey,
             messages,
             options.showTextJustificationActivity,
             options.showTurnChangedFiles,
             mergeKey,
         );
+        const cached = getCachedProjection(cacheKey);
         if (cached) {
             previousProjectionRef.current = cached;
             return cached;
@@ -74,13 +75,6 @@ export const useTurnRecords = (
             });
             previousProjectionRef.current = nextProjection;
 
-            const cacheKey = buildProjectionCacheKey(
-                sessionKey,
-                messages,
-                options.showTextJustificationActivity,
-                options.showTurnChangedFiles,
-                mergeKey,
-            );
             setCachedProjection(cacheKey, nextProjection);
 
             return nextProjection;
diff --git a/packages/ui/src/components/chat/lib/turns/turnProjectionCache.ts b/packages/ui/src/components/chat/lib/turns/turnProjectionCache.ts
index 91b493c1..52d3fb26 100644
--- a/packages/ui/src/components/chat/lib/turns/turnProjectionCache.ts
+++ b/packages/ui/src/components/chat/lib/turns/turnProjectionCache.ts
@@ -56,14 +56,7 @@ export const buildProjectionCacheKey = (
   ].join('|');
 };
 
-export const getCachedProjection = (
-  sessionKey: string,
-  messages: ChatMessageEntry[],
-  showTextJustificationActivity: boolean,
-  showTurnChangedFiles: boolean,
-  mergeHiddenUserTurnsKey: string,
-): TurnProjectionResult | undefined => {
-  const key = buildProjectionCacheKey(sessionKey, messages, showTextJustificationActivity, showTurnChangedFiles, mergeHiddenUserTurnsKey);
+export const getCachedProjection = (key: string): TurnProjectionResult | undefined => {
   const cached = projectionCache.get(key);
   if (cached) {
     // LRU re-order: move hit to the end (most recent) so it survives
diff --git a/packages/ui/src/components/chat/message/parts/ProgressiveGroup.tsx b/packages/ui/src/components/chat/message/parts/ProgressiveGroup.tsx
index c8256d34..d0e9681a 100644
--- a/packages/ui/src/components/chat/message/parts/ProgressiveGroup.tsx
+++ b/packages/ui/src/components/chat/message/parts/ProgressiveGroup.tsx
@@ -623,7 +623,7 @@ const StaticToolRowInner: React.FC<{
         return entries;
     }, [activities, currentDirectory, isReadGroup]);
 
-    const handleReadFileClick = React.useCallback((filePath: string, offset?: number) => {
+    const handleFileClick = React.useCallback((filePath: string, offset?: number) => {
         const absolutePath = toAbsoluteFilePath(currentDirectory, filePath);
         if (!absolutePath) {
             return;
@@ -656,14 +656,6 @@ const StaticToolRowInner: React.FC<{
         uiStore.openContextFile(contextDirectory, absolutePath);
     }, [currentDirectory, runtime]);
 
-    const handleSkillClick = React.useCallback((skillPath: string) => {
-        if (!skillPath) {
-            return;
-        }
-        const uiStore = useUIStore.getState();
-        uiStore.openContextFile(currentDirectory || getDirectoryForFilePath('', skillPath), skillPath);
-    }, [currentDirectory]);
-
     const normalizedToolName = toolName.toLowerCase();
     const isSearchGroup = normalizedToolName === 'grep'
         || normalizedToolName === 'search'
@@ -699,7 +691,7 @@ const StaticToolRowInner: React.FC<{
                         onClick={(event) => {
                             event.preventDefault();
                             event.stopPropagation();
-                            handleReadFileClick(entry.path, entry.offset);
+                            handleFileClick(entry.path, entry.offset);
                         }}
                         className={cn('inline-flex !min-h-0 items-center justify-start gap-1 min-w-0 flex-1 text-left hover:opacity-90', TOOL_ROW_DESCRIPTION_CLASS)}
                         style={{ color: 'var(--tools-description)' }}
@@ -751,7 +743,7 @@ const StaticToolRowInner: React.FC<{
                         onClick={(event) => {
                             event.preventDefault();
                             event.stopPropagation();
-                            handleSkillClick(entry.path);
+                            handleFileClick(entry.path);
                         }}
                         className={cn('!min-h-0 min-w-0 flex-1 truncate whitespace-nowrap text-left hover:opacity-90', TOOL_ROW_DESCRIPTION_CLASS)}
                         style={{ color: 'var(--tools-description)' }}
diff --git a/packages/ui/src/components/comments/useInlineCommentController.ts b/packages/ui/src/components/comments/useInlineCommentController.ts
index 7b54d6de..3220e07a 100644
--- a/packages/ui/src/components/comments/useInlineCommentController.ts
+++ b/packages/ui/src/components/comments/useInlineCommentController.ts
@@ -1,8 +1,16 @@
 import React from 'react';
 import { toast } from '@/components/ui';
-import { useInlineCommentDraftStore, type InlineCommentDraft, type InlineCommentSource } from '@/stores/useInlineCommentDraftStore';
+import {
+  EMPTY_INLINE_COMMENT_DRAFTS,
+  getInlineCommentDraftKey,
+  useInlineCommentDraftStore,
+  type InlineCommentDraft,
+  type InlineCommentSource,
+} from '@/stores/useInlineCommentDraftStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useI18n } from '@/lib/i18n';
+import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 type LineRangeBase = {
   start: number;
@@ -52,25 +60,42 @@ export function useInlineCommentController<TRange extends LineRangeBase>(
 
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const newSessionDraftOpen = useSessionUIStore((state) => state.newSessionDraft?.open);
+  const effectiveDirectory = useEffectiveDirectory();
+  const sessionDirectory = useSessionUIStore(
+    React.useCallback(
+      (state) => currentSessionId ? state.getDirectoryForSession(currentSessionId) : null,
+      [currentSessionId],
+    ),
+  );
 
   const addDraft = useInlineCommentDraftStore((state) => state.addDraft);
   const updateDraft = useInlineCommentDraftStore((state) => state.updateDraft);
   const removeDraft = useInlineCommentDraftStore((state) => state.removeDraft);
-  const allDrafts = useInlineCommentDraftStore((state) => state.drafts);
 
   const [selection, setSelection] = React.useState<TRange | null>(null);
   const [commentText, setCommentText] = React.useState('');
   const [editingDraftId, setEditingDraftId] = React.useState<string | null>(null);
 
-  const sessionKey = React.useMemo(() => {
-    return currentSessionId ?? (newSessionDraftOpen ? 'draft' : null);
-  }, [currentSessionId, newSessionDraftOpen]);
+  const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : null);
+  const draftDirectory = sessionDirectory ?? effectiveDirectory;
+  const target = React.useMemo(() => {
+    if (!sessionKey || !draftDirectory) return null;
+    return { directory: draftDirectory, sessionKey };
+  }, [draftDirectory, sessionKey]);
+  const targetKey = target
+    ? getInlineCommentDraftKey(getRuntimeKey(), target.directory, target.sessionKey)
+    : null;
+  const sessionDrafts = useInlineCommentDraftStore(
+    React.useCallback(
+      (state) => targetKey ? state.drafts[targetKey] ?? EMPTY_INLINE_COMMENT_DRAFTS : EMPTY_INLINE_COMMENT_DRAFTS,
+      [targetKey],
+    ),
+  );
 
   const drafts = React.useMemo(() => {
-    if (!sessionKey || !fileLabel) return [];
-    const sessionDrafts = allDrafts[sessionKey] ?? [];
+    if (!target || !fileLabel) return [];
     return sessionDrafts.filter((draft) => draft.source === source && draft.fileLabel === fileLabel);
-  }, [allDrafts, fileLabel, sessionKey, source]);
+  }, [fileLabel, sessionDrafts, source, target]);
 
   const reset = React.useCallback(() => {
     setSelection(null);
@@ -90,18 +115,19 @@ export function useInlineCommentController<TRange extends LineRangeBase>(
   }, [fromDraftRange]);
 
   const deleteDraft = React.useCallback((draft: InlineCommentDraft) => {
-    removeDraft(draft.sessionKey, draft.id);
+    if (!target) return;
+    removeDraft(target, draft.id);
     if (editingDraftId === draft.id) {
       reset();
     }
-  }, [editingDraftId, removeDraft, reset]);
+  }, [editingDraftId, removeDraft, reset, target]);
 
   const saveComment = React.useCallback((textToSave: string, rangeOverride?: TRange) => {
     const targetRange = rangeOverride ?? selection;
     const trimmedText = textToSave.trim();
     if (!targetRange || !trimmedText || !fileLabel) return;
 
-    if (!sessionKey) {
+    if (!target) {
       toast.error(t('inlineComment.toast.selectSessionToSave'));
       return;
     }
@@ -111,7 +137,7 @@ export function useInlineCommentController<TRange extends LineRangeBase>(
     const code = getCodeForRange(normalizedRange);
 
     if (editingDraftId) {
-      updateDraft(sessionKey, editingDraftId, {
+      updateDraft(target, editingDraftId, {
         fileLabel,
         startLine: normalizedStoreRange.startLine,
         endLine: normalizedStoreRange.endLine,
@@ -121,8 +147,7 @@ export function useInlineCommentController<TRange extends LineRangeBase>(
         text: trimmedText,
       });
     } else {
-      addDraft({
-        sessionKey,
+      addDraft(target, {
         source,
         fileLabel,
         startLine: normalizedStoreRange.startLine,
@@ -135,7 +160,7 @@ export function useInlineCommentController<TRange extends LineRangeBase>(
     }
 
     reset();
-  }, [addDraft, editingDraftId, fileLabel, getCodeForRange, language, reset, selection, sessionKey, source, t, toStoreRange, updateDraft]);
+  }, [addDraft, editingDraftId, fileLabel, getCodeForRange, language, reset, selection, source, t, target, toStoreRange, updateDraft]);
 
   return {
     sessionKey,
diff --git a/packages/ui/src/components/layout/ContextPanel.tsx b/packages/ui/src/components/layout/ContextPanel.tsx
index e195ba37..2e057339 100644
--- a/packages/ui/src/components/layout/ContextPanel.tsx
+++ b/packages/ui/src/components/layout/ContextPanel.tsx
@@ -542,6 +542,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
   const [hoverTarget, setHoverTarget] = React.useState<PreviewElementMetadata | null>(null);
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const newSessionDraftOpen = useSessionUIStore((state) => state.newSessionDraft?.open);
+  const effectiveDirectory = useEffectiveDirectory();
   const addInlineCommentDraft = useInlineCommentDraftStore((state) => state.addDraft);
   const addAttachedFile = useInputStore((state) => state.addAttachedFile);
 
@@ -688,7 +689,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
 
   const attachPreviewAnnotation = React.useCallback((target: PreviewElementMetadata) => {
     const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : null);
-    if (!sessionKey) {
+    if (!sessionKey || !effectiveDirectory) {
       toast.error(t('contextPanel.preview.inspect.attachNoSession'));
       return;
     }
@@ -712,8 +713,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
         attachedScreenshot = false;
       }
 
-      addInlineCommentDraft({
-        sessionKey,
+      addInlineCommentDraft({ directory: effectiveDirectory, sessionKey }, {
         source: 'preview-annotation',
         fileLabel: pageUrl || 'preview',
         startLine: 1,
@@ -731,7 +731,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
       });
       toast.success(t('contextPanel.preview.inspect.attached'));
     })();
-  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, effectiveSrc, newSessionDraftOpen, rawUrl, t]);
+  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, effectiveDirectory, effectiveSrc, newSessionDraftOpen, rawUrl, t]);
 
   React.useEffect(() => {
     setBridgeReady(false);
@@ -921,7 +921,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
 
   const attachConsoleEvents = React.useCallback(() => {
     const sessionKey = currentSessionId ?? (newSessionDraftOpen ? 'draft' : null);
-    if (!sessionKey) {
+    if (!sessionKey || !effectiveDirectory) {
       toast.error(t('contextPanel.preview.console.attachNoSession'));
       return;
     }
@@ -937,8 +937,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
       return `[${timestamp}] [${event.level}] ${event.message}${details}`;
     }).join('\n');
 
-    addInlineCommentDraft({
-      sessionKey,
+    addInlineCommentDraft({ directory: effectiveDirectory, sessionKey }, {
       source: 'preview-console',
       fileLabel: rawUrl || effectiveSrc || 'preview',
       startLine: 1,
@@ -948,7 +947,7 @@ const PreviewPane: React.FC<PreviewPaneProps> = ({ rawUrl, onNavigate }) => {
       text: t('contextPanel.preview.console.attachAnnotation'),
     });
     toast.success(t('contextPanel.preview.console.attached'));
-  }, [addInlineCommentDraft, consoleEvents, currentSessionId, effectiveSrc, newSessionDraftOpen, rawUrl, t]);
+  }, [addInlineCommentDraft, consoleEvents, currentSessionId, effectiveDirectory, effectiveSrc, newSessionDraftOpen, rawUrl, t]);
 
   // Out-of-band upstream probe: iframes don't expose HTTP status to the parent,
   // so when the proxy returns a 502 (upstream dev server is offline) the iframe
@@ -1590,8 +1589,7 @@ const IframeBrowserPane: React.FC<DesktopBrowserPaneProps> = ({ initialUrl, dire
       await addAttachedFile(file);
     }
 
-    addInlineCommentDraft({
-      sessionKey,
+    addInlineCommentDraft({ directory, sessionKey }, {
       source: 'preview-annotation',
       fileLabel: currentUrl || 'browser',
       startLine: 1,
@@ -1610,7 +1608,7 @@ const IframeBrowserPane: React.FC<DesktopBrowserPaneProps> = ({ initialUrl, dire
       text: '',
     });
     toast.success(t('contextPanel.preview.inspect.attached'));
-  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, currentUrl, newSessionDraftOpen, t]);
+  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, currentUrl, directory, newSessionDraftOpen, t]);
 
   const cancelInspect = React.useCallback(() => {
     const iframe = iframeRef.current;
@@ -1998,8 +1996,7 @@ const DesktopBrowserPane: React.FC<DesktopBrowserPaneProps> = ({ initialUrl, dir
           await addAttachedFile(file);
         }
 
-        addInlineCommentDraft({
-          sessionKey,
+        addInlineCommentDraft({ directory, sessionKey }, {
           source: 'preview-annotation',
           fileLabel: currentUrl || 'browser',
           startLine: 1,
@@ -2018,7 +2015,7 @@ const DesktopBrowserPane: React.FC<DesktopBrowserPaneProps> = ({ initialUrl, dir
         toast.success(t('contextPanel.preview.inspect.attached'));
       })
       .catch(() => setIsInspecting(false));
-  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, currentUrl, isInspecting, newSessionDraftOpen, t]);
+  }, [addAttachedFile, addInlineCommentDraft, currentSessionId, currentUrl, directory, isInspecting, newSessionDraftOpen, t]);
 
   return (
     <div className="absolute inset-0 flex flex-col bg-background">
diff --git a/packages/ui/src/components/layout/Header.tsx b/packages/ui/src/components/layout/Header.tsx
index 276aee87..f9c18eff 100644
--- a/packages/ui/src/components/layout/Header.tsx
+++ b/packages/ui/src/components/layout/Header.tsx
@@ -21,12 +21,12 @@ import { useConfigStore } from '@/stores/useConfigStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSessionWorktreeStore } from '@/sync/session-worktree-store';
 import { formatSessionWorktreeBadge } from '@/sync/session-worktree-contract';
-import { useAllLiveSessions, useSession, useSessionMessagesResolved } from '@/sync/sync-context';
-import { getAllSyncSessions } from '@/sync/sync-refs';
+import { useSessionMessagesResolved } from '@/sync/sync-context';
 import { useProjectsStore } from '@/stores/useProjectsStore';
 import { useQuotaAutoRefresh, useQuotaStore } from '@/stores/useQuotaStore';
 import { useGitBranchLabel } from '@/stores/useGitStore';
 import { useGlobalSessionsStore } from '@/stores/useGlobalSessionsStore';
+import { streamPerfCount } from '@/stores/utils/streamDebug';
 import { useFeatureFlagsStore } from '@/stores/useFeatureFlagsStore';
 
 import { useGitHubAuthStore } from '@/stores/useGitHubAuthStore';
@@ -74,7 +74,7 @@ import { useI18n } from '@/lib/i18n';
 import { runtimeFetch } from '@/lib/runtime-fetch';
 import { getRuntimeBearerTokenSync } from '@/lib/runtime-auth';
 import { getRuntimeApiBaseUrl } from '@/lib/runtime-switch';
-import type { Session } from '@opencode-ai/sdk/v2/client';
+import { useShallow } from 'zustand/react/shallow';
 import type { IconName } from "@/components/icon/icons";
 
 const DESKTOP_HEADER_ICON_BUTTON_CLASS = 'app-region-no-drag inline-flex h-8 w-8 items-center justify-center gap-2 rounded-md typography-ui-label font-medium text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary disabled:pointer-events-none disabled:opacity-50 hover:bg-interactive-hover transition-colors';
@@ -703,12 +703,20 @@ interface HeaderProps {
   rightDrawerOpen?: boolean;
 }
 
+type HeaderSessionSnapshot = {
+  title: string | null;
+  directory: string | null;
+  created: number | null;
+  slug: string | null;
+};
+
 export const Header: React.FC<HeaderProps> = ({
   onToggleLeftDrawer,
   onToggleRightDrawer,
   leftDrawerOpen,
   rightDrawerOpen,
 }) => {
+  streamPerfCount('ui.header.render');
   const { t } = useI18n();
   const setSessionSwitcherOpen = useUIStore((state) => state.setSessionSwitcherOpen);
   const toggleSidebar = useUIStore((state) => state.toggleSidebar);
@@ -720,7 +728,6 @@ export const Header: React.FC<HeaderProps> = ({
   const openContextBrowser = useUIStore((state) => state.openContextBrowser);
   const openContextPanelTab = useUIStore((state) => state.openContextPanelTab);
   const closeContextPanel = useUIStore((state) => state.closeContextPanel);
-  const contextPanelByDirectory = useUIStore((state) => state.contextPanelByDirectory);
   const activeMainTab = useUIStore((state) => state.activeMainTab);
   const setActiveMainTab = useUIStore((state) => state.setActiveMainTab);
   const shortcutOverrides = useUIStore((state) => state.shortcutOverrides);
@@ -734,15 +741,28 @@ export const Header: React.FC<HeaderProps> = ({
   const isNewSessionDraftOpen = useSessionUIStore((state) => Boolean(state.newSessionDraft?.open));
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const currentSessionMessagesResolved = useSessionMessagesResolved(currentSessionId ?? '');
-  const currentSyncedSession = useSession(currentSessionId ?? null);
-  const globalActiveSessions = useGlobalSessionsStore((state) => state.activeSessions);
-  const liveSessions = useAllLiveSessions();
-  const activeProject = useProjectsStore((state) => {
+  const currentGlobalSession = useGlobalSessionsStore(useShallow(React.useCallback(
+    (state): HeaderSessionSnapshot | null => {
+      if (!currentSessionId) return null;
+      const session = state.activeSessions.find((candidate) => candidate.id === currentSessionId);
+      if (!session) return null;
+      const record = session as typeof session & { directory?: string | null; slug?: string | null };
+      return {
+        title: session.title ?? null,
+        directory: record.directory ?? null,
+        created: session.time?.created ?? null,
+        slug: record.slug ?? null,
+      };
+    },
+    [currentSessionId],
+  )));
+  const activeProject = useProjectsStore(useShallow((state) => {
     if (!state.activeProjectId) {
       return null;
     }
-    return state.projects.find((project) => project.id === state.activeProjectId) ?? null;
-  });
+    const project = state.projects.find((candidate) => candidate.id === state.activeProjectId);
+    return project ? { id: project.id, path: project.path, label: project.label } : null;
+  }));
   const activeProjectLabel = React.useMemo(() => {
     if (!activeProject) {
       return null;
@@ -1130,18 +1150,13 @@ export const Header: React.FC<HeaderProps> = ({
     });
   }, [fetchAllQuotas, isUsageRefreshSpinning]);
 
-  const currentSessionLive = React.useMemo(() => {
-    if (!currentSessionId) return null;
-    return liveSessions.find((s) => s.id === currentSessionId)
-      ?? globalActiveSessions.find((s) => s.id === currentSessionId)
-      ?? currentSyncedSession
-      ?? getAllSyncSessions().find((s) => s.id === currentSessionId)
-      ?? null;
-  }, [currentSessionId, currentSyncedSession, globalActiveSessions, liveSessions]);
+  const currentSessionSnapshot = currentSessionId
+    ? currentGlobalSession ?? null
+    : null;
 
   const lastResolvedSessionRef = React.useRef<{
     sessionId: string;
-    session: Session;
+    session: HeaderSessionSnapshot;
     expiresAt: number;
   } | null>(null);
   const [sessionFallbackVersion, setSessionFallbackVersion] = React.useState(0);
@@ -1155,10 +1170,10 @@ export const Header: React.FC<HeaderProps> = ({
       return;
     }
 
-    if (currentSessionLive) {
+    if (currentSessionSnapshot) {
       lastResolvedSessionRef.current = {
         sessionId: currentSessionId,
-        session: currentSessionLive,
+        session: currentSessionSnapshot,
         expiresAt: Date.now() + 2000,
       };
       return;
@@ -1186,12 +1201,12 @@ export const Header: React.FC<HeaderProps> = ({
     return () => {
       window.clearTimeout(timeoutId);
     };
-  }, [currentSessionId, currentSessionLive]);
+  }, [currentSessionId, currentSessionSnapshot]);
 
   void sessionFallbackVersion;
   const currentSession = (() => {
-    if (currentSessionLive) {
-      return currentSessionLive;
+    if (currentSessionSnapshot) {
+      return currentSessionSnapshot;
     }
 
     if (!currentSessionId) {
@@ -1256,6 +1271,10 @@ export const Header: React.FC<HeaderProps> = ({
   const openDirectory = React.useMemo(() => {
     return worktreeDirectory || sessionDirectory || draftDirectory;
   }, [draftDirectory, sessionDirectory, worktreeDirectory]);
+  const activeContextMode = useUIStore(React.useCallback((state) => {
+    const directory = normalize(openDirectory || '');
+    return directory ? getActiveContextMode(state.contextPanelByDirectory[directory]) : null;
+  }, [openDirectory]));
 
   const catalogWorktreeBranch = useSessionUIStore((state) => {
     const candidateDirectory = normalize(worktreeDirectory || sessionDirectory || '');
@@ -1336,7 +1355,7 @@ export const Header: React.FC<HeaderProps> = ({
 
     if (!currentSessionId) return;
 
-    const sessionKey = `${currentSessionId || 'none'}:${sessionDirectory || 'none'}:${currentSession?.time?.created || 0}:${currentSession?.slug || 'none'}`;
+    const sessionKey = `${currentSessionId || 'none'}:${sessionDirectory || 'none'}:${currentSession?.created || 0}:${currentSession?.slug || 'none'}`;
     if (lastPlanSessionKeyRef.current !== sessionKey) {
       lastPlanSessionKeyRef.current = sessionKey;
     }
@@ -1349,7 +1368,7 @@ export const Header: React.FC<HeaderProps> = ({
     planModeEnabled,
     planTabAvailable,
     currentSession?.slug,
-    currentSession?.time?.created,
+    currentSession?.created,
     currentSessionId,
     sessionDirectory,
   ]);
@@ -1449,23 +1468,16 @@ export const Header: React.FC<HeaderProps> = ({
       return;
     }
 
-    const panelState = contextPanelByDirectory[directory];
+    const panelState = useUIStore.getState().contextPanelByDirectory[directory];
     if (getActiveContextMode(panelState) === 'context') {
       closeContextPanel(directory);
       return;
     }
 
     openContextOverview(directory);
-  }, [closeContextPanel, contextPanelByDirectory, openContextOverview, openDirectory]);
+  }, [closeContextPanel, openContextOverview, openDirectory]);
 
-  const isContextPanelActive = React.useMemo(() => {
-    const directory = normalize(openDirectory || '');
-    if (!directory) {
-      return false;
-    }
-    const panelState = contextPanelByDirectory[directory];
-    return getActiveContextMode(panelState) === 'context';
-  }, [contextPanelByDirectory, openDirectory]);
+  const isContextPanelActive = activeContextMode === 'context';
 
   const handleOpenContextPlan = React.useCallback(() => {
     const directory = normalize(openDirectory || '');
@@ -1473,14 +1485,14 @@ export const Header: React.FC<HeaderProps> = ({
       return;
     }
 
-    const panelState = contextPanelByDirectory[directory];
+    const panelState = useUIStore.getState().contextPanelByDirectory[directory];
     if (getActiveContextMode(panelState) === 'plan') {
       closeContextPanel(directory);
       return;
     }
 
     openContextPlan(directory);
-  }, [closeContextPanel, contextPanelByDirectory, openContextPlan, openDirectory]);
+  }, [closeContextPanel, openContextPlan, openDirectory]);
 
   const handleOpenContextChanges = React.useCallback(() => {
     const directory = normalize(openDirectory || '');
@@ -1488,14 +1500,14 @@ export const Header: React.FC<HeaderProps> = ({
       return;
     }
 
-    const panelState = contextPanelByDirectory[directory];
+    const panelState = useUIStore.getState().contextPanelByDirectory[directory];
     if (getActiveContextMode(panelState) === 'diff') {
       closeContextPanel(directory);
       return;
     }
 
     openContextPanelTab(directory, { mode: 'diff', stagedDiff: false });
-  }, [closeContextPanel, contextPanelByDirectory, openContextPanelTab, openDirectory]);
+  }, [closeContextPanel, openContextPanelTab, openDirectory]);
 
   const handleOpenContextBrowser = React.useCallback(() => {
     const directory = normalize(openDirectory || '');
@@ -1503,41 +1515,18 @@ export const Header: React.FC<HeaderProps> = ({
       return;
     }
 
-    const panelState = contextPanelByDirectory[directory];
+    const panelState = useUIStore.getState().contextPanelByDirectory[directory];
     if (getActiveContextMode(panelState) === 'browser') {
       closeContextPanel(directory);
       return;
     }
 
     openContextBrowser(directory);
-  }, [closeContextPanel, contextPanelByDirectory, openContextBrowser, openDirectory]);
+  }, [closeContextPanel, openContextBrowser, openDirectory]);
 
-  const isContextPlanActive = React.useMemo(() => {
-    const directory = normalize(openDirectory || '');
-    if (!directory) {
-      return false;
-    }
-    const panelState = contextPanelByDirectory[directory];
-    return getActiveContextMode(panelState) === 'plan';
-  }, [contextPanelByDirectory, openDirectory]);
-
-  const isContextChangesActive = React.useMemo(() => {
-    const directory = normalize(openDirectory || '');
-    if (!directory) {
-      return false;
-    }
-    const panelState = contextPanelByDirectory[directory];
-    return getActiveContextMode(panelState) === 'diff';
-  }, [contextPanelByDirectory, openDirectory]);
-
-  const isContextBrowserActive = React.useMemo(() => {
-    const directory = normalize(openDirectory || '');
-    if (!directory) {
-      return false;
-    }
-    const panelState = contextPanelByDirectory[directory];
-    return getActiveContextMode(panelState) === 'browser';
-  }, [contextPanelByDirectory, openDirectory]);
+  const isContextPlanActive = activeContextMode === 'plan';
+  const isContextChangesActive = activeContextMode === 'diff';
+  const isContextBrowserActive = activeContextMode === 'browser';
 
   const desktopHeaderIconButtonClass = DESKTOP_HEADER_ICON_BUTTON_CLASS;
   const mobileHeaderIconButtonClass = MOBILE_HEADER_ICON_BUTTON_CLASS;
diff --git a/packages/ui/src/components/layout/MainLayout.tsx b/packages/ui/src/components/layout/MainLayout.tsx
index 0efd43b4..0347df87 100644
--- a/packages/ui/src/components/layout/MainLayout.tsx
+++ b/packages/ui/src/components/layout/MainLayout.tsx
@@ -72,7 +72,6 @@ export const MainLayout: React.FC = () => {
         setMobileLeftDrawerOpen(open);
         useUIStore.getState().setSessionSwitcherOpen(open);
     }, []);
-    const mobileRightDrawerOpenRef = React.useRef(false);
     const initialDrawerWidthRef = React.useRef(typeof window === 'undefined' ? 0 : window.innerWidth);
 
     // Left drawer motion value
@@ -114,7 +113,6 @@ export const MainLayout: React.FC = () => {
             setMobileRightDrawerVisible(false);
             return;
         }
-        mobileRightDrawerOpenRef.current = mobileRightSidebarOpen;
         if (mobileRightSidebarOpen) {
             setMobileRightDrawerVisible(true);
         }
@@ -441,7 +439,7 @@ export const MainLayout: React.FC = () => {
                     >
                         <main className="w-full h-full overflow-hidden bg-background relative" data-page-scroll-lock="true">
                             <div className={cn('absolute inset-0', !isChatActive && 'invisible')}>
-                                <ErrorBoundary><ChatView /></ErrorBoundary>
+                                <ErrorBoundary><ChatView active={isChatActive && !isSettingsDialogOpen} /></ErrorBoundary>
                             </div>
                             {secondaryView && (
                                 <div className="absolute inset-0">
@@ -480,7 +478,7 @@ export const MainLayout: React.FC = () => {
                                 aria-hidden={!mobileLeftDrawerOpen}
                             >
                                 <ErrorBoundary>
-                                    <SessionSidebar mobileVariant />
+                                    <SessionSidebar mobileVariant isVisible={mobileLeftDrawerVisible} />
                                 </ErrorBoundary>
                             </motion.div>
                             {mobileRightDrawerVisible && (
@@ -520,7 +518,7 @@ export const MainLayout: React.FC = () => {
                             className="border-border/50"
                             topBar={<SidebarTopBar />}
                         >
-                            <SessionSidebar />
+                            <SessionSidebar isVisible={isSidebarOpen} />
                         </Sidebar>
                         <div className="relative flex flex-1 min-w-0 flex-col overflow-hidden bg-background" data-page-scroll-lock="true">
                             <Header />
@@ -530,7 +528,7 @@ export const MainLayout: React.FC = () => {
                                         <div className="relative flex flex-1 min-h-0 min-w-0 overflow-hidden" data-page-scroll-lock="true">
                                             <main className="flex-1 overflow-hidden bg-background relative" data-page-scroll-lock="true">
                                                 <div className={cn('absolute inset-0', !isChatActive && 'invisible')}>
-                                                    <ErrorBoundary><ChatView /></ErrorBoundary>
+                                                    <ErrorBoundary><ChatView active={isChatActive && !isSettingsDialogOpen} /></ErrorBoundary>
                                                 </div>
                                                 {secondaryView && (
                                                     <div className="absolute inset-0">
diff --git a/packages/ui/src/components/layout/SidebarFilesTree.tsx b/packages/ui/src/components/layout/SidebarFilesTree.tsx
index 2ad972d2..4763cc33 100644
--- a/packages/ui/src/components/layout/SidebarFilesTree.tsx
+++ b/packages/ui/src/components/layout/SidebarFilesTree.tsx
@@ -1,4 +1,5 @@
 import React from 'react';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 import { toast } from '@/components/ui';
 import {
@@ -121,20 +122,23 @@ type FileTreeCache = {
 };
 const FILE_TREE_CACHE_MAX_ROOTS = 8;
 const fileTreeCacheByRoot = new Map<string, FileTreeCache>();
+const fileTreeCacheKey = (root: string): string => JSON.stringify([getRuntimeKey(), root]);
 
 const touchCache = (root: string): FileTreeCache | null => {
-  const entry = fileTreeCacheByRoot.get(root);
+  const key = fileTreeCacheKey(root);
+  const entry = fileTreeCacheByRoot.get(key);
   if (!entry) return null;
   entry.touchedAt = Date.now();
   // Touch on read promotes the key to the end of the Map's iteration order,
   // so the oldest (front) entry is the next eviction candidate.
-  fileTreeCacheByRoot.delete(root);
-  fileTreeCacheByRoot.set(root, entry);
+  fileTreeCacheByRoot.delete(key);
+  fileTreeCacheByRoot.set(key, entry);
   return entry;
 };
 
 const getOrCreateCache = (root: string): FileTreeCache => {
-  const existing = fileTreeCacheByRoot.get(root);
+  const key = fileTreeCacheKey(root);
+  const existing = fileTreeCacheByRoot.get(key);
   if (existing) {
     existing.touchedAt = Date.now();
     return existing;
@@ -151,12 +155,12 @@ const getOrCreateCache = (root: string): FileTreeCache => {
     loadedDirs: new Set(),
     touchedAt: Date.now(),
   };
-  fileTreeCacheByRoot.set(root, created);
+  fileTreeCacheByRoot.set(key, created);
   return created;
 };
 
 const dropCacheForRoot = (root: string): void => {
-  fileTreeCacheByRoot.delete(root);
+  fileTreeCacheByRoot.delete(fileTreeCacheKey(root));
 };
 
 const getFileIcon = (filePath: string, extension?: string): React.ReactNode => {
diff --git a/packages/ui/src/components/layout/VSCodeLayout.tsx b/packages/ui/src/components/layout/VSCodeLayout.tsx
index 10d44b28..a944725f 100644
--- a/packages/ui/src/components/layout/VSCodeLayout.tsx
+++ b/packages/ui/src/components/layout/VSCodeLayout.tsx
@@ -251,6 +251,10 @@ export const VSCodeLayout: React.FC = () => {
     setCurrentView('sessions');
   }, []);
 
+  const handleSessionSelected = React.useCallback(() => {
+    setCurrentView('chat');
+  }, []);
+
   const isSessionInActiveWorkspace = React.useCallback((session: Session): boolean => {
     if (!activeWorkspacePath) {
       return false;
@@ -590,7 +594,7 @@ export const VSCodeLayout: React.FC = () => {
             />
             <div className="flex-1 overflow-hidden">
               <ErrorBoundary>
-                <ChatView />
+                <ChatView active={currentView === 'chat'} />
               </ErrorBoundary>
             </div>
           </div>
@@ -609,7 +613,7 @@ export const VSCodeLayout: React.FC = () => {
                 <SessionSidebar
                   mobileVariant
                   allowReselect
-                  onSessionSelected={() => setCurrentView('chat')}
+                  onSessionSelected={handleSessionSelected}
                   hideDirectoryControls
                 />
               </div>
@@ -628,7 +632,7 @@ export const VSCodeLayout: React.FC = () => {
             />
             <div className="flex-1 overflow-hidden">
               <ErrorBoundary>
-                <ChatView />
+                <ChatView active={currentView === 'chat'} />
               </ErrorBoundary>
             </div>
           </div>
diff --git a/packages/ui/src/components/layout/__tests__/mainLayoutMobileSidebarMount.test.ts b/packages/ui/src/components/layout/__tests__/mainLayoutMobileSidebarMount.test.ts
index d3d977ab..2f567528 100644
--- a/packages/ui/src/components/layout/__tests__/mainLayoutMobileSidebarMount.test.ts
+++ b/packages/ui/src/components/layout/__tests__/mainLayoutMobileSidebarMount.test.ts
@@ -8,6 +8,10 @@ const mainLayoutSource = readFileSync(
     join(__dirname, '..', 'MainLayout.tsx'),
     'utf-8',
 );
+const sessionSidebarSource = readFileSync(
+    join(__dirname, '..', '..', 'session', 'SessionSidebar.tsx'),
+    'utf-8',
+);
 
 describe('MainLayout mobile SessionSidebar mount (issue #1695 regression guard)', () => {
     test('mobile SessionSidebar is not conditionally mounted on mobileLeftDrawerVisible', () => {
@@ -20,10 +24,11 @@ describe('MainLayout mobile SessionSidebar mount (issue #1695 regression guard)'
         expect(/\{\s*mobileLeftDrawerVisible\s*&&\s*\(/.test(precedingWindow)).toBe(false);
 
         expect(precedingWindow.includes('pointer-events-none')).toBe(true);
+        expect(mainLayoutSource.slice(mobileSidebarIndex, mobileSidebarIndex + 120)).toContain('isVisible={mobileLeftDrawerVisible}');
     });
 
     test('desktop SessionSidebar is rendered inside Sidebar without drawer-visibility gating', () => {
-        const desktopSidebarIndex = mainLayoutSource.indexOf('<SessionSidebar />');
+        const desktopSidebarIndex = mainLayoutSource.indexOf('<SessionSidebar isVisible={isSidebarOpen} />');
         expect(desktopSidebarIndex).toBeGreaterThan(-1);
 
         const windowStart = Math.max(0, desktopSidebarIndex - 300);
@@ -32,4 +37,12 @@ describe('MainLayout mobile SessionSidebar mount (issue #1695 regression guard)'
         expect(precedingWindow).toContain('<Sidebar');
         expect(/mobileLeftDrawerVisible\s*&&/.test(precedingWindow)).toBe(false);
     });
+
+    test('hidden sidebars disable render-only subscriptions and effects', () => {
+        expect(sessionSidebarSource).toContain('useGitAllBranches(isVisible)');
+        expect(sessionSidebarSource).toContain('useGitRepoStatusMap(isVisible ? normalizedProjectPaths : EMPTY_STRING_ARRAY)');
+        expect(sessionSidebarSource).toContain('enabled: isVisible,\n    isSessionSearchOpen');
+        expect(sessionSidebarSource).toContain('enabled: isVisible,\n    isDesktopShellRuntime');
+        expect(sessionSidebarSource).toContain('if (!isVisible) return EMPTY_STRING_ARRAY;');
+    });
 });
diff --git a/packages/ui/src/components/session/SessionSidebar.tsx b/packages/ui/src/components/session/SessionSidebar.tsx
index 5a0213e2..1104d4ad 100644
--- a/packages/ui/src/components/session/SessionSidebar.tsx
+++ b/packages/ui/src/components/session/SessionSidebar.tsx
@@ -7,10 +7,11 @@ import { isDesktopShell } from '@/lib/desktop';
 import { sessionEvents } from '@/lib/sessionEvents';
 import { formatDirectoryName, cn } from '@/lib/utils';
 import { useSessionUIStore } from '@/sync/session-ui-store';
-import { useAllLiveSessions } from '@/sync/sync-context';
+import { useChildStoreManager } from '@/sync/sync-context';
+import { getAllSyncSessionMap } from '@/sync/sync-refs';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
 import { useSync } from '@/sync/use-sync';
-import { useSessionPrefetch } from './sidebar/hooks/useSessionPrefetch';
+import { SessionPrefetchEffect } from './sidebar/hooks/useSessionPrefetch';
 import { useProjectsStore } from '@/stores/useProjectsStore';
 import { useUIStore } from '@/stores/useUIStore';
 import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
@@ -22,7 +23,7 @@ import { useSessionFoldersStore } from '@/stores/useSessionFoldersStore';
 import { useDebouncedValue } from '@/hooks/useDebouncedValue';
 import { useArchivedAutoFolders } from './sidebar/hooks/useArchivedAutoFolders';
 import { useSessionSidebarSections } from './sidebar/hooks/useSessionSidebarSections';
-import { useProjectSessionSelection } from './sidebar/hooks/useProjectSessionSelection';
+import { ProjectSessionSelectionEffect } from './sidebar/hooks/useProjectSessionSelection';
 import { useGroupOrdering } from './sidebar/hooks/useGroupOrdering';
 import { useSessionGrouping } from './sidebar/hooks/useSessionGrouping';
 import { useSessionSearchEffects } from './sidebar/hooks/useSessionSearchEffects';
@@ -30,7 +31,7 @@ import { useSessionActions } from './sidebar/hooks/useSessionActions';
 import { useSidebarPersistence } from './sidebar/hooks/useSidebarPersistence';
 import { useProjectRepoStatus } from './sidebar/hooks/useProjectRepoStatus';
 import { useProjectSessionLists } from './sidebar/hooks/useProjectSessionLists';
-import { useSessionFolderCleanup } from './sidebar/hooks/useSessionFolderCleanup';
+import { useAuthoritativeSessionCleanup } from './sidebar/hooks/useAuthoritativeSessionCleanup';
 import { createSessionOwnershipIndex } from './sidebar/sessionOwnership';
 import { useStickyProjectHeaders } from './sidebar/hooks/useStickyProjectHeaders';
 import { getGitHubPrStatusKey, usePrVisualSummaryByKeys, useGitHubPrStatusStore } from '@/stores/useGitHubPrStatusStore';
@@ -69,30 +70,32 @@ import {
   compareSessionsByPinnedAndTime,
   formatProjectLabel,
   normalizePath,
+  selectExpandedParentKeysForContext,
+  toggleExpandedParentKey,
 } from './sidebar/utils';
 import {
-  mergeLiveSessionWithGlobalSession,
   refreshGlobalSessions,
   refreshGlobalSessionsForDirectories,
+  getSessionStructuralSignature,
   resolveGlobalSessionDirectory,
   useGlobalSessionsStore,
 } from '@/stores/useGlobalSessionsStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import { useGitHubAuthStore } from '@/stores/useGitHubAuthStore';
 import { subscribeOpenchamberEvents } from '@/lib/openchamberEvents';
+import { buildSessionBootstrapDemands } from './sidebar/sessionBootstrapDemands';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { streamPerfCount, streamPerfMark } from '@/stores/utils/streamDebug';
 
 const PROJECT_COLLAPSE_STORAGE_KEY = 'oc.sessions.projectCollapse';
 const GROUP_ORDER_STORAGE_KEY = 'oc.sessions.groupOrder';
 const GROUP_COLLAPSE_STORAGE_KEY = 'oc.sessions.groupCollapse';
 const PROJECT_ACTIVE_SESSION_STORAGE_KEY = 'oc.sessions.activeSessionByProject';
-// v2 key holds composite "${renderContext}:${active|archived}:${sessionId}"
+// v3 holds composite "${renderContext}:${active|archived}:${sessionId}"
 // entries so the same session in different render contexts (e.g. "Recent"
-// and a project's root) has independent expand state. v1 held bare session
-// ids; useSidebarPersistence migrates v1 data on first read by fanning each
-// id into all four context combinations.
-const SESSION_EXPANDED_STORAGE_KEY = 'oc.sessions.expandedParents.v2';
-const LEGACY_SESSION_EXPANDED_STORAGE_KEY = 'oc.sessions.expandedParents';
-const SESSION_PINNED_STORAGE_KEY = 'oc.sessions.pinned';
+// and a project's root) has independent expand state. Older expansion state
+// mixed contexts and is intentionally not migrated.
+const SESSION_EXPANDED_STORAGE_KEY = 'oc.sessions.expandedParents.v3';
 
 type PrVisualState = 'draft' | 'open' | 'blocked' | 'merged' | 'closed';
 
@@ -157,6 +160,7 @@ const isKnownActiveSessionDirectory = (
 const SIDEBAR_PR_NO_PR_RETRY_MS = 5 * 60_000;
 
 const EMPTY_SUBTREE_SET: Set<string> = new Set();
+const EMPTY_STRING_ARRAY: string[] = [];
 
 const useStableRenderCallback = <Args extends unknown[], Return>(handler: (...args: Args) => Return): ((...args: Args) => Return) => {
   const handlerRef = React.useRef(handler);
@@ -165,6 +169,7 @@ const useStableRenderCallback = <Args extends unknown[], Return>(handler: (...ar
 };
 
 interface SessionSidebarProps {
+  isVisible?: boolean;
   mobileVariant?: boolean;
   onSessionSelected?: (sessionId: string) => void;
   allowReselect?: boolean;
@@ -172,13 +177,65 @@ interface SessionSidebarProps {
   showOnlyMainWorkspace?: boolean;
 }
 
-export const SessionSidebar: React.FC<SessionSidebarProps> = ({
+const SidebarBootstrapDemandEffect: React.FC<{
+  owner: string;
+  childStores: ReturnType<typeof useChildStoreManager>;
+  projectSections: Parameters<typeof buildSessionBootstrapDemands>[0]['projectSections'];
+  activeProjectId: string | null;
+  collapsedProjects: ReadonlySet<string>;
+  collapsedGroups: ReadonlySet<string>;
+  currentDirectory: string | null;
+}> = ({
+  owner,
+  childStores,
+  projectSections,
+  activeProjectId,
+  collapsedProjects,
+  collapsedGroups,
+  currentDirectory,
+}) => {
+  const currentSessionDirectory = useSessionUIStore((state) => state.currentSessionDirectory);
+
+  React.useEffect(() => {
+    childStores.setBootstrapDemand(owner, buildSessionBootstrapDemands({
+      projectSections,
+      activeProjectId,
+      collapsedProjects,
+      collapsedGroups,
+      currentDirectory,
+      currentSessionDirectory,
+    }));
+  }, [
+    activeProjectId,
+    childStores,
+    collapsedGroups,
+    collapsedProjects,
+    currentDirectory,
+    currentSessionDirectory,
+    owner,
+    projectSections,
+  ]);
+
+  React.useEffect(
+    () => () => childStores.clearBootstrapDemand(owner),
+    [childStores, owner],
+  );
+
+  return null;
+};
+
+const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
+  isVisible = true,
   mobileVariant = false,
   onSessionSelected,
   allowReselect = false,
   hideDirectoryControls = false,
   showOnlyMainWorkspace = false,
 }) => {
+  streamPerfMark('react.session_sidebar_render');
+  streamPerfCount('ui.session_sidebar.render');
+  streamPerfCount(`ui.session_sidebar.render.${mobileVariant ? 'mobile' : 'desktop'}`);
+  streamPerfCount(`ui.session_sidebar.render.${isVisible ? 'visible' : 'hidden'}`);
   const { t } = useI18n();
   const [isSessionSearchOpen, setIsSessionSearchOpen] = React.useState(false);
   const [sessionSearchQuery, setSessionSearchQuery] = React.useState('');
@@ -204,7 +261,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const [deleteFolderConfirm, setDeleteFolderConfirm] = React.useState<DeleteFolderConfirmState>(null);
   const [bulkDeleteConfirm, setBulkDeleteConfirm] = React.useState<BulkDeleteSessionsConfirmState>(null);
   const pinnedSessionIds = useSessionPinnedStore((state) => state.ids);
-  const setPinnedSessionIds = useSessionPinnedStore((state) => state.setIds);
   const togglePinnedSession = useSessionPinnedStore((state) => state.toggle);
   const [collapsedGroups, setCollapsedGroups] = React.useState<Set<string>>(() => {
     try {
@@ -236,7 +292,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       return new Map();
     }
   });
-  const [activeSessionByProject, setActiveSessionByProject] = React.useState<Map<string, string>>(() => {
+  const initialActiveSessionByProject = React.useMemo<Map<string, string>>(() => {
     try {
       const raw = getDeferredSafeStorage().getItem(PROJECT_ACTIVE_SESSION_STORAGE_KEY);
       if (!raw) {
@@ -253,7 +309,12 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     } catch {
       return new Map();
     }
-  });
+  }, []);
+  const persistActiveSessionByProject = React.useCallback((value: Map<string, string>) => {
+    try {
+      safeStorage.setItem(PROJECT_ACTIVE_SESSION_STORAGE_KEY, JSON.stringify(Object.fromEntries(value.entries())));
+    } catch { /* ignored */ }
+  }, [safeStorage]);
 
   const [projectRootBranches, setProjectRootBranches] = React.useState<Map<string, string>>(new Map());
   const projectHeaderSentinelRefs = React.useRef<Map<string, HTMLDivElement | null>>(new Map());
@@ -261,7 +322,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
 
   const homeDirectory = useDirectoryStore((state) => state.homeDirectory);
   const currentDirectory = useDirectoryStore((state) => state.currentDirectory);
-  const setDirectory = useDirectoryStore((state) => state.setDirectory);
 
   const projects = useProjectsStore((state) => state.projects);
   const activeProjectId = useProjectsStore((state) => state.activeProjectId);
@@ -302,26 +362,51 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const removeSessionFromFolder = useSessionFoldersStore((state) => state.removeSessionFromFolder);
   const removeSessionsFromFolders = useSessionFoldersStore((state) => state.removeSessionsFromFolders);
   const toggleFolderCollapse = useSessionFoldersStore((state) => state.toggleFolderCollapse);
-  const cleanupSessions = useSessionFoldersStore((state) => state.cleanupSessions);
   const getSessionFolderId = useSessionFoldersStore((state) => state.getSessionFolderId);
 
   useSessionSearchEffects({
+    enabled: isVisible,
     isSessionSearchOpen,
     setIsSessionSearchOpen,
     sessionSearchInputRef,
     sessionSearchContainerRef,
   });
 
-  const gitBranches = useGitAllBranches();
+  const gitBranches = useGitAllBranches(isVisible);
 
   const sync = useSync();
-  const liveSessions = useAllLiveSessions();
+  const childStores = useChildStoreManager();
+  const bootstrapDemandOwner = `session-sidebar:${React.useId()}`;
+  const liveSessionIndex = getAllSyncSessionMap();
+  const liveSessions = React.useMemo(() => Array.from(liveSessionIndex.values()), [liveSessionIndex]);
   const isVSCode = React.useMemo(() => isVSCodeRuntime(), []);
   const hasAuthoritativeGlobalSessions = useGlobalSessionsStore((state) => state.status === 'ready');
-  const globalActiveSessions = useGlobalSessionsStore((state) => state.activeSessions);
-  const archivedSessions = useGlobalSessionsStore((state) => state.archivedSessions);
-  const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
-  const newSessionDraftOpen = useSessionUIStore((state) => Boolean(state.newSessionDraft?.open));
+  const activeSessionStructure = useGlobalSessionsStore(useShallow(
+    (state) => state.activeSessions.map(getSessionStructuralSignature).sort(),
+  ));
+  const archivedSessionStructure = useGlobalSessionsStore(useShallow(
+    (state) => state.archivedSessions.map(getSessionStructuralSignature).sort(),
+  ));
+  const globalSessionSnapshot = useGlobalSessionsStore.getState();
+  const globalActiveSessions = globalSessionSnapshot.activeSessions;
+  const archivedSessions = globalSessionSnapshot.archivedSessions;
+  const liveFallbackCacheRef = React.useRef<{ signature: string; sessions: Session[] }>({
+    signature: '',
+    sessions: [],
+  });
+  const globalActiveSessionIds = React.useMemo(
+    () => new Set(globalActiveSessions.map((session) => session.id)),
+    [globalActiveSessions],
+  );
+  const liveFallbackSessions = (() => {
+    const candidates = liveSessions.filter((session) => !globalActiveSessionIds.has(session.id));
+    const signature = candidates.map(getSessionStructuralSignature).sort().join('\n');
+    if (liveFallbackCacheRef.current.signature === signature) {
+      return liveFallbackCacheRef.current.sessions;
+    }
+    liveFallbackCacheRef.current = { signature, sessions: candidates };
+    return candidates;
+  })();
   const setCurrentSession = useSessionUIStore((state) => state.setCurrentSession);
   const updateSessionTitle = useSessionUIStore((state) => state.updateSessionTitle);
   const shareSession = useSessionUIStore((state) => state.shareSession);
@@ -359,14 +444,10 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   );
 
   const sessions = React.useMemo(() => {
-    const liveById = new Map(liveSessions.map((session) => [session.id, session]));
-    const merged = globalActiveSessions.map((session) => {
-      const liveSession = liveById.get(session.id);
-      return liveSession ? mergeLiveSessionWithGlobalSession(liveSession, session) : session;
-    });
+    const merged = [...globalActiveSessions];
     const seenIds = new Set(merged.map((session) => session.id));
 
-    liveSessions.forEach((session) => {
+    liveFallbackSessions.forEach((session) => {
       if (seenIds.has(session.id)) {
         return;
       }
@@ -377,43 +458,24 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       allowUnknownDirectory: !isVSCode,
       allowEmptyDirectorySet: !isVSCode,
     }));
-  }, [globalActiveSessions, isVSCode, knownSessionDirectories, liveSessions]);
+  }, [globalActiveSessions, isVSCode, knownSessionDirectories, liveFallbackSessions]);
 
   const persistenceSessions = React.useMemo(
     () => [...globalActiveSessions, ...archivedSessions],
     [archivedSessions, globalActiveSessions],
   );
 
-  const syncSessionStructureSignature = React.useMemo(
-    () => liveSessions
-      .map((session) => {
-        const directory = normalizePath((session as Session & { directory?: string | null }).directory ?? null) ?? '';
-        return `${session.id}:${session.title ?? ''}:${session.time?.archived ? 1 : 0}:${directory}`;
-      })
-      .join('|'),
-    [liveSessions],
-  );
-
   const syncSessionsSnapshotRef = React.useRef<Session[]>(liveSessions);
   React.useEffect(() => {
     syncSessionsSnapshotRef.current = liveSessions;
-  }, [syncSessionStructureSignature, liveSessions]);
-
-  // Batched live-session index. Building this here turns the per-row
-  // `useSession(session.id)` reads in SessionNodeItem (each of which
-  // iterates all child-stores via `findLiveSession`) into a single
-  // Map lookup. With M visible rows, that changes an O(M × child-stores)
-  // work to O(child-stores) once per Sidebar render.
-  const liveSessionById = React.useMemo(
-    () => new Map(liveSessions.map((session) => [session.id, session] as const)),
-    [liveSessions],
-  );
+  }, [liveSessions]);
 
+  const runtimeKey = getRuntimeKey();
   const projectWorktreeDiscoveryKey = React.useMemo(
-    () => projects
+    () => `${runtimeKey}|${projects
       .map((project) => `${project.id}:${normalizePath(project.path) ?? ''}`)
-      .join('|'),
-    [projects],
+      .join('|')}`,
+    [projects, runtimeKey],
   );
   const [resolvedWorktreeTopologyKey, setResolvedWorktreeTopologyKey] = React.useState<string | null>(
     isVSCode ? projectWorktreeDiscoveryKey : null,
@@ -434,6 +496,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     let cancelled = false;
 
     const discoverWorktrees = async () => {
+      const discoveryRuntimeKey = runtimeKey;
       const projectEntries = useProjectsStore.getState().projects;
       if (projectEntries.length === 0 || isVSCode) {
         if (!cancelled) {
@@ -488,7 +551,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       });
       await Promise.all(workers);
 
-      if (cancelled) return;
+      if (cancelled || getRuntimeKey() !== discoveryRuntimeKey) return;
 
       const activeProjectPaths = new Set(projectEntries.map((project) => normalizePath(project.path)).filter(Boolean));
       for (const projectPath of worktreesByProject.keys()) {
@@ -514,7 +577,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     return () => {
       cancelled = true;
     };
-  }, [isVSCode, projectWorktreeDiscoveryKey]);
+  }, [isVSCode, projectWorktreeDiscoveryKey, runtimeKey]);
 
   React.useEffect(() => {
     let refreshTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -556,22 +619,14 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
 
   const { scheduleCollapsedProjectsPersist } = useSidebarPersistence({
     isVSCode,
-    hasAuthoritativeGlobalSessions,
     safeStorage,
     keys: {
       sessionExpanded: SESSION_EXPANDED_STORAGE_KEY,
-      sessionExpandedLegacy: LEGACY_SESSION_EXPANDED_STORAGE_KEY,
       projectCollapse: PROJECT_COLLAPSE_STORAGE_KEY,
-      sessionPinned: SESSION_PINNED_STORAGE_KEY,
       groupOrder: GROUP_ORDER_STORAGE_KEY,
-      projectActiveSession: PROJECT_ACTIVE_SESSION_STORAGE_KEY,
       groupCollapse: GROUP_COLLAPSE_STORAGE_KEY,
     },
-    sessions: persistenceSessions,
-    pinnedSessionIds,
-    setPinnedSessionIds,
     groupOrderByProject,
-    activeSessionByProject,
     collapsedGroups,
     setExpandedParents,
     setCollapsedProjects,
@@ -619,12 +674,12 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     return map;
   }, [sortedSessions, pinnedSessionIds]);
 
-  const emptyState = (
+  const emptyState = React.useMemo(() => (
     <div className="py-6 text-center text-muted-foreground">
       <p className="typography-ui-label font-semibold">{t('sessions.sidebar.empty.noSessions.title')}</p>
       <p className="typography-meta mt-1">{t('sessions.sidebar.empty.noSessions.description')}</p>
     </div>
-  );
+  ), [t]);
 
   const editingProject = React.useMemo(
     () => projects.find((project) => project.id === editingProjectDialogId) ?? null,
@@ -703,9 +758,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     handleDeleteSession,
     confirmDeleteSession,
   } = useSessionActions({
-    activeProjectId,
-    currentDirectory,
-    currentSessionId,
     mobileVariant,
     allowReselect,
     onSessionSelected,
@@ -713,8 +765,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     sessionSearchQuery,
     setSessionSearchQuery,
     setIsSessionSearchOpen,
-    setActiveProjectIdOnly,
-    setDirectory,
     setActiveMainTab,
     setSessionSwitcherOpen,
     setCurrentSession,
@@ -746,40 +796,9 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     sessionEvents.requestDirectoryDialog();
   }, []);
 
-  // Auto-expand parent session when navigating to a subagent (child) session.
-  // We don't know which render context the user will look at the parent in
-  // (Recent, project root, archived bucket, ...), so fan out across all
-  // four combinations to ensure it's expanded wherever it appears.
-  React.useEffect(() => {
-    if (!currentSessionId) return;
-    const current = sessions.find((s) => s.id === currentSessionId);
-    const parentID = (current as Session & { parentID?: string | null })?.parentID;
-    if (!parentID) return;
-    const keysToAdd = [
-      `project:active:${parentID}`,
-      `project:archived:${parentID}`,
-      `recent:active:${parentID}`,
-      `recent:archived:${parentID}`,
-    ];
-    setExpandedParents((prev) => {
-      if (keysToAdd.every((k) => prev.has(k))) return prev;
-      const next = new Set(prev);
-      keysToAdd.forEach((k) => next.add(k));
-      try {
-        safeStorage.setItem(SESSION_EXPANDED_STORAGE_KEY, JSON.stringify(Array.from(next)));
-      } catch { /* ignored */ }
-      return next;
-    });
-  }, [currentSessionId, sessions, safeStorage]);
-
   const toggleParent = React.useCallback((expansionKey: string) => {
-    setExpandedParents((prev) => {
-      const next = new Set(prev);
-      if (next.has(expansionKey)) {
-        next.delete(expansionKey);
-      } else {
-        next.add(expansionKey);
-      }
+    setExpandedParents((previous) => {
+      const next = toggleExpandedParentKey(previous, expansionKey);
       try {
         safeStorage.setItem(SESSION_EXPANDED_STORAGE_KEY, JSON.stringify(Array.from(next)));
       } catch { /* ignored */ }
@@ -964,12 +983,13 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const { github } = useRuntimeAPIs();
   const githubAuthStatus = useGitHubAuthStore((state) => state.status);
   const githubAuthChecked = useGitHubAuthStore((state) => state.hasChecked);
-  const gitRepoStatus = useGitRepoStatusMap(normalizedProjectPaths);
+  const gitRepoStatus = useGitRepoStatusMap(isVisible ? normalizedProjectPaths : EMPTY_STRING_ARRAY);
   const ensurePrStatusEntry = useGitHubPrStatusStore((state) => state.ensureEntry);
   const setPrStatusParams = useGitHubPrStatusStore((state) => state.setParams);
   const refreshPrStatusTargets = useGitHubPrStatusStore((state) => state.refreshTargets);
 
   useProjectRepoStatus({
+    enabled: isVisible,
     normalizedProjects,
     gitRepoStatus,
     setProjectRepoStatus,
@@ -981,15 +1001,10 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     () => createSessionOwnershipIndex(sessions, normalizedProjects, availableWorktreesByProject, isVSCode, archivedSessions),
     [archivedSessions, availableWorktreesByProject, isVSCode, normalizedProjects, sessions],
   );
-  useSessionFolderCleanup({
-    isSessionsLoading,
+  useAuthoritativeSessionCleanup({
+    enabled: isVisible,
     hasAuthoritativeGlobalSessions,
-    isWorktreeTopologyLoading,
-    normalizedProjects,
-    ownership: sessionOwnership,
-    availableWorktreesByProject,
-    unresolvedWorktreeProjectPaths,
-    cleanupSessions,
+    sessions: persistenceSessions,
   });
 
   const { getSessionsForProject, getArchivedSessionsForProject } = useProjectSessionLists({
@@ -997,6 +1012,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   });
 
   useArchivedAutoFolders({
+    enabled: isVisible,
     normalizedProjects,
     ownership: sessionOwnership,
     isSessionsLoading,
@@ -1006,7 +1022,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     foldersMap,
     createFolder,
     addSessionToFolder,
-    cleanupSessions,
   });
 
   // Keep last-known repo status to avoid UI jiggling during project switch
@@ -1019,6 +1034,89 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const showArchivedSessions = useSessionDisplayStore((state) => state.showArchivedSessions);
   const projectSortOrder = useSessionDisplayStore((state) => state.projectSortOrder);
   const manualProjectOrder = useProjectsStore((state) => state.manualProjectOrder);
+  const projectExpandedParentsRef = React.useRef<Set<string>>(new Set());
+  const recentExpandedParentsRef = React.useRef<Set<string>>(new Set());
+  const projectExpandedParents = selectExpandedParentKeysForContext(
+    projectExpandedParentsRef.current,
+    expandedParents,
+    'project',
+  );
+  const recentExpandedParents = selectExpandedParentKeysForContext(
+    recentExpandedParentsRef.current,
+    expandedParents,
+    'recent',
+  );
+  projectExpandedParentsRef.current = projectExpandedParents;
+  recentExpandedParentsRef.current = recentExpandedParents;
+
+  const sidebarRenderSources = {
+    isVisible,
+    mobileVariant,
+    onSessionSelected,
+    allowReselect,
+    hideDirectoryControls,
+    showOnlyMainWorkspace,
+    t,
+    isTablet,
+    liveSessions,
+    activeSessionStructure,
+    archivedSessionStructure,
+    globalActiveSessions,
+    archivedSessions,
+    projects,
+    activeProjectId,
+    manualProjectOrder,
+    currentDirectory,
+    worktreeMetadata,
+    availableWorktreesByProject,
+    pinnedSessionIds,
+    foldersMap,
+    collapsedFolderIds,
+    gitBranches,
+    gitRepoStatus,
+    githubAuthStatus,
+    githubAuthChecked,
+    updateStore,
+    showRecentSection,
+    showArchivedSessions,
+    projectSortOrder,
+    projectRepoStatus,
+    projectRootBranches,
+    resolvedWorktreeTopologyKey,
+    unresolvedWorktreeProjectPaths,
+    isSessionSearchOpen,
+    sessionSearchQuery,
+    editingId,
+    editTitle,
+    editingProjectDialogId,
+    expandedParents,
+    collapsedProjects,
+    visibleSessionCountByGroup,
+    updateDialogOpen,
+    openSidebarMenuKey,
+    renamingFolderId,
+    renameFolderDraft,
+    deleteSessionConfirm,
+    deleteFolderConfirm,
+    bulkDeleteConfirm,
+    collapsedGroups,
+    groupOrderByProject,
+  };
+  const previousSidebarRenderSourcesRef = React.useRef<typeof sidebarRenderSources | null>(null);
+  const previousSidebarRenderSources = previousSidebarRenderSourcesRef.current;
+  if (previousSidebarRenderSources) {
+    let attributed = false;
+    for (const source of Object.keys(sidebarRenderSources) as Array<keyof typeof sidebarRenderSources>) {
+      if (!Object.is(previousSidebarRenderSources[source], sidebarRenderSources[source])) {
+        streamPerfCount(`ui.session_sidebar.source.${source}`);
+        attributed = true;
+      }
+    }
+    if (!attributed) {
+      streamPerfCount('ui.session_sidebar.source.parent_or_context');
+    }
+  }
+  previousSidebarRenderSourcesRef.current = sidebarRenderSources;
 
   const sortedProjects = React.useMemo(() => {
     const list = [...normalizedProjects];
@@ -1079,26 +1177,12 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     foldersMap,
   });
 
-  const searchEmptyState = (
+  const searchEmptyState = React.useMemo(() => (
     <div className="py-6 text-center text-muted-foreground">
       <p className="typography-ui-label font-semibold">{t('sessions.sidebar.empty.noMatches.title')}</p>
       <p className="typography-meta mt-1">{t('sessions.sidebar.empty.noMatches.description')}</p>
     </div>
-  );
-
-  useProjectSessionSelection({
-    projectSections,
-    activeProjectId,
-    activeSessionByProject,
-    setActiveSessionByProject,
-    currentSessionId,
-    handleSessionSelect,
-    newSessionDraftOpen,
-    mobileVariant,
-    openNewSessionDraft,
-    setActiveMainTab,
-    setSessionSwitcherOpen,
-  });
+  ), [t]);
 
   const { getOrderedGroups } = useGroupOrdering(groupOrderByProject);
   const hasInitializedArchivedCollapseRef = React.useRef(false);
@@ -1231,19 +1315,6 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   );
 
 
-  const recentSessionIds = React.useMemo(() => {
-    return new Set(activeNowSessions.map((session) => session.id));
-  }, [activeNowSessions]);
-
-  const recentSessionIdsList = React.useMemo(() => [...recentSessionIds], [recentSessionIds]);
-
-  useSessionPrefetch({
-    currentSessionId,
-    sortedSessions,
-    recentSessionIds: recentSessionIdsList,
-    ensureSessionRenderable: sync.ensureSessionRenderable,
-  });
-
   const sectionsForSidebarRender = React.useMemo(() => {
     return showArchivedSessions
       ? sectionsForRender
@@ -1254,6 +1325,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   }, [sectionsForRender, showArchivedSessions]);
 
   const prLookupKeys = React.useMemo(() => {
+    if (!isVisible) return EMPTY_STRING_ARRAY;
     const keys = new Set<string>();
     sectionsForSidebarRender.forEach((section) => {
       section.groups.forEach((group) => {
@@ -1266,16 +1338,16 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       });
     });
     return [...keys];
-  }, [gitBranches, sectionsForSidebarRender]);
+  }, [gitBranches, isVisible, sectionsForSidebarRender]);
 
   const prVisualSummaryMap = usePrVisualSummaryByKeys(prLookupKeys);
 
   React.useEffect(() => {
-    if (!githubAuthChecked || !githubAuthStatus?.connected || !github) {
+    if (!isVisible || !githubAuthChecked || !githubAuthStatus?.connected || !github) {
       return;
     }
 
-    const missingTargets: Array<{ directory: string; branch: string; remoteName?: string | null }> = [];
+    const targetsByKey = new Map<string, { directory: string; branch: string }>();
     const now = Date.now();
 
     sectionsForSidebarRender.forEach((section) => {
@@ -1307,29 +1379,23 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
           if (shouldRetryNoPr) {
             retriedNoPrStatusKeysRef.current.add(retryKey);
           }
-          missingTargets.push({ directory, branch });
+          if (!targetsByKey.has(key)) {
+            targetsByKey.set(key, { directory, branch });
+          }
         }
       });
     });
 
-    if (missingTargets.length === 0) {
+    if (targetsByKey.size === 0) {
       return;
     }
 
-    const uniqueTargets = new Map<string, { directory: string; branch: string; remoteName?: string | null }>();
-    missingTargets.forEach((target) => {
-      const key = getGitHubPrStatusKey(target.directory, target.branch, target.remoteName ?? null);
-      if (!uniqueTargets.has(key)) {
-        uniqueTargets.set(key, target);
-      }
-    });
-
-    uniqueTargets.forEach((target, key) => {
+    targetsByKey.forEach((target, key) => {
       ensurePrStatusEntry(key);
       setPrStatusParams(key, {
         directory: target.directory,
         branch: target.branch,
-        remoteName: target.remoteName ?? null,
+        remoteName: null,
         canShow: true,
         github,
         githubAuthChecked,
@@ -1337,7 +1403,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       });
     });
 
-    void refreshPrStatusTargets([...uniqueTargets.values()], {
+    void refreshPrStatusTargets([...targetsByKey.values()], {
       silent: true,
       markInitialResolved: true,
     });
@@ -1347,6 +1413,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     github,
     githubAuthChecked,
     githubAuthStatus?.connected,
+    isVisible,
     gitBranches,
     refreshPrStatusTargets,
     sectionsForSidebarRender,
@@ -1360,6 +1427,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
   const headerActionButtonClass = mobileVariant ? mobileHeaderActionButtonClass : desktopHeaderActionButtonClass;
   const headerActionIconClass = 'h-4.5 w-4.5';
   const stuckProjectHeaders = useStickyProjectHeaders({
+    enabled: isVisible,
     isDesktopShellRuntime,
     projectSections,
     projectHeaderSentinelRefs,
@@ -1382,9 +1450,8 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         groupDirectory={groupDirectory}
         projectId={projectId}
         archivedBucket={archivedBucket}
-        currentSessionId={currentSessionId}
         pinnedSessionIds={pinnedSessionIds}
-        expandedParents={expandedParents}
+        expandedParents={renderContext === 'recent' ? recentExpandedParents : projectExpandedParents}
         hasSessionSearchQuery={hasSessionSearchQuery}
         normalizedSessionSearchQuery={normalizedSessionSearchQuery}
         notifyOnSubtasks={notifyOnSubtasks}
@@ -1417,12 +1484,10 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         renderSessionNode={renderSessionNode}
         secondaryMeta={secondaryMeta}
         renderContext={renderContext}
-        subtreeContainsActive={renderExtras?.subtreeContainsActive ?? EMPTY_SUBTREE_SET}
         subtreeContainsEditing={renderExtras?.subtreeContainsEditing ?? EMPTY_SUBTREE_SET}
         menuOpenSessionId={renderExtras?.menuOpenSessionId ?? null}
         nodeStructureKey={renderExtras?.nodeStructureKey ?? ''}
         childRenderExtrasFor={renderExtras?.childRenderExtrasFor}
-        liveSessionById={liveSessionById}
       />
     ),
   );
@@ -1505,13 +1570,11 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         setRenameFolderDraft={setRenameFolderDraft}
         setRenamingFolderId={setRenamingFolderId}
         pinnedSessionIds={pinnedSessionIds}
-        expandedParents={expandedParents}
+        expandedParents={projectExpandedParents}
         sessionOrderIndex={sessionOrderIndex}
-        currentSessionId={currentSessionId}
         editingId={editingId}
         editTitle={editTitle}
         openSidebarMenuKey={openSidebarMenuKey}
-        liveSessionById={liveSessionById}
         prVisualStateByDirectoryBranch={prVisualStateByDirectoryBranch}
         onToggleCollapsedGroup={toggleCollapsedGroup}
         dragHandleProps={dragHandleProps}
@@ -1546,28 +1609,29 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
       renamingFolderId,
       renameFolderDraft,
       pinnedSessionIds,
-      expandedParents,
+      projectExpandedParents,
       sessionOrderIndex,
-      currentSessionId,
       editingId,
       editTitle,
       openSidebarMenuKey,
-      liveSessionById,
       prVisualStateByDirectoryBranch,
       toggleCollapsedGroup,
     ],
   );
 
-  const topContent = (!isVSCode && showRecentSection && !hasSessionSearchQuery) ? (
-    <SidebarActivitySections
-      sections={activitySections}
-      renderSessionNode={renderSessionNode}
-      currentSessionId={currentSessionId}
-      editingId={editingId}
-      openSidebarMenuKey={openSidebarMenuKey}
-      variant="section"
-    />
-  ) : null;
+  const topContent = React.useMemo(
+    () => (!isVSCode && showRecentSection && !hasSessionSearchQuery) ? (
+      <SidebarActivitySections
+        sections={activitySections}
+        renderSessionNode={renderSessionNode}
+        editingId={editingId}
+        openSidebarMenuKey={openSidebarMenuKey}
+        expansionState={recentExpandedParents}
+        variant="section"
+      />
+    ) : null,
+    [activitySections, editingId, hasSessionSearchQuery, isVSCode, openSidebarMenuKey, recentExpandedParents, renderSessionNode, showRecentSection],
+  );
   const isInlineEditing = Boolean(renamingFolderId || editingId || editingProjectDialogId);
 
   const {
@@ -1620,6 +1684,32 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         mobileVariant ? '' : 'bg-transparent',
       )}
     >
+      <SidebarBootstrapDemandEffect
+        owner={bootstrapDemandOwner}
+        childStores={childStores}
+        projectSections={projectSections}
+        activeProjectId={activeProjectId}
+        collapsedProjects={collapsedProjects}
+        collapsedGroups={collapsedGroups}
+        currentDirectory={currentDirectory}
+      />
+      <ProjectSessionSelectionEffect
+        projectSections={projectSections}
+        activeProjectId={activeProjectId}
+        initialActiveSessionByProject={initialActiveSessionByProject}
+        persistActiveSessionByProject={persistActiveSessionByProject}
+        handleSessionSelect={stableHandleSessionSelect}
+        mobileVariant={mobileVariant}
+        openNewSessionDraft={openNewSessionDraft}
+        setActiveMainTab={setActiveMainTab}
+        setSessionSwitcherOpen={setSessionSwitcherOpen}
+      />
+      <SessionPrefetchEffect
+        enabled={isVisible}
+        sortedSessions={sortedSessions}
+        recentSessions={activeNowSessions}
+        prefetchSession={sync.prefetchSession}
+      />
       <SidebarHeader
         hideDirectoryControls={hideDirectoryControls}
         showRecentControls={!isVSCode}
@@ -1643,7 +1733,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         onToggleSelectionMode={handleToggleSelectionMode}
       />
 
-      <SidebarProjectsList
+      {isVisible ? <SidebarProjectsList
         topContent={topContent}
         hasSharedSessions={hasActivitySectionItems}
         sectionsForRender={sectionsForSidebarRender}
@@ -1678,7 +1768,7 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
         openSidebarMenuKey={openSidebarMenuKey}
         setOpenSidebarMenuKey={setOpenSidebarMenuKey}
         isInlineEditing={isInlineEditing}
-      />
+      /> : null}
 
       {selectionModeEnabled && hasSelection ? (
         <BulkActionBar
@@ -1770,3 +1860,5 @@ export const SessionSidebar: React.FC<SessionSidebarProps> = ({
     </div>
   );
 };
+
+export const SessionSidebar = React.memo(SessionSidebarComponent);
diff --git a/packages/ui/src/components/session/sidebar/DOCUMENTATION.md b/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
index 1a833d72..5f6fad53 100644
--- a/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
+++ b/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
@@ -10,9 +10,10 @@
 - Archived groups are collapsed by default and support bulk deletion at group/folder level.
 - Session rows support compact inline dates in minimal mode and simplified metadata in default mode.
 - Root session menus can quickly create a worktree from the session directory's current branch and move the full session subtree there while idle.
+- Directory loading is demand-driven: the sidebar publishes one complete priority plan for all known project/worktree directories, while the sync layer owns bounded execution.
 - New extractions in latest pass reduced local effect/callback bulk further:
   - project session list builders
-  - folder cleanup sync
+  - authoritative deletion cleanup
   - sticky project header observer
 
 ## VS Code grouping
@@ -29,8 +30,8 @@
 - `SidebarActivitySections.tsx`: Global top section renderer; currently used for the `recent` section only.
 - `SidebarFooter.tsx`: Static footer with icon-only settings, shortcuts, and about actions.
 - `SidebarProjectsList.tsx`: Main scrollable tree renderer for projects, root sessions, worktrees/groups, and empty/search states.
-- `SessionGroupSection.tsx`: Renders a single worktree/archived group, collapse/expand, folder subtree, and group-level controls.
-- `SessionNodeItem.tsx`: Renders one session row/tree node with inline metadata, menu actions, minimal/default variants, and nested children.
+- `SessionGroupSection.tsx`: Renders a single worktree/archived group, collapse/expand, folder subtree, group-level controls, and explicit loading/error/retry state for empty groups.
+- `SessionNodeItem.tsx`: Renders one session row/tree node with inline metadata, menu actions, minimal/default variants, and nested children. Rows do not initiate directory bootstrap on mount.
 - `ConfirmDialogs.tsx`: Shared confirm dialog wrappers for session delete and folder delete flows.
 - `sortableItems.tsx`: DnD sortable wrappers for project and group ordering plus project-row action affordances.
 - `sessionFolderDnd.tsx`: Folder/session DnD scope and wrappers for dropping/moving sessions into folders.
@@ -40,7 +41,7 @@
 
 - `hooks/useSessionActions.ts`: Centralizes session row actions (select/open, rename, share/unshare, archive/delete, confirmations).
 - `hooks/useSessionSearchEffects.ts`: Handles search open/close UX and input focus behavior.
-- `hooks/useSessionPrefetch.ts`: Prefetches messages for nearby/active sessions to improve perceived load speed.
+- `hooks/useSessionPrefetch.ts`: Publishes directory-aware nearby/active session prefetch demand to the shared message loader. Recent may prefetch across projects without substituting the current directory.
 - `hooks/useSessionGrouping.ts`: Builds grouped session structures and search text/filter helpers.
 - `hooks/useSessionSidebarSections.ts`: Composes final per-project sections and group search metadata for rendering.
 - `hooks/useProjectSessionSelection.ts`: Resolves active/current project-session selection logic and session-directory context.
@@ -49,11 +50,29 @@
 - `hooks/useSidebarPersistence.ts`: Persists sidebar UI state (expanded/collapsed/pinned/group order/active session) to storage + desktop settings.
 - `hooks/useProjectRepoStatus.ts`: Tracks per-project git-repo state and root branch metadata.
 - `hooks/useProjectSessionLists.ts`: Reads live and archived project buckets from the shared ownership index.
-- `hooks/useSessionFolderCleanup.ts`: Cleans stale folder session IDs by reconciling known sessions/archived scopes.
+- `hooks/useAuthoritativeSessionCleanup.ts`: Establishes the first complete active+archived list as a non-destructive baseline, then cleans persisted state only for sessions omitted by a later authoritative snapshot.
 - `hooks/useStickyProjectHeaders.ts`: Tracks which project headers are sticky/stuck via `IntersectionObserver`.
 
 ### Types and utilities
 
 - `types.ts`: Shared sidebar types (`SessionNode`, `SessionGroup`, summary/search metadata).
 - `activitySections.ts`: Persisted top-section storage/helpers for the current `recent` session list.
+- `sessionBootstrapDemands.ts`: Builds the deduplicated directory demand plan. Selected directories rank above active projects, expanded groups, visible collapsed groups, and background/collapsed projects.
 - `utils.tsx`: Shared sidebar utilities (path normalization, sorting, dedupe, archived scope keys, project relation checks, text highlight, labels, compact/default date formatting).
+
+## Loading rules
+
+- Always publish every known project root and worktree directory. Collapse/visibility changes priority only; they do not opt a directory out of authoritative refresh.
+- Current directory and selected-session directory are `selected` demand and therefore run first.
+- Expanded projects/worktrees outrank merely visible and background groups.
+- The sync scheduler deduplicates, promotes, retries, and limits work. Sidebar components must not reproduce that lifecycle with mount effects.
+- Hide speculative work when the sidebar/chat surface is hidden: message prefetch, Git/PR enrichment and subscriptions, search listeners, sticky-header observation, and archived-folder derivation stop. The session row tree unmounts so row-owned status, permission, unseen, and viewport subscriptions do no background work. The outer sidebar remains mounted, preserving UI state and authoritative directory refresh for an immediate reopen; deferred derived work reruns from current state when visibility returns.
+- The sidebar does not subscribe its whole tree to the cross-directory live-session aggregate. Global create/structural/lifecycle snapshots drive rendered session metadata; the cached sync index only fills sessions not yet present globally and provides refresh fallback data. Row activity continues to come from the session-keyed live status index.
+- Session selection does not invalidate the sidebar orchestration component. Each mounted row selects only whether its own session ID is active, while parent expansion, project selection memory, and neighbor prefetch run in small effect-only subscribers.
+- Parent expansion is exclusively manual. Selecting or navigating to a subsession never expands its parent automatically. Project/worktree and `recent` trees use independent persisted context keys and receive separate stable projections, so expansion changes in one context neither invalidate nor change the other. The persisted storage key remains `v3`; older state mixed contexts and is not migrated into this contract.
+- Folder membership may contain both a parent session and its descendants. Rendering treats only the highest assigned ancestors as folder roots because their normal session trees already include assigned descendants; persisted membership remains unchanged for cleanup and move semantics.
+- Sidebar selection holds the clicked row's viewport position across navigation-driven sidebar updates. Wheel or touch input cancels the hold immediately, so programmatic compensation never fights intentional scrolling.
+- Global session subscriptions are structural: create/delete, title, share, archive, directory, parent, and slug changes invalidate the tree. Recency-only `time.updated` changes are read from the authoritative snapshot on the next sidebar render rather than triggering a full tree rebuild themselves.
+- Structural updates rebuild grouped nodes only for projects whose local sessions, worktrees, repository state, or branch changed; unchanged project sections preserve references so memoized group/session descendants skip the update wave.
+- Empty successful lists, unresolved loads, and failed loads are separate UI states. Failed groups expose Retry and retain prior data.
+- Pins and folder assignments are not pruned from the first startup snapshot or from optimistic mutations. Confirmed local deletion and routed external deletion clean immediately; a later authoritative omission after an established baseline covers missed external delete events.
diff --git a/packages/ui/src/components/session/sidebar/SessionGroupSection.tsx b/packages/ui/src/components/session/sidebar/SessionGroupSection.tsx
index 1838b51a..1b4dac07 100644
--- a/packages/ui/src/components/session/sidebar/SessionGroupSection.tsx
+++ b/packages/ui/src/components/session/sidebar/SessionGroupSection.tsx
@@ -5,11 +5,6 @@ import type { Session } from '@opencode-ai/sdk/v2';
 // Archived buckets routinely grow into the hundreds/thousands; virtualize
 // when we cross this row count so the DOM stays bounded.
 const ARCHIVED_VIRTUALIZE_THRESHOLD = 50;
-// Active/worktree groups can also grow large (a single worktree with 80+
-// sessions), and unlike the archive they're interactive from the start.
-// Virtualize eagerly for non-archived groups to keep the rendered row
-// count bounded. With overscan ~8 the visible behavior is identical.
-const ACTIVE_VIRTUALIZE_THRESHOLD = 30;
 // Compact rows in the archived bucket without nested subagents render
 // around 24-32px; virtua measures mounted rows and uses this as the initial hint.
 const ARCHIVED_ROW_ESTIMATE_PX = 28;
@@ -26,8 +21,10 @@ import { compareSessionsByPinnedAndTime, isBranchDifferentFromLabel, normalizePa
 import {
   collectSubtreeContainingId,
   computeNodeStructureKey,
+  nodeHasPinnedMembershipChange,
   nodeContainsSessionId,
   resolveMenuOpenSessionId,
+  selectFolderRootNodes,
 } from './sessionNodeItemUtils';
 import type { SessionNodeRenderExtras } from './sessionNodeItemUtils';
 import type { SessionFolder } from '@/stores/useSessionFoldersStore';
@@ -36,6 +33,7 @@ import { useSessionDisplayStore } from '@/stores/useSessionDisplayStore';
 import { openExternalUrl } from '@/lib/url';
 import { isVSCodeRuntime } from '@/lib/desktop';
 import { useI18n } from '@/lib/i18n';
+import { useChildStoreManager } from '@/sync/sync-context';
 
 type DeleteFolderConfirm = {
   scopeKey: string;
@@ -92,11 +90,9 @@ type Props = {
   pinnedSessionIds: Set<string>;
   expandedParents: Set<string>;
   sessionOrderIndex: Map<string, number>;
-  currentSessionId: string | null;
   editingId: string | null;
   editTitle: string;
   openSidebarMenuKey: string | null;
-  liveSessionById: Map<string, Session>;
   prVisualStateByDirectoryBranch: Map<string, {
     visualState: 'draft' | 'open' | 'blocked' | 'merged' | 'closed';
     number: number;
@@ -142,12 +138,14 @@ const groupHasPinnedMembershipChange = (
   prevPinnedSessionIds: Set<string>,
   nextPinnedSessionIds: Set<string>,
 ): boolean => {
-  const visit = (node: SessionNode): boolean => {
-    const sessionId = node.session.id;
-    if (prevPinnedSessionIds.has(sessionId) !== nextPinnedSessionIds.has(sessionId)) return true;
-    return node.children.some(visit);
-  };
-  return group.sessions.some(visit);
+  return group.sessions.some((node) => nodeHasPinnedMembershipChange(
+    node,
+    node,
+    prevPinnedSessionIds,
+    nextPinnedSessionIds,
+    group.directory,
+    group.directory,
+  ));
 };
 
 const groupHasSessionOrderChange = (
@@ -177,21 +175,6 @@ const groupHasExpansionMembershipChange = (
   return group.sessions.some(visit);
 };
 
-const groupHasResolvedSessionChange = (
-  group: SessionGroup,
-  prevLiveSessionById: Map<string, Session>,
-  nextLiveSessionById: Map<string, Session>,
-): boolean => {
-  const visit = (node: SessionNode): boolean => {
-    const sessionId = node.session.id;
-    if ((prevLiveSessionById.get(sessionId) ?? node.session) !== (nextLiveSessionById.get(sessionId) ?? node.session)) {
-      return true;
-    }
-    return node.children.some(visit);
-  };
-  return group.sessions.some(visit);
-};
-
 const getProjectRepoStatusValue = (props: Props): boolean | null | undefined => {
   if (!props.projectId) return undefined;
   return props.projectRepoStatus.has(props.projectId)
@@ -236,11 +219,6 @@ const areGroupPropsEqual = (prev: Props, next: Props): boolean => {
     return false;
   }
 
-  if (prev.currentSessionId !== next.currentSessionId
-    && (groupContainsSessionId(prev.group, prev.currentSessionId) || groupContainsSessionId(next.group, next.currentSessionId))) {
-    return false;
-  }
-
   if (prev.editingId !== next.editingId
     && (groupContainsSessionId(prev.group, prev.editingId) || groupContainsSessionId(next.group, next.editingId))) {
     return false;
@@ -257,11 +235,6 @@ const areGroupPropsEqual = (prev: Props, next: Props): boolean => {
     if (prevMenuSessionId || nextMenuSessionId) return false;
   }
 
-  if (prev.liveSessionById !== next.liveSessionById
-    && groupHasResolvedSessionChange(next.group, prev.liveSessionById, next.liveSessionById)) {
-    return false;
-  }
-
   // Per-row / per-state props. The PR-visual-state map flips frequently
   // during bootstrap but a single group's value is usually stable, so we
   // compare only the value this group actually consumes instead of the
@@ -352,7 +325,6 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
     pinnedSessionIds,
     expandedParents,
     sessionOrderIndex,
-    currentSessionId,
     editingId,
     openSidebarMenuKey,
     prVisualStateByDirectoryBranch,
@@ -379,6 +351,19 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
   // VS Code always uses the expanded layout (see SessionNodeItem).
   const isMinimalMode = displayMode === 'minimal' && !isVSCodeRuntime();
   const isCollapsed = hasSessionSearchQuery ? false : collapsedGroups.has(groupKey);
+  const childStores = useChildStoreManager();
+  const bootstrapDirectory = normalizePath(group.directory ?? null);
+  const bootstrapState = React.useSyncExternalStore(
+    React.useCallback(
+      (notify) => bootstrapDirectory ? childStores.subscribeBootstrap(notify) : () => undefined,
+      [bootstrapDirectory, childStores],
+    ),
+    React.useCallback(
+      () => bootstrapDirectory ? childStores.getBootstrapState(bootstrapDirectory) : undefined,
+      [bootstrapDirectory, childStores],
+    ),
+    React.useCallback(() => undefined, []),
+  );
   const maxVisible = hideDirectoryControls ? 10 : 5;
   const nonArchivedVisibleCount = Math.max(maxVisible, visibleSessionCount ?? maxVisible);
   const groupMatchesSearch = hasSessionSearchQuery ? searchData?.groupMatches === true : false;
@@ -409,10 +394,7 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
   }, [sourceGroupNodes]);
 
   const allFoldersForGroupBase = React.useMemo(() => scopeFolders.map((folder) => {
-    const nodes = folder.sessionIds
-      .map((sid) => nodeBySessionId.get(sid))
-      .filter((n): n is SessionNode => Boolean(n))
-      .sort(compareSessionNodes);
+    const nodes = selectFolderRootNodes(folder.sessionIds, nodeBySessionId).sort(compareSessionNodes);
     return { folder, nodes };
   }), [scopeFolders, nodeBySessionId, compareSessionNodes]);
 
@@ -472,21 +454,12 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
   const ungroupedSessions = React.useMemo(() => sourceGroupNodes.filter((node) => !sessionIdsInFolders.has(node.session.id)), [sourceGroupNodes, sessionIdsInFolders]);
   const rootFolders = React.useMemo(() => allFoldersForGroup.filter(({ folder }) => !folder.parentId), [allFoldersForGroup]);
 
-  // Precompute per-row "subtree contains active session" and "subtree contains
-  // editing session" lookups once per render. The previous design walked the
+  // Precompute the per-row "subtree contains editing session" lookup once per
+  // render. The previous design walked the
   // node tree inside SessionNodeItem.areEqual for every row, which is O(M^2)
   // across the whole sidebar. These sets let areEqual answer with a single
   // Set.has lookup, so the cost is O(M) once per SessionGroupSection render.
   const renderContextForGroup = 'project' as const;
-  const subtreeContainsActive = React.useMemo(() => {
-    const set = new Set<string>();
-    collectSubtreeContainingId(sourceGroupNodes, currentSessionId, set);
-    allFoldersForGroup.forEach(({ nodes }) => {
-      collectSubtreeContainingId(nodes, currentSessionId, set);
-    });
-    return set;
-  }, [sourceGroupNodes, allFoldersForGroup, currentSessionId]);
-
   const subtreeContainsEditing = React.useMemo(() => {
     const set = new Set<string>();
     collectSubtreeContainingId(sourceGroupNodes, editingId, set);
@@ -539,11 +512,10 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
   }, [nodeStructureKeyBySourceNode, nodeStructureKeyByFolderNode]);
 
   const childRenderExtrasFor = React.useCallback((child: SessionNode) => ({
-    subtreeContainsActive,
     subtreeContainsEditing,
     menuOpenSessionId,
     nodeStructureKey: resolveNodeStructureKey(child),
-  }), [subtreeContainsActive, subtreeContainsEditing, menuOpenSessionId, resolveNodeStructureKey]);
+  }), [subtreeContainsEditing, menuOpenSessionId, resolveNodeStructureKey]);
 
   const totalSessions = ungroupedSessions.length;
   const visibleSessions = group.isArchivedBucket
@@ -554,21 +526,14 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
   const remainingCount = totalSessions - visibleSessions.length;
   const canShowLess = !group.isArchivedBucket && !hasSessionSearchQuery && totalSessions > maxVisible && remainingCount === 0;
 
-  // Virtualize large groups. Archived buckets grow into the hundreds or
-  // thousands of rows; active/worktree groups can also hit 80+ sessions
-  // when a single worktree accumulates over time. Both paths share the
-  // same virtua Virtualizer; the threshold just controls when we mount
-  // it. The visible behavior is identical because virtua uses overscan
-  // (8) for the buffer zone. All hooks below MUST stay above the
-  // search-empty early-return so they fire in the same order every
-  // render — rules-of-hooks.
-  const shouldVirtualizeArchived = group.isArchivedBucket === true
+  // Virtualize archived buckets, which can grow into the thousands. Active
+  // groups retain normal flow because their incremental Show more control and
+  // the shared ancestor scroller cannot expose an unmounted virtual tail.
+  // Hooks below MUST stay above the search-empty early-return so they fire in
+  // the same order every render — rules-of-hooks.
+  const shouldVirtualize = group.isArchivedBucket === true
     && !hasSessionSearchQuery
     && visibleSessions.length >= ARCHIVED_VIRTUALIZE_THRESHOLD;
-  const shouldVirtualizeActive = group.isArchivedBucket !== true
-    && !hasSessionSearchQuery
-    && visibleSessions.length >= ACTIVE_VIRTUALIZE_THRESHOLD;
-  const shouldVirtualize = shouldVirtualizeArchived || shouldVirtualizeActive;
 
   // Check if any parent node is expanded - expanded parents render their
   // children inline, making them much taller than the fixed estimate.
@@ -864,7 +829,6 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
             renderSessionNode={renderSessionNode}
             getRenderExtras={resolveNodeStructureKey
               ? (node) => ({
-                subtreeContainsActive,
                 subtreeContainsEditing,
                 menuOpenSessionId,
                 nodeStructureKey: resolveNodeStructureKey(node),
@@ -941,7 +905,6 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
             // meanwhile keeps the container's height real so the scroller
             // never collapses/clamps during the flip.
             visibleSessions.map((node) => renderSessionNode(node, 0, group.directory, projectId, group.isArchivedBucket === true, undefined, 'project', {
-              subtreeContainsActive,
               subtreeContainsEditing,
               menuOpenSessionId,
               nodeStructureKey: resolveNodeStructureKey(node),
@@ -980,7 +943,6 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
                   }}
                 >
                   {renderSessionNode(node, 0, group.directory, projectId, group.isArchivedBucket === true, undefined, 'project', {
-                    subtreeContainsActive,
                     subtreeContainsEditing,
                     menuOpenSessionId,
                     nodeStructureKey: resolveNodeStructureKey(node),
@@ -994,7 +956,6 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
         </div>
       ) : (
         visibleSessions.map((node) => renderSessionNode(node, 0, group.directory, projectId, group.isArchivedBucket === true, undefined, 'project', {
-          subtreeContainsActive,
           subtreeContainsEditing,
           menuOpenSessionId,
           nodeStructureKey: resolveNodeStructureKey(node),
@@ -1005,6 +966,31 @@ function SessionGroupSectionBase(props: Props): React.ReactNode {
         <div className="py-1 text-left typography-micro text-muted-foreground">
           {group.isArchivedBucket
             ? t('sessions.sidebar.group.empty.noArchivedSessions')
+            : bootstrapState === 'queued' || bootstrapState === 'running'
+              ? (
+                <span className="inline-flex items-center gap-1.5">
+                  <Icon name="loader-4" className="size-3 animate-spin" />
+                  {t('sessions.sidebar.group.empty.loadingSessions')}
+                </span>
+              )
+              : bootstrapState === 'failed' && bootstrapDirectory
+                ? (
+                  <span className="inline-flex items-center gap-1.5">
+                    {t('sessions.sidebar.group.empty.loadFailed')}
+                    <button
+                      type="button"
+                      className="text-foreground hover:underline"
+                      onClick={() => childStores.requestBootstrap({
+                        directory: bootstrapDirectory,
+                        priority: isCollapsed ? 'visible' : 'expanded',
+                        reason: group.isMain ? 'project-expanded' : 'worktree-expanded',
+                        force: true,
+                      })}
+                    >
+                      {t('sessions.sidebar.group.empty.retry')}
+                    </button>
+                  </span>
+                )
             : t('sessions.sidebar.group.empty.noSessionsInWorkspace')}
         </div>
       ) : null}
diff --git a/packages/ui/src/components/session/sidebar/SessionNodeItem.tsx b/packages/ui/src/components/session/sidebar/SessionNodeItem.tsx
index 88b33aff..c6a058bb 100644
--- a/packages/ui/src/components/session/sidebar/SessionNodeItem.tsx
+++ b/packages/ui/src/components/session/sidebar/SessionNodeItem.tsx
@@ -18,6 +18,7 @@ import { canUseElectronDesktopIPC, invokeDesktop, isVSCodeRuntime } from '@/lib/
 import { toast } from '@/components/ui';
 import { Button } from '@/components/ui/button';
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog';
+import { isSessionPinned, type SessionPinnedTarget } from '@/stores/useSessionPinnedStore';
 import { Icon } from "@/components/icon/Icon";
 import { buildExportFilename, downloadAsMarkdown, formatSessionAsMarkdown, getExportRevealLabelKey, revealExportedMarkdown, saveAsMarkdownDesktop } from '@/lib/exportSession';
 import type { ChildSessionExport } from '@/lib/exportSession';
@@ -25,7 +26,7 @@ import { buildSessionMessageRecordsSnapshot, useDirectoryStore, useGlobalSession
 import { useSync } from '@/sync/use-sync';
 import { useViewportStore, viewportSessionKey } from '@/sync/viewport-store';
 import { DraggableSessionRow } from './sessionFolderDnd';
-import { nodeContainsSessionId } from './sessionNodeItemUtils';
+import { nodeContainsSessionId, nodeHasPinnedMembershipChange } from './sessionNodeItemUtils';
 import type { SessionNodeChildRenderExtras, SessionNodeRenderExtras } from './sessionNodeItemUtils';
 import type { SessionNode } from './types';
 import { formatSessionCompactDateLabel, formatSessionDateLabel, normalizePath, renderHighlightedText } from './utils';
@@ -43,6 +44,8 @@ import { MultiRunFusionDialog } from '@/components/multirun/MultiRunFusionDialog
 import { FusionIcon } from '@/components/icons/FusionIcon';
 import { RuntimeAPIContext } from '@/contexts/runtimeAPIContext';
 import { startSessionTreeWorktreeMove, useIsSessionWorktreeMovePending } from '@/lib/worktrees/sessionWorktreeMove';
+import { streamPerfCount } from '@/stores/utils/streamDebug';
+import { useSessionUIStore } from '@/sync/session-ui-store';
 
 type Folder = { id: string; name: string; sessionIds: string[] };
 
@@ -57,7 +60,6 @@ type Props = {
   groupDirectory?: string | null;
   projectId?: string | null;
   archivedBucket?: boolean;
-  currentSessionId: string | null;
   pinnedSessionIds: Set<string>;
   expandedParents: Set<string>;
   hasSessionSearchQuery: boolean;
@@ -70,9 +72,9 @@ type Props = {
   handleSaveEdit: (titleOverride?: string) => void;
   handleCancelEdit: () => void;
   toggleParent: (expansionKey: string) => void;
-  handleSessionSelect: (sessionId: string, sessionDirectory: string | null, projectId?: string | null) => void;
+  handleSessionSelect: (sessionId: string, sessionDirectory: string | null) => void;
   handleSessionDoubleClick: (sessionId: string, sessionTitle: string) => void;
-  togglePinnedSession: (sessionId: string) => void;
+  togglePinnedSession: (target: SessionPinnedTarget) => void;
   handleShareSession: (session: Session) => void;
   copiedSessionId: string | null;
   handleCopyShareUrl: (url: string, sessionId: string) => void;
@@ -101,16 +103,9 @@ type Props = {
   ) => React.ReactNode;
   secondaryMeta?: SecondaryMeta | null;
   renderContext?: 'project' | 'recent';
-  /**
-   * Precomputed set of session IDs whose subtree contains the current
-   * active session. Computed once per SessionGroupSection render (when
-   * currentSessionId changes) instead of being recomputed in every row's
-   * React.memo comparator.
-   */
-  subtreeContainsActive: Set<string>;
   /**
    * Precomputed set of session IDs whose subtree contains the session
-   * currently being edited. Same rationale as subtreeContainsActive.
+   * currently being edited. Precomputed once per group render.
    */
   subtreeContainsEditing: Set<string>;
   /**
@@ -132,15 +127,52 @@ type Props = {
    * to fetch the right key for each child it produces.
    */
   childRenderExtrasFor?: (child: SessionNode) => SessionNodeChildRenderExtras;
-  /**
-   * Batched index of live session objects keyed by id. The previous
-   * implementation called `useSession(session.id)` per row, which used
-   * `findLiveSession` to iterate every child-store on every SSE event.
-   * With M visible rows that's M×child-stores per event; the batched
-   * map turns it into a single Map.get per row. The parent falls back
-   * to `useSession` only when this map returns undefined.
-   */
-  liveSessionById: Map<string, Session>;
+};
+
+const cancelScrollAnchorByContainer = new WeakMap<HTMLElement, () => void>();
+
+const holdSessionRowPosition = (target: HTMLElement): void => {
+  if (typeof window === 'undefined') return;
+  const row = target.closest<HTMLElement>('[data-session-row]');
+  const container = row?.closest<HTMLElement>('.overlay-scrollbar-container');
+  if (!row || !container) return;
+
+  cancelScrollAnchorByContainer.get(container)?.();
+
+  const initialTop = row.getBoundingClientRect().top;
+  let remainingFrames = 3;
+  let cancelled = false;
+  let frameId: number | null = null;
+  const cancel = () => {
+    cancelled = true;
+    if (frameId !== null) window.cancelAnimationFrame(frameId);
+    frameId = null;
+    cancelScrollAnchorByContainer.delete(container);
+    container.removeEventListener('wheel', cancel);
+    container.removeEventListener('touchstart', cancel);
+  };
+  const restore = () => {
+    if (cancelled || !row.isConnected || !container.isConnected) {
+      cancel();
+      return;
+    }
+    const delta = row.getBoundingClientRect().top - initialTop;
+    if (Math.abs(delta) > 0.5) {
+      container.scrollTop += delta;
+      streamPerfCount('ui.sidebar.selection_scroll_anchor_adjustment');
+    }
+    remainingFrames -= 1;
+    if (remainingFrames <= 0) {
+      cancel();
+      return;
+    }
+    frameId = window.requestAnimationFrame(restore);
+  };
+
+  container.addEventListener('wheel', cancel, { passive: true });
+  container.addEventListener('touchstart', cancel, { passive: true });
+  cancelScrollAnchorByContainer.set(container, cancel);
+  frameId = window.requestAnimationFrame(restore);
 };
 
 type QuickSessionActionProps = {
@@ -206,6 +238,7 @@ const QuickSessionAction = React.memo(function QuickSessionAction({
 });
 
 function SessionNodeItemComponent(props: Props): React.ReactNode {
+  streamPerfCount('ui.sidebar_session_node.render');
   const { t } = useI18n();
   const {
     node,
@@ -213,7 +246,6 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
     groupDirectory,
     projectId,
     archivedBucket = false,
-    currentSessionId,
     pinnedSessionIds,
     expandedParents,
     hasSessionSearchQuery,
@@ -248,11 +280,9 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
     renderSessionNode,
     secondaryMeta,
     renderContext = 'project',
-    subtreeContainsActive,
     subtreeContainsEditing,
     menuOpenSessionId,
     childRenderExtrasFor,
-    liveSessionById,
   } = props;
   const hasSecondaryProjectLabel = Boolean(secondaryMeta?.projectLabel);
   const hasSecondaryBranchLabel = Boolean(secondaryMeta?.branchLabel);
@@ -307,25 +337,15 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
   const formRef = React.useRef<HTMLFormElement>(null);
 
   const session = node.session;
-  // Batched live-session lookup. `liveSessionById` is built once per
-  // Sidebar render from the same `useAllLiveSessions` selector that
-  // `useSession` would have iterated per child-store, so a Map.get
-  // here is equivalent in observed state but O(1) per row instead of
-  // O(child-stores). Falls back to the row session when the live map
-  // hasn't seen this id yet (sub-render latency between when a session
-  // is created and when the SSE-driven aggregate picks it up).
-  const resolvedSession = liveSessionById.get(session.id) ?? session;
+  const resolvedSession = session;
+  const isActive = useSessionUIStore((state) => state.currentSessionId === session.id);
 
   const sessionDirectory =
     normalizePath((session as Session & { directory?: string | null }).directory ?? null)
     ?? normalizePath(groupDirectory ?? null);
-  // Archived rows are historical and never need live state, yet they point at
-  // dozens of (often deleted) worktrees — bootstrapping each from the sidebar
-  // triggers a pointless session-list fetch + 6×2s empty-retry storm on startup.
-  // Skip bootstrap for archived rows; the store ref is only read on-demand via
-  // getState() in the export handlers (never subscribed). Active rows keep
-  // bootstrapping so live cross-directory session/status still aggregates.
-  const directoryStore = useDirectoryStore(sessionDirectory ?? undefined, { bootstrap: !archivedBucket });
+  // Directory bootstrap is scheduled once at sidebar level. A row only needs
+  // the lightweight store reference for scoped state and export actions.
+  const directoryStore = useDirectoryStore(sessionDirectory ?? undefined, { bootstrap: false });
   const sync = useSync();
 
   const selectionModeEnabled = useSessionMultiSelectStore((state) => state.enabled);
@@ -368,7 +388,7 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
   );
   const sessionStatus = useGlobalSessionStatus(session.id);
   const isMovingToWorktree = useIsSessionWorktreeMovePending(session.id);
-  const sessionPermissions = useSessionPermissions(session.id, sessionDirectory ?? undefined);
+  const sessionPermissions = useSessionPermissions(session.id, sessionDirectory ?? undefined, { bootstrap: false });
   const sessionGoal = getSessionGoal(resolvedSession);
   const sessionGoalGlyph = sessionGoal ? (
     <span
@@ -379,10 +399,9 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
       <Icon name="target" className="h-3 w-3" style={{ color: sessionGoalStatusColor[sessionGoal.status] }} />
     </span>
   ) : null;
-  const isActive = currentSessionId === session.id;
   const sessionTitle = resolvedSession.title || t('sessions.sidebar.session.untitled');
   const hasChildren = node.children.length > 0;
-  const isPinnedSession = pinnedSessionIds.has(session.id);
+  const isPinnedSession = isSessionPinned(pinnedSessionIds, sessionDirectory, session.id);
   // Per-render-context expansion key: the same session can appear in both
   // the project's root and the "Recent" list, and expanding one should not
   // expand the other. Matches the format of menuInstanceKey.
@@ -409,7 +428,7 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
     let skipped = 0;
     for (const child of children) {
       try {
-        await sync.ensureSessionRenderable(child.session.id);
+        await sync.ensureSessionRenderable(child.session.id, false, sessionDirectory ?? undefined);
         const childRecords = buildSessionMessageRecordsSnapshot(directoryStore.getState(), child.session.id).list;
         const childTitle = child.session.title || t('sessions.sidebar.session.export.untitledSubagent');
         const childAgent = (child.session as Session & { agent?: string }).agent;
@@ -426,7 +445,7 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
       }
     }
     return { children: results, skipped };
-  }, [collectNodeDescendantIds, directoryStore, sync, t]);
+  }, [collectNodeDescendantIds, directoryStore, sessionDirectory, sync, t]);
 
   const showSkippedSubtasksWarning = React.useCallback((count: number) => {
     if (count <= 0) return;
@@ -441,7 +460,7 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
       return;
     }
 
-    await sync.ensureSessionRenderable(session.id);
+    await sync.ensureSessionRenderable(session.id, false, sessionDirectory);
 
     const records = buildSessionMessageRecordsSnapshot(directoryStore.getState(), session.id).list;
     if (records.length === 0) {
@@ -775,7 +794,8 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
       toggleRowSelected(session.id, sessionDirectory ?? null, collectNodeDescendantIds(node));
       return;
     }
-    handleSessionSelect(session.id, sessionDirectory, projectId);
+    if (event?.currentTarget) holdSessionRowPosition(event.currentTarget);
+    handleSessionSelect(session.id, sessionDirectory);
   };
 
   // The selection/active highlight covers the WHOLE row box (gutter, edge
@@ -832,7 +852,7 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
         <Icon name="pencil-ai" className="mr-1 h-4 w-4" />
         {t('sessions.sidebar.session.menu.rename')}
       </Item>
-      <Item onClick={() => togglePinnedSession(session.id)} className="[&>svg]:mr-1">
+      <Item onClick={() => sessionDirectory && togglePinnedSession({ directory: sessionDirectory, sessionId: session.id })} className="[&>svg]:mr-1">
         {isPinnedSession ? <Icon name="unpin" className="mr-1 h-4 w-4" /> : <Icon name="pushpin" className="mr-1 h-4 w-4" />}
         {isPinnedSession ? t('sessions.sidebar.session.menu.unpin') : t('sessions.sidebar.session.menu.pin')}
       </Item>
@@ -1267,7 +1287,6 @@ function SessionNodeItemComponent(props: Props): React.ReactNode {
           const childRenderExtras: SessionNodeChildRenderExtras = childRenderExtrasFor
             ? childRenderExtrasFor(child)
             : {
-                subtreeContainsActive,
                 subtreeContainsEditing,
                 menuOpenSessionId,
                 nodeStructureKey: '',
@@ -1387,26 +1406,6 @@ const hasSetMembershipChangeInNode = (
   return false;
 };
 
-const hasResolvedSessionChangeInNode = (
-  prevNode: SessionNode,
-  nextNode: SessionNode,
-  prevLiveSessionById: Map<string, Session>,
-  nextLiveSessionById: Map<string, Session>,
-): boolean => {
-  if (prevNode.session.id !== nextNode.session.id) return true;
-  const sessionId = prevNode.session.id;
-  if ((prevLiveSessionById.get(sessionId) ?? prevNode.session) !== (nextLiveSessionById.get(sessionId) ?? nextNode.session)) {
-    return true;
-  }
-  if (prevNode.children.length !== nextNode.children.length) return true;
-  for (let i = 0; i < prevNode.children.length; i += 1) {
-    if (hasResolvedSessionChangeInNode(prevNode.children[i], nextNode.children[i], prevLiveSessionById, nextLiveSessionById)) {
-      return true;
-    }
-  }
-  return false;
-};
-
 const hasExpansionMembershipChange = (prev: Props, next: Props): boolean => {
   if (prev.hasSessionSearchQuery || next.hasSessionSearchQuery) return false;
   const prevBucketTag = prev.archivedBucket ? 'archived' : 'active';
@@ -1428,6 +1427,7 @@ const hasExpansionMembershipChange = (prev: Props, next: Props): boolean => {
 
 const areSessionNodeItemPropsEqual = (prev: Props, next: Props): boolean => {
   if (prev.node.session.id !== next.node.session.id) return false;
+  if (prev.node.session !== next.node.session) return false;
   if (prev.depth !== next.depth) return false;
   if (prev.groupDirectory !== next.groupDirectory) return false;
   if (prev.projectId !== next.projectId) return false;
@@ -1442,13 +1442,15 @@ const areSessionNodeItemPropsEqual = (prev: Props, next: Props): boolean => {
   if (getNodeSessionDirectory(prev.node) !== getNodeSessionDirectory(next.node)) return false;
   if (!isSecondaryMetaEqual(prev.secondaryMeta, next.secondaryMeta)) return false;
 
-  if (prev.liveSessionById !== next.liveSessionById
-    && hasResolvedSessionChangeInNode(prev.node, next.node, prev.liveSessionById, next.liveSessionById)) {
-    return false;
-  }
-
   if (prev.pinnedSessionIds !== next.pinnedSessionIds
-    && hasSetMembershipChangeInNode(prev.node, next.node, prev.pinnedSessionIds, next.pinnedSessionIds, (node) => node.session.id)) {
+    && nodeHasPinnedMembershipChange(
+      prev.node,
+      next.node,
+      prev.pinnedSessionIds,
+      next.pinnedSessionIds,
+      prev.groupDirectory,
+      next.groupDirectory,
+    )) {
     return false;
   }
 
@@ -1456,14 +1458,6 @@ const areSessionNodeItemPropsEqual = (prev: Props, next: Props): boolean => {
     return false;
   }
 
-  if (prev.currentSessionId !== next.currentSessionId
-    && (
-      subtreeContainsSession(prev, prev.currentSessionId, prev.subtreeContainsActive)
-      || subtreeContainsSession(next, next.currentSessionId, next.subtreeContainsActive)
-    )) {
-    return false;
-  }
-
   if (prev.editingId !== next.editingId
     && (
       subtreeContainsSession(prev, prev.editingId, prev.subtreeContainsEditing)
diff --git a/packages/ui/src/components/session/sidebar/SidebarActivitySections.tsx b/packages/ui/src/components/session/sidebar/SidebarActivitySections.tsx
index 8f053344..8f97bc53 100644
--- a/packages/ui/src/components/session/sidebar/SidebarActivitySections.tsx
+++ b/packages/ui/src/components/session/sidebar/SidebarActivitySections.tsx
@@ -38,9 +38,9 @@ type Props = {
     renderContext?: 'project' | 'recent',
     renderExtras?: SessionNodeRenderExtras,
   ) => React.ReactNode;
-  currentSessionId: string | null;
   editingId: string | null;
   openSidebarMenuKey: string | null;
+  expansionState?: ReadonlySet<string>;
   variant?: 'section' | 'flat';
   initialVisibleCount?: number;
   batchSize?: number;
@@ -50,16 +50,16 @@ type RenderExtras = SessionNodeRenderExtras;
 
 const MAX_VISIBLE_RECENT_SESSIONS = 7;
 
-export function SidebarActivitySections({
-  sections,
-  renderSessionNode,
-  currentSessionId,
-  editingId,
-  openSidebarMenuKey,
-  variant = 'section',
-  initialVisibleCount = MAX_VISIBLE_RECENT_SESSIONS,
-  batchSize = MAX_VISIBLE_RECENT_SESSIONS,
-}: Props): React.ReactNode {
+export function SidebarActivitySections(props: Props): React.ReactNode {
+  const {
+    sections,
+    renderSessionNode,
+    editingId,
+    openSidebarMenuKey,
+    variant = 'section',
+    initialVisibleCount = MAX_VISIBLE_RECENT_SESSIONS,
+    batchSize = MAX_VISIBLE_RECENT_SESSIONS,
+  } = props;
   const { t } = useI18n();
   const [collapsed, setCollapsed] = React.useState<Set<string>>(new Set());
   const [visibleCountBySection, setVisibleCountBySection] = React.useState<Map<string, number>>(new Map());
@@ -101,8 +101,6 @@ export function SidebarActivitySections({
   }, [batchSize]);
 
   const buildRenderExtras = React.useCallback((nodes: SessionNode[]) => {
-    const subtreeContainsActive = new Set<string>();
-    collectSubtreeContainingId(nodes, currentSessionId, subtreeContainsActive);
     const subtreeContainsEditing = new Set<string>();
     collectSubtreeContainingId(nodes, editingId, subtreeContainsEditing);
     const menuOpenSessionId = resolveMenuOpenSessionId(nodes, openSidebarMenuKey, 'recent', false);
@@ -114,7 +112,6 @@ export function SidebarActivitySections({
     nodes.forEach(visit);
 
     const childRenderExtrasFor = (child: SessionNode): RenderExtras => ({
-      subtreeContainsActive,
       subtreeContainsEditing,
       menuOpenSessionId,
       nodeStructureKey: nodeStructureKeyByNode.get(child) ?? '',
@@ -122,13 +119,12 @@ export function SidebarActivitySections({
     });
 
     return (node: SessionNode): RenderExtras => ({
-      subtreeContainsActive,
       subtreeContainsEditing,
       menuOpenSessionId,
       nodeStructureKey: nodeStructureKeyByNode.get(node) ?? '',
       childRenderExtrasFor,
     });
-  }, [currentSessionId, editingId, openSidebarMenuKey]);
+  }, [editingId, openSidebarMenuKey]);
 
   const visibleSections = sections.filter((section) => section.items.length > 0);
   if (visibleSections.length === 0) {
diff --git a/packages/ui/src/components/session/sidebar/SidebarProjectsList.tsx b/packages/ui/src/components/session/sidebar/SidebarProjectsList.tsx
index 9efac151..7498cec4 100644
--- a/packages/ui/src/components/session/sidebar/SidebarProjectsList.tsx
+++ b/packages/ui/src/components/session/sidebar/SidebarProjectsList.tsx
@@ -18,6 +18,7 @@ import { formatProjectLabel } from './utils';
 import { useI18n } from '@/lib/i18n';
 import type { MainTab } from '@/stores/useUIStore';
 import type { ProjectSortOrder } from '@/stores/useSessionDisplayStore';
+import { streamPerfCount } from '@/stores/utils/streamDebug';
 
 type ProjectSection = {
   project: {
@@ -78,7 +79,8 @@ type Props = {
   isInlineEditing: boolean;
 };
 
-export function SidebarProjectsList(props: Props): React.ReactNode {
+function SidebarProjectsListComponent(props: Props): React.ReactNode {
+  streamPerfCount('ui.sidebar_projects_list.render');
   const { t } = useI18n();
   const projectSensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 8 } }),
@@ -311,3 +313,5 @@ export function SidebarProjectsList(props: Props): React.ReactNode {
     </ScrollableOverlay>
   );
 }
+
+export const SidebarProjectsList = React.memo(SidebarProjectsListComponent);
diff --git a/packages/ui/src/components/session/sidebar/authoritativeSessionCleanup.ts b/packages/ui/src/components/session/sidebar/authoritativeSessionCleanup.ts
new file mode 100644
index 00000000..a58bb766
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/authoritativeSessionCleanup.ts
@@ -0,0 +1,31 @@
+import type { Session } from '@opencode-ai/sdk/v2';
+import { resolveGlobalSessionDirectory } from '@/stores/useGlobalSessionsStore';
+
+type AuthoritativeSessionIdentity = {
+  directory: string;
+  sessionId: string;
+};
+
+export const buildAuthoritativeSessionIdentityMap = (
+  sessions: Session[],
+): Map<string, AuthoritativeSessionIdentity> => {
+  const identities = new Map<string, AuthoritativeSessionIdentity>();
+  for (const session of sessions) {
+    const directory = resolveGlobalSessionDirectory(session);
+    if (!directory) continue;
+    identities.set(session.id, { directory, sessionId: session.id });
+  }
+  return identities;
+};
+
+export const findRemovedAuthoritativeSessions = (
+  previous: ReadonlyMap<string, AuthoritativeSessionIdentity> | null,
+  current: ReadonlyMap<string, AuthoritativeSessionIdentity>,
+): AuthoritativeSessionIdentity[] => {
+  if (!previous) return [];
+  const removed: AuthoritativeSessionIdentity[] = [];
+  previous.forEach((identity, key) => {
+    if (!current.has(key)) removed.push(identity);
+  });
+  return removed;
+};
diff --git a/packages/ui/src/components/session/sidebar/hooks/pinnedSessionCleanup.ts b/packages/ui/src/components/session/sidebar/hooks/pinnedSessionCleanup.ts
deleted file mode 100644
index f2381896..00000000
--- a/packages/ui/src/components/session/sidebar/hooks/pinnedSessionCleanup.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import type { Session } from '@opencode-ai/sdk/v2';
-
-export const prunePinnedSessionIds = (
-  sessions: Array<Pick<Session, 'id'>>,
-  pinnedSessionIds: Set<string>,
-): Set<string> => {
-  const existingSessionIds = new Set(sessions.map((session) => session.id));
-  let changed = false;
-  const next = new Set<string>();
-
-  pinnedSessionIds.forEach((id) => {
-    if (existingSessionIds.has(id)) {
-      next.add(id);
-      return;
-    }
-    changed = true;
-  });
-
-  return changed ? next : pinnedSessionIds;
-};
diff --git a/packages/ui/src/components/session/sidebar/hooks/useArchivedAutoFolders.ts b/packages/ui/src/components/session/sidebar/hooks/useArchivedAutoFolders.ts
index 5bb33e8d..0031b36d 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useArchivedAutoFolders.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useArchivedAutoFolders.ts
@@ -17,6 +17,7 @@ type FolderEntry = {
 };
 
 type Args = {
+  enabled?: boolean;
   normalizedProjects: ProjectForArchivedFolders[];
   ownership: SessionOwnershipIndex;
   isSessionsLoading: boolean;
@@ -26,12 +27,12 @@ type Args = {
   foldersMap: Record<string, FolderEntry[]>;
   createFolder: (scopeKey: string, name: string, parentId?: string | null) => FolderEntry;
   addSessionToFolder: (scopeKey: string, folderId: string, sessionId: string) => void;
-  cleanupSessions: (scopeKey: string, existingSessionIds: Set<string>) => void;
 };
 
 export const useArchivedAutoFolders = (args: Args): void => {
   const {
     normalizedProjects,
+    enabled = true,
     ownership,
     isSessionsLoading,
     hasAuthoritativeGlobalSessions,
@@ -40,11 +41,10 @@ export const useArchivedAutoFolders = (args: Args): void => {
     foldersMap,
     createFolder,
     addSessionToFolder,
-    cleanupSessions,
   } = args;
 
   React.useEffect(() => {
-    if (isSessionsLoading || !hasAuthoritativeGlobalSessions || isWorktreeTopologyLoading) {
+    if (!enabled || isSessionsLoading || !hasAuthoritativeGlobalSessions || isWorktreeTopologyLoading) {
       return;
     }
 
@@ -54,8 +54,6 @@ export const useArchivedAutoFolders = (args: Args): void => {
       }
       const scopeKey = getArchivedScopeKey(project.normalizedPath);
       const projectArchivedSessions = ownership.archivedSessionsByProject.get(project.id) ?? [];
-      const sessionIds = new Set(projectArchivedSessions.map((session) => session.id));
-
       const existingFolders = foldersMap[scopeKey] ?? [];
       const folderByName = new Map(existingFolders.map((folder) => [folder.name.toLowerCase(), folder]));
 
@@ -72,11 +70,10 @@ export const useArchivedAutoFolders = (args: Args): void => {
           addSessionToFolder(scopeKey, folder.id, session.id);
         }
       });
-
-      cleanupSessions(scopeKey, sessionIds);
     });
   }, [
     normalizedProjects,
+    enabled,
     ownership,
     isSessionsLoading,
     hasAuthoritativeGlobalSessions,
@@ -85,6 +82,5 @@ export const useArchivedAutoFolders = (args: Args): void => {
     foldersMap,
     createFolder,
     addSessionToFolder,
-    cleanupSessions,
   ]);
 };
diff --git a/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.test.ts b/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.test.ts
new file mode 100644
index 00000000..d33089e5
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test';
+import type { Session } from '@opencode-ai/sdk/v2';
+import {
+  buildAuthoritativeSessionIdentityMap,
+  findRemovedAuthoritativeSessions,
+} from '../authoritativeSessionCleanup';
+
+const session = (id: string, directory = '/repo'): Session => ({ id, directory }) as Session;
+
+describe('authoritative session cleanup', () => {
+  test('does not infer deletion from the first authoritative startup snapshot', () => {
+    const current = buildAuthoritativeSessionIdentityMap([]);
+
+    expect(findRemovedAuthoritativeSessions(null, current)).toEqual([]);
+  });
+
+  test('finds sessions omitted after an established authoritative baseline', () => {
+    const previous = buildAuthoritativeSessionIdentityMap([
+      session('deleted'),
+      session('retained'),
+    ]);
+    const current = buildAuthoritativeSessionIdentityMap([session('retained')]);
+
+    expect(findRemovedAuthoritativeSessions(previous, current)).toEqual([
+      { directory: '/repo', sessionId: 'deleted' },
+    ]);
+  });
+
+  test('treats archive membership as retained authority', () => {
+    const previous = buildAuthoritativeSessionIdentityMap([session('archived')]);
+    const current = buildAuthoritativeSessionIdentityMap([
+      { ...session('archived'), time: { archived: 10 } } as Session,
+    ]);
+
+    expect(findRemovedAuthoritativeSessions(previous, current)).toEqual([]);
+  });
+
+  test('does not treat a directory move as session deletion', () => {
+    const previous = buildAuthoritativeSessionIdentityMap([session('moved', '/repo-a')]);
+    const current = buildAuthoritativeSessionIdentityMap([session('moved', '/repo-b')]);
+
+    expect(findRemovedAuthoritativeSessions(previous, current)).toEqual([]);
+  });
+});
diff --git a/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.ts b/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.ts
new file mode 100644
index 00000000..a86cc08b
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/hooks/useAuthoritativeSessionCleanup.ts
@@ -0,0 +1,35 @@
+import React from 'react';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { cleanupPersistedSessionState } from '@/sync/session-deletion-cleanup';
+import {
+  buildAuthoritativeSessionIdentityMap,
+  findRemovedAuthoritativeSessions,
+} from '../authoritativeSessionCleanup';
+
+export const useAuthoritativeSessionCleanup = (args: {
+  enabled?: boolean;
+  hasAuthoritativeGlobalSessions: boolean;
+  sessions: Session[];
+}): void => {
+  const { enabled = true, hasAuthoritativeGlobalSessions, sessions } = args;
+  const baselineRef = React.useRef<{
+    runtimeKey: string;
+    identities: ReturnType<typeof buildAuthoritativeSessionIdentityMap>;
+  } | null>(null);
+
+  React.useEffect(() => {
+    if (!enabled || !hasAuthoritativeGlobalSessions) return;
+
+    const runtimeKey = getRuntimeKey();
+    const current = buildAuthoritativeSessionIdentityMap(sessions);
+    const previous = baselineRef.current?.runtimeKey === runtimeKey
+      ? baselineRef.current.identities
+      : null;
+
+    for (const identity of findRemovedAuthoritativeSessions(previous, current)) {
+      cleanupPersistedSessionState({ runtimeKey, ...identity });
+    }
+    baselineRef.current = { runtimeKey, identities: current };
+  }, [enabled, hasAuthoritativeGlobalSessions, sessions]);
+};
diff --git a/packages/ui/src/components/session/sidebar/hooks/useProjectRepoStatus.ts b/packages/ui/src/components/session/sidebar/hooks/useProjectRepoStatus.ts
index 44b72f34..2d3cb253 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useProjectRepoStatus.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useProjectRepoStatus.ts
@@ -5,8 +5,10 @@ import { useGitStore } from '@/stores/useGitStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 
 type Project = { id: string; path: string; normalizedPath: string };
+const ROOT_BRANCH_TTL_MS = 5 * 60_000;
 
 type Args = {
+  enabled?: boolean;
   normalizedProjects: Project[];
   gitRepoStatus: Map<string, { isGitRepo: boolean | null; branch: string | null }>;
   setProjectRepoStatus: React.Dispatch<React.SetStateAction<Map<string, boolean | null>>>;
@@ -16,6 +18,7 @@ type Args = {
 export const useProjectRepoStatus = (args: Args): void => {
   const {
     normalizedProjects,
+    enabled = true,
     gitRepoStatus,
     setProjectRepoStatus,
     setProjectRootBranches,
@@ -26,7 +29,7 @@ export const useProjectRepoStatus = (args: Args): void => {
 
   // Derive repo status from centralized Git store
   React.useEffect(() => {
-    if (!git || normalizedProjects.length === 0) {
+    if (!enabled || !git || normalizedProjects.length === 0) {
       setProjectRepoStatus(new Map());
       return;
     }
@@ -35,16 +38,17 @@ export const useProjectRepoStatus = (args: Args): void => {
     normalizedProjects.forEach((project) => {
       void ensureStatus(project.normalizedPath, git);
     });
-  }, [normalizedProjects, git, ensureStatus, setProjectRepoStatus]);
+  }, [enabled, normalizedProjects, git, ensureStatus, setProjectRepoStatus]);
 
   // Read isGitRepo from the store-populated state
   React.useEffect(() => {
+    if (!enabled) return;
     const next = new Map<string, boolean | null>();
     normalizedProjects.forEach((project) => {
       next.set(project.id, gitRepoStatus.get(project.normalizedPath)?.isGitRepo ?? null);
     });
     setProjectRepoStatus(next);
-  }, [normalizedProjects, gitRepoStatus, setProjectRepoStatus]);
+  }, [enabled, normalizedProjects, gitRepoStatus, setProjectRepoStatus]);
 
   const projectGitBranchesKey = React.useMemo(() => {
     return normalizedProjects
@@ -69,9 +73,9 @@ export const useProjectRepoStatus = (args: Args): void => {
   // 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(() => {
+    if (!enabled) return;
     let cancelled = false;
 
     // Debounce so the initial burst of per-project `ensureStatus` updates
@@ -164,9 +168,5 @@ 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]);
+  }, [enabled, normalizedProjects, projectGitBranchesKey, gitRepoStatus, setProjectRootBranches]);
 };
diff --git a/packages/ui/src/components/session/sidebar/hooks/useProjectSessionSelection.ts b/packages/ui/src/components/session/sidebar/hooks/useProjectSessionSelection.ts
index 421dfdff..9d099dc1 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useProjectSessionSelection.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useProjectSessionSelection.ts
@@ -4,6 +4,7 @@ import type { SessionGroup, SessionNode } from '../types';
 import { normalizePath } from '../utils';
 import type { MainTab } from '@/stores/useUIStore';
 import { useUIStore } from '@/stores/useUIStore';
+import { useSessionUIStore } from '@/sync/session-ui-store';
 
 type ProjectSection = {
   project: { id: string; normalizedPath: string };
@@ -16,7 +17,7 @@ type Args = {
   activeSessionByProject: Map<string, string>;
   setActiveSessionByProject: React.Dispatch<React.SetStateAction<Map<string, string>>>;
   currentSessionId: string | null;
-  handleSessionSelect: (sessionId: string, sessionDirectory: string | null, projectId?: string | null) => void;
+  handleSessionSelect: (sessionId: string, sessionDirectory: string | null) => void;
   newSessionDraftOpen: boolean;
   mobileVariant: boolean;
   openNewSessionDraft: (options?: { selectedProjectId?: string | null; directoryOverride?: string | null }) => void;
@@ -148,7 +149,7 @@ export const useProjectSessionSelection = (args: Args): void => {
       return;
     }
     const targetDirectory = projectMap.get(targetSessionId)?.directory ?? null;
-    handleSessionSelect(targetSessionId, targetDirectory, activeProjectId);
+    handleSessionSelect(targetSessionId, targetDirectory);
   }, [
     activeProjectId,
     activeSessionByProject,
@@ -183,3 +184,34 @@ export const useProjectSessionSelection = (args: Args): void => {
   }, [activeProjectId, currentSessionId, projectSessionMeta, setActiveSessionByProject]);
 
 };
+
+type ProjectSessionSelectionEffectProps = Omit<
+  Args,
+  'activeSessionByProject' | 'setActiveSessionByProject' | 'currentSessionId' | 'newSessionDraftOpen'
+> & {
+  initialActiveSessionByProject: Map<string, string>;
+  persistActiveSessionByProject: (value: Map<string, string>) => void;
+};
+
+export const ProjectSessionSelectionEffect: React.FC<ProjectSessionSelectionEffectProps> = ({
+  initialActiveSessionByProject,
+  persistActiveSessionByProject,
+  ...args
+}) => {
+  const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
+  const newSessionDraftOpen = useSessionUIStore((state) => Boolean(state.newSessionDraft?.open));
+  const [activeSessionByProject, setActiveSessionByProject] = React.useState(
+    () => new Map(initialActiveSessionByProject),
+  );
+  useProjectSessionSelection({
+    ...args,
+    activeSessionByProject,
+    setActiveSessionByProject,
+    currentSessionId,
+    newSessionDraftOpen,
+  });
+  React.useEffect(() => {
+    persistActiveSessionByProject(activeSessionByProject);
+  }, [activeSessionByProject, persistActiveSessionByProject]);
+  return null;
+};
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionActions.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionActions.ts
index 7338be53..d3ab4123 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionActions.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSessionActions.ts
@@ -4,6 +4,8 @@ import { toast } from '@/components/ui';
 import { copyTextToClipboard } from '@/lib/clipboard';
 import { useI18n } from '@/lib/i18n';
 import type { MainTab } from '@/stores/useUIStore';
+import { streamPerfMark } from '@/stores/utils/streamDebug';
+import { useSessionUIStore } from '@/sync/session-ui-store';
 
 type DeleteSessionConfirmSetter = React.Dispatch<React.SetStateAction<{
   session: Session;
@@ -20,9 +22,6 @@ type DeleteSessionSource = {
 };
 
 type Args = {
-  activeProjectId: string | null;
-  currentDirectory: string | null;
-  currentSessionId: string | null;
   mobileVariant: boolean;
   allowReselect: boolean;
   onSessionSelected?: (sessionId: string) => void;
@@ -30,8 +29,6 @@ type Args = {
   sessionSearchQuery: string;
   setSessionSearchQuery: (value: string) => void;
   setIsSessionSearchOpen: (open: boolean) => void;
-  setActiveProjectIdOnly: (id: string) => void;
-  setDirectory: (directory: string, options?: { showOverlay?: boolean }) => void;
   setActiveMainTab: (tab: MainTab) => void;
   setSessionSwitcherOpen: (open: boolean) => void;
   setCurrentSession: (sessionId: string | null, directoryHint?: string | null) => void;
@@ -66,7 +63,8 @@ export const useSessionActions = (args: Args) => {
   }, []);
 
   const handleSessionSelect = React.useCallback(
-    (sessionId: string, sessionDirectory?: string | null, projectId?: string | null) => {
+    (sessionId: string, sessionDirectory?: string | null) => {
+      streamPerfMark('navigation.session_select');
       const resetSessionSearch = () => {
         if (!args.isSessionSearchOpen && args.sessionSearchQuery.length === 0) {
           return;
@@ -75,26 +73,19 @@ export const useSessionActions = (args: Args) => {
         args.setIsSessionSearchOpen(false);
       };
 
-      if (projectId && projectId !== args.activeProjectId) {
-        args.setActiveProjectIdOnly(projectId);
-      }
-
-      if (sessionDirectory && sessionDirectory !== args.currentDirectory) {
-        args.setDirectory(sessionDirectory, { showOverlay: false });
-      }
-
       if (args.mobileVariant) {
         args.setActiveMainTab('chat');
         args.setSessionSwitcherOpen(false);
       }
 
-      if (sessionId === args.currentSessionId) {
+      if (sessionId === useSessionUIStore.getState().currentSessionId) {
         if (args.allowReselect) {
           args.onSessionSelected?.(sessionId);
         }
         resetSessionSearch();
         return;
       }
+      streamPerfMark('navigation.session_state_set');
       args.setCurrentSession(sessionId, sessionDirectory ?? null);
       args.onSessionSelected?.(sessionId);
       resetSessionSearch();
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionFolderCleanup.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionFolderCleanup.ts
deleted file mode 100644
index 103c0698..00000000
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionFolderCleanup.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import React from 'react';
-import { getArchivedScopeKey, normalizePath } from '../utils';
-import type { SessionOwnershipIndex } from '../sessionOwnership';
-
-type WorktreeMeta = { path: string };
-
-type NormalizedProject = {
-  id: string;
-  normalizedPath: string;
-};
-
-type Args = {
-  isSessionsLoading: boolean;
-  hasAuthoritativeGlobalSessions: boolean;
-  isWorktreeTopologyLoading: boolean;
-  normalizedProjects: NormalizedProject[];
-  ownership: SessionOwnershipIndex;
-  availableWorktreesByProject: Map<string, WorktreeMeta[]>;
-  unresolvedWorktreeProjectPaths: ReadonlySet<string>;
-  cleanupSessions: (scopeKey: string, validSessionIds: Set<string>) => void;
-};
-
-export const useSessionFolderCleanup = (args: Args): void => {
-  const {
-    isSessionsLoading,
-    hasAuthoritativeGlobalSessions,
-    isWorktreeTopologyLoading,
-    normalizedProjects,
-    ownership,
-    availableWorktreesByProject,
-    unresolvedWorktreeProjectPaths,
-    cleanupSessions,
-  } = args;
-
-  React.useEffect(() => {
-    if (isSessionsLoading || !hasAuthoritativeGlobalSessions || isWorktreeTopologyLoading) {
-      return;
-    }
-
-    if (ownership.bySessionId.size === 0) {
-      return;
-    }
-
-    const idsByScope = new Map<string, Set<string>>();
-    ownership.sessionsByScope.forEach((sessionIds, scopeDirectory) => {
-      idsByScope.set(scopeDirectory, new Set(sessionIds));
-    });
-
-    normalizedProjects.forEach((project) => {
-      if (unresolvedWorktreeProjectPaths.has(project.normalizedPath)) {
-        return;
-      }
-      const scopeKey = getArchivedScopeKey(project.normalizedPath);
-      const archivedSessions = ownership.archivedSessionsByProject.get(project.id) ?? [];
-      idsByScope.set(scopeKey, new Set(archivedSessions.map((session) => session.id)));
-      if (!idsByScope.has(project.normalizedPath)) {
-        idsByScope.set(project.normalizedPath, new Set());
-      }
-      for (const worktree of availableWorktreesByProject.get(project.normalizedPath) ?? []) {
-        const worktreePath = normalizePath(worktree.path);
-        if (worktreePath && !idsByScope.has(worktreePath)) {
-          idsByScope.set(worktreePath, new Set());
-        }
-      }
-    });
-
-    idsByScope.forEach((sessionIds, scopeKey) => {
-      cleanupSessions(scopeKey, sessionIds);
-    });
-  }, [
-    availableWorktreesByProject,
-    cleanupSessions,
-    hasAuthoritativeGlobalSessions,
-    isWorktreeTopologyLoading,
-    isSessionsLoading,
-    normalizedProjects,
-    ownership,
-    unresolvedWorktreeProjectPaths,
-  ]);
-};
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
index 8d00bc84..66bdda18 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSessionPrefetch.ts
@@ -10,120 +10,152 @@ const SESSION_PREFETCH_CONCURRENCY = 1;
 const SESSION_PREFETCH_PENDING_LIMIT = 6;
 
 type Args = {
+  enabled?: boolean;
   currentSessionId: string | null;
   sortedSessions: Session[];
-  recentSessionIds?: string[];
-  ensureSessionRenderable: (sessionId: string) => Promise<unknown>;
+  recentSessions?: Session[];
+  prefetchSession: (sessionId: string, directory: string) => Promise<unknown>;
 };
 
-export const useSessionPrefetch = ({ currentSessionId, sortedSessions, recentSessionIds = [], ensureSessionRenderable }: Args): void => {
+type PrefetchRequest = {
+  sessionId: string;
+  directory: string;
+  generation: number;
+};
+
+const sessionDirectory = (session: Session | null | undefined): string | null => {
+  const directory = (session as (Session & { directory?: string | null }) | null | undefined)?.directory;
+  return typeof directory === 'string' && directory.trim() ? directory : null;
+};
+
+export const useSessionPrefetch = ({ enabled = true, currentSessionId, sortedSessions, recentSessions = [], prefetchSession }: Args): void => {
   const sessionPrefetchTimersRef = React.useRef<Map<string, number>>(new Map());
-  const sessionPrefetchQueueRef = React.useRef<string[]>([]);
+  const sessionPrefetchQueueRef = React.useRef<PrefetchRequest[]>([]);
   const sessionPrefetchInFlightRef = React.useRef<Set<string>>(new Set());
+  const generationRef = React.useRef(0);
   const prefetchDisabled = React.useMemo(() => isVSCodeRuntime(), []);
 
+  const requestKey = React.useCallback((request: Pick<PrefetchRequest, 'directory' | 'sessionId'>) => (
+    `${request.directory}\n${request.sessionId}`
+  ), []);
+
+  const clearPendingPrefetches = React.useCallback(() => {
+    generationRef.current += 1;
+    sessionPrefetchQueueRef.current = [];
+    sessionPrefetchTimersRef.current.forEach((timer) => window.clearTimeout(timer));
+    sessionPrefetchTimersRef.current.clear();
+  }, []);
+
   const pumpSessionPrefetchQueue = React.useCallback(() => {
-    if (prefetchDisabled || typeof window === 'undefined') {
+    if (!enabled || prefetchDisabled || typeof window === 'undefined') {
       return;
     }
 
     while (sessionPrefetchInFlightRef.current.size < SESSION_PREFETCH_CONCURRENCY && sessionPrefetchQueueRef.current.length > 0) {
-      const nextSessionId = sessionPrefetchQueueRef.current.shift();
-      if (!nextSessionId) {
+      const request = sessionPrefetchQueueRef.current.shift();
+      if (!request) {
         break;
       }
+      if (request.generation !== generationRef.current) continue;
 
       const state = useSessionUIStore.getState();
-      if (state.currentSessionId === nextSessionId) {
+      if (state.currentSessionId === request.sessionId) {
         continue;
       }
 
       // Check if the session is already renderable in the sync child store.
-      if (getSyncSessionMaterializationStatus(nextSessionId).renderable) {
+      if (getSyncSessionMaterializationStatus(request.sessionId, request.directory).renderable) {
         continue;
       }
 
-      sessionPrefetchInFlightRef.current.add(nextSessionId);
-      void ensureSessionRenderable(nextSessionId)
+      const key = requestKey(request);
+      sessionPrefetchInFlightRef.current.add(key);
+      void prefetchSession(request.sessionId, request.directory)
         .catch(() => undefined)
         .finally(() => {
-          sessionPrefetchInFlightRef.current.delete(nextSessionId);
+          sessionPrefetchInFlightRef.current.delete(key);
           pumpSessionPrefetchQueue();
         });
     }
-  }, [ensureSessionRenderable, prefetchDisabled]);
+  }, [enabled, prefetchDisabled, prefetchSession, requestKey]);
 
-  const scheduleSessionPrefetch = React.useCallback((sessionId: string | null | undefined) => {
-    if (prefetchDisabled || !sessionId || sessionId === currentSessionId || typeof window === 'undefined') {
+  const scheduleSessionPrefetch = React.useCallback((session: Session | null | undefined) => {
+    const sessionId = session?.id;
+    const directory = sessionDirectory(session);
+    if (!enabled || prefetchDisabled || !sessionId || !directory || sessionId === currentSessionId || typeof window === 'undefined') {
       return;
     }
+    const request = { sessionId, directory, generation: generationRef.current };
+    const key = requestKey(request);
 
     // Already renderable in sync
-    if (getSyncSessionMaterializationStatus(sessionId).renderable) {
+    if (getSyncSessionMaterializationStatus(sessionId, directory).renderable) {
       return;
     }
 
-    if (sessionPrefetchInFlightRef.current.has(sessionId)) {
+    if (sessionPrefetchInFlightRef.current.has(key)) {
       return;
     }
 
-    if (sessionPrefetchQueueRef.current.includes(sessionId)) {
+    if (sessionPrefetchQueueRef.current.some((candidate) => requestKey(candidate) === key)) {
       return;
     }
 
-    if (sessionPrefetchQueueRef.current.length >= SESSION_PREFETCH_PENDING_LIMIT) {
-      sessionPrefetchQueueRef.current.shift();
-    }
-
-    const existingTimer = sessionPrefetchTimersRef.current.get(sessionId);
+    const existingTimer = sessionPrefetchTimersRef.current.get(key);
     if (existingTimer !== undefined) {
       window.clearTimeout(existingTimer);
     }
 
     const timer = window.setTimeout(() => {
-      sessionPrefetchTimersRef.current.delete(sessionId);
-      sessionPrefetchQueueRef.current.push(sessionId);
+      sessionPrefetchTimersRef.current.delete(key);
+      if (request.generation !== generationRef.current) return;
+      const queue = sessionPrefetchQueueRef.current;
+      if (queue.length >= SESSION_PREFETCH_PENDING_LIMIT) {
+        queue.shift();
+      }
+      queue.push(request);
       pumpSessionPrefetchQueue();
     }, SESSION_PREFETCH_HOVER_DELAY_MS);
-    sessionPrefetchTimersRef.current.set(sessionId, timer);
-  }, [currentSessionId, prefetchDisabled, pumpSessionPrefetchQueue]);
+    sessionPrefetchTimersRef.current.set(key, timer);
+  }, [currentSessionId, enabled, prefetchDisabled, pumpSessionPrefetchQueue, requestKey]);
+
+  React.useEffect(() => {
+    clearPendingPrefetches();
+  }, [clearPendingPrefetches, currentSessionId, enabled, prefetchDisabled]);
 
   // Wait for the active session to finish loading before prefetching neighbors.
   // On rapid session switches the timer resets, so only the final session triggers prefetch.
   React.useEffect(() => {
-    if (prefetchDisabled || !currentSessionId || sortedSessions.length === 0) {
+    if (!enabled || prefetchDisabled || !currentSessionId || sortedSessions.length === 0) {
       return;
     }
     const timer = window.setTimeout(() => {
       const currentIndex = sortedSessions.findIndex((session) => session.id === currentSessionId);
       if (currentIndex < 0) return;
-      scheduleSessionPrefetch(sortedSessions[currentIndex - 1]?.id);
-      scheduleSessionPrefetch(sortedSessions[currentIndex + 1]?.id);
+      scheduleSessionPrefetch(sortedSessions[currentIndex - 1]);
+      scheduleSessionPrefetch(sortedSessions[currentIndex + 1]);
     }, SESSION_PREFETCH_SETTLE_MS);
     return () => window.clearTimeout(timer);
-  }, [currentSessionId, prefetchDisabled, scheduleSessionPrefetch, sortedSessions]);
+  }, [currentSessionId, enabled, prefetchDisabled, scheduleSessionPrefetch, sortedSessions]);
 
   React.useEffect(() => {
-    if (prefetchDisabled || !currentSessionId || recentSessionIds.length === 0) {
+    if (!enabled || prefetchDisabled || !currentSessionId || recentSessions.length === 0) {
       return;
     }
     const timer = window.setTimeout(() => {
-      const currentIndex = recentSessionIds.indexOf(currentSessionId);
+      const currentIndex = recentSessions.findIndex((session) => session.id === currentSessionId);
       if (currentIndex < 0) return;
-      scheduleSessionPrefetch(recentSessionIds[currentIndex - 1]);
-      scheduleSessionPrefetch(recentSessionIds[currentIndex + 1]);
+      scheduleSessionPrefetch(recentSessions[currentIndex - 1]);
+      scheduleSessionPrefetch(recentSessions[currentIndex + 1]);
     }, SESSION_PREFETCH_SETTLE_MS);
     return () => window.clearTimeout(timer);
-  }, [currentSessionId, prefetchDisabled, recentSessionIds, scheduleSessionPrefetch]);
+  }, [currentSessionId, enabled, prefetchDisabled, recentSessions, scheduleSessionPrefetch]);
 
-  React.useEffect(() => {
-    const prefetchTimers = sessionPrefetchTimersRef.current;
-    return () => {
-      prefetchTimers.forEach((timer) => {
-        clearTimeout(timer);
-      });
-      prefetchTimers.clear();
-      sessionPrefetchQueueRef.current = [];
-    };
-  }, []);
+  React.useEffect(() => clearPendingPrefetches, [clearPendingPrefetches]);
+};
+
+export const SessionPrefetchEffect: React.FC<Omit<Args, 'currentSessionId'>> = (args) => {
+  const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
+  useSessionPrefetch({ ...args, currentSessionId });
+  return null;
 };
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionSearchEffects.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionSearchEffects.ts
index bb0a760c..a4543458 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionSearchEffects.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSessionSearchEffects.ts
@@ -1,6 +1,7 @@
 import React from 'react';
 
 type Args = {
+  enabled?: boolean;
   isSessionSearchOpen: boolean;
   setIsSessionSearchOpen: (open: boolean) => void;
   sessionSearchInputRef: React.RefObject<HTMLInputElement | null>;
@@ -8,13 +9,14 @@ type Args = {
 };
 
 export const useSessionSearchEffects = ({
+  enabled = true,
   isSessionSearchOpen,
   setIsSessionSearchOpen,
   sessionSearchInputRef,
   sessionSearchContainerRef,
 }: Args): void => {
   React.useEffect(() => {
-    if (!isSessionSearchOpen || typeof window === 'undefined') {
+    if (!enabled || !isSessionSearchOpen || typeof window === 'undefined') {
       return;
     }
     const raf = window.requestAnimationFrame(() => {
@@ -22,10 +24,10 @@ export const useSessionSearchEffects = ({
       sessionSearchInputRef.current?.select();
     });
     return () => window.cancelAnimationFrame(raf);
-  }, [isSessionSearchOpen, sessionSearchInputRef]);
+  }, [enabled, isSessionSearchOpen, sessionSearchInputRef]);
 
   React.useEffect(() => {
-    if (!isSessionSearchOpen || typeof document === 'undefined') {
+    if (!enabled || !isSessionSearchOpen || typeof document === 'undefined') {
       return;
     }
     const handlePointerDown = (event: MouseEvent) => {
@@ -38,5 +40,5 @@ export const useSessionSearchEffects = ({
     };
     document.addEventListener('mousedown', handlePointerDown);
     return () => document.removeEventListener('mousedown', handlePointerDown);
-  }, [isSessionSearchOpen, setIsSessionSearchOpen, sessionSearchContainerRef]);
+  }, [enabled, isSessionSearchOpen, setIsSessionSearchOpen, sessionSearchContainerRef]);
 };
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSessionSidebarSections.ts b/packages/ui/src/components/session/sidebar/hooks/useSessionSidebarSections.ts
index e0567af4..c1a02d58 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSessionSidebarSections.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSessionSidebarSections.ts
@@ -4,6 +4,7 @@ import type { SessionGroup, SessionNode, GroupSearchData } from '../types';
 import { dedupeSessionsById, normalizePath } from '../utils';
 import type { WorktreeMetadata } from '@/types/worktree';
 import type { SessionFoldersMap } from '@/stores/useSessionFoldersStore';
+import { streamPerfCount } from '@/stores/utils/streamDebug';
 
 type ProjectItem = {
   id: string;
@@ -21,6 +22,19 @@ type ProjectSection = {
   groups: SessionGroup[];
 };
 
+type ProjectSectionCacheEntry = {
+  project: ProjectItem;
+  activeSessions: Session[];
+  archivedSessions: Session[];
+  availableWorktrees: WorktreeMetadata[];
+  rootBranch: string | null;
+  isRepo: boolean;
+  buildGroupedSessions: Args['buildGroupedSessions'];
+  section: ProjectSection;
+};
+
+const EMPTY_WORKTREES: WorktreeMetadata[] = [];
+
 type Args = {
   normalizedProjects: ProjectItem[];
   getSessionsForProject: (projectId: string) => Session[];
@@ -59,26 +73,67 @@ export const useSessionSidebarSections = (args: Args) => {
     buildGroupSearchText,
     foldersMap,
   } = args;
+  const projectSectionCacheRef = React.useRef<Map<string, ProjectSectionCacheEntry>>(new Map());
 
   const projectSections = React.useMemo<ProjectSection[]>(() => {
-    return normalizedProjects.map((project) => {
-      const projectSessions = dedupeSessionsById([
-        ...getSessionsForProject(project.id),
-        ...getArchivedSessionsForProject(project.id),
-      ]);
-      const worktreesForProject = availableWorktreesByProject.get(project.normalizedPath) ?? [];
+    const previousCache = projectSectionCacheRef.current;
+    const nextCache = new Map<string, ProjectSectionCacheEntry>();
+    let reusedSections = 0;
+    let rebuiltSections = 0;
+    const sameSessions = (left: Session[], right: Session[]): boolean => (
+      left.length === right.length && left.every((session, index) => session === right[index])
+    );
+
+    const sections = normalizedProjects.map((project) => {
+      const activeSessions = getSessionsForProject(project.id);
+      const archivedSessions = getArchivedSessionsForProject(project.id);
+      const worktreesForProject = availableWorktreesByProject.get(project.normalizedPath) ?? EMPTY_WORKTREES;
       const isRepo = projectRepoStatus.has(project.id)
         ? Boolean(projectRepoStatus.get(project.id))
         : lastRepoStatus;
+      const rootBranch = projectRootBranches.get(project.id) ?? null;
+      const cached = previousCache.get(project.id);
+      if (
+        cached
+        && cached.project === project
+        && sameSessions(cached.activeSessions, activeSessions)
+        && sameSessions(cached.archivedSessions, archivedSessions)
+        && cached.availableWorktrees === worktreesForProject
+        && cached.rootBranch === rootBranch
+        && cached.isRepo === isRepo
+        && cached.buildGroupedSessions === buildGroupedSessions
+      ) {
+        reusedSections += 1;
+        nextCache.set(project.id, cached);
+        return cached.section;
+      }
+
+      rebuiltSections += 1;
+      const projectSessions = dedupeSessionsById([...activeSessions, ...archivedSessions]);
       const groups = buildGroupedSessions(
         projectSessions,
         project.normalizedPath,
         worktreesForProject,
-        projectRootBranches.get(project.id) ?? null,
+        rootBranch,
         isRepo,
       );
-      return { project, groups };
+      const section = { project, groups };
+      nextCache.set(project.id, {
+        project,
+        activeSessions,
+        archivedSessions,
+        availableWorktrees: worktreesForProject,
+        rootBranch,
+        isRepo,
+        buildGroupedSessions,
+        section,
+      });
+      return section;
     });
+    projectSectionCacheRef.current = nextCache;
+    if (reusedSections > 0) streamPerfCount('ui.sidebar.project_section.reused', reusedSections);
+    if (rebuiltSections > 0) streamPerfCount('ui.sidebar.project_section.rebuilt', rebuiltSections);
+    return sections;
   }, [
     normalizedProjects,
     getSessionsForProject,
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.test.ts b/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.test.ts
deleted file mode 100644
index 2d0b8a29..00000000
--- a/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { Session } from '@opencode-ai/sdk/v2';
-import { prunePinnedSessionIds } from './pinnedSessionCleanup';
-
-const makeSession = (id: string): Pick<Session, 'id'> => ({ id });
-
-describe('prunePinnedSessionIds', () => {
-  test('keeps pinned ids that still exist in the authoritative session list', () => {
-    const sessions = [makeSession('visible-session'), makeSession('hidden-session')];
-    const pinnedSessionIds = new Set(['hidden-session', 'missing-session']);
-
-    const next = prunePinnedSessionIds(sessions, pinnedSessionIds);
-
-    expect([...next]).toEqual(['hidden-session']);
-    expect(next).not.toBe(pinnedSessionIds);
-  });
-
-  test('returns the original set when nothing needs pruning', () => {
-    const sessions = [makeSession('visible-session'), makeSession('hidden-session')];
-    const pinnedSessionIds = new Set(['visible-session', 'hidden-session']);
-
-    const next = prunePinnedSessionIds(sessions, pinnedSessionIds);
-
-    expect(next).toBe(pinnedSessionIds);
-  });
-});
diff --git a/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.ts b/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.ts
index 3a4a2146..d2e8604e 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useSidebarPersistence.ts
@@ -1,46 +1,24 @@
 import React from 'react';
-import type { Session } from '@opencode-ai/sdk/v2';
 import { updateDesktopSettings } from '@/lib/persistence';
 import { useProjectsStore } from '@/stores/useProjectsStore';
-import { prunePinnedSessionIds } from './pinnedSessionCleanup';
 
 type SafeStorageLike = {
   getItem: (key: string) => string | null;
   setItem: (key: string, value: string) => void;
-  removeItem?: (key: string) => void;
 };
 
 type Keys = {
   sessionExpanded: string;
-  // v1 key, still on disk for users upgrading from pre-per-context expansion.
-  // When present, its bare-session-id entries are fanned out to all four
-  // (project|recent) × (active|archived) context combinations and rewritten
-  // under `sessionExpanded`. After migration the v1 key is removed.
-  sessionExpandedLegacy: string;
   projectCollapse: string;
-  sessionPinned: string;
   groupOrder: string;
-  projectActiveSession: string;
   groupCollapse: string;
 };
 
-const LEGACY_EXPANSION_CONTEXT_PREFIXES = [
-  'project:active:',
-  'project:archived:',
-  'recent:active:',
-  'recent:archived:',
-];
-
 type Args = {
   isVSCode: boolean;
-  hasAuthoritativeGlobalSessions: boolean;
   safeStorage: SafeStorageLike;
   keys: Keys;
-  sessions: Session[];
-  pinnedSessionIds: Set<string>;
-  setPinnedSessionIds: React.Dispatch<React.SetStateAction<Set<string>>>;
   groupOrderByProject: Map<string, string[]>;
-  activeSessionByProject: Map<string, string>;
   collapsedGroups: Set<string>;
   setExpandedParents: React.Dispatch<React.SetStateAction<Set<string>>>;
   setCollapsedProjects: React.Dispatch<React.SetStateAction<Set<string>>>;
@@ -49,13 +27,9 @@ type Args = {
 export const useSidebarPersistence = (args: Args) => {
   const {
     isVSCode,
-    hasAuthoritativeGlobalSessions,
     safeStorage,
     keys,
-    sessions,
-    setPinnedSessionIds,
     groupOrderByProject,
-    activeSessionByProject,
     collapsedGroups,
     setExpandedParents,
     setCollapsedProjects,
@@ -115,28 +89,6 @@ export const useSidebarPersistence = (args: Args) => {
         if (Array.isArray(parsed)) {
           setExpandedParents(new Set(parsed.filter((item) => typeof item === 'string')));
         }
-      } else {
-        // No v2 data — migrate from v1 (bare session ids) if present.
-        const legacyRaw = safeStorage.getItem(keys.sessionExpandedLegacy);
-        if (legacyRaw) {
-          try {
-            const parsedLegacy = JSON.parse(legacyRaw);
-            if (Array.isArray(parsedLegacy)) {
-              const migrated = new Set<string>();
-              parsedLegacy.forEach((item) => {
-                if (typeof item !== 'string' || item.length === 0) return;
-                LEGACY_EXPANSION_CONTEXT_PREFIXES.forEach((prefix) => migrated.add(`${prefix}${item}`));
-              });
-              if (migrated.size > 0) {
-                setExpandedParents(migrated);
-                try { safeStorage.setItem(keys.sessionExpanded, JSON.stringify(Array.from(migrated))); } catch { /* ignored */ }
-              }
-            }
-          } catch {
-            // legacy data was malformed; ignore and let it expire
-          }
-          try { safeStorage.removeItem?.(keys.sessionExpandedLegacy); } catch { /* ignored */ }
-        }
       }
       const storedProjects = safeStorage.getItem(keys.projectCollapse);
       if (storedProjects) {
@@ -148,17 +100,7 @@ export const useSidebarPersistence = (args: Args) => {
     } catch {
       // ignored
     }
-  }, [keys.projectCollapse, keys.sessionExpanded, keys.sessionExpandedLegacy, safeStorage, setCollapsedProjects, setExpandedParents]);
-
-  React.useEffect(() => {
-    if (!hasAuthoritativeGlobalSessions) {
-      return;
-    }
-
-    setPinnedSessionIds((prev) => {
-      return prunePinnedSessionIds(sessions, prev);
-    });
-  }, [hasAuthoritativeGlobalSessions, sessions, setPinnedSessionIds]);
+  }, [keys.projectCollapse, keys.sessionExpanded, safeStorage, setCollapsedProjects, setExpandedParents]);
 
   React.useEffect(() => {
     try {
@@ -169,15 +111,6 @@ export const useSidebarPersistence = (args: Args) => {
     }
   }, [groupOrderByProject, keys.groupOrder, safeStorage]);
 
-  React.useEffect(() => {
-    try {
-      const serialized = Object.fromEntries(activeSessionByProject.entries());
-      safeStorage.setItem(keys.projectActiveSession, JSON.stringify(serialized));
-    } catch {
-      // ignored
-    }
-  }, [activeSessionByProject, keys.projectActiveSession, safeStorage]);
-
   React.useEffect(() => {
     try {
       safeStorage.setItem(keys.groupCollapse, JSON.stringify(Array.from(collapsedGroups)));
diff --git a/packages/ui/src/components/session/sidebar/hooks/useStickyProjectHeaders.ts b/packages/ui/src/components/session/sidebar/hooks/useStickyProjectHeaders.ts
index 9a48e4bf..e3bfe0e7 100644
--- a/packages/ui/src/components/session/sidebar/hooks/useStickyProjectHeaders.ts
+++ b/packages/ui/src/components/session/sidebar/hooks/useStickyProjectHeaders.ts
@@ -1,17 +1,18 @@
 import React from 'react';
 
 type Args = {
+  enabled?: boolean;
   isDesktopShellRuntime: boolean;
   projectSections: unknown[];
   projectHeaderSentinelRefs: React.MutableRefObject<Map<string, HTMLDivElement | null>>;
 };
 
 export const useStickyProjectHeaders = (args: Args): Set<string> => {
-  const { isDesktopShellRuntime, projectSections, projectHeaderSentinelRefs } = args;
+  const { enabled = true, isDesktopShellRuntime, projectSections, projectHeaderSentinelRefs } = args;
   const [stuckProjectHeaders, setStuckProjectHeaders] = React.useState<Set<string>>(new Set());
 
   React.useEffect(() => {
-    if (!isDesktopShellRuntime) {
+    if (!enabled || !isDesktopShellRuntime) {
       return;
     }
 
@@ -24,12 +25,16 @@ export const useStickyProjectHeaders = (args: Args): Set<string> => {
           }
 
           setStuckProjectHeaders((prev) => {
-            const next = new Set(prev);
             if (!entry.isIntersecting) {
+              if (prev.has(projectId)) return prev;
+              const next = new Set(prev);
               next.add(projectId);
-            } else {
-              next.delete(projectId);
+              return next;
             }
+
+            if (!prev.has(projectId)) return prev;
+            const next = new Set(prev);
+            next.delete(projectId);
             return next;
           });
         });
@@ -44,7 +49,7 @@ export const useStickyProjectHeaders = (args: Args): Set<string> => {
     });
 
     return () => observer.disconnect();
-  }, [isDesktopShellRuntime, projectHeaderSentinelRefs, projectSections]);
+  }, [enabled, isDesktopShellRuntime, projectHeaderSentinelRefs, projectSections]);
 
   return stuckProjectHeaders;
 };
diff --git a/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.test.ts b/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.test.ts
new file mode 100644
index 00000000..302b46cd
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.test.ts
@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test"
+import { buildSessionBootstrapDemands } from "./sessionBootstrapDemands"
+
+const sections = [{
+  project: { id: "project-a", normalizedPath: "/repo" },
+  groups: [
+    { id: "root", directory: "/repo", isMain: true },
+    { id: "worktree:/repo/wt-a", directory: "/repo/wt-a", isMain: false },
+    { id: "worktree:/repo/wt-b", directory: "/repo/wt-b", isMain: false },
+  ],
+}]
+
+describe("buildSessionBootstrapDemands", () => {
+  test("keeps collapsed worktrees eligible at background priority", () => {
+    const demands = buildSessionBootstrapDemands({
+      projectSections: sections,
+      activeProjectId: null,
+      collapsedProjects: new Set(["project-a"]),
+      collapsedGroups: new Set(),
+      currentDirectory: null,
+      currentSessionDirectory: null,
+    })
+
+    expect(demands.map(({ directory, priority }) => [directory, priority])).toEqual([
+      ["/repo", "background"],
+      ["/repo/wt-a", "background"],
+      ["/repo/wt-b", "background"],
+    ])
+  })
+
+  test("promotes expansion and selected session without duplicate directories", () => {
+    const demands = buildSessionBootstrapDemands({
+      projectSections: sections,
+      activeProjectId: "project-a",
+      collapsedProjects: new Set(),
+      collapsedGroups: new Set(["project-a:worktree:/repo/wt-b"]),
+      currentDirectory: "/repo",
+      currentSessionDirectory: "/repo/wt-b",
+    })
+    const byDirectory = new Map(demands.map((demand) => [demand.directory, demand]))
+
+    expect(demands.length).toBe(3)
+    expect(byDirectory.get("/repo")?.priority).toBe("selected")
+    expect(byDirectory.get("/repo/wt-a")?.priority).toBe("expanded")
+    expect(byDirectory.get("/repo/wt-b")?.priority).toBe("selected")
+  })
+})
diff --git a/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.ts b/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.ts
new file mode 100644
index 00000000..a8ff2357
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/sessionBootstrapDemands.ts
@@ -0,0 +1,77 @@
+import type { DirectoryBootstrapDemand, DirectoryBootstrapPriority } from "@/sync/child-store"
+import { normalizePath } from "./utils"
+
+type BootstrapProjectSection = {
+  project: { id: string; normalizedPath: string }
+  groups: Array<{
+    id: string
+    directory: string | null
+    isArchivedBucket?: boolean
+    isMain: boolean
+  }>
+}
+
+const PRIORITY_RANK: Record<DirectoryBootstrapPriority, number> = {
+  selected: 0,
+  "active-project": 1,
+  expanded: 2,
+  visible: 3,
+  background: 4,
+}
+
+export function buildSessionBootstrapDemands(input: {
+  projectSections: BootstrapProjectSection[]
+  activeProjectId: string | null
+  collapsedProjects: ReadonlySet<string>
+  collapsedGroups: ReadonlySet<string>
+  currentDirectory: string | null
+  currentSessionDirectory: string | null
+}): DirectoryBootstrapDemand[] {
+  const byDirectory = new Map<string, DirectoryBootstrapDemand>()
+  const add = (
+    directory: string | null | undefined,
+    priority: DirectoryBootstrapPriority,
+    reason: DirectoryBootstrapDemand["reason"],
+  ) => {
+    const normalizedDirectory = normalizePath(directory ?? null)
+    if (!normalizedDirectory) return
+    const existing = byDirectory.get(normalizedDirectory)
+    if (existing && PRIORITY_RANK[existing.priority] <= PRIORITY_RANK[priority]) return
+    byDirectory.set(normalizedDirectory, { directory: normalizedDirectory, priority, reason })
+  }
+
+  for (const section of input.projectSections) {
+    const projectExpanded = !input.collapsedProjects.has(section.project.id)
+    let projectPriority: DirectoryBootstrapPriority = "background"
+    if (section.project.id === input.activeProjectId) {
+      projectPriority = "active-project"
+    } else if (projectExpanded) {
+      projectPriority = "expanded"
+    }
+    add(
+      section.project.normalizedPath,
+      projectPriority,
+      projectExpanded ? "project-expanded" : "known-project",
+    )
+
+    for (const group of section.groups) {
+      if (!group.directory || group.isArchivedBucket || group.isMain) continue
+      const groupExpanded = projectExpanded && !input.collapsedGroups.has(`${section.project.id}:${group.id}`)
+      let groupPriority: DirectoryBootstrapPriority = "background"
+      if (groupExpanded) {
+        groupPriority = "expanded"
+      } else if (projectExpanded) {
+        groupPriority = "visible"
+      }
+      add(
+        group.directory,
+        groupPriority,
+        groupExpanded ? "worktree-expanded" : "known-worktree",
+      )
+    }
+  }
+
+  add(input.currentDirectory, "selected", "current-directory")
+  add(input.currentSessionDirectory, "selected", "selected-session")
+  return [...byDirectory.values()]
+}
diff --git a/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.test.ts b/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.test.ts
new file mode 100644
index 00000000..873796bb
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.test.ts
@@ -0,0 +1,125 @@
+import { describe, expect, test } from 'bun:test';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { getPinnedSessionKey } from '@/stores/useSessionPinnedStore';
+import { computeNodeStructureKey, nodeHasPinnedMembershipChange, selectFolderRootNodes } from './sessionNodeItemUtils';
+import type { SessionNode } from './types';
+
+const session = (id: string, title: string): Session => ({
+  id,
+  title,
+  time: { created: 1, updated: 1 },
+} as Session);
+
+const rootWithChild = (childSession: Session): SessionNode => ({
+  session: session('root', 'Root'),
+  children: [{ session: childSession, children: [], worktree: null }],
+  worktree: null,
+});
+
+describe('computeNodeStructureKey', () => {
+  test('stays stable across grouping rebuilds that reuse session objects', () => {
+    const child = session('child', 'Child');
+
+    expect(computeNodeStructureKey(rootWithChild(child))).toBe(computeNodeStructureKey(rootWithChild(child)));
+  });
+
+  test('changes when a descendant session object changes', () => {
+    const previous = session('child', 'Before');
+    const next = { ...previous, title: 'After' };
+
+    expect(computeNodeStructureKey(rootWithChild(previous))).not.toBe(computeNodeStructureKey(rootWithChild(next)));
+  });
+});
+
+describe('nodeHasPinnedMembershipChange', () => {
+  test('detects composite pin changes using the group directory fallback', () => {
+    const node: SessionNode = {
+      session: session('root', 'Root'),
+      children: [],
+      worktree: null,
+    };
+    const pinnedKey = getPinnedSessionKey(getRuntimeKey(), '/repo', 'root');
+
+    expect(pinnedKey).not.toBeNull();
+    expect(nodeHasPinnedMembershipChange(
+      node,
+      node,
+      new Set(),
+      new Set([pinnedKey!]),
+      '/repo',
+      '/repo',
+    )).toBe(true);
+  });
+
+  test('ignores pin changes for the same session id in another directory', () => {
+    const node: SessionNode = {
+      session: session('root', 'Root'),
+      children: [],
+      worktree: null,
+    };
+    const pinnedKey = getPinnedSessionKey(getRuntimeKey(), '/other-repo', 'root');
+
+    expect(pinnedKey).not.toBeNull();
+    expect(nodeHasPinnedMembershipChange(
+      node,
+      node,
+      new Set(),
+      new Set([pinnedKey!]),
+      '/repo',
+      '/repo',
+    )).toBe(false);
+  });
+});
+
+describe('selectFolderRootNodes', () => {
+  test('does not render assigned descendants again beside their assigned parent tree', () => {
+    const grandchild: SessionNode = {
+      session: { ...session('grandchild', 'Grandchild'), parentID: 'child' } as Session,
+      children: [],
+      worktree: null,
+    };
+    const child: SessionNode = {
+      session: { ...session('child', 'Child'), parentID: 'root' } as Session,
+      children: [grandchild],
+      worktree: null,
+    };
+    const root: SessionNode = {
+      session: session('root', 'Root'),
+      children: [child],
+      worktree: null,
+    };
+    const nodes = new Map([
+      ['root', root],
+      ['child', child],
+      ['grandchild', grandchild],
+    ]);
+
+    expect(selectFolderRootNodes(['root', 'child', 'grandchild'], nodes)).toEqual([root]);
+  });
+
+  test('keeps a child as a folder root when none of its ancestors are assigned', () => {
+    const child: SessionNode = {
+      session: { ...session('child', 'Child'), parentID: 'root' } as Session,
+      children: [],
+      worktree: null,
+    };
+    const root: SessionNode = {
+      session: session('root', 'Root'),
+      children: [child],
+      worktree: null,
+    };
+
+    expect(selectFolderRootNodes(['child'], new Map([['root', root], ['child', child]]))).toEqual([child]);
+  });
+
+  test('keeps a child when an assigned ancestor is not available in the group', () => {
+    const child: SessionNode = {
+      session: { ...session('child', 'Child'), parentID: 'missing-root' } as Session,
+      children: [],
+      worktree: null,
+    };
+
+    expect(selectFolderRootNodes(['missing-root', 'child'], new Map([['child', child]]))).toEqual([child]);
+  });
+});
diff --git a/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.ts b/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.ts
index ba8b4b53..8bb67ce2 100644
--- a/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.ts
+++ b/packages/ui/src/components/session/sidebar/sessionNodeItemUtils.ts
@@ -1,3 +1,5 @@
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { getPinnedSessionKey } from '@/stores/useSessionPinnedStore';
 import type { SessionNode } from './types';
 
 /**
@@ -10,7 +12,6 @@ import type { SessionNode } from './types';
  * each child's extras object.
  */
 export type SessionNodeChildRenderExtras = {
-  subtreeContainsActive: Set<string>;
   subtreeContainsEditing: Set<string>;
   menuOpenSessionId: string | null;
   nodeStructureKey: string;
@@ -24,7 +25,7 @@ export type SessionNodeRenderExtras<TNode = SessionNode> = SessionNodeChildRende
  * Walk `nodes` and add `node.session.id` to `result` for every node
  * whose subtree contains `targetId`. This is used to precompute, once
  * per SessionGroupSection render, which rows need to update when
- * `currentSessionId` or `editingId` changes. With M visible rows, this
+ * `editingId` changes. With M visible rows, this
  * turns an O(M × subtree-depth) walk inside `SessionNodeItem.areEqual`
  * into a single O(M) `Set.has` per row.
  */
@@ -69,12 +70,45 @@ export const nodeContainsSessionId = (node: SessionNode, sessionId: string | nul
   return false;
 };
 
+export const selectFolderRootNodes = (
+  sessionIds: string[],
+  nodeBySessionId: ReadonlyMap<string, SessionNode>,
+): SessionNode[] => {
+  const assignedSessionIds = new Set(sessionIds);
+
+  return sessionIds
+    .map((sessionId) => nodeBySessionId.get(sessionId))
+    .filter((node): node is SessionNode => {
+      if (!node) return false;
+
+      const visited = new Set<string>();
+      let parentID = (node.session as SessionNode['session'] & { parentID?: string | null }).parentID ?? null;
+      while (parentID && !visited.has(parentID)) {
+        if (assignedSessionIds.has(parentID) && nodeBySessionId.has(parentID)) return false;
+        visited.add(parentID);
+        const parentNode = nodeBySessionId.get(parentID);
+        parentID = (parentNode?.session as (SessionNode['session'] & { parentID?: string | null }) | undefined)?.parentID ?? null;
+      }
+      return true;
+    });
+};
+
+const sessionObjectVersions = new WeakMap<object, number>();
+let nextSessionObjectVersion = 1;
+
+const getSessionObjectVersion = (session: object): number => {
+  const existing = sessionObjectVersions.get(session);
+  if (existing !== undefined) return existing;
+  const version = nextSessionObjectVersion;
+  nextSessionObjectVersion += 1;
+  sessionObjectVersions.set(session, version);
+  return version;
+};
+
 /**
- * Build a structural key for `node` that encodes the IDs of all
- * descendants. Used by `SessionNodeItem.areEqual` so a reference-only
- * rebuild of the tree (which happens on every `buildGroupedSessions`
- * pass) can be detected with a single string compare instead of a
- * recursive walk per row.
+ * Build a key encoding descendant IDs and session object versions. This lets
+ * row memoization detect one changed descendant without recursively comparing
+ * every subtree after a reference-only grouping rebuild.
  */
 export const computeNodeStructureKey = (node: SessionNode): string => {
   if (node.children.length === 0) {
@@ -82,15 +116,49 @@ export const computeNodeStructureKey = (node: SessionNode): string => {
   }
 
   const childKeys = node.children.map((child) => {
+    const childVersion = getSessionObjectVersion(child.session);
     if (child.children.length === 0) {
-      return child.session.id;
+      return `${child.session.id}@${childVersion}`;
     }
-    return `${child.session.id}:${computeNodeStructureKey(child)}`;
+    return `${child.session.id}@${childVersion}:${computeNodeStructureKey(child)}`;
   });
 
   return childKeys.join('|');
 };
 
+export const nodeHasPinnedMembershipChange = (
+  prevNode: SessionNode,
+  nextNode: SessionNode,
+  prevPinnedSessionIds: Set<string>,
+  nextPinnedSessionIds: Set<string>,
+  prevGroupDirectory?: string | null,
+  nextGroupDirectory?: string | null,
+): boolean => {
+  const runtimeKey = getRuntimeKey();
+  const visit = (previous: SessionNode, current: SessionNode): boolean => {
+    if (previous.session.id !== current.session.id || previous.children.length !== current.children.length) {
+      return true;
+    }
+
+    const prevDirectory = (previous.session as SessionNode['session'] & { directory?: string | null }).directory
+      ?? prevGroupDirectory;
+    const nextDirectory = (current.session as SessionNode['session'] & { directory?: string | null }).directory
+      ?? nextGroupDirectory;
+    const prevKey = getPinnedSessionKey(runtimeKey, prevDirectory ?? '', previous.session.id);
+    const nextKey = getPinnedSessionKey(runtimeKey, nextDirectory ?? '', current.session.id);
+    if (
+      (prevKey ? prevPinnedSessionIds.has(prevKey) : false)
+      !== (nextKey ? nextPinnedSessionIds.has(nextKey) : false)
+    ) {
+      return true;
+    }
+
+    return previous.children.some((child, index) => visit(child, current.children[index]));
+  };
+
+  return visit(prevNode, nextNode);
+};
+
 /**
  * Resolve the session id whose sidebar menu is open, or null if no
  * menu is open. Only one row can have its menu open at a time.
diff --git a/packages/ui/src/components/session/sidebar/utils.test.ts b/packages/ui/src/components/session/sidebar/utils.test.ts
index d9135d05..fc164281 100644
--- a/packages/ui/src/components/session/sidebar/utils.test.ts
+++ b/packages/ui/src/components/session/sidebar/utils.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, test } from 'bun:test';
-import { isPathWithinProject } from './utils';
+import {
+  isPathWithinProject,
+  selectExpandedParentKeysForContext,
+  toggleExpandedParentKey,
+} from './utils';
 
 describe('isPathWithinProject', () => {
   test('matches child directories for root projects', () => {
@@ -26,3 +30,48 @@ describe('isPathWithinProject', () => {
     expect(isPathWithinProject('/workspace/app/sub/dir', '/workspace/app')).toBe(true);
   });
 });
+
+describe('selectExpandedParentKeysForContext', () => {
+  test('keeps project and recent expansion state isolated', () => {
+    const expanded = new Set([
+      'project:active:parent-a',
+      'project:archived:parent-b',
+      'recent:active:parent-a',
+    ]);
+
+    expect(selectExpandedParentKeysForContext(new Set(), expanded, 'project')).toEqual(new Set([
+      'project:active:parent-a',
+      'project:archived:parent-b',
+    ]));
+    expect(selectExpandedParentKeysForContext(new Set(), expanded, 'recent')).toEqual(new Set([
+      'recent:active:parent-a',
+    ]));
+  });
+
+  test('preserves a context projection when only another context changes', () => {
+    const recent = new Set(['recent:active:parent-a']);
+    const expanded = new Set(['recent:active:parent-a', 'project:active:parent-a']);
+
+    expect(selectExpandedParentKeysForContext(recent, expanded, 'recent')).toBe(recent);
+  });
+});
+
+describe('parent expansion state', () => {
+  const recentKey = 'recent:active:parent-a';
+  const projectKey = 'project:active:parent-a';
+
+  test('manually expands and collapses a parent', () => {
+    const expanded = toggleExpandedParentKey(new Set(), recentKey);
+    expect(expanded).toEqual(new Set([recentKey]));
+    expect(toggleExpandedParentKey(expanded, recentKey)).toEqual(new Set());
+  });
+
+  test('does not change the other render context', () => {
+    const recentExpanded = new Set([recentKey]);
+    const bothExpanded = toggleExpandedParentKey(recentExpanded, projectKey);
+    const projectCollapsed = toggleExpandedParentKey(bothExpanded, projectKey);
+
+    expect(selectExpandedParentKeysForContext(new Set(), bothExpanded, 'recent')).toEqual(new Set([recentKey]));
+    expect(selectExpandedParentKeysForContext(new Set(), projectCollapsed, 'recent')).toEqual(new Set([recentKey]));
+  });
+});
diff --git a/packages/ui/src/components/session/sidebar/utils.tsx b/packages/ui/src/components/session/sidebar/utils.tsx
index c24ef19e..2af0e05e 100644
--- a/packages/ui/src/components/session/sidebar/utils.tsx
+++ b/packages/ui/src/components/session/sidebar/utils.tsx
@@ -1,11 +1,36 @@
 import React from 'react';
 import type { Session } from '@opencode-ai/sdk/v2';
+import { resolveGlobalSessionDirectory } from '@/stores/useGlobalSessionsStore';
+import { isSessionPinned } from '@/stores/useSessionPinnedStore';
 import { getCurrentIntlLocale } from '@/lib/i18n';
 import { formatMessage, useI18nStore } from '@/lib/i18n/store';
 
 import { normalizePath } from '@/lib/pathNormalization';
 export { normalizePath };
 
+export const selectExpandedParentKeysForContext = (
+  previous: Set<string>,
+  expanded: ReadonlySet<string>,
+  context: 'project' | 'recent',
+): Set<string> => {
+  const prefix = `${context}:`;
+  const next = new Set([...expanded].filter((key) => key.startsWith(prefix)));
+  if (previous.size === next.size && [...next].every((key) => previous.has(key))) {
+    return previous;
+  }
+  return next;
+};
+
+export const toggleExpandedParentKey = (
+  expanded: Set<string>,
+  key: string,
+): Set<string> => {
+  const next = new Set(expanded);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  return next;
+};
+
 const t = (key: Parameters<typeof formatMessage>[1], params?: Parameters<typeof formatMessage>[2]) =>
   formatMessage(useI18nStore.getState().dictionary, key, params);
 
@@ -132,8 +157,8 @@ export const compareSessionsByPinnedAndTime = (
   b: Session,
   pinnedSessionIds: Set<string>,
 ): number => {
-  const aPinned = pinnedSessionIds.has(a.id);
-  const bPinned = pinnedSessionIds.has(b.id);
+  const aPinned = isSessionPinned(pinnedSessionIds, resolveGlobalSessionDirectory(a), a.id);
+  const bPinned = isSessionPinned(pinnedSessionIds, resolveGlobalSessionDirectory(b), b.id);
   if (aPinned !== bPinned) {
     return aPinned ? -1 : 1;
   }
diff --git a/packages/ui/src/components/ui/CommandPalette.tsx b/packages/ui/src/components/ui/CommandPalette.tsx
index e7e8fc75..77bccafd 100644
--- a/packages/ui/src/components/ui/CommandPalette.tsx
+++ b/packages/ui/src/components/ui/CommandPalette.tsx
@@ -53,6 +53,7 @@ type CommandEntry = {
 };
 
 type FileHit = { path: string; name: string; relativePath: string };
+const EMPTY_SESSIONS: Session[] = [];
 
 const normalizePath = (value: string): string => {
   if (!value) return '';
@@ -85,7 +86,10 @@ export const CommandPalette: React.FC = () => {
   const openNewSessionDraft = useSessionUIStore((s) => s.openNewSessionDraft);
   const setCurrentSession = useSessionUIStore((s) => s.setCurrentSession);
 
-  const activeSessions = useGlobalSessionsStore((s) => s.activeSessions);
+  const activeSessions = useGlobalSessionsStore(React.useCallback(
+    (state) => isCommandPaletteOpen ? state.activeSessions : EMPTY_SESSIONS,
+    [isCommandPaletteOpen],
+  ));
   const currentDirectory = useDirectoryStore((s) => s.currentDirectory);
   const activeProject = useProjectsStore((s) => s.getActiveProject());
   const projects = useProjectsStore((s) => s.projects);
diff --git a/packages/ui/src/components/views/ChatView.tsx b/packages/ui/src/components/views/ChatView.tsx
index f1e5b21b..152998f4 100644
--- a/packages/ui/src/components/views/ChatView.tsx
+++ b/packages/ui/src/components/views/ChatView.tsx
@@ -4,15 +4,16 @@ import { ChatErrorBoundary } from '@/components/chat/ChatErrorBoundary';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 
 type ChatViewProps = {
+    active?: boolean;
     readOnly?: boolean;
 };
 
-export const ChatView: React.FC<ChatViewProps> = ({ readOnly = false }) => {
+export const ChatView: React.FC<ChatViewProps> = ({ active = true, readOnly = false }) => {
     const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
 
     return (
         <ChatErrorBoundary sessionId={currentSessionId || undefined}>
-            <ChatContainer readOnly={readOnly} />
+            <ChatContainer active={active} readOnly={readOnly} />
         </ChatErrorBoundary>
     );
 };
diff --git a/packages/ui/src/components/views/DiffView.tsx b/packages/ui/src/components/views/DiffView.tsx
index 473711d4..95d83840 100644
--- a/packages/ui/src/components/views/DiffView.tsx
+++ b/packages/ui/src/components/views/DiffView.tsx
@@ -3,6 +3,7 @@ import React from 'react';
 import { useUIStore } from '@/stores/useUIStore';
 import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
 import { useGitStore, useGitStatus, useIsGitRepo, useGitLoadingStatus } from '@/stores/useGitStore';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 import { cn } from '@/lib/utils';
 import type { GitStatus } from '@/lib/api/types';
 import {
@@ -667,6 +668,7 @@ const MultiFileDiffEntry = React.memo<MultiFileDiffEntryProps>(({
         setIsLoading(true);
 
         let cancelled = false;
+        const runtimeKey = getRuntimeKey();
         const contextLines = loadFullFiles ? FULL_CONTEXT_DIFF_LINES : DEFAULT_CONTEXT_DIFF_LINES;
         const fetchPromise = isImageFile(file.path)
             ? git.getGitFileDiff(directory, { path: file.path, staged })
@@ -697,7 +699,7 @@ const MultiFileDiffEntry = React.memo<MultiFileDiffEntryProps>(({
                     if (staged) {
                         setStagedDiffData(nextDiff);
                     } else {
-                        setDiff(directory, file.path, nextDiff);
+                        setDiff(directory, file.path, nextDiff, runtimeKey);
                     }
                 }
                 setIsLoading(false);
@@ -1494,6 +1496,7 @@ export const DiffView: React.FC<DiffViewProps> = ({
         }
 
         setOpeningEditorFilePath(filePath);
+        const runtimeKey = getRuntimeKey();
         try {
             let targetLine: number | null = null;
 
@@ -1525,7 +1528,7 @@ export const DiffView: React.FC<DiffViewProps> = ({
                     isBinary: response.isBinary,
                 };
                 if (!activeDiffStaged) {
-                    setDiff(effectiveDirectory, filePath, diffForNavigation);
+                    setDiff(effectiveDirectory, filePath, diffForNavigation, runtimeKey);
                 }
             }
 
diff --git a/packages/ui/src/components/views/FilesView.tsx b/packages/ui/src/components/views/FilesView.tsx
index 163fa58e..5c7191bb 100644
--- a/packages/ui/src/components/views/FilesView.tsx
+++ b/packages/ui/src/components/views/FilesView.tsx
@@ -567,9 +567,9 @@ const FileRow: React.FC<FileRowProps> = ({
             onOpenChange={(open) => setContextMenuPath(open ? node.path : null)}
           >
             <DropdownMenuTrigger asChild>
-              <Button 
-                variant="ghost" 
-                size="icon" 
+              <Button
+                variant="ghost"
+                size="icon"
                 className="size-6"
                 onClick={handleMenuButtonClick}
               >
@@ -810,7 +810,6 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
   const openPaths = useFilesViewTabsStore((state) => (root ? (state.byRoot[root]?.openPaths ?? EMPTY_PATHS) : EMPTY_PATHS));
   const selectedPath = useFilesViewTabsStore((state) => (root ? (state.byRoot[root]?.selectedPath ?? null) : null));
   const expandedPaths = useFilesViewTabsStore((state) => (root ? (state.byRoot[root]?.expandedPaths ?? EMPTY_PATHS) : EMPTY_PATHS));
-  const addOpenPath = useFilesViewTabsStore((state) => state.addOpenPath);
   const removeOpenPath = useFilesViewTabsStore((state) => state.removeOpenPath);
   const removeOpenPathsByPrefix = useFilesViewTabsStore((state) => state.removeOpenPathsByPrefix);
   const removeExpandedPathsByPrefix = useFilesViewTabsStore((state) => state.removeExpandedPathsByPrefix);
@@ -922,6 +921,7 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
   const diagramEditorRef = React.useRef<React.ComponentRef<typeof DiagramEditor>>(null);
   const lastLoadedFileStatRef = React.useRef<FileStatSnapshot | null>(null);
   const activeFileLoadIdRef = React.useRef(0);
+  const loadingFilePathRef = React.useRef<string | null>(null);
   const [autoSaveStatus, setAutoSaveStatus] = React.useState<'idle' | 'saved'>('idle');
   const [diagramSaved, setDiagramSaved] = React.useState(false);
   const [autoSaveEnabled, setAutoSaveEnabled] = React.useState(getInitialAutoSaveEnabled);
@@ -1952,7 +1952,6 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
 
     if (root) {
       setSelectedPath(root, node.path);
-      addOpenPath(root, node.path);
       void ensurePathVisible(node.path, false);
     }
 
@@ -1966,7 +1965,7 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
     if (isMobile) {
       setShowMobilePageContent(true);
     }
-  }, [addOpenPath, ensurePathVisible, isDirty, isMobile, root, setSelectedPath]);
+  }, [ensurePathVisible, isDirty, isMobile, root, setSelectedPath]);
 
   React.useEffect(() => {
     if (!selectedFile?.path) {
@@ -1979,16 +1978,23 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
   React.useEffect(() => {
     if (!selectedFile) {
       activeFileLoadIdRef.current += 1;
+      loadingFilePathRef.current = null;
       setFileLoading(false);
       return;
     }
 
-    if (loadedFilePath === selectedFile.path) {
+    if (loadedFilePath === selectedFile.path || loadingFilePathRef.current === selectedFile.path) {
       return;
     }
 
     // Selection changes are guarded; this effect is also what restores persisted tabs on mount.
-    void loadSelectedFile(selectedFile);
+    const loadingPath = selectedFile.path;
+    loadingFilePathRef.current = loadingPath;
+    void loadSelectedFile(selectedFile).finally(() => {
+      if (loadingFilePathRef.current === loadingPath) {
+        loadingFilePathRef.current = null;
+      }
+    });
   }, [loadSelectedFile, loadedFilePath, selectedFile]);
 
   // Sync isDirty to a ref so the polling interval can read the latest value
@@ -2192,7 +2198,7 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
   const getFileStatus = React.useCallback((path: string): FileStatus | null => {
     // Check open status
     if (openPaths.includes(path)) return 'open';
-    
+
     // Check git status
     if (gitStatus?.files) {
       const relative = path.startsWith(root + '/') ? path.slice(root.length + 1) : path;
@@ -2210,7 +2216,7 @@ export const FilesView: React.FC<FilesViewProps> = ({ mode = 'full' }) => {
     if (!gitStatus?.files) return null;
     const relativeDir = dirPath.startsWith(root + '/') ? dirPath.slice(root.length + 1) : dirPath;
     const prefix = relativeDir ? `${relativeDir}/` : '';
-    
+
     let modified = 0, added = 0;
     for (const f of gitStatus.files) {
       if (f.path.startsWith(prefix)) {
diff --git a/packages/ui/src/components/views/TerminalView.tsx b/packages/ui/src/components/views/TerminalView.tsx
index 772faeb8..ed7acc1a 100644
--- a/packages/ui/src/components/views/TerminalView.tsx
+++ b/packages/ui/src/components/views/TerminalView.tsx
@@ -615,9 +615,8 @@ export const TerminalView: React.FC<TerminalViewProps> = ({ visible }) => {
     const handleAttachSelection = React.useCallback(() => {
         const selection = terminalControllerRef.current?.getSelection();
         const sessionKey = currentSessionId ?? (newSessionDraft?.open ? 'draft' : null);
-        if (!selection || !sessionKey || !activeTab) return;
-        addContextDraft({
-            sessionKey,
+        if (!selection || !sessionKey || !activeTab || !effectiveDirectory) return;
+        addContextDraft({ directory: effectiveDirectory, sessionKey }, {
             source: 'terminal',
             fileLabel: activeTab.label,
             startLine: selection.startLine,
@@ -626,7 +625,7 @@ export const TerminalView: React.FC<TerminalViewProps> = ({ visible }) => {
             language: activeTab.terminalSessionId ?? activeTab.id,
             text: '',
         });
-    }, [activeTab, addContextDraft, currentSessionId, newSessionDraft?.open]);
+    }, [activeTab, addContextDraft, currentSessionId, effectiveDirectory, newSessionDraft?.open]);
 
     const handleSelectTab = React.useCallback(
         (tabId: string) => {
diff --git a/packages/ui/src/components/views/git/PullRequestSection.tsx b/packages/ui/src/components/views/git/PullRequestSection.tsx
index 916d0642..f647d2fb 100644
--- a/packages/ui/src/components/views/git/PullRequestSection.tsx
+++ b/packages/ui/src/components/views/git/PullRequestSection.tsx
@@ -382,8 +382,8 @@ export const PullRequestSection: React.FC<{
   const canShow = Boolean(directory && branch && baseBranch && (branch !== baseBranch || isFork));
 
   const prStatusKey = React.useMemo(
-    () => getGitHubPrStatusKey(directory, branch),
-    [directory, branch],
+    () => getGitHubPrStatusKey(directory, branch, selectedRemote?.name ?? null),
+    [directory, branch, selectedRemote?.name],
   );
   const statusEntry = useGitHubPrStatusStore((state) => state.entries[prStatusKey]);
 
diff --git a/packages/ui/src/contexts/RuntimeAPIProvider.tsx b/packages/ui/src/contexts/RuntimeAPIProvider.tsx
index 5cb76743..f91a4abe 100644
--- a/packages/ui/src/contexts/RuntimeAPIProvider.tsx
+++ b/packages/ui/src/contexts/RuntimeAPIProvider.tsx
@@ -1,161 +1,17 @@
 import React, { type JSX, type ReactNode } from 'react';
 import { RuntimeAPIContext } from '@/contexts/runtimeAPIContext';
-import type { FilesAPI, RuntimeAPIs } from '@/lib/api/types';
-import {
-  approxStringBytes,
-  evictContentLru,
-  setContentBytes,
-  touchContent as touchContentLru,
-  removeContentBytes,
-} from '@/sync/content-cache';
-
-/** Wrap a FilesAPI with an in-memory LRU content cache. */
-function withContentCache(files: FilesAPI): FilesAPI {
-  const cache = new Map<string, { content: string; path: string; size?: number; mtimeMs?: number }>();
-
-  const removeCacheEntry = (path: string) => {
-    cache.delete(path);
-    removeContentBytes(path);
-  };
-
-  const removeCacheEntriesByPrefix = (path: string) => {
-    const prefix = path.endsWith('/') ? path : `${path}/`;
-    for (const key of cache.keys()) {
-      if (key === path || key.startsWith(prefix)) {
-        removeCacheEntry(key);
-      }
-    }
-  };
-
-  /** Whether cached metadata still matches the file on disk. */
-  const statMatches = (
-    cached: { size?: number; mtimeMs?: number },
-    latest: { isFile: boolean; size: number; mtimeMs?: number },
-  ): boolean => {
-    if (!latest.isFile) return false;
-    // If mtimeMs is available on both sides, it is the strongest signal.
-    if (cached.mtimeMs !== undefined && latest.mtimeMs !== undefined) {
-      return cached.mtimeMs === latest.mtimeMs && cached.size === latest.size;
-    }
-    return cached.size === latest.size;
-  };
-
-  const syncCacheEntry = (
-    path: string,
-    result: { content: string; path: string },
-    stat?: { isFile: boolean; size: number; mtimeMs?: number } | null,
-  ): { content: string; path: string } => {
-    const bytes = approxStringBytes(result.content);
-    cache.set(path, {
-      ...result,
-      size: stat?.isFile ? stat.size : undefined,
-      mtimeMs: stat?.isFile ? stat.mtimeMs : undefined,
-    });
-    setContentBytes(path, bytes);
-
-    const keep = new Set<string>();
-    evictContentLru(keep, (evictPath) => {
-      cache.delete(evictPath);
-    });
-
-    return result;
-  };
-
-  const readFreshFile = async (path: string, options?: Parameters<NonNullable<FilesAPI['readFile']>>[1]): Promise<{ content: string; path: string }> => {
-    // stat → read → stat to avoid TOCTOU:
-    // if the file changes between read and either stat, metadata won't match and we retry.
-    const statBefore = await files.statFile?.(path, options).catch(() => null);
-
-    const result = await files.readFile!(path, options);
-
-    const statAfter = await files.statFile?.(path, options).catch(() => null);
-
-    // If both stats are available and agree, the read was atomic with respect to file changes.
-    if (statBefore && statAfter && statBefore.isFile && statAfter.isFile) {
-      if (statBefore.size === statAfter.size && statBefore.mtimeMs === statAfter.mtimeMs) {
-        return syncCacheEntry(path, result, statAfter);
-      }
-      // File changed during read — discard and re-read once.
-      const retryStatBefore = await files.statFile?.(path, options).catch(() => null);
-      const retry = await files.readFile!(path, options);
-      const retryStat = await files.statFile?.(path, options).catch(() => null);
-      // Accept retry only if file was stable across the read.
-      if (retryStatBefore && retryStat && retryStatBefore.isFile && retryStat.isFile
-        && retryStatBefore.size === retryStat.size && retryStatBefore.mtimeMs === retryStat.mtimeMs) {
-        return syncCacheEntry(path, retry, retryStat);
-      }
-      // Best-effort: file was still changing, cache what we got. Next hit will re-validate.
-      return syncCacheEntry(path, retry, retryStat);
-    }
-
-    return syncCacheEntry(path, result, statAfter ?? statBefore);
-  };
-
-  const cachedReadFile: FilesAPI['readFile'] = files.readFile
-    ? async (path: string, options) => {
-        if (options?.allowOutsideWorkspace) {
-          return readFreshFile(path, options);
-        }
-        const hit = cache.get(path);
-        if (hit) {
-          // Validate cached entry is still fresh
-          if (files.statFile) {
-            const latest = await files.statFile(path, options).catch(() => {
-              removeCacheEntry(path);
-              return null;
-            });
-            if (!latest || !statMatches(hit, latest)) {
-              removeCacheEntry(path);
-              return readFreshFile(path, options);
-            }
-          }
-          touchContentLru(path);
-          return { content: hit.content, path: hit.path };
-        }
-
-        return readFreshFile(path, options);
-      }
-    : undefined;
-
-  // Invalidate cache on writes, deletes, renames
-  const cachedWriteFile: FilesAPI['writeFile'] = files.writeFile
-    ? async (path, content) => {
-        removeCacheEntry(path);
-        return files.writeFile!(path, content);
-      }
-    : undefined;
-
-  const cachedDelete: FilesAPI['delete'] = files.delete
-    ? async (path) => {
-        removeCacheEntriesByPrefix(path);
-        return files.delete!(path);
-      }
-    : undefined;
-
-  const cachedRename: FilesAPI['rename'] = files.rename
-    ? async (oldPath, newPath) => {
-        removeCacheEntriesByPrefix(oldPath);
-        removeCacheEntriesByPrefix(newPath);
-        return files.rename!(oldPath, newPath);
-      }
-    : undefined;
-
-  return {
-    ...files,
-    readFile: cachedReadFile,
-    writeFile: cachedWriteFile,
-    delete: cachedDelete,
-    rename: cachedRename,
-  };
-}
+import type { RuntimeAPIs } from '@/lib/api/types';
+import { createContentCachedFiles } from '@/contexts/content-cache-owner';
 
 export function RuntimeAPIProvider({ apis, children }: { apis: RuntimeAPIs; children: ReactNode }): JSX.Element {
+  const cachedFiles = React.useMemo(() => createContentCachedFiles(apis.files), [apis.files]);
+  React.useEffect(() => () => cachedFiles.dispose(), [cachedFiles]);
   const cachedApis = React.useMemo<RuntimeAPIs>(
     () => ({
       ...apis,
-      files: withContentCache(apis.files),
+      files: cachedFiles.files,
     }),
-    [apis],
+    [apis, cachedFiles],
   );
   return <RuntimeAPIContext.Provider value={cachedApis}>{children}</RuntimeAPIContext.Provider>;
 }
diff --git a/packages/ui/src/contexts/ThemeSystemContext.tsx b/packages/ui/src/contexts/ThemeSystemContext.tsx
index 5d33d2f2..cb76b498 100644
--- a/packages/ui/src/contexts/ThemeSystemContext.tsx
+++ b/packages/ui/src/contexts/ThemeSystemContext.tsx
@@ -2,6 +2,7 @@ import React, {
   useEffect,
   useMemo,
   useCallback,
+  useRef,
   useState,
 } from 'react';
 import { flushSync } from 'react-dom';
@@ -24,6 +25,7 @@ import { runtimeFetch } from '@/lib/runtime-fetch';
 import { getInitialSystemPreference, readEmbeddedThemeSearchParams } from './theme-embedded-bootstrap';
 import { isValidTheme } from './theme-validation';
 import { getSyncedThemeFromPayload, getSyncedThemeVariant } from './theme-sync-payload';
+import { getRuntimeKey, subscribeRuntimeEndpointChanged } from '@/lib/runtime-switch';
 
 type ThemePreferences = {
   themeMode: ThemeMode;
@@ -172,8 +174,8 @@ export function ThemeSystemProvider({ children, defaultThemeId }: ThemeSystemPro
     return existing || null;
   });
   const isVSCode = useMemo(() => isVSCodeRuntime(), []);
-  const isLocalDesktopOrigin = useMemo(() => isDesktopLocalOriginActive(), []);
   const isDesktopShell = useMemo(() => detectDesktopShell(), []);
+  const customThemesRequestRef = useRef(0);
   const receivesParentThemeSync = useMemo(() => {
     if (typeof window === 'undefined') {
       return false;
@@ -249,11 +251,13 @@ export function ThemeSystemProvider({ children, defaultThemeId }: ThemeSystemPro
       return;
     }
 
+    const runtimeKey = getRuntimeKey();
+    const request = ++customThemesRequestRef.current;
     setCustomThemesLoading(true);
     try {
       const res = await runtimeFetch('/api/config/themes', {
         method: 'GET',
-        credentials: isLocalDesktopOrigin ? 'omit' : 'include',
+        credentials: isDesktopLocalOriginActive() ? 'omit' : 'include',
         headers: {
           Accept: 'application/json',
         },
@@ -269,20 +273,31 @@ export function ThemeSystemProvider({ children, defaultThemeId }: ThemeSystemPro
       }
 
       const payload = await res.json();
+      if (request !== customThemesRequestRef.current || runtimeKey !== getRuntimeKey()) return;
       const incoming = Array.isArray(payload?.themes) ? payload.themes : [];
       const normalized = incoming.filter(isValidTheme);
       setCustomThemes(normalized);
     } catch {
       // ignore
     } finally {
-      setCustomThemesLoading(false);
+      if (request === customThemesRequestRef.current && runtimeKey === getRuntimeKey()) {
+        setCustomThemesLoading(false);
+      }
     }
-  }, [isLocalDesktopOrigin, isVSCode]);
+  }, [isVSCode]);
 
   useEffect(() => {
     void reloadCustomThemes();
   }, [reloadCustomThemes]);
 
+  useEffect(() => subscribeRuntimeEndpointChanged((detail) => {
+    if (detail.runtimeKey === detail.previousRuntimeKey || isVSCode) return;
+    customThemesRequestRef.current += 1;
+    setCustomThemes([]);
+    setCustomThemesLoading(false);
+    void reloadCustomThemes();
+  }), [isVSCode, reloadCustomThemes]);
+
   useEffect(() => {
     if (!isVSCode) {
       return;
diff --git a/packages/ui/src/contexts/content-cache-owner.test.ts b/packages/ui/src/contexts/content-cache-owner.test.ts
new file mode 100644
index 00000000..31547064
--- /dev/null
+++ b/packages/ui/src/contexts/content-cache-owner.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test"
+import type { FilesAPI } from "@/lib/api/types"
+import { createContentCachedFiles } from "./content-cache-owner"
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((res) => { resolve = res })
+  return { promise, resolve }
+}
+
+describe("content cache owner", () => {
+  test("reuses only strongly validated content", async () => {
+    let reads = 0
+    const files = {
+      readFile: async (path: string) => ({ path, content: `value-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 7, mtimeMs: 1 }),
+    } as unknown as FilesAPI
+    const owner = createContentCachedFiles(files)
+
+    expect((await owner.files.readFile!("file.ts")).content).toBe("value-1")
+    expect((await owner.files.readFile!("file.ts")).content).toBe("value-1")
+    expect(reads).toBe(1)
+    owner.dispose()
+  })
+
+  test("does not retain size-only reads without mtime", async () => {
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string) => ({ path, content: `value-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 7 }),
+    } as unknown as FilesAPI)
+
+    await owner.files.readFile!("file.ts")
+    await owner.files.readFile!("file.ts")
+    expect(reads).toBe(2)
+    owner.dispose()
+  })
+
+  test("retries a read that overlaps a write", async () => {
+    const firstRead = deferred<{ path: string; content: string }>()
+    let content = "old"
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string) => {
+        reads += 1
+        return reads === 1 ? firstRead.promise : { path, content }
+      },
+      statFile: async () => ({ isFile: true, isDirectory: false, size: content.length, mtimeMs: content === "old" ? 1 : 2 }),
+      writeFile: async (_path: string, next: string) => { content = next },
+    } as unknown as FilesAPI)
+
+    const reading = owner.files.readFile!("file.ts")
+    await owner.files.writeFile!("file.ts", "new")
+    firstRead.resolve({ path: "file.ts", content: "old" })
+
+    expect((await reading).content).toBe("new")
+    expect(reads).toBe(2)
+    owner.dispose()
+  })
+
+  test("separates identical paths by directory scope", async () => {
+    let reads = 0
+    const owner = createContentCachedFiles({
+      readFile: async (path: string, options?: Parameters<NonNullable<FilesAPI['readFile']>>[1]) => ({ path, content: `${options?.directory}-${++reads}` }),
+      statFile: async () => ({ isFile: true, isDirectory: false, size: 1, mtimeMs: 1 }),
+    } as unknown as FilesAPI)
+
+    const first = await owner.files.readFile!("file.ts", { directory: "/a" })
+    const second = await owner.files.readFile!("file.ts", { directory: "/b" })
+    expect(first.content).toBe("/a-1")
+    expect(second.content).toBe("/b-2")
+    owner.dispose()
+  })
+})
diff --git a/packages/ui/src/contexts/content-cache-owner.ts b/packages/ui/src/contexts/content-cache-owner.ts
new file mode 100644
index 00000000..34b8e8aa
--- /dev/null
+++ b/packages/ui/src/contexts/content-cache-owner.ts
@@ -0,0 +1,134 @@
+import type { FilesAPI } from '@/lib/api/types';
+import { subscribeRuntimeEndpointWillChange } from '@/lib/runtime-switch';
+
+const MAX_ENTRIES = 40;
+const MAX_BYTES = 20 * 1024 * 1024;
+type Entry = { content: string; path: string; sourcePath: string; size: number; mtimeMs: number; bytes: number };
+
+export function createContentCachedFiles(files: FilesAPI): { files: FilesAPI; dispose: () => void } {
+  const cache = new Map<string, Entry>();
+  let totalBytes = 0;
+  let generation = 0;
+  let active = true;
+  let mutationBarrier = Promise.resolve();
+
+  const cacheKey = (path: string, options?: Parameters<NonNullable<FilesAPI['readFile']>>[1]) =>
+    JSON.stringify([options?.directory ?? '', path]);
+  const contentBytes = (content: string) => new TextEncoder().encode(content).byteLength;
+  const removeEntry = (key: string) => {
+    const entry = cache.get(key);
+    if (entry) totalBytes = Math.max(0, totalBytes - entry.bytes);
+    cache.delete(key);
+  };
+  const removePrefix = (path: string) => {
+    const prefix = path.endsWith('/') ? path : `${path}/`;
+    for (const [key, entry] of cache) {
+      if (entry.sourcePath === path || entry.sourcePath.startsWith(prefix)) removeEntry(key);
+    }
+  };
+  const metadataMatches = (cached: Entry, latest: { isFile: boolean; size: number; mtimeMs?: number }) => (
+    latest.isFile
+    && latest.mtimeMs !== undefined
+    && cached.mtimeMs === latest.mtimeMs
+    && cached.size === latest.size
+  );
+  const cacheResult = (
+    key: string,
+    sourcePath: string,
+    result: { content: string; path: string },
+    stat: { isFile: boolean; size: number; mtimeMs?: number },
+  ) => {
+    if (!active || !stat.isFile || stat.mtimeMs === undefined) return result;
+    const bytes = contentBytes(result.content);
+    if (bytes > MAX_BYTES) return result;
+    removeEntry(key);
+    cache.set(key, { ...result, sourcePath, size: stat.size, mtimeMs: stat.mtimeMs, bytes });
+    totalBytes += bytes;
+    while (cache.size > MAX_ENTRIES || totalBytes > MAX_BYTES) {
+      const oldest = cache.keys().next().value;
+      if (!oldest) break;
+      removeEntry(oldest);
+    }
+    return result;
+  };
+
+  const readFresh = async (
+    key: string,
+    path: string,
+    options: Parameters<NonNullable<FilesAPI['readFile']>>[1] | undefined,
+    capturedGeneration: number,
+  ): Promise<{ content: string; path: string }> => {
+    const before = await files.statFile?.(path, options).catch(() => null);
+    const result = await files.readFile!(path, options);
+    const after = await files.statFile?.(path, options).catch(() => null);
+    if (!active) throw new Error('File read invalidated by runtime change');
+    if (capturedGeneration !== generation) return cachedReadFile!(path, options);
+    const stable = before && after && before.isFile && after.isFile
+      && before.mtimeMs !== undefined && after.mtimeMs !== undefined
+      && before.size === after.size && before.mtimeMs === after.mtimeMs;
+    return stable ? cacheResult(key, path, result, after) : result;
+  };
+
+  const cachedReadFile: FilesAPI['readFile'] = files.readFile
+    ? async (path, options) => {
+        await mutationBarrier;
+        if (!active) throw new Error('File cache owner disposed');
+        const capturedGeneration = generation;
+        if (options?.allowOutsideWorkspace) return files.readFile!(path, options);
+        const key = cacheKey(path, options);
+        const hit = cache.get(key);
+        if (!hit) return readFresh(key, path, options, capturedGeneration);
+        const latest = await files.statFile?.(path, options).catch(() => null);
+        if (!active) throw new Error('File read invalidated by runtime change');
+        if (capturedGeneration !== generation) return cachedReadFile!(path, options);
+        if (!latest || !metadataMatches(hit, latest)) {
+          removeEntry(key);
+          return readFresh(key, path, options, capturedGeneration);
+        }
+        cache.delete(key);
+        cache.set(key, hit);
+        return { content: hit.content, path: hit.path };
+      }
+    : undefined;
+
+  const mutate = async <T>(paths: string[], operation: () => Promise<T>): Promise<T> => {
+    const previous = mutationBarrier;
+    let release!: () => void;
+    mutationBarrier = new Promise<void>((resolve) => { release = resolve; });
+    await previous;
+    generation += 1;
+    paths.forEach(removePrefix);
+    try {
+      return await operation();
+    } finally {
+      paths.forEach(removePrefix);
+      generation += 1;
+      release();
+    }
+  };
+
+  const cachedFiles: FilesAPI = {
+    ...files,
+    readFile: cachedReadFile,
+    writeFile: files.writeFile ? (path, content) => mutate([path], () => files.writeFile!(path, content)) : undefined,
+    delete: files.delete ? (path) => mutate([path], () => files.delete!(path)) : undefined,
+    rename: files.rename ? (oldPath, newPath) => mutate([oldPath, newPath], () => files.rename!(oldPath, newPath)) : undefined,
+  };
+  const unsubscribeRuntime = subscribeRuntimeEndpointWillChange((detail) => {
+    if (detail.runtimeKey === detail.previousRuntimeKey) return;
+    active = false;
+    generation += 1;
+    cache.clear();
+    totalBytes = 0;
+  });
+  return {
+    files: cachedFiles,
+    dispose: () => {
+      active = false;
+      generation += 1;
+      cache.clear();
+      totalBytes = 0;
+      unsubscribeRuntime();
+    },
+  };
+}
diff --git a/packages/ui/src/hooks/usePwaManifestSync.ts b/packages/ui/src/hooks/usePwaManifestSync.ts
index 4d3ce7b5..d0c01deb 100644
--- a/packages/ui/src/hooks/usePwaManifestSync.ts
+++ b/packages/ui/src/hooks/usePwaManifestSync.ts
@@ -69,6 +69,7 @@ export const usePwaManifestSync = () => {
   }, [currentSessionId, sessions]);
 
   const signature = React.useMemo(() => JSON.stringify(recentShortcuts), [recentShortcuts]);
+  const hasRecentShortcuts = recentShortcuts.length > 0;
 
   React.useEffect(() => {
     if (typeof window === 'undefined' || !isWebRuntime()) {
@@ -76,7 +77,7 @@ export const usePwaManifestSync = () => {
     }
 
     try {
-      if (recentShortcuts.length === 0) {
+      if (!hasRecentShortcuts) {
         localStorage.removeItem(PWA_RECENT_SESSIONS_STORAGE_KEY);
       } else {
         localStorage.setItem(PWA_RECENT_SESSIONS_STORAGE_KEY, signature);
@@ -87,5 +88,5 @@ export const usePwaManifestSync = () => {
 
     const win = window as ManifestSyncWindow;
     win.__OPENCHAMBER_UPDATE_PWA_MANIFEST__?.();
-  }, [recentShortcuts, signature]);
+  }, [hasRecentShortcuts, signature]);
 };
diff --git a/packages/ui/src/hooks/useQueuedMessageAutoSend.test.ts b/packages/ui/src/hooks/useQueuedMessageAutoSend.test.ts
index fad8d66c..6675b2a5 100644
--- a/packages/ui/src/hooks/useQueuedMessageAutoSend.test.ts
+++ b/packages/ui/src/hooks/useQueuedMessageAutoSend.test.ts
@@ -167,7 +167,7 @@ describe('buildQueuedAutoSendPayload', () => {
     ]);
 
     expect(payload).not.toBeNull();
-    await sendQueuedAutoSendPayload('session-original', payload!, {
+    await sendQueuedAutoSendPayload('session-original', '/repo', payload!, {
       providerID: 'provider-1',
       modelID: 'model-1',
       agent: 'agent-1',
@@ -185,7 +185,7 @@ describe('buildQueuedAutoSendPayload', () => {
       undefined,
       'variant-1',
       'normal',
-      { sessionId: 'session-original' },
+      { sessionId: 'session-original', directory: '/repo' },
     ]);
   });
 });
diff --git a/packages/ui/src/hooks/useQueuedMessageAutoSend.ts b/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
index 894bdbda..ecb53e6b 100644
--- a/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
+++ b/packages/ui/src/hooks/useQueuedMessageAutoSend.ts
@@ -1,13 +1,15 @@
 import React from 'react';
-import { useMessageQueueStore, type QueuedMessage } from '@/stores/messageQueueStore';
+import { getMessageQueueKey, parseMessageQueueKey, useMessageQueueStore, type MessageQueueTarget, type QueuedMessage } from '@/stores/messageQueueStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSelectionStore } from '@/sync/selection-store';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { useContextStore } from '@/stores/contextStore';
 import { useAutoReviewStore } from '@/stores/useAutoReviewStore';
 import { parseAgentMentions } from '@/lib/messages/agentMentions';
-import { getSyncSessionStatus } from '@/sync/sync-refs';
+import { getDirectoryState } from '@/sync/sync-refs';
 import { useDirectorySync } from '@/sync/sync-context';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { useDirectoryStore } from '@/stores/useDirectoryStore';
 
 type SessionStatusType = 'idle' | 'busy' | 'retry';
 
@@ -67,6 +69,7 @@ type ResolvedQueuedSendConfig = {
 
 export const sendQueuedAutoSendPayload = (
   sessionId: string,
+  directory: string,
   payload: QueuedAutoSendPayload,
   resolved: ResolvedQueuedSendConfig,
 ) => {
@@ -80,7 +83,7 @@ export const sendQueuedAutoSendPayload = (
     undefined,
     resolved.variant,
     'normal',
-    { sessionId },
+    { sessionId, directory },
   );
 };
 
@@ -140,6 +143,7 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
   const queuedMessages = useMessageQueueStore((state) => state.queuedMessages);
   const autoReviewRuns = useAutoReviewStore((state) => state.runsByOriginalSessionID);
   const sessionStatusRecord = useDirectorySync((state) => state.session_status);
+  const currentDirectory = useDirectoryStore((state) => state.currentDirectory);
 
   const inFlightSessionsRef = React.useRef<Set<string>>(new Set());
   const sendFailuresRef = React.useRef<Map<string, QueuedAutoSendFailure>>(new Map());
@@ -151,11 +155,13 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
       return;
     }
 
-    const dispatchSessionQueue = async (sessionId: string, queueSnapshot: QueuedMessage[]) => {
+    const dispatchSessionQueue = async (target: MessageQueueTarget, queueSnapshot: QueuedMessage[]) => {
+      const { sessionId } = target;
+      const targetKey = getMessageQueueKey(target);
       if (queueSnapshot.length === 0) {
         return;
       }
-      if (inFlightSessionsRef.current.has(sessionId)) {
+      if (inFlightSessionsRef.current.has(targetKey)) {
         return;
       }
       if (hasRecentAbort(sessionId)) {
@@ -166,7 +172,7 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
         return;
       }
 
-      const currentStatus = getSyncSessionStatus(sessionId)?.type ?? 'idle';
+      const currentStatus = getDirectoryState(target.directory)?.session_status?.[sessionId]?.type ?? 'idle';
       if (currentStatus !== 'idle') {
         return;
       }
@@ -176,9 +182,9 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
         return;
       }
 
-      const failure = sendFailuresRef.current.get(sessionId);
+      const failure = sendFailuresRef.current.get(targetKey);
       if (failure && failure.messageId !== payload.queuedMessageId) {
-        sendFailuresRef.current.delete(sessionId);
+        sendFailuresRef.current.delete(targetKey);
       } else if (isQueuedAutoSendBackedOff(failure, payload.queuedMessageId, Date.now())) {
         return;
       }
@@ -192,28 +198,28 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
         return;
       }
 
-      inFlightSessionsRef.current.add(sessionId);
+      inFlightSessionsRef.current.add(targetKey);
 
       try {
-        await sendQueuedAutoSendPayload(sessionId, payload, {
+        await sendQueuedAutoSendPayload(sessionId, target.directory, payload, {
           providerID: resolved.providerID,
           modelID: resolved.modelID,
           agent: resolved.agent,
           variant: resolved.variant,
         });
-        useMessageQueueStore.getState().removeFromQueue(sessionId, payload.queuedMessageId);
-        sendFailuresRef.current.delete(sessionId);
+        useMessageQueueStore.getState().removeFromQueue(target, payload.queuedMessageId);
+        sendFailuresRef.current.delete(targetKey);
       } catch (error) {
         console.warn('[queue] queued auto-send failed:', error);
         const priorFailures = failure?.messageId === payload.queuedMessageId ? failure.failures : 0;
         const failures = priorFailures + 1;
-        sendFailuresRef.current.set(sessionId, {
+        sendFailuresRef.current.set(targetKey, {
           messageId: payload.queuedMessageId,
           failures,
           nextAttemptAt: Date.now() + getQueuedAutoSendRetryDelayMs(failures),
         });
       } finally {
-        inFlightSessionsRef.current.delete(sessionId);
+        inFlightSessionsRef.current.delete(targetKey);
       }
     };
 
@@ -226,7 +232,10 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
     }
 
     const queueEntries = Object.entries(queuedMessages);
-    queueEntries.forEach(([sessionId, queue]) => {
+    queueEntries.forEach(([key, queue]) => {
+      const target = parseMessageQueueKey(key);
+      if (!target || target.runtimeKey !== getRuntimeKey() || target.directory !== currentDirectory) return;
+      const { sessionId } = target;
       const currentStatusType = (statusRecord[sessionId]?.type ?? 'idle') as SessionStatusType;
       const previousStatusType = previousStatusRef.current.get(sessionId);
       const wasAutoReviewBlocked = autoReviewBlockedSessionsRef.current.has(sessionId);
@@ -241,12 +250,12 @@ export function useQueuedMessageAutoSend(enabledOrOptions?: boolean | { enabled?
         shouldDispatchQueuedAutoSend(previousStatusType, currentStatusType, queue.length > 0)
         || (wasAutoReviewBlocked && !isAutoReviewRunning && currentStatusType === 'idle')
       )) {
-        void dispatchSessionQueue(sessionId, queue);
+        void dispatchSessionQueue(target, queue);
       }
 
       nextStatusMap.set(sessionId, currentStatusType);
     });
 
     previousStatusRef.current = nextStatusMap;
-  }, [enabled, queuedMessages, sessionStatusRecord, autoReviewRuns]);
+  }, [enabled, queuedMessages, sessionStatusRecord, autoReviewRuns, currentDirectory]);
 }
diff --git a/packages/ui/src/hooks/useSessionAutoCleanup.ts b/packages/ui/src/hooks/useSessionAutoCleanup.ts
index 7ae8878a..97666e68 100644
--- a/packages/ui/src/hooks/useSessionAutoCleanup.ts
+++ b/packages/ui/src/hooks/useSessionAutoCleanup.ts
@@ -9,6 +9,7 @@ import { useUIStore } from '@/stores/useUIStore';
 const DAY_MS = 24 * 60 * 60 * 1000;
 const AUTO_DELETE_KEEP_RECENT = 5;
 const AUTO_DELETE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const EMPTY_SESSIONS: Session[] = [];
 
 const getSessionLastActivity = (session: Session): number => {
   return session.time?.updated ?? session.time?.created ?? 0;
@@ -71,14 +72,17 @@ export const useSessionAutoCleanup = (enabledOrOptions?: boolean | CleanupOption
 
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const isLoading = useSessionUIStore((state) => state.isLoading);
-  const globalSessions = useGlobalSessionsStore((state) => state.activeSessions);
-  const hasLoadedGlobalSessions = useGlobalSessionsStore((state) => state.hasLoaded);
-
   const autoDeleteEnabled = useUIStore((state) => state.autoDeleteEnabled);
   const autoDeleteAfterDays = useUIStore((state) => state.autoDeleteAfterDays);
   const sessionRetentionAction = useUIStore((state) => state.sessionRetentionAction);
   const autoDeleteLastRunAt = useUIStore((state) => state.autoDeleteLastRunAt);
   const setAutoDeleteLastRunAt = useUIStore((state) => state.setAutoDeleteLastRunAt);
+  const needsGlobalSessions = enabled && (!autoRun || autoDeleteEnabled);
+  const globalSessions = useGlobalSessionsStore(React.useCallback(
+    (state) => needsGlobalSessions ? state.activeSessions : EMPTY_SESSIONS,
+    [needsGlobalSessions],
+  ));
+  const hasLoadedGlobalSessions = useGlobalSessionsStore((state) => state.hasLoaded);
 
   const [isRunning, setIsRunning] = React.useState(false);
   const runningRef = React.useRef(false);
diff --git a/packages/ui/src/hooks/useTraySync.ts b/packages/ui/src/hooks/useTraySync.ts
index 25864f76..9b41c328 100644
--- a/packages/ui/src/hooks/useTraySync.ts
+++ b/packages/ui/src/hooks/useTraySync.ts
@@ -359,7 +359,7 @@ const buildSnapshot = (instanceName: string): TraySnapshot => {
   const resolveStatus = (id: string): TraySessionStatus => {
     const fromStores = live.statusById.get(id);
     if (fromStores && fromStores !== 'idle') return fromStores;
-    return globalStatusById.get(id)?.status ?? fromStores ?? 'idle';
+    return globalStatusById.get(id)?.status.type ?? fromStores ?? 'idle';
   };
 
   const rollupStatus = (family: string[]): TraySessionStatus => {
diff --git a/packages/ui/src/lib/chatDraftPersistence.test.ts b/packages/ui/src/lib/chatDraftPersistence.test.ts
new file mode 100644
index 00000000..ef1d9b83
--- /dev/null
+++ b/packages/ui/src/lib/chatDraftPersistence.test.ts
@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import {
+  clearChatDraft,
+  createChatDraftIdentity,
+  getChatDraftIdentityKey,
+  readChatDraft,
+  subscribeChatDraftDeletion,
+  writeChatDraft,
+} from './chatDraftPersistence';
+import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
+
+const storage = getDeferredSafeStorage();
+
+describe('chatDraftPersistence', () => {
+  beforeEach(() => {
+    storage.removeItem('openchamber.chatDrafts.v2');
+  });
+
+  test('isolates drafts by runtime, directory, and session', () => {
+    const first = createChatDraftIdentity('runtime-a', '/repo-a/', 'session-1')!;
+    const second = createChatDraftIdentity('runtime-b', '/repo-a', 'session-1')!;
+    const third = createChatDraftIdentity('runtime-a', '/repo-b', 'session-1')!;
+    writeChatDraft(first, 'first', ['file.ts']);
+    writeChatDraft(second, 'second', []);
+    writeChatDraft(third, 'third', []);
+
+    expect(readChatDraft(first)).toEqual({ text: 'first', confirmedMentions: new Set(['file.ts']) });
+    expect(readChatDraft(second).text).toBe('second');
+    expect(readChatDraft(third).text).toBe('third');
+  });
+
+  test('keeps new-session drafts separate from similarly named sessions', () => {
+    const newSession = createChatDraftIdentity('runtime-a', '/repo', null)!;
+    const namedSession = createChatDraftIdentity('runtime-a', '/repo', '__new__')!;
+
+    writeChatDraft(newSession, 'new session', []);
+    writeChatDraft(namedSession, 'named session', []);
+
+    expect(readChatDraft(newSession).text).toBe('new session');
+    expect(readChatDraft(namedSession).text).toBe('named session');
+  });
+
+  test('clears only the matching identity and notifies active composers', () => {
+    const deleted = createChatDraftIdentity('runtime-a', '/repo-a', 'session-1')!;
+    const retained = createChatDraftIdentity('runtime-a', '/repo-b', 'session-1')!;
+    const notifications: string[] = [];
+    const unsubscribe = subscribeChatDraftDeletion((identity) => notifications.push(identity.directory));
+    writeChatDraft(deleted, 'delete', []);
+    writeChatDraft(retained, 'retain', []);
+
+    clearChatDraft(deleted, true);
+    unsubscribe();
+
+    expect(readChatDraft(deleted).text).toBe('');
+    expect(readChatDraft(retained).text).toBe('retain');
+    expect(notifications).toEqual(['/repo-a']);
+  });
+
+  test('bounds persisted drafts by recency', () => {
+    for (let index = 0; index < 55; index += 1) {
+      const identity = createChatDraftIdentity('runtime-a', '/repo', `session-${index}`)!;
+      writeChatDraft(identity, `draft-${index}`, []);
+    }
+
+    const envelope = JSON.parse(storage.getItem('openchamber.chatDrafts.v2') ?? '{}') as { drafts?: object };
+    expect(Object.keys(envelope.drafts ?? {})).toHaveLength(50);
+  });
+
+  test('reuses a parsed envelope while the stored value is unchanged', () => {
+    const identity = createChatDraftIdentity('runtime-cache', '/repo', 'session-1')!;
+    const key = getChatDraftIdentityKey(identity);
+    storage.setItem('openchamber.chatDrafts.v2', JSON.stringify({
+      version: 2,
+      drafts: { [key]: { text: 'cached', confirmedMentions: [], touchedAt: 1 } },
+    }));
+    const originalParse = JSON.parse;
+    let parseCalls = 0;
+    JSON.parse = ((...args: Parameters<typeof JSON.parse>) => {
+      parseCalls += 1;
+      return originalParse(...args);
+    }) as typeof JSON.parse;
+
+    try {
+      expect(readChatDraft(identity).text).toBe('cached');
+      expect(readChatDraft(identity).text).toBe('cached');
+      expect(parseCalls).toBe(1);
+    } finally {
+      JSON.parse = originalParse;
+    }
+  });
+});
diff --git a/packages/ui/src/lib/chatDraftPersistence.ts b/packages/ui/src/lib/chatDraftPersistence.ts
new file mode 100644
index 00000000..684b61a4
--- /dev/null
+++ b/packages/ui/src/lib/chatDraftPersistence.ts
@@ -0,0 +1,125 @@
+import { normalizePath } from '@/lib/pathNormalization';
+import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
+import { countSyncPersistenceSerialization } from '@/sync/performance-diagnostics';
+
+export type ChatDraftIdentity = {
+  runtimeKey: string;
+  directory: string;
+  sessionId: string | null;
+};
+
+export type ChatDraftSnapshot = {
+  text: string;
+  confirmedMentions: Set<string>;
+};
+
+type PersistedChatDraft = {
+  text: string;
+  confirmedMentions: string[];
+  touchedAt: number;
+};
+
+type PersistedChatDraftEnvelope = {
+  version: 2;
+  drafts: Record<string, PersistedChatDraft>;
+};
+
+const STORAGE_KEY = 'openchamber.chatDrafts.v2';
+const MAX_DRAFTS = 50;
+const storage = getDeferredSafeStorage();
+const deletionListeners = new Set<(identity: ChatDraftIdentity) => void>();
+let cachedRawEnvelope: string | null | undefined;
+let cachedEnvelope: PersistedChatDraftEnvelope | undefined;
+
+export const createChatDraftIdentity = (
+  runtimeKey: string,
+  directory: string | null | undefined,
+  sessionId: string | null,
+): ChatDraftIdentity | null => {
+  const normalizedDirectory = normalizePath(directory);
+  if (!runtimeKey || !normalizedDirectory) return null;
+  return { runtimeKey, directory: normalizedDirectory, sessionId };
+};
+
+export const getChatDraftIdentityKey = (identity: ChatDraftIdentity): string =>
+  JSON.stringify([identity.runtimeKey, identity.directory, identity.sessionId]);
+
+const readEnvelope = (): PersistedChatDraftEnvelope => {
+  const raw = storage.getItem(STORAGE_KEY);
+  if (raw === cachedRawEnvelope && cachedEnvelope) return cachedEnvelope;
+  try {
+    const parsed = JSON.parse(raw ?? '') as Partial<PersistedChatDraftEnvelope>;
+    if (parsed.version !== 2 || !parsed.drafts || typeof parsed.drafts !== 'object' || Array.isArray(parsed.drafts)) {
+      cachedRawEnvelope = raw;
+      cachedEnvelope = { version: 2, drafts: {} };
+      return cachedEnvelope;
+    }
+    const drafts: Record<string, PersistedChatDraft> = {};
+    for (const [key, value] of Object.entries(parsed.drafts)) {
+      if (!value || typeof value !== 'object') continue;
+      const draft = value as Partial<PersistedChatDraft>;
+      if (typeof draft.text !== 'string' || !Array.isArray(draft.confirmedMentions) || typeof draft.touchedAt !== 'number') continue;
+      drafts[key] = {
+        text: draft.text,
+        confirmedMentions: draft.confirmedMentions.filter((mention): mention is string => typeof mention === 'string'),
+        touchedAt: draft.touchedAt,
+      };
+    }
+    cachedRawEnvelope = raw;
+    cachedEnvelope = { version: 2, drafts };
+    return cachedEnvelope;
+  } catch {
+    storage.removeItem(STORAGE_KEY);
+    cachedRawEnvelope = null;
+    cachedEnvelope = { version: 2, drafts: {} };
+    return cachedEnvelope;
+  }
+};
+
+const writeEnvelope = (envelope: PersistedChatDraftEnvelope): void => {
+  const serialized = JSON.stringify(envelope);
+  cachedRawEnvelope = serialized;
+  cachedEnvelope = envelope;
+  countSyncPersistenceSerialization(serialized);
+  storage.setItem(STORAGE_KEY, serialized);
+};
+
+export const readChatDraft = (identity: ChatDraftIdentity | null): ChatDraftSnapshot => {
+  if (!identity) return { text: '', confirmedMentions: new Set() };
+  const persisted = readEnvelope().drafts[getChatDraftIdentityKey(identity)];
+  return persisted
+    ? { text: persisted.text, confirmedMentions: new Set(persisted.confirmedMentions) }
+    : { text: '', confirmedMentions: new Set() };
+};
+
+export const writeChatDraft = (
+  identity: ChatDraftIdentity | null,
+  text: string,
+  confirmedMentions: Iterable<string>,
+): void => {
+  if (!identity) return;
+  const envelope = readEnvelope();
+  const key = getChatDraftIdentityKey(identity);
+  const mentions = Array.from(new Set(confirmedMentions));
+  if (!text && mentions.length === 0) {
+    if (!(key in envelope.drafts)) return;
+    delete envelope.drafts[key];
+  } else {
+    envelope.drafts[key] = { text, confirmedMentions: mentions, touchedAt: Date.now() };
+  }
+
+  const retained = Object.entries(envelope.drafts)
+    .sort((left, right) => right[1].touchedAt - left[1].touchedAt)
+    .slice(0, MAX_DRAFTS);
+  writeEnvelope({ version: 2, drafts: Object.fromEntries(retained) });
+};
+
+export const clearChatDraft = (identity: ChatDraftIdentity, notify = false): void => {
+  writeChatDraft(identity, '', []);
+  if (notify) deletionListeners.forEach((listener) => listener(identity));
+};
+
+export const subscribeChatDraftDeletion = (listener: (identity: ChatDraftIdentity) => void): (() => void) => {
+  deletionListeners.add(listener);
+  return () => deletionListeners.delete(listener);
+};
diff --git a/packages/ui/src/lib/gitApiHttp.ts b/packages/ui/src/lib/gitApiHttp.ts
index 04a0c449..4d8786c8 100644
--- a/packages/ui/src/lib/gitApiHttp.ts
+++ b/packages/ui/src/lib/gitApiHttp.ts
@@ -1,5 +1,3 @@
-
-
 import type {
   GitStatus,
   GitDiffResponse,
@@ -37,6 +35,7 @@ import type {
 } from './api/types';
 import { runtimeFetch } from './runtime-fetch';
 import { getRuntimeUrlResolver } from './runtime-url';
+import { getRuntimeKey } from './runtime-switch';
 
 const API_BASE = '/api/git';
 const GIT_STATUS_CACHE_TTL_MS = 1200;
@@ -48,24 +47,22 @@ const gitRepoCache = new Map<string, { value: boolean; expiresAt: number }>();
 const gitRepoInFlight = new Map<string, Promise<boolean>>();
 
 const normalizeDirectoryKey = (directory: string): string => directory.trim();
-const getStatusCacheKey = (directory: string, mode?: 'light'): string =>
-  mode === 'light' ? `${normalizeDirectoryKey(directory)}::light` : normalizeDirectoryKey(directory);
+const getDirectoryCacheKey = (runtimeKey: string, directory: string): string =>
+  JSON.stringify([runtimeKey, normalizeDirectoryKey(directory)]);
+const getStatusCacheKey = (runtimeKey: string, directory: string, mode?: 'light'): string =>
+  JSON.stringify([runtimeKey, normalizeDirectoryKey(directory), mode ?? 'full']);
 
-const getStatusCacheVersion = (directory: string): number =>
-  gitStatusCacheVersions.get(normalizeDirectoryKey(directory)) ?? 0;
+const getStatusCacheVersion = (runtimeKey: string, directory: string): number =>
+  gitStatusCacheVersions.get(getDirectoryCacheKey(runtimeKey, directory)) ?? 0;
 
 const invalidateGitStatusCache = (directory: string): void => {
-  const key = normalizeDirectoryKey(directory);
-  gitStatusCacheVersions.set(key, getStatusCacheVersion(directory) + 1);
-  for (const cacheKey of Array.from(gitStatusCache.keys())) {
-    if (cacheKey === key || cacheKey.startsWith(`${key}::`)) {
-      gitStatusCache.delete(cacheKey);
-    }
-  }
-  for (const cacheKey of Array.from(gitStatusInFlight.keys())) {
-    if (cacheKey === key || cacheKey.startsWith(`${key}::`)) {
-      gitStatusInFlight.delete(cacheKey);
-    }
+  const runtimeKey = getRuntimeKey();
+  const key = getDirectoryCacheKey(runtimeKey, directory);
+  gitStatusCacheVersions.set(key, getStatusCacheVersion(runtimeKey, directory) + 1);
+  for (const mode of [undefined, 'light'] as const) {
+    const statusKey = getStatusCacheKey(runtimeKey, directory, mode);
+    gitStatusCache.delete(statusKey);
+    gitStatusInFlight.delete(statusKey);
   }
 };
 
@@ -81,7 +78,7 @@ function buildUrl(
 }
 
 export async function checkIsGitRepository(directory: string): Promise<boolean> {
-  const key = normalizeDirectoryKey(directory);
+  const key = getDirectoryCacheKey(getRuntimeKey(), directory);
   const now = Date.now();
   const cached = gitRepoCache.get(key);
   if (cached && cached.expiresAt > now) {
@@ -119,7 +116,8 @@ export async function checkIsGitRepository(directory: string): Promise<boolean>
 
 export async function getGitStatus(directory: string, options?: { mode?: 'light' }): Promise<GitStatus> {
   const mode = options?.mode;
-  const key = getStatusCacheKey(directory, mode);
+  const runtimeKey = getRuntimeKey();
+  const key = getStatusCacheKey(runtimeKey, directory, mode);
   const now = Date.now();
   const cached = gitStatusCache.get(key);
   if (cached && cached.expiresAt > now) {
@@ -132,13 +130,13 @@ export async function getGitStatus(directory: string, options?: { mode?: 'light'
   }
 
   const task = (async () => {
-    const cacheVersion = getStatusCacheVersion(directory);
+    const cacheVersion = getStatusCacheVersion(runtimeKey, directory);
     const response = await runtimeFetch(buildUrl(`${API_BASE}/status`, directory, mode ? { mode } : undefined));
     if (!response.ok) {
       throw new Error(`Failed to get git status: ${response.statusText}`);
     }
     const payload = await response.json() as GitStatus;
-    if (getStatusCacheVersion(directory) === cacheVersion) {
+    if (getStatusCacheVersion(runtimeKey, directory) === cacheVersion) {
       gitStatusCache.set(key, {
         value: payload,
         expiresAt: Date.now() + GIT_STATUS_CACHE_TTL_MS,
diff --git a/packages/ui/src/lib/i18n/messages/en.ts b/packages/ui/src/lib/i18n/messages/en.ts
index 00dd6225..83036ff8 100644
--- a/packages/ui/src/lib/i18n/messages/en.ts
+++ b/packages/ui/src/lib/i18n/messages/en.ts
@@ -1860,6 +1860,12 @@ export const dict = {
   'chat.container.returnToParent.title': 'Return to parent session',
   'chat.container.returnToParent.label': 'Parent',
   'chat.container.readOnlySubagentPromptBanner': 'Subagent sessions cannot be prompted.',
+  'chat.container.sessionLoadError.title': 'Session could not be loaded',
+  'chat.container.sessionLoadError.description': 'Check the connection and try loading this session again.',
+  'chat.container.sessionLoadError.retry': 'Try again',
+  'sessions.sidebar.group.empty.loadingSessions': 'Loading sessions…',
+  'sessions.sidebar.group.empty.loadFailed': 'Could not refresh sessions.',
+  'sessions.sidebar.group.empty.retry': 'Try again',
   'chat.unifiedControls.title': 'Controls',
   'chat.unifiedControls.model.title': 'Model',
   'chat.unifiedControls.model.noRecent': 'No recent models',
diff --git a/packages/ui/src/lib/i18n/messages/es.ts b/packages/ui/src/lib/i18n/messages/es.ts
index abcade0c..a888528a 100644
--- a/packages/ui/src/lib/i18n/messages/es.ts
+++ b/packages/ui/src/lib/i18n/messages/es.ts
@@ -1838,6 +1838,12 @@ export const dict: Record<I18nKey, string> = {
   "chat.container.returnToParent.title": "Volver a la sesión principal",
   "chat.container.returnToParent.label": "Principal",
   "chat.container.readOnlySubagentPromptBanner": "Las sesiones de subagentes no pueden recibir prompts.",
+  "chat.container.sessionLoadError.title": "No se pudo cargar la sesión",
+  "chat.container.sessionLoadError.description": "Comprueba la conexión e intenta cargar esta sesión de nuevo.",
+  "chat.container.sessionLoadError.retry": "Reintentar",
+  "sessions.sidebar.group.empty.loadingSessions": "Cargando sesiones…",
+  "sessions.sidebar.group.empty.loadFailed": "No se pudieron actualizar las sesiones.",
+  "sessions.sidebar.group.empty.retry": "Reintentar",
   "chat.unifiedControls.title": "Controles",
   "chat.unifiedControls.model.title": "Modelo",
   "chat.unifiedControls.model.noRecent": "No hay modelos recientes",
diff --git a/packages/ui/src/lib/i18n/messages/fr.ts b/packages/ui/src/lib/i18n/messages/fr.ts
index 3dc56279..f8f6ccdb 100644
--- a/packages/ui/src/lib/i18n/messages/fr.ts
+++ b/packages/ui/src/lib/i18n/messages/fr.ts
@@ -1656,6 +1656,12 @@ export const dict = {
   'chat.container.returnToParent.title': 'Retour à la session parents',
   'chat.container.returnToParent.label': 'Mère',
   'chat.container.readOnlySubagentPromptBanner': 'Les sessions de sous-agent ne peuvent pas être invitées.',
+  'chat.container.sessionLoadError.title': 'Impossible de charger la session',
+  'chat.container.sessionLoadError.description': 'Vérifiez la connexion et essayez de charger à nouveau cette session.',
+  'chat.container.sessionLoadError.retry': 'Réessayer',
+  'sessions.sidebar.group.empty.loadingSessions': 'Chargement des sessions…',
+  'sessions.sidebar.group.empty.loadFailed': 'Impossible d’actualiser les sessions.',
+  'sessions.sidebar.group.empty.retry': 'Réessayer',
   'chat.unifiedControls.title': 'Contrôles',
   'chat.unifiedControls.model.title': 'Modèle',
   'chat.unifiedControls.model.noRecent': 'Aucun modèle récent',
diff --git a/packages/ui/src/lib/i18n/messages/ja.ts b/packages/ui/src/lib/i18n/messages/ja.ts
index a62bda58..11e921e5 100644
--- a/packages/ui/src/lib/i18n/messages/ja.ts
+++ b/packages/ui/src/lib/i18n/messages/ja.ts
@@ -1856,6 +1856,12 @@ export const dict: Record<I18nKey, string> = {
   'chat.container.returnToParent.title': '親セッションに戻る',
   'chat.container.returnToParent.label': '親',
   'chat.container.readOnlySubagentPromptBanner': 'サブエージェントセッションはプロンプトを受け付けません。',
+  'chat.container.sessionLoadError.title': 'セッションを読み込めませんでした',
+  'chat.container.sessionLoadError.description': '接続を確認して、このセッションをもう一度読み込んでください。',
+  'chat.container.sessionLoadError.retry': '再試行',
+  'sessions.sidebar.group.empty.loadingSessions': 'セッションを読み込んでいます…',
+  'sessions.sidebar.group.empty.loadFailed': 'セッションを更新できませんでした。',
+  'sessions.sidebar.group.empty.retry': '再試行',
   'chat.unifiedControls.title': 'コントロール',
   'chat.unifiedControls.model.title': 'モデル',
   'chat.unifiedControls.model.noRecent': '最近のモデルはありません',
diff --git a/packages/ui/src/lib/i18n/messages/ko.ts b/packages/ui/src/lib/i18n/messages/ko.ts
index e5c2ea4d..e238234b 100644
--- a/packages/ui/src/lib/i18n/messages/ko.ts
+++ b/packages/ui/src/lib/i18n/messages/ko.ts
@@ -1862,6 +1862,12 @@ export const dict: Record<I18nKey, string> = {
   'chat.container.returnToParent.title': '상위 세션으로 돌아가기',
   'chat.container.returnToParent.label': '상위',
   'chat.container.readOnlySubagentPromptBanner': '하위 에이전트 세션에는 프롬프트를 보낼 수 없습니다.',
+  'chat.container.sessionLoadError.title': '세션을 불러올 수 없습니다',
+  'chat.container.sessionLoadError.description': '연결을 확인한 후 이 세션을 다시 불러오세요.',
+  'chat.container.sessionLoadError.retry': '다시 시도',
+  'sessions.sidebar.group.empty.loadingSessions': '세션을 불러오는 중…',
+  'sessions.sidebar.group.empty.loadFailed': '세션을 새로 고칠 수 없습니다.',
+  'sessions.sidebar.group.empty.retry': '다시 시도',
   'chat.unifiedControls.title': '컨트롤',
   'chat.unifiedControls.model.title': '모델',
   'chat.unifiedControls.model.noRecent': '최근 모델 없음',
diff --git a/packages/ui/src/lib/i18n/messages/pl.ts b/packages/ui/src/lib/i18n/messages/pl.ts
index 13b8f78c..86bbbeff 100644
--- a/packages/ui/src/lib/i18n/messages/pl.ts
+++ b/packages/ui/src/lib/i18n/messages/pl.ts
@@ -749,6 +749,12 @@ export const dict: Record<I18nKey, string> = {
   'chat.container.returnToParent.title': 'Powrót do sesji nadrzędnej',
   'chat.container.returnToParent.label': 'Nadrzędna',
   'chat.container.readOnlySubagentPromptBanner': 'Sesje podagentów nie mogą otrzymywać promptów.',
+  'chat.container.sessionLoadError.title': 'Nie udało się wczytać sesji',
+  'chat.container.sessionLoadError.description': 'Sprawdź połączenie i spróbuj ponownie wczytać tę sesję.',
+  'chat.container.sessionLoadError.retry': 'Spróbuj ponownie',
+  'sessions.sidebar.group.empty.loadingSessions': 'Wczytywanie sesji…',
+  'sessions.sidebar.group.empty.loadFailed': 'Nie udało się odświeżyć sesji.',
+  'sessions.sidebar.group.empty.retry': 'Spróbuj ponownie',
   'chat.unifiedControls.title': 'Kontrolki',
   'chat.unifiedControls.model.title': 'Model',
   'chat.unifiedControls.model.noRecent': 'Brak ostatnich modeli',
diff --git a/packages/ui/src/lib/i18n/messages/pt-BR.ts b/packages/ui/src/lib/i18n/messages/pt-BR.ts
index 65400be9..eedfb214 100644
--- a/packages/ui/src/lib/i18n/messages/pt-BR.ts
+++ b/packages/ui/src/lib/i18n/messages/pt-BR.ts
@@ -1838,6 +1838,12 @@ export const dict: Record<I18nKey, string> = {
   "chat.container.returnToParent.title": "Voltar para a sessão principal",
   "chat.container.returnToParent.label": "Principal",
   "chat.container.readOnlySubagentPromptBanner": "Sessões de subagente não podem receber prompts.",
+  "chat.container.sessionLoadError.title": "Não foi possível carregar a sessão",
+  "chat.container.sessionLoadError.description": "Verifique a conexão e tente carregar esta sessão novamente.",
+  "chat.container.sessionLoadError.retry": "Tentar novamente",
+  "sessions.sidebar.group.empty.loadingSessions": "Carregando sessões…",
+  "sessions.sidebar.group.empty.loadFailed": "Não foi possível atualizar as sessões.",
+  "sessions.sidebar.group.empty.retry": "Tentar novamente",
   "chat.unifiedControls.title": "Controles",
   "chat.unifiedControls.model.title": "Modelo",
   "chat.unifiedControls.model.noRecent": "Não há modelos recentes",
diff --git a/packages/ui/src/lib/i18n/messages/uk.ts b/packages/ui/src/lib/i18n/messages/uk.ts
index 22c3251d..74aaf9c5 100644
--- a/packages/ui/src/lib/i18n/messages/uk.ts
+++ b/packages/ui/src/lib/i18n/messages/uk.ts
@@ -1838,6 +1838,12 @@ export const dict: Record<I18nKey, string> = {
   "chat.container.returnToParent.title": "Повернутися до батьківської сесії",
   "chat.container.returnToParent.label": "Батьківська",
   "chat.container.readOnlySubagentPromptBanner": "Сесії субагентів не можна запитувати.",
+  "chat.container.sessionLoadError.title": "Не вдалося завантажити сесію",
+  "chat.container.sessionLoadError.description": "Перевірте з’єднання та спробуйте завантажити цю сесію ще раз.",
+  "chat.container.sessionLoadError.retry": "Спробувати знову",
+  "sessions.sidebar.group.empty.loadingSessions": "Завантаження сесій…",
+  "sessions.sidebar.group.empty.loadFailed": "Не вдалося оновити сесії.",
+  "sessions.sidebar.group.empty.retry": "Спробувати знову",
   "chat.unifiedControls.title": "Елементи керування",
   "chat.unifiedControls.model.title": "Модель",
   "chat.unifiedControls.model.noRecent": "Немає останніх моделей",
diff --git a/packages/ui/src/lib/i18n/messages/zh-CN.ts b/packages/ui/src/lib/i18n/messages/zh-CN.ts
index 8d24a202..0926edc8 100644
--- a/packages/ui/src/lib/i18n/messages/zh-CN.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-CN.ts
@@ -1826,6 +1826,12 @@ export const dict: Record<I18nKey, string> = {
   'chat.container.returnToParent.title': '返回父会话',
   'chat.container.returnToParent.label': '父级',
   'chat.container.readOnlySubagentPromptBanner': '无法向子智能体会话发送提示。',
+  'chat.container.sessionLoadError.title': '无法加载会话',
+  'chat.container.sessionLoadError.description': '请检查连接，然后重新加载此会话。',
+  'chat.container.sessionLoadError.retry': '重试',
+  'sessions.sidebar.group.empty.loadingSessions': '正在加载会话…',
+  'sessions.sidebar.group.empty.loadFailed': '无法刷新会话。',
+  'sessions.sidebar.group.empty.retry': '重试',
   'chat.unifiedControls.title': '控制',
   'chat.unifiedControls.model.title': '模型',
   'chat.unifiedControls.model.noRecent': '没有最近使用的模型',
diff --git a/packages/ui/src/lib/i18n/messages/zh-TW.ts b/packages/ui/src/lib/i18n/messages/zh-TW.ts
index cb38d4b4..10d19522 100644
--- a/packages/ui/src/lib/i18n/messages/zh-TW.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-TW.ts
@@ -1830,6 +1830,12 @@ export const dict: Record<I18nKey, string> = {
   'chat.container.returnToParent.title': '返回父會話',
   'chat.container.returnToParent.label': '父級',
   'chat.container.readOnlySubagentPromptBanner': '無法向子 Agent 會話傳送提示。',
+  'chat.container.sessionLoadError.title': '無法載入工作階段',
+  'chat.container.sessionLoadError.description': '請檢查連線，然後重新載入此工作階段。',
+  'chat.container.sessionLoadError.retry': '再試一次',
+  'sessions.sidebar.group.empty.loadingSessions': '正在載入工作階段…',
+  'sessions.sidebar.group.empty.loadFailed': '無法重新整理工作階段。',
+  'sessions.sidebar.group.empty.retry': '再試一次',
   'chat.unifiedControls.title': '控制',
   'chat.unifiedControls.model.title': '模型',
   'chat.unifiedControls.model.noRecent': '沒有最近使用的模型',
diff --git a/packages/ui/src/lib/modelPrefsAutoSave.ts b/packages/ui/src/lib/modelPrefsAutoSave.ts
index 130f5253..bef31d31 100644
--- a/packages/ui/src/lib/modelPrefsAutoSave.ts
+++ b/packages/ui/src/lib/modelPrefsAutoSave.ts
@@ -1,5 +1,6 @@
 import { useUIStore } from '@/stores/useUIStore';
 import { updateDesktopSettings } from '@/lib/persistence';
+import { getRuntimeKey, subscribeRuntimeEndpointWillChange } from '@/lib/runtime-switch';
 
 type ModelRef = { providerID: string; modelID: string };
 type ModelPrefsPayload = {
@@ -75,9 +76,13 @@ export const startModelPrefsAutoSave = () => {
   let timer: number | null = null;
   let lastSent: ModelPrefsPayload | null = null;
   let didSkipInitial = false;
+  let scheduledRuntimeKey: string | null = null;
 
   const flush = () => {
     timer = null;
+    const runtimeKey = scheduledRuntimeKey;
+    scheduledRuntimeKey = null;
+    if (!runtimeKey || runtimeKey !== getRuntimeKey()) return;
     const payload = snapshotModelPrefs();
 
     if (lastSent && modelPrefsEqual(lastSent, payload)) {
@@ -97,9 +102,17 @@ export const startModelPrefsAutoSave = () => {
     if (timer !== null) {
       window.clearTimeout(timer);
     }
+    scheduledRuntimeKey = getRuntimeKey();
     timer = window.setTimeout(flush, 1200);
   };
 
+  const unsubscribeRuntime = subscribeRuntimeEndpointWillChange(() => {
+    if (timer !== null) window.clearTimeout(timer);
+    timer = null;
+    scheduledRuntimeKey = null;
+    lastSent = null;
+  });
+
   const unsubscribe = useUIStore.subscribe((state, prevState) => {
     const next = {
       favoriteModels: state.favoriteModels,
@@ -125,6 +138,7 @@ export const startModelPrefsAutoSave = () => {
 
   return () => {
     unsubscribe();
+    unsubscribeRuntime();
     if (timer !== null) {
       window.clearTimeout(timer);
     }
diff --git a/packages/ui/src/lib/opencode/provider-tracker.test.ts b/packages/ui/src/lib/opencode/provider-tracker.test.ts
new file mode 100644
index 00000000..d9a85492
--- /dev/null
+++ b/packages/ui/src/lib/opencode/provider-tracker.test.ts
@@ -0,0 +1,18 @@
+import { expect, mock, test } from "bun:test"
+
+let runtimeKey = "runtime-a"
+mock.module("@/lib/runtime-switch", () => ({ getRuntimeKey: () => runtimeKey }))
+
+const { assertProviderCircuitClosed, recordProviderError, recordProviderSuccess } = await import("./provider-tracker")
+
+test("isolates provider circuit state by runtime", () => {
+  for (let attempt = 0; attempt < 3; attempt += 1) recordProviderError("provider", 503)
+  expect(() => assertProviderCircuitClosed("provider")).toThrow()
+
+  runtimeKey = "runtime-b"
+  assertProviderCircuitClosed("provider")
+
+  runtimeKey = "runtime-a"
+  recordProviderSuccess("provider")
+  assertProviderCircuitClosed("provider")
+})
diff --git a/packages/ui/src/lib/opencode/provider-tracker.ts b/packages/ui/src/lib/opencode/provider-tracker.ts
index 5f613fb5..0cc9e761 100644
--- a/packages/ui/src/lib/opencode/provider-tracker.ts
+++ b/packages/ui/src/lib/opencode/provider-tracker.ts
@@ -8,6 +8,8 @@
  * Inspired by HiveMind (arXiv:2604.17111) OS-inspired scheduling primitives.
  */
 
+import { getRuntimeKey } from '@/lib/runtime-switch'
+
 const DEFAULT_CIRCUIT_BREAK_THRESHOLD = 3
 const DEFAULT_CIRCUIT_COOLDOWN_MS = 30_000
 const DEFAULT_RETRY_BASE_DELAY_MS = 1000
@@ -15,6 +17,7 @@ const DEFAULT_RETRY_MAX_DELAY_MS = 32_000
 const DEFAULT_RETRY_MAX_ATTEMPTS = 3
 const PROVIDER_EVICTION_TTL_MS = 60 * 60 * 1000
 const PROVIDER_EVICTION_INTERVAL_MS = 10 * 60 * 1000
+const PROVIDER_MAX_ENTRIES = 200
 
 const RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504])
 
@@ -27,15 +30,14 @@ type ProviderState = {
 }
 
 const providers = new Map<string, ProviderState>()
+const providerKey = (providerID: string): string => JSON.stringify([getRuntimeKey(), providerID])
 
 function evictStaleProviders(): void {
   const now = Date.now()
-  for (const [providerID, state] of providers) {
-    if (
-      state.consecutiveErrors === 0 &&
-      now - state.lastErrorAt > PROVIDER_EVICTION_TTL_MS
-    ) {
-      providers.delete(providerID)
+  for (const [key, state] of providers) {
+    const lastActivityAt = Math.max(state.lastErrorAt, state.circuitOpenAt)
+    if (now - lastActivityAt > PROVIDER_EVICTION_TTL_MS) {
+      providers.delete(key)
     }
   }
 }
@@ -46,7 +48,8 @@ if (typeof setInterval !== 'undefined') {
 }
 
 function getOrCreateProvider(providerID: string): ProviderState {
-  let state = providers.get(providerID)
+  const key = providerKey(providerID)
+  let state = providers.get(key)
   if (!state) {
     state = {
       consecutiveErrors: 0,
@@ -55,17 +58,19 @@ function getOrCreateProvider(providerID: string): ProviderState {
       circuitOpenAt: 0,
       circuitCooldownMs: DEFAULT_CIRCUIT_COOLDOWN_MS,
     }
-    providers.set(providerID, state)
+    providers.set(key, state)
+    while (providers.size > PROVIDER_MAX_ENTRIES) {
+      const oldest = providers.keys().next().value
+      if (!oldest) break
+      providers.delete(oldest)
+    }
   }
   return state
 }
 
 export function recordProviderSuccess(providerID: string): void {
   if (!providerID) return
-  const state = providers.get(providerID)
-  if (!state) return
-  state.consecutiveErrors = 0
-  state.lastErrorAt = 0
+  providers.delete(providerKey(providerID))
 }
 
 export function recordProviderError(providerID: string, status?: number): void {
@@ -91,7 +96,7 @@ function isCircuitBreakerStatus(status?: number): boolean {
 }
 
 function isCircuitOpen(providerID: string): boolean {
-  const state = providers.get(providerID)
+  const state = providers.get(providerKey(providerID))
   if (!state?.circuitOpen) return false
 
   const elapsed = Date.now() - state.circuitOpenAt
diff --git a/packages/ui/src/lib/persistence.test.ts b/packages/ui/src/lib/persistence.test.ts
index bca2a9ac..ec960d40 100644
--- a/packages/ui/src/lib/persistence.test.ts
+++ b/packages/ui/src/lib/persistence.test.ts
@@ -5,8 +5,10 @@ import { registerRuntimeAPIs } from '@/contexts/runtimeAPIRegistry';
 import { startModelPrefsAutoSave } from '@/lib/modelPrefsAutoSave';
 import { startAppearanceAutoSave } from '@/lib/appearanceAutoSave';
 import { useUIStore } from '@/stores/useUIStore';
+import { useMessageQueueStore } from '@/stores/messageQueueStore';
 import {
   applyPersistedHomeDirectoryToWindow,
+  getRuntimeSettingsMirrorStorageKey,
   getSettingsSaveState,
   invalidateSettingsCache,
   subscribeToSettingsSaveState,
@@ -315,6 +317,88 @@ describe('updateDesktopSettings', () => {
     expect(useUIStore.getState().terminalShell).toBe('bash');
   });
 
+  test('isolates local settings mirrors and removes values omitted by the next runtime', async () => {
+    getWindow();
+    localStorage.clear();
+    switchRuntimeEndpoint({ apiBaseUrl: 'https://mirror-a.example', runtimeKey: 'mirror-a' });
+    registerSettingsApi(async () => ({}), async () => ({
+      settings: {
+        themeId: 'theme-a',
+        directoryShowHidden: true,
+        sttModel: 'model-a',
+        draftStartersCraftGoalAdded: true,
+      },
+      source: 'web',
+    }));
+    await syncDesktopSettings();
+
+    switchRuntimeEndpoint({ apiBaseUrl: 'https://mirror-b.example', runtimeKey: 'mirror-b' });
+    registerSettingsApi(async () => ({}), async () => ({
+      settings: { draftStartersCraftGoalAdded: true },
+      source: 'web',
+    }));
+    await syncDesktopSettings();
+
+    expect(localStorage.getItem('selectedThemeId')).toBeNull();
+    expect(localStorage.getItem('directoryTreeShowHidden')).toBeNull();
+    expect(localStorage.getItem('sttModel')).toBeNull();
+    expect(JSON.parse(localStorage.getItem(getRuntimeSettingsMirrorStorageKey('mirror-a')) ?? '{}')).toEqual({
+      themeId: 'theme-a',
+      directoryShowHidden: true,
+      sttModel: 'model-a',
+    });
+    expect(JSON.parse(localStorage.getItem(getRuntimeSettingsMirrorStorageKey('mirror-b')) ?? '{}')).toEqual({});
+  });
+
+  test('resets in-memory preferences omitted by an authoritative runtime snapshot', async () => {
+    getWindow();
+    switchRuntimeEndpoint({ apiBaseUrl: 'https://preferences-a.example', runtimeKey: 'preferences-a' });
+    registerSettingsApi(async () => ({}), async () => ({
+      settings: {
+        showReasoningTraces: false,
+        terminalShell: 'fish',
+        favoriteModels: [{ providerID: 'anthropic', modelID: 'claude-sonnet-4' }],
+        followUpBehavior: 'steer',
+        draftStarters: [{ type: 'command', name: 'runtime-a' }],
+        draftStartersCraftGoalAdded: true,
+      },
+      source: 'web',
+    }));
+    await syncDesktopSettings();
+
+    expect(useUIStore.getState().showReasoningTraces).toBe(false);
+    expect(useUIStore.getState().terminalShell).toBe('fish');
+    expect(useUIStore.getState().favoriteModels).toHaveLength(1);
+    expect(useUIStore.getState().globalDraftStarters).toEqual([{ type: 'command', name: 'runtime-a' }]);
+    expect(useMessageQueueStore.getState().followUpBehavior).toBe('steer');
+
+    switchRuntimeEndpoint({ apiBaseUrl: 'https://preferences-b.example', runtimeKey: 'preferences-b' });
+    registerSettingsApi(async () => ({}), async () => ({
+      settings: { draftStartersCraftGoalAdded: true },
+      source: 'web',
+    }));
+    await syncDesktopSettings();
+
+    expect(useUIStore.getState().showReasoningTraces).toBe(true);
+    expect(useUIStore.getState().terminalShell).toBe('auto');
+    expect(useUIStore.getState().favoriteModels).toEqual([]);
+    expect(useUIStore.getState().globalDraftStarters).toBeNull();
+    expect(useMessageQueueStore.getState().followUpBehavior).toBe('queue');
+  });
+
+  test('treats settings save responses as partial patches', async () => {
+    getWindow();
+    localStorage.setItem('selectedThemeId', 'existing-theme');
+    useUIStore.getState().setTerminalShell('fish');
+    registerSettingsSave(async () => ({ showReasoningTraces: false }));
+
+    await updateDesktopSettings({ showReasoningTraces: false });
+
+    expect(useUIStore.getState().showReasoningTraces).toBe(false);
+    expect(useUIStore.getState().terminalShell).toBe('fish');
+    expect(localStorage.getItem('selectedThemeId')).toBe('existing-theme');
+  });
+
   test('applies model selector settings from server settings', async () => {
     getWindow();
     const settings = {
diff --git a/packages/ui/src/lib/persistence.ts b/packages/ui/src/lib/persistence.ts
index f4b9e152..38744b7c 100644
--- a/packages/ui/src/lib/persistence.ts
+++ b/packages/ui/src/lib/persistence.ts
@@ -2,7 +2,13 @@ import type { DesktopSettings } from '@/lib/desktop';
 import { createProjectIdFromPath } from '@/lib/projectId';
 import { useUIStore } from '@/stores/useUIStore';
 import { isMonoFontOption, isUiFontOption } from '@/lib/fontOptions';
-import { isFollowUpBehavior, normalizeFollowUpBehavior, useMessageQueueStore, type FollowUpBehavior } from '@/stores/messageQueueStore';
+import {
+  DEFAULT_FOLLOW_UP_BEHAVIOR,
+  isFollowUpBehavior,
+  normalizeFollowUpBehavior,
+  useMessageQueueStore,
+  type FollowUpBehavior,
+} from '@/stores/messageQueueStore';
 import { setDirectoryShowHidden } from '@/lib/directoryShowHidden';
 import { setFilesViewShowGitignored } from '@/lib/filesViewShowGitignored';
 import { loadAppearancePreferences, applyAppearancePreferences } from '@/lib/appearancePersistence';
@@ -12,6 +18,8 @@ import { normalizeMobileKeyboardMode, setStoredMobileKeyboardMode } from '@/lib/
 import { runtimeFetch } from '@/lib/runtime-fetch';
 import { isTerminalShell } from '@/lib/terminalShell';
 import { getRuntimeKey, subscribeRuntimeEndpointChanged, subscribeRuntimeEndpointWillChange } from '@/lib/runtime-switch';
+import { DEFAULT_DARK_THEME_ID, DEFAULT_LIGHT_THEME_ID } from '@/lib/theme/themes';
+import { DEFAULT_OPEN_IN_APP_ID } from '@/lib/openInApps';
 
 export const applyPersistedHomeDirectoryToWindow = (homeDirectory: string): void => {
   if (typeof window === 'undefined') {
@@ -28,32 +36,80 @@ export const applyPersistedHomeDirectoryToWindow = (homeDirectory: string): void
   }
 };
 
+const SETTINGS_MIRROR_INDEX_KEY = 'openchamber.settingsMirror.v2.index';
+const SETTINGS_MIRROR_KEY_PREFIX = 'openchamber.settingsMirror.v2:';
+const MAX_SETTINGS_MIRROR_RUNTIMES = 5;
+
+export const getRuntimeSettingsMirrorStorageKey = (runtimeKey: string): string =>
+  `${SETTINGS_MIRROR_KEY_PREFIX}${encodeURIComponent(runtimeKey)}`;
+
+const setOrRemoveLocalStorage = (key: string, value: string | null): void => {
+  if (value === null) {
+    localStorage.removeItem(key);
+  } else {
+    localStorage.setItem(key, value);
+  }
+};
+
+const persistRuntimeSettingsMirror = (settings: DesktopSettings, runtimeKey: string): void => {
+  const mirror = {
+    themeId: settings.themeId,
+    themeVariant: settings.themeVariant,
+    lightThemeId: settings.lightThemeId,
+    darkThemeId: settings.darkThemeId,
+    useSystemTheme: settings.useSystemTheme,
+    lastDirectory: settings.lastDirectory,
+    homeDirectory: settings.homeDirectory,
+    projects: settings.projects,
+    activeProjectId: settings.activeProjectId,
+    pinnedDirectories: settings.pinnedDirectories,
+    gitmojiEnabled: settings.gitmojiEnabled,
+    directoryShowHidden: settings.directoryShowHidden,
+    filesViewShowGitignored: settings.filesViewShowGitignored,
+    openInAppId: settings.openInAppId,
+    pwaAppName: settings.pwaAppName,
+    mobileKeyboardMode: settings.mobileKeyboardMode,
+    openCodeUpdateToastDismissedVersion: settings.openCodeUpdateToastDismissedVersion,
+    dictationEnabled: settings.dictationEnabled,
+    sttProvider: settings.sttProvider,
+    sttServerUrl: settings.sttServerUrl,
+    sttModel: settings.sttModel,
+    sttLocalModel: settings.sttLocalModel,
+    sttLanguage: settings.sttLanguage,
+  };
+  localStorage.setItem(getRuntimeSettingsMirrorStorageKey(runtimeKey), JSON.stringify(mirror));
+
+  let previous: string[] = [];
+  try {
+    const parsed = JSON.parse(localStorage.getItem(SETTINGS_MIRROR_INDEX_KEY) ?? '[]') as unknown;
+    if (Array.isArray(parsed)) previous = parsed.filter((entry): entry is string => typeof entry === 'string');
+  } catch {
+    previous = [];
+  }
+  const runtimes = [runtimeKey, ...previous.filter((entry) => entry !== runtimeKey)].slice(0, MAX_SETTINGS_MIRROR_RUNTIMES);
+  for (const staleRuntime of previous) {
+    if (!runtimes.includes(staleRuntime)) localStorage.removeItem(getRuntimeSettingsMirrorStorageKey(staleRuntime));
+  }
+  localStorage.setItem(SETTINGS_MIRROR_INDEX_KEY, JSON.stringify(runtimes));
+};
+
 const persistToLocalStorage = (settings: DesktopSettings) => {
   if (typeof window === 'undefined') {
     return;
   }
 
-  if (settings.themeId) {
-    localStorage.setItem('selectedThemeId', settings.themeId);
-  }
-  if (settings.themeVariant) {
-    localStorage.setItem('selectedThemeVariant', settings.themeVariant);
-  }
-  if (settings.lightThemeId) {
-    localStorage.setItem('lightThemeId', settings.lightThemeId);
-  }
-  if (settings.darkThemeId) {
-    localStorage.setItem('darkThemeId', settings.darkThemeId);
-  }
-  if (typeof settings.useSystemTheme === 'boolean') {
-    localStorage.setItem('useSystemTheme', String(settings.useSystemTheme));
-  }
-  if (settings.lastDirectory) {
-    localStorage.setItem('lastDirectory', settings.lastDirectory);
-  }
+  persistRuntimeSettingsMirror(settings, getRuntimeKey());
+  setOrRemoveLocalStorage('selectedThemeId', settings.themeId || null);
+  setOrRemoveLocalStorage('selectedThemeVariant', settings.themeVariant || null);
+  setOrRemoveLocalStorage('lightThemeId', settings.lightThemeId || null);
+  setOrRemoveLocalStorage('darkThemeId', settings.darkThemeId || null);
+  setOrRemoveLocalStorage('useSystemTheme', typeof settings.useSystemTheme === 'boolean' ? String(settings.useSystemTheme) : null);
+  setOrRemoveLocalStorage('lastDirectory', settings.lastDirectory || null);
   if (settings.homeDirectory) {
     localStorage.setItem('homeDirectory', settings.homeDirectory);
     applyPersistedHomeDirectoryToWindow(settings.homeDirectory);
+  } else {
+    localStorage.removeItem('homeDirectory');
   }
   if (Array.isArray(settings.projects) && settings.projects.length > 0) {
     localStorage.setItem('projects', JSON.stringify(settings.projects));
@@ -81,6 +137,8 @@ const persistToLocalStorage = (settings: DesktopSettings) => {
     } else {
       localStorage.removeItem('oc.sessions.projectCollapse');
     }
+  } else {
+    localStorage.removeItem('oc.sessions.projectCollapse');
   }
   if (typeof settings.gitmojiEnabled === 'boolean') {
     localStorage.setItem('gitmojiEnabled', String(settings.gitmojiEnabled));
@@ -89,13 +147,15 @@ const persistToLocalStorage = (settings: DesktopSettings) => {
   }
   if (typeof settings.directoryShowHidden === 'boolean') {
     localStorage.setItem('directoryTreeShowHidden', settings.directoryShowHidden ? 'true' : 'false');
+  } else {
+    localStorage.removeItem('directoryTreeShowHidden');
   }
   if (typeof settings.filesViewShowGitignored === 'boolean') {
     localStorage.setItem('filesViewShowGitignored', settings.filesViewShowGitignored ? 'true' : 'false');
+  } else {
+    localStorage.removeItem('filesViewShowGitignored');
   }
-  if (typeof settings.openInAppId === 'string' && settings.openInAppId.length > 0) {
-    localStorage.setItem('openInAppId', settings.openInAppId);
-  }
+  setOrRemoveLocalStorage('openInAppId', typeof settings.openInAppId === 'string' && settings.openInAppId.length > 0 ? settings.openInAppId : null);
   if (typeof settings.pwaAppName === 'string') {
     const normalized = settings.pwaAppName.trim().replace(/\s+/g, ' ').slice(0, 64);
     if (normalized.length > 0) {
@@ -103,10 +163,10 @@ const persistToLocalStorage = (settings: DesktopSettings) => {
     } else {
       localStorage.removeItem('openchamber.pwaName');
     }
+  } else {
+    localStorage.removeItem('openchamber.pwaName');
   }
-  if (typeof settings.mobileKeyboardMode === 'string') {
-    setStoredMobileKeyboardMode(settings.mobileKeyboardMode);
-  }
+  setStoredMobileKeyboardMode(settings.mobileKeyboardMode);
   if (typeof settings.openCodeUpdateToastDismissedVersion === 'string') {
     const version = settings.openCodeUpdateToastDismissedVersion.trim();
     if (version) {
@@ -114,25 +174,23 @@ const persistToLocalStorage = (settings: DesktopSettings) => {
     } else {
       localStorage.removeItem('opencode-update-toast-dismissed-version');
     }
+  } else {
+    localStorage.removeItem('opencode-update-toast-dismissed-version');
   }
   if (typeof settings.dictationEnabled === 'boolean') {
     localStorage.setItem('dictationEnabled', String(settings.dictationEnabled));
+  } else {
+    localStorage.removeItem('dictationEnabled');
   }
   if (settings.sttProvider === 'local' || settings.sttProvider === 'openai-compatible') {
     localStorage.setItem('sttProvider', settings.sttProvider);
+  } else {
+    localStorage.removeItem('sttProvider');
   }
-  if (typeof settings.sttServerUrl === 'string') {
-    localStorage.setItem('sttServerUrl', settings.sttServerUrl);
-  }
-  if (typeof settings.sttModel === 'string') {
-    localStorage.setItem('sttModel', settings.sttModel);
-  }
-  if (typeof settings.sttLocalModel === 'string') {
-    localStorage.setItem('sttLocalModel', settings.sttLocalModel);
-  }
-  if (typeof settings.sttLanguage === 'string') {
-    localStorage.setItem('sttLanguage', settings.sttLanguage);
-  }
+  setOrRemoveLocalStorage('sttServerUrl', typeof settings.sttServerUrl === 'string' ? settings.sttServerUrl : null);
+  setOrRemoveLocalStorage('sttModel', typeof settings.sttModel === 'string' ? settings.sttModel : null);
+  setOrRemoveLocalStorage('sttLocalModel', typeof settings.sttLocalModel === 'string' ? settings.sttLocalModel : null);
+  setOrRemoveLocalStorage('sttLanguage', typeof settings.sttLanguage === 'string' ? settings.sttLanguage : null);
 };
 
 const dispatchSettingsSynced = (settings: DesktopSettings): void => {
@@ -457,6 +515,91 @@ const getPersistApi = (): PersistApi | undefined => {
 
 const getRuntimeSettingsAPI = () => getRegisteredRuntimeAPIs()?.settings ?? null;
 
+const materializeAuthoritativeUiSettings = (settings: DesktopSettings): DesktopSettings => {
+  const defaults = useUIStore.getInitialState();
+
+  return {
+    useSystemTheme: true,
+    lightThemeId: DEFAULT_LIGHT_THEME_ID,
+    darkThemeId: DEFAULT_DARK_THEME_ID,
+    openInAppId: DEFAULT_OPEN_IN_APP_ID,
+    showReasoningTraces: defaults.showReasoningTraces,
+    sessionRecapEnabled: defaults.sessionRecapEnabled,
+    sessionSuggestionEnabled: defaults.sessionSuggestionEnabled,
+    sessionGoalEnabled: defaults.sessionGoalEnabled,
+    sessionGoalDefaultBudgetEnabled: defaults.sessionGoalDefaultBudgetEnabled,
+    sessionGoalDefaultBudget: defaults.sessionGoalDefaultBudget,
+    collapsibleThinkingBlocks: defaults.collapsibleThinkingBlocks,
+    autoDeleteEnabled: defaults.autoDeleteEnabled,
+    autoDeleteAfterDays: defaults.autoDeleteAfterDays,
+    sessionRetentionAction: defaults.sessionRetentionAction,
+    followUpBehavior: DEFAULT_FOLLOW_UP_BEHAVIOR,
+    showDeletionDialog: defaults.showDeletionDialog,
+    nativeNotificationsEnabled: defaults.nativeNotificationsEnabled,
+    notificationMode: defaults.notificationMode,
+    notifyOnSubtasks: defaults.notifyOnSubtasks,
+    notifyOnCompletion: defaults.notifyOnCompletion,
+    notifyOnError: defaults.notifyOnError,
+    notifyOnQuestion: defaults.notifyOnQuestion,
+    notificationTemplates: defaults.notificationTemplates,
+    summarizeLastMessage: defaults.summarizeLastMessage,
+    summaryThreshold: defaults.summaryThreshold,
+    summaryLength: defaults.summaryLength,
+    maxLastMessageLength: defaults.maxLastMessageLength,
+    inputSpellcheckEnabled: defaults.inputSpellcheckEnabled,
+    showOpenCodeUpdateNotifications: defaults.showOpenCodeUpdateNotifications,
+    showToolFileIcons: defaults.showToolFileIcons,
+    codeBlockLineWrap: defaults.codeBlockLineWrap,
+    showTurnChangedFiles: defaults.showTurnChangedFiles,
+    showExpandedBashTools: defaults.showExpandedBashTools,
+    showExpandedEditTools: defaults.showExpandedEditTools,
+    timeFormatPreference: defaults.timeFormatPreference,
+    weekStartPreference: defaults.weekStartPreference,
+    desktopWindowControlsPosition: defaults.desktopWindowControlsPosition,
+    chatRenderMode: defaults.chatRenderMode,
+    activityRenderMode: defaults.activityRenderMode,
+    mermaidRenderingMode: defaults.mermaidRenderingMode,
+    userMessageRenderingMode: defaults.userMessageRenderingMode,
+    collapsibleUserMessages: defaults.collapsibleUserMessages,
+    messageStreamTransport: 'auto',
+    stickyUserHeader: defaults.stickyUserHeader,
+    promptNavigatorEnabled: defaults.promptNavigatorEnabled,
+    expandedEditorToolbar: defaults.expandedEditorToolbar,
+    wideChatLayoutEnabled: defaults.wideChatLayoutEnabled,
+    showSplitAssistantMessageActions: defaults.showSplitAssistantMessageActions,
+    reportUsage: defaults.reportUsage,
+    fontSize: defaults.fontSize,
+    terminalFontSize: defaults.terminalFontSize,
+    terminalShell: defaults.terminalShell,
+    terminalLoginShells: defaults.terminalLoginShells,
+    editorFontSize: defaults.editorFontSize,
+    uiFont: defaults.uiFont,
+    monoFont: defaults.monoFont,
+    padding: defaults.padding,
+    cornerRadius: defaults.cornerRadius,
+    inputBarOffset: defaults.inputBarOffset,
+    shortcutOverrides: defaults.shortcutOverrides,
+    mobileKeyboardMode: 'resize-content',
+    favoriteModels: defaults.favoriteModels,
+    hiddenModels: defaults.hiddenModels,
+    collapsedModelProviders: defaults.collapsedModelProviders,
+    recentModels: defaults.recentModels,
+    recentAgents: defaults.recentAgents,
+    recentEfforts: defaults.recentEfforts,
+    diffLayoutPreference: defaults.diffLayoutPreference,
+    gitChangesViewMode: defaults.gitChangesViewMode,
+    directoryShowHidden: true,
+    filesViewShowGitignored: false,
+    dictationEnabled: true,
+    sttProvider: 'local',
+    sttServerUrl: 'http://localhost:8001/v1',
+    sttModel: 'deepdml/faster-whisper-large-v3-turbo-ct2',
+    sttLocalModel: 'parakeet-tdt-0.6b-v2-int8',
+    sttLanguage: '',
+    ...settings,
+  };
+};
+
 const applyDesktopUiPreferences = (settings: DesktopSettings) => {
   const store = useUIStore.getState();
   const configStore = typeof window !== 'undefined'
@@ -1215,6 +1358,9 @@ const sanitizeWebSettings = (payload: unknown): DesktopSettings | null => {
   if (typeof candidate.promptNavigatorEnabled === 'boolean') {
     result.promptNavigatorEnabled = candidate.promptNavigatorEnabled;
   }
+  if (typeof candidate.expandedEditorToolbar === 'boolean') {
+    result.expandedEditorToolbar = candidate.expandedEditorToolbar;
+  }
   if (typeof candidate.wideChatLayoutEnabled === 'boolean') {
     result.wideChatLayoutEnabled = candidate.wideChatLayoutEnabled;
   }
@@ -1524,6 +1670,7 @@ export const syncDesktopSettings = async (): Promise<void> => {
   const applySettings = async (settings: DesktopSettings) => {
     if (!isSettingsRuntimeContextCurrent(context)) return;
     const shouldPersistCraftGoalMigration = settings.draftStartersCraftGoalAdded !== true;
+    const authoritativeSettings = materializeAuthoritativeUiSettings(settings);
     try {
       persistToLocalStorage(settings);
     } catch (error) {
@@ -1531,20 +1678,23 @@ export const syncDesktopSettings = async (): Promise<void> => {
     }
     await waitForHydration();
     if (!isSettingsRuntimeContextCurrent(context)) return;
+    if (settings.draftStarters === undefined) {
+      useUIStore.setState({ globalDraftStarters: null });
+    }
     try {
-      applyDesktopUiPreferences(settings);
+      applyDesktopUiPreferences(authoritativeSettings);
     } catch (error) {
       console.warn('applyDesktopUiPreferences failed:', error);
     }
     if (shouldPersistCraftGoalMigration) {
       await updateDesktopSettings({
-        ...(settings.draftStarters ? { draftStarters: settings.draftStarters } : {}),
+        ...(authoritativeSettings.draftStarters ? { draftStarters: authoritativeSettings.draftStarters } : {}),
         draftStartersCraftGoalAdded: true,
       });
       if (!isSettingsRuntimeContextCurrent(context)) return;
     }
 
-    dispatchSettingsSynced(settings);
+    dispatchSettingsSynced(authoritativeSettings);
   };
 
   try {
@@ -1579,7 +1729,6 @@ async function _flushSettingsUpdate(): Promise<void> {
         const updated = await runtimeSettings.save(changes);
         if (!isSettingsRuntimeContextCurrent(context)) return;
         if (updated) {
-          persistToLocalStorage(updated);
           applyDesktopUiPreferences(updated);
           dispatchSettingsSynced(updated);
           _settingsCache = null;
@@ -1613,7 +1762,6 @@ async function _flushSettingsUpdate(): Promise<void> {
       const updated = (await response.json().catch(() => null)) as DesktopSettings | null;
       if (!isSettingsRuntimeContextCurrent(context)) return;
       if (updated) {
-        persistToLocalStorage(updated);
         applyDesktopUiPreferences(updated);
         dispatchSettingsSynced(updated);
         dispatchSettingsSaveState('saved');
diff --git a/packages/ui/src/lib/runtime-auth.test.ts b/packages/ui/src/lib/runtime-auth.test.ts
index 58858dfa..75bcf1aa 100644
--- a/packages/ui/src/lib/runtime-auth.test.ts
+++ b/packages/ui/src/lib/runtime-auth.test.ts
@@ -5,6 +5,8 @@ import {
   clearRuntimeUrlAuthToken,
   getRuntimeBearerTokenSync,
   refreshRuntimeUrlAuthToken,
+  refreshLocalRuntimeUrlAuthToken,
+  getLocalRuntimeUrlAuthTokenSync,
   setRuntimeAuthCredentialProvider,
   setRuntimeBearerToken,
   setRuntimeExtraHeaders,
@@ -145,4 +147,53 @@ describe('runtime auth headers', () => {
       clearRuntimeAuthCredentialProvider();
     }
   });
+
+  test('never reuses a local URL token for another origin', async () => {
+    const previousFetch = globalThis.fetch;
+    let fetchCount = 0;
+    try {
+      clearRuntimeUrlAuthToken();
+      globalThis.fetch = (async (input: RequestInfo | URL) => {
+        fetchCount += 1;
+        const origin = new URL(String(input)).origin;
+        return Response.json({ token: `${origin}-token`, expiresAt: Date.now() + 60_000 });
+      }) as typeof fetch;
+
+      const a = await refreshLocalRuntimeUrlAuthToken('http://127.0.0.1:3001');
+      const b = await refreshLocalRuntimeUrlAuthToken('http://127.0.0.1:3002');
+
+      expect(a).toBe('http://127.0.0.1:3001-token');
+      expect(b).toBe('http://127.0.0.1:3002-token');
+      expect(getLocalRuntimeUrlAuthTokenSync('http://127.0.0.1:3001')).toBe('');
+      expect(getLocalRuntimeUrlAuthTokenSync('http://127.0.0.1:3002')).toBe(b);
+      expect(fetchCount).toBe(2);
+    } finally {
+      globalThis.fetch = previousFetch;
+      clearRuntimeUrlAuthToken();
+    }
+  });
+
+  test('rejects a local mint that completes after switching origins', async () => {
+    const previousFetch = globalThis.fetch;
+    let resolveA!: (response: Response) => void;
+    try {
+      clearRuntimeUrlAuthToken();
+      globalThis.fetch = ((input: RequestInfo | URL) => {
+        const origin = new URL(String(input)).origin;
+        if (origin.endsWith(':3001')) return new Promise<Response>((resolve) => { resolveA = resolve; });
+        return Promise.resolve(Response.json({ token: 'token-b', expiresAt: Date.now() + 60_000 }));
+      }) as typeof fetch;
+
+      const requestA = refreshLocalRuntimeUrlAuthToken('http://127.0.0.1:3001');
+      const tokenB = await refreshLocalRuntimeUrlAuthToken('http://127.0.0.1:3002');
+      resolveA(Response.json({ token: 'token-a', expiresAt: Date.now() + 60_000 }));
+
+      expect(tokenB).toBe('token-b');
+      await expect(requestA).rejects.toThrow('stale');
+      expect(getLocalRuntimeUrlAuthTokenSync('http://127.0.0.1:3002')).toBe('token-b');
+    } finally {
+      globalThis.fetch = previousFetch;
+      clearRuntimeUrlAuthToken();
+    }
+  });
 });
diff --git a/packages/ui/src/lib/runtime-auth.ts b/packages/ui/src/lib/runtime-auth.ts
index 4fc9beda..780e330c 100644
--- a/packages/ui/src/lib/runtime-auth.ts
+++ b/packages/ui/src/lib/runtime-auth.ts
@@ -14,7 +14,10 @@ let runtimeUrlAuthTokenExpiresAt = 0;
 let runtimeUrlAuthRefreshPromise: Promise<string> | null = null;
 let localRuntimeUrlAuthToken = '';
 let localRuntimeUrlAuthTokenExpiresAt = 0;
+let localRuntimeUrlAuthOrigin = '';
 let localRuntimeUrlAuthRefreshPromise: Promise<string> | null = null;
+let localRuntimeUrlAuthRefreshOrigin = '';
+let localRuntimeUrlAuthGeneration = 0;
 let runtimeAuthGeneration = 0;
 
 const URL_AUTH_REFRESH_SKEW_MS = 10_000;
@@ -66,11 +69,27 @@ const buildAuthUrl = (apiBaseUrl: string | null | undefined, path: string): stri
   }
 };
 
+const normalizeOrigin = (value: string): string => {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return '';
+  }
+};
+
+const clearLocalRuntimeUrlAuthToken = (): void => {
+  localRuntimeUrlAuthToken = '';
+  localRuntimeUrlAuthTokenExpiresAt = 0;
+  localRuntimeUrlAuthOrigin = '';
+  localRuntimeUrlAuthRefreshPromise = null;
+  localRuntimeUrlAuthRefreshOrigin = '';
+  localRuntimeUrlAuthGeneration += 1;
+};
+
 export const clearRuntimeUrlAuthToken = (): void => {
   runtimeUrlAuthToken = '';
   runtimeUrlAuthTokenExpiresAt = 0;
-  localRuntimeUrlAuthToken = '';
-  localRuntimeUrlAuthTokenExpiresAt = 0;
+  clearLocalRuntimeUrlAuthToken();
 };
 
 const resetRuntimeAuthGeneration = (): void => {
@@ -135,15 +154,20 @@ export const setRuntimeUrlAuthToken = (token: string | null | undefined, expires
   }
 };
 
-export const setLocalRuntimeUrlAuthToken = (token: string | null | undefined, expiresAt: number | null | undefined): void => {
+export const setLocalRuntimeUrlAuthToken = (
+  token: string | null | undefined,
+  expiresAt: number | null | undefined,
+  localOrigin?: string | null,
+): void => {
   const normalized = normalizeBearerToken(token);
-  if (!normalized || typeof expiresAt !== 'number' || !Number.isFinite(expiresAt)) {
-    localRuntimeUrlAuthToken = '';
-    localRuntimeUrlAuthTokenExpiresAt = 0;
+  const origin = typeof localOrigin === 'string' ? normalizeOrigin(localOrigin) : '';
+  if (!normalized || typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || !origin) {
+    clearLocalRuntimeUrlAuthToken();
     return;
   }
   localRuntimeUrlAuthToken = normalized;
   localRuntimeUrlAuthTokenExpiresAt = expiresAt;
+  localRuntimeUrlAuthOrigin = origin;
 };
 
 const readValidRuntimeUrlAuthTokenSync = (): string => {
@@ -154,10 +178,13 @@ const readValidRuntimeUrlAuthTokenSync = (): string => {
   return runtimeUrlAuthToken;
 };
 
-const readValidLocalRuntimeUrlAuthTokenSync = (): string => {
+const readValidLocalRuntimeUrlAuthTokenSync = (localOrigin: string): string => {
+  const origin = normalizeOrigin(localOrigin);
+  if (!origin || localRuntimeUrlAuthOrigin !== origin) return '';
   if (!localRuntimeUrlAuthToken || localRuntimeUrlAuthTokenExpiresAt <= Date.now() + URL_AUTH_REFRESH_SKEW_MS) {
     localRuntimeUrlAuthToken = '';
     localRuntimeUrlAuthTokenExpiresAt = 0;
+    localRuntimeUrlAuthOrigin = '';
     return '';
   }
   return localRuntimeUrlAuthToken;
@@ -172,7 +199,7 @@ export const getRuntimeUrlAuthTokenSync = (): string => {
 };
 
 export const getLocalRuntimeUrlAuthTokenSync = (localOrigin?: string | null): string => {
-  const token = readValidLocalRuntimeUrlAuthTokenSync();
+  const token = localOrigin ? readValidLocalRuntimeUrlAuthTokenSync(localOrigin) : '';
   if (!token && localOrigin && typeof window !== 'undefined') {
     void refreshLocalRuntimeUrlAuthToken(localOrigin).catch(() => {});
   }
@@ -242,15 +269,23 @@ const mintRuntimeUrlAuthToken = (apiBaseUrl?: string | null): Promise<string> =>
 };
 
 const mintLocalRuntimeUrlAuthToken = (localOrigin: string): Promise<string> => {
-  if (localRuntimeUrlAuthRefreshPromise) return localRuntimeUrlAuthRefreshPromise;
+  const origin = normalizeOrigin(localOrigin);
+  if (!origin) return Promise.reject(new Error('Local runtime URL auth origin was invalid'));
+  if (localRuntimeUrlAuthRefreshPromise && localRuntimeUrlAuthRefreshOrigin === origin) {
+    return localRuntimeUrlAuthRefreshPromise;
+  }
+  const generation = localRuntimeUrlAuthGeneration;
   const refreshPromise = (async () => {
-    const response = await fetch(buildAuthUrl(localOrigin, '/auth/url-token'), {
+    const response = await fetch(buildAuthUrl(origin, '/auth/url-token'), {
       method: 'POST',
       credentials: 'include',
     });
     if (!response.ok) {
-      localRuntimeUrlAuthToken = '';
-      localRuntimeUrlAuthTokenExpiresAt = 0;
+      if (generation === localRuntimeUrlAuthGeneration && origin === localRuntimeUrlAuthRefreshOrigin) {
+        localRuntimeUrlAuthToken = '';
+        localRuntimeUrlAuthTokenExpiresAt = 0;
+        localRuntimeUrlAuthOrigin = '';
+      }
       throw new Error(`Failed to mint local runtime URL auth token (${response.status})`);
     }
     const payload = await response.json().catch(() => null) as { token?: unknown; expiresAt?: unknown } | null;
@@ -259,16 +294,22 @@ const mintLocalRuntimeUrlAuthToken = (localOrigin: string): Promise<string> => {
     if (!token || !Number.isFinite(expiresAt)) {
       throw new Error('Local runtime URL auth token response was invalid');
     }
+    if (generation !== localRuntimeUrlAuthGeneration || origin !== localRuntimeUrlAuthRefreshOrigin) {
+      throw new Error('Local runtime URL auth token response is stale');
+    }
     localRuntimeUrlAuthToken = token;
     localRuntimeUrlAuthTokenExpiresAt = expiresAt;
+    localRuntimeUrlAuthOrigin = origin;
     return token;
   })();
   const trackedPromise = refreshPromise.finally(() => {
     if (localRuntimeUrlAuthRefreshPromise === trackedPromise) {
       localRuntimeUrlAuthRefreshPromise = null;
+      localRuntimeUrlAuthRefreshOrigin = '';
     }
   });
   localRuntimeUrlAuthRefreshPromise = trackedPromise;
+  localRuntimeUrlAuthRefreshOrigin = origin;
   return localRuntimeUrlAuthRefreshPromise;
 };
 
@@ -281,9 +322,17 @@ export const refreshRuntimeUrlAuthToken = async (apiBaseUrl?: string | null): Pr
 };
 
 export const refreshLocalRuntimeUrlAuthToken = async (localOrigin: string): Promise<string> => {
-  const existing = readValidLocalRuntimeUrlAuthTokenSync();
+  const origin = normalizeOrigin(localOrigin);
+  if (!origin) throw new Error('Local runtime URL auth origin was invalid');
+  const existing = readValidLocalRuntimeUrlAuthTokenSync(origin);
   if (existing) return existing;
-  return mintLocalRuntimeUrlAuthToken(localOrigin);
+  if (
+    (localRuntimeUrlAuthOrigin && localRuntimeUrlAuthOrigin !== origin)
+    || (localRuntimeUrlAuthRefreshOrigin && localRuntimeUrlAuthRefreshOrigin !== origin)
+  ) {
+    clearLocalRuntimeUrlAuthToken();
+  }
+  return mintLocalRuntimeUrlAuthToken(origin);
 };
 
 // ── Proactive URL auth token refresh ──────────────────────────────────────
diff --git a/packages/ui/src/lib/runtime-url.test.ts b/packages/ui/src/lib/runtime-url.test.ts
index fffceec4..4525955a 100644
--- a/packages/ui/src/lib/runtime-url.test.ts
+++ b/packages/ui/src/lib/runtime-url.test.ts
@@ -103,7 +103,7 @@ describe('createRuntimeUrlResolver', () => {
   test('adds local URL auth token to desktop realtime proxy URL', () => {
     setRuntimeExtraHeaders({ 'CF-Access-Client-Id': 'client-id' });
     setRuntimeUrlAuthToken('remote-url-token', Date.now() + 60_000);
-    setLocalRuntimeUrlAuthToken('local-url-token', Date.now() + 60_000);
+    setLocalRuntimeUrlAuthToken('local-url-token', Date.now() + 60_000, 'http://127.0.0.1:57123');
     try {
       withWindow({
         location: { origin: 'openchamber-ui://app', href: 'openchamber-ui://app/index.html' },
diff --git a/packages/ui/src/lib/shiki/appThemeRegistry.test.ts b/packages/ui/src/lib/shiki/appThemeRegistry.test.ts
new file mode 100644
index 00000000..37221a64
--- /dev/null
+++ b/packages/ui/src/lib/shiki/appThemeRegistry.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'bun:test';
+
+import { themes } from '@/lib/theme/themes';
+import { getResolvedShikiTheme, getThemeContentSignature } from './appThemeRegistry';
+
+describe('appThemeRegistry', () => {
+  test('invalidates resolved themes when content changes under the same ID', () => {
+    const original = themes[0];
+    const changed = {
+      ...original,
+      colors: {
+        ...original.colors,
+        syntax: {
+          ...original.colors.syntax,
+          base: {
+            ...original.colors.syntax.base,
+            keyword: original.colors.syntax.base.string,
+          },
+        },
+      },
+    };
+
+    expect(getThemeContentSignature(changed)).not.toBe(getThemeContentSignature(original));
+    expect(getResolvedShikiTheme(changed)).not.toBe(getResolvedShikiTheme(original));
+  });
+
+  test('reuses resolved themes for identical content', () => {
+    const original = themes[0];
+    const clone = JSON.parse(JSON.stringify(original));
+
+    expect(getResolvedShikiTheme(clone)).toBe(getResolvedShikiTheme(original));
+  });
+});
diff --git a/packages/ui/src/lib/shiki/appThemeRegistry.ts b/packages/ui/src/lib/shiki/appThemeRegistry.ts
index 5b54c434..6479ba5c 100644
--- a/packages/ui/src/lib/shiki/appThemeRegistry.ts
+++ b/packages/ui/src/lib/shiki/appThemeRegistry.ts
@@ -35,8 +35,11 @@ function withStableStringId<T extends object>(value: T, id: string): T {
   return value;
 }
 
+const MAX_RESOLVED_THEME_CACHE_ENTRIES = 40;
 const resolvedThemeCache = new Map<string, ShikiThemeRegistrationResolvedLike>();
-const registeredPierreThemes = new Set<string>();
+const registeredPierreThemeSignatures = new Map<string, string>();
+
+export const getThemeContentSignature = (theme: Theme): string => JSON.stringify(theme);
 
 const toResolvedTheme = (raw: VSCodeTextMateTheme, id: string): ShikiThemeRegistrationResolvedLike => {
   const bgRaw = raw.colors?.['editor.background'];
@@ -68,24 +71,33 @@ const buildTextMateTheme = (theme: Theme): VSCodeTextMateTheme => {
 };
 
 export const getResolvedShikiTheme = (theme: Theme): ShikiThemeRegistrationResolvedLike => {
-  const cached = resolvedThemeCache.get(theme.metadata.id);
+  const signature = getThemeContentSignature(theme);
+  const cached = resolvedThemeCache.get(signature);
   if (cached) {
+    resolvedThemeCache.delete(signature);
+    resolvedThemeCache.set(signature, cached);
     return cached;
   }
 
   const raw = buildTextMateTheme(theme);
   const resolved = toResolvedTheme(raw, theme.metadata.id);
-  resolvedThemeCache.set(theme.metadata.id, resolved);
+  resolvedThemeCache.set(signature, resolved);
+  while (resolvedThemeCache.size > MAX_RESOLVED_THEME_CACHE_ENTRIES) {
+    const oldest = resolvedThemeCache.keys().next().value;
+    if (oldest === undefined) break;
+    resolvedThemeCache.delete(oldest);
+  }
   return resolved;
 };
 
 export const ensurePierreThemeRegistered = (theme: Theme): void => {
   const id = theme.metadata.id;
-  if (registeredPierreThemes.has(id)) {
+  const signature = getThemeContentSignature(theme);
+  if (registeredPierreThemeSignatures.get(id) === signature) {
     return;
   }
 
   const resolved = getResolvedShikiTheme(theme);
   registerCustomTheme(id, async () => resolved);
-  registeredPierreThemes.add(id);
+  registeredPierreThemeSignatures.set(id, signature);
 };
diff --git a/packages/ui/src/stores/DOCUMENTATION.md b/packages/ui/src/stores/DOCUMENTATION.md
index 6b7acf48..e88d0186 100644
--- a/packages/ui/src/stores/DOCUMENTATION.md
+++ b/packages/ui/src/stores/DOCUMENTATION.md
@@ -50,17 +50,42 @@ Examples:
 
 These stores coordinate persistent project/session metadata across multiple views.
 
+`useGlobalSessionsStore.ts` owns cold/global active and archived session coverage, including `sessionsByDirectory`. It is complementary to directory child stores: it is not the source of live busy/retry status or session messages.
+
+Global refresh rules:
+
+- Per-directory refresh is bounded to two requests across callers and prioritizes the current directory.
+- Each directory is an independent completeness scope. A failed directory preserves its previous sessions while successful directories reconcile normally.
+- Fetch failure must remain distinguishable from a successful empty list; failed scopes cannot destructively clear cached sessions.
+- Runtime switch increments the load generation and clears the previous runtime's snapshot so stale in-flight work cannot commit.
+- Live session mutations update the cache directly after successful SDK actions; they preserve stable directory metadata when lighter event payloads omit it.
+- Full and per-directory loads capture a mutation revision. At commit time they overlay only per-session create/update/archive/delete/move mutations newer than that baseline, including no-op deletion tombstones, so an older response cannot undo newer local authority.
+
+Permission auto-accept policy is authoritative in the active Web server or VS Code extension host. Owner snapshots carry a monotonic revision; the UI rejects lower revisions and any hydration or mutation completion captured before a runtime reset. Persisted UI policy is not live authority. The version-2 store retains an old unscoped policy only as a one-runtime legacy migration candidate, then removes it after successful migration.
+
+Shared safe storage treats durable failures per key. A quota or access failure creates an ephemeral override or tombstone for that key without disabling reads and writes for unrelated keys; later writes retry the durable backend. Deferred adapters retain failed operations for a later flush, and malformed Zustand JSON is removed and treated as missing so hydration can recover.
+
+Project and UI settings use successful settings synchronization as authority. Omitted fields in a complete snapshot reset to canonical client defaults, including an omitted project list becoming empty; transport or settings-load failure dispatches no synchronization event and preserves current state. Settings save responses are partial patches and must not clear unrelated in-memory preferences or local mirrors.
+
+Session folders persist in runtime-specific v2 browser keys without silently evicting older runtime namespaces. Runtime switch, page hide, app freeze, and unload synchronously flush the pending browser snapshot before lifecycle suspension or namespace replacement. A runtime switch then cancels stale old-runtime disk work and starts generation-owned disk hydration. Missing or malformed server files are not authoritative empty snapshots; disk data may replace browser state only when it carries a real revision and no newer local folder mutation occurred. Server writes are serialized and reject non-newer revisions so delayed or duplicate requests cannot overwrite the current state. File-search cache and in-flight keys include runtime plus directory and are cleared on endpoint reset.
+
+Persisted session todos use a bounded composite key of runtime, normalized directory, and session ID. Ambiguous legacy todo entries are discarded rather than claimed by whichever runtime starts first. Authoritative deletion uses an explicit runtime identity, and session-folder deletion scans every scope in the active runtime so archived assignments cannot survive after their session is gone.
+
+Chat composer drafts, confirmed mentions, inline-comment drafts, and pinned sessions use the same runtime/directory/session ownership rule. Chat drafts use a bounded shared envelope and notify mounted composers when authoritative deletion clears their identity, preventing unmount autosave from resurrecting deleted text. Inline drafts enforce per-session, global-session, and serialized-byte bounds. Pins retain every valid composite key across runtimes without silent age/count eviction and are never pruned from the first startup list. Confirmed local deletion and routed deletion events clear immediately; after an authoritative baseline exists, a later complete omission also cleans persisted state. Ambiguous session-only legacy drafts and pins are not claimed.
+
+Composer draft edits remain immediate in memory and use a trailing durable-write debounce. Pending text and confirmed mentions flush synchronously when the document becomes hidden, freezes, receives `pagehide`, switches identity, or unmounts; authoritative deletion cancels pending work before any lifecycle flush can run. The shared chat-draft envelope reuses its parsed snapshot until the storage value changes. Inline-comment draft byte accounting indexes serialized buckets and recalculates only the changed session bucket during normal edits; deferred storage still performs the final full-envelope serialization and lifecycle flush.
+
 ## Git / PR Stores
 
 The Git and PR stores are the most important stores to understand before editing this directory.
 
 ### `useGitStore.ts`
 
-`useGitStore` is a centralized per-directory Git cache.
+`useGitStore` is a centralized active-runtime, per-directory Git cache.
 
 Core model:
 
-- top-level keyed by `directory`
+- active runtime owns one `directories` map keyed by directory
 - each directory entry contains:
   - repo detection
   - status
@@ -77,11 +102,15 @@ Important properties:
 - loading state is per-directory, not global
 - `ensureStatus()` and `ensureAll()` are the preferred entry points for consumers
 - in-flight dedupe exists for status and `ensureAll()`
-- diff data is separately cached and capped with size + count limits
+- runtime reset replaces all live entries with that runtime's persisted branch seeds and invalidates old completions
+- status, branches, log, identity, repository probes, and prefetch diffs commit through runtime and per-channel generations
+- status mutations advance a revision so older refreshes cannot undo optimistic or confirmed index changes
+- branch persistence is versioned, bounded, runtime-scoped, and claims the ambiguous legacy cache once
+- diff data has per-directory and aggregate count/UTF-8-byte limits; oversized single entries are rejected
 
 ### `useGitHubPrStatusStore.ts`
 
-`useGitHubPrStatusStore` is a centralized PR cache keyed by `directory::branch`.
+`useGitHubPrStatusStore` is a centralized PR cache keyed by a collision-safe tuple of runtime, directory, branch, and requested remote.
 
 Core model:
 
@@ -98,9 +127,11 @@ Important properties:
 
 - `ensureEntry()` initializes a key lazily
 - `setParams()` attaches runtime context
+- parameter changes advance an entry revision; stale queued, successful, and failed requests cannot update a newer authority
 - `startWatching()` / `stopWatching()` are for true live PR consumers only
 - `refreshTargets()` supports one-shot multi-target bootstrap without turning on live watching
-- persisted cache is for page refresh continuity, not for broad background syncing
+- runtime reset disposes timers, watchers, API references, and request ownership while inert namespaced snapshots remain isolated
+- persisted cache is versioned, TTL-filtered, and bounded for page refresh continuity, not broad background syncing
 
 ## Ownership Rules
 
@@ -114,6 +145,8 @@ These rules are important. Breaking them tends to reintroduce idle CPU churn, st
 6. Header should not depend on PR store.
 7. Closed sidebar should not create live PR work.
 8. File tree Git status should update only when the file tree is visible.
+9. Global session refresh must remain bounded and failure-isolated per directory.
+10. Global session cache must not drive live activity indicators or message-loading state.
 
 ## Selector Rules
 
diff --git a/packages/ui/src/stores/globalSessions.test.ts b/packages/ui/src/stores/globalSessions.test.ts
index 73da61b2..118a94b4 100644
--- a/packages/ui/src/stores/globalSessions.test.ts
+++ b/packages/ui/src/stores/globalSessions.test.ts
@@ -95,4 +95,29 @@ describe('listGlobalSessionPages', () => {
     expect(calls[1]).toEqual({ directory: '/repo', archived: false, roots: false, limit: 2, cursor: 10 })
     expect(sessions.map((session) => session.id)).toEqual(['ses_root', 'ses_child_1', 'ses_child_2'])
   })
+
+  test('retries SDK error responses before treating the load as failed', async () => {
+    let calls = 0
+    const apiClient = {
+      experimental: {
+        session: {
+          list: async () => {
+            calls += 1
+            if (calls === 1) {
+              return { error: { message: 'warming up' }, response: { status: 503 } }
+            }
+            return {
+              data: [{ id: 'ses_1', time: { updated: 1 } }],
+              response: { headers: new Headers() },
+            }
+          },
+        },
+      },
+    } as unknown as OpencodeClient
+
+    const sessions = await listGlobalSessionPages(apiClient, { archived: false, pageSize: 500 })
+
+    expect(calls).toBe(2)
+    expect(sessions.map((session) => session.id)).toEqual(['ses_1'])
+  })
 })
diff --git a/packages/ui/src/stores/globalSessions.ts b/packages/ui/src/stores/globalSessions.ts
index 56babca6..3ef34f01 100644
--- a/packages/ui/src/stores/globalSessions.ts
+++ b/packages/ui/src/stores/globalSessions.ts
@@ -1,6 +1,8 @@
 import type { OpencodeClient, Session } from "@opencode-ai/sdk/v2";
 import { retry } from "@/sync/retry";
 import { stripSessionListDetails } from "@/sync/sanitize";
+import { getRuntimeKey } from "@/lib/runtime-switch";
+import { startSessionLoadPerformanceEvent } from "@/sync/session-load-performance";
 
 export type GlobalSessionRecord = Session & {
     project?: {
@@ -86,21 +88,49 @@ export async function listGlobalSessionPages(
     const all: GlobalSessionRecord[] = [];
     const seenIds = new Set<string>();
     let cursor: number | undefined;
+    let operation: string;
+    if (!options.directory) {
+        operation = `global-sessions.${options.archived ? "archived" : "active"}`;
+    } else if (options.roots === true) {
+        operation = "bootstrap.sessions.roots";
+    } else if (options.archived) {
+        operation = "bootstrap.sessions.archived";
+    } else {
+        operation = "bootstrap.sessions.all";
+    }
 
     while (true) {
-        const response = await retry(
-            () => apiClient.experimental.session.list({
-                ...(options.directory ? { directory: options.directory } : {}),
-                archived: options.archived,
-                ...(options.roots !== undefined ? { roots: options.roots } : {}),
-                limit: options.pageSize,
-                ...(cursor !== undefined ? { cursor } : {}),
-            }),
+        let attempts = 0;
+        const finishPerformanceEvent = startSessionLoadPerformanceEvent({
+            operation,
+            runtimeKey: getRuntimeKey(),
+            directory: options.directory,
+            caller: cursor === undefined ? "initial-page" : "pagination",
+        });
+        const { response, payload } = await retry(
+            async () => {
+                attempts += 1;
+                const response = await apiClient.experimental.session.list({
+                    ...(options.directory ? { directory: options.directory } : {}),
+                    archived: options.archived,
+                    ...(options.roots !== undefined ? { roots: options.roots } : {}),
+                    limit: options.pageSize,
+                    ...(cursor !== undefined ? { cursor } : {}),
+                });
+                const payload = unwrapSessionList(response, "experimental.session.list")
+                    .map((session) => stripSessionListDetails(session) as GlobalSessionRecord);
+                return { response, payload };
+            },
             { attempts: 3, delay: 500, retryIf: () => true },
-        );
+        ).catch((error) => {
+            finishPerformanceEvent("error", { retryCount: Math.max(0, attempts - 1) });
+            throw error;
+        });
 
-        const payload = unwrapSessionList(response, "experimental.session.list")
-            .map((session) => stripSessionListDetails(session) as GlobalSessionRecord);
+        finishPerformanceEvent("complete", {
+            retryCount: Math.max(0, attempts - 1),
+            recordCount: payload.length,
+        });
         if (payload.length === 0) break;
 
         let appended = 0;
diff --git a/packages/ui/src/stores/messageQueueStore.test.ts b/packages/ui/src/stores/messageQueueStore.test.ts
new file mode 100644
index 00000000..6ec859a0
--- /dev/null
+++ b/packages/ui/src/stores/messageQueueStore.test.ts
@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, test } from "bun:test"
+import {
+  createMessageQueueTarget,
+  getMessageQueueKey,
+  migrateMessageQueueState,
+  parseMessageQueueKey,
+  useMessageQueueStore,
+} from "./messageQueueStore"
+
+beforeEach(() => {
+  useMessageQueueStore.setState({ queuedMessages: {}, quarantinedLegacyMessages: {} })
+})
+
+describe("message queue runtime ownership", () => {
+  test("isolates colliding session IDs by runtime and directory", () => {
+    const a = createMessageQueueTarget("session-1", "/repo", "runtime-a")!
+    const b = createMessageQueueTarget("session-1", "/repo", "runtime-b")!
+    useMessageQueueStore.getState().addToQueue(a, { content: "from A" })
+    useMessageQueueStore.getState().addToQueue(b, { content: "from B" })
+
+    expect(useMessageQueueStore.getState().getQueueForTarget(a)[0]?.content).toBe("from A")
+    expect(useMessageQueueStore.getState().getQueueForTarget(b)[0]?.content).toBe("from B")
+  })
+
+  test("round trips a composite queue key", () => {
+    const target = createMessageQueueTarget("session-1", "/repo", "runtime-a")!
+    expect(parseMessageQueueKey(getMessageQueueKey(target))).toEqual(target)
+  })
+
+  test("quarantines legacy session-only queues instead of activating them", () => {
+    const migrated = migrateMessageQueueState({
+      queuedMessages: {
+        "session-1": [{ id: "queued-1", content: "legacy", createdAt: 1 }],
+      },
+    }, 1)
+
+    expect(migrated.queuedMessages).toEqual({})
+    expect(migrated.quarantinedLegacyMessages?.["session-1"]?.[0]?.content).toBe("legacy")
+  })
+
+  test("bounds each queue to the newest 20 messages", () => {
+    const target = createMessageQueueTarget("session-1", "/repo", "runtime-a")!
+    for (let index = 0; index < 25; index += 1) {
+      useMessageQueueStore.getState().addToQueue(target, { content: `message-${index}` })
+    }
+
+    const queue = useMessageQueueStore.getState().getQueueForTarget(target)
+    expect(queue).toHaveLength(20)
+    expect(queue[0]?.content).toBe("message-5")
+  })
+})
diff --git a/packages/ui/src/stores/messageQueueStore.ts b/packages/ui/src/stores/messageQueueStore.ts
index ae964feb..2ac9f86f 100644
--- a/packages/ui/src/stores/messageQueueStore.ts
+++ b/packages/ui/src/stores/messageQueueStore.ts
@@ -3,6 +3,8 @@ import { devtools, persist } from 'zustand/middleware';
 import { createDeferredSafeJSONStorage } from './utils/safeStorage';
 import type { AttachedFile } from './types/sessionTypes';
 import { updateDesktopSettings } from '@/lib/persistence';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { normalizePath } from '@/lib/pathNormalization';
 
 export type FollowUpBehavior = 'steer' | 'queue';
 
@@ -52,38 +54,82 @@ export interface QueuedMessage {
     };
 }
 
+export type MessageQueueTarget = {
+    runtimeKey: string;
+    directory: string;
+    sessionId: string;
+};
+
+const MAX_QUEUE_TARGETS = 50;
+const MAX_MESSAGES_PER_QUEUE = 20;
+
+export const createMessageQueueTarget = (
+    sessionId: string,
+    directory: string | null | undefined,
+    runtimeKey: string = getRuntimeKey(),
+): MessageQueueTarget | null => {
+    const normalizedDirectory = normalizePath(directory);
+    if (!runtimeKey || !normalizedDirectory || !sessionId) return null;
+    return { runtimeKey, directory: normalizedDirectory, sessionId };
+};
+
+export const getMessageQueueKey = (target: MessageQueueTarget): string =>
+    `${target.runtimeKey}\n${target.directory}\n${target.sessionId}`;
+
+export const parseMessageQueueKey = (key: string): MessageQueueTarget | null => {
+    const [runtimeKey, directory, ...sessionParts] = key.split('\n');
+    return createMessageQueueTarget(sessionParts.join('\n'), directory, runtimeKey);
+};
+
 interface MessageQueueState {
-    queuedMessages: Record<string, QueuedMessage[]>; // sessionId → queue
+    queuedMessages: Record<string, QueuedMessage[]>; // runtime + directory + session → queue
+    quarantinedLegacyMessages: Record<string, QueuedMessage[]>;
     followUpBehavior: FollowUpBehavior;
 }
 
 interface MessageQueueActions {
-    addToQueue: (sessionId: string, message: Omit<QueuedMessage, 'id' | 'createdAt'>) => void;
-    removeFromQueue: (sessionId: string, messageId: string) => void;
-    reorderQueue: (sessionId: string, fromId: string, toId: string) => void;
-    popToInput: (sessionId: string, messageId: string) => QueuedMessage | null;
-    clearQueue: (sessionId: string) => void;
+    addToQueue: (target: MessageQueueTarget, message: Omit<QueuedMessage, 'id' | 'createdAt'>) => void;
+    removeFromQueue: (target: MessageQueueTarget, messageId: string) => void;
+    reorderQueue: (target: MessageQueueTarget, fromId: string, toId: string) => void;
+    popToInput: (target: MessageQueueTarget, messageId: string) => QueuedMessage | null;
+    clearQueue: (target: MessageQueueTarget) => void;
     clearAllQueues: () => void;
     setFollowUpBehavior: (behavior: FollowUpBehavior) => void;
-    getQueueForSession: (sessionId: string) => QueuedMessage[];
+    getQueueForTarget: (target: MessageQueueTarget) => QueuedMessage[];
 }
 
 type MessageQueueStore = MessageQueueState & MessageQueueActions;
 
 type PersistedMessageQueueState = {
     queuedMessages?: Record<string, QueuedMessage[]>;
+    quarantinedLegacyMessages?: Record<string, QueuedMessage[]>;
     followUpBehavior?: FollowUpBehavior;
     queueModeEnabled?: boolean;
 };
 
+export const migrateMessageQueueState = (persistedState: unknown, version: number): Partial<MessageQueueStore> => {
+    const state = (persistedState ?? {}) as PersistedMessageQueueState;
+    const legacyQueues = version < 2 ? (state.queuedMessages ?? {}) : {};
+    return {
+        queuedMessages: version < 2 ? {} : (state.queuedMessages ?? {}),
+        quarantinedLegacyMessages: {
+            ...(state.quarantinedLegacyMessages ?? {}),
+            ...legacyQueues,
+        },
+        followUpBehavior: normalizeFollowUpBehavior(state.followUpBehavior, state.queueModeEnabled ?? null),
+    };
+};
+
 export const useMessageQueueStore = create<MessageQueueStore>()(
     devtools(
         persist(
             (set, get) => ({
                 queuedMessages: {},
+                quarantinedLegacyMessages: {},
                 followUpBehavior: DEFAULT_FOLLOW_UP_BEHAVIOR,
 
-                addToQueue: (sessionId, message) => {
+                addToQueue: (target, message) => {
+                    const key = getMessageQueueKey(target);
                     const id = `queued-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
                     const queuedMessage: QueuedMessage = {
                         id,
@@ -94,23 +140,32 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                     };
 
                     set((state) => {
-                        const currentQueue = state.queuedMessages[sessionId] ?? [];
+                        const currentQueue = state.queuedMessages[key] ?? [];
+                        const queuedMessages = {
+                            ...state.queuedMessages,
+                            [key]: [...currentQueue, queuedMessage].slice(-MAX_MESSAGES_PER_QUEUE),
+                        };
+                        const keys = Object.keys(queuedMessages);
+                        if (keys.length > MAX_QUEUE_TARGETS) {
+                            keys.sort((left, right) => (
+                                (queuedMessages[left]?.[0]?.createdAt ?? 0) - (queuedMessages[right]?.[0]?.createdAt ?? 0)
+                            ));
+                            for (const staleKey of keys.slice(0, keys.length - MAX_QUEUE_TARGETS)) delete queuedMessages[staleKey];
+                        }
                         return {
-                            queuedMessages: {
-                                ...state.queuedMessages,
-                                [sessionId]: [...currentQueue, queuedMessage],
-                            },
+                            queuedMessages,
                         };
                     });
                 },
 
-                removeFromQueue: (sessionId, messageId) => {
+                removeFromQueue: (target, messageId) => {
+                    const key = getMessageQueueKey(target);
                     set((state) => {
-                        const currentQueue = state.queuedMessages[sessionId] ?? [];
+                        const currentQueue = state.queuedMessages[key] ?? [];
                         const newQueue = currentQueue.filter((m) => m.id !== messageId);
                         
                         if (newQueue.length === 0) {
-                            const { [sessionId]: _removed, ...rest } = state.queuedMessages;
+                            const { [key]: _removed, ...rest } = state.queuedMessages;
                             void _removed;
                             return { queuedMessages: rest };
                         }
@@ -118,16 +173,17 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                         return {
                             queuedMessages: {
                                 ...state.queuedMessages,
-                                [sessionId]: newQueue,
+                                [key]: newQueue,
                             },
                         };
                     });
                 },
 
-                reorderQueue: (sessionId, fromId, toId) => {
+                reorderQueue: (target, fromId, toId) => {
                     if (fromId === toId) return;
+                    const key = getMessageQueueKey(target);
                     set((state) => {
-                        const currentQueue = state.queuedMessages[sessionId];
+                        const currentQueue = state.queuedMessages[key];
                         if (!currentQueue) return state;
                         const fromIndex = currentQueue.findIndex((m) => m.id === fromId);
                         const toIndex = currentQueue.findIndex((m) => m.id === toId);
@@ -140,15 +196,16 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                         return {
                             queuedMessages: {
                                 ...state.queuedMessages,
-                                [sessionId]: newQueue,
+                                [key]: newQueue,
                             },
                         };
                     });
                 },
 
-                popToInput: (sessionId, messageId) => {
+                popToInput: (target, messageId) => {
+                    const key = getMessageQueueKey(target);
                     const state = get();
-                    const currentQueue = state.queuedMessages[sessionId] ?? [];
+                    const currentQueue = state.queuedMessages[key] ?? [];
                     const message = currentQueue.find((m) => m.id === messageId);
                     
                     if (!message) {
@@ -157,11 +214,11 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
 
                     // Remove from queue
                     set((prevState) => {
-                        const queue = prevState.queuedMessages[sessionId] ?? [];
+                        const queue = prevState.queuedMessages[key] ?? [];
                         const newQueue = queue.filter((m) => m.id !== messageId);
                         
                         if (newQueue.length === 0) {
-                            const { [sessionId]: _removed, ...rest } = prevState.queuedMessages;
+                            const { [key]: _removed, ...rest } = prevState.queuedMessages;
                             void _removed;
                             return { queuedMessages: rest };
                         }
@@ -169,7 +226,7 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                         return {
                             queuedMessages: {
                                 ...prevState.queuedMessages,
-                                [sessionId]: newQueue,
+                                    [key]: newQueue,
                             },
                         };
                     });
@@ -177,9 +234,10 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                     return message;
                 },
 
-                clearQueue: (sessionId) => {
+                clearQueue: (target) => {
+                    const key = getMessageQueueKey(target);
                     set((state) => {
-                        const { [sessionId]: _removed, ...rest } = state.queuedMessages;
+                        const { [key]: _removed, ...rest } = state.queuedMessages;
                         void _removed;
                         return { queuedMessages: rest };
                     });
@@ -194,25 +252,20 @@ export const useMessageQueueStore = create<MessageQueueStore>()(
                     void updateDesktopSettings({ followUpBehavior: behavior });
                 },
 
-                getQueueForSession: (sessionId) => {
-                    return get().queuedMessages[sessionId] ?? [];
+                getQueueForTarget: (target) => {
+                    return get().queuedMessages[getMessageQueueKey(target)] ?? [];
                 },
             }),
             {
                 name: 'message-queue-store',
-                version: 1,
+                version: 2,
                 storage: createDeferredSafeJSONStorage(),
                 partialize: (state) => ({
                     queuedMessages: state.queuedMessages,
+                    quarantinedLegacyMessages: state.quarantinedLegacyMessages,
                     followUpBehavior: state.followUpBehavior,
                 }),
-                migrate: (persistedState) => {
-                    const state = (persistedState ?? {}) as PersistedMessageQueueState;
-                    return {
-                        queuedMessages: state.queuedMessages ?? {},
-                        followUpBehavior: normalizeFollowUpBehavior(state.followUpBehavior, state.queueModeEnabled ?? null),
-                    };
-                },
+                migrate: migrateMessageQueueState,
             }
         ),
         {
diff --git a/packages/ui/src/stores/permissionStore.test.ts b/packages/ui/src/stores/permissionStore.test.ts
index 128c9281..18936087 100644
--- a/packages/ui/src/stores/permissionStore.test.ts
+++ b/packages/ui/src/stores/permissionStore.test.ts
@@ -18,6 +18,7 @@ const json = (value: unknown, status = 200) => new Response(JSON.stringify(value
 describe('permission store server policy', () => {
   beforeEach(() => {
     usePermissionStore.getState().reset();
+    usePermissionStore.setState({ legacyCandidate: null, legacyRuntimeKey: null });
     fetchImpl = async () => json({ sessions: {} });
   });
 
@@ -51,7 +52,7 @@ describe('permission store server policy', () => {
   });
 
   test('migrates a legacy local policy when the server has no policy yet', async () => {
-    usePermissionStore.setState({ autoAccept: { root: true } });
+    usePermissionStore.setState({ legacyCandidate: { root: true }, legacyRuntimeKey: null });
     const requests: string[] = [];
     fetchImpl = async (input) => {
       requests.push(input);
@@ -62,5 +63,56 @@ describe('permission store server policy', () => {
     await usePermissionStore.getState().hydrate();
     expect(requests).toEqual(['/api/permission-auto-accept', '/api/permission-auto-accept/sessions/root']);
     expect(usePermissionStore.getState().autoAccept).toEqual({ root: true });
+    expect(usePermissionStore.getState().legacyCandidate).toBe(null);
+  });
+
+  test('rejects a hydration response from before reset', async () => {
+    let resolveOld!: (response: Response) => void;
+    const oldResponse = new Promise<Response>((resolve) => { resolveOld = resolve; });
+    fetchImpl = async () => oldResponse;
+    const oldHydration = usePermissionStore.getState().hydrate();
+
+    usePermissionStore.getState().reset();
+    fetchImpl = async () => json({ sessions: { current: true }, revision: 2 });
+    await usePermissionStore.getState().hydrate();
+    resolveOld(json({ sessions: { stale: true }, revision: 1 }));
+    await oldHydration;
+
+    expect(usePermissionStore.getState().autoAccept).toEqual({ current: true });
+  });
+
+  test('rejects a mutation response from before reset', async () => {
+    let resolveOld!: (response: Response) => void;
+    fetchImpl = async () => new Promise<Response>((resolve) => { resolveOld = resolve; });
+    const mutation = usePermissionStore.getState().setSessionAutoAccept('stale', true);
+
+    usePermissionStore.getState().reset();
+    resolveOld(json({ sessions: { stale: true }, revision: 1 }));
+    await mutation;
+
+    expect(usePermissionStore.getState().autoAccept).toEqual({});
+    expect(usePermissionStore.getState().saving).toBe(false);
+  });
+
+  test('keeps the highest authoritative revision when mutations resolve out of order', async () => {
+    const resolvers: Array<(response: Response) => void> = [];
+    fetchImpl = async () => new Promise<Response>((resolve) => { resolvers.push(resolve); });
+    const first = usePermissionStore.getState().setSessionAutoAccept('first', true);
+    const second = usePermissionStore.getState().setSessionAutoAccept('second', true);
+
+    resolvers[1](json({ sessions: { first: true, second: true }, revision: 2 }));
+    await second;
+    resolvers[0](json({ sessions: { first: true }, revision: 1 }));
+    await first;
+
+    expect(usePermissionStore.getState().autoAccept).toEqual({ first: true, second: true });
+    expect(usePermissionStore.getState().saving).toBe(false);
+  });
+
+  test('ignores an older broadcast revision', () => {
+    usePermissionStore.getState().applySnapshot({ sessions: { current: true }, revision: 4 });
+    usePermissionStore.getState().applySnapshot({ sessions: { stale: true }, revision: 3 });
+
+    expect(usePermissionStore.getState().autoAccept).toEqual({ current: true });
   });
 });
diff --git a/packages/ui/src/stores/permissionStore.ts b/packages/ui/src/stores/permissionStore.ts
index 34db0838..cbd2c175 100644
--- a/packages/ui/src/stores/permissionStore.ts
+++ b/packages/ui/src/stores/permissionStore.ts
@@ -8,17 +8,26 @@ import { isVSCodeRuntime } from "@/lib/desktop";
 import { createDeferredSafeJSONStorage } from "./utils/safeStorage";
 import { useSessionUIStore } from "@/sync/session-ui-store";
 import { opencodeClient } from "@/lib/opencode/client";
+import { getRuntimeKey } from "@/lib/runtime-switch";
 
 type PermissionPolicySnapshot = {
     sessions: PermissionAutoAcceptMap;
+    revision?: number;
 };
 
+const normalizeRevision = (value: unknown): number | undefined => (
+    Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : undefined
+);
+
 interface PermissionStore {
     autoAccept: PermissionAutoAcceptMap;
     loaded: boolean;
     saving: boolean;
+    lastAppliedRevision: number;
+    legacyCandidate: PermissionAutoAcceptMap | null;
+    legacyRuntimeKey: string | null;
     hydrate: () => Promise<void>;
-    applySnapshot: (snapshot: PermissionPolicySnapshot) => void;
+    applySnapshot: (snapshot: PermissionPolicySnapshot, expectedRuntimeKey?: string) => void;
     reset: () => void;
     isSessionAutoAccepting: (sessionId: string) => boolean;
     setSessionAutoAccept: (sessionId: string, enabled: boolean) => Promise<void>;
@@ -34,7 +43,7 @@ const readSnapshot = async (response: Response): Promise<PermissionPolicySnapsho
     for (const [sessionId, enabled] of Object.entries(payload.sessions)) {
         if (sessionId && typeof enabled === "boolean") sessions[sessionId] = enabled;
     }
-    return { sessions };
+    return { sessions, revision: normalizeRevision(payload.revision) };
 };
 
 const requestSnapshot = async (path: string, init?: RequestInit) => readSnapshot(await runtimeFetch(path, init));
@@ -45,15 +54,52 @@ const isAutoAccepting = (
     sessionId: string,
 ) => autoRespondsPermission({ autoAccept, sessions: [], sessionById, sessionID: sessionId });
 
+type PermissionOperation = { generation: number; runtimeKey: string; sequence: number };
+let generation = 0;
+let operationSequence = 0;
+let latestStartedSequence = 0;
+const pendingSavingOperations = new Set<number>();
+
+const beginOperation = (): PermissionOperation => {
+    const operation = { generation, runtimeKey: getRuntimeKey(), sequence: ++operationSequence };
+    latestStartedSequence = operation.sequence;
+    return operation;
+};
+
+const isCurrentOperation = (operation: PermissionOperation) => (
+    operation.generation === generation && operation.runtimeKey === getRuntimeKey()
+);
+
+const normalizeSessions = (value: unknown): PermissionAutoAcceptMap => {
+    const sessions: PermissionAutoAcceptMap = {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) return sessions;
+    for (const [sessionId, enabled] of Object.entries(value)) {
+        if (sessionId && typeof enabled === "boolean") sessions[sessionId] = enabled;
+    }
+    return sessions;
+};
+
 export const usePermissionStore = create<PermissionStore>()(persist((set, get) => ({
     autoAccept: {},
     loaded: false,
     saving: false,
+    lastAppliedRevision: -1,
+    legacyCandidate: null,
+    legacyRuntimeKey: null,
 
     hydrate: async () => {
+        const operation = beginOperation();
+        const legacyCandidate = get().legacyCandidate;
+        let legacyRuntimeKey = get().legacyRuntimeKey;
+        if (legacyCandidate && !legacyRuntimeKey) {
+            legacyRuntimeKey = operation.runtimeKey;
+            set({ legacyRuntimeKey });
+        }
         let snapshot = await requestSnapshot("/api/permission-auto-accept");
-        const legacyEntries = Object.entries(get().autoAccept)
-            .filter(([sessionId, enabled]) => !sessionId.includes("/") && typeof enabled === "boolean");
+        if (!isCurrentOperation(operation)) return;
+        const legacyEntries = legacyRuntimeKey === operation.runtimeKey
+            ? Object.entries(legacyCandidate ?? {})
+            : [];
         if (Object.keys(snapshot.sessions).length === 0 && legacyEntries.length > 0) {
             for (const [sessionId, enabled] of legacyEntries) {
                 if (!sessionId || typeof enabled !== "boolean") continue;
@@ -65,19 +111,37 @@ export const usePermissionStore = create<PermissionStore>()(persist((set, get) =
                         body: JSON.stringify({ enabled }),
                     },
                 );
+                if (!isCurrentOperation(operation)) return;
             }
         }
-        set({ autoAccept: snapshot.sessions, loaded: true });
+        if (!isCurrentOperation(operation)) return;
+        if (snapshot.revision === undefined && operation.sequence !== latestStartedSequence) return;
+        get().applySnapshot(snapshot, operation.runtimeKey);
+        if (legacyRuntimeKey === operation.runtimeKey) {
+            set({ legacyCandidate: null, legacyRuntimeKey: null });
+        }
     },
 
-    reset: () => set({ autoAccept: {}, loaded: false, saving: false }),
+    reset: () => {
+        generation += 1;
+        latestStartedSequence = 0;
+        pendingSavingOperations.clear();
+        set({ autoAccept: {}, loaded: false, saving: false, lastAppliedRevision: -1 });
+    },
 
-    applySnapshot: (snapshot) => {
-        const sessions: PermissionAutoAcceptMap = {};
-        for (const [sessionId, enabled] of Object.entries(snapshot.sessions ?? {})) {
-            if (sessionId && typeof enabled === "boolean") sessions[sessionId] = enabled;
-        }
-        set({ autoAccept: sessions, loaded: true });
+    applySnapshot: (snapshot, expectedRuntimeKey) => {
+        if (expectedRuntimeKey && expectedRuntimeKey !== getRuntimeKey()) return;
+        const sessions = normalizeSessions(snapshot.sessions);
+        const revision = normalizeRevision(snapshot.revision);
+        set((state) => {
+            if (revision === undefined && state.lastAppliedRevision >= 0) return state;
+            if (revision !== undefined && revision < state.lastAppliedRevision) return state;
+            return {
+                autoAccept: sessions,
+                loaded: true,
+                ...(revision !== undefined ? { lastAppliedRevision: revision } : {}),
+            };
+        });
     },
 
     isSessionAutoAccepting: (sessionId) => {
@@ -89,6 +153,8 @@ export const usePermissionStore = create<PermissionStore>()(persist((set, get) =
 
     setSessionAutoAccept: async (sessionId, enabled) => {
         if (!sessionId) return;
+        const operation = beginOperation();
+        pendingSavingOperations.add(operation.sequence);
         set({ saving: true });
         try {
             const directory = useSessionUIStore.getState().getDirectoryForSession(sessionId)
@@ -102,18 +168,40 @@ export const usePermissionStore = create<PermissionStore>()(persist((set, get) =
                     body: JSON.stringify({ enabled, directory }),
                 },
             );
-            set({ autoAccept: snapshot.sessions, loaded: true });
-            if (isVSCodeRuntime() && enabled) {
+            if (!isCurrentOperation(operation)) return;
+            if (snapshot.revision === undefined && operation.sequence !== latestStartedSequence) return;
+            get().applySnapshot(snapshot, operation.runtimeKey);
+            if (isCurrentOperation(operation) && isVSCodeRuntime() && enabled) {
                 const { reconcileVSCodePendingPermissions } = await import("@/sync/vscode-permission-auto-accept");
-                void reconcileVSCodePendingPermissions(directory).catch(() => undefined);
+                if (isCurrentOperation(operation)) {
+                    void reconcileVSCodePendingPermissions(directory).catch(() => undefined);
+                }
             }
         } finally {
-            set({ saving: false });
+            if (isCurrentOperation(operation)) {
+                pendingSavingOperations.delete(operation.sequence);
+                set({ saving: pendingSavingOperations.size > 0 });
+            }
         }
     },
 
 }), {
     name: "permission-store",
     storage: createDeferredSafeJSONStorage(),
-    partialize: (state) => ({ autoAccept: state.autoAccept }),
+    version: 2,
+    migrate: (persisted, version) => {
+        const state = persisted && typeof persisted === "object" ? persisted as Record<string, unknown> : {};
+        if (version < 2) {
+            const legacyCandidate = normalizeSessions(state.autoAccept);
+            return {
+                legacyCandidate: Object.keys(legacyCandidate).length > 0 ? legacyCandidate : null,
+                legacyRuntimeKey: null,
+            };
+        }
+        return state;
+    },
+    partialize: (state) => ({
+        legacyCandidate: state.legacyCandidate,
+        legacyRuntimeKey: state.legacyRuntimeKey,
+    }),
 }));
diff --git a/packages/ui/src/stores/useConfigStore.ts b/packages/ui/src/stores/useConfigStore.ts
index 8e468bbb..a8c1d3f4 100644
--- a/packages/ui/src/stores/useConfigStore.ts
+++ b/packages/ui/src/stores/useConfigStore.ts
@@ -21,6 +21,7 @@ import { runtimeFetch } from "@/lib/runtime-fetch";
 import { markStartupTrace, measureStartupTrace } from "@/lib/startupTrace";
 import { normalizePath } from "@/lib/pathNormalization";
 import { getSyncConfig, subscribeToSyncConfigChanges } from "@/sync/sync-refs";
+import { getRuntimeKey } from "@/lib/runtime-switch";
 
 const MODELS_DEV_API_URL = "https://models.dev/api.json";
 const MODELS_DEV_PROXY_URL = "/api/openchamber/models-metadata";
@@ -717,18 +718,57 @@ const resolveInitialDirectoryKey = (): string => {
 // We cache resolved mappings to localStorage so subsequent launches resolve the
 // project synchronously at init time. worktree→project is effectively immutable,
 // so a cached entry is safe to trust.
-const WORKTREE_PROJECT_MAP_KEY = 'oc.worktreeProjectMap';
-let _worktreeProjectMap: Record<string, string> | null = null;
+const WORKTREE_PROJECT_MAP_KEY = 'oc.worktreeProjectMap.v2';
+const LEGACY_WORKTREE_PROJECT_MAP_KEY = 'oc.worktreeProjectMap';
+const MAX_WORKTREE_PROJECT_RUNTIME_MAPS = 8;
+type WorktreeProjectMapEnvelope = {
+    version: 2;
+    legacyClaimed: boolean;
+    runtimes: Record<string, { updatedAt: number; entries: Record<string, string> }>;
+};
+const _worktreeProjectMaps = new Map<string, Record<string, string>>();
+const readWorktreeProjectEnvelope = (): WorktreeProjectMapEnvelope => {
+    try {
+        const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(WORKTREE_PROJECT_MAP_KEY) : null;
+        if (!raw) return { version: 2, legacyClaimed: false, runtimes: {} };
+        const parsed = JSON.parse(raw) as Partial<WorktreeProjectMapEnvelope>;
+        if (parsed.version !== 2 || !parsed.runtimes || typeof parsed.runtimes !== 'object') {
+            return { version: 2, legacyClaimed: false, runtimes: {} };
+        }
+        return { version: 2, legacyClaimed: parsed.legacyClaimed === true, runtimes: parsed.runtimes };
+    } catch {
+        return { version: 2, legacyClaimed: false, runtimes: {} };
+    }
+};
+const writeWorktreeProjectEnvelope = (envelope: WorktreeProjectMapEnvelope): void => {
+    const runtimes = Object.fromEntries(
+        Object.entries(envelope.runtimes)
+            .sort(([, left], [, right]) => right.updatedAt - left.updatedAt)
+            .slice(0, MAX_WORKTREE_PROJECT_RUNTIME_MAPS),
+    );
+    localStorage.setItem(WORKTREE_PROJECT_MAP_KEY, JSON.stringify({ ...envelope, runtimes }));
+};
 const getWorktreeProjectMap = (): Record<string, string> => {
-    if (_worktreeProjectMap === null) {
+    const runtimeKey = getRuntimeKey() || 'default';
+    const existing = _worktreeProjectMaps.get(runtimeKey);
+    if (existing) return existing;
+    const envelope = readWorktreeProjectEnvelope();
+    let map = envelope.runtimes[runtimeKey]?.entries ?? null;
+    if (!map && !envelope.legacyClaimed) {
         try {
-            const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(WORKTREE_PROJECT_MAP_KEY) : null;
-            _worktreeProjectMap = raw ? (JSON.parse(raw) as Record<string, string>) : {};
+            const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(LEGACY_WORKTREE_PROJECT_MAP_KEY) : null;
+            map = raw ? (JSON.parse(raw) as Record<string, string>) : {};
+            envelope.legacyClaimed = true;
+            envelope.runtimes[runtimeKey] = { updatedAt: Date.now(), entries: map };
+            writeWorktreeProjectEnvelope(envelope);
+            localStorage.removeItem(LEGACY_WORKTREE_PROJECT_MAP_KEY);
         } catch {
-            _worktreeProjectMap = {};
+            map = {};
         }
     }
-    return _worktreeProjectMap;
+    const result = map ?? {};
+    _worktreeProjectMaps.set(runtimeKey, result);
+    return result;
 };
 const rememberWorktreeProject = (worktree: string, project: string): void => {
     if (!worktree || !project || worktree === project) return;
@@ -736,7 +776,12 @@ const rememberWorktreeProject = (worktree: string, project: string): void => {
     if (map[worktree] === project) return;
     map[worktree] = project;
     try {
-        localStorage.setItem(WORKTREE_PROJECT_MAP_KEY, JSON.stringify(map));
+        const runtimeKey = getRuntimeKey() || 'default';
+        const envelope = readWorktreeProjectEnvelope();
+        envelope.legacyClaimed = true;
+        envelope.runtimes[runtimeKey] = { updatedAt: Date.now(), entries: map };
+        writeWorktreeProjectEnvelope(envelope);
+        localStorage.removeItem(LEGACY_WORKTREE_PROJECT_MAP_KEY);
     } catch {
         // localStorage quota exceeded — ignore; live resolution still works.
     }
diff --git a/packages/ui/src/stores/useFileSearchStore.test.ts b/packages/ui/src/stores/useFileSearchStore.test.ts
index ad59eaa8..3a021db5 100644
--- a/packages/ui/src/stores/useFileSearchStore.test.ts
+++ b/packages/ui/src/stores/useFileSearchStore.test.ts
@@ -7,6 +7,7 @@ type Deferred<T> = {
 };
 
 const searchRequests: Array<Deferred<Array<{ path: string }>>> = [];
+let runtimeKey = 'runtime-a';
 
 const createDeferred = <T>(): Deferred<T> => {
   let resolve!: (value: T) => void;
@@ -29,12 +30,14 @@ mock.module('@/lib/opencode/client', () => ({
     searchFiles: searchFilesMock,
   },
 }));
+mock.module('@/lib/runtime-switch', () => ({ getRuntimeKey: () => runtimeKey }));
 
 const { useFileSearchStore } = await import('./useFileSearchStore');
 
 describe('useFileSearchStore', () => {
   beforeEach(() => {
     searchRequests.length = 0;
+    runtimeKey = 'runtime-a';
     useFileSearchStore.setState({
       cache: {},
       cacheKeys: [],
@@ -101,4 +104,20 @@ describe('useFileSearchStore', () => {
     searchRequests[1].resolve([{ path: 'second.ts' }]);
     expect(await secondPromise).toEqual([{ path: 'second.ts' }]);
   });
+
+  test('isolates cache and in-flight ownership by runtime', async () => {
+    const firstPromise = useFileSearchStore.getState().searchFiles('/project', 'foo');
+    runtimeKey = 'runtime-b';
+    const secondPromise = useFileSearchStore.getState().searchFiles('/project', 'foo');
+    expect(searchRequests).toHaveLength(2);
+
+    searchRequests[1].resolve([{ path: 'runtime-b.ts' }]);
+    expect(await secondPromise).toEqual([{ path: 'runtime-b.ts' }]);
+    searchRequests[0].resolve([{ path: 'runtime-a.ts' }]);
+    await firstPromise;
+
+    runtimeKey = 'runtime-b';
+    expect(await useFileSearchStore.getState().searchFiles('/project', 'foo')).toEqual([{ path: 'runtime-b.ts' }]);
+    expect(searchRequests).toHaveLength(2);
+  });
 });
diff --git a/packages/ui/src/stores/useFileSearchStore.ts b/packages/ui/src/stores/useFileSearchStore.ts
index 31e969b5..a907d4f3 100644
--- a/packages/ui/src/stores/useFileSearchStore.ts
+++ b/packages/ui/src/stores/useFileSearchStore.ts
@@ -1,6 +1,7 @@
 import { create } from 'zustand';
 import { devtools } from 'zustand/middleware';
 import { opencodeClient, type ProjectFileSearchHit } from '@/lib/opencode/client';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 const CACHE_TTL_MS = 30_000;
 const MAX_CACHE_ENTRIES = 40;
@@ -22,9 +23,11 @@ interface FileSearchStoreState {
     options?: { includeHidden?: boolean; respectGitignore?: boolean; type?: 'file' | 'directory' }
   ) => Promise<ProjectFileSearchHit[]>;
   invalidateDirectory: (directory?: string | null) => void;
+  resetForRuntimeSwitch: () => void;
 }
 
 const buildCacheKey = (
+  runtimeKey: string,
   directory: string,
   query: string,
   limit: number,
@@ -34,13 +37,13 @@ const buildCacheKey = (
 ) => {
   const normalizedDirectory = directory.trim();
   const normalizedQuery = query.trim().toLowerCase();
-  return JSON.stringify([normalizedDirectory, normalizedQuery, limit, includeHidden, respectGitignore, type]);
+  return JSON.stringify([runtimeKey, normalizedDirectory, normalizedQuery, limit, includeHidden, respectGitignore, type]);
 };
 
 const cacheKeyMatchesDirectory = (cacheKey: string, directory: string) => {
   try {
     const value: unknown = JSON.parse(cacheKey);
-    return Array.isArray(value) && value[0] === directory;
+    return Array.isArray(value) && value[1] === directory;
   } catch {
     return false;
   }
@@ -58,11 +61,12 @@ export const useFileSearchStore = create<FileSearchStoreState>()(
         }
 
         const normalizedDirectory = directory.trim();
+        const runtimeKey = getRuntimeKey();
         const normalizedQuery = typeof query === 'string' ? query.trim() : '';
         const includeHidden = Boolean(options?.includeHidden);
         const respectGitignore = options?.respectGitignore ?? true;
         const type = options?.type === 'directory' ? 'directory' : 'file';
-        const key = buildCacheKey(normalizedDirectory, normalizedQuery, limit, includeHidden, respectGitignore, type);
+        const key = buildCacheKey(runtimeKey, normalizedDirectory, normalizedQuery, limit, includeHidden, respectGitignore, type);
         const now = Date.now();
         const cached = get().cache[key];
 
@@ -159,6 +163,9 @@ export const useFileSearchStore = create<FileSearchStoreState>()(
           };
         });
       },
+      resetForRuntimeSwitch() {
+        set({ cache: {}, cacheKeys: [], inFlight: {} });
+      },
     }),
     {
       name: 'file-search-store',
diff --git a/packages/ui/src/stores/useFilesViewTabsStore.test.ts b/packages/ui/src/stores/useFilesViewTabsStore.test.ts
index d08df0f6..1937e3e1 100644
--- a/packages/ui/src/stores/useFilesViewTabsStore.test.ts
+++ b/packages/ui/src/stores/useFilesViewTabsStore.test.ts
@@ -3,7 +3,7 @@ import { useFilesViewTabsStore } from './useFilesViewTabsStore';
 
 describe('useFilesViewTabsStore', () => {
   beforeEach(() => {
-    useFilesViewTabsStore.setState({ byRoot: {} });
+    useFilesViewTabsStore.setState({ byRoot: {}, activeRuntimeKey: 'runtime-a', runtimeSnapshots: {} });
   });
 
   test('ignores runtime paths outside the requested root', () => {
@@ -47,4 +47,16 @@ describe('useFilesViewTabsStore', () => {
     expect(state?.openPaths).toEqual(['/repo/src/index.ts']);
     expect(state?.expandedPaths).toEqual(['/repo/src', '/repo/other']);
   });
+
+  test('restores independent active projections across runtime switches', () => {
+    useFilesViewTabsStore.getState().addOpenPath('/repo', '/repo/a.ts');
+    useFilesViewTabsStore.getState().resetForRuntimeSwitch('runtime-b');
+    expect(useFilesViewTabsStore.getState().byRoot).toEqual({});
+    useFilesViewTabsStore.getState().addOpenPath('/repo', '/repo/b.ts');
+
+    useFilesViewTabsStore.getState().resetForRuntimeSwitch('runtime-a');
+    expect(useFilesViewTabsStore.getState().byRoot['/repo']?.openPaths).toEqual(['/repo/a.ts']);
+    useFilesViewTabsStore.getState().resetForRuntimeSwitch('runtime-b');
+    expect(useFilesViewTabsStore.getState().byRoot['/repo']?.openPaths).toEqual(['/repo/b.ts']);
+  });
 });
diff --git a/packages/ui/src/stores/useFilesViewTabsStore.ts b/packages/ui/src/stores/useFilesViewTabsStore.ts
index b069f507..870de332 100644
--- a/packages/ui/src/stores/useFilesViewTabsStore.ts
+++ b/packages/ui/src/stores/useFilesViewTabsStore.ts
@@ -2,6 +2,7 @@ import { create } from 'zustand';
 import { devtools, persist } from 'zustand/middleware';
 
 import { createDeferredSafeJSONStorage } from './utils/safeStorage';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 type RootTabsState = {
   openPaths: string[];
@@ -12,6 +13,8 @@ type RootTabsState = {
 
 type FilesViewTabsState = {
   byRoot: Record<string, RootTabsState>;
+  activeRuntimeKey: string;
+  runtimeSnapshots: Record<string, { byRoot: Record<string, RootTabsState>; updatedAt: number }>;
 };
 
 type FilesViewTabsActions = {
@@ -24,10 +27,18 @@ type FilesViewTabsActions = {
   toggleExpandedPath: (root: string, path: string) => void;
   expandPath: (root: string, path: string) => void;
   expandPaths: (root: string, paths: string[]) => void;
+  resetForRuntimeSwitch: (runtimeKey: string) => void;
 };
 
 export type FilesViewTabsStore = FilesViewTabsState & FilesViewTabsActions;
 
+const MAX_ROOTS = 20;
+const MAX_RUNTIME_SNAPSHOTS = 8;
+const MAX_OPEN_PATHS_PER_ROOT = 50;
+const MAX_EXPANDED_PATHS_PER_ROOT = 500;
+const MAX_PATH_LENGTH = 4096;
+const ROOT_TTL_MS = 90 * 24 * 60 * 60_000;
+
 const normalizePath = (value: string): string => {
   if (!value) return '';
 
@@ -90,14 +101,16 @@ const sanitizeByRoot = (input: unknown): Record<string, RootTabsState> => {
       ? Array.from(new Set(state.openPaths
         .filter((value): value is string => typeof value === 'string')
         .map((value) => normalizePath(value))
-        .filter((value) => isPathWithinRoot(value, root))))
+        .filter((value) => value.length <= MAX_PATH_LENGTH && isPathWithinRoot(value, root))))
+        .slice(-MAX_OPEN_PATHS_PER_ROOT)
       : [];
 
     const expandedPaths = Array.isArray(state.expandedPaths)
       ? Array.from(new Set(state.expandedPaths
         .filter((value): value is string => typeof value === 'string')
         .map((value) => normalizePath(value))
-        .filter((value) => isPathWithinRoot(value, root))))
+        .filter((value) => value.length <= MAX_PATH_LENGTH && isPathWithinRoot(value, root))))
+        .slice(-MAX_EXPANDED_PATHS_PER_ROOT)
       : [];
 
     const selectedPathCandidate = typeof state.selectedPath === 'string'
@@ -111,6 +124,7 @@ const sanitizeByRoot = (input: unknown): Record<string, RootTabsState> => {
     const touchedAt = typeof state.touchedAt === 'number' && Number.isFinite(state.touchedAt)
       ? state.touchedAt
       : Date.now();
+    if (Date.now() - touchedAt > ROOT_TTL_MS) continue;
 
     const existing = next[root];
     if (existing) {
@@ -134,7 +148,7 @@ const sanitizeByRoot = (input: unknown): Record<string, RootTabsState> => {
     };
   }
 
-  return next;
+  return clampRoots(next, MAX_ROOTS);
 };
 
 const clampRoots = (byRoot: Record<string, RootTabsState>, maxRoots: number): Record<string, RootTabsState> => {
@@ -163,6 +177,22 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
     persist(
       (set, get) => ({
         byRoot: {},
+        activeRuntimeKey: getRuntimeKey(),
+        runtimeSnapshots: {},
+
+        resetForRuntimeSwitch: (runtimeKey) => {
+          set((state) => {
+            const runtimeSnapshots = {
+              ...state.runtimeSnapshots,
+              [state.activeRuntimeKey]: { byRoot: sanitizeByRoot(state.byRoot), updatedAt: Date.now() },
+            };
+            return {
+              activeRuntimeKey: runtimeKey,
+              runtimeSnapshots,
+              byRoot: sanitizeByRoot(runtimeSnapshots[runtimeKey]?.byRoot),
+            };
+          });
+        },
 
         addOpenPath: (root, path, options) => {
           const normalizedRoot = normalizePath((root || '').trim());
@@ -189,7 +219,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 selectedPath: nextSelectedPath,
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -225,7 +255,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 touchedAt: Date.now(),
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -267,7 +297,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
               },
             };
 
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -304,7 +334,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
               },
             };
 
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -334,7 +364,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 selectedPath: normalizedPath,
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -383,7 +413,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 expandedPaths: nextExpandedPaths,
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -410,7 +440,7 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 expandedPaths: [...current.expandedPaths, normalizedPath],
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
 
@@ -444,25 +474,49 @@ export const useFilesViewTabsStore = create<FilesViewTabsStore>()(
                 expandedPaths: [...current.expandedPaths, ...newPaths],
               },
             };
-            return { byRoot: clampRoots(byRoot, 20) };
+            return { byRoot: clampRoots(byRoot, MAX_ROOTS) };
           });
         },
       }),
       {
         name: 'files-view-tabs-store',
-        version: 2,
+        version: 3,
         storage: createDeferredSafeJSONStorage(),
-        migrate: (persistedState) => {
-          if (!persistedState || typeof persistedState !== 'object') {
-            return { byRoot: {} };
+        migrate: (persistedState, version) => {
+          if (version < 3 || !persistedState || typeof persistedState !== 'object') {
+            return { byRoot: {}, activeRuntimeKey: getRuntimeKey(), runtimeSnapshots: {} };
           }
-
-          const rawByRoot = (persistedState as { byRoot?: unknown }).byRoot;
+          return persistedState;
+        },
+        partialize: (state) => {
+          const currentSnapshots = {
+            ...state.runtimeSnapshots,
+            [state.activeRuntimeKey]: { byRoot: sanitizeByRoot(state.byRoot), updatedAt: Date.now() },
+          };
+          const runtimeSnapshots = Object.fromEntries(Object.entries(currentSnapshots)
+            .sort(([, left], [, right]) => right.updatedAt - left.updatedAt)
+            .slice(0, MAX_RUNTIME_SNAPSHOTS)
+            .map(([runtimeKey, snapshot]) => [runtimeKey, {
+              byRoot: sanitizeByRoot(snapshot.byRoot),
+              updatedAt: snapshot.updatedAt,
+            }]));
+          return { activeRuntimeKey: state.activeRuntimeKey, runtimeSnapshots };
+        },
+        merge: (persistedState, currentState) => {
+          const persisted = persistedState && typeof persistedState === 'object'
+            ? persistedState as Partial<FilesViewTabsState>
+            : {};
+          const runtimeSnapshots = persisted.runtimeSnapshots && typeof persisted.runtimeSnapshots === 'object'
+            ? persisted.runtimeSnapshots
+            : {};
+          const activeRuntimeKey = getRuntimeKey();
           return {
-            byRoot: sanitizeByRoot(rawByRoot),
+            ...currentState,
+            activeRuntimeKey,
+            runtimeSnapshots,
+            byRoot: sanitizeByRoot(runtimeSnapshots[activeRuntimeKey]?.byRoot),
           };
         },
-        partialize: (state) => ({ byRoot: sanitizeByRoot(state.byRoot) }),
       }
     ),
     { name: 'files-view-tabs-store' }
diff --git a/packages/ui/src/stores/useGitHubPrStatusStore.test.ts b/packages/ui/src/stores/useGitHubPrStatusStore.test.ts
new file mode 100644
index 00000000..0514167d
--- /dev/null
+++ b/packages/ui/src/stores/useGitHubPrStatusStore.test.ts
@@ -0,0 +1,139 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test"
+import type { GitHubPullRequestStatus, RuntimeAPIs } from "@/lib/api/types"
+
+let runtimeKey = "runtime-a"
+mock.module("@/lib/runtime-switch", () => ({ getRuntimeKey: () => runtimeKey }))
+
+const { getGitHubPrStatusKey, useGitHubPrStatusStore } = await import("./useGitHubPrStatusStore")
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((res) => { resolve = res })
+  return { promise, resolve }
+}
+
+const params = (github: RuntimeAPIs["github"], branch = "main") => ({
+  directory: "/repo",
+  branch,
+  remoteName: "origin",
+  canShow: true,
+  github,
+  githubAuthChecked: true,
+  githubConnected: true,
+})
+
+describe("GitHub PR status cache ownership", () => {
+  beforeEach(() => {
+    runtimeKey = "runtime-a"
+    useGitHubPrStatusStore.setState({ entries: {}, activeRequestCount: 0, totalRequestCount: 0 })
+    useGitHubPrStatusStore.getState().resetForRuntimeSwitch()
+  })
+
+  test("keys colliding paths by runtime and requested remote", () => {
+    const originA = getGitHubPrStatusKey("/repo", "main", "origin")
+    const upstreamA = getGitHubPrStatusKey("/repo", "main", "upstream")
+    runtimeKey = "runtime-b"
+    const originB = getGitHubPrStatusKey("/repo", "main", "origin")
+
+    expect(new Set([originA, upstreamA, originB]).size).toBe(3)
+  })
+
+  test("rejects a response after params change", async () => {
+    const request = deferred<GitHubPullRequestStatus>()
+    const github = { prStatus: () => request.promise } as unknown as RuntimeAPIs["github"]
+    const key = getGitHubPrStatusKey("/repo", "main", "origin")
+    useGitHubPrStatusStore.getState().ensureEntry(key)
+    useGitHubPrStatusStore.getState().setParams(key, params(github))
+    const loading = useGitHubPrStatusStore.getState().refresh(key, { force: true })
+
+    useGitHubPrStatusStore.getState().setParams(key, params(github, "next"))
+    request.resolve({ connected: true, pr: null })
+    await loading
+
+    expect(useGitHubPrStatusStore.getState().entries[key]?.status).toBe(null)
+    expect(useGitHubPrStatusStore.getState().entries[key]?.isLoading).toBe(false)
+  })
+
+  test("rejects an old runtime response after reset", async () => {
+    const request = deferred<GitHubPullRequestStatus>()
+    const github = { prStatus: () => request.promise } as unknown as RuntimeAPIs["github"]
+    const key = getGitHubPrStatusKey("/repo", "main", "origin")
+    useGitHubPrStatusStore.getState().ensureEntry(key)
+    useGitHubPrStatusStore.getState().setParams(key, params(github))
+    const loading = useGitHubPrStatusStore.getState().refresh(key, { force: true })
+
+    runtimeKey = "runtime-b"
+    useGitHubPrStatusStore.getState().resetForRuntimeSwitch()
+    request.resolve({ connected: true, pr: null })
+    await loading
+
+    expect(useGitHubPrStatusStore.getState().entries[key]?.status).toBe(null)
+    expect(useGitHubPrStatusStore.getState().activeRequestCount).toBe(0)
+  })
+
+  test("throttles repeated non-forced refreshes after a failure", async () => {
+    let requestCount = 0
+    const github = {
+      prStatus: async () => {
+        requestCount += 1
+        throw new Error("GitHub rate limited")
+      },
+    } as unknown as RuntimeAPIs["github"]
+    const key = getGitHubPrStatusKey("/repo", "main", "origin")
+    useGitHubPrStatusStore.getState().ensureEntry(key)
+    useGitHubPrStatusStore.getState().setParams(key, params(github))
+
+    await useGitHubPrStatusStore.getState().refresh(key)
+    await useGitHubPrStatusStore.getState().refresh(key)
+
+    expect(requestCount).toBe(1)
+    expect(useGitHubPrStatusStore.getState().entries[key]?.error).toBe("GitHub rate limited")
+  })
+
+  test("does not throttle replacement params when a queued request becomes stale", async () => {
+    const first = deferred<GitHubPullRequestStatus>()
+    const second = deferred<GitHubPullRequestStatus>()
+    let staleRequestCount = 0
+    let replacementRequestCount = 0
+    const firstGitHub = { prStatus: () => first.promise } as unknown as RuntimeAPIs["github"]
+    const secondGitHub = { prStatus: () => second.promise } as unknown as RuntimeAPIs["github"]
+    const staleGitHub = {
+      prStatus: async () => {
+        staleRequestCount += 1
+        return { connected: true, pr: null }
+      },
+    } as unknown as RuntimeAPIs["github"]
+    const replacementGitHub = {
+      prStatus: async () => {
+        replacementRequestCount += 1
+        return { connected: true, pr: null }
+      },
+    } as unknown as RuntimeAPIs["github"]
+    const firstKey = getGitHubPrStatusKey("/repo", "first", "origin")
+    const secondKey = getGitHubPrStatusKey("/repo", "second", "origin")
+    const queuedKey = getGitHubPrStatusKey("/repo", "queued", "origin")
+
+    for (const [key, github, branch] of [
+      [firstKey, firstGitHub, "first"],
+      [secondKey, secondGitHub, "second"],
+      [queuedKey, staleGitHub, "queued"],
+    ] as const) {
+      useGitHubPrStatusStore.getState().ensureEntry(key)
+      useGitHubPrStatusStore.getState().setParams(key, params(github, branch))
+    }
+
+    const firstRefresh = useGitHubPrStatusStore.getState().refresh(firstKey, { force: true })
+    const secondRefresh = useGitHubPrStatusStore.getState().refresh(secondKey, { force: true })
+    const staleRefresh = useGitHubPrStatusStore.getState().refresh(queuedKey, { force: true })
+    await Promise.resolve()
+    useGitHubPrStatusStore.getState().setParams(queuedKey, params(replacementGitHub, "queued"))
+    first.resolve({ connected: true, pr: null })
+    second.resolve({ connected: true, pr: null })
+    await Promise.all([firstRefresh, secondRefresh, staleRefresh])
+
+    await useGitHubPrStatusStore.getState().refresh(queuedKey)
+
+    expect(staleRequestCount).toBe(0)
+    expect(replacementRequestCount).toBe(1)
+  })
+})
diff --git a/packages/ui/src/stores/useGitHubPrStatusStore.ts b/packages/ui/src/stores/useGitHubPrStatusStore.ts
index 0dd0b24d..41ead2d1 100644
--- a/packages/ui/src/stores/useGitHubPrStatusStore.ts
+++ b/packages/ui/src/stores/useGitHubPrStatusStore.ts
@@ -3,6 +3,7 @@ import { persist } from 'zustand/middleware';
 import type { GitHubPullRequestStatus, RuntimeAPIs } from '@/lib/api/types';
 import { mapWithConcurrency } from '@/lib/concurrency';
 import { createDeferredSafeJSONStorage } from './utils/safeStorage';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 const PR_REVALIDATE_TTL_MS = 90_000;
 const PR_REVALIDATE_INTERVAL_MS = 15_000;
@@ -14,6 +15,7 @@ const PR_OPEN_STABLE_INTERVAL_MS = 5 * 60_000;
 const PR_STATUS_REFRESH_CONCURRENCY = 4;
 const PR_PERSIST_TTL_MS = 12 * 60 * 60_000;
 const PR_STATUS_STORAGE_KEY = 'openchamber.github-pr-status';
+const PR_MAX_ENTRIES = 200;
 
 const isTerminalPrState = (state: string | null | undefined): boolean => state === 'closed' || state === 'merged';
 const isPendingChecks = (status: GitHubPullRequestStatus | null): boolean => {
@@ -24,9 +26,14 @@ const isPendingChecks = (status: GitHubPullRequestStatus | null): boolean => {
   return checks.state === 'pending' || checks.pending > 0;
 };
 
+const getOpenPrRefreshInterval = (status: GitHubPullRequestStatus | null): number => {
+  if (isPendingChecks(status)) return PR_OPEN_BUSY_INTERVAL_MS;
+  if (status?.checks && status.checks.state !== 'pending') return PR_OPEN_STABLE_INTERVAL_MS;
+  return PR_OPEN_DEFAULT_INTERVAL_MS;
+};
+
 export const getGitHubPrStatusKey = (directory: string, branch: string, remoteName?: string | null): string => {
-  void remoteName;
-  return `${directory}::${branch}`;
+  return JSON.stringify([getRuntimeKey(), directory, branch, remoteName ?? 'auto']);
 };
 
 type RefreshOptions = {
@@ -43,6 +50,7 @@ type PrTrackingTarget = {
 };
 
 type PrRuntimeParams = {
+  runtimeKey?: string;
   directory: string;
   branch: string;
   remoteName: string | null;
@@ -53,6 +61,7 @@ type PrRuntimeParams = {
 };
 
 type PrEntryIdentity = {
+  runtimeKey: string;
   directory: string;
   branch: string;
   remoteName: string | null;
@@ -69,6 +78,7 @@ type PrStatusEntry = {
   params: PrRuntimeParams | null;
   identity: PrEntryIdentity | null;
   resolvedRemoteName: string | null;
+  paramsRevision: number;
 };
 
 type PersistedPrStatusEntry = Pick<
@@ -87,12 +97,14 @@ type GitHubPrStatusStore = {
   refresh: (key: string, options?: RefreshOptions) => Promise<void>;
   refreshTargets: (targets: PrTrackingTarget[], options?: RefreshOptions) => Promise<void>;
   updateStatus: (key: string, updater: (prev: GitHubPullRequestStatus | null) => GitHubPullRequestStatus | null) => void;
+  resetForRuntimeSwitch: () => void;
 };
 
 const timers = new Map<string, number>();
 const bootstrapTimers = new Map<string, number[]>();
-const inFlightBySignature = new Set<string>();
+const inFlightBySignature = new Map<string, symbol>();
 const lastRefreshBySignature = new Map<string, number>();
+let prRuntimeGeneration = 0;
 
 // Global concurrency gate for PR-status network requests.
 //
@@ -141,6 +153,7 @@ const createEntry = (): PrStatusEntry => ({
   params: null,
   identity: null,
   resolvedRemoteName: null,
+  paramsRevision: 0,
 });
 
 const getIdentityFromEntry = (entry: PrStatusEntry | null | undefined): PrEntryIdentity | null => {
@@ -148,6 +161,7 @@ const getIdentityFromEntry = (entry: PrStatusEntry | null | undefined): PrEntryI
     return {
       directory: entry.params.directory,
       branch: entry.params.branch,
+      runtimeKey: entry.params.runtimeKey ?? entry.identity?.runtimeKey ?? getRuntimeKey(),
       remoteName: entry.params.remoteName ?? entry.resolvedRemoteName ?? entry.identity?.remoteName ?? null,
     };
   }
@@ -162,7 +176,7 @@ const getSignatureFromEntry = (entry: PrStatusEntry | null | undefined): string
   if (!identity?.directory || !identity.branch) {
     return null;
   }
-  return `${identity.directory}::${identity.branch}`;
+  return JSON.stringify([identity.runtimeKey, identity.directory, identity.branch, identity.remoteName ?? 'auto']);
 };
 
 const getKeysBySignature = (entries: Record<string, PrStatusEntry>, signature: string): string[] => {
@@ -172,20 +186,35 @@ const getKeysBySignature = (entries: Record<string, PrStatusEntry>, signature: s
 };
 
 const mergeParams = (entry: PrStatusEntry, next: PrRuntimeParams): PrStatusEntry => {
+  const runtimeKey = next.runtimeKey ?? getRuntimeKey();
   const remoteName = next.remoteName ?? entry.params?.remoteName ?? entry.resolvedRemoteName ?? entry.identity?.remoteName ?? null;
+  const paramsChanged = !entry.params
+    || entry.params.runtimeKey !== runtimeKey
+    || entry.params.directory !== next.directory
+    || entry.params.branch !== next.branch
+    || entry.params.remoteName !== remoteName
+    || entry.params.canShow !== next.canShow
+    || entry.params.github !== next.github
+    || entry.params.githubAuthChecked !== next.githubAuthChecked
+    || entry.params.githubConnected !== next.githubConnected;
   return {
     ...entry,
+    paramsRevision: paramsChanged ? entry.paramsRevision + 1 : entry.paramsRevision,
+    ...(paramsChanged ? { isLoading: false, error: null } : {}),
     params: entry.params
       ? {
         ...entry.params,
         ...next,
+        runtimeKey,
         remoteName,
       }
       : {
         ...next,
+        runtimeKey,
         remoteName,
       },
     identity: {
+      runtimeKey,
       directory: next.directory,
       branch: next.branch,
       remoteName,
@@ -256,6 +285,20 @@ const hydrateEntry = (entry: PersistedPrStatusEntry | undefined): PrStatusEntry
   resolvedRemoteName: entry?.resolvedRemoteName ?? entry?.status?.resolvedRemoteName ?? null,
 });
 
+const boundEntries = (entries: Record<string, PrStatusEntry>): Record<string, PrStatusEntry> => {
+  const all = Object.entries(entries);
+  if (all.length <= PR_MAX_ENTRIES) return entries;
+  return Object.fromEntries(all
+    .sort(([, left], [, right]) => {
+      const leftProtected = left.watchers > 0 || left.isLoading;
+      const rightProtected = right.watchers > 0 || right.isLoading;
+      if (leftProtected !== rightProtected) return leftProtected ? -1 : 1;
+      return Math.max(right.lastRefreshAt, right.lastDiscoveryPollAt)
+        - Math.max(left.lastRefreshAt, left.lastDiscoveryPollAt);
+    })
+    .slice(0, PR_MAX_ENTRIES));
+};
+
 export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
   persist(
     (set, get) => ({
@@ -263,16 +306,36 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
       activeRequestCount: 0,
       totalRequestCount: 0,
 
+      resetForRuntimeSwitch: () => {
+        prRuntimeGeneration += 1;
+        for (const timerId of timers.values()) window.clearInterval(timerId);
+        for (const timerIds of bootstrapTimers.values()) timerIds.forEach((timerId) => window.clearTimeout(timerId));
+        timers.clear();
+        bootstrapTimers.clear();
+        inFlightBySignature.clear();
+        lastRefreshBySignature.clear();
+        set((state) => ({
+          activeRequestCount: 0,
+          entries: Object.fromEntries(Object.entries(state.entries).map(([key, entry]) => [key, {
+            ...entry,
+            watchers: 0,
+            isLoading: false,
+            params: null,
+            paramsRevision: entry.paramsRevision + 1,
+          }])),
+        }));
+      },
+
       ensureEntry: (key) => {
         set((state) => {
           if (state.entries[key]) {
             return state;
           }
           return {
-            entries: {
+            entries: boundEntries({
               ...state.entries,
               [key]: createEntry(),
-            },
+            }),
           };
         });
       },
@@ -369,11 +432,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
           }
 
           const elapsed = Date.now() - entry.lastRefreshAt;
-          const nextInterval = isPendingChecks(entry.status)
-            ? PR_OPEN_BUSY_INTERVAL_MS
-            : (entry.status?.checks && entry.status.checks.state !== 'pending'
-                ? PR_OPEN_STABLE_INTERVAL_MS
-                : PR_OPEN_DEFAULT_INTERVAL_MS);
+          const nextInterval = getOpenPrRefreshInterval(entry.status);
           if (elapsed < nextInterval) {
             return;
           }
@@ -449,8 +508,17 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
           return;
         }
 
-        inFlightBySignature.add(signature);
-        lastRefreshBySignature.set(signature, Date.now());
+        const requestToken = Symbol(signature);
+        const runtimeGeneration = prRuntimeGeneration;
+        const paramsRevision = entry.paramsRevision;
+        const runtimeKey = entry.params?.runtimeKey ?? entry.identity?.runtimeKey ?? getRuntimeKey();
+        const isCurrent = () => (
+          runtimeGeneration === prRuntimeGeneration
+          && runtimeKey === getRuntimeKey()
+          && inFlightBySignature.get(signature) === requestToken
+          && get().entries[key]?.paramsRevision === paramsRevision
+        );
+        inFlightBySignature.set(signature, requestToken);
 
         set((prev) => {
           const nextEntries = { ...prev.entries };
@@ -461,7 +529,6 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
             }
             nextEntries[signatureKey] = {
               ...current,
-              lastRefreshAt: Date.now(),
               isLoading: options?.silent ? current.isLoading : true,
               error: null,
             };
@@ -472,6 +539,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
         });
 
         if (params.githubAuthChecked && params.githubConnected === false) {
+          if (!isCurrent()) return;
           set((prev) => {
             const nextEntries = { ...prev.entries };
             signatureKeys.forEach((signatureKey) => {
@@ -491,11 +559,12 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
               entries: nextEntries,
             };
           });
-          inFlightBySignature.delete(signature);
+          if (inFlightBySignature.get(signature) === requestToken) inFlightBySignature.delete(signature);
           return;
         }
 
         if (!params.github?.prStatus) {
+          if (!isCurrent()) return;
           set((prev) => {
             const nextEntries = { ...prev.entries };
             signatureKeys.forEach((signatureKey) => {
@@ -515,7 +584,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
               entries: nextEntries,
             };
           });
-          inFlightBySignature.delete(signature);
+          if (inFlightBySignature.get(signature) === requestToken) inFlightBySignature.delete(signature);
           return;
         }
 
@@ -528,10 +597,16 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
           await acquirePrStatusNetworkSlot();
           let next: GitHubPullRequestStatus;
           try {
+            if (!isCurrent()) return;
+            // Failed requests need the same non-forced cooldown as successful
+            // refreshes. Record only work that reaches the network slot so a
+            // stale queued request cannot suppress its replacement.
+            lastRefreshBySignature.set(signature, Date.now());
             next = await params.github.prStatus(params.directory, params.branch, params.remoteName ?? undefined, { force: options?.force });
           } finally {
             releasePrStatusNetworkSlot();
           }
+          if (!isCurrent()) return;
           set((prev) => {
             const nextEntries = { ...prev.entries };
             signatureKeys.forEach((signatureKey) => {
@@ -563,6 +638,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
 
               const resolvedRemoteName = status.resolvedRemoteName ?? current.resolvedRemoteName ?? params.remoteName ?? null;
               const identity = getIdentityFromEntry(current) ?? {
+                runtimeKey,
                 directory: params.directory,
                 branch: params.branch,
                 remoteName: params.remoteName ?? null,
@@ -574,6 +650,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
                 error: null,
                 isLoading: options?.silent ? current.isLoading : false,
                 isInitialStatusResolved: options?.markInitialResolved === false ? current.isInitialStatusResolved : true,
+                lastRefreshAt: Date.now(),
                 resolvedRemoteName,
                 identity: {
                   ...identity,
@@ -587,6 +664,7 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
             };
           });
         } catch (error) {
+          if (!isCurrent()) return;
           const message = error instanceof Error ? error.message : String(error);
           set((prev) => {
             const nextEntries = { ...prev.entries };
@@ -607,8 +685,10 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
             };
           });
         } finally {
-          inFlightBySignature.delete(signature);
-          set((prev) => ({ ...prev, activeRequestCount: Math.max(0, prev.activeRequestCount - 1) }));
+          if (inFlightBySignature.get(signature) === requestToken) inFlightBySignature.delete(signature);
+          if (runtimeGeneration === prRuntimeGeneration) {
+            set((prev) => ({ ...prev, activeRequestCount: Math.max(0, prev.activeRequestCount - 1) }));
+          }
         }
       },
 
@@ -648,6 +728,8 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
     {
       name: PR_STATUS_STORAGE_KEY,
       storage: createDeferredSafeJSONStorage(),
+      version: 2,
+      migrate: (persistedState, version) => version < 2 ? { entries: {} } : persistedState,
       partialize: (state) => ({
         entries: Object.fromEntries(
           Object.entries(state.entries)
@@ -657,8 +739,11 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
                 return false;
               }
               const freshness = Math.max(entry.lastRefreshAt, entry.lastDiscoveryPollAt);
-              return freshness === 0 || Date.now() - freshness < PR_PERSIST_TTL_MS;
+              return freshness > 0 && Date.now() - freshness < PR_PERSIST_TTL_MS;
             })
+            .sort(([, left], [, right]) => Math.max(right.lastRefreshAt, right.lastDiscoveryPollAt)
+              - Math.max(left.lastRefreshAt, left.lastDiscoveryPollAt))
+            .slice(0, PR_MAX_ENTRIES)
             .map(([key, entry]) => [key, toPersistedEntry(entry)]),
         ),
       }),
@@ -668,7 +753,14 @@ export const useGitHubPrStatusStore = create<GitHubPrStatusStore>()(
         return {
           ...current,
           entries: Object.fromEntries(
-            Object.entries(persistedEntries).map(([key, entry]) => [key, hydrateEntry(entry)]),
+            Object.entries(persistedEntries)
+              .filter(([, entry]) => Boolean(
+                entry.identity?.runtimeKey
+                && Math.max(entry.lastRefreshAt, entry.lastDiscoveryPollAt) > 0
+                && Date.now() - Math.max(entry.lastRefreshAt, entry.lastDiscoveryPollAt) < PR_PERSIST_TTL_MS,
+              ))
+              .slice(0, PR_MAX_ENTRIES)
+              .map(([key, entry]) => [key, hydrateEntry(entry)]),
           ),
         };
       },
diff --git a/packages/ui/src/stores/useGitStore.test.ts b/packages/ui/src/stores/useGitStore.test.ts
index 6eb5c6fc..01180db1 100644
--- a/packages/ui/src/stores/useGitStore.test.ts
+++ b/packages/ui/src/stores/useGitStore.test.ts
@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, test } from 'bun:test';
 import type { GitStatus } from '@/lib/api/types';
 import { useGitStore } from './useGitStore';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 type Deferred<T> = {
   promise: Promise<T>;
@@ -39,7 +40,7 @@ const createDirectoryState = (status: GitStatus): DirectoryGitState => ({
   identity: null,
   diffCache: new Map(),
   indexRevision: 0,
-  lastRepoCheckAt: 0,
+  lastRepoCheckAt: Date.now(),
   lastStatusFetch: 0,
   lastStatusChange: 0,
   lastLogFetch: 0,
@@ -70,13 +71,11 @@ const createGitApi = (getGitStatus: GitAPI['getGitStatus']): GitAPI => ({
 
 describe('useGitStore', () => {
   beforeEach(() => {
-    useGitStore.setState({
-      directories: new Map(),
-      activeDirectory: null,
-    });
+    useGitStore.getState().resetForRuntimeSwitch(getRuntimeKey());
   });
 
   test('does not reuse an in-flight light status request for full status', async () => {
+    setDirectoryStatus(createStatus());
     const requests: Deferred<GitStatus>[] = [];
     const statusCalls: Array<{ directory: string; options?: { mode?: 'light' } }> = [];
     const git = createGitApi((directory, options) => {
@@ -95,12 +94,18 @@ describe('useGitStore', () => {
       { directory: '/repo', options: undefined },
     ]);
 
-    requests[0].resolve(createStatus());
     requests[1].resolve(createStatus({ 'src/index.ts': { insertions: 1, deletions: 0 } }));
-    await Promise.all([lightPromise, fullPromise]);
+    await fullPromise;
+    requests[0].resolve(createStatus());
+    await lightPromise;
+
+    expect(useGitStore.getState().getDirectoryState('/repo')?.status?.diffStats).toEqual({
+      'src/index.ts': { insertions: 1, deletions: 0 },
+    });
   });
 
   test('reuses an in-flight full status request for light status', async () => {
+    setDirectoryStatus(createStatus());
     const requests: Deferred<GitStatus>[] = [];
     const statusCalls: Array<{ directory: string; options?: { mode?: 'light' } }> = [];
     const git = createGitApi((directory, options) => {
@@ -121,6 +126,59 @@ describe('useGitStore', () => {
     expect(lightResult).toBe(fullResult);
   });
 
+  test('does not let an older status fetch undo an optimistic mutation', async () => {
+    const initial = createStatus(undefined, [{ path: 'src/index.ts', index: ' ', working_dir: 'M' }]);
+    setDirectoryStatus(initial);
+    const request = createDeferred<GitStatus>();
+    const git = createGitApi(() => request.promise);
+
+    const loading = useGitStore.getState().fetchStatus('/repo', git, { silent: true });
+    useGitStore.getState().moveStatusPathsOptimistically('/repo', ['src/index.ts'], 'stage');
+    request.resolve(initial);
+    await loading;
+
+    expect(useGitStore.getState().getDirectoryState('/repo')?.status?.files).toEqual([
+      { path: 'src/index.ts', index: 'M', working_dir: ' ' },
+    ]);
+  });
+
+  test('rejects an old runtime completion after reset', async () => {
+    setDirectoryStatus(createStatus());
+    const request = createDeferred<GitStatus>();
+    const git = createGitApi(() => request.promise);
+    const loading = useGitStore.getState().fetchStatus('/repo', git, { silent: true });
+
+    useGitStore.getState().resetForRuntimeSwitch('runtime-b');
+    request.resolve(createStatus(undefined, [{ path: 'stale.ts', index: 'M', working_dir: ' ' }]));
+    await loading;
+
+    expect(useGitStore.getState().runtimeKey).toBe('runtime-b');
+    expect(useGitStore.getState().getDirectoryState('/repo')?.status ?? null).toBe(null);
+  });
+
+  test('rejects direct diff commits captured for another runtime', () => {
+    useGitStore.getState().setDiff('/repo', 'stale.ts', { original: 'a', modified: 'b' }, 'runtime-a');
+    expect(useGitStore.getState().getDiff('/repo', 'stale.ts')).toBe(null);
+  });
+
+  test('keeps the newest branch request when completions are reversed', async () => {
+    const requests = [createDeferred<Awaited<ReturnType<GitAPI['getGitBranches']>>>(), createDeferred<Awaited<ReturnType<GitAPI['getGitBranches']>>>()];
+    let index = 0;
+    const git = {
+      ...createGitApi(async () => createStatus()),
+      getGitBranches: () => requests[index++].promise,
+    };
+    const first = useGitStore.getState().fetchBranches('/repo', git);
+    const second = useGitStore.getState().fetchBranches('/repo', git);
+
+    requests[1].resolve({ all: ['new'], current: 'new', branches: {} });
+    await second;
+    requests[0].resolve({ all: ['old'], current: 'old', branches: {} });
+    await first;
+
+    expect(useGitStore.getState().getDirectoryState('/repo')?.branches?.current).toBe('new');
+  });
+
   test('optimistically stages modified files and preserves untouched file references', () => {
     const target = { path: 'src/index.ts', index: ' ', working_dir: 'M' };
     const untouched = { path: 'README.md', index: ' ', working_dir: 'M' };
diff --git a/packages/ui/src/stores/useGitStore.ts b/packages/ui/src/stores/useGitStore.ts
index 05a5648b..d066f1e8 100644
--- a/packages/ui/src/stores/useGitStore.ts
+++ b/packages/ui/src/stores/useGitStore.ts
@@ -8,6 +8,7 @@ import type {
   GitIdentitySummary,
 } from '@/lib/api/types';
 import { getDeferredSafeStorage } from '@/stores/utils/safeStorage';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 const LOG_STALE_THRESHOLD = 10000;
 const REPO_CHECK_STALE_THRESHOLD = 60_000;
@@ -23,6 +24,7 @@ const DIFF_PREFETCH_LARGE_FILE_THRESHOLD = 500; // skip prefetch for files with
 // Diff cache limits to prevent memory bloat with many modified files
 const DIFF_CACHE_MAX_ENTRIES = 30;
 const DIFF_CACHE_MAX_TOTAL_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
+const DIFF_CACHE_MAX_GLOBAL_ENTRIES = 200;
 type GitStatusFetchMode = 'full' | 'light';
 
 interface DirectoryGitState {
@@ -47,7 +49,7 @@ interface DirectoryGitState {
 }
 
 interface GitStore {
-
+  runtimeKey: string;
   directories: Map<string, DirectoryGitState>;
 
   activeDirectory: string | null;
@@ -68,7 +70,7 @@ interface GitStore {
   bumpIndexRevision: (directory: string) => void;
 
   getDiff: (directory: string, filePath: string) => { original: string; modified: string; fetchedAt: number; isBinary?: boolean } | null;
-  setDiff: (directory: string, filePath: string, diff: { original: string; modified: string; isBinary?: boolean }) => void;
+  setDiff: (directory: string, filePath: string, diff: { original: string; modified: string; isBinary?: boolean }, expectedRuntimeKey?: string) => void;
   clearDiffCache: (directory: string) => void;
   fetchAllDiffs: (directory: string, git: GitAPI) => Promise<void>;
   prefetchDiffs: (directory: string, git: GitAPI, filePaths: string[], options?: { maxFiles?: number }) => Promise<void>;
@@ -76,6 +78,7 @@ interface GitStore {
   setLogMaxCount: (directory: string, maxCount: number) => void;
 
   refresh: (git: GitAPI, options?: { force?: boolean }) => Promise<void>;
+  resetForRuntimeSwitch: (runtimeKey: string) => void;
 }
 
 interface GitFileDiffResponse {
@@ -98,25 +101,72 @@ const inFlightDiffFetchesByDirectory = new Map<string, Set<string>>();
 const diffFetchGenerationByDirectory = new Map<string, number>();
 const inFlightStatusFetches = new Map<string, Promise<boolean>>();
 const inFlightEnsureAllByDirectory = new Map<string, Promise<void>>();
+const requestGenerationByChannel = new Map<string, number>();
+const statusMutationRevisionByDirectory = new Map<string, number>();
+let gitRuntimeGeneration = 0;
+let activeGitRuntimeKey = getRuntimeKey();
 
-const getStatusFetchKey = (directory: string, mode: GitStatusFetchMode): string => `${mode}:${directory}`;
+const runtimeDirectoryKey = (runtimeKey: string, directory: string) => JSON.stringify([runtimeKey, directory]);
+const getStatusFetchKey = (runtimeKey: string, directory: string, mode: GitStatusFetchMode): string =>
+  JSON.stringify([runtimeKey, directory, mode]);
+const channelKey = (runtimeKey: string, directory: string, channel: string) =>
+  JSON.stringify([runtimeKey, directory, channel]);
+
+type GitRequestToken = {
+  runtimeKey: string;
+  runtimeGeneration: number;
+  channelKey: string;
+  requestGeneration: number;
+  statusMutationRevision?: number;
+};
+
+const startRequest = (directory: string, channel: string, includeStatusMutation = false): GitRequestToken => {
+  const runtimeKey = getRuntimeKey();
+  const key = channelKey(runtimeKey, directory, channel);
+  const requestGeneration = (requestGenerationByChannel.get(key) ?? 0) + 1;
+  requestGenerationByChannel.set(key, requestGeneration);
+  return {
+    runtimeKey,
+    runtimeGeneration: gitRuntimeGeneration,
+    channelKey: key,
+    requestGeneration,
+    ...(includeStatusMutation
+      ? { statusMutationRevision: statusMutationRevisionByDirectory.get(runtimeDirectoryKey(runtimeKey, directory)) ?? 0 }
+      : {}),
+  };
+};
+
+const isRequestCurrent = (token: GitRequestToken, directory: string): boolean => (
+  token.runtimeKey === getRuntimeKey()
+  && token.runtimeKey === activeGitRuntimeKey
+  && token.runtimeGeneration === gitRuntimeGeneration
+  && requestGenerationByChannel.get(token.channelKey) === token.requestGeneration
+  && (token.statusMutationRevision === undefined
+    || token.statusMutationRevision === (statusMutationRevisionByDirectory.get(runtimeDirectoryKey(token.runtimeKey, directory)) ?? 0))
+);
+
+const bumpStatusMutationRevision = (runtimeKey: string, directory: string): void => {
+  const key = runtimeDirectoryKey(runtimeKey, directory);
+  statusMutationRevisionByDirectory.set(key, (statusMutationRevisionByDirectory.get(key) ?? 0) + 1);
+};
 
 const getDiffFetchGeneration = (directory: string): number =>
-  diffFetchGenerationByDirectory.get(directory) ?? 0;
+  diffFetchGenerationByDirectory.get(runtimeDirectoryKey(getRuntimeKey(), directory)) ?? 0;
 
 const bumpDiffFetchGeneration = (directory: string): number => {
   const next = getDiffFetchGeneration(directory) + 1;
-  diffFetchGenerationByDirectory.set(directory, next);
+  diffFetchGenerationByDirectory.set(runtimeDirectoryKey(getRuntimeKey(), directory), next);
   return next;
 };
 
 const getInFlightDiffs = (directory: string): Set<string> => {
-  const existing = inFlightDiffFetchesByDirectory.get(directory);
+  const key = runtimeDirectoryKey(getRuntimeKey(), directory);
+  const existing = inFlightDiffFetchesByDirectory.get(key);
   if (existing) {
     return existing;
   }
   const created = new Set<string>();
-  inFlightDiffFetchesByDirectory.set(directory, created);
+  inFlightDiffFetchesByDirectory.set(key, created);
   return created;
 };
 
@@ -152,33 +202,71 @@ const createEmptyDirectoryState = (): DirectoryGitState => ({
 // branch list is cached — never status/log/diff.
 // ---------------------------------------------------------------------------
 const GIT_BRANCH_CACHE_KEY = 'oc.gitBranchCache';
+const GIT_BRANCH_CACHE_V2_KEY = 'oc.gitBranchCache.v2';
+const MAX_BRANCH_CACHE_RUNTIMES = 8;
+const MAX_BRANCH_CACHE_DIRECTORIES = 50;
+type BranchCacheEnvelope = {
+  version: 2;
+  legacyClaimed: boolean;
+  runtimes: Record<string, { updatedAt: number; directories: Record<string, { branches: GitBranch; updatedAt: number }> }>;
+};
 
-const readBranchCache = (): Record<string, GitBranch> => {
+const emptyBranchCache = (): BranchCacheEnvelope => ({ version: 2, legacyClaimed: false, runtimes: {} });
+
+const readBranchCacheEnvelope = (runtimeKey: string): BranchCacheEnvelope => {
   try {
-    const raw = getDeferredSafeStorage().getItem(GIT_BRANCH_CACHE_KEY);
-    if (!raw) return {};
-    const parsed = JSON.parse(raw) as Record<string, GitBranch>;
-    return parsed && typeof parsed === 'object' ? parsed : {};
+    const storage = getDeferredSafeStorage();
+    const raw = storage.getItem(GIT_BRANCH_CACHE_V2_KEY);
+    const parsed = raw ? JSON.parse(raw) as Partial<BranchCacheEnvelope> : emptyBranchCache();
+    const envelope: BranchCacheEnvelope = parsed?.version === 2 && parsed.runtimes && typeof parsed.runtimes === 'object'
+      ? { version: 2, legacyClaimed: Boolean(parsed.legacyClaimed), runtimes: parsed.runtimes }
+      : emptyBranchCache();
+    if (!envelope.legacyClaimed) {
+      const legacyRaw = storage.getItem(GIT_BRANCH_CACHE_KEY);
+      if (legacyRaw) {
+        const legacy = JSON.parse(legacyRaw) as Record<string, GitBranch>;
+        const directories: BranchCacheEnvelope['runtimes'][string]['directories'] = {};
+        for (const [directory, branches] of Object.entries(legacy ?? {})) {
+          if (directory && branches && Array.isArray(branches.all)) directories[directory] = { branches, updatedAt: 0 };
+        }
+        if (Object.keys(directories).length > 0) envelope.runtimes[runtimeKey] = { updatedAt: 0, directories };
+      }
+      envelope.legacyClaimed = true;
+      const serialized = JSON.stringify(envelope);
+      storage.setItem(GIT_BRANCH_CACHE_V2_KEY, serialized);
+      if (storage.getItem(GIT_BRANCH_CACHE_V2_KEY) === serialized) storage.removeItem(GIT_BRANCH_CACHE_KEY);
+    }
+    return envelope;
   } catch {
-    return {};
+    return emptyBranchCache();
   }
 };
 
-const writeCachedBranches = (directory: string, branches: GitBranch): void => {
+const writeCachedBranches = (runtimeKey: string, directory: string, branches: GitBranch): void => {
   if (!directory || !branches) return;
   try {
-    const cache = readBranchCache();
-    cache[directory] = branches;
-    getDeferredSafeStorage().setItem(GIT_BRANCH_CACHE_KEY, JSON.stringify(cache));
+    const envelope = readBranchCacheEnvelope(runtimeKey);
+    const now = Date.now();
+    const current = envelope.runtimes[runtimeKey]?.directories ?? {};
+    const directories = { ...current, [directory]: { branches, updatedAt: now } };
+    const boundedDirectories = Object.fromEntries(
+      Object.entries(directories).sort(([, left], [, right]) => right.updatedAt - left.updatedAt).slice(0, MAX_BRANCH_CACHE_DIRECTORIES),
+    );
+    envelope.runtimes[runtimeKey] = { updatedAt: now, directories: boundedDirectories };
+    envelope.runtimes = Object.fromEntries(
+      Object.entries(envelope.runtimes).sort(([, left], [, right]) => right.updatedAt - left.updatedAt).slice(0, MAX_BRANCH_CACHE_RUNTIMES),
+    );
+    getDeferredSafeStorage().setItem(GIT_BRANCH_CACHE_V2_KEY, JSON.stringify(envelope));
   } catch {
     // quota / serialization — ignore; live fetch still refreshes the store
   }
 };
 
-const seedDirectoriesFromBranchCache = (): Map<string, DirectoryGitState> => {
+const seedDirectoriesFromBranchCache = (runtimeKey: string): Map<string, DirectoryGitState> => {
   const directories = new Map<string, DirectoryGitState>();
-  const cache = readBranchCache();
-  for (const [directory, branches] of Object.entries(cache)) {
+  const cache = readBranchCacheEnvelope(runtimeKey).runtimes[runtimeKey]?.directories ?? {};
+  for (const [directory, entry] of Object.entries(cache)) {
+    const branches = entry.branches;
     if (!directory || !branches || !Array.isArray(branches.all)) continue;
     // A cached branch list implies the directory was a git repo. Seed isGitRepo
     // so the selector's gate passes immediately; lastBranchesFetch stays 0 so the
@@ -197,7 +285,8 @@ const evictDiffCacheIfNeeded = (
   // Calculate total size
   let totalSize = 0;
   for (const entry of diffCache.values()) {
-    totalSize += (entry.original?.length ?? 0) + (entry.modified?.length ?? 0);
+    totalSize += new TextEncoder().encode(entry.original ?? '').byteLength
+      + new TextEncoder().encode(entry.modified ?? '').byteLength;
   }
 
   // If within limits, return as-is
@@ -215,10 +304,11 @@ const evictDiffCacheIfNeeded = (
   // Keep entries from newest to oldest until limits are reached
   for (let i = entries.length - 1; i >= 0; i--) {
     const [path, entry] = entries[i];
-    const entrySize = (entry.original?.length ?? 0) + (entry.modified?.length ?? 0);
+    const entrySize = new TextEncoder().encode(entry.original ?? '').byteLength
+      + new TextEncoder().encode(entry.modified ?? '').byteLength;
 
     if (newCache.size >= maxEntries) break;
-    if (newTotalSize + entrySize > maxTotalSize && newCache.size > 0) continue;
+    if (newTotalSize + entrySize > maxTotalSize) continue;
 
     newCache.set(path, entry);
     newTotalSize += entrySize;
@@ -227,6 +317,39 @@ const evictDiffCacheIfNeeded = (
   return newCache;
 };
 
+const diffEntrySize = (entry: { original: string; modified: string }): number => {
+  const encoder = new TextEncoder();
+  return encoder.encode(entry.original ?? '').byteLength + encoder.encode(entry.modified ?? '').byteLength;
+};
+
+const evictGlobalDiffCachesIfNeeded = (directories: Map<string, DirectoryGitState>): Map<string, DirectoryGitState> => {
+  const entries: Array<{ directory: string; path: string; fetchedAt: number; size: number }> = [];
+  let totalSize = 0;
+  for (const [directory, state] of directories) {
+    for (const [path, entry] of state.diffCache) {
+      const size = diffEntrySize(entry);
+      entries.push({ directory, path, fetchedAt: entry.fetchedAt, size });
+      totalSize += size;
+    }
+  }
+  if (entries.length <= DIFF_CACHE_MAX_GLOBAL_ENTRIES && totalSize <= DIFF_CACHE_MAX_TOTAL_SIZE_BYTES) return directories;
+
+  const next = new Map(directories);
+  entries.sort((left, right) => left.fetchedAt - right.fetchedAt);
+  let count = entries.length;
+  for (const entry of entries) {
+    if (count <= DIFF_CACHE_MAX_GLOBAL_ENTRIES && totalSize <= DIFF_CACHE_MAX_TOTAL_SIZE_BYTES) break;
+    const state = next.get(entry.directory);
+    if (!state?.diffCache.has(entry.path)) continue;
+    const diffCache = new Map(state.diffCache);
+    diffCache.delete(entry.path);
+    next.set(entry.directory, { ...state, diffCache });
+    count -= 1;
+    totalSize -= entry.size;
+  }
+  return next;
+};
+
 const haveDiffStatsChanged = (
   previous?: GitStatus['diffStats'],
   next?: GitStatus['diffStats']
@@ -418,12 +541,27 @@ const toUnstagedStatusFile = (file: GitStatus['files'][number]): GitStatus['file
 const isCleanStatusFile = (file: GitStatus['files'][number]): boolean =>
   isBlankStatusCode(file.index) && isBlankStatusCode(file.working_dir);
 
+const initialGitRuntimeKey = activeGitRuntimeKey;
+
 export const useGitStore = create<GitStore>()(
   devtools(
     (set, get) => ({
-      directories: seedDirectoriesFromBranchCache(),
+      runtimeKey: initialGitRuntimeKey,
+      directories: seedDirectoriesFromBranchCache(initialGitRuntimeKey),
       activeDirectory: null,
 
+      resetForRuntimeSwitch: (runtimeKey) => {
+        gitRuntimeGeneration += 1;
+        activeGitRuntimeKey = runtimeKey;
+        requestGenerationByChannel.clear();
+        statusMutationRevisionByDirectory.clear();
+        inFlightStatusFetches.clear();
+        inFlightEnsureAllByDirectory.clear();
+        inFlightDiffFetchesByDirectory.clear();
+        diffFetchGenerationByDirectory.clear();
+        set({ runtimeKey, directories: seedDirectoriesFromBranchCache(runtimeKey), activeDirectory: null });
+      },
+
       setActiveDirectory: (directory) => {
         const { activeDirectory, directories } = get();
         if (activeDirectory === directory) return;
@@ -450,13 +588,15 @@ export const useGitStore = create<GitStore>()(
 
       fetchStatus: async (directory, git, options = {}) => {
         const statusFetchMode: GitStatusFetchMode = options.mode ?? 'full';
-        const statusFetchKey = getStatusFetchKey(directory, statusFetchMode);
+        const runtimeKey = getRuntimeKey();
+        const statusFetchKey = getStatusFetchKey(runtimeKey, directory, statusFetchMode);
         const existing = inFlightStatusFetches.get(statusFetchKey)
-          ?? (statusFetchMode === 'light' ? inFlightStatusFetches.get(getStatusFetchKey(directory, 'full')) : undefined);
+          ?? (statusFetchMode === 'light' ? inFlightStatusFetches.get(getStatusFetchKey(runtimeKey, directory, 'full')) : undefined);
         if (existing) {
           return existing;
         }
 
+        const token = startRequest(directory, 'status', true);
         const fetchPromise = (async () => {
           const { silent = false } = options;
           const { directories } = get();
@@ -484,6 +624,7 @@ export const useGitStore = create<GitStore>()(
             let isRepo = dirState.isGitRepo === true;
             if (shouldProbeRepository) {
               isRepo = await git.checkIsGitRepository(directory);
+              if (!isRequestCurrent(token, directory)) return false;
             }
 
             if (!isRepo) {
@@ -502,8 +643,10 @@ export const useGitStore = create<GitStore>()(
             }
 
             const newStatus = await git.getGitStatus(directory, options.mode ? { mode: options.mode } : undefined);
+            if (!isRequestCurrent(token, directory)) return false;
 
-            if (hasStatusChanged(dirState.status, newStatus)) {
+            const latestState = get().directories.get(directory) ?? createEmptyDirectoryState();
+            if (hasStatusChanged(latestState.status, newStatus)) {
               statusChanged = true;
               const newDirectories = new Map(get().directories);
               const currentDirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
@@ -573,7 +716,7 @@ export const useGitStore = create<GitStore>()(
           } catch (error) {
             console.error('Failed to fetch git status:', error);
           } finally {
-            if (!silent) {
+            if (!silent && isRequestCurrent(token, directory)) {
               const newDirectories = new Map(get().directories);
               const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
               newDirectories.set(directory, { ...d, isLoadingStatus: false });
@@ -636,6 +779,8 @@ export const useGitStore = create<GitStore>()(
           return previousStatus;
         }
 
+        bumpStatusMutationRevision(get().runtimeKey, directory);
+
         const nextDirectories = new Map(directories);
         nextDirectories.set(directory, {
           ...dirState,
@@ -659,6 +804,8 @@ export const useGitStore = create<GitStore>()(
           return;
         }
 
+        bumpStatusMutationRevision(get().runtimeKey, directory);
+
         const nextDirectories = new Map(directories);
         nextDirectories.set(directory, {
           ...dirState,
@@ -676,6 +823,8 @@ export const useGitStore = create<GitStore>()(
           return;
         }
 
+        bumpStatusMutationRevision(get().runtimeKey, directory);
+
         const nextDirectories = new Map(directories);
         nextDirectories.set(directory, {
           ...dirState,
@@ -685,6 +834,7 @@ export const useGitStore = create<GitStore>()(
       },
 
       fetchBranches: async (directory, git) => {
+        const token = startRequest(directory, 'branches');
         {
           const newDirectories = new Map(get().directories);
           const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
@@ -694,13 +844,15 @@ export const useGitStore = create<GitStore>()(
 
         try {
           const branches = await git.getGitBranches(directory);
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, { ...dirState, branches, isLoadingBranches: false, lastBranchesFetch: Date.now() });
           set({ directories: newDirectories });
-          writeCachedBranches(directory, branches);
+          writeCachedBranches(token.runtimeKey, directory, branches);
         } catch (error) {
           console.error('Failed to fetch git branches:', error);
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, { ...d, isLoadingBranches: false });
@@ -709,6 +861,7 @@ export const useGitStore = create<GitStore>()(
       },
 
       fetchLog: async (directory, git, maxCount) => {
+        const token = startRequest(directory, 'log');
         const { directories } = get();
         const dirState = directories.get(directory);
         const effectiveMaxCount = maxCount ?? dirState?.logMaxCount ?? 25;
@@ -722,6 +875,7 @@ export const useGitStore = create<GitStore>()(
 
         try {
           const log = await git.getGitLog(directory, { maxCount: effectiveMaxCount });
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const currentDirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, {
@@ -734,6 +888,7 @@ export const useGitStore = create<GitStore>()(
           set({ directories: newDirectories });
         } catch (error) {
           console.error('Failed to fetch git log:', error);
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, { ...d, isLoadingLog: false });
@@ -742,6 +897,7 @@ export const useGitStore = create<GitStore>()(
       },
 
       fetchIdentity: async (directory, git) => {
+        const token = startRequest(directory, 'identity');
         {
           const newDirectories = new Map(get().directories);
           const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
@@ -751,12 +907,14 @@ export const useGitStore = create<GitStore>()(
 
         try {
           const identity = await git.getCurrentGitIdentity(directory);
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, { ...dirState, identity, isLoadingIdentity: false, lastIdentityFetch: Date.now() });
           set({ directories: newDirectories });
         } catch (error) {
           console.error('Failed to fetch git identity:', error);
+          if (!isRequestCurrent(token, directory)) return;
           const newDirectories = new Map(get().directories);
           const d = newDirectories.get(directory) ?? createEmptyDirectoryState();
           newDirectories.set(directory, { ...d, isLoadingIdentity: false });
@@ -803,7 +961,9 @@ export const useGitStore = create<GitStore>()(
         return dirState?.diffCache.get(filePath) ?? null;
       },
 
-      setDiff: (directory, filePath, diff) => {
+      setDiff: (directory, filePath, diff, expectedRuntimeKey) => {
+        if (expectedRuntimeKey && expectedRuntimeKey !== get().runtimeKey) return;
+        if (diffEntrySize(diff) > DIFF_CACHE_MAX_TOTAL_SIZE_BYTES) return;
         const newDirectories = new Map(get().directories);
         const dirState = newDirectories.get(directory) ?? createEmptyDirectoryState();
         const newDiffCache = new Map(dirState.diffCache);
@@ -811,11 +971,12 @@ export const useGitStore = create<GitStore>()(
         // Apply LRU eviction to prevent memory bloat
         const evictedCache = evictDiffCacheIfNeeded(newDiffCache);
         newDirectories.set(directory, { ...dirState, diffCache: evictedCache });
-        set({ directories: newDirectories });
+        set({ directories: evictGlobalDiffCachesIfNeeded(newDirectories) });
       },
 
       clearDiffCache: (directory) => {
         bumpDiffFetchGeneration(directory);
+        startRequest(directory, 'diff');
         const newDirectories = new Map(get().directories);
         const dirState = newDirectories.get(directory);
         if (dirState) {
@@ -835,6 +996,7 @@ export const useGitStore = create<GitStore>()(
       },
 
       prefetchDiffs: async (directory, git, filePaths, options = {}) => {
+        const token = startRequest(directory, 'diff');
         const dirState = get().directories.get(directory);
         if (!dirState?.status?.files || dirState.status.files.length === 0 || filePaths.length === 0) return;
 
@@ -901,7 +1063,7 @@ export const useGitStore = create<GitStore>()(
 
         const worker = async () => {
           for (;;) {
-            if (generation !== getDiffFetchGeneration(directory)) {
+            if (generation !== getDiffFetchGeneration(directory) || !isRequestCurrent(token, directory)) {
               return;
             }
             const next = takeNext();
@@ -921,7 +1083,7 @@ export const useGitStore = create<GitStore>()(
 
         limitedFilePaths.forEach((path) => inFlight.delete(path));
 
-        if (generation !== getDiffFetchGeneration(directory)) {
+        if (generation !== getDiffFetchGeneration(directory) || !isRequestCurrent(token, directory)) {
           return;
         }
 
@@ -943,7 +1105,7 @@ export const useGitStore = create<GitStore>()(
         // Apply LRU eviction to prevent memory bloat
         const evictedCache = evictDiffCacheIfNeeded(newDiffCache);
         newDirectories.set(directory, { ...currentDirState, diffCache: evictedCache });
-        set({ directories: newDirectories });
+        set({ directories: evictGlobalDiffCachesIfNeeded(newDirectories) });
       },
 
       setLogMaxCount: (directory, maxCount) => {
@@ -963,7 +1125,8 @@ export const useGitStore = create<GitStore>()(
       },
 
       ensureAll: (directory, git) => {
-        const existing = inFlightEnsureAllByDirectory.get(directory);
+        const ensureKey = runtimeDirectoryKey(getRuntimeKey(), directory);
+        const existing = inFlightEnsureAllByDirectory.get(ensureKey);
         if (existing) return existing;
 
         const promise = (async () => {
@@ -993,10 +1156,10 @@ export const useGitStore = create<GitStore>()(
           if (fetches.length > 0) await Promise.all(fetches);
         })();
 
-        inFlightEnsureAllByDirectory.set(directory, promise);
+        inFlightEnsureAllByDirectory.set(ensureKey, promise);
         promise.finally(() => {
-          if (inFlightEnsureAllByDirectory.get(directory) === promise) {
-            inFlightEnsureAllByDirectory.delete(directory);
+          if (inFlightEnsureAllByDirectory.get(ensureKey) === promise) {
+            inFlightEnsureAllByDirectory.delete(ensureKey);
           }
         });
 
@@ -1056,9 +1219,11 @@ export const useGitBranchLabel = (directory: string | null) => {
 };
 
 const allBranchesCacheRef = { current: new Map<string, string | null>() };
+const EMPTY_BRANCHES = new Map<string, string | null>();
 
-export const useGitAllBranches = () => {
+export const useGitAllBranches = (enabled = true) => {
   return useGitStore((state) => {
+    if (!enabled) return EMPTY_BRANCHES;
     const prev = allBranchesCacheRef.current;
     let same = prev.size === state.directories.size;
     if (same) {
diff --git a/packages/ui/src/stores/useGlobalSessionsStore-races.test.ts b/packages/ui/src/stores/useGlobalSessionsStore-races.test.ts
new file mode 100644
index 00000000..eb949319
--- /dev/null
+++ b/packages/ui/src/stores/useGlobalSessionsStore-races.test.ts
@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test"
+import type { Session } from "@opencode-ai/sdk/v2"
+
+type Deferred<T> = {
+  promise: Promise<T>
+  resolve: (value: T) => void
+  reject: (reason: unknown) => void
+}
+
+const deferred = <T>(): Deferred<T> => {
+  let resolve!: (value: T) => void
+  let reject!: (reason: unknown) => void
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}
+
+let activeRequest: Deferred<Session[]>
+let archivedRequest: Deferred<Session[]>
+
+mock.module("@/lib/opencode/client", () => ({
+  opencodeClient: { getSdkClient: () => ({}), getDirectory: () => "/source", setDirectory: () => undefined },
+}))
+mock.module("@/stores/globalSessions", () => ({
+  listGlobalSessionPages: (_sdk: unknown, options: { archived?: boolean }) => (
+    options.archived ? archivedRequest.promise : activeRequest.promise
+  ),
+}))
+
+const { useGlobalSessionsStore } = await import("./useGlobalSessionsStore")
+
+const session = (id: string, title = id, archived?: number): Session => ({
+  id,
+  title,
+  time: { created: 1, updated: 1, ...(archived ? { archived } : {}) },
+} as Session)
+
+describe("global session mutation reconciliation", () => {
+  beforeEach(() => {
+    activeRequest = deferred<Session[]>()
+    archivedRequest = deferred<Session[]>()
+    useGlobalSessionsStore.getState().resetForRuntimeSwitch()
+  })
+
+  test("keeps a session created after a full load starts", async () => {
+    const loading = useGlobalSessionsStore.getState().loadSessions()
+    useGlobalSessionsStore.getState().upsertSession(session("created"))
+
+    activeRequest.resolve([])
+    archivedRequest.resolve([])
+    await loading
+
+    expect(useGlobalSessionsStore.getState().activeSessions.map((item) => item.id)).toEqual(["created"])
+  })
+
+  test("does not resurrect a session deleted after a full load starts", async () => {
+    const stale = session("deleted")
+    useGlobalSessionsStore.getState().applySnapshot([stale], [])
+    const loading = useGlobalSessionsStore.getState().loadSessions()
+    useGlobalSessionsStore.getState().removeSessions([stale.id])
+
+    activeRequest.resolve([stale])
+    archivedRequest.resolve([])
+    await loading
+
+    expect(useGlobalSessionsStore.getState().activeSessions).toEqual([])
+    expect(useGlobalSessionsStore.getState().archivedSessions).toEqual([])
+  })
+
+  test("keeps an archive mutation newer than both list requests", async () => {
+    const stale = session("archived")
+    useGlobalSessionsStore.getState().applySnapshot([stale], [])
+    const loading = useGlobalSessionsStore.getState().loadSessions()
+    useGlobalSessionsStore.getState().archiveSessions([stale.id], 10)
+
+    activeRequest.resolve([stale])
+    archivedRequest.resolve([])
+    await loading
+
+    expect(useGlobalSessionsStore.getState().activeSessions).toEqual([])
+    expect(useGlobalSessionsStore.getState().archivedSessions[0]?.time.archived).toBe(10)
+  })
+
+  test("keeps a newer title when an older response finishes last", async () => {
+    const stale = session("updated", "Old")
+    useGlobalSessionsStore.getState().applySnapshot([stale], [])
+    const loading = useGlobalSessionsStore.getState().loadSessions()
+    useGlobalSessionsStore.getState().upsertSession(session("updated", "New"))
+
+    activeRequest.resolve([stale])
+    archivedRequest.resolve([])
+    await loading
+
+    expect(useGlobalSessionsStore.getState().activeSessions[0]?.title).toBe("New")
+  })
+
+  test("uses commit-time state when one side of the load fails", async () => {
+    const created = session("created")
+    const loading = useGlobalSessionsStore.getState().loadSessions()
+    useGlobalSessionsStore.getState().upsertSession(created)
+
+    activeRequest.reject(new Error("unavailable"))
+    archivedRequest.resolve([])
+    await loading
+
+    expect(useGlobalSessionsStore.getState().activeSessions).toEqual([created])
+    expect(useGlobalSessionsStore.getState().status).toBe("error")
+  })
+
+  test("does not undo a move while refreshing the source directory", async () => {
+    const source = { ...session("moved"), directory: "/source" } as Session
+    const destination = { ...source, directory: "/destination" } as Session
+    useGlobalSessionsStore.getState().applySnapshot([source], [])
+    const refreshing = useGlobalSessionsStore.getState().refreshSessionsForDirectories(["/source"])
+    useGlobalSessionsStore.getState().upsertSession(destination)
+
+    activeRequest.resolve([source])
+    archivedRequest.resolve([])
+    await refreshing
+
+    expect(useGlobalSessionsStore.getState().sessionsByDirectory.get("/source")).toBe(undefined)
+    expect(useGlobalSessionsStore.getState().sessionsByDirectory.get("/destination")?.[0]?.id).toBe("moved")
+  })
+})
diff --git a/packages/ui/src/stores/useGlobalSessionsStore.test.ts b/packages/ui/src/stores/useGlobalSessionsStore.test.ts
index 3aaaa6d0..e068fbf2 100644
--- a/packages/ui/src/stores/useGlobalSessionsStore.test.ts
+++ b/packages/ui/src/stores/useGlobalSessionsStore.test.ts
@@ -1,7 +1,12 @@
 import { beforeEach, describe, expect, test } from 'bun:test';
 import type { Session } from '@opencode-ai/sdk/v2';
 
-import { resolveGlobalSessionDirectory, mergeLiveSessionWithGlobalSession, useGlobalSessionsStore } from './useGlobalSessionsStore';
+import {
+  isGlobalSessionRecencyOnlyUpdate,
+  resolveGlobalSessionDirectory,
+  mergeLiveSessionWithGlobalSession,
+  useGlobalSessionsStore,
+} from './useGlobalSessionsStore';
 
 type SessionExtra = Partial<Session> & {
   directory?: string | null;
@@ -78,6 +83,44 @@ describe('useGlobalSessionsStore', () => {
     expect(useGlobalSessionsStore.getState().activeSessions).toEqual([]);
     expect(resolveGlobalSessionDirectory(useGlobalSessionsStore.getState().archivedSessions[0])).toBe('/repo/app');
   });
+
+  test('preserves the opposite session-list reference during an upsert', () => {
+    const active = buildSession('https://share.example/active');
+    const archived = buildSession('https://share.example/archived', {
+      id: 'ses_archived',
+      time: { created: 1, updated: 2, archived: 3 },
+    });
+    useGlobalSessionsStore.getState().applySnapshot([active], [archived]);
+
+    const archivedSessions = useGlobalSessionsStore.getState().archivedSessions;
+    useGlobalSessionsStore.getState().upsertSession(buildSession('https://share.example/active-updated', {
+      time: { created: 1, updated: 3 },
+    }));
+    expect(useGlobalSessionsStore.getState().archivedSessions).toBe(archivedSessions);
+
+    const activeSessions = useGlobalSessionsStore.getState().activeSessions;
+    useGlobalSessionsStore.getState().upsertSession({
+      ...archived,
+      time: { created: 1, updated: 4, archived: 3 },
+    });
+    expect(useGlobalSessionsStore.getState().activeSessions).toBe(activeSessions);
+  });
+
+  test('applies a batch of session upserts in one store publication', () => {
+    let publications = 0;
+    const unsubscribe = useGlobalSessionsStore.subscribe(() => {
+      publications += 1;
+    });
+
+    useGlobalSessionsStore.getState().upsertSessions([
+      buildSession('https://share.example/a'),
+      buildSession('https://share.example/b', { id: 'ses_2' }),
+    ]);
+
+    unsubscribe();
+    expect(useGlobalSessionsStore.getState().activeSessions.map((session) => session.id)).toEqual(['ses_2', 'ses_1']);
+    expect(publications).toBe(1);
+  });
 });
 
 describe('mergeLiveSessionWithGlobalSession', () => {
@@ -106,3 +149,52 @@ describe('mergeLiveSessionWithGlobalSession', () => {
     expect(resolveGlobalSessionDirectory(merged)).toBe('/repo/worktree');
   });
 });
+
+describe('isGlobalSessionRecencyOnlyUpdate', () => {
+  test('accepts an updated timestamp while preserving omitted directory metadata', () => {
+    const existing = buildSession('https://share.example/s', {
+      directory: '/repo/app',
+      time: { created: 1, updated: 2 },
+    });
+    const incoming = buildSession('https://share.example/s', {
+      time: { created: 1, updated: 3 },
+    });
+
+    expect(isGlobalSessionRecencyOnlyUpdate(existing, incoming)).toBe(true);
+  });
+
+  test('rejects title and archive changes as structural updates', () => {
+    const existing = buildSession('https://share.example/s', { time: { created: 1, updated: 2 } });
+    const renamed = buildSession('https://share.example/s', {
+      title: 'Renamed',
+      time: { created: 1, updated: 3 },
+    });
+    const archived = buildSession('https://share.example/s', {
+      time: { created: 1, updated: 3, archived: 4 },
+    });
+
+    expect(isGlobalSessionRecencyOnlyUpdate(existing, renamed)).toBe(false);
+    expect(isGlobalSessionRecencyOnlyUpdate(existing, archived)).toBe(false);
+  });
+
+  test('rejects parent and slug changes as structural updates', () => {
+    const existing = buildSession('https://share.example/s', {
+      parentID: 'parent-a',
+      slug: 'slug-a',
+      time: { created: 1, updated: 2 },
+    });
+    const reparented = buildSession('https://share.example/s', {
+      parentID: 'parent-b',
+      slug: 'slug-a',
+      time: { created: 1, updated: 3 },
+    });
+    const reslugged = buildSession('https://share.example/s', {
+      parentID: 'parent-a',
+      slug: 'slug-b',
+      time: { created: 1, updated: 3 },
+    });
+
+    expect(isGlobalSessionRecencyOnlyUpdate(existing, reparented)).toBe(false);
+    expect(isGlobalSessionRecencyOnlyUpdate(existing, reslugged)).toBe(false);
+  });
+});
diff --git a/packages/ui/src/stores/useGlobalSessionsStore.ts b/packages/ui/src/stores/useGlobalSessionsStore.ts
index c7dacd56..2f4d5632 100644
--- a/packages/ui/src/stores/useGlobalSessionsStore.ts
+++ b/packages/ui/src/stores/useGlobalSessionsStore.ts
@@ -5,6 +5,7 @@ import { listGlobalSessionPages } from '@/stores/globalSessions';
 import { getReviewTransferDirection, type ReviewTransferDirection } from '@/lib/reviewFlow';
 import { getOriginalSessionID, getReviewSessionID } from '@/lib/sessionReviewMetadata';
 import { normalizePath } from '@/lib/pathNormalization';
+import { mapWithConcurrency } from '@/lib/concurrency';
 
 type GlobalSessionsStatus = 'idle' | 'loading' | 'ready' | 'error';
 
@@ -18,12 +19,15 @@ type GlobalSessionsState = {
   archivedSessions: Session[];
   sessionsByDirectory: Map<string, Session[]>;
   reviewTransferBySessionId: Map<string, ReviewTransferDirection>;
+  mutationRevision: number;
+  mutationRevisionBySessionId: Map<string, number>;
   hasLoaded: boolean;
   status: GlobalSessionsStatus;
   loadSessions: (fallbackActive?: Session[]) => Promise<LoadResult>;
   refreshSessionsForDirectories: (directories: Iterable<string>, fallbackActive?: Session[]) => Promise<LoadResult>;
   applySnapshot: (activeSessions: Session[], archivedSessions: Session[], status?: GlobalSessionsStatus) => void;
   upsertSession: (session: Session) => void;
+  upsertSessions: (sessions: Session[]) => void;
   removeSessions: (ids: Iterable<string>) => void;
   archiveSessions: (ids: Iterable<string>, archivedAt?: number) => void;
   /** Drop every session from the previous runtime instance and go back to the
@@ -32,6 +36,24 @@ type GlobalSessionsState = {
 };
 
 const PAGE_SIZE = 500;
+const DIRECTORY_SESSION_REFRESH_CONCURRENCY = 2;
+let directorySessionRefreshActive = 0;
+const directorySessionRefreshWaiters: Array<() => void> = [];
+
+const withDirectorySessionRefreshSlot = async <T>(task: () => Promise<T>): Promise<T> => {
+  if (directorySessionRefreshActive >= DIRECTORY_SESSION_REFRESH_CONCURRENCY) {
+    await new Promise<void>((resolve) => directorySessionRefreshWaiters.push(resolve));
+  } else {
+    directorySessionRefreshActive += 1;
+  }
+  try {
+    return await task();
+  } finally {
+    const next = directorySessionRefreshWaiters.shift();
+    if (next) next();
+    else directorySessionRefreshActive = Math.max(0, directorySessionRefreshActive - 1);
+  }
+};
 
 let inflightLoad: Promise<LoadResult> | null = null;
 // Bumped on runtime switch: an in-flight load from the previous instance must
@@ -133,6 +155,27 @@ const getSessionSignature = (session: Session): string => {
   ].join(':');
 };
 
+export const getSessionStructuralSignature = (session: Session): string => {
+  const record = session as Session & { parentID?: string | null; slug?: string | null };
+  return [
+    session.id,
+    session.title ?? '',
+    record.parentID ?? '',
+    record.slug ?? '',
+    session.time?.created ?? 0,
+    session.time?.archived ?? 0,
+    session.share?.url ?? '',
+    JSON.stringify((session as Session & { metadata?: unknown }).metadata ?? null),
+    resolveGlobalSessionDirectory(session) ?? '',
+  ].join(':');
+};
+
+export const isGlobalSessionRecencyOnlyUpdate = (existing: Session, incoming: Session): boolean => {
+  const merged = mergeSessionDirectoryMetadata(incoming, existing);
+  return existing.time?.updated !== merged.time?.updated
+    && getSessionStructuralSignature(existing) === getSessionStructuralSignature(merged);
+};
+
 const sameSessionList = (prev: Session[], next: Session[]): boolean => {
   if (prev === next) {
     return true;
@@ -211,12 +254,27 @@ const fetchDirectoryPages = async (
   directories: Set<string>,
   archived: boolean,
 ): Promise<DirectoryPageResult> => {
-  const results = await Promise.allSettled(
-    [...directories].map(async (directory) => ({
-      directory,
-      sessions: await listGlobalSessionPages(sdk, { directory, archived, pageSize: PAGE_SIZE }),
-    })),
-  );
+  const currentDirectory = normalizePath(opencodeClient.getDirectory());
+  const orderedDirectories = [...directories].sort((left, right) => {
+    if (left === currentDirectory) return -1;
+    if (right === currentDirectory) return 1;
+    return left.localeCompare(right);
+  });
+  const results = await mapWithConcurrency(orderedDirectories, DIRECTORY_SESSION_REFRESH_CONCURRENCY, async (directory) => {
+    try {
+      return {
+        status: 'fulfilled' as const,
+        value: {
+          directory,
+          sessions: await withDirectorySessionRefreshSlot(() => (
+            listGlobalSessionPages(sdk, { directory, archived, pageSize: PAGE_SIZE })
+          )),
+        },
+      };
+    } catch (reason) {
+      return { status: 'rejected' as const, reason };
+    }
+  });
 
   const fulfilledDirectories = new Set<string>();
   const sessions: Session[] = [];
@@ -248,6 +306,14 @@ const upsertSessionIntoList = (sessions: Session[], session: Session): Session[]
   return next;
 };
 
+const removeSessionFromList = (sessions: Session[], sessionId: string): Session[] => {
+  const index = sessions.findIndex((session) => session.id === sessionId);
+  if (index === -1) {
+    return sessions;
+  }
+  return [...sessions.slice(0, index), ...sessions.slice(index + 1)];
+};
+
 const mergeSessionLists = (existing: Session[], incoming?: Session[]): Session[] => {
   if (!incoming || incoming.length === 0) {
     return existing;
@@ -328,6 +394,77 @@ const applySnapshot = (
   };
 };
 
+const overlayMutationsSince = (
+  state: GlobalSessionsState,
+  activeSessions: Session[],
+  archivedSessions: Session[],
+  baselineRevision: number,
+): LoadResult => {
+  const affectedIds = new Set<string>();
+  for (const [sessionId, revision] of state.mutationRevisionBySessionId) {
+    if (revision > baselineRevision) affectedIds.add(sessionId);
+  }
+  if (affectedIds.size === 0) return { activeSessions, archivedSessions };
+
+  const currentActive = new Map(state.activeSessions.map((session) => [session.id, session]));
+  const currentArchived = new Map(state.archivedSessions.map((session) => [session.id, session]));
+  let nextActive = activeSessions.filter((session) => !affectedIds.has(session.id));
+  let nextArchived = archivedSessions.filter((session) => !affectedIds.has(session.id));
+  for (const sessionId of affectedIds) {
+    const active = currentActive.get(sessionId);
+    const archived = currentArchived.get(sessionId);
+    if (active) nextActive = upsertSessionIntoList(nextActive, active);
+    else if (archived) nextArchived = upsertSessionIntoList(nextArchived, archived);
+  }
+  return { activeSessions: nextActive, archivedSessions: nextArchived };
+};
+
+const mutationRevisionPatch = (state: GlobalSessionsState, ids: Iterable<string>) => {
+  const mutationRevision = state.mutationRevision + 1;
+  const mutationRevisionBySessionId = new Map(state.mutationRevisionBySessionId);
+  for (const id of ids) mutationRevisionBySessionId.set(id, mutationRevision);
+  return { mutationRevision, mutationRevisionBySessionId };
+};
+
+const applySessionUpserts = (state: GlobalSessionsState, sessions: Session[]): Partial<GlobalSessionsState> => {
+  const revisionPatch = mutationRevisionPatch(state, sessions.map((session) => session.id));
+  let nextActiveSessions = state.activeSessions;
+  let nextArchivedSessions = state.archivedSessions;
+
+  for (const session of sessions) {
+    const existingSession = nextActiveSessions.find((candidate) => candidate.id === session.id)
+      ?? nextArchivedSessions.find((candidate) => candidate.id === session.id)
+      ?? null;
+    const sessionWithMetadata = mergeSessionDirectoryMetadata(session, existingSession);
+    const isArchived = Boolean(sessionWithMetadata.time?.archived);
+    nextActiveSessions = isArchived
+      ? removeSessionFromList(nextActiveSessions, session.id)
+      : upsertSessionIntoList(nextActiveSessions, sessionWithMetadata);
+    nextArchivedSessions = isArchived
+      ? upsertSessionIntoList(nextArchivedSessions, sessionWithMetadata)
+      : removeSessionFromList(nextArchivedSessions, session.id);
+  }
+
+  if (
+    nextActiveSessions === state.activeSessions
+    && nextArchivedSessions === state.archivedSessions
+  ) {
+    return revisionPatch;
+  }
+
+  return {
+    activeSessions: nextActiveSessions,
+    archivedSessions: nextArchivedSessions,
+    sessionsByDirectory: nextActiveSessions === state.activeSessions
+      ? state.sessionsByDirectory
+      : buildSessionsByDirectory(nextActiveSessions),
+    reviewTransferBySessionId: nextActiveSessions === state.activeSessions
+      ? state.reviewTransferBySessionId
+      : buildReviewTransferMap(nextActiveSessions),
+    ...revisionPatch,
+  };
+};
+
 const buildReviewTransferMap = (sessions: Session[]): Map<string, ReviewTransferDirection> => {
   const next = new Map<string, ReviewTransferDirection>()
   const activeIds = new Set(sessions.map((s) => s.id))
@@ -348,6 +485,8 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
   archivedSessions: [],
   sessionsByDirectory: new Map(),
   reviewTransferBySessionId: new Map(),
+  mutationRevision: 0,
+  mutationRevisionBySessionId: new Map(),
   hasLoaded: false,
   status: 'idle',
 
@@ -363,6 +502,8 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
       archivedSessions: [],
       sessionsByDirectory: new Map(),
       reviewTransferBySessionId: new Map(),
+      mutationRevision: 0,
+      mutationRevisionBySessionId: new Map(),
       hasLoaded: false,
       status: 'idle',
     });
@@ -376,9 +517,8 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
     set((state) => (state.status === 'loading' ? state : { status: 'loading' }));
 
     const generation = loadGeneration;
-    inflightLoad = (async () => {
-      const current = get();
-
+    const baselineRevision = get().mutationRevision;
+    const loadPromise = (async () => {
       try {
         const sdk = opencodeClient.getSdkClient();
         const [activeResult, archivedResult] = await Promise.allSettled([
@@ -386,14 +526,6 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
           listGlobalSessionPages(sdk, { archived: true, pageSize: PAGE_SIZE }),
         ]);
 
-        const fallbackSnapshot = mergeSessionLists(current.activeSessions, fallbackActive);
-        const nextActiveSessions = activeResult.status === 'fulfilled'
-          ? activeResult.value
-          : fallbackSnapshot;
-        const nextArchivedSessions = archivedResult.status === 'fulfilled'
-          ? archivedResult.value
-          : current.archivedSessions;
-
         if (activeResult.status === 'rejected') {
           console.warn('[GlobalSessions] Failed to load active sessions, preserving existing snapshot with fallback merge:', activeResult.reason);
         }
@@ -409,23 +541,45 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
         const status = activeResult.status === 'fulfilled' && archivedResult.status === 'fulfilled'
           ? 'ready'
           : 'error';
-        set((state) => applySnapshot(state, nextActiveSessions, nextArchivedSessions, status));
-        return { activeSessions: nextActiveSessions, archivedSessions: nextArchivedSessions };
+        set((state) => {
+          const fetchedActive = activeResult.status === 'fulfilled'
+            ? activeResult.value
+            : mergeSessionLists(state.activeSessions, fallbackActive);
+          const fetchedArchived = archivedResult.status === 'fulfilled'
+            ? archivedResult.value
+            : state.archivedSessions;
+          const reconciled = overlayMutationsSince(state, fetchedActive, fetchedArchived, baselineRevision);
+          return applySnapshot(state, reconciled.activeSessions, reconciled.archivedSessions, status);
+        });
+        const committed = get();
+        return { activeSessions: committed.activeSessions, archivedSessions: committed.archivedSessions };
       } catch (error) {
         if (generation !== loadGeneration) {
           return { activeSessions: [], archivedSessions: [] };
         }
-        const nextActiveSessions = mergeSessionLists(current.activeSessions, fallbackActive);
-        const nextArchivedSessions = current.archivedSessions;
         console.warn('[GlobalSessions] Failed to load sessions, using fallback snapshot:', error);
-        set((state) => applySnapshot(state, nextActiveSessions, nextArchivedSessions, 'error'));
-        return { activeSessions: nextActiveSessions, archivedSessions: nextArchivedSessions };
-      } finally {
-        inflightLoad = null;
+        set((state) => {
+          const reconciled = overlayMutationsSince(
+            state,
+            mergeSessionLists(state.activeSessions, fallbackActive),
+            state.archivedSessions,
+            baselineRevision,
+          );
+          return applySnapshot(state, reconciled.activeSessions, reconciled.archivedSessions, 'error');
+        });
+        const committed = get();
+        return { activeSessions: committed.activeSessions, archivedSessions: committed.archivedSessions };
       }
     })();
 
-    return inflightLoad;
+    inflightLoad = loadPromise;
+    const clearInflightLoad = () => {
+      if (inflightLoad === loadPromise) {
+        inflightLoad = null;
+      }
+    };
+    void loadPromise.then(clearInflightLoad, clearInflightLoad);
+    return loadPromise;
   },
 
   refreshSessionsForDirectories: async (directories, fallbackActive) => {
@@ -435,12 +589,19 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
       return { activeSessions: state.activeSessions, archivedSessions: state.archivedSessions };
     }
 
+    const generation = loadGeneration;
+    const baselineRevision = get().mutationRevision;
     const sdk = opencodeClient.getSdkClient();
     const [active, archived] = await Promise.all([
       fetchDirectoryPages(sdk, directorySet, false),
       fetchDirectoryPages(sdk, directorySet, true),
     ]);
 
+    if (generation !== loadGeneration) {
+      const state = get();
+      return { activeSessions: state.activeSessions, archivedSessions: state.archivedSessions };
+    }
+
     if (active.errors.length > 0) {
       console.warn('[GlobalSessions] Failed to refresh active sessions for some directories:', active.errors[0]);
     }
@@ -460,6 +621,10 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
         nextArchivedSessions = state.archivedSessions;
       }
 
+      const reconciled = overlayMutationsSince(state, nextActiveSessions, nextArchivedSessions, baselineRevision);
+      nextActiveSessions = reconciled.activeSessions;
+      nextArchivedSessions = reconciled.archivedSessions;
+
       const nextSessionsByDirectory = nextActiveSessions === state.activeSessions
         ? state.sessionsByDirectory
         : buildSessionsByDirectory(nextActiveSessions);
@@ -487,37 +652,12 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
   },
 
   upsertSession: (session) => {
-    set((state) => {
-      const existingSession = state.activeSessions.find((candidate) => candidate.id === session.id)
-        ?? state.archivedSessions.find((candidate) => candidate.id === session.id)
-        ?? null;
-      const sessionWithMetadata = mergeSessionDirectoryMetadata(session, existingSession);
-      const isArchived = Boolean(sessionWithMetadata.time?.archived);
-      const nextActiveSessions = isArchived
-        ? state.activeSessions.filter((candidate) => candidate.id !== session.id)
-        : upsertSessionIntoList(state.activeSessions, sessionWithMetadata);
-      const nextArchivedSessions = isArchived
-        ? upsertSessionIntoList(state.archivedSessions, sessionWithMetadata)
-        : state.archivedSessions.filter((candidate) => candidate.id !== session.id);
+    set((state) => applySessionUpserts(state, [session]));
+  },
 
-      if (
-        nextActiveSessions === state.activeSessions
-        && nextArchivedSessions === state.archivedSessions
-      ) {
-        return state;
-      }
-
-      return {
-        activeSessions: nextActiveSessions,
-        archivedSessions: nextArchivedSessions,
-        sessionsByDirectory: nextActiveSessions === state.activeSessions
-          ? state.sessionsByDirectory
-          : buildSessionsByDirectory(nextActiveSessions),
-        reviewTransferBySessionId: nextActiveSessions === state.activeSessions
-          ? state.reviewTransferBySessionId
-          : buildReviewTransferMap(nextActiveSessions),
-      };
-    });
+  upsertSessions: (sessions) => {
+    if (sessions.length === 0) return;
+    set((state) => applySessionUpserts(state, sessions));
   },
 
   removeSessions: (ids) => {
@@ -527,6 +667,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
     }
 
     set((state) => {
+      const revisionPatch = mutationRevisionPatch(state, idSet);
       const nextActiveSessions = state.activeSessions.filter((session) => !idSet.has(session.id));
       const nextArchivedSessions = state.archivedSessions.filter((session) => !idSet.has(session.id));
 
@@ -534,7 +675,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
         nextActiveSessions.length === state.activeSessions.length
         && nextArchivedSessions.length === state.archivedSessions.length
       ) {
-        return state;
+        return revisionPatch;
       }
 
       return {
@@ -542,6 +683,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
         archivedSessions: nextArchivedSessions,
         sessionsByDirectory: buildSessionsByDirectory(nextActiveSessions),
         reviewTransferBySessionId: buildReviewTransferMap(nextActiveSessions),
+        ...revisionPatch,
       };
     });
   },
@@ -553,6 +695,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
     }
 
     set((state) => {
+      const revisionPatch = mutationRevisionPatch(state, idSet);
       const movedSessions: Session[] = [];
       const nextActiveSessions = state.activeSessions.filter((session) => {
         if (!idSet.has(session.id)) {
@@ -570,7 +713,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
       });
 
       if (movedSessions.length === 0) {
-        return state;
+        return revisionPatch;
       }
 
       const remainingArchivedSessions = state.archivedSessions.filter((session) => !idSet.has(session.id));
@@ -580,6 +723,7 @@ export const useGlobalSessionsStore = create<GlobalSessionsState>((set, get) =>
         archivedSessions: [...movedSessions, ...remainingArchivedSessions],
         sessionsByDirectory: buildSessionsByDirectory(nextActiveSessions),
         reviewTransferBySessionId: buildReviewTransferMap(nextActiveSessions),
+        ...revisionPatch,
       };
     });
   },
diff --git a/packages/ui/src/stores/useInlineCommentDraftStore.terminal.test.ts b/packages/ui/src/stores/useInlineCommentDraftStore.terminal.test.ts
index cfe87889..aa3248cb 100644
--- a/packages/ui/src/stores/useInlineCommentDraftStore.terminal.test.ts
+++ b/packages/ui/src/stores/useInlineCommentDraftStore.terminal.test.ts
@@ -2,7 +2,6 @@ import { afterEach, describe, expect, test } from 'bun:test';
 import { useInlineCommentDraftStore } from './useInlineCommentDraftStore';
 
 const selection = {
-  sessionKey: 'session-1',
   source: 'terminal' as const,
   fileLabel: 'Terminal 1',
   startLine: 4,
@@ -11,32 +10,72 @@ const selection = {
   language: 'term-1',
   text: '',
 };
+const target = { directory: '/repo', sessionKey: 'session-1' };
 
 describe('terminal context drafts', () => {
-  afterEach(() => { useInlineCommentDraftStore.setState({ drafts: {} }); });
+  afterEach(() => { useInlineCommentDraftStore.setState({ drafts: {}, touchedAt: {} }); });
 
   test('persists snapshots by chat session and deduplicates identical selections', () => {
-    useInlineCommentDraftStore.getState().addDraft(selection);
-    useInlineCommentDraftStore.getState().addDraft(selection);
-    const drafts = useInlineCommentDraftStore.getState().getDrafts('session-1');
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    const drafts = useInlineCommentDraftStore.getState().getDrafts(target);
     expect(drafts).toHaveLength(1);
-    expect({ ...drafts[0], id: undefined, createdAt: undefined }).toEqual({ ...selection, id: undefined, createdAt: undefined });
+    expect({ ...drafts[0], id: undefined, createdAt: undefined }).toEqual({ ...selection, sessionKey: 'session-1', id: undefined, createdAt: undefined });
   });
 
   test('supports individual removal and ordered consume', () => {
-    useInlineCommentDraftStore.getState().addDraft(selection);
-    useInlineCommentDraftStore.getState().addDraft({ ...selection, startLine: 8, endLine: 8, code: 'third' });
-    const drafts = useInlineCommentDraftStore.getState().getDrafts('session-1');
-    useInlineCommentDraftStore.getState().removeDraft('session-1', drafts[0].id);
-    expect(useInlineCommentDraftStore.getState().consumeDrafts('session-1')).toHaveLength(1);
-    expect(useInlineCommentDraftStore.getState().getDrafts('session-1')).toEqual([]);
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    useInlineCommentDraftStore.getState().addDraft(target, { ...selection, startLine: 8, endLine: 8, code: 'third' });
+    const drafts = useInlineCommentDraftStore.getState().getDrafts(target);
+    useInlineCommentDraftStore.getState().removeDraft(target, drafts[0].id);
+    expect(useInlineCommentDraftStore.getState().consumeDrafts(target)).toHaveLength(1);
+    expect(useInlineCommentDraftStore.getState().getDrafts(target)).toEqual([]);
   });
 
   test('restores consumed drafts after a failed send without duplicating them', () => {
-    useInlineCommentDraftStore.getState().addDraft(selection);
-    const consumed = useInlineCommentDraftStore.getState().consumeDrafts('session-1');
-    useInlineCommentDraftStore.getState().restoreDrafts('session-1', consumed);
-    useInlineCommentDraftStore.getState().restoreDrafts('session-1', consumed);
-    expect(useInlineCommentDraftStore.getState().getDrafts('session-1')).toEqual(consumed);
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    const consumed = useInlineCommentDraftStore.getState().consumeDrafts(target);
+    useInlineCommentDraftStore.getState().restoreDrafts(target, consumed);
+    useInlineCommentDraftStore.getState().restoreDrafts(target, consumed);
+    expect(useInlineCommentDraftStore.getState().getDrafts(target)).toEqual(consumed);
+  });
+
+  test('isolates identical session IDs by normalized directory', () => {
+    const otherTarget = { directory: '/other', sessionKey: 'session-1' };
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    useInlineCommentDraftStore.getState().addDraft(otherTarget, { ...selection, code: 'other' });
+
+    useInlineCommentDraftStore.getState().clearDrafts({ ...target, directory: '/repo/' });
+
+    expect(useInlineCommentDraftStore.getState().getDrafts(target)).toEqual([]);
+    expect(useInlineCommentDraftStore.getState().getDrafts(otherTarget)).toHaveLength(1);
+  });
+
+  test('returns a stable empty snapshot for absent draft buckets', () => {
+    const first = useInlineCommentDraftStore.getState().getDrafts(target);
+    const second = useInlineCommentDraftStore.getState().getDrafts(target);
+
+    expect(first).toBe(second);
+  });
+
+  test('updates one draft without serializing the complete envelope on the mutation path', () => {
+    useInlineCommentDraftStore.getState().addDraft(target, selection);
+    const draft = useInlineCommentDraftStore.getState().getDrafts(target)[0];
+    const originalStringify = JSON.stringify;
+    let envelopeSerializations = 0;
+    JSON.stringify = ((value: unknown, ...rest: unknown[]) => {
+      if (value && typeof value === 'object' && 'drafts' in value && 'touchedAt' in value) {
+        envelopeSerializations += 1;
+      }
+      return originalStringify(value, ...(rest as [Parameters<typeof JSON.stringify>[1], Parameters<typeof JSON.stringify>[2]]));
+    }) as typeof JSON.stringify;
+
+    try {
+      useInlineCommentDraftStore.getState().updateDraft(target, draft.id, { text: 'edited' });
+      expect(envelopeSerializations).toBe(0);
+      expect(useInlineCommentDraftStore.getState().getDrafts(target)[0]?.text).toBe('edited');
+    } finally {
+      JSON.stringify = originalStringify;
+    }
   });
 });
diff --git a/packages/ui/src/stores/useInlineCommentDraftStore.ts b/packages/ui/src/stores/useInlineCommentDraftStore.ts
index e79c7dbf..f2a9135a 100644
--- a/packages/ui/src/stores/useInlineCommentDraftStore.ts
+++ b/packages/ui/src/stores/useInlineCommentDraftStore.ts
@@ -1,105 +1,175 @@
 import { create } from 'zustand';
 import { devtools, persist } from 'zustand/middleware';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { normalizePath } from '@/lib/pathNormalization';
 import { createDeferredSafeJSONStorage } from './utils/safeStorage';
 
 export type InlineCommentSource = 'diff' | 'plan' | 'file' | 'preview-console' | 'preview-annotation' | 'terminal';
 
+export type InlineCommentDraftTarget = {
+  directory: string;
+  sessionKey: string;
+};
+
 export interface InlineCommentDraft {
   id: string;
-  sessionKey: string; // sessionId or 'draft' for new sessions
+  sessionKey: string;
   source: InlineCommentSource;
-  fileLabel: string; // filename or 'plan'
+  fileLabel: string;
   startLine: number;
   endLine: number;
-  side?: 'original' | 'modified'; // diff only
+  side?: 'original' | 'modified';
   code: string;
   language: string;
   text: string;
   createdAt: number;
 }
 
+export const EMPTY_INLINE_COMMENT_DRAFTS: InlineCommentDraft[] = [];
+
 interface InlineCommentDraftState {
-  drafts: Record<string, InlineCommentDraft[]>; // sessionKey -> drafts
+  drafts: Record<string, InlineCommentDraft[]>;
+  touchedAt: Record<string, number>;
 }
 
 interface InlineCommentDraftActions {
-  addDraft: (draft: Omit<InlineCommentDraft, 'id' | 'createdAt'>) => void;
-  updateDraft: (sessionKey: string, draftId: string, updates: Partial<Omit<InlineCommentDraft, 'id' | 'createdAt' | 'sessionKey'>>) => void;
-  removeDraft: (sessionKey: string, draftId: string) => void;
-  clearDrafts: (sessionKey: string) => void;
-  getDrafts: (sessionKey: string) => InlineCommentDraft[];
-  consumeDrafts: (sessionKey: string) => InlineCommentDraft[];
-  restoreDrafts: (sessionKey: string, drafts: InlineCommentDraft[]) => void;
-  getDraftCount: (sessionKey: string) => number;
-  hasDrafts: (sessionKey: string) => boolean;
+  addDraft: (target: InlineCommentDraftTarget, draft: Omit<InlineCommentDraft, 'id' | 'createdAt' | 'sessionKey'>) => string | null;
+  updateDraft: (target: InlineCommentDraftTarget, draftId: string, updates: Partial<Omit<InlineCommentDraft, 'id' | 'createdAt' | 'sessionKey'>>) => void;
+  removeDraft: (target: InlineCommentDraftTarget, draftId: string) => void;
+  clearDrafts: (target: InlineCommentDraftTarget) => void;
+  getDrafts: (target: InlineCommentDraftTarget) => InlineCommentDraft[];
+  consumeDrafts: (target: InlineCommentDraftTarget) => InlineCommentDraft[];
+  restoreDrafts: (target: InlineCommentDraftTarget, drafts: InlineCommentDraft[]) => void;
+  getDraftCount: (target: InlineCommentDraftTarget) => number;
+  hasDrafts: (target: InlineCommentDraftTarget) => boolean;
+  clearSessionDrafts: (runtimeKey: string, directory: string, sessionId: string) => void;
 }
 
 type InlineCommentDraftStore = InlineCommentDraftState & InlineCommentDraftActions;
 
-const isValidSource = (value: unknown): value is InlineCommentSource =>
-  value === 'diff' || value === 'plan' || value === 'file' || value === 'preview-console' || value === 'preview-annotation' || value === 'terminal';
+const MAX_SESSIONS = 50;
+const MAX_DRAFTS_PER_SESSION = 20;
+const MAX_PERSISTED_BYTES = 1024 * 1024;
+const encoder = new TextEncoder();
 
-const isValidSide = (value: unknown): value is 'original' | 'modified' =>
-  value === 'original' || value === 'modified';
-
-const toPositiveLine = (value: unknown): number | null => {
-  const parsed = typeof value === 'number' ? value : Number(value);
-  if (!Number.isFinite(parsed)) return null;
-  return Math.max(1, Math.floor(parsed));
+type SerializedSizeIndex = {
+  draftEntries: Map<string, number>;
+  touchedEntries: Map<string, number>;
+  total: number;
 };
 
-const sanitizeDraft = (input: unknown): InlineCommentDraft | null => {
-  if (!input || typeof input !== 'object') return null;
-  const draft = input as Partial<InlineCommentDraft>;
+const serializedSizeByDrafts = new WeakMap<Record<string, InlineCommentDraft[]>, SerializedSizeIndex>();
+const EMPTY_ENVELOPE_BYTES = encoder.encode(JSON.stringify({ drafts: {}, touchedAt: {} })).byteLength;
 
-  if (typeof draft.sessionKey !== 'string' || draft.sessionKey.trim().length === 0) return null;
-  if (!isValidSource(draft.source)) return null;
-
-  const startLine = toPositiveLine(draft.startLine);
-  const endLine = toPositiveLine(draft.endLine);
-  if (!startLine || !endLine) return null;
-
-  const id = typeof draft.id === 'string' && draft.id.trim().length > 0
-    ? draft.id
-    : `icd-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-  const code = typeof draft.code === 'string' ? draft.code : '';
-  if (draft.source === 'terminal' && !code.trim()) return null;
-  return {
-    id,
-    sessionKey: draft.sessionKey,
-    source: draft.source,
-    fileLabel: typeof draft.fileLabel === 'string' ? draft.fileLabel : 'unknown',
-    startLine,
-    endLine,
-    side: isValidSide(draft.side) ? draft.side : undefined,
-    code,
-    language: typeof draft.language === 'string' ? draft.language : 'text',
-    text: typeof draft.text === 'string' ? draft.text : '',
-    createdAt: Number.isFinite(draft.createdAt) ? Number(draft.createdAt) : Date.now(),
-  };
+export const getInlineCommentDraftKey = (runtimeKey: string, directory: string, sessionKey: string): string | null => {
+  const normalizedDirectory = normalizePath(directory);
+  if (!runtimeKey || !normalizedDirectory || !sessionKey) return null;
+  return JSON.stringify([runtimeKey, normalizedDirectory, sessionKey]);
 };
 
-const sanitizeDraftMap = (input: unknown): Record<string, InlineCommentDraft[]> => {
-  if (!input || typeof input !== 'object') return {};
+const getCurrentKey = (target: InlineCommentDraftTarget): string | null =>
+  getInlineCommentDraftKey(getRuntimeKey(), target.directory, target.sessionKey);
 
-  const entries = Object.entries(input as Record<string, unknown>);
-  const result: Record<string, InlineCommentDraft[]> = {};
+const serializedEntryBytes = (key: string, value: unknown): number =>
+  encoder.encode(`${JSON.stringify(key)}:${JSON.stringify(value)}`).byteLength;
 
-  for (const [sessionKey, sessionDrafts] of entries) {
-    if (!Array.isArray(sessionDrafts)) continue;
+const sumEntryBytes = (entries: Map<string, number>): number => {
+  let total = 0;
+  for (const bytes of entries.values()) total += bytes;
+  return total;
+};
 
-    const sanitized = sessionDrafts
-      .map(sanitizeDraft)
-      .filter((draft): draft is InlineCommentDraft => Boolean(draft))
-      .filter((draft) => draft.sessionKey === sessionKey);
+const indexedTotal = (draftEntries: Map<string, number>, touchedEntries: Map<string, number>): number => (
+  EMPTY_ENVELOPE_BYTES
+  + sumEntryBytes(draftEntries)
+  + Math.max(0, draftEntries.size - 1)
+  + sumEntryBytes(touchedEntries)
+  + Math.max(0, touchedEntries.size - 1)
+);
 
-    if (sanitized.length > 0) {
-      result[sessionKey] = sanitized;
+const buildSerializedSizeIndex = (
+  drafts: Record<string, InlineCommentDraft[]>,
+  touchedAt: Record<string, number>,
+): SerializedSizeIndex => {
+  const draftEntries = new Map<string, number>();
+  const touchedEntries = new Map<string, number>();
+  for (const [key, value] of Object.entries(drafts)) draftEntries.set(key, serializedEntryBytes(key, value));
+  for (const [key, value] of Object.entries(touchedAt)) touchedEntries.set(key, serializedEntryBytes(key, value));
+  const index = { draftEntries, touchedEntries, total: indexedTotal(draftEntries, touchedEntries) };
+  serializedSizeByDrafts.set(drafts, index);
+  return index;
+};
+
+const updateSerializedSizeIndex = (
+  previous: InlineCommentDraftState,
+  drafts: Record<string, InlineCommentDraft[]>,
+  touchedAt: Record<string, number>,
+  changedKey: string,
+): SerializedSizeIndex => {
+  const previousIndex = serializedSizeByDrafts.get(previous.drafts)
+    ?? buildSerializedSizeIndex(previous.drafts, previous.touchedAt);
+  const draftEntries = new Map(previousIndex.draftEntries);
+  const touchedEntries = new Map(previousIndex.touchedEntries);
+  const bucket = drafts[changedKey];
+  if (bucket) draftEntries.set(changedKey, serializedEntryBytes(changedKey, bucket));
+  else draftEntries.delete(changedKey);
+  const touched = touchedAt[changedKey];
+  if (typeof touched === 'number') touchedEntries.set(changedKey, serializedEntryBytes(changedKey, touched));
+  else touchedEntries.delete(changedKey);
+  return { draftEntries, touchedEntries, total: indexedTotal(draftEntries, touchedEntries) };
+};
+
+const boundState = (
+  previous: InlineCommentDraftState,
+  drafts: Record<string, InlineCommentDraft[]>,
+  touchedAt: Record<string, number>,
+  changedKey: string,
+): { drafts: Record<string, InlineCommentDraft[]>; touchedAt: Record<string, number> } | null => {
+  const keys = Object.keys(drafts).sort((left, right) => (touchedAt[right] ?? 0) - (touchedAt[left] ?? 0));
+  const retainedKeys = keys.slice(0, MAX_SESSIONS);
+  const retainedDrafts: Record<string, InlineCommentDraft[]> = {};
+  const retainedTouchedAt: Record<string, number> = {};
+  for (const key of retainedKeys) {
+    retainedDrafts[key] = drafts[key].length > MAX_DRAFTS_PER_SESSION
+      ? drafts[key].slice(-MAX_DRAFTS_PER_SESSION)
+      : drafts[key];
+    retainedTouchedAt[key] = touchedAt[key] ?? Date.now();
+  }
+  const sizeIndex = updateSerializedSizeIndex(previous, retainedDrafts, retainedTouchedAt, changedKey);
+  for (const key of keys) {
+    if (!(key in retainedDrafts)) {
+      sizeIndex.draftEntries.delete(key);
+      sizeIndex.touchedEntries.delete(key);
+    } else if (retainedDrafts[key] !== drafts[key]) {
+      sizeIndex.draftEntries.set(key, serializedEntryBytes(key, retainedDrafts[key]));
+    }
+    if (key !== changedKey && retainedTouchedAt[key] !== previous.touchedAt[key]) {
+      sizeIndex.touchedEntries.set(key, serializedEntryBytes(key, retainedTouchedAt[key]));
     }
   }
+  sizeIndex.total = indexedTotal(sizeIndex.draftEntries, sizeIndex.touchedEntries);
+  const evictionKeys = [...retainedKeys];
+  while (evictionKeys.length > 0 && sizeIndex.total > MAX_PERSISTED_BYTES) {
+    const oldest = evictionKeys.pop()!;
+    delete retainedDrafts[oldest];
+    delete retainedTouchedAt[oldest];
+    sizeIndex.draftEntries.delete(oldest);
+    sizeIndex.touchedEntries.delete(oldest);
+    sizeIndex.total = indexedTotal(sizeIndex.draftEntries, sizeIndex.touchedEntries);
+  }
+  if (sizeIndex.draftEntries.size === 0 && keys.length > 0) return null;
+  serializedSizeByDrafts.set(retainedDrafts, sizeIndex);
+  return { drafts: retainedDrafts, touchedAt: retainedTouchedAt };
+};
 
-  return result;
+const removeDraftKey = (state: InlineCommentDraftState, key: string): InlineCommentDraftState => {
+  if (!(key in state.drafts)) return state;
+
+  const drafts = { ...state.drafts };
+  const touchedAt = { ...state.touchedAt };
+  delete drafts[key];
+  delete touchedAt[key];
+  return { drafts, touchedAt };
 };
 
 export const useInlineCommentDraftStore = create<InlineCommentDraftStore>()(
@@ -107,143 +177,115 @@ export const useInlineCommentDraftStore = create<InlineCommentDraftStore>()(
     persist(
       (set, get) => ({
         drafts: {},
-
-        addDraft: (draft) => {
-          if (draft.source === 'terminal' && !draft.code.trim()) return;
+        touchedAt: {},
+        addDraft: (target, draft) => {
+          const key = getCurrentKey(target);
+          if (!key || (draft.source === 'terminal' && !draft.code.trim())) return null;
           const id = `icd-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-          const newDraft: InlineCommentDraft = {
-            ...draft,
-            id,
-            createdAt: Date.now(),
-          };
-
+          const nextDraft: InlineCommentDraft = { ...draft, sessionKey: target.sessionKey, id, createdAt: Date.now() };
+          let accepted = false;
           set((state) => {
-            const currentDrafts = state.drafts[draft.sessionKey] ?? [];
-            if (draft.source === 'terminal' && currentDrafts.some((current) => current.source === 'terminal' && current.fileLabel === draft.fileLabel && current.startLine === draft.startLine && current.endLine === draft.endLine && current.code === draft.code)) {
-              return state;
-            }
-            return {
-              drafts: {
-                ...state.drafts,
-                [draft.sessionKey]: [...currentDrafts, newDraft],
-              },
-            };
+            const current = state.drafts[key] ?? [];
+            const isDuplicateTerminalDraft = draft.source === 'terminal' && current.some((item) => (
+              item.source === 'terminal'
+              && item.fileLabel === draft.fileLabel
+              && item.startLine === draft.startLine
+              && item.endLine === draft.endLine
+              && item.code === draft.code
+            ));
+            if (isDuplicateTerminalDraft) return state;
+
+            const bounded = boundState(
+              state,
+              { ...state.drafts, [key]: [...current, nextDraft] },
+              { ...state.touchedAt, [key]: Date.now() },
+              key,
+            );
+            if (!bounded || !bounded.drafts[key]?.some((item) => item.id === id)) return state;
+            accepted = true;
+            return bounded;
           });
-
-          return id;
+          return accepted ? id : null;
         },
-
-        updateDraft: (sessionKey, draftId, updates) => {
+        updateDraft: (target, draftId, updates) => {
+          const key = getCurrentKey(target);
+          if (!key) return;
           set((state) => {
-            const currentDrafts = state.drafts[sessionKey] ?? [];
-            const newDrafts = currentDrafts.map((draft) => {
-              if (draft.id !== draftId) {
-                return draft;
-              }
-              return {
-                ...draft,
-                ...updates,
-              };
-            });
-
-            return {
-              drafts: {
-                ...state.drafts,
-                [sessionKey]: newDrafts,
-              },
-            };
+            const current = state.drafts[key] ?? [];
+            if (!current.some((draft) => draft.id === draftId)) return state;
+            const bounded = boundState(
+              state,
+              { ...state.drafts, [key]: current.map((draft) => draft.id === draftId ? { ...draft, ...updates } : draft) },
+              { ...state.touchedAt, [key]: Date.now() },
+              key,
+            );
+            return bounded ?? state;
           });
         },
-
-        removeDraft: (sessionKey, draftId) => {
+        removeDraft: (target, draftId) => {
+          const key = getCurrentKey(target);
+          if (!key) return;
           set((state) => {
-            const currentDrafts = state.drafts[sessionKey] ?? [];
-            const newDrafts = currentDrafts.filter((d) => d.id !== draftId);
+            const current = state.drafts[key] ?? [];
+            const remaining = current.filter((draft) => draft.id !== draftId);
+            if (remaining.length === current.length) return state;
+            if (remaining.length === 0) return removeDraftKey(state, key);
 
-            if (newDrafts.length === 0) {
-              const { [sessionKey]: _removed, ...rest } = state.drafts;
-              void _removed;
-              return { drafts: rest };
-            }
-
-            return {
-              drafts: {
-                ...state.drafts,
-                [sessionKey]: newDrafts,
-              },
-            };
+            const drafts = { ...state.drafts };
+            const touchedAt = { ...state.touchedAt };
+            drafts[key] = remaining;
+            touchedAt[key] = Date.now();
+            return { drafts, touchedAt };
           });
         },
-
-        clearDrafts: (sessionKey) => {
-          set((state) => {
-            const { [sessionKey]: _removed, ...rest } = state.drafts;
-            void _removed;
-            return { drafts: rest };
-          });
+        clearDrafts: (target) => {
+          const key = getCurrentKey(target);
+          if (!key) return;
+          set((state) => removeDraftKey(state, key));
         },
-
-        getDrafts: (sessionKey) => {
-          return get().drafts[sessionKey] ?? [];
+        getDrafts: (target) => {
+          const key = getCurrentKey(target);
+          return key ? get().drafts[key] ?? EMPTY_INLINE_COMMENT_DRAFTS : EMPTY_INLINE_COMMENT_DRAFTS;
         },
-
-        consumeDrafts: (sessionKey) => {
-          const drafts = get().drafts[sessionKey] ?? [];
-          if (drafts.length === 0) return [];
-
-          // Sort by creation time to maintain order
-          const sortedDrafts = [...drafts].sort((a, b) => a.createdAt - b.createdAt);
-
-          // Clear drafts after consuming
-          set((state) => {
-            const { [sessionKey]: _removed, ...rest } = state.drafts;
-            void _removed;
-            return { drafts: rest };
-          });
-
-          return sortedDrafts;
+        consumeDrafts: (target) => {
+          const key = getCurrentKey(target);
+          if (!key) return [];
+          const drafts = [...(get().drafts[key] ?? [])].sort((left, right) => left.createdAt - right.createdAt);
+          if (drafts.length > 0) set((state) => removeDraftKey(state, key));
+          return drafts;
         },
-
-        restoreDrafts: (sessionKey, drafts) => {
-          if (drafts.length === 0) return;
+        restoreDrafts: (target, draftsToRestore) => {
+          const key = getCurrentKey(target);
+          if (!key || draftsToRestore.length === 0) return;
           set((state) => {
-            const current = state.drafts[sessionKey] ?? [];
+            const current = state.drafts[key] ?? [];
             const currentIds = new Set(current.map((draft) => draft.id));
-            const restored = drafts.filter((draft) => draft.sessionKey === sessionKey && !currentIds.has(draft.id));
+            const restored = draftsToRestore.filter((draft) => draft.sessionKey === target.sessionKey && !currentIds.has(draft.id));
             if (restored.length === 0) return state;
-            return {
-              drafts: {
-                ...state.drafts,
-                [sessionKey]: [...restored, ...current].sort((a, b) => a.createdAt - b.createdAt),
-              },
-            };
+            return boundState(
+              state,
+              { ...state.drafts, [key]: [...restored, ...current].sort((left, right) => left.createdAt - right.createdAt) },
+              { ...state.touchedAt, [key]: Date.now() },
+              key,
+            ) ?? state;
           });
         },
-
-        getDraftCount: (sessionKey) => {
-          return (get().drafts[sessionKey] ?? []).length;
-        },
-
-        hasDrafts: (sessionKey) => {
-          return (get().drafts[sessionKey] ?? []).length > 0;
+        getDraftCount: (target) => get().getDrafts(target).length,
+        hasDrafts: (target) => get().getDrafts(target).length > 0,
+        clearSessionDrafts: (runtimeKey, directory, sessionId) => {
+          const key = getInlineCommentDraftKey(runtimeKey, directory, sessionId);
+          if (!key) return;
+          set((state) => removeDraftKey(state, key));
         },
       }),
       {
         name: 'openchamber-inline-comment-drafts',
         storage: createDeferredSafeJSONStorage(),
-        version: 1,
-        migrate: (persistedState: unknown) => {
-          if (!persistedState || typeof persistedState !== 'object') {
-            return { drafts: {} };
-          }
-
-          const state = persistedState as { drafts?: unknown };
-          return {
-            drafts: sanitizeDraftMap(state.drafts),
-          };
-        },
-      }
+        version: 2,
+        partialize: (state) => ({ drafts: state.drafts, touchedAt: state.touchedAt }),
+        migrate: () => ({ drafts: {}, touchedAt: {} }),
+      },
     ),
-    { name: 'inline-comment-draft-store' }
-  )
+    { name: 'inline-comment-draft-store' },
+  ),
 );
diff --git a/packages/ui/src/stores/useProjectsStore.test.ts b/packages/ui/src/stores/useProjectsStore.test.ts
new file mode 100644
index 00000000..34c02726
--- /dev/null
+++ b/packages/ui/src/stores/useProjectsStore.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test"
+import type { ProjectEntry } from "@/lib/api/types"
+import type { DesktopSettings } from "@/lib/desktop"
+import { useProjectsStore } from "./useProjectsStore"
+
+describe("useProjectsStore settings synchronization", () => {
+  test("treats a successful empty project snapshot as authoritative", () => {
+    const project = { id: "project-a", path: "/repo", label: "Repo" } as ProjectEntry
+    useProjectsStore.setState({
+      projects: [project],
+      activeProjectId: project.id,
+      manualProjectOrder: [project.id],
+    })
+
+    useProjectsStore.getState().synchronizeFromSettings({ projects: [] } as DesktopSettings)
+
+    expect(useProjectsStore.getState().projects).toEqual([])
+    expect(useProjectsStore.getState().activeProjectId).toBe(null)
+    expect(useProjectsStore.getState().manualProjectOrder).toEqual([])
+  })
+})
diff --git a/packages/ui/src/stores/useProjectsStore.ts b/packages/ui/src/stores/useProjectsStore.ts
index 46feb476..d4c93952 100644
--- a/packages/ui/src/stores/useProjectsStore.ts
+++ b/packages/ui/src/stores/useProjectsStore.ts
@@ -916,25 +916,6 @@ export const useProjectsStore = create<ProjectsStore>()(
 
       const current = get();
 
-      // Race guard: settings load can return empty projects during app
-      // rebuild/reinstall or an incomplete settings read. Don't clobber
-      // a populated cache with empty — the sidebar would go blank and
-      // localStorage would be overwritten, losing the list entirely.
-      if (incomingProjects.length === 0 && current.projects.length > 0) {
-        if (incomingActive !== current.activeProjectId) {
-          // Active project may still be valid within the cached list.
-          const activeExists = incomingActive
-            ? current.projects.some((project) => project.id === incomingActive)
-            : true;
-          if (activeExists) {
-            set({ activeProjectId: incomingActive });
-            cacheProjects(current.projects, incomingActive);
-            persistManualProjectOrder(get().manualProjectOrder);
-          }
-        }
-        return;
-      }
-
       const projectsChanged = JSON.stringify(current.projects) !== JSON.stringify(incomingProjects);
       const activeChanged = current.activeProjectId !== incomingActive;
 
diff --git a/packages/ui/src/stores/useSessionFoldersStore.test.ts b/packages/ui/src/stores/useSessionFoldersStore.test.ts
index 95b8a9a4..088ebfd3 100644
--- a/packages/ui/src/stores/useSessionFoldersStore.test.ts
+++ b/packages/ui/src/stores/useSessionFoldersStore.test.ts
@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, mock, test } from 'bun:test';
 
 const storage = new Map<string, string>();
 let storageSetCount = 0;
+let runtimeKey = 'runtime-a';
+let diskResponseBody: Record<string, unknown> = { version: 1, exists: false };
 
 const safeStorage = {
   getItem: (key: string) => storage.get(key) ?? null,
@@ -31,8 +33,9 @@ mock.module('@/lib/desktop', () => ({
 }));
 
 mock.module('@/lib/runtime-fetch', () => ({
-  runtimeFetch: mock(async () => new Response('{}', { headers: { 'Content-Type': 'application/json' } })),
+  runtimeFetch: mock(async () => new Response(JSON.stringify(diskResponseBody), { headers: { 'Content-Type': 'application/json' } })),
 }));
+mock.module('@/lib/runtime-switch', () => ({ getRuntimeKey: () => runtimeKey }));
 
 const { useSessionFoldersStore } = await import('./useSessionFoldersStore');
 
@@ -42,6 +45,9 @@ describe('useSessionFoldersStore folder assignments', () => {
   beforeEach(() => {
     storage.clear();
     storageSetCount = 0;
+    runtimeKey = 'runtime-a';
+    diskResponseBody = { version: 1, exists: false };
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
     useSessionFoldersStore.setState({
       foldersMap: {},
       collapsedFolderIds: new Set<string>(),
@@ -77,4 +83,54 @@ describe('useSessionFoldersStore folder assignments', () => {
     expect(useSessionFoldersStore.getState().foldersMap).toBe(before);
     expect(storageSetCount).toBe(0);
   });
+
+  test('restores independent folder snapshots across runtime switches', async () => {
+    useSessionFoldersStore.getState().createFolder('/workspace/project', 'Runtime A');
+    await waitForPersist();
+
+    runtimeKey = 'runtime-b';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+    expect(useSessionFoldersStore.getState().getFoldersForScope('/workspace/project')).toEqual([]);
+    useSessionFoldersStore.getState().createFolder('/workspace/project', 'Runtime B');
+    await waitForPersist();
+
+    runtimeKey = 'runtime-a';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+    expect(useSessionFoldersStore.getState().getFoldersForScope('/workspace/project').map((folder) => folder.name)).toEqual(['Runtime A']);
+  });
+
+  test('flushes the outgoing runtime before a debounced browser write can be lost', () => {
+    useSessionFoldersStore.getState().createFolder('/workspace/project', 'Runtime A pending');
+
+    runtimeKey = 'runtime-b';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+    runtimeKey = 'runtime-a';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+
+    expect(useSessionFoldersStore.getState().getFoldersForScope('/workspace/project').map((folder) => folder.name)).toEqual(['Runtime A pending']);
+  });
+
+  test('does not replace browser folders when the server has no disk snapshot', async () => {
+    useSessionFoldersStore.getState().createFolder('/workspace/project', 'Browser folder');
+    runtimeKey = 'runtime-b';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+    runtimeKey = 'runtime-a';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(useSessionFoldersStore.getState().getFoldersForScope('/workspace/project').map((folder) => folder.name)).toEqual(['Browser folder']);
+  });
+
+  test('does not silently evict folder state from older runtimes', () => {
+    for (let index = 0; index < 10; index += 1) {
+      runtimeKey = `runtime-${index}`;
+      useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+      useSessionFoldersStore.getState().createFolder('/workspace/project', `Folder ${index}`);
+    }
+
+    runtimeKey = 'runtime-0';
+    useSessionFoldersStore.getState().resetForRuntimeSwitch(runtimeKey);
+    expect(useSessionFoldersStore.getState().getFoldersForScope('/workspace/project').map((folder) => folder.name)).toEqual(['Folder 0']);
+  });
 });
diff --git a/packages/ui/src/stores/useSessionFoldersStore.ts b/packages/ui/src/stores/useSessionFoldersStore.ts
index c4254873..9aabdaa3 100644
--- a/packages/ui/src/stores/useSessionFoldersStore.ts
+++ b/packages/ui/src/stores/useSessionFoldersStore.ts
@@ -1,8 +1,9 @@
 import { create } from 'zustand';
 import { devtools } from 'zustand/middleware';
-import { getDeferredSafeStorage } from './utils/safeStorage';
+import { getDeferredSafeStorage, getSafeStorage } from './utils/safeStorage';
 import { isVSCodeRuntime } from '@/lib/desktop';
 import { runtimeFetch } from '@/lib/runtime-fetch';
+import { getRuntimeKey } from '@/lib/runtime-switch';
 
 // --- Types ---
 
@@ -30,10 +31,11 @@ interface SessionFoldersActions {
   addSessionToFolder: (scopeKey: string, folderId: string, sessionId: string) => void;
   addSessionsToFolder: (scopeKey: string, folderId: string, sessionIds: string[]) => void;
   removeSessionFromFolder: (scopeKey: string, sessionId: string) => void;
+  removeSessionEverywhere: (runtimeKey: string, sessionId: string) => void;
   removeSessionsFromFolders: (scopeKey: string, sessionIds: string[]) => void;
   toggleFolderCollapse: (folderId: string) => void;
-  cleanupSessions: (scopeKey: string, existingSessionIds: Set<string>) => void;
   getSessionFolderId: (scopeKey: string, sessionId: string) => string | null;
+  resetForRuntimeSwitch: (runtimeKey: string) => void;
 }
 
 type SessionFoldersStore = SessionFoldersState & SessionFoldersActions;
@@ -42,11 +44,12 @@ type SessionFoldersStore = SessionFoldersState & SessionFoldersActions;
 
 const FOLDERS_STORAGE_KEY = 'oc.sessions.folders';
 const COLLAPSED_STORAGE_KEY = 'oc.sessions.folderCollapse';
+const STORAGE_INDEX_KEY = 'oc.sessions.folders.v2.index';
 const SESSION_FOLDERS_API_PATH = '/api/session-folders';
 const DISK_WRITE_DEBOUNCE_MS = 250;
-const ARCHIVED_SCOPE_PREFIX = '__archived__:';
 
 const safeStorage = getDeferredSafeStorage();
+const immediateSafeStorage = getSafeStorage();
 let diskWriteTimer: ReturnType<typeof setTimeout> | null = null;
 let diskHydrated = false;
 let diskHydrationInFlight = false;
@@ -54,6 +57,54 @@ let persistFoldersTimer: ReturnType<typeof setTimeout> | undefined;
 let persistCollapsedTimer: ReturnType<typeof setTimeout> | undefined;
 let pendingFoldersMap: SessionFoldersMap | null = null;
 let pendingCollapsedIds: Set<string> | null = null;
+let pendingBrowserRuntimeKey: string | null = null;
+let activeFolderRuntimeKey = getRuntimeKey();
+let folderRuntimeGeneration = 0;
+let folderMutationRevision = 0;
+const lastDiskUpdatedAtByRuntime = new Map<string, number>();
+
+type FolderStorageIndex = {
+  version: 2;
+  legacyClaimed: boolean;
+  runtimes: Array<{ runtimeKey: string; updatedAt: number }>;
+};
+
+const runtimeStorageKey = (base: string, runtimeKey: string) => `${base}.v2:${encodeURIComponent(runtimeKey)}`;
+const readStorageIndex = (): FolderStorageIndex => {
+  try {
+    const parsed = JSON.parse(safeStorage.getItem(STORAGE_INDEX_KEY) ?? '') as Partial<FolderStorageIndex>;
+    return parsed.version === 2 && Array.isArray(parsed.runtimes)
+      ? { version: 2, legacyClaimed: Boolean(parsed.legacyClaimed), runtimes: parsed.runtimes }
+      : { version: 2, legacyClaimed: false, runtimes: [] };
+  } catch {
+    return { version: 2, legacyClaimed: false, runtimes: [] };
+  }
+};
+
+const touchRuntimeStorage = (runtimeKey: string, updatedAt = Date.now(), targetStorage: Storage = safeStorage): void => {
+  const index = readStorageIndex();
+  const runtimes = [
+    { runtimeKey, updatedAt },
+    ...index.runtimes.filter((entry) => entry.runtimeKey !== runtimeKey),
+  ];
+  targetStorage.setItem(STORAGE_INDEX_KEY, JSON.stringify({ version: 2, legacyClaimed: index.legacyClaimed, runtimes }));
+};
+
+const claimLegacyStorage = (runtimeKey: string): void => {
+  const index = readStorageIndex();
+  if (index.legacyClaimed) return;
+  const legacyFolders = safeStorage.getItem(FOLDERS_STORAGE_KEY);
+  const legacyCollapsed = safeStorage.getItem(COLLAPSED_STORAGE_KEY);
+  if (legacyFolders) safeStorage.setItem(runtimeStorageKey(FOLDERS_STORAGE_KEY, runtimeKey), legacyFolders);
+  if (legacyCollapsed) safeStorage.setItem(runtimeStorageKey(COLLAPSED_STORAGE_KEY, runtimeKey), legacyCollapsed);
+  const next = { ...index, legacyClaimed: true };
+  safeStorage.setItem(STORAGE_INDEX_KEY, JSON.stringify(next));
+  if (safeStorage.getItem(STORAGE_INDEX_KEY) === JSON.stringify(next)) {
+    safeStorage.removeItem(FOLDERS_STORAGE_KEY);
+    safeStorage.removeItem(COLLAPSED_STORAGE_KEY);
+  }
+  touchRuntimeStorage(runtimeKey, 0);
+};
 
 const isVSCodeWebview = (): boolean => {
   if (typeof window === 'undefined') {
@@ -82,14 +133,19 @@ const schedulePersistToDisk = (foldersMap: SessionFoldersMap, collapsedFolderIds
 
   const foldersSnapshot = JSON.parse(JSON.stringify(foldersMap)) as SessionFoldersMap;
   const collapsedSnapshot = Array.from(collapsedFolderIds);
+  const runtimeKey = activeFolderRuntimeKey;
+  const generation = folderRuntimeGeneration;
 
   diskWriteTimer = setTimeout(() => {
     diskWriteTimer = null;
+    if (runtimeKey !== getRuntimeKey() || generation !== folderRuntimeGeneration) return;
+    const updatedAt = Math.max(Date.now(), (lastDiskUpdatedAtByRuntime.get(runtimeKey) ?? 0) + 1);
+    lastDiskUpdatedAtByRuntime.set(runtimeKey, updatedAt);
     const payload = {
       version: 1,
       foldersMap: foldersSnapshot,
       collapsedFolderIds: collapsedSnapshot,
-      updatedAt: Date.now(),
+      updatedAt,
     };
     void runtimeFetch(SESSION_FOLDERS_API_PATH, {
       method: 'POST',
@@ -99,9 +155,10 @@ const schedulePersistToDisk = (foldersMap: SessionFoldersMap, collapsedFolderIds
   }, DISK_WRITE_DEBOUNCE_MS);
 };
 
-const readPersistedFolders = (): SessionFoldersMap => {
+const readPersistedFolders = (runtimeKey = activeFolderRuntimeKey): SessionFoldersMap => {
   try {
-    const raw = safeStorage.getItem(FOLDERS_STORAGE_KEY);
+    claimLegacyStorage(runtimeKey);
+    const raw = safeStorage.getItem(runtimeStorageKey(FOLDERS_STORAGE_KEY, runtimeKey));
     if (!raw) {
       return {};
     }
@@ -138,9 +195,10 @@ const readPersistedFolders = (): SessionFoldersMap => {
   }
 };
 
-const readPersistedCollapsed = (): Set<string> => {
+const readPersistedCollapsed = (runtimeKey = activeFolderRuntimeKey): Set<string> => {
   try {
-    const raw = safeStorage.getItem(COLLAPSED_STORAGE_KEY);
+    claimLegacyStorage(runtimeKey);
+    const raw = safeStorage.getItem(runtimeStorageKey(COLLAPSED_STORAGE_KEY, runtimeKey));
     if (!raw) {
       return new Set();
     }
@@ -156,10 +214,13 @@ const readPersistedCollapsed = (): Set<string> => {
 
 const persistFolders = (foldersMap: SessionFoldersMap): void => {
   pendingFoldersMap = foldersMap;
+  pendingBrowserRuntimeKey = activeFolderRuntimeKey;
   clearTimeout(persistFoldersTimer);
   persistFoldersTimer = setTimeout(() => {
     try {
-      safeStorage.setItem(FOLDERS_STORAGE_KEY, JSON.stringify(foldersMap));
+      const runtimeKey = pendingBrowserRuntimeKey ?? activeFolderRuntimeKey;
+      safeStorage.setItem(runtimeStorageKey(FOLDERS_STORAGE_KEY, runtimeKey), JSON.stringify(foldersMap));
+      touchRuntimeStorage(runtimeKey);
       pendingFoldersMap = null;
     } catch {
       // ignored
@@ -169,10 +230,13 @@ const persistFolders = (foldersMap: SessionFoldersMap): void => {
 
 const persistCollapsed = (collapsedFolderIds: Set<string>): void => {
   pendingCollapsedIds = collapsedFolderIds;
+  pendingBrowserRuntimeKey = activeFolderRuntimeKey;
   clearTimeout(persistCollapsedTimer);
   persistCollapsedTimer = setTimeout(() => {
     try {
-      safeStorage.setItem(COLLAPSED_STORAGE_KEY, JSON.stringify(Array.from(collapsedFolderIds)));
+      const runtimeKey = pendingBrowserRuntimeKey ?? activeFolderRuntimeKey;
+      safeStorage.setItem(runtimeStorageKey(COLLAPSED_STORAGE_KEY, runtimeKey), JSON.stringify(Array.from(collapsedFolderIds)));
+      touchRuntimeStorage(runtimeKey);
       pendingCollapsedIds = null;
     } catch {
       // ignored
@@ -180,26 +244,54 @@ const persistCollapsed = (collapsedFolderIds: Set<string>): void => {
   }, 300);
 };
 
+const flushPendingBrowserPersistence = (): void => {
+  if (persistFoldersTimer) clearTimeout(persistFoldersTimer);
+  if (persistCollapsedTimer) clearTimeout(persistCollapsedTimer);
+  persistFoldersTimer = undefined;
+  persistCollapsedTimer = undefined;
+
+  const runtimeKey = pendingBrowserRuntimeKey ?? activeFolderRuntimeKey;
+  let wrote = false;
+  if (pendingFoldersMap !== null) {
+    const key = runtimeStorageKey(FOLDERS_STORAGE_KEY, runtimeKey);
+    const value = JSON.stringify(pendingFoldersMap);
+    safeStorage.setItem(key, value);
+    immediateSafeStorage.setItem(key, value);
+    pendingFoldersMap = null;
+    wrote = true;
+  }
+  if (pendingCollapsedIds !== null) {
+    const key = runtimeStorageKey(COLLAPSED_STORAGE_KEY, runtimeKey);
+    const value = JSON.stringify(Array.from(pendingCollapsedIds));
+    safeStorage.setItem(key, value);
+    immediateSafeStorage.setItem(key, value);
+    pendingCollapsedIds = null;
+    wrote = true;
+  }
+  if (wrote) {
+    const updatedAt = Date.now();
+    touchRuntimeStorage(runtimeKey, updatedAt);
+    touchRuntimeStorage(runtimeKey, updatedAt, immediateSafeStorage);
+  }
+  pendingBrowserRuntimeKey = null;
+};
+
 if (typeof window !== 'undefined') {
-  window.addEventListener('beforeunload', () => {
-    if (pendingFoldersMap !== null) {
-      clearTimeout(persistFoldersTimer);
-      try {
-        safeStorage.setItem(FOLDERS_STORAGE_KEY, JSON.stringify(pendingFoldersMap));
-      } catch { /* ignored */ }
-      pendingFoldersMap = null;
-    }
-    if (pendingCollapsedIds !== null) {
-      clearTimeout(persistCollapsedTimer);
-      try {
-        safeStorage.setItem(COLLAPSED_STORAGE_KEY, JSON.stringify(Array.from(pendingCollapsedIds)));
-      } catch { /* ignored */ }
-      pendingCollapsedIds = null;
-    }
-  });
+  const flushPending = () => {
+    try { flushPendingBrowserPersistence(); } catch { /* ignored */ }
+  };
+  window.addEventListener('pagehide', flushPending, { capture: true });
+  window.addEventListener('beforeunload', flushPending, { capture: true });
+  if (typeof document !== 'undefined') {
+    document.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden') flushPending();
+    });
+    document.addEventListener('freeze', flushPending);
+  }
 }
 
 const persistState = (foldersMap: SessionFoldersMap, collapsedFolderIds: Set<string>): void => {
+  folderMutationRevision += 1;
   persistFolders(foldersMap);
   persistCollapsed(collapsedFolderIds);
   schedulePersistToDisk(foldersMap, collapsedFolderIds);
@@ -232,14 +324,6 @@ const syncCollapsedAfterFolderCleanup = (
   return nextCollapsed;
 };
 
-const pruneEmptyArchivedFolders = (scopeKey: string, folders: SessionFolder[]): SessionFolder[] => {
-  if (!scopeKey.startsWith(ARCHIVED_SCOPE_PREFIX)) {
-    return folders;
-  }
-
-  return folders.filter((folder) => folder.sessionIds.length > 0);
-};
-
 // --- Store ---
 
 export const useSessionFoldersStore = create<SessionFoldersStore>()(
@@ -248,6 +332,22 @@ export const useSessionFoldersStore = create<SessionFoldersStore>()(
       foldersMap: readPersistedFolders(),
       collapsedFolderIds: readPersistedCollapsed(),
 
+      resetForRuntimeSwitch: (runtimeKey: string): void => {
+        try { flushPendingBrowserPersistence(); } catch { /* deferred storage retains failed writes */ }
+        activeFolderRuntimeKey = runtimeKey;
+        folderRuntimeGeneration += 1;
+        folderMutationRevision = 0;
+        diskHydrated = false;
+        diskHydrationInFlight = false;
+        if (diskWriteTimer) clearTimeout(diskWriteTimer);
+        diskWriteTimer = null;
+        set({
+          foldersMap: readPersistedFolders(runtimeKey),
+          collapsedFolderIds: readPersistedCollapsed(runtimeKey),
+        });
+        queueMicrotask(() => void hydrateSessionFoldersFromDisk());
+      },
+
       getFoldersForScope: (scopeKey: string): SessionFolder[] => {
         if (!scopeKey) return [];
         return get().foldersMap[scopeKey] ?? [];
@@ -306,18 +406,12 @@ export const useSessionFoldersStore = create<SessionFoldersStore>()(
         }
         const nextFolders = scopeFolders.filter((folder) => !idsToDelete.has(folder.id));
         const nextMap: SessionFoldersMap = { ...current, [scopeKey]: nextFolders };
-        set({ foldersMap: nextMap });
-        persistState(nextMap, get().collapsedFolderIds);
-
-        // Clean up collapsed state for all deleted folders
         const collapsed = get().collapsedFolderIds;
-        const hasStale = Array.from(idsToDelete).some((id) => collapsed.has(id));
-        if (hasStale) {
-          const nextCollapsed = new Set(collapsed);
-          idsToDelete.forEach((id) => nextCollapsed.delete(id));
-          set({ collapsedFolderIds: nextCollapsed });
-          persistState(nextMap, nextCollapsed);
-        }
+        const nextCollapsed = syncCollapsedAfterFolderCleanup(scopeFolders, nextFolders, collapsed);
+        set(nextCollapsed
+          ? { foldersMap: nextMap, collapsedFolderIds: nextCollapsed }
+          : { foldersMap: nextMap });
+        persistState(nextMap, nextCollapsed ?? collapsed);
       },
 
       addSessionToFolder: (scopeKey: string, folderId: string, sessionId: string): void => {
@@ -466,6 +560,29 @@ export const useSessionFoldersStore = create<SessionFoldersStore>()(
         persistState(nextMap, nextCollapsed ?? get().collapsedFolderIds);
       },
 
+      removeSessionEverywhere: (runtimeKey: string, sessionId: string): void => {
+        if (!runtimeKey || runtimeKey !== activeFolderRuntimeKey || runtimeKey !== getRuntimeKey() || !sessionId) return;
+        const current = get().foldersMap;
+        let nextMap: SessionFoldersMap | null = null;
+
+        for (const [scopeKey, scopeFolders] of Object.entries(current)) {
+          let scopeChanged = false;
+          const nextFolders = scopeFolders.map((folder) => {
+            const sessionIds = folder.sessionIds.filter((id) => id !== sessionId);
+            if (sessionIds.length === folder.sessionIds.length) return folder;
+            scopeChanged = true;
+            return { ...folder, sessionIds };
+          });
+          if (!scopeChanged) continue;
+          nextMap ??= { ...current };
+          nextMap[scopeKey] = nextFolders;
+        }
+
+        if (!nextMap) return;
+        set({ foldersMap: nextMap });
+        persistState(nextMap, get().collapsedFolderIds);
+      },
+
       toggleFolderCollapse: (folderId: string): void => {
         const collapsed = get().collapsedFolderIds;
         const next = new Set(collapsed);
@@ -478,37 +595,6 @@ export const useSessionFoldersStore = create<SessionFoldersStore>()(
         persistState(get().foldersMap, next);
       },
 
-      cleanupSessions: (scopeKey: string, existingSessionIds: Set<string>): void => {
-        if (!scopeKey) return;
-        const current = get().foldersMap;
-        const scopeFolders = current[scopeKey];
-        if (!scopeFolders || scopeFolders.length === 0) return;
-
-        let changed = false;
-        const filteredFolders = scopeFolders.map((folder) => {
-          const filtered = folder.sessionIds.filter((id) => existingSessionIds.has(id));
-          if (filtered.length !== folder.sessionIds.length) {
-            changed = true;
-            return { ...folder, sessionIds: filtered };
-          }
-          return folder;
-        });
-
-        const nextFolders = pruneEmptyArchivedFolders(scopeKey, filteredFolders);
-        if (nextFolders.length !== filteredFolders.length) {
-          changed = true;
-        }
-
-        if (!changed) return;
-        const nextMap: SessionFoldersMap = { ...current, [scopeKey]: nextFolders };
-        const nextCollapsed = syncCollapsedAfterFolderCleanup(scopeFolders, nextFolders, get().collapsedFolderIds);
-
-        set(nextCollapsed
-          ? { foldersMap: nextMap, collapsedFolderIds: nextCollapsed }
-          : { foldersMap: nextMap });
-        persistState(nextMap, nextCollapsed ?? get().collapsedFolderIds);
-      },
-
       getSessionFolderId: (scopeKey: string, sessionId: string): string | null => {
         if (!scopeKey || !sessionId) return null;
         const scopeFolders = get().foldersMap[scopeKey];
@@ -536,6 +622,10 @@ const hydrateSessionFoldersFromDisk = async (): Promise<void> => {
   }
 
   diskHydrationInFlight = true;
+  const runtimeKey = activeFolderRuntimeKey;
+  const generation = folderRuntimeGeneration;
+  const baselineMutationRevision = folderMutationRevision;
+  let completed = false;
 
   try {
     const response = await runtimeFetch(SESSION_FOLDERS_API_PATH).catch(() => null);
@@ -544,14 +634,21 @@ const hydrateSessionFoldersFromDisk = async (): Promise<void> => {
     }
 
     const parsed = await response.json().catch(() => null) as {
+      exists?: boolean;
       foldersMap?: SessionFoldersMap;
       collapsedFolderIds?: string[];
+      updatedAt?: number;
     } | null;
 
     if (!parsed) {
       return;
     }
 
+    if (parsed.exists === false) {
+      completed = true;
+      return;
+    }
+
     const diskFolders = parsed.foldersMap && typeof parsed.foldersMap === 'object'
       ? parsed.foldersMap
       : {};
@@ -559,23 +656,26 @@ const hydrateSessionFoldersFromDisk = async (): Promise<void> => {
       ? new Set(parsed.collapsedFolderIds.filter((value): value is string => typeof value === 'string'))
       : new Set<string>();
 
-    const hasDiskData = Object.keys(diskFolders).length > 0 || diskCollapsed.size > 0;
-    if (!hasDiskData) {
-      return;
+    if (generation !== folderRuntimeGeneration || runtimeKey !== getRuntimeKey()) return;
+    const browserUpdatedAt = readStorageIndex().runtimes.find((entry) => entry.runtimeKey === runtimeKey)?.updatedAt ?? 0;
+    const diskUpdatedAt = typeof parsed.updatedAt === 'number' && Number.isFinite(parsed.updatedAt) ? parsed.updatedAt : 0;
+    if (diskUpdatedAt > 0) {
+      lastDiskUpdatedAtByRuntime.set(runtimeKey, Math.max(lastDiskUpdatedAtByRuntime.get(runtimeKey) ?? 0, diskUpdatedAt));
     }
-
-    useSessionFoldersStore.setState({
-      foldersMap: diskFolders,
-      collapsedFolderIds: diskCollapsed,
-    });
-
-    persistFolders(diskFolders);
-    persistCollapsed(diskCollapsed);
+    const hasDiskAuthority = parsed.exists === true || diskUpdatedAt > 0;
+    if (hasDiskAuthority && folderMutationRevision === baselineMutationRevision && diskUpdatedAt >= browserUpdatedAt) {
+      useSessionFoldersStore.setState({ foldersMap: diskFolders, collapsedFolderIds: diskCollapsed });
+      persistFolders(diskFolders);
+      persistCollapsed(diskCollapsed);
+    }
+    completed = true;
   } catch {
     // ignored
   } finally {
-    diskHydrationInFlight = false;
-    diskHydrated = true;
+    if (generation === folderRuntimeGeneration && runtimeKey === getRuntimeKey()) {
+      diskHydrationInFlight = false;
+      if (completed) diskHydrated = true;
+    }
   }
 };
 
diff --git a/packages/ui/src/stores/useSessionPinnedStore.test.ts b/packages/ui/src/stores/useSessionPinnedStore.test.ts
new file mode 100644
index 00000000..327a0a5a
--- /dev/null
+++ b/packages/ui/src/stores/useSessionPinnedStore.test.ts
@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { getPinnedSessionKey, isSessionPinned, useSessionPinnedStore } from './useSessionPinnedStore';
+
+describe('useSessionPinnedStore', () => {
+  beforeEach(() => {
+    useSessionPinnedStore.setState({ ids: new Set(), touchedAt: {} });
+  });
+
+  test('isolates identical session IDs by directory', () => {
+    const store = useSessionPinnedStore.getState();
+    store.toggle({ directory: '/repo-a', sessionId: 'session-1' });
+    store.toggle({ directory: '/repo-b', sessionId: 'session-1' });
+
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-a/', 'session-1')).toBe(true);
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-b', 'session-1')).toBe(true);
+    store.toggle({ directory: '/repo-a', sessionId: 'session-1' });
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-a', 'session-1')).toBe(false);
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-b', 'session-1')).toBe(true);
+  });
+
+  test('explicit deletion clears only the matching runtime and directory', () => {
+    const runtimeKey = getRuntimeKey();
+    const activeKey = getPinnedSessionKey(runtimeKey, '/repo', 'session-1')!;
+    const otherRuntimeKey = getPinnedSessionKey('other-runtime', '/repo', 'session-1')!;
+    useSessionPinnedStore.setState({
+      ids: new Set([activeKey, otherRuntimeKey]),
+      touchedAt: { [activeKey]: 1, [otherRuntimeKey]: 2 },
+    });
+
+    useSessionPinnedStore.getState().clearPinnedSession(runtimeKey, '/repo/', 'session-1');
+
+    expect(useSessionPinnedStore.getState().ids.has(activeKey)).toBe(false);
+    expect(useSessionPinnedStore.getState().ids.has(otherRuntimeKey)).toBe(true);
+  });
+
+  test('does not silently evict older user pins', () => {
+    const store = useSessionPinnedStore.getState();
+    for (let index = 0; index < 250; index += 1) {
+      store.toggle({ directory: '/repo', sessionId: `session-${index}` });
+    }
+
+    expect(useSessionPinnedStore.getState().ids.size).toBe(250);
+  });
+});
diff --git a/packages/ui/src/stores/useSessionPinnedStore.ts b/packages/ui/src/stores/useSessionPinnedStore.ts
index 56b42f71..41630a98 100644
--- a/packages/ui/src/stores/useSessionPinnedStore.ts
+++ b/packages/ui/src/stores/useSessionPinnedStore.ts
@@ -1,54 +1,121 @@
 import { create } from 'zustand';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { normalizePath } from '@/lib/pathNormalization';
 import { getDeferredSafeStorage } from './utils/safeStorage';
 
-const SESSION_PINNED_STORAGE_KEY = 'oc.sessions.pinned';
+const STORAGE_KEY = 'oc.sessions.pinned.v2';
+const LEGACY_STORAGE_KEY = 'oc.sessions.pinned';
 
-const readPinned = (storage: Storage): Set<string> => {
-  try {
-    const raw = storage.getItem(SESSION_PINNED_STORAGE_KEY);
-    if (!raw) return new Set();
-    const parsed = JSON.parse(raw) as unknown;
-    if (!Array.isArray(parsed)) return new Set();
-    return new Set(parsed.filter((item): item is string => typeof item === 'string'));
-  } catch {
-    return new Set();
-  }
-};
+export type SessionPinnedTarget = { directory: string; sessionId: string };
 
-const persistPinned = (storage: Storage, ids: Set<string>): void => {
-  try {
-    storage.setItem(SESSION_PINNED_STORAGE_KEY, JSON.stringify([...ids]));
-  } catch {
-    // ignore
-  }
-};
+type PersistedPins = { version: 2; sessions: Record<string, number> };
 
-type SessionPinnedStore = {
+type PinnedSessionState = {
   ids: Set<string>;
-  setIds: (next: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
-  toggle: (sessionId: string) => void;
+  touchedAt: Record<string, number>;
 };
 
-const safeStorage = getDeferredSafeStorage();
+type SessionPinnedStore = PinnedSessionState & {
+  setIds: (next: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
+  toggle: (target: SessionPinnedTarget) => void;
+  clearPinnedSession: (runtimeKey: string, directory: string, sessionId: string) => void;
+};
+
+const storage = getDeferredSafeStorage();
+
+export const getPinnedSessionKey = (runtimeKey: string, directory: string, sessionId: string): string | null => {
+  const normalizedDirectory = normalizePath(directory);
+  if (!runtimeKey || !normalizedDirectory || !sessionId) return null;
+  return JSON.stringify([runtimeKey, normalizedDirectory, sessionId]);
+};
+
+const parsePinnedSessionKey = (key: string): [string, string, string] | null => {
+  try {
+    const parsed = JSON.parse(key) as unknown;
+    if (!Array.isArray(parsed) || parsed.length !== 3) return null;
+    const [runtimeKey, directory, sessionId] = parsed;
+    if (typeof runtimeKey !== 'string' || typeof directory !== 'string' || typeof sessionId !== 'string') return null;
+    const normalizedDirectory = normalizePath(directory);
+    if (!runtimeKey || !normalizedDirectory || normalizedDirectory !== directory || !sessionId) return null;
+    return [runtimeKey, normalizedDirectory, sessionId];
+  } catch {
+    return null;
+  }
+};
+
+export const isSessionPinned = (ids: Set<string>, directory: string | null | undefined, sessionId: string): boolean => {
+  if (!directory) return false;
+  const key = getPinnedSessionKey(getRuntimeKey(), directory, sessionId);
+  return key ? ids.has(key) : false;
+};
+
+const readPinned = (): PinnedSessionState => {
+  storage.removeItem(LEGACY_STORAGE_KEY);
+  const raw = storage.getItem(STORAGE_KEY);
+  if (raw === null) return { ids: new Set(), touchedAt: {} };
+  try {
+    const parsed = JSON.parse(raw) as Partial<PersistedPins>;
+    if (parsed.version !== 2 || !parsed.sessions || typeof parsed.sessions !== 'object') return { ids: new Set(), touchedAt: {} };
+    const entries = Object.entries(parsed.sessions)
+      .filter(([key, touchedAt]) => parsePinnedSessionKey(key) && typeof touchedAt === 'number' && Number.isFinite(touchedAt))
+      .sort((left, right) => right[1] - left[1]);
+    return { ids: new Set(entries.map(([key]) => key)), touchedAt: Object.fromEntries(entries) };
+  } catch {
+    storage.removeItem(STORAGE_KEY);
+    return { ids: new Set(), touchedAt: {} };
+  }
+};
+
+const boundPinnedState = (ids: Set<string>, touchedAt: Record<string, number>): PinnedSessionState => {
+  const entries = [...ids]
+    .filter((key) => parsePinnedSessionKey(key) !== null)
+    .map((key) => [key, touchedAt[key] ?? Date.now()] as const)
+    .sort((left, right) => right[1] - left[1]);
+  return {
+    ids: new Set(entries.map(([key]) => key)),
+    touchedAt: Object.fromEntries(entries),
+  };
+};
+
+const persistPinned = ({ ids, touchedAt }: PinnedSessionState): void => {
+  const sessions = Object.fromEntries([...ids].map((key) => [key, touchedAt[key] ?? Date.now()]));
+  storage.setItem(STORAGE_KEY, JSON.stringify({ version: 2, sessions }));
+};
+
+const initial = readPinned();
 
 export const useSessionPinnedStore = create<SessionPinnedStore>((set, get) => ({
-  ids: readPinned(safeStorage),
+  ids: initial.ids,
+  touchedAt: initial.touchedAt,
   setIds: (next) => {
     const current = get().ids;
     const resolved = typeof next === 'function' ? next(current) : next;
     if (resolved === current) return;
-    set({ ids: resolved });
-    persistPinned(safeStorage, resolved);
+    const pinnedState = boundPinnedState(resolved, get().touchedAt);
+    set(pinnedState);
+    persistPinned(pinnedState);
   },
-  toggle: (sessionId) => {
-    const current = get().ids;
-    const next = new Set(current);
-    if (next.has(sessionId)) {
-      next.delete(sessionId);
+  toggle: (target) => {
+    const key = getPinnedSessionKey(getRuntimeKey(), target.directory, target.sessionId);
+    if (!key) return;
+    const ids = new Set(get().ids);
+    const touchedAt = { ...get().touchedAt };
+    if (ids.has(key)) {
+      ids.delete(key);
+      delete touchedAt[key];
     } else {
-      next.add(sessionId);
+      ids.add(key);
+      touchedAt[key] = Date.now();
     }
-    set({ ids: next });
-    persistPinned(safeStorage, next);
+    const pinnedState = boundPinnedState(ids, touchedAt);
+    set(pinnedState);
+    persistPinned(pinnedState);
+  },
+  clearPinnedSession: (runtimeKey, directory, sessionId) => {
+    const key = getPinnedSessionKey(runtimeKey, directory, sessionId);
+    if (!key || !get().ids.has(key)) return;
+    const ids = new Set(get().ids);
+    ids.delete(key);
+    get().setIds(ids);
   },
 }));
diff --git a/packages/ui/src/stores/useTodosPersistStore.test.ts b/packages/ui/src/stores/useTodosPersistStore.test.ts
new file mode 100644
index 00000000..df8d6052
--- /dev/null
+++ b/packages/ui/src/stores/useTodosPersistStore.test.ts
@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import type { Todo } from '@opencode-ai/sdk/v2/client';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { getTodosPersistenceKey, useTodosPersistStore } from './useTodosPersistStore';
+
+const todo = (content: string): Todo => ({ content, status: 'pending', priority: 'medium' });
+
+describe('useTodosPersistStore', () => {
+    beforeEach(() => {
+        useTodosPersistStore.setState({ sessions: {} });
+    });
+
+    test('isolates identical session IDs by directory', () => {
+        const store = useTodosPersistStore.getState();
+        store.setSessionTodos('/repo-a', 'session-1', [todo('a')]);
+        store.setSessionTodos('/repo-b', 'session-1', [todo('b')]);
+
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo-a', 'session-1')).toEqual([todo('a')]);
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo-b', 'session-1')).toEqual([todo('b')]);
+    });
+
+    test('stores entries under the active runtime identity', () => {
+        useTodosPersistStore.getState().setSessionTodos('/repo', 'session-1', [todo('active')]);
+
+        const key = getTodosPersistenceKey(getRuntimeKey(), '/repo', 'session-1');
+        expect(useTodosPersistStore.getState().sessions[key]?.todos).toEqual([todo('active')]);
+        expect(getTodosPersistenceKey('runtime-a', '/repo', 'session-1'))
+            .not.toBe(getTodosPersistenceKey('runtime-b', '/repo', 'session-1'));
+    });
+
+    test('removes only the matching composite session', () => {
+        const store = useTodosPersistStore.getState();
+        store.setSessionTodos('/repo-a', 'session-1', [todo('a')]);
+        store.setSessionTodos('/repo-b', 'session-1', [todo('b')]);
+        store.setSessionTodos('/repo-a', 'session-1', []);
+
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo-a', 'session-1')).toBe(undefined);
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo-b', 'session-1')).toEqual([todo('b')]);
+    });
+
+    test('clears an explicitly owned runtime session', () => {
+        const runtimeKey = getRuntimeKey();
+        const store = useTodosPersistStore.getState();
+        store.setSessionTodos('/repo', 'session-1', [todo('active')]);
+        store.clearSessionTodos('other-runtime', '/repo', 'session-1');
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo', 'session-1')).toEqual([todo('active')]);
+
+        store.clearSessionTodos(runtimeKey, '/repo/', 'session-1');
+        expect(useTodosPersistStore.getState().getSessionTodos('/repo', 'session-1')).toBe(undefined);
+    });
+});
diff --git a/packages/ui/src/stores/useTodosPersistStore.ts b/packages/ui/src/stores/useTodosPersistStore.ts
index 0a5ba49f..be16a807 100644
--- a/packages/ui/src/stores/useTodosPersistStore.ts
+++ b/packages/ui/src/stores/useTodosPersistStore.ts
@@ -1,6 +1,8 @@
 import { create } from 'zustand';
 import { devtools, persist } from 'zustand/middleware';
 import type { Todo } from '@opencode-ai/sdk/v2/client';
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { normalizePath } from '@/lib/pathNormalization';
 import { createDeferredSafeJSONStorage } from './utils/safeStorage';
 
 const MAX_SESSIONS = 50;
@@ -12,10 +14,19 @@ interface SessionTodosRecord {
 
 interface TodosPersistState {
     sessions: Record<string, SessionTodosRecord>;
-    setSessionTodos: (sessionId: string, todos: Todo[] | undefined) => void;
-    getSessionTodos: (sessionId: string) => Todo[] | undefined;
+    setSessionTodos: (directory: string, sessionId: string, todos: Todo[] | undefined) => void;
+    getSessionTodos: (directory: string, sessionId: string) => Todo[] | undefined;
+    clearSessionTodos: (runtimeKey: string, directory: string, sessionId: string) => void;
 }
 
+export const getTodosPersistenceKey = (runtimeKey: string, directory: string, sessionId: string): string =>
+    JSON.stringify([runtimeKey, normalizePath(directory), sessionId]);
+
+const getCurrentSessionKey = (directory: string, sessionId: string): string | null => {
+    if (!directory || !sessionId) return null;
+    return getTodosPersistenceKey(getRuntimeKey(), directory, sessionId);
+};
+
 const evictOldest = (sessions: Record<string, SessionTodosRecord>): Record<string, SessionTodosRecord> => {
     const ids = Object.keys(sessions);
     if (ids.length <= MAX_SESSIONS) return sessions;
@@ -34,29 +45,41 @@ export const useTodosPersistStore = create<TodosPersistState>()(
         persist(
             (set, get) => ({
                 sessions: {},
-                setSessionTodos: (sessionId, todos) => {
-                    if (!sessionId) return;
+                setSessionTodos: (directory, sessionId, todos) => {
+                    const key = getCurrentSessionKey(directory, sessionId);
+                    if (!key) return;
                     set((state) => {
                         const next = { ...state.sessions };
                         if (!todos || todos.length === 0) {
-                            if (!(sessionId in next)) return state;
-                            delete next[sessionId];
+                            if (!(key in next)) return state;
+                            delete next[key];
                             return { sessions: next };
                         }
-                        next[sessionId] = { todos, touchedAt: Date.now() };
+                        next[key] = { todos, touchedAt: Date.now() };
                         return { sessions: evictOldest(next) };
                     });
                 },
-                getSessionTodos: (sessionId) => {
-                    if (!sessionId) return undefined;
-                    return get().sessions[sessionId]?.todos;
+                getSessionTodos: (directory, sessionId) => {
+                    const key = getCurrentSessionKey(directory, sessionId);
+                    return key ? get().sessions[key]?.todos : undefined;
+                },
+                clearSessionTodos: (runtimeKey, directory, sessionId) => {
+                    if (!runtimeKey || !directory || !sessionId) return;
+                    const key = getTodosPersistenceKey(runtimeKey, directory, sessionId);
+                    set((state) => {
+                        if (!(key in state.sessions)) return state;
+                        const sessions = { ...state.sessions };
+                        delete sessions[key];
+                        return { sessions };
+                    });
                 },
             }),
             {
                 name: 'openchamber-session-todos',
-                version: 1,
+                version: 2,
                 storage: createDeferredSafeJSONStorage(),
                 partialize: (state) => ({ sessions: state.sessions }),
+                migrate: () => ({ sessions: {} }),
             },
         ),
         { name: 'TodosPersistStore' },
diff --git a/packages/ui/src/stores/utils/safeStorage.test.ts b/packages/ui/src/stores/utils/safeStorage.test.ts
index 359d2ed1..d4289485 100644
--- a/packages/ui/src/stores/utils/safeStorage.test.ts
+++ b/packages/ui/src/stores/utils/safeStorage.test.ts
@@ -158,4 +158,64 @@ describe('safeStorage', () => {
             }
         }
     });
+
+    test('isolates quota failures to one key and retries durable storage later', async () => {
+        const previousWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
+        const backingStorage = createFakeStorage();
+        backingStorage.setItem('large', 'old');
+        const originalSet = backingStorage.setItem.bind(backingStorage);
+        let rejectLarge = true;
+        backingStorage.setItem = (key, value) => {
+            if (key === 'large' && rejectLarge) throw new DOMException('quota', 'QuotaExceededError');
+            originalSet(key, value);
+        };
+        Object.defineProperty(globalThis, 'window', {
+            configurable: true,
+            value: { localStorage: backingStorage, sessionStorage: createFakeStorage(), addEventListener: () => {} },
+        });
+
+        try {
+            const { getSafeStorage } = await importSafeStorage();
+            const storage = getSafeStorage();
+            storage.setItem('large', 'ephemeral-new');
+            storage.setItem('unrelated', 'durable');
+
+            expect(storage.getItem('large')).toBe('ephemeral-new');
+            expect(backingStorage.getItem('large')).toBeNull();
+            expect(backingStorage.getItem('unrelated')).toBe('durable');
+
+            rejectLarge = false;
+            storage.setItem('large', 'durable-new');
+            expect(backingStorage.getItem('large')).toBe('durable-new');
+            expect(storage.getItem('large')).toBe('durable-new');
+        } finally {
+            if (previousWindow) Object.defineProperty(globalThis, 'window', previousWindow);
+            else delete (globalThis as { window?: unknown }).window;
+        }
+    });
+
+    test('removes malformed persisted JSON and permits later recovery', async () => {
+        const previousWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
+        const backingStorage = createFakeStorage();
+        backingStorage.setItem('broken', '{not-json');
+        Object.defineProperty(globalThis, 'window', {
+            configurable: true,
+            value: { localStorage: backingStorage, sessionStorage: createFakeStorage(), addEventListener: () => {} },
+        });
+
+        try {
+            const { createDeferredSafeJSONStorage } = await importSafeStorage();
+            const storage = createDeferredSafeJSONStorage<{ value: string }>();
+            if (!storage) throw new Error('storage unavailable');
+
+            expect(storage.getItem('broken')).toBeNull();
+            expect(backingStorage.getItem('broken')).toBeNull();
+            storage.setItem('broken', { state: { value: 'recovered' } });
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(storage.getItem('broken')).toEqual({ state: { value: 'recovered' } });
+        } finally {
+            if (previousWindow) Object.defineProperty(globalThis, 'window', previousWindow);
+            else delete (globalThis as { window?: unknown }).window;
+        }
+    });
 });
diff --git a/packages/ui/src/stores/utils/safeStorage.ts b/packages/ui/src/stores/utils/safeStorage.ts
index 8389d089..f31d3bfb 100644
--- a/packages/ui/src/stores/utils/safeStorage.ts
+++ b/packages/ui/src/stores/utils/safeStorage.ts
@@ -26,10 +26,12 @@ const registerDeferredFlusher = (flush: () => void) => {
     try {
         window.addEventListener('pagehide', flushAll, { capture: true });
         window.addEventListener('beforeunload', flushAll, { capture: true });
-        window.addEventListener('visibilitychange', () => {
-            if (typeof document !== 'undefined' && document.visibilityState === 'hidden') flushAll();
-        });
-        window.addEventListener('freeze', flushAll);
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'hidden') flushAll();
+            });
+            document.addEventListener('freeze', flushAll);
+        }
     } catch {
         // Restricted environments can reject listeners; timers still flush.
     }
@@ -64,6 +66,7 @@ const createDeferredJSONStorage = <S>(
                 storage.setItem(name, JSON.stringify(value, options?.replacer));
             } catch (error) {
                 console.error('Failed to persist deferred storage value', error);
+                if (!pendingWrites.has(name) && !pendingDeletes.has(name)) pendingWrites.set(name, value);
             }
         }
         for (const name of deletes) {
@@ -71,6 +74,7 @@ const createDeferredJSONStorage = <S>(
                 storage.removeItem(name);
             } catch (error) {
                 console.error('Failed to remove deferred storage value', error);
+                if (!pendingWrites.has(name)) pendingDeletes.add(name);
             }
         }
     };
@@ -93,7 +97,16 @@ const createDeferredJSONStorage = <S>(
 
             const parse = (value: string | null): StorageValue<S> | null => {
                 if (value === null) return null;
-                return JSON.parse(value, options?.reviver) as StorageValue<S>;
+                try {
+                    return JSON.parse(value, options?.reviver) as StorageValue<S>;
+                } catch {
+                    try {
+                        storage.removeItem(name);
+                    } catch {
+                        // A later hydration can retry cleanup.
+                    }
+                    return null;
+                }
             };
             const value = storage.getItem(name);
             if (value instanceof Promise) {
@@ -137,6 +150,7 @@ const createDeferredStorage = (storage: Storage): Storage => {
                 storage.setItem(key, value);
             } catch (error) {
                 console.error('Failed to persist deferred storage value', error);
+                if (!pendingWrites.has(key) && !pendingDeletes.has(key)) pendingWrites.set(key, value);
             }
         }
         for (const key of deletes) {
@@ -144,6 +158,7 @@ const createDeferredStorage = (storage: Storage): Storage => {
                 storage.removeItem(key);
             } catch (error) {
                 console.error('Failed to remove deferred storage value', error);
+                if (!pendingWrites.has(key)) pendingDeletes.add(key);
             }
         }
     };
@@ -219,80 +234,84 @@ const createInMemoryStorage = (): Storage => {
     } as Storage;
 };
 
-const createSafeStorage = (): Storage => {
-    const baseStorage = getWindowStorage('localStorage');
-
-    if (!baseStorage) {
-        return createInMemoryStorage();
-    }
-
+const createSafeStorageAdapter = (baseStorage: Storage): Storage => {
     const fallback = createInMemoryStorage();
-    let storageAvailable = true;
-
-    const disableStorage = () => {
-        storageAvailable = false;
-    };
+    const fallbackKeys = new Set<string>();
+    const deletedKeys = new Set<string>();
 
     const safeGet = (key: string): string | null => {
-        if (storageAvailable) {
-            try {
-                const value = baseStorage.getItem(key);
-                if (value !== null) {
-                    return value;
-                }
-            } catch {
-                disableStorage();
-            }
+        if (deletedKeys.has(key)) return null;
+        if (fallbackKeys.has(key)) return fallback.getItem(key);
+        try {
+            return baseStorage.getItem(key);
+        } catch {
+            return null;
         }
-        return fallback.getItem(key);
     };
 
     const safeSet = (key: string, value: string) => {
-        if (storageAvailable) {
+        try {
+            baseStorage.setItem(key, value);
+            fallback.removeItem(key);
+            fallbackKeys.delete(key);
+            deletedKeys.delete(key);
+            return;
+        } catch {
+            // Hide an older durable value even when quota or storage policy blocks replacement.
             try {
-                baseStorage.setItem(key, value);
-                fallback.removeItem(key);
-                return;
+                baseStorage.removeItem(key);
             } catch {
-                disableStorage();
-                // Prevent stale previous value from surviving when writes fail (e.g. quota).
-                try {
-                    baseStorage.removeItem(key);
-                } catch {
-                    // noop
-                }
+                // The ephemeral override remains authoritative for this adapter.
             }
         }
         fallback.setItem(key, value);
+        fallbackKeys.add(key);
+        deletedKeys.delete(key);
     };
 
     const safeRemove = (key: string) => {
         try {
             baseStorage.removeItem(key);
+            deletedKeys.delete(key);
         } catch {
-            disableStorage();
+            deletedKeys.add(key);
         }
         fallback.removeItem(key);
+        fallbackKeys.delete(key);
     };
 
     const safeClear = () => {
+        const knownKeys: string[] = [];
+        try {
+            for (let index = 0; index < baseStorage.length; index += 1) {
+                const key = baseStorage.key(index);
+                if (key) knownKeys.push(key);
+            }
+        } catch {
+            // Best-effort tombstones cover keys that could be enumerated.
+        }
         try {
             baseStorage.clear();
+            deletedKeys.clear();
         } catch {
-            disableStorage();
+            for (const key of knownKeys) deletedKeys.add(key);
         }
         fallback.clear();
+        fallbackKeys.clear();
     };
 
-    const safeKey = (index: number): string | null => {
-        if (storageAvailable) {
-            try {
-                return baseStorage.key(index);
-            } catch {
-                disableStorage();
+    const visibleKeys = (): string[] => {
+        const keys = new Set<string>();
+        try {
+            for (let index = 0; index < baseStorage.length; index += 1) {
+                const key = baseStorage.key(index);
+                if (key && !deletedKeys.has(key) && !fallbackKeys.has(key)) keys.add(key);
             }
+        } catch {
+            // Ephemeral keys remain available when durable enumeration fails.
         }
-        return fallback.key(index);
+        for (const key of fallbackKeys) keys.add(key);
+        return [...keys];
     };
 
     return {
@@ -300,20 +319,18 @@ const createSafeStorage = (): Storage => {
         setItem: safeSet,
         removeItem: safeRemove,
         clear: safeClear,
-        key: safeKey,
+        key: (index) => visibleKeys()[index] ?? null,
         get length() {
-            if (storageAvailable) {
-                try {
-                    return baseStorage.length + fallback.length;
-                } catch {
-                    disableStorage();
-                }
-            }
-            return fallback.length;
+            return visibleKeys().length;
         },
     } as Storage;
 };
 
+const createSafeStorage = (): Storage => {
+    const baseStorage = getWindowStorage('localStorage');
+    return baseStorage ? createSafeStorageAdapter(baseStorage) : createInMemoryStorage();
+};
+
 export const getSafeStorage = (): Storage => {
     if (!safeStorageInstance) {
         safeStorageInstance = createSafeStorage();
@@ -330,97 +347,7 @@ export const getDeferredSafeStorage = (): Storage => {
 
 const createSafeSessionStorage = (): Storage => {
     const baseStorage = getWindowStorage('sessionStorage');
-
-    if (!baseStorage) {
-        return createInMemoryStorage();
-    }
-
-    const fallback = createInMemoryStorage();
-    let storageAvailable = true;
-
-    const disableStorage = () => {
-        storageAvailable = false;
-    };
-
-    const safeGet = (key: string): string | null => {
-        if (storageAvailable) {
-            try {
-                const value = baseStorage.getItem(key);
-                if (value !== null) {
-                    return value;
-                }
-            } catch {
-                disableStorage();
-            }
-        }
-        return fallback.getItem(key);
-    };
-
-    const safeSet = (key: string, value: string) => {
-        if (storageAvailable) {
-            try {
-                baseStorage.setItem(key, value);
-                fallback.removeItem(key);
-                return;
-            } catch {
-                disableStorage();
-                // Prevent stale previous value from surviving when writes fail (e.g. quota).
-                try {
-                    baseStorage.removeItem(key);
-                } catch {
-                    // noop
-                }
-            }
-        }
-        fallback.setItem(key, value);
-    };
-
-    const safeRemove = (key: string) => {
-        try {
-            baseStorage.removeItem(key);
-        } catch {
-            disableStorage();
-        }
-        fallback.removeItem(key);
-    };
-
-    const safeClear = () => {
-        try {
-            baseStorage.clear();
-        } catch {
-            disableStorage();
-        }
-        fallback.clear();
-    };
-
-    const safeKey = (index: number): string | null => {
-        if (storageAvailable) {
-            try {
-                return baseStorage.key(index);
-            } catch {
-                disableStorage();
-            }
-        }
-        return fallback.key(index);
-    };
-
-    return {
-        getItem: safeGet,
-        setItem: safeSet,
-        removeItem: safeRemove,
-        clear: safeClear,
-        key: safeKey,
-        get length() {
-            if (storageAvailable) {
-                try {
-                    return baseStorage.length + fallback.length;
-                } catch {
-                    disableStorage();
-                }
-            }
-            return fallback.length;
-        },
-    } as Storage;
+    return baseStorage ? createSafeStorageAdapter(baseStorage) : createInMemoryStorage();
 };
 
 export const getSafeSessionStorage = (): Storage => {
diff --git a/packages/ui/src/stores/utils/streamDebug.ts b/packages/ui/src/stores/utils/streamDebug.ts
index aa5f38a2..03e1f340 100644
--- a/packages/ui/src/stores/utils/streamDebug.ts
+++ b/packages/ui/src/stores/utils/streamDebug.ts
@@ -42,6 +42,11 @@ export type StreamPerfSnapshot = {
 declare global {
     interface Window {
         __openchamberStreamPerfState?: StreamPerfState;
+        __openchamberStreamPerformance?: {
+            setEnabled: (enabled: boolean) => void;
+            reset: () => void;
+            getSnapshot: () => StreamPerfSnapshot;
+        };
         __openchamberVsCodeStreamPerfState?: {
             counters: Map<string, PerfCounter>;
             lastReportAt?: number;
@@ -52,7 +57,7 @@ declare global {
     }
 }
 
-const streamPerfEnabled = (): boolean => {
+const readInitialStreamPerfEnabled = (): boolean => {
     if (typeof window === 'undefined') return false;
     try {
         return window.localStorage.getItem(STREAM_PERF_STORAGE_KEY) === '1';
@@ -61,6 +66,8 @@ const streamPerfEnabled = (): boolean => {
     }
 };
 
+let streamPerfEnabled = readInitialStreamPerfEnabled();
+
 const nowMs = (): number => {
     if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
         return performance.now();
@@ -69,7 +76,7 @@ const nowMs = (): number => {
 };
 
 const ensureStreamPerfState = (): StreamPerfState | null => {
-    if (!streamPerfEnabled() || typeof window === 'undefined') {
+    if (!streamPerfEnabled || typeof window === 'undefined') {
         return null;
     }
 
@@ -114,6 +121,7 @@ const updatePerfCounter = (metric: string, amount: number): void => {
 };
 
 export const setStreamPerfEnabled = (enabled: boolean): void => {
+    streamPerfEnabled = enabled;
     if (typeof window === 'undefined') {
         return;
     }
@@ -142,7 +150,7 @@ export const resetStreamPerf = (): void => {
         return;
     }
 
-    if (streamPerfEnabled()) {
+    if (streamPerfEnabled) {
         window.__openchamberStreamPerfState = {
             counters: new Map<string, PerfCounter>(),
             startedAt: Date.now(),
@@ -172,7 +180,7 @@ export const getStreamPerfSnapshot = (): StreamPerfSnapshot => {
     }
 
     const state = window.__openchamberStreamPerfState;
-    if (!streamPerfEnabled() || !state) {
+    if (!streamPerfEnabled || !state) {
         return {
             enabled: false,
             startedAt: null,
@@ -203,7 +211,7 @@ export const getVsCodeStreamPerfSnapshot = (): StreamPerfSnapshot => {
     }
 
     const state = window.__openchamberVsCodeStreamPerfState;
-    if (!streamPerfEnabled() || !state) {
+    if (!streamPerfEnabled || !state) {
         return {
             enabled: false,
             startedAt: null,
@@ -232,8 +240,15 @@ export const streamPerfObserve = (metric: string, value: number): void => {
     updatePerfCounter(metric, value);
 };
 
+export const streamPerfMark = (metric: string): void => {
+    if (!streamPerfEnabled || typeof performance === 'undefined' || typeof performance.mark !== 'function') {
+        return;
+    }
+    performance.mark(`openchamber.${metric}`);
+};
+
 export const streamPerfMeasure = <T>(metric: string, fn: () => T): T => {
-    if (!streamPerfEnabled()) {
+    if (!streamPerfEnabled) {
         return fn();
     }
 
@@ -244,3 +259,11 @@ export const streamPerfMeasure = <T>(metric: string, fn: () => T): T => {
         updatePerfCounter(metric, nowMs() - start);
     }
 };
+
+if (typeof window !== 'undefined') {
+    window.__openchamberStreamPerformance = {
+        setEnabled: setStreamPerfEnabled,
+        reset: resetStreamPerf,
+        getSnapshot: getStreamPerfSnapshot,
+    };
+}
diff --git a/packages/ui/src/sync/DOCUMENTATION.md b/packages/ui/src/sync/DOCUMENTATION.md
index 41109fc5..c97bca34 100644
--- a/packages/ui/src/sync/DOCUMENTATION.md
+++ b/packages/ui/src/sync/DOCUMENTATION.md
@@ -35,13 +35,15 @@ So:
 
 - Use the **directory sync stores** for per-directory live session/message state
 - Use the **global sessions store** for cold/global session coverage (especially archived pages and unopened directories)
-- Use **aggregated child-store snapshots** for live session/status truth across already initialized directories
+- Use **aggregated child-store sessions and the global live status index** for live truth across initialized directories
 
 ## Ownership map
 
 | Layer / Store | Owns | Scope |
 |---|---|---|
-| child directory stores in `sync-context.tsx` | `session`, `message`, `part`, `permission`, `question`, etc. | One directory |
+| `ChildStoreManager` and child directory stores | Priority-scheduled directory bootstrap plus `session`, `message`, `part`, `permission`, `question`, etc. | One runtime and one store per directory |
+| `SessionMessageLoader` | Initial message loading, pagination, prefetch, retries, load state, and optimistic reconciliation | One runtime, directory, and session ID |
+| `global-session-status.ts` | Incremental non-idle session status index reconciled from events and authoritative directory snapshots | All known directories in the active runtime |
 | `session-ui-store.ts` | Session selection, draft lifecycle, abort prompts, worktree metadata, SDK-facing action entrypoints | App UI state |
 | `useGlobalSessionsStore.ts` | Global active sessions, global archived sessions, `sessionsByDirectory` | All opened project/worktree session lists |
 | `viewport-store.ts` | Scroll anchors, session memory, loading indicators | App UI state |
@@ -51,6 +53,27 @@ So:
 
 ## Session list rules
 
+### Directory bootstrap scheduling
+
+`ChildStoreManager` is the single owner of directory bootstrap scheduling. Consumers publish demand; they must not start bootstrap from row mount effects.
+
+- The scheduler runs at most two directory bootstraps concurrently.
+- Selected session/current directory demand outranks active-project, expanded, visible, and background demand.
+- Demand is deduplicated by normalized directory and can be promoted while queued.
+- The complete known project/worktree set is always published. Collapsed and off-screen directories remain background demand, so they refresh eventually rather than waiting for expansion.
+- A bootstrap holds its scheduler slot through critical state and the authoritative directory session-list fetch. Deferrable command/MCP/LSP/VCS/question/permission enrichment starts afterward without extending slot ownership or competing with the initial session-list request.
+- A mounted directory-store consumer pins that store for its lifetime. Eviction may dispose only unmounted directories, so optimistic actions and realtime events cannot move to a replacement store while visible React consumers remain subscribed to an older identity.
+- Reconfiguration and runtime switching invalidate stale generations. A stale completion must not publish state into the new runtime.
+- Failure is recorded as `failed`; it is not converted into a successful empty snapshot. Forced demand can retry failed or completed work.
+
+Bootstrap remains stale-while-revalidate: a directory store may paint persisted sessions immediately, but only a successful authoritative fetch may replace that cached list.
+
+Directory session lists record whether their current snapshot is empty, persisted, live-event-derived, or authoritative. Bootstrap captures a mutation revision before starting its requests. Its completion replaces persisted data, including with a successful empty response, then overlays only session events and direct move/archive/delete mutations newer than that revision. It must not preserve the entire cached list as a race fallback because that would retain stale persisted sessions.
+
+The roots request is authoritative for root completeness. The broader child-session request has independent completeness: a successful empty response clears stale children, while a failed request preserves known children and their required ancestors without turning the failure into an empty snapshot.
+
+The persisted session snapshot keeps up to 50 sessions selected by `time.updated`/`time.created`, not ID ordering. Non-empty updates coalesce to the latest runtime-directory snapshot and flush on lifecycle suspension; runtime switches reject stale pending writes. Successful empty results persist an empty v2 tombstone synchronously so legacy data cannot reappear on restart. If localStorage quota prevents the full snapshot, persistence retries with progressively smaller recent snapshots and removes stale current/legacy values rather than leaving an old list indefinitely.
+
 ### Directory-scoped session list
 
 Use the directory-scoped sync store when the UI needs the live session list for the **current directory**.
@@ -65,6 +88,14 @@ Directory bootstrap must publish a closed session hierarchy: when a child is
 returned before the roots query catches up during cold startup, retain or
 recover its referenced parent instead of exposing an orphan-only snapshot.
 
+Session message loads use runtime, normalized directory, session ID, SDK epoch, and loader generation as commit authority. Eviction, archive, delete, move, directory disposal, and runtime switching invalidate the applicable loader generation before stale in-flight work can publish. A move invalidates both source and destination loader targets.
+
+An authoritative `session.deleted` event also clears persisted UI state before routing metadata can be removed. Confirmed local deletion and accepted `404` deletion do the same directly instead of depending on the event echo. Cleanup is identity-owned by runtime, normalized directory, and session ID: queued messages, persisted todos, composer drafts, inline-comment drafts, and pins clear only that tuple, while the active runtime's folder store removes the session from every active or archived folder scope. Stale-runtime events and unresolved/global directory identities do not mutate persisted state.
+
+Persisted sidebar state is never reconciled destructively from the first successful startup list. That list establishes an authoritative active+archived baseline. Only a session present in that baseline and omitted from a later complete snapshot is treated as a missed external deletion. Archive and directory moves retain the session ID across snapshots and are not deletion cleanup. This favors harmless hidden stale metadata over irreversible user-state loss when startup data is incomplete.
+
+Session materialization recency is keyed by runtime and directory. Foreground loads and successful prefetches participate in the same bounded per-directory session LRU. Prefetch pagination metadata has a global count ceiling and is removed with session eviction, directory disposal, loader runtime reconfiguration, and loader disposal.
+
 ### Global session list
 
 Use `useGlobalSessionsStore` when the UI needs a **shared global session cache**.
@@ -84,18 +115,19 @@ Current consumers:
 - `Header.tsx`
 - agent/session activity surfaces using `useGlobalSessionStatus()` / `useAllSessionStatuses()`
 
-Cross-directory selectors subscribe to the narrow child-store field they aggregate. Session aggregation listens to `state.session`; per-session status listens only to that session's `state.session_status` entry. Unrelated streaming events such as `message.part.delta` must not trigger global session/status scans.
+Cross-directory selectors subscribe to the narrow child-store field they aggregate. Session aggregation listens to `state.session`. Live busy/retry state is also maintained in `global-session-status.ts`, where each row subscribes to one session ID instead of scanning every child store. Events update the index incrementally; authoritative per-directory status snapshots seed it, clear sessions omitted as idle, and reconcile missed events. Unrelated streaming events such as `message.part.delta` must not trigger global session/status scans.
 
 Imperative cross-directory session lookups use the cached ID index from `getAllSyncSessionMap()`. The index is rebuilt only when a child store's `state.session` reference changes; permission lineage checks must reuse it instead of rebuilding a full session map per call.
 
-VS Code does not run the server permission-auto-accept runtime. The extension host persists and broadcasts authoritative policy, while its foreground UI runtime resolves missing child-session lineage through the OpenCode API before deciding whether to suppress and answer a `permission.asked` event. Enabling the policy and reconnect/bootstrap both reconcile pending requests in the session directory, including requests inherited by child sessions. Unknown lineage and exhausted reply retries fail closed and leave the request available for manual action. With every OpenChamber webview closed or suspended no responder runs; this is an intentional VS Code limitation. Other runtimes remain fully server-owned.
+VS Code does not run the server permission-auto-accept runtime. The extension host persists and broadcasts authoritative policy, while its foreground UI runtime resolves missing child-session lineage through the OpenCode API before deciding whether to suppress and answer a `permission.asked` event. Enabling the policy and reconnect/bootstrap both reconcile pending requests in the session directory, including requests inherited by child sessions. Unknown lineage and exhausted reply retries fail closed and leave the request available for manual action. A later `permission.replied` event invalidates any older deferred ask so the async policy check cannot resurrect a resolved request. With every OpenChamber webview closed or suspended no responder runs; this is an intentional VS Code limitation. Other runtimes remain fully server-owned.
 
 ### Mutation responsibility
 
-`useGlobalSessionsStore` is not maintained by SSE directly. It is kept correct by:
+`useGlobalSessionsStore` is kept correct by:
 
 1. shared global fetch/reconciliation via `loadSessions()` / `refreshGlobalSessions()`
-2. direct mutation from session actions after successful SDK calls:
+2. session create/update/delete events; recency-only updates for existing sessions are retained latest-per-session and committed once on `session.idle`/`session.error`, while structural updates and create/delete remain immediate and runtime switching discards pending updates
+3. direct mutation from session actions after successful SDK calls:
    - create
    - title update
    - share
@@ -107,7 +139,46 @@ VS Code does not run the server permission-auto-accept runtime. The extension ho
 
 This keeps cold/global lists responsive without requiring a refetch after every change.
 
-Live activity/status indicators must not depend on this cache. They must derive from aggregated child-store state.
+Live activity/status indicators must not depend on this cache. They must use the event/snapshot-reconciled global live status index.
+
+## Session message loading
+
+`SessionMessageLoader` is the shared authority for session message requests. Navigation, reactive chat loading, sidebar prefetch, pagination, reconnect/recovery, and optimistic reconciliation must delegate to it rather than issuing parallel initial requests.
+
+Rules:
+
+1. Request identity is runtime key + normalized directory + session ID. Session IDs alone are not globally unique across runtimes or directories.
+2. One in-flight request is shared by all callers. Foreground demand may promote the visible load kind of an existing prefetch without starting another request.
+3. Load state is explicit per session: `idle`, `loading`, `ready`, or `error`. Fetch failure preserves prior materialized records and exposes retry; it never becomes authoritative empty success.
+4. Async commits are generation-checked. Runtime switches, forced refreshes, eviction, and disposal must reject stale completion.
+5. Prefetch coverage and persisted directory data are runtime-scoped. Legacy persisted directory entries may seed startup continuity, but they are not live truth.
+6. Message and part materialization preserves references for unchanged records and maintains direct message-to-parts lookup. Consumers subscribe to the selected session's records rather than broad message/part containers.
+
+Initial loads use smaller pages on constrained VS Code/mobile surfaces. Older pages are fetched through the same loader and merged with optimistic records before publication.
+
+## Loading diagnostics
+
+Session loading instrumentation is disabled by default. Set `localStorage.openchamber_session_load_perf` to `"1"`, reproduce the interaction, then inspect `window.__openchamberSessionLoadPerformance.events`.
+
+The bounded event buffer records bootstrap, message, and global-list operations with queue/duration, caller, outcome, retry count, and record count where applicable. Instrumentation is diagnostic only; unit/type/lint checks do not replace production runtime profiling at representative project/session scale.
+
+High-frequency sync diagnostics are separately disabled by default. Set `localStorage.openchamber_sync_perf` to `"1"` before reload to enable fixed numeric counters for pipeline traffic, reducer publications, streaming reconciliations, entries/messages visited, targeted heartbeat work, and persistence serialization/write volume. The hot path performs only a null check while disabled; counters never retain IDs, payloads, or user content.
+
+Browser profiling also enables `localStorage.openchamber_stream_perf` to capture bounded aggregate timings and render counts for chat projections, message components, and major sidebar boundaries. These metrics contain no session IDs or user content and are reset immediately before each recording.
+
+The profiler also emits a user-timing mark when pending global-session recency is committed at a lifecycle edge. `summary.json.longTaskAttribution` correlates that mark with enclosing long tasks without recording session data.
+
+Streaming assistant and reasoning text is throttled once before reaching the markdown renderer. The renderer incrementally reconciles changed markdown blocks but does not add a second character-pacing timer, which would multiply parse/morph work while catching up on large streamed chunks.
+
+The event pipeline delivers each ordered per-directory flush as one reducer batch. Events retain their individual global indexes, notifications, cleanup, routing, materialization, and debug side effects, while their directory mutations accumulate in order and publish one store transaction per touched directory. Each top-level state slice is cloned lazily at most once in that batch; no-op events do not change references.
+
+Streaming lifecycle derivation has two paths. Directory attach, switch, bootstrap, and reconnect may perform a full reconciliation. Normal store publications reconcile only sessions whose `session_status` or `message` bucket changed; part-only events update the affected streaming message heartbeat directly and must not rescan all busy sessions.
+
+Incomplete-session materialization is deduplicated by runtime, directory, and session for the full cooldown window, including after a fast success or failure. Deferred recovery is dropped if its captured runtime is no longer active. If recovery requests a tail refresh while an older load is in flight, one refresh runs after that load instead of losing the newer authority demand. Completion retains the cooldown marker until expiry, and an older completion cannot clear a newer request marker. Recovery starts after the current ordered event batch and rechecks whether local state already contains the requested entity before starting HTTP. An explicit empty part bucket is authoritative fetched-empty state, not a missing snapshot. This prevents repeated orphan/missing-part events from creating message-tail and status request storms while preserving later recovery.
+
+Directory stores also own session-keyed sidecar notification channels for permissions and message materialization. High-frequency realtime part events annotate the exact session/message before committing, so visible records, user history, renderability, and sidebar permission rows are not notified by unrelated sessions. Structural message replacements notify only changed subscribed session buckets; unannotated bulk part replacement conservatively resets active message subscribers so bootstrap, pagination, rollback, and legacy writers cannot leave stale projections.
+
+Message sidecar consumers also filter targeted updates by purpose before notifying React. Suspended live-tail text/reasoning changes do not rebuild visible message records, but structural Task session identity changes bypass suspension so a parent can link a newly created subagent immediately. Assistant-only part changes do not rebuild user input history, and targeted updates that preserve authoritative part buckets do not recheck a session that is already renderable. Message replacements, removed final part buckets, and conservative resets always notify.
 
 ## Session action rules
 
@@ -124,8 +195,8 @@ Examples of global-store updates performed in `session-actions.ts`:
 - `createSession()` -> `upsertSession(session)`
 - `updateSessionTitle()` -> `upsertSession(result.data)`
 - `shareSession()` / `unshareSession()` -> `upsertSession(result.data)`
-- `archiveSession()` -> `archiveSessions([id], archivedAt)`
-- `deleteSession()` -> `removeSessions([id])`
+- `archiveSession()` -> waits for server confirmation, then upserts the archived session
+- `deleteSession()` -> waits for server confirmation or `404`, then removes the session and its persisted state
 - `moveSessionToDirectory()` -> move the session between directory stores and update the global directory index
 
 ## The golden rule
@@ -218,9 +289,10 @@ The optimization multiplies with targeted event cloning: fewer new references pe
 
 1. **Never add to `session-ui-store`** unless it's session selection, draft lifecycle, or abort state
 2. **Group by change frequency** — state that changes during streaming (viewport, memory) must not live with state that changes on user action (selections, input)
-3. **Group by subscriber set** — if only 2 components read a value, it should be in a store that only those 2 components subscribe to
-4. **Prefer a new store over growing an existing one** if the new state has different subscribers or change frequency
-5. **Cross-store reads use `.getState()`** — actions in one store that need to read another store call `useOtherStore.getState()` (imperative, no subscription)
+3. **Skip canonical no-ops** — selecting a session must not republish an already-reset draft; session ID and directory remain the authoritative navigation publication.
+4. **Group by subscriber set** — if only 2 components read a value, it should be in a store that only those 2 components subscribe to
+5. **Prefer a new store over growing an existing one** if the new state has different subscribers or change frequency
+6. **Cross-store reads use `.getState()`** — actions in one store that need to read another store call `useOtherStore.getState()` (imperative, no subscription)
 
 ### Anti-patterns
 
diff --git a/packages/ui/src/sync/__tests__/materialization.test.ts b/packages/ui/src/sync/__tests__/materialization.test.ts
index 6ce540dc..421a6594 100644
--- a/packages/ui/src/sync/__tests__/materialization.test.ts
+++ b/packages/ui/src/sync/__tests__/materialization.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, test } from "bun:test"
 import type { Message, Part } from "@opencode-ai/sdk/v2/client"
-import { getSessionMaterializationStatus, materializeSessionSnapshots } from "../materialization"
+import {
+  getSessionMaterializationRequestKey,
+  getSessionMaterializationStatus,
+  isSessionMaterializationStillNeeded,
+  materializeSessionSnapshots,
+} from "../materialization"
 
 function message(id: string, sessionID = "ses_1"): Message {
   return { id, sessionID, role: "assistant", time: { created: 1 } } as Message
@@ -14,6 +19,13 @@ function part(id: string, messageID: string, type = "text", text = id): Part {
   return { id, messageID, sessionID: "ses_1", type, text } as Part
 }
 
+describe("getSessionMaterializationRequestKey", () => {
+  test("isolates the same directory and session identity across runtimes", () => {
+    expect(getSessionMaterializationRequestKey("runtime-a", "/repo", "ses_1"))
+      .not.toBe(getSessionMaterializationRequestKey("runtime-b", "/repo", "ses_1"))
+  })
+})
+
 describe("materializeSessionSnapshots", () => {
   test("marks an empty successful page as materialized", () => {
     const result = materializeSessionSnapshots(
@@ -182,3 +194,47 @@ describe("getSessionMaterializationStatus", () => {
     })
   })
 })
+
+describe("isSessionMaterializationStillNeeded", () => {
+  test("skips empty-assistant recovery after a part bucket arrives", () => {
+    const state = { message: { ses_1: [message("msg_1")] }, part: { msg_1: [part("prt_1", "msg_1")] } }
+
+    expect(isSessionMaterializationStillNeeded(state, "ses_1", {
+      reason: "empty-assistant-message",
+      messageID: "msg_1",
+    })).toBe(false)
+  })
+
+  test("treats an explicit empty part bucket as authoritative", () => {
+    const state = { message: { ses_1: [message("msg_1")] }, part: { msg_1: [] } }
+
+    expect(isSessionMaterializationStillNeeded(state, "ses_1", {
+      reason: "empty-assistant-message",
+      messageID: "msg_1",
+    })).toBe(false)
+  })
+
+  test("skips missing-message and missing-part recovery after ordered events repair state", () => {
+    const state = { message: { ses_1: [message("msg_1")] }, part: { msg_1: [part("prt_1", "msg_1")] } }
+
+    expect(isSessionMaterializationStillNeeded(state, "ses_1", {
+      reason: "missing-owning-message",
+      messageID: "msg_1",
+    })).toBe(false)
+    expect(isSessionMaterializationStillNeeded(state, "ses_1", {
+      reason: "missing-delta-part",
+      messageID: "msg_1",
+      partID: "prt_1",
+    })).toBe(false)
+  })
+
+  test("keeps recovery active while the requested entity is still missing", () => {
+    const state = { message: { ses_1: [message("msg_1")] }, part: {} }
+
+    expect(isSessionMaterializationStillNeeded(state, "ses_1", {
+      reason: "orphan-delta",
+      messageID: "msg_1",
+      partID: "prt_1",
+    })).toBe(true)
+  })
+})
diff --git a/packages/ui/src/sync/__tests__/session-prefetch-cache.test.ts b/packages/ui/src/sync/__tests__/session-prefetch-cache.test.ts
deleted file mode 100644
index 58201ca5..00000000
--- a/packages/ui/src/sync/__tests__/session-prefetch-cache.test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import { shouldSkipSessionPrefetch } from "../session-prefetch-cache"
-
-describe("shouldSkipSessionPrefetch", () => {
-  test("does not skip when only metadata exists without cached messages", () => {
-    expect(shouldSkipSessionPrefetch({
-      hasMessages: false,
-      info: { limit: 200, complete: true, at: 1_000 },
-      pageSize: 200,
-      now: 1_001,
-    })).toBe(false)
-  })
-
-  test("does not skip a larger fetch when only a smaller partial prefetch is cached", () => {
-    expect(shouldSkipSessionPrefetch({
-      hasMessages: true,
-      info: { limit: 50, complete: false, at: 1_000 },
-      pageSize: 200,
-      now: 1_001,
-    })).toBe(false)
-  })
-
-  test("still skips a recent partial prefetch when cached coverage matches the request", () => {
-    expect(shouldSkipSessionPrefetch({
-      hasMessages: true,
-      info: { limit: 200, complete: false, at: 1_000 },
-      pageSize: 200,
-      now: 1_001,
-    })).toBe(true)
-  })
-})
diff --git a/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts b/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
index bdae78f6..2a05aeb9 100644
--- a/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
+++ b/packages/ui/src/sync/__tests__/sync-context-session-events.test.ts
@@ -3,8 +3,14 @@ import type { Event, Session } from "@opencode-ai/sdk/v2/client"
 
 let currentSessions: Session[] = []
 const upsertedSessions: Session[] = []
+const removedSessionIds: string[] = []
+let runtimeKey = "runtime-a"
+let runtimeWillChange: (() => void) | null = null
 
 mock.module("@/stores/useGlobalSessionsStore", () => ({
+  isGlobalSessionRecencyOnlyUpdate: (existing: Session, incoming: Session) => (
+    existing.title === incoming.title && existing.time?.updated !== incoming.time?.updated
+  ),
   useGlobalSessionsStore: {
     getState: () => ({
       activeSessions: currentSessions,
@@ -12,9 +18,22 @@ mock.module("@/stores/useGlobalSessionsStore", () => ({
       upsertSession: (session: Session) => {
         upsertedSessions.push(session)
       },
+      upsertSessions: (sessions: Session[]) => {
+        upsertedSessions.push(...sessions)
+      },
+      removeSessions: (ids: string[]) => {
+        removedSessionIds.push(...ids)
+      },
     }),
   },
 }))
+mock.module("@/lib/runtime-switch", () => ({
+  getRuntimeKey: () => runtimeKey,
+  subscribeRuntimeEndpointWillChange: (callback: () => void) => {
+    runtimeWillChange = callback
+    return () => undefined
+  },
+}))
 import { applySessionEventToGlobalSessions } from "../session-event-router"
 
 const buildSession = (title: string, time: Session["time"]): Session => ({
@@ -30,10 +49,23 @@ const buildEvent = (session: Session): Event => ({
   },
 } as Event)
 
+const buildDeleteEvent = (sessionId: string): Event => ({
+  type: "session.deleted",
+  properties: { sessionID: sessionId },
+} as Event)
+
+const buildLifecycleEvent = (type: "session.idle" | "session.error", sessionId: string): Event => ({
+  type,
+  properties: { sessionID: sessionId },
+} as Event)
+
 describe("applySessionEventToGlobalSessions", () => {
   beforeEach(() => {
+    runtimeWillChange?.()
+    runtimeKey = "runtime-a"
     currentSessions = []
     upsertedSessions.length = 0
+    removedSessionIds.length = 0
   })
 
   test("skips stale global session.updated echoes after a newer rename", () => {
@@ -43,4 +75,45 @@ describe("applySessionEventToGlobalSessions", () => {
 
     expect(upsertedSessions).toEqual([])
   })
+
+  test("commits only the latest recency update when a session becomes idle", () => {
+    currentSessions = [buildSession("Initial", { created: 1, updated: 10 })]
+
+    applySessionEventToGlobalSessions(buildEvent(buildSession("Initial", { created: 1, updated: 20 })))
+    applySessionEventToGlobalSessions(buildEvent(buildSession("Initial", { created: 1, updated: 30 })))
+
+    expect(upsertedSessions).toEqual([])
+    applySessionEventToGlobalSessions(buildLifecycleEvent("session.idle", "ses_1"))
+    expect(upsertedSessions.map((session) => session.time.updated)).toEqual([30])
+  })
+
+  test("applies substantive session updates immediately", () => {
+    currentSessions = [buildSession("Initial", { created: 1, updated: 10 })]
+
+    applySessionEventToGlobalSessions(buildEvent(buildSession("Renamed", { created: 1, updated: 20 })))
+
+    expect(upsertedSessions.map((session) => session.title)).toEqual(["Renamed"])
+  })
+
+  test("cancels a pending global update when the session is deleted", () => {
+    currentSessions = [buildSession("Initial", { created: 1, updated: 10 })]
+
+    applySessionEventToGlobalSessions(buildEvent(buildSession("Initial", { created: 1, updated: 20 })))
+    applySessionEventToGlobalSessions(buildDeleteEvent("ses_1"))
+    applySessionEventToGlobalSessions(buildLifecycleEvent("session.idle", "ses_1"))
+
+    expect(upsertedSessions).toEqual([])
+    expect(removedSessionIds).toEqual(["ses_1"])
+  })
+
+  test("discards pending global updates when the runtime changes", () => {
+    currentSessions = [buildSession("Initial", { created: 1, updated: 10 })]
+    applySessionEventToGlobalSessions(buildEvent(buildSession("Initial", { created: 1, updated: 20 })))
+
+    runtimeKey = "runtime-b"
+    runtimeWillChange?.()
+    applySessionEventToGlobalSessions(buildLifecycleEvent("session.idle", "ses_1"))
+
+    expect(upsertedSessions).toEqual([])
+  })
 })
diff --git a/packages/ui/src/sync/bootstrap.test.ts b/packages/ui/src/sync/bootstrap.test.ts
new file mode 100644
index 00000000..eaa8661e
--- /dev/null
+++ b/packages/ui/src/sync/bootstrap.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test"
+import type { OpencodeClient, Project } from "@opencode-ai/sdk/v2/client"
+import { bootstrapDirectory } from "./bootstrap"
+import { INITIAL_STATE, type State } from "./types"
+
+const createSdk = (options?: { commandList?: () => Promise<{ data: unknown[] }> }) => ({
+  project: { current: async () => ({ data: { id: "project-a" } }) },
+  config: { get: async () => ({ data: {} }) },
+  path: { get: async () => ({ data: { state: "", config: "", worktree: "/repo", directory: "/repo", home: "/home" } }) },
+  session: { status: async () => ({ data: {} }) },
+  command: { list: options?.commandList ?? (async () => ({ data: [] })) },
+  mcp: { status: async () => ({ data: {} }) },
+  lsp: { status: async () => ({ data: [] }) },
+  vcs: { get: async () => ({ data: { branch: "main" } }) },
+  question: { list: async () => ({ data: [] }) },
+  permission: { list: async () => ({ data: [] }) },
+}) as unknown as OpencodeClient
+
+const createState = (): State => ({
+  ...INITIAL_STATE,
+  message: {},
+  part: {},
+})
+
+const project = { id: "project-a", worktree: "/repo" } as Project
+
+describe("bootstrapDirectory", () => {
+  test("prioritizes session loading without waiting for deferred fields", async () => {
+    let state = createState()
+    let deferredStarted = false
+    let resolveDeferred!: () => void
+    const deferred = new Promise<{ data: unknown[] }>((resolve) => {
+      resolveDeferred = () => resolve({ data: [] })
+    })
+    let resolveSessions!: () => void
+    const sessions = new Promise<void>((resolve) => {
+      resolveSessions = resolve
+    })
+    let settled = false
+    const sdk = createSdk({
+      commandList: async () => {
+        deferredStarted = true
+        return deferred
+      },
+    })
+    const bootstrapping = bootstrapDirectory({
+      directory: "/repo",
+      sdk,
+      getState: () => state,
+      set: (patch) => {
+        state = { ...state, ...patch }
+      },
+      global: { config: {}, projects: [project] },
+      loadSessions: () => sessions,
+    }).then((result) => {
+      settled = true
+      return result
+    })
+
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(settled).toBe(false)
+    expect(deferredStarted).toBe(false)
+    resolveSessions()
+
+    expect(await bootstrapping).toBe("complete")
+    expect(state.status).toBe("complete")
+    expect(deferredStarted).toBe(false)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(deferredStarted).toBe(true)
+    resolveDeferred()
+  })
+
+  test("reports session-list failure without clearing existing state", async () => {
+    let state = { ...createState(), session: [{ id: "cached" }] as State["session"] }
+    const result = await bootstrapDirectory({
+      directory: "/repo",
+      sdk: createSdk(),
+      getState: () => state,
+      set: (patch) => {
+        state = { ...state, ...patch }
+      },
+      global: { config: {}, projects: [project] },
+      loadSessions: async () => {
+        throw new Error("unavailable")
+      },
+    })
+
+    expect(result).toBe("failed")
+    expect(state.session.map((session) => session.id)).toEqual(["cached"])
+  })
+
+  test("rejects stale work before committing", async () => {
+    const state = createState()
+    let commits = 0
+    const result = await bootstrapDirectory({
+      directory: "/repo",
+      sdk: createSdk(),
+      getState: () => state,
+      set: () => {
+        commits += 1
+      },
+      isStale: () => true,
+      global: { config: {}, projects: [project] },
+      loadSessions: async () => undefined,
+    })
+
+    expect(result).toBe("stale")
+    expect(commits).toBe(0)
+  })
+})
diff --git a/packages/ui/src/sync/bootstrap.ts b/packages/ui/src/sync/bootstrap.ts
index bfd1a9d7..058a55e0 100644
--- a/packages/ui/src/sync/bootstrap.ts
+++ b/packages/ui/src/sync/bootstrap.ts
@@ -122,25 +122,31 @@ export async function bootstrapDirectory(input: {
   sdk: OpencodeClient
   getState: () => State
   set: (patch: Partial<State>) => void
+  isStale?: () => boolean
   global: {
     config: Record<string, unknown>
     projects: Project[]
   }
   loadSessions: (directory: string) => Promise<void> | void
-}) {
+}): Promise<"complete" | "failed" | "stale"> {
   const { directory, sdk, getState, set, global: g } = input
+  const commit = (patch: Partial<State>): boolean => {
+    if (input.isStale?.()) return false
+    set(patch)
+    return true
+  }
   const state = getState()
   const loading = state.status !== "complete"
 
   // Seed from global state while we fetch directory-specific data
   const seededProject = projectID(directory, g.projects)
-  if (seededProject) set({ project: seededProject })
+  if (seededProject) commit({ project: seededProject })
   if (Object.keys(state.config ?? {}).length === 0 && Object.keys(g.config ?? {}).length > 0) {
     const seededConfig = g.config as State["config"]
-    set({ config: seededConfig })
-    emitSyncConfigChanged(directory, seededConfig)
+    if (commit({ config: seededConfig })) emitSyncConfigChanged(directory, seededConfig)
   }
-  if (loading) set({ status: "partial" })
+  if (loading) commit({ status: "partial" })
+  if (input.isStale?.()) return "stale"
 
   // ---------------------------------------------------------------------------
   // Phase 1: Critical path — block until these resolve so the UI can render.
@@ -149,23 +155,24 @@ export async function bootstrapDirectory(input: {
   const phase1Results = await Promise.allSettled([
     seededProject
       ? Promise.resolve()
-      : retry(() => sdk.project.current().then((x) => set({ project: unwrap(x, "project.current").id }))),
+      : retry(() => sdk.project.current().then((x) => commit({ project: unwrap(x, "project.current").id }))),
     retry(() => sdk.config.get().then((x) => {
       const config = unwrap(x, "config.get")
-      set({ config })
-      emitSyncConfigChanged(directory, config)
+      if (commit({ config })) emitSyncConfigChanged(directory, config)
     })),
     retry(() =>
       sdk.path.get().then((x) => {
         const data = unwrap(x, "path.get")
-        set({ path: data })
+        commit({ path: data })
         const next = projectID(data?.directory ?? directory, g.projects)
-        if (next) set({ project: next })
+        if (next) commit({ project: next })
       }),
     ),
-    retry(() => sdk.session.status().then((x) => set({ session_status: unwrap(x, "session.status") }))),
+    retry(() => sdk.session.status().then((x) => commit({ session_status: unwrap(x, "session.status") }))),
   ])
 
+  if (input.isStale?.()) return "stale"
+
   const phase1Errors = phase1Results
     .filter((r): r is PromiseRejectedResult => r.status === "rejected")
     .map((r) => r.reason)
@@ -184,27 +191,27 @@ export async function bootstrapDirectory(input: {
 
   if (phase1Errors.length === phase1Results.length || pathFailedWithoutProject) {
     console.error(`[bootstrap] directory bootstrap failed for ${directory}`, phase1Errors[0])
-    return
+    return "failed"
   }
 
   // Mark ready after critical data arrives so the UI can paint.
-  if (loading) set({ status: "complete" })
+  if (loading) commit({ status: "complete" })
 
   // ---------------------------------------------------------------------------
   // Phase 2: Deferrable — fetch after first paint without blocking.
   // These enrich the UI but aren't required for basic functionality.
   // ---------------------------------------------------------------------------
-  void Promise.allSettled([
-    retry(() => sdk.command.list().then((x) => set({ command: unwrap(x, "command.list") }))),
-    retry(() => sdk.mcp.status().then((x) => set({ mcp: unwrap(x, "mcp.status") }))),
-    retry(() => sdk.lsp.status().then((x) => set({ lsp: unwrap(x, "lsp.status") }))),
+  const runDeferredPhase = () => Promise.allSettled([
+    retry(() => sdk.command.list().then((x) => commit({ command: unwrap(x, "command.list") }))),
+    retry(() => sdk.mcp.status().then((x) => commit({ mcp: unwrap(x, "mcp.status") }))),
+    retry(() => sdk.lsp.status().then((x) => commit({ lsp: unwrap(x, "lsp.status") }))),
     retry(() =>
       sdk.vcs.get().then((x) => {
         const current = getState()
         if (x.error) {
           throw new Error(`vcs.get failed: ${String(x.error)}`)
         }
-        set({ vcs: x.data ?? current.vcs })
+        commit({ vcs: x.data ?? current.vcs })
       }),
     ),
     retry(async () => {
@@ -236,7 +243,7 @@ export async function bootstrapDirectory(input: {
         if (currentSignature !== beforeSignature) continue
         delete merged[sessionID]
       }
-      set({ question: merged })
+      commit({ question: merged })
     }),
     retry(async () => {
       const before = getState()
@@ -267,7 +274,7 @@ export async function bootstrapDirectory(input: {
         if (currentSignature !== beforeSignature) continue
         delete merged[sessionID]
       }
-      set({ permission: merged })
+      commit({ permission: merged })
     }),
   ]).then((results) => {
     const errors = results
@@ -279,9 +286,19 @@ export async function bootstrapDirectory(input: {
   })
 
   // ---------------------------------------------------------------------------
-  // Phase 3: Lazy — session list can be large; don't block on it.
+  // Phase 3: Authoritative session list. Keep this scheduler-owned so bounded
+  // bootstrap concurrency also bounds list pagination, but do not hold the slot
+  // for the deferrable enrichment phase above.
   // ---------------------------------------------------------------------------
-  void Promise.resolve(input.loadSessions(directory)).catch((err) => {
-    console.error(`[bootstrap] session load failed for ${directory}`, err)
-  })
+  const sessionsResult = await Promise.allSettled([Promise.resolve(input.loadSessions(directory))])
+  if (input.isStale?.()) return "stale"
+  const sessionLoad = sessionsResult[0]
+  setTimeout(() => {
+    if (!input.isStale?.()) void runDeferredPhase()
+  }, 0)
+  if (sessionLoad?.status === "rejected") {
+    console.error(`[bootstrap] session load failed for ${directory}`, sessionLoad.reason)
+    return "failed"
+  }
+  return "complete"
 }
diff --git a/packages/ui/src/sync/child-store.test.ts b/packages/ui/src/sync/child-store.test.ts
index ed3a5cb3..1ec3b0dc 100644
--- a/packages/ui/src/sync/child-store.test.ts
+++ b/packages/ui/src/sync/child-store.test.ts
@@ -1,6 +1,29 @@
 import { describe, expect, test } from 'bun:test';
 
-import { ChildStoreManager } from './child-store';
+import {
+  ChildStoreManager,
+  markDirectorySessionPartChanged,
+  subscribeDirectoryPermission,
+  subscribeDirectorySessionMessages,
+} from './child-store';
+import {
+  getSyncPerformanceDiagnostics,
+  setSyncPerformanceDiagnosticsEnabled,
+} from './performance-diagnostics';
+import { DIR_IDLE_TTL_MS } from './types';
+
+const deferred = () => {
+  let resolve!: () => void;
+  const promise = new Promise<void>((next) => {
+    resolve = next;
+  });
+  return { promise, resolve };
+};
+
+const settle = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
 
 describe('ChildStoreManager.subscribeAllSelected', () => {
   test('ignores unrelated child-store updates', () => {
@@ -34,4 +57,341 @@ describe('ChildStoreManager.subscribeAllSelected', () => {
     unsubscribe();
     manager.disposeAll();
   });
+
+});
+
+describe('ChildStoreManager directory lifecycle', () => {
+  test('keeps an idle directory alive until its final consumer releases it', () => {
+    const manager = new ChildStoreManager();
+    const now = 10_000;
+    const originalDateNow = Date.now;
+    let currentTime = now;
+    Date.now = () => currentTime;
+
+    try {
+      const child = manager.ensureChild('/workspace', { bootstrap: false });
+      manager.pin('/workspace/');
+      manager.pin('/workspace');
+      manager.unpin('/workspace');
+      currentTime = now + DIR_IDLE_TTL_MS + 1;
+
+      manager.runEviction();
+
+      expect(manager.pinned('/workspace')).toBe(true);
+      expect(manager.getChild('/workspace')).toBe(child);
+
+      manager.unpin('/workspace/');
+
+      expect(manager.pinned('/workspace')).toBe(false);
+      expect(manager.getChild('/workspace')).toBe(undefined);
+    } finally {
+      Date.now = originalDateNow;
+      manager.disposeAll();
+    }
+  });
+});
+
+describe('ChildStoreManager permission subscriptions', () => {
+  test('does not notify session permission listeners for unrelated high-frequency updates', () => {
+    const manager = new ChildStoreManager();
+    const child = manager.ensureChild('/workspace', { bootstrap: false });
+    let notifications = 0;
+    const unsubscribers = Array.from({ length: 50 }, (_, index) => (
+      subscribeDirectoryPermission(child, `session-${index}`, () => {
+        notifications += 1;
+      })
+    ));
+    setSyncPerformanceDiagnosticsEnabled(true);
+
+    for (let index = 0; index < 10_000; index += 1) {
+      child.setState({ part: { [`message-${index}`]: [] } });
+    }
+
+    expect(notifications).toBe(0);
+    expect(getSyncPerformanceDiagnostics()?.permissionChangeCallbacks).toBe(0);
+
+    child.setState({ permission: { 'session-17': [{ id: 'permission-1' }] as never[] } });
+
+    expect(notifications).toBe(1);
+    expect(getSyncPerformanceDiagnostics()?.permissionChangeCallbacks).toBe(1);
+    for (const unsubscribe of unsubscribers) unsubscribe();
+    setSyncPerformanceDiagnosticsEnabled(false);
+    manager.disposeAll();
+  });
+});
+
+describe('ChildStoreManager session message subscriptions', () => {
+  test('routes annotated part changes only to the owning session', () => {
+    const manager = new ChildStoreManager();
+    const child = manager.ensureChild('/workspace', { bootstrap: false });
+    const notifications = new Map<string, number>();
+    const unsubscribers = Array.from({ length: 50 }, (_, index) => {
+      const sessionID = `session-${index}`;
+      return subscribeDirectorySessionMessages(child, sessionID, () => {
+        notifications.set(sessionID, (notifications.get(sessionID) ?? 0) + 1);
+      });
+    });
+    setSyncPerformanceDiagnosticsEnabled(true);
+
+    for (let index = 0; index < 1_000; index += 1) {
+      const sessionID = `session-${index % 50}`;
+      const messageID = `message-${index}`;
+      markDirectorySessionPartChanged(child, sessionID, messageID);
+      child.setState({ part: { ...child.getState().part, [messageID]: [] } });
+    }
+
+    expect([...notifications.values()].reduce((sum, count) => sum + count, 0)).toBe(1_000);
+    expect(notifications.get('session-0')).toBe(20);
+    expect(getSyncPerformanceDiagnostics()?.sessionMessageChangeCallbacks).toBe(1_000);
+    for (const unsubscribe of unsubscribers) unsubscribe();
+    setSyncPerformanceDiagnosticsEnabled(false);
+    manager.disposeAll();
+  });
+
+  test('conservatively resets active subscribers for unannotated bulk part replacement', () => {
+    const manager = new ChildStoreManager();
+    const child = manager.ensureChild('/workspace', { bootstrap: false });
+    let reset = false;
+    const unsubscribe = subscribeDirectorySessionMessages(child, 'session-1', (change) => {
+      reset = change.reset;
+    });
+
+    child.setState({ part: { message: [] } });
+
+    expect(reset).toBe(true);
+    unsubscribe();
+    manager.disposeAll();
+  });
+});
+
+describe('ChildStoreManager directory bootstrap scheduler', () => {
+  test('bounds concurrency and eventually refreshes every queued directory', async () => {
+    const manager = new ChildStoreManager();
+    const running = new Map<string, ReturnType<typeof deferred>>();
+    const started: string[] = [];
+    let maxRunning = 0;
+    manager.setBootstrapDemand('sidebar', Array.from({ length: 10 }, (_, index) => ({
+      directory: `/workspace-${index}`,
+      priority: 'expanded' as const,
+      reason: 'project-expanded' as const,
+    })));
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 2,
+      onBootstrap: ({ directory }) => {
+        const task = deferred();
+        running.set(directory, task);
+        started.push(directory);
+        maxRunning = Math.max(maxRunning, running.size);
+        return task.promise.finally(() => running.delete(directory));
+      },
+    });
+
+    while (started.length < 10) {
+      expect(running.size <= 2).toBe(true);
+      const task = running.values().next().value;
+      expect(task).toBeDefined();
+      task?.resolve();
+      await settle();
+    }
+    for (const task of running.values()) task.resolve();
+    await settle();
+
+    expect(new Set(started).size).toBe(10);
+    expect(maxRunning).toBe(2);
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('reserves capacity for foreground work while background refresh drains', async () => {
+    const manager = new ChildStoreManager();
+    const tasks = new Map<string, ReturnType<typeof deferred>>();
+    const started: string[] = [];
+    manager.setBootstrapDemand('sidebar', [
+      { directory: '/background-a', priority: 'background', reason: 'known-worktree' },
+      { directory: '/background-b', priority: 'background', reason: 'known-worktree' },
+    ]);
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 2,
+      onBootstrap: ({ directory }) => {
+        const task = deferred();
+        tasks.set(directory, task);
+        started.push(directory);
+        return task.promise;
+      },
+    });
+
+    expect(started).toEqual(['/background-a']);
+    manager.requestBootstrap({ directory: '/selected', priority: 'selected', reason: 'selected-session' });
+    expect(started).toEqual(['/background-a', '/selected']);
+
+    tasks.get('/selected')?.resolve();
+    tasks.get('/background-a')?.resolve();
+    await settle();
+    tasks.get('/background-b')?.resolve();
+    await settle();
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('promotes a queued worktree without duplicating its execution', async () => {
+    const manager = new ChildStoreManager();
+    const blocker = deferred();
+    const started: string[] = [];
+    manager.setBootstrapDemand('sidebar', [
+      { directory: '/blocker', priority: 'expanded', reason: 'project-expanded' },
+      { directory: '/worktree', priority: 'background', reason: 'known-worktree' },
+    ]);
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: ({ directory }) => {
+        started.push(directory);
+        return directory === '/blocker' ? blocker.promise : Promise.resolve();
+      },
+    });
+
+    manager.setBootstrapDemand('sidebar', [
+      { directory: '/blocker', priority: 'expanded', reason: 'project-expanded' },
+      { directory: '/worktree', priority: 'expanded', reason: 'worktree-expanded' },
+    ]);
+    blocker.resolve();
+    await settle();
+    await settle();
+
+    expect(started).toEqual(['/blocker', '/worktree']);
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('failed work does not block unrelated queued directories', async () => {
+    const manager = new ChildStoreManager();
+    const started: string[] = [];
+    manager.setBootstrapDemand('sidebar', [
+      { directory: '/failed', priority: 'expanded', reason: 'project-expanded' },
+      { directory: '/healthy', priority: 'expanded', reason: 'project-expanded' },
+    ]);
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: async ({ directory }) => {
+        started.push(directory);
+        if (directory === '/failed') throw new Error('failed');
+      },
+    });
+    await settle();
+    await settle();
+
+    expect(started).toEqual(['/failed', '/healthy']);
+    expect(manager.getBootstrapState('/failed')).toBe('failed');
+    expect(manager.getBootstrapState('/healthy')).toBe('complete');
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('continues after a synchronous bootstrap failure', async () => {
+    const manager = new ChildStoreManager();
+    const started: string[] = [];
+    manager.setBootstrapDemand('sidebar', [
+      { directory: '/failed', priority: 'expanded', reason: 'project-expanded' },
+      { directory: '/healthy', priority: 'expanded', reason: 'project-expanded' },
+    ]);
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: ({ directory }) => {
+        started.push(directory);
+        if (directory === '/failed') throw new Error('failed');
+      },
+    });
+
+    await settle();
+    await settle();
+
+    expect(started).toEqual(['/failed', '/healthy']);
+    expect(manager.getBootstrapState('/failed')).toBe('failed');
+    expect(manager.getBootstrapState('/healthy')).toBe('complete');
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('reruns a forced manual demand that arrives while the directory is running', async () => {
+    const manager = new ChildStoreManager();
+    const firstRun = deferred();
+    const started: string[] = [];
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: ({ directory }) => {
+        started.push(directory);
+        return started.length === 1 ? firstRun.promise : Promise.resolve();
+      },
+    });
+
+    manager.requestBootstrap({ directory: '/workspace', priority: 'selected', reason: 'current-directory' });
+    manager.requestBootstrap({
+      directory: '/workspace',
+      priority: 'selected',
+      reason: 'server-connected',
+      force: true,
+    });
+    firstRun.resolve();
+    await settle();
+    await settle();
+
+    expect(started).toEqual(['/workspace', '/workspace']);
+    expect(manager.getBootstrapState('/workspace')).toBe('complete');
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('coalesces repeated non-forced manual demands while a directory is running', async () => {
+    const manager = new ChildStoreManager();
+    const firstRun = deferred();
+    let starts = 0;
+    const cleanup = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: () => {
+        starts += 1;
+        return firstRun.promise;
+      },
+    });
+
+    const demand = { directory: '/workspace', priority: 'selected' as const, reason: 'current-directory' as const };
+    manager.requestBootstrap(demand);
+    manager.requestBootstrap(demand);
+    firstRun.resolve();
+    await settle();
+    await settle();
+
+    expect(starts).toBe(1);
+    expect(manager.getBootstrapState('/workspace')).toBe('complete');
+    cleanup();
+    manager.disposeAll();
+  });
+
+  test('reruns a manual demand after its bootstrap generation becomes stale', async () => {
+    const manager = new ChildStoreManager();
+    const staleRun = deferred();
+    const started: string[] = [];
+    const cleanupStale = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: () => {
+        started.push('stale');
+        return staleRun.promise;
+      },
+    });
+
+    manager.requestBootstrap({ directory: '/workspace', priority: 'selected', reason: 'current-directory' });
+    cleanupStale();
+    const cleanupCurrent = manager.configure({
+      bootstrapConcurrency: 1,
+      onBootstrap: () => {
+        started.push('current');
+      },
+    });
+    staleRun.resolve();
+    await settle();
+    await settle();
+
+    expect(started).toEqual(['stale', 'current']);
+    expect(manager.getBootstrapState('/workspace')).toBe('complete');
+    cleanupCurrent();
+    manager.disposeAll();
+  });
 });
diff --git a/packages/ui/src/sync/child-store.ts b/packages/ui/src/sync/child-store.ts
index 154331f2..662edb88 100644
--- a/packages/ui/src/sync/child-store.ts
+++ b/packages/ui/src/sync/child-store.ts
@@ -3,6 +3,9 @@ import type { DirState, State } from "./types"
 import { INITIAL_STATE, MAX_DIR_STORES, DIR_IDLE_TTL_MS } from "./types"
 import { pickDirectoriesToEvict, canDisposeDirectory, hasPendingBlockingRequests } from "./eviction"
 import { readDirCache, persistVcs, persistProjectMeta, persistIcon, persistSessions } from "./persist-cache"
+import { normalizePath } from "@/lib/pathNormalization"
+import { startSessionLoadPerformanceEvent } from "./session-load-performance"
+import { countSyncPerformance } from "./performance-diagnostics"
 
 export type DirectoryStore = State & {
   /** Apply a partial state update */
@@ -11,13 +14,210 @@ export type DirectoryStore = State & {
   replace: (next: State) => void
 }
 
+type PermissionSubscriber = () => void
+const permissionSubscribersByStore = new WeakMap<StoreApi<DirectoryStore>, Map<string, Set<PermissionSubscriber>>>()
+
+type SessionMessageChange = {
+  messagesChanged: boolean
+  reset: boolean
+  partMessageIDs: readonly string[]
+}
+
+type SessionMessageSubscriber = (change: SessionMessageChange) => void
+const messageSubscribersByStore = new WeakMap<StoreApi<DirectoryStore>, Map<string, Set<SessionMessageSubscriber>>>()
+const pendingPartChangesByStore = new WeakMap<StoreApi<DirectoryStore>, Map<string, Set<string>>>()
+
+export function subscribeDirectorySessionMessages(
+  store: StoreApi<DirectoryStore>,
+  sessionID: string,
+  listener: SessionMessageSubscriber,
+): () => void {
+  let bySession = messageSubscribersByStore.get(store)
+  if (!bySession) {
+    bySession = new Map()
+    messageSubscribersByStore.set(store, bySession)
+  }
+  let listeners = bySession.get(sessionID)
+  if (!listeners) {
+    listeners = new Set()
+    bySession.set(sessionID, listeners)
+  }
+  listeners.add(listener)
+  return () => {
+    listeners?.delete(listener)
+    if (listeners?.size === 0) bySession?.delete(sessionID)
+    if (bySession?.size === 0) messageSubscribersByStore.delete(store)
+  }
+}
+
+export function markDirectorySessionPartChanged(
+  store: StoreApi<DirectoryStore>,
+  sessionID: string,
+  messageID: string,
+): void {
+  if (!sessionID || !messageID) return
+  let bySession = pendingPartChangesByStore.get(store)
+  if (!bySession) {
+    bySession = new Map()
+    pendingPartChangesByStore.set(store, bySession)
+  }
+  let messageIDs = bySession.get(sessionID)
+  if (!messageIDs) {
+    messageIDs = new Set()
+    bySession.set(sessionID, messageIDs)
+  }
+  messageIDs.add(messageID)
+}
+
+export function subscribeDirectoryPermission(
+  store: StoreApi<DirectoryStore>,
+  sessionID: string,
+  listener: PermissionSubscriber,
+): () => void {
+  let bySession = permissionSubscribersByStore.get(store)
+  if (!bySession) {
+    bySession = new Map()
+    permissionSubscribersByStore.set(store, bySession)
+  }
+  let listeners = bySession.get(sessionID)
+  if (!listeners) {
+    listeners = new Set()
+    bySession.set(sessionID, listeners)
+  }
+  listeners.add(listener)
+  return () => {
+    listeners?.delete(listener)
+    if (listeners?.size === 0) bySession?.delete(sessionID)
+    if (bySession?.size === 0) permissionSubscribersByStore.delete(store)
+  }
+}
+
+const notifyChangedPermissions = (
+  store: StoreApi<DirectoryStore>,
+  current: State["permission"],
+  previous: State["permission"],
+): void => {
+  if (current === previous) return
+  const subscribers = permissionSubscribersByStore.get(store)
+  if (!subscribers || subscribers.size === 0) return
+  for (const [sessionID, listeners] of subscribers) {
+    if (current[sessionID] === previous[sessionID]) continue
+    for (const listener of listeners) {
+      countSyncPerformance("permissionChangeCallbacks")
+      listener()
+    }
+  }
+}
+
+const notifyChangedSessionMessages = (
+  store: StoreApi<DirectoryStore>,
+  current: State,
+  previous: State,
+): void => {
+  const subscribers = messageSubscribersByStore.get(store)
+  const pendingParts = pendingPartChangesByStore.get(store)
+  pendingPartChangesByStore.delete(store)
+  if (!subscribers || subscribers.size === 0) return
+
+  const notifications = new Map<string, SessionMessageChange>()
+  if (current.message !== previous.message) {
+    for (const sessionID of subscribers.keys()) {
+      if (current.message[sessionID] === previous.message[sessionID]) continue
+      notifications.set(sessionID, { messagesChanged: true, reset: false, partMessageIDs: [] })
+    }
+  }
+
+  if (current.part !== previous.part) {
+    if (pendingParts && pendingParts.size > 0) {
+      for (const [sessionID, messageIDs] of pendingParts) {
+        if (!subscribers.has(sessionID)) continue
+        const existing = notifications.get(sessionID)
+        notifications.set(sessionID, {
+          messagesChanged: existing?.messagesChanged ?? false,
+          reset: existing?.reset ?? false,
+          partMessageIDs: [...messageIDs],
+        })
+      }
+    } else {
+      for (const sessionID of subscribers.keys()) {
+        const existing = notifications.get(sessionID)
+        notifications.set(sessionID, {
+          messagesChanged: existing?.messagesChanged ?? false,
+          reset: true,
+          partMessageIDs: existing?.partMessageIDs ?? [],
+        })
+      }
+    }
+  }
+
+  for (const [sessionID, change] of notifications) {
+    const listeners = subscribers.get(sessionID)
+    if (!listeners) continue
+    for (const listener of listeners) {
+      countSyncPerformance("sessionMessageChangeCallbacks")
+      listener(change)
+    }
+  }
+}
+
+export type DirectoryBootstrapPriority = "selected" | "active-project" | "expanded" | "visible" | "background"
+
+export type DirectoryBootstrapReason =
+  | "current-directory"
+  | "selected-session"
+  | "known-project"
+  | "known-worktree"
+  | "project-expanded"
+  | "worktree-expanded"
+  | "server-connected"
+  | "action-demand"
+
+export type DirectoryBootstrapDemand = {
+  directory: string
+  priority: DirectoryBootstrapPriority
+  reason: DirectoryBootstrapReason
+  force?: boolean
+}
+
+export type DirectoryBootstrapState = "queued" | "running" | "complete" | "failed"
+
+export type DirectoryBootstrapContext = DirectoryBootstrapDemand & {
+  generation: number
+  isCurrent: () => boolean
+}
+
+const BOOTSTRAP_PRIORITY: Record<DirectoryBootstrapPriority, number> = {
+  selected: 0,
+  "active-project": 1,
+  expanded: 2,
+  visible: 3,
+  background: 4,
+}
+
+type QueuedBootstrap = DirectoryBootstrapDemand & {
+  sequence: number
+  enqueuedAt: number
+}
+
+type RunningBootstrap = QueuedBootstrap & {
+  generation: number
+  token: object
+  manualDemandRevision?: number
+  rerunRequested?: boolean
+}
+
+type ManualBootstrapDemand = {
+  demand: DirectoryBootstrapDemand
+  revision: number
+}
+
 function createDirectoryStore(directory: string): StoreApi<DirectoryStore> {
   // Restore cached metadata from localStorage
   const cached = readDirCache(directory)
 
   // Stale-while-revalidate: seed the session list from cache so the sidebar
-  // paints chats instantly. Bootstrap phase-3 loadSessions overwrites with the
-  // fresh list (its empty-list race guard preserves these until then).
+  // paints chats instantly. Bootstrap replaces it with the authoritative list
+  // while preserving session mutations that happened after the request began.
   const cachedSessions = cached.sessions ?? INITIAL_STATE.session
 
   const store = create<DirectoryStore>()((set) => ({
@@ -27,6 +227,7 @@ function createDirectoryStore(directory: string): StoreApi<DirectoryStore> {
     icon: cached.icon ?? INITIAL_STATE.icon,
     session: cachedSessions,
     sessionTotal: cachedSessions.length,
+    sessionListSource: cachedSessions.length > 0 ? "persisted" : "empty",
     limit: Math.max(cachedSessions.length, INITIAL_STATE.limit),
     patch: (partial) => set(partial),
     replace: (next) => set(next),
@@ -38,6 +239,8 @@ function createDirectoryStore(directory: string): StoreApi<DirectoryStore> {
     if (state.projectMeta !== prev.projectMeta) persistProjectMeta(directory, state.projectMeta)
     if (state.icon !== prev.icon) persistIcon(directory, state.icon)
     if (state.session !== prev.session) persistSessions(directory, state.session)
+    notifyChangedPermissions(store, state.permission, prev.permission)
+    notifyChangedSessionMessages(store, state, prev)
   })
 
   return store
@@ -49,11 +252,22 @@ export class ChildStoreManager {
   private readonly pins = new Map<string, number>()
   private readonly disposers = new Map<string, () => void>()
   private readonly registrySubscribers = new Set<() => void>()
+  private readonly bootstrapSubscribers = new Set<() => void>()
+  private readonly bootstrapDemandsByOwner = new Map<string, Map<string, DirectoryBootstrapDemand>>()
+  private readonly manualBootstrapDemands = new Map<string, ManualBootstrapDemand>()
+  private readonly bootstrapQueue = new Map<string, QueuedBootstrap>()
+  private readonly runningBootstraps = new Map<string, RunningBootstrap>()
+  private readonly bootstrapStates = new Map<string, DirectoryBootstrapState>()
 
-  private onBootstrap?: (directory: string) => void
+  private onBootstrap?: (context: DirectoryBootstrapContext) => Promise<void> | void
   private onDispose?: (directory: string) => void
   private isBooting?: (directory: string) => boolean
   private isLoadingSessions?: (directory: string) => boolean
+  private bootstrapConcurrency = 2
+  private bootstrapGeneration = 0
+  private bootstrapSequence = 0
+  private manualBootstrapDemandRevision = 0
+  private disposed = false
 
   private notifyRegistrySubscribers() {
     for (const subscriber of this.registrySubscribers) {
@@ -61,16 +275,34 @@ export class ChildStoreManager {
     }
   }
 
+  private notifyBootstrapSubscribers() {
+    for (const subscriber of this.bootstrapSubscribers) subscriber()
+  }
+
   configure(callbacks: {
-    onBootstrap?: (directory: string) => void
+    onBootstrap?: (context: DirectoryBootstrapContext) => Promise<void> | void
     onDispose?: (directory: string) => void
     isBooting?: (directory: string) => boolean
     isLoadingSessions?: (directory: string) => boolean
-  }) {
+    bootstrapConcurrency?: number
+  }): () => void {
+    const generation = ++this.bootstrapGeneration
+    this.disposed = false
     this.onBootstrap = callbacks.onBootstrap
     this.onDispose = callbacks.onDispose
     this.isBooting = callbacks.isBooting
     this.isLoadingSessions = callbacks.isLoadingSessions
+    this.bootstrapConcurrency = Math.max(1, Math.floor(callbacks.bootstrapConcurrency ?? 2))
+    this.pumpBootstrapQueue()
+
+    return () => {
+      if (this.bootstrapGeneration !== generation) return
+      this.bootstrapGeneration += 1
+      this.onBootstrap = undefined
+      this.onDispose = undefined
+      this.isBooting = undefined
+      this.isLoadingSessions = undefined
+    }
   }
 
   mark(directory: string) {
@@ -80,48 +312,273 @@ export class ChildStoreManager {
   }
 
   pin(directory: string) {
-    if (!directory) return
-    this.pins.set(directory, (this.pins.get(directory) ?? 0) + 1)
-    this.mark(directory)
+    const normalizedDirectory = normalizePath(directory)
+    if (!normalizedDirectory) return
+    this.pins.set(normalizedDirectory, (this.pins.get(normalizedDirectory) ?? 0) + 1)
+    this.mark(normalizedDirectory)
   }
 
   unpin(directory: string) {
-    if (!directory) return
-    const next = (this.pins.get(directory) ?? 0) - 1
+    const normalizedDirectory = normalizePath(directory)
+    if (!normalizedDirectory) return
+    const next = (this.pins.get(normalizedDirectory) ?? 0) - 1
     if (next > 0) {
-      this.pins.set(directory, next)
+      this.pins.set(normalizedDirectory, next)
       return
     }
-    this.pins.delete(directory)
+    this.pins.delete(normalizedDirectory)
     this.runEviction()
   }
 
   pinned(directory: string) {
-    return (this.pins.get(directory) ?? 0) > 0
+    const normalizedDirectory = normalizePath(directory)
+    return normalizedDirectory ? (this.pins.get(normalizedDirectory) ?? 0) > 0 : false
   }
 
-  ensureChild(directory: string, options?: { bootstrap?: boolean }): StoreApi<DirectoryStore> {
-    if (!directory) throw new Error("No directory provided to ensureChild")
+  ensureChild(
+    directory: string,
+    options?: {
+      bootstrap?: boolean
+      priority?: DirectoryBootstrapPriority
+      reason?: DirectoryBootstrapReason
+    },
+  ): StoreApi<DirectoryStore> {
+    const normalizedDirectory = normalizePath(directory)
+    if (!normalizedDirectory) throw new Error("No directory provided to ensureChild")
 
-    let store = this.children.get(directory)
+    let store = this.children.get(normalizedDirectory)
     if (!store) {
-      store = createDirectoryStore(directory)
-      this.children.set(directory, store)
+      store = createDirectoryStore(normalizedDirectory)
+      this.children.set(normalizedDirectory, store)
       this.notifyRegistrySubscribers()
     }
 
-    this.mark(directory)
+    this.mark(normalizedDirectory)
 
     const shouldBootstrap = options?.bootstrap ?? true
     if (shouldBootstrap && store.getState().status === "loading") {
-      this.onBootstrap?.(directory)
+      this.requestBootstrap({
+        directory: normalizedDirectory,
+        priority: options?.priority ?? "selected",
+        reason: options?.reason ?? "action-demand",
+      })
     }
 
     return store
   }
 
   getChild(directory: string): StoreApi<DirectoryStore> | undefined {
-    return this.children.get(directory)
+    const normalizedDirectory = normalizePath(directory)
+    return normalizedDirectory ? this.children.get(normalizedDirectory) : undefined
+  }
+
+  requestBootstrap(demand: DirectoryBootstrapDemand): void {
+    const normalizedDirectory = normalizePath(demand.directory)
+    if (!normalizedDirectory || this.disposed) return
+    const normalizedDemand = { ...demand, directory: normalizedDirectory }
+    const existingDemand = this.manualBootstrapDemands.get(normalizedDirectory)?.demand
+    const nextDemand = existingDemand
+      ? {
+          ...existingDemand,
+          ...normalizedDemand,
+          priority: BOOTSTRAP_PRIORITY[normalizedDemand.priority] < BOOTSTRAP_PRIORITY[existingDemand.priority]
+            ? normalizedDemand.priority
+            : existingDemand.priority,
+          force: Boolean(existingDemand.force || normalizedDemand.force),
+        }
+      : normalizedDemand
+    this.manualBootstrapDemands.set(normalizedDirectory, {
+      demand: nextDemand,
+      revision: ++this.manualBootstrapDemandRevision,
+    })
+    this.ensureChild(normalizedDirectory, { bootstrap: false })
+    this.queueBootstrap(nextDemand)
+  }
+
+  setBootstrapDemand(owner: string, demands: DirectoryBootstrapDemand[]): void {
+    if (!owner || this.disposed) return
+    const next = new Map<string, DirectoryBootstrapDemand>()
+    for (const demand of demands) {
+      const directory = normalizePath(demand.directory)
+      if (!directory) continue
+      const normalized = { ...demand, directory }
+      const existing = next.get(directory)
+      if (!existing || BOOTSTRAP_PRIORITY[normalized.priority] < BOOTSTRAP_PRIORITY[existing.priority]) {
+        next.set(directory, normalized)
+      }
+    }
+    this.bootstrapDemandsByOwner.set(owner, next)
+    this.reconcileBootstrapQueue()
+  }
+
+  clearBootstrapDemand(owner: string): void {
+    if (!this.bootstrapDemandsByOwner.delete(owner)) return
+    this.reconcileBootstrapQueue()
+  }
+
+  getBootstrapState(directory: string): DirectoryBootstrapState | undefined {
+    const normalizedDirectory = normalizePath(directory)
+    return normalizedDirectory ? this.bootstrapStates.get(normalizedDirectory) : undefined
+  }
+
+  subscribeBootstrap(listener: () => void): () => void {
+    this.bootstrapSubscribers.add(listener)
+    return () => this.bootstrapSubscribers.delete(listener)
+  }
+
+  private aggregateBootstrapDemand(directory: string): DirectoryBootstrapDemand | undefined {
+    let result = this.manualBootstrapDemands.get(directory)?.demand
+    for (const demands of this.bootstrapDemandsByOwner.values()) {
+      const demand = demands.get(directory)
+      if (!demand) continue
+      if (!result || BOOTSTRAP_PRIORITY[demand.priority] < BOOTSTRAP_PRIORITY[result.priority]) result = demand
+    }
+    return result
+  }
+
+  private reconcileBootstrapQueue(): void {
+    const directories = new Set<string>()
+    for (const demands of this.bootstrapDemandsByOwner.values()) {
+      for (const directory of demands.keys()) directories.add(directory)
+    }
+    for (const directory of this.manualBootstrapDemands.keys()) directories.add(directory)
+
+    let changed = false
+    for (const [directory] of this.bootstrapQueue) {
+      if (directories.has(directory)) continue
+      this.bootstrapQueue.delete(directory)
+      if (this.bootstrapStates.get(directory) === "queued") this.bootstrapStates.delete(directory)
+      changed = true
+    }
+    for (const directory of directories) {
+      const demand = this.aggregateBootstrapDemand(directory)
+      if (!demand) continue
+      this.ensureChild(directory, { bootstrap: false })
+      changed = this.queueBootstrap(demand, false) || changed
+    }
+    if (changed) this.notifyBootstrapSubscribers()
+    this.pumpBootstrapQueue()
+  }
+
+  private queueBootstrap(demand: DirectoryBootstrapDemand, notify = true): boolean {
+    const directory = demand.directory
+    const store = this.children.get(directory)
+    const state = this.bootstrapStates.get(directory)
+    if (!demand.force && (state === "complete" || state === "failed" || store?.getState().status === "complete")) {
+      return false
+    }
+    const running = this.runningBootstraps.get(directory)
+    if (running) {
+      if (demand.force) running.rerunRequested = true
+      return false
+    }
+    const existing = this.bootstrapQueue.get(directory)
+    const next: QueuedBootstrap = existing
+      ? {
+          ...existing,
+          ...demand,
+          priority: BOOTSTRAP_PRIORITY[demand.priority] < BOOTSTRAP_PRIORITY[existing.priority]
+            ? demand.priority
+            : existing.priority,
+          force: Boolean(existing.force || demand.force),
+        }
+      : { ...demand, sequence: ++this.bootstrapSequence, enqueuedAt: Date.now() }
+    const changed = !existing
+      || next.priority !== existing.priority
+      || next.reason !== existing.reason
+      || next.force !== existing.force
+    this.bootstrapQueue.set(directory, next)
+    this.bootstrapStates.set(directory, "queued")
+    if (changed && notify) this.notifyBootstrapSubscribers()
+    this.pumpBootstrapQueue()
+    return changed
+  }
+
+  private nextBootstrap(): QueuedBootstrap | undefined {
+    const candidates = [...this.bootstrapQueue.values()].sort((left, right) => {
+      const priority = BOOTSTRAP_PRIORITY[left.priority] - BOOTSTRAP_PRIORITY[right.priority]
+      return priority !== 0 ? priority : left.sequence - right.sequence
+    })
+    const lowPriorityRunning = [...this.runningBootstraps.values()].filter(
+      (entry) => BOOTSTRAP_PRIORITY[entry.priority] >= BOOTSTRAP_PRIORITY.visible,
+    ).length
+    return candidates.find((entry) => (
+      BOOTSTRAP_PRIORITY[entry.priority] < BOOTSTRAP_PRIORITY.visible || lowPriorityRunning === 0
+    ))
+  }
+
+  private pumpBootstrapQueue(): void {
+    if (!this.onBootstrap || this.disposed) return
+    while (this.runningBootstraps.size < this.bootstrapConcurrency) {
+      const next = this.nextBootstrap()
+      if (!next) return
+      this.bootstrapQueue.delete(next.directory)
+      const token = {}
+      const running: RunningBootstrap = {
+        ...next,
+        generation: this.bootstrapGeneration,
+        token,
+        manualDemandRevision: this.manualBootstrapDemands.get(next.directory)?.revision,
+      }
+      this.runningBootstraps.set(next.directory, running)
+      this.bootstrapStates.set(next.directory, "running")
+      this.notifyBootstrapSubscribers()
+      const finishPerformanceEvent = startSessionLoadPerformanceEvent({
+        operation: "bootstrap.directory",
+        directory: next.directory,
+        caller: next.reason,
+        queuedMs: Math.max(0, Date.now() - next.enqueuedAt),
+      })
+
+      const isCurrent = () => (
+        !this.disposed
+        && this.bootstrapGeneration === running.generation
+        && this.runningBootstraps.get(next.directory)?.token === token
+        && this.children.has(next.directory)
+      )
+      let bootstrapPromise: Promise<void>
+      try {
+        bootstrapPromise = Promise.resolve(this.onBootstrap({ ...next, generation: running.generation, isCurrent }))
+      } catch (error) {
+        bootstrapPromise = Promise.reject(error)
+      }
+      void bootstrapPromise
+        .then(() => {
+          if (isCurrent()) {
+            this.bootstrapStates.set(next.directory, "complete")
+            finishPerformanceEvent("complete")
+          } else {
+            finishPerformanceEvent("stale")
+          }
+        })
+        .catch(() => {
+          if (isCurrent()) {
+            this.bootstrapStates.set(next.directory, "failed")
+            finishPerformanceEvent("error")
+          } else {
+            finishPerformanceEvent("stale")
+          }
+        })
+        .finally(() => {
+          const executionBecameStale = this.bootstrapGeneration !== running.generation || this.disposed
+          if (this.runningBootstraps.get(next.directory)?.token === token) {
+            this.runningBootstraps.delete(next.directory)
+          }
+          const currentManualDemand = this.manualBootstrapDemands.get(next.directory)
+          const hasNewForcedManualDemand = currentManualDemand !== undefined
+            && currentManualDemand.revision !== running.manualDemandRevision
+            && currentManualDemand.demand.force === true
+          if (!executionBecameStale && !hasNewForcedManualDemand) {
+            this.manualBootstrapDemands.delete(next.directory)
+          }
+          if ((executionBecameStale || hasNewForcedManualDemand || running.rerunRequested) && !this.disposed) {
+            const demand = this.aggregateBootstrapDemand(next.directory)
+            if (demand) this.queueBootstrap({ ...demand, force: true }, false)
+          }
+          this.notifyBootstrapSubscribers()
+          this.pumpBootstrapQueue()
+        })
+    }
   }
 
   disposeDirectory(directory: string): boolean {
@@ -130,7 +587,9 @@ export class ChildStoreManager {
         directory,
         hasStore: this.children.has(directory),
         pinned: this.pinned(directory),
-        booting: this.isBooting?.(directory) ?? false,
+        booting: this.bootstrapStates.get(directory) === "queued"
+          || this.bootstrapStates.get(directory) === "running"
+          || (this.isBooting?.(directory) ?? false),
         loadingSessions: this.isLoadingSessions?.(directory) ?? false,
         hasPendingBlockingRequests: this.hasPendingBlockingRequestsForDirectory(directory),
       })
@@ -139,6 +598,10 @@ export class ChildStoreManager {
     }
 
     this.lifecycle.delete(directory)
+    this.bootstrapQueue.delete(directory)
+    this.manualBootstrapDemands.delete(directory)
+    this.bootstrapStates.delete(directory)
+    for (const demands of this.bootstrapDemandsByOwner.values()) demands.delete(directory)
     this.children.delete(directory)
     this.notifyRegistrySubscribers()
     const dispose = this.disposers.get(directory)
@@ -186,6 +649,8 @@ export class ChildStoreManager {
   }
 
   disposeAll() {
+    this.disposed = true
+    this.bootstrapGeneration += 1
     for (const directory of [...this.children.keys()]) {
       this.children.delete(directory)
     }
@@ -193,6 +658,12 @@ export class ChildStoreManager {
     this.lifecycle.clear()
     this.pins.clear()
     this.disposers.clear()
+    this.bootstrapQueue.clear()
+    this.runningBootstraps.clear()
+    this.bootstrapStates.clear()
+    this.bootstrapDemandsByOwner.clear()
+    this.manualBootstrapDemands.clear()
+    this.notifyBootstrapSubscribers()
   }
 
   subscribeRegistry(listener: () => void): () => void {
diff --git a/packages/ui/src/sync/content-cache.ts b/packages/ui/src/sync/content-cache.ts
deleted file mode 100644
index eaf5b218..00000000
--- a/packages/ui/src/sync/content-cache.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * File content LRU cache — dual constraint eviction.
- * Port of OpenCode's content-cache.ts.
- *
- * Evicts when either entry count exceeds MAX_FILE_CONTENT_ENTRIES
- * or total byte estimate exceeds MAX_FILE_CONTENT_BYTES.
- * Uses Map insertion order as LRU (oldest = first key).
- */
-
-const MAX_FILE_CONTENT_ENTRIES = 40
-const MAX_FILE_CONTENT_BYTES = 20 * 1024 * 1024 // 20 MB
-
-// LRU map: path → approximate bytes. Map insertion order = access order.
-const lru = new Map<string, number>()
-let total = 0
-
-/** Estimate byte size of a string (UTF-16 → ~2 bytes per char). */
-export function approxStringBytes(content: string): number {
-  return content.length * 2
-}
-
-function setBytes(path: string, nextBytes: number) {
-  const prev = lru.get(path)
-  if (prev !== undefined) total -= prev
-  lru.delete(path)
-  lru.set(path, nextBytes)
-  total += nextBytes
-}
-
-function touch(path: string, bytes?: number) {
-  const prev = lru.get(path)
-  if (prev === undefined && bytes === undefined) return
-  setBytes(path, bytes ?? prev ?? 0)
-}
-
-function remove(path: string) {
-  const prev = lru.get(path)
-  if (prev === undefined) return
-  lru.delete(path)
-  total -= prev
-}
-
-/**
- * Evict entries until both constraints are satisfied.
- * @param keep - paths to preserve (moved to end of LRU if encountered)
- * @param evict - callback to actually remove content from the store
- */
-export function evictContentLru(keep: Set<string> | undefined, evict: (path: string) => void) {
-  const safeSet = keep ?? new Set<string>()
-
-  while (lru.size > MAX_FILE_CONTENT_ENTRIES || total > MAX_FILE_CONTENT_BYTES) {
-    const path = lru.keys().next().value
-    if (!path) return
-
-    if (safeSet.has(path)) {
-      touch(path)
-      if (lru.size <= safeSet.size) return
-      continue
-    }
-
-    remove(path)
-    evict(path)
-  }
-}
-
-export function setContentBytes(path: string, bytes: number) {
-  setBytes(path, bytes)
-}
-
-export function removeContentBytes(path: string) {
-  remove(path)
-}
-
-export function touchContent(path: string, bytes?: number) {
-  touch(path, bytes)
-}
diff --git a/packages/ui/src/sync/event-pipeline.test.ts b/packages/ui/src/sync/event-pipeline.test.ts
index f7d690e9..cbe64161 100644
--- a/packages/ui/src/sync/event-pipeline.test.ts
+++ b/packages/ui/src/sync/event-pipeline.test.ts
@@ -33,6 +33,18 @@ function deltaEvent(delta: string): Event {
   } as Event
 }
 
+function statusEvent(type: "busy" | "retry"): Event {
+  return {
+    type: "session.status",
+    properties: {
+      sessionID: "ses_1",
+      status: type === "busy"
+        ? { type }
+        : { type, attempt: 1, message: "retrying", next: 1 },
+    },
+  } as Event
+}
+
 function createSdk(events: Event[], streamFinished: () => void): OpencodeClient {
   return {
     global: {
@@ -56,6 +68,73 @@ function createSdk(events: Event[], streamFinished: () => void): OpencodeClient
 }
 
 describe("createEventPipeline", () => {
+  test("delivers one ordered batch per directory flush", async () => {
+    let resolveStreamFinished!: () => void
+    const streamFinished = new Promise<void>((resolve) => {
+      resolveStreamFinished = resolve
+    })
+    let resolveDelivered!: (events: readonly Event[]) => void
+    const deliveredBatch = new Promise<readonly Event[]>((resolve) => {
+      resolveDelivered = resolve
+    })
+    const pipeline = createEventPipeline({
+      sdk: createSdk([
+        partUpdatedEvent("a"),
+        deltaEvent("b"),
+        partUpdatedEvent("ab"),
+      ], resolveStreamFinished),
+      onEvents: (_directory, events) => resolveDelivered([...events]),
+      transport: "sse",
+      heartbeatTimeoutMs: 1_000,
+    })
+
+    try {
+      await streamFinished
+      const delivered = await Promise.race([deliveredBatch, failAfter(500)])
+      expect(delivered.map((event) => event.type)).toEqual([
+        "message.part.updated",
+        "message.part.delta",
+        "message.part.updated",
+      ])
+    } finally {
+      pipeline.cleanup()
+    }
+  })
+
+  test("does not coalesce session status across an idle barrier", async () => {
+    let resolveStreamFinished!: () => void
+    const streamFinished = new Promise<void>((resolve) => {
+      resolveStreamFinished = resolve
+    })
+    let resolveDelivered!: (events: readonly Event[]) => void
+    const deliveredBatch = new Promise<readonly Event[]>((resolve) => {
+      resolveDelivered = resolve
+    })
+    const pipeline = createEventPipeline({
+      sdk: createSdk([
+        statusEvent("busy"),
+        { type: "session.idle", properties: { sessionID: "ses_1" } } as Event,
+        statusEvent("retry"),
+      ], resolveStreamFinished),
+      onEvents: (_directory, events) => resolveDelivered([...events]),
+      transport: "sse",
+      heartbeatTimeoutMs: 1_000,
+    })
+
+    try {
+      await streamFinished
+      const delivered = await Promise.race([deliveredBatch, failAfter(500)])
+      expect(delivered.map((event) => event.type)).toEqual([
+        "session.status",
+        "session.idle",
+        "session.status",
+      ])
+      expect((delivered[2]?.properties as { status?: { type?: string } }).status?.type).toBe("retry")
+    } finally {
+      pipeline.cleanup()
+    }
+  })
+
   test("preserves part update order around text deltas", async () => {
     let resolveStreamFinished!: () => void
     const streamFinished = new Promise<void>((resolve) => {
diff --git a/packages/ui/src/sync/event-pipeline.ts b/packages/ui/src/sync/event-pipeline.ts
index fa22c5fa..9ad84efb 100644
--- a/packages/ui/src/sync/event-pipeline.ts
+++ b/packages/ui/src/sync/event-pipeline.ts
@@ -6,7 +6,7 @@
  * snapshot belongs in the reducer, which has access to the current state.
  *
  * Plain closure API:
- *   const { cleanup } = createEventPipeline({ sdk, onEvent })
+ *   const { cleanup } = createEventPipeline({ sdk, onEvents })
  *
  * No class, no start/stop lifecycle. One pipeline per mount.
  * Abort controller created once at init, cleaned up via returned cleanup fn.
@@ -19,6 +19,7 @@ import { clearRuntimeUrlAuthToken, refreshRuntimeUrlAuthToken } from "@/lib/runt
 import { type RelayTunnelWebSocket } from "@/lib/relay/tunnel-client"
 import { openRuntimeWebSocket } from "@/lib/relay/runtime-socket"
 import { syncDebug } from "./debug"
+import { countSyncPerformance } from "./performance-diagnostics"
 
 const FLUSH_FRAME_MS = 33
 const BACKPRESSURE_FLUSH_FRAME_MS = 200
@@ -38,9 +39,16 @@ const RETRY_BACKOFF_BASE_MS = 250
 const RETRY_BACKOFF_CAP_VISIBLE_MS = 5_000
 const RETRY_BACKOFF_CAP_HIDDEN_OR_OFFLINE_MS = 60_000
 const RETRY_BACKOFF_MAX_EXPONENT = 8
+type EventPipelineDelivery = {
+  onEvent: (directory: string, payload: Event) => void
+  onEvents?: never
+} | {
+  onEvent?: never
+  onEvents: (directory: string, payloads: readonly Event[]) => void
+}
+
 export type EventPipelineInput = {
   sdk: OpencodeClient
-  onEvent: (directory: string, payload: Event) => void
   routeDirectory?: (directory: string, payload: Event) => string
   /** Called after stream reconnects (visibility restore or heartbeat timeout). */
   onReconnect?: () => void
@@ -52,7 +60,7 @@ export type EventPipelineInput = {
   heartbeatTimeoutMs?: number
   reconnectDelayMs?: number
   wsReadyTimeoutMs?: number
-}
+} & EventPipelineDelivery
 
 export type EventPipeline = {
   cleanup: () => void
@@ -242,6 +250,7 @@ export function createEventPipeline(input: EventPipelineInput): EventPipeline {
   const {
     sdk,
     onEvent,
+    onEvents,
     onReconnect,
     onDisconnect,
     onTransportSwitch,
@@ -308,8 +317,13 @@ export function createEventPipeline(input: EventPipelineInput): EventPipeline {
 
     d.last = Date.now()
     syncDebug.pipeline.flush(events.length)
-    for (const payload of events) {
-      onEvent(directory, payload)
+    for (let index = 0; index < events.length; index += 1) {
+      countSyncPerformance("pipelineDeliveredEvents")
+    }
+    if (onEvents) {
+      onEvents(directory, events)
+    } else if (onEvent) {
+      for (const payload of events) onEvent(directory, payload)
     }
 
     d.buffer.length = 0
@@ -450,6 +464,7 @@ export function createEventPipeline(input: EventPipelineInput): EventPipeline {
   }
 
   const enqueueEvent = (directory: string, payload: Event) => {
+    countSyncPerformance("pipelineRawEvents")
     const normalizedPayload = normalizeEventType(payload)
     const routedDirectory = routeDirectory?.(directory, normalizedPayload) || directory
     const d = getOrCreateDir(routedDirectory)
@@ -473,6 +488,29 @@ export function createEventPipeline(input: EventPipelineInput): EventPipeline {
       }
     }
 
+    if (
+      normalizedPayload.type === "session.idle"
+      || normalizedPayload.type === "session.error"
+      || normalizedPayload.type === "session.created"
+      || normalizedPayload.type === "session.deleted"
+    ) {
+      const properties = normalizedPayload.properties as {
+        sessionID?: unknown
+        info?: { id?: unknown }
+      }
+      const sessionID = typeof properties.sessionID === "string"
+        ? properties.sessionID
+        : typeof properties.info?.id === "string"
+          ? properties.info.id
+          : undefined
+      if (sessionID) {
+        d.coalesced.delete(`session.status:${sessionID}`)
+        if (normalizedPayload.type === "session.created" || normalizedPayload.type === "session.deleted") {
+          d.coalesced.delete(`session.updated:${sessionID}`)
+        }
+      }
+    }
+
     const k = key(normalizedPayload)
     if (k) {
       const i = d.coalesced.get(k)
@@ -490,6 +528,7 @@ export function createEventPipeline(input: EventPipelineInput): EventPipeline {
         } else {
           d.queue[i] = normalizedPayload
         }
+        countSyncPerformance("pipelineCoalescedEvents")
         syncDebug.pipeline.coalesced(normalizedPayload.type, k)
         return
       }
diff --git a/packages/ui/src/sync/event-reducer.ts b/packages/ui/src/sync/event-reducer.ts
index 5288b140..ffcaa0d0 100644
--- a/packages/ui/src/sync/event-reducer.ts
+++ b/packages/ui/src/sync/event-reducer.ts
@@ -217,6 +217,21 @@ export function applyDirectoryEvent(
     onSetSessionTodo?: (sessionID: string, todos: Todo[] | undefined) => void
   },
 ): DirectoryEventResult {
+  const markSessionEvent = (sessionID: string, deleted: boolean) => {
+    const revision = (draft.sessionRevision ?? 0) + 1
+    draft.sessionRevision = revision
+    draft.sessionListSource = "live"
+    draft.sessionEventRevision = draft.sessionEventRevision ?? {}
+    draft.sessionDeletedRevision = draft.sessionDeletedRevision ?? {}
+    if (deleted) {
+      draft.sessionDeletedRevision[sessionID] = revision
+      delete draft.sessionEventRevision[sessionID]
+    } else {
+      draft.sessionEventRevision[sessionID] = revision
+      delete draft.sessionDeletedRevision[sessionID]
+    }
+  }
+
   switch (event.type) {
     case "server.instance.disposed": {
       callbacks?.onRefresh?.("")
@@ -237,6 +252,7 @@ export function applyDirectoryEvent(
         trimSessions(draft)
         if (!info.parentID) draft.sessionTotal += 1
       }
+      markSessionEvent(info.id, false)
       return true
     }
 
@@ -256,6 +272,7 @@ export function applyDirectoryEvent(
         if (result.found) sessions.splice(result.index, 1)
         cleanupSessionCaches(draft, info.id, callbacks?.onSetSessionTodo)
         if (!info.parentID) draft.sessionTotal = Math.max(0, draft.sessionTotal - 1)
+        markSessionEvent(info.id, true)
         return true
       }
 
@@ -265,16 +282,21 @@ export function applyDirectoryEvent(
         sessions.splice(result.index, 0, info)
         trimSessions(draft)
       }
+      markSessionEvent(info.id, false)
       return true
     }
 
     case "session.deleted": {
-      const info = (event.properties as { info: Session }).info
       const sessions = draft.session
-      const result = Binary.search(sessions, info.id, (s) => s.id)
+      const props = event.properties as { info?: Session; sessionID?: string }
+      const sessionID = props.info?.id ?? props.sessionID
+      if (!sessionID) return false
+      const result = Binary.search(sessions, sessionID, (s) => s.id)
+      const info = props.info ?? (result.found ? sessions[result.index] : undefined)
       if (result.found) sessions.splice(result.index, 1)
-      cleanupSessionCaches(draft, info.id, callbacks?.onSetSessionTodo)
-      if (!info.parentID) draft.sessionTotal = Math.max(0, draft.sessionTotal - 1)
+      cleanupSessionCaches(draft, sessionID, callbacks?.onSetSessionTodo)
+      if (!info?.parentID) draft.sessionTotal = Math.max(0, draft.sessionTotal - 1)
+      markSessionEvent(sessionID, true)
       return true
     }
 
diff --git a/packages/ui/src/sync/global-session-status.test.ts b/packages/ui/src/sync/global-session-status.test.ts
new file mode 100644
index 00000000..e21f2b9e
--- /dev/null
+++ b/packages/ui/src/sync/global-session-status.test.ts
@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, test } from "bun:test"
+import type { Event } from "@opencode-ai/sdk/v2/client"
+import {
+  applyGlobalSessionStatusEvent,
+  applyGlobalSessionStatusSnapshot,
+  useGlobalSessionStatusStore,
+} from "./global-session-status"
+
+beforeEach(() => {
+  useGlobalSessionStatusStore.setState({ statusById: new Map() })
+})
+
+describe("global session status index", () => {
+  test("preserves full retry status details from live events", () => {
+    applyGlobalSessionStatusEvent("/repo", {
+      type: "session.status",
+      properties: {
+        sessionID: "session-a",
+        status: { type: "retry", attempt: 2, message: "waiting" },
+      },
+    } as Event)
+
+    expect(useGlobalSessionStatusStore.getState().statusById.get("session-a")?.status).toEqual({
+      type: "retry",
+      attempt: 2,
+      message: "waiting",
+    })
+  })
+
+  test("authoritative snapshots clear absent active entries for their directory", () => {
+    applyGlobalSessionStatusSnapshot("/repo", { "session-a": { type: "busy" } }, ["session-a"])
+    expect(useGlobalSessionStatusStore.getState().statusById.get("session-a")?.status.type).toBe("busy")
+
+    applyGlobalSessionStatusSnapshot("/repo", {}, ["session-a"])
+    expect(useGlobalSessionStatusStore.getState().statusById.has("session-a")).toBe(false)
+  })
+
+  test("clears an explicitly idle known session when directory aliases differ", () => {
+    applyGlobalSessionStatusSnapshot("/canonical/repo", { "session-a": { type: "busy" } }, ["session-a"])
+
+    applyGlobalSessionStatusSnapshot("/alias/repo", { "session-a": { type: "idle" } }, ["session-a"])
+
+    expect(useGlobalSessionStatusStore.getState().statusById.has("session-a")).toBe(false)
+  })
+})
diff --git a/packages/ui/src/sync/global-session-status.ts b/packages/ui/src/sync/global-session-status.ts
index 4c631837..1321614a 100644
--- a/packages/ui/src/sync/global-session-status.ts
+++ b/packages/ui/src/sync/global-session-status.ts
@@ -1,13 +1,10 @@
 import { create } from 'zustand';
-import type { Event } from '@opencode-ai/sdk/v2/client';
+import type { Event, SessionStatus } from '@opencode-ai/sdk/v2/client';
 import { normalizeProjectPath } from '@/lib/projectResolution';
 
-// Live busy/retry status for sessions in directories WITHOUT a synced child
-// store. The global event stream (`/api/global/event/ws`) carries status
-// events for every directory, but the sync dispatcher can only apply them to
-// an existing child store — events for unopened directories used to be
-// dropped. They land here instead, so cross-project consumers (the macOS tray)
-// see live status for all sessions, not just the synced ones.
+// Shared live busy/retry index for every directory. Global events update it
+// incrementally and authoritative directory snapshots reconcile it, so each
+// sidebar row can subscribe to one leaf instead of every child store.
 //
 // Only non-idle entries are kept; absence means idle. Entries carry their
 // directory so a polled per-directory snapshot can authoritatively replace
@@ -15,7 +12,7 @@ import { normalizeProjectPath } from '@/lib/projectResolution';
 
 type ActiveStatusType = 'busy' | 'retry';
 
-type GlobalSessionStatusEntry = { status: ActiveStatusType; directory: string };
+type GlobalSessionStatusEntry = { status: SessionStatus; directory: string };
 
 type GlobalSessionStatusState = {
   statusById: Map<string, GlobalSessionStatusEntry>;
@@ -34,16 +31,17 @@ const normalizeStatusType = (type: unknown): ActiveStatusType | 'idle' =>
 const normalizeDirectory = (directory: string): string =>
   normalizeProjectPath(directory) ?? directory;
 
-const setStatus = (sessionId: string, directory: string, status: ActiveStatusType | 'idle'): void => {
+const setStatus = (sessionId: string, directory: string, status: SessionStatus | { type: 'idle' }): void => {
   useGlobalSessionStatusStore.setState((state) => {
     const current = state.statusById.get(sessionId);
-    if (status === 'idle') {
+    if (status.type === 'idle') {
       if (!current) return state;
       const next = new Map(state.statusById);
       next.delete(sessionId);
       return { statusById: next };
     }
-    if (current && current.status === status && current.directory === directory) return state;
+    if (current && current.status.type === status.type && current.directory === directory
+      && JSON.stringify(current.status) === JSON.stringify(status)) return state;
     const next = new Map(state.statusById);
     next.set(sessionId, { status, directory });
     return { statusById: next };
@@ -58,14 +56,19 @@ export const applyGlobalSessionStatusEvent = (directory: string, payload: Event)
     case 'session.status': {
       const props = payload.properties as { sessionID?: string; status?: { type?: string } } | undefined;
       if (typeof props?.sessionID !== 'string' || !props.sessionID) return;
-      setStatus(props.sessionID, normalizeDirectory(directory), normalizeStatusType(props.status?.type));
+      const type = normalizeStatusType(props.status?.type);
+      setStatus(
+        props.sessionID,
+        normalizeDirectory(directory),
+        type === 'idle' ? { type: 'idle' } : { ...(props.status ?? {}), type } as SessionStatus,
+      );
       return;
     }
     case 'session.idle':
     case 'session.error': {
       const props = payload.properties as { sessionID?: string } | undefined;
       if (typeof props?.sessionID === 'string' && props.sessionID) {
-        setStatus(props.sessionID, normalizeDirectory(directory), 'idle');
+        setStatus(props.sessionID, normalizeDirectory(directory), { type: 'idle' });
       }
       return;
     }
@@ -101,14 +104,16 @@ export const applyGlobalSessionStatusSnapshot = (
       const type = normalizeStatusType(status?.type);
       const current = next.get(sessionId);
       if (type === 'idle') {
-        if (current && current.directory === directory) {
+        if (current && (current.directory === directory || known.has(sessionId))) {
           next.delete(sessionId);
           changed = true;
         }
         continue;
       }
-      if (!current || current.status !== type || current.directory !== directory) {
-        next.set(sessionId, { status: type, directory });
+      const normalizedStatus = { ...status, type } as SessionStatus;
+      if (!current || current.status.type !== type || current.directory !== directory
+        || JSON.stringify(current.status) !== JSON.stringify(normalizedStatus)) {
+        next.set(sessionId, { status: normalizedStatus, directory });
         changed = true;
       }
     }
diff --git a/packages/ui/src/sync/live-aggregate-performance.test.ts b/packages/ui/src/sync/live-aggregate-performance.test.ts
new file mode 100644
index 00000000..7c590e8f
--- /dev/null
+++ b/packages/ui/src/sync/live-aggregate-performance.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test'
+import type { Session, SessionStatus } from '@opencode-ai/sdk/v2/client'
+
+import { aggregateLiveSessionStatuses } from './live-aggregate'
+import {
+  getSyncPerformanceDiagnostics,
+  setSyncPerformanceDiagnosticsEnabled,
+} from './performance-diagnostics'
+
+describe('aggregateLiveSessionStatuses performance', () => {
+  test('indexes 50 sessions once instead of scanning the list per status', () => {
+    const sessions = Array.from({ length: 50 }, (_, index) => ({
+      id: `session-${index}`,
+      time: { created: index, updated: index },
+    })) as Session[]
+    const session_status = Object.fromEntries(
+      sessions.map((session) => [session.id, { type: 'busy' } as SessionStatus]),
+    )
+    setSyncPerformanceDiagnosticsEnabled(true)
+
+    const statuses = aggregateLiveSessionStatuses([{ session: sessions, session_status }])
+    const diagnostics = getSyncPerformanceDiagnostics()
+
+    expect(Object.keys(statuses)).toHaveLength(50)
+    expect(diagnostics?.statusAggregationSessionEntries).toBe(50)
+    expect(diagnostics?.statusAggregationCandidates).toBe(50)
+    setSyncPerformanceDiagnosticsEnabled(false)
+  })
+})
diff --git a/packages/ui/src/sync/live-aggregate.ts b/packages/ui/src/sync/live-aggregate.ts
index 77535e4a..1467e2fc 100644
--- a/packages/ui/src/sync/live-aggregate.ts
+++ b/packages/ui/src/sync/live-aggregate.ts
@@ -1,6 +1,7 @@
 import type { SessionStatus } from '@opencode-ai/sdk/v2/client'
 import type { Session } from '@opencode-ai/sdk/v2'
 import type { State } from './types'
+import { countSyncPerformance } from './performance-diagnostics'
 
 type LiveStateSlice = Pick<State, 'session' | 'session_status'>
 
@@ -158,10 +159,16 @@ export function aggregateLiveSessionStatuses(states: Iterable<LiveStateSlice>):
   const candidates = new Map<string, StatusCandidate>()
 
   for (const state of states) {
-    for (const sessionId of Object.keys(state.session_status ?? {})) {
-      const next = getStatusCandidate(state, sessionId)
-      if (!next) {
-        continue
+    const sessionUpdatedAtById = new Map<string, number>()
+    for (const session of state.session) {
+      countSyncPerformance('statusAggregationSessionEntries')
+      sessionUpdatedAtById.set(session.id, getSessionUpdatedAt(session))
+    }
+    for (const [sessionId, status] of Object.entries(state.session_status ?? {})) {
+      countSyncPerformance('statusAggregationCandidates')
+      const next: StatusCandidate = {
+        status,
+        sessionUpdatedAt: sessionUpdatedAtById.get(sessionId) ?? -1,
       }
 
       const current = candidates.get(sessionId)
diff --git a/packages/ui/src/sync/materialization.ts b/packages/ui/src/sync/materialization.ts
index 7f984253..c02d19be 100644
--- a/packages/ui/src/sync/materialization.ts
+++ b/packages/ui/src/sync/materialization.ts
@@ -1,5 +1,6 @@
 import type { Message, Part } from "@opencode-ai/sdk/v2/client"
 import { mergeMessages } from "./optimistic"
+import type { SessionMaterializationReason } from "./event-reducer"
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 const STREAMING_PART_FIELDS = ["text", "output"] as const
@@ -33,6 +34,40 @@ export type SessionMaterializationStatus = {
   missingPartMessageIDs: string[]
 }
 
+export type SessionMaterializationRequest = {
+  reason: SessionMaterializationReason
+  messageID?: string
+  partID?: string
+}
+
+export const getSessionMaterializationRequestKey = (
+  runtimeKey: string,
+  directory: string,
+  sessionID: string,
+): string => JSON.stringify([runtimeKey, directory, sessionID])
+
+export function isSessionMaterializationStillNeeded(
+  state: MaterializedState,
+  sessionID: string,
+  request: SessionMaterializationRequest,
+): boolean {
+  if (request.reason === "empty-assistant-message") {
+    return !request.messageID || !Object.prototype.hasOwnProperty.call(state.part, request.messageID)
+  }
+
+  if (request.reason === "missing-owning-message") {
+    if (!request.messageID) return true
+    return !(state.message[sessionID] ?? []).some((message) => message.id === request.messageID)
+  }
+
+  if (request.reason === "orphan-delta" || request.reason === "missing-delta-part") {
+    if (!request.messageID || !request.partID) return true
+    return !(state.part[request.messageID] ?? []).some((part) => part.id === request.partID)
+  }
+
+  return true
+}
+
 function sortParts(parts: Part[], skipPartTypes: ReadonlySet<string>) {
   return parts
     .filter((part) => !!part?.id && !skipPartTypes.has(part.type))
@@ -50,6 +85,7 @@ function haveEquivalentPartSnapshots(left: Part[] | undefined, right: Part[]): b
     const leftPart = left[index]
     const rightPart = right[index]
     if (!leftPart || !rightPart) return false
+    if (leftPart === rightPart) continue
     if (leftPart.id !== rightPart.id) return false
     if (JSON.stringify(leftPart) !== JSON.stringify(rightPart)) return false
   }
@@ -171,7 +207,7 @@ export function materializeSessionSnapshots(
   const messagesChanged = messages !== currentMessages || (existingMessages === undefined && snapshots.length === 0)
 
   let partsChanged = false
-  const nextPartState = { ...state.part }
+  let nextPartState = state.part
   const isPrepend = options.mode === "prepend"
 
   for (const record of snapshots) {
@@ -194,6 +230,8 @@ export function materializeSessionSnapshots(
       : nextParts.length === 0 && !isAssistant
     if (equivalent) continue
 
+    if (nextPartState === state.part) nextPartState = { ...state.part }
+
     if (nextParts.length === 0 && !isAssistant) {
       delete nextPartState[messageID]
     } else {
diff --git a/packages/ui/src/sync/performance-diagnostics.ts b/packages/ui/src/sync/performance-diagnostics.ts
new file mode 100644
index 00000000..063e4697
--- /dev/null
+++ b/packages/ui/src/sync/performance-diagnostics.ts
@@ -0,0 +1,126 @@
+const STORAGE_KEY = "openchamber_sync_perf"
+
+declare global {
+  interface Window {
+    __openchamberSyncPerformance?: {
+      getSnapshot: () => SyncPerformanceCounters | null
+      reset: () => void
+    }
+  }
+}
+
+export type SyncPerformanceCounters = {
+  pipelineRawEvents: number
+  pipelineCoalescedEvents: number
+  pipelineDeliveredEvents: number
+  reducerEvents: number
+  reducerChangedEvents: number
+  directoryStorePublications: number
+  streamingFullReconciliations: number
+  streamingIncrementalReconciliations: number
+  streamingStatusEntriesVisited: number
+  streamingSessionCandidatesVisited: number
+  streamingMessagesVisited: number
+  streamingHeartbeatAttempts: number
+  streamingHeartbeatCommits: number
+  permissionChangeCallbacks: number
+  sessionMessageChangeCallbacks: number
+  sessionRenderableNotificationSkips: number
+  userMessageHistoryNotificationSkips: number
+  sessionMessageRecordNotificationSkips: number
+  materializationEnqueues: number
+  materializationEmptyAssistantEnqueues: number
+  materializationMissingMessageEnqueues: number
+  materializationMissingPartEnqueues: number
+  materializationLifecycleEnqueues: number
+  materializationPreflightSkips: number
+  materializationRequests: number
+  statusAggregationSessionEntries: number
+  statusAggregationCandidates: number
+  persistenceSerializations: number
+  persistenceStorageWrites: number
+  persistenceUtf8Bytes: number
+}
+
+const createCounters = (): SyncPerformanceCounters => ({
+  pipelineRawEvents: 0,
+  pipelineCoalescedEvents: 0,
+  pipelineDeliveredEvents: 0,
+  reducerEvents: 0,
+  reducerChangedEvents: 0,
+  directoryStorePublications: 0,
+  streamingFullReconciliations: 0,
+  streamingIncrementalReconciliations: 0,
+  streamingStatusEntriesVisited: 0,
+  streamingSessionCandidatesVisited: 0,
+  streamingMessagesVisited: 0,
+  streamingHeartbeatAttempts: 0,
+  streamingHeartbeatCommits: 0,
+  permissionChangeCallbacks: 0,
+  sessionMessageChangeCallbacks: 0,
+  sessionRenderableNotificationSkips: 0,
+  userMessageHistoryNotificationSkips: 0,
+  sessionMessageRecordNotificationSkips: 0,
+  materializationEnqueues: 0,
+  materializationEmptyAssistantEnqueues: 0,
+  materializationMissingMessageEnqueues: 0,
+  materializationMissingPartEnqueues: 0,
+  materializationLifecycleEnqueues: 0,
+  materializationPreflightSkips: 0,
+  materializationRequests: 0,
+  statusAggregationSessionEntries: 0,
+  statusAggregationCandidates: 0,
+  persistenceSerializations: 0,
+  persistenceStorageWrites: 0,
+  persistenceUtf8Bytes: 0,
+})
+
+const readInitialEnabled = (): boolean => {
+  if (typeof window === "undefined") return false
+  try {
+    return window.localStorage.getItem(STORAGE_KEY) === "1"
+  } catch {
+    return false
+  }
+}
+
+let activeCounters: SyncPerformanceCounters | null = readInitialEnabled() ? createCounters() : null
+
+export function setSyncPerformanceDiagnosticsEnabled(enabled: boolean): void {
+  activeCounters = enabled ? createCounters() : null
+}
+
+export function resetSyncPerformanceDiagnostics(): void {
+  if (activeCounters) activeCounters = createCounters()
+}
+
+export function getSyncPerformanceDiagnostics(): SyncPerformanceCounters | null {
+  return activeCounters ? { ...activeCounters } : null
+}
+
+export function countSyncPerformance(
+  counter: keyof SyncPerformanceCounters,
+  amount = 1,
+): void {
+  const counters = activeCounters
+  if (!counters) return
+  counters[counter] += amount
+}
+
+export function countSyncPersistenceSerialization(serialized: string): void {
+  const counters = activeCounters
+  if (!counters) return
+  counters.persistenceSerializations += 1
+  counters.persistenceUtf8Bytes += new TextEncoder().encode(serialized).byteLength
+}
+
+export function countSyncPersistenceStorageWrite(): void {
+  if (activeCounters) activeCounters.persistenceStorageWrites += 1
+}
+
+if (typeof window !== "undefined") {
+  window.__openchamberSyncPerformance = {
+    getSnapshot: getSyncPerformanceDiagnostics,
+    reset: resetSyncPerformanceDiagnostics,
+  }
+}
diff --git a/packages/ui/src/sync/persist-cache.test.ts b/packages/ui/src/sync/persist-cache.test.ts
new file mode 100644
index 00000000..7830f5f5
--- /dev/null
+++ b/packages/ui/src/sync/persist-cache.test.ts
@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import type { Session } from "@opencode-ai/sdk/v2/client"
+import { switchRuntimeEndpoint } from "@/lib/runtime-switch"
+import { persistSessions, readDirCache } from "./persist-cache"
+import { getSyncPerformanceDiagnostics, setSyncPerformanceDiagnosticsEnabled } from "./performance-diagnostics"
+
+class TestStorage implements Storage {
+  readonly values = new Map<string, string>()
+  maxValueLength = Number.POSITIVE_INFINITY
+  writes = 0
+
+  get length(): number {
+    return this.values.size
+  }
+
+  clear(): void {
+    this.values.clear()
+  }
+
+  getItem(key: string): string | null {
+    return this.values.get(key) ?? null
+  }
+
+  key(index: number): string | null {
+    return [...this.values.keys()][index] ?? null
+  }
+
+  removeItem(key: string): void {
+    this.values.delete(key)
+  }
+
+  setItem(key: string, value: string): void {
+    if (value.length > this.maxValueLength) throw new DOMException("Quota exceeded", "QuotaExceededError")
+    this.writes += 1
+    this.values.set(key, value)
+  }
+}
+
+const originalLocalStorage = globalThis.localStorage
+const directory = "/repo"
+let storage: TestStorage
+const waitForPersistence = () => new Promise((resolve) => setTimeout(resolve, 70))
+
+const hashCode = (value: string): string => {
+  let hash = 0
+  for (let index = 0; index < value.length; index += 1) {
+    hash = ((hash << 5) - hash) + value.charCodeAt(index)
+    hash |= 0
+  }
+  return Math.abs(hash).toString(36)
+}
+
+const legacySessionKey = (value: string): string => {
+  const head = value.slice(0, 12).replace(/[^a-zA-Z0-9]/g, "_")
+  return `oc.dir.${head}.${hashCode(value)}.sessions`
+}
+
+const session = (
+  index: number,
+  updated: number,
+  title = `Session ${index}`,
+  sessionDirectory = directory,
+): Session => ({
+  id: `ses_${String(index).padStart(3, "0")}`,
+  projectID: "project",
+  directory: sessionDirectory,
+  title,
+  version: "1",
+  time: { created: updated - 1, updated },
+} as Session)
+
+beforeEach(() => {
+  storage = new TestStorage()
+  Object.defineProperty(globalThis, "localStorage", { configurable: true, value: storage })
+  switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-default.test", runtimeKey: "runtime-default" })
+})
+
+afterEach(() => {
+  setSyncPerformanceDiagnosticsEnabled(false)
+  Object.defineProperty(globalThis, "localStorage", { configurable: true, value: originalLocalStorage })
+})
+
+describe("persisted directory sessions", () => {
+  test("keeps the 50 most recently updated sessions across restart reads", async () => {
+    const sessions = Array.from({ length: 60 }, (_, updated) => session(59 - updated, updated))
+
+    persistSessions(directory, sessions)
+    await waitForPersistence()
+
+    const cached = readDirCache(directory).sessions ?? []
+    const cachedIds = new Set(cached.map((item) => item.id))
+    const expectedIds = new Set(Array.from({ length: 50 }, (_, index) => session(index, index).id))
+    expect(cached).toHaveLength(50)
+    expect(cachedIds).toEqual(expectedIds)
+  })
+
+  test("persists authoritative empty instead of resurrecting legacy sessions", () => {
+    const legacyKey = legacySessionKey(directory)
+    storage.setItem(legacyKey, JSON.stringify([session(1, 1)]))
+
+    persistSessions(directory, [])
+
+    expect(readDirCache(directory).sessions).toEqual([])
+    expect(storage.getItem(legacyKey)).toBeNull()
+  })
+
+  test("replaces stale data with a smaller recent snapshot when quota is tight", async () => {
+    persistSessions(directory, [session(1, 1, "old")])
+    await waitForPersistence()
+    storage.maxValueLength = 700
+    const sessions = Array.from({ length: 50 }, (_, index) => session(index + 10, index + 10, "x".repeat(80)))
+
+    persistSessions(directory, sessions)
+    await waitForPersistence()
+
+    const cached = readDirCache(directory).sessions ?? []
+    expect(cached.length).toBeGreaterThan(0)
+    expect(cached.length).toBeLessThan(50)
+    expect(cached.some((item) => item.title === "old")).toBe(false)
+    expect(cached.map((item) => item.id)).toEqual(sessions.slice(-cached.length).map((item) => item.id))
+  })
+
+  test("isolates snapshots by runtime and directory", async () => {
+    const otherDirectory = "/other-repo"
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-a.test", runtimeKey: "runtime-a" })
+    persistSessions(directory, [session(1, 1, "runtime A")])
+    persistSessions(otherDirectory, [session(2, 2, "other directory", otherDirectory)])
+    await waitForPersistence()
+
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-b.test", runtimeKey: "runtime-b" })
+    persistSessions(directory, [session(3, 3, "runtime B")])
+    await waitForPersistence()
+
+    expect(readDirCache(directory).sessions?.map((item) => item.title)).toEqual(["runtime B"])
+    expect(readDirCache(otherDirectory).sessions).toBe(undefined)
+
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-a.test", runtimeKey: "runtime-a" })
+    expect(readDirCache(directory).sessions?.map((item) => item.title)).toEqual(["runtime A"])
+    expect(readDirCache(otherDirectory).sessions?.map((item) => item.title)).toEqual(["other directory"])
+  })
+
+  test("coalesces burst updates per runtime and directory while serving the latest pending value", async () => {
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-coalesce.test", runtimeKey: "runtime-coalesce" })
+    const writesBefore = storage.writes
+    setSyncPerformanceDiagnosticsEnabled(true)
+
+    for (let index = 0; index < 100; index += 1) {
+      persistSessions(directory, [session(index, index)])
+    }
+
+    expect(readDirCache(directory).sessions?.[0]?.id).toBe(session(99, 99).id)
+    expect(storage.writes).toBe(writesBefore)
+    await waitForPersistence()
+    expect(storage.writes - writesBefore).toBe(1)
+    expect(readDirCache(directory).sessions?.[0]?.id).toBe(session(99, 99).id)
+    expect(getSyncPerformanceDiagnostics()?.persistenceSerializations).toBe(1)
+    expect(getSyncPerformanceDiagnostics()?.persistenceStorageWrites).toBe(1)
+  })
+
+  test("writes authoritative empty immediately and prevents an older pending snapshot from returning", async () => {
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-empty.test", runtimeKey: "runtime-empty" })
+    persistSessions(directory, [session(1, 1)])
+    persistSessions(directory, [])
+
+    expect(readDirCache(directory).sessions).toEqual([])
+    await waitForPersistence()
+    expect(readDirCache(directory).sessions).toEqual([])
+  })
+
+  test("does not commit a pending snapshot after its runtime is no longer active", async () => {
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-stale-a.test", runtimeKey: "runtime-stale-a" })
+    persistSessions(directory, [session(1, 1, "runtime stale A")])
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-stale-b.test", runtimeKey: "runtime-stale-b" })
+
+    await waitForPersistence()
+    switchRuntimeEndpoint({ apiBaseUrl: "https://runtime-stale-a.test", runtimeKey: "runtime-stale-a" })
+    expect(readDirCache(directory).sessions).toBe(undefined)
+  })
+})
diff --git a/packages/ui/src/sync/persist-cache.ts b/packages/ui/src/sync/persist-cache.ts
index 35808852..a6fe49c0 100644
--- a/packages/ui/src/sync/persist-cache.ts
+++ b/packages/ui/src/sync/persist-cache.ts
@@ -1,17 +1,30 @@
 /**
  * Persisted child-store metadata caches.
  *
- * VCS info, project metadata, and icons are cached to localStorage
- * per directory so they survive page reloads.
- * Only metadata is persisted — session/message/part data is always fresh
- * from the server via SSE bootstrap.
+ * VCS info, project metadata, icons, and a bounded session-list snapshot are
+ * cached to localStorage per runtime and directory so they survive reloads.
+ * Message/part data is always loaded from the server.
  */
 
 import type { Session, VcsInfo } from "@opencode-ai/sdk/v2/client"
 import type { ProjectMeta } from "./types"
+import { getRuntimeKey, subscribeRuntimeEndpointWillChange } from "@/lib/runtime-switch"
+import { countSyncPersistenceSerialization, countSyncPersistenceStorageWrite } from "./performance-diagnostics"
 
 /** Cap persisted session lists so localStorage stays bounded per directory. */
 const PERSISTED_SESSION_LIMIT = 50
+const SESSION_CACHE_FALLBACK_LIMITS = [PERSISTED_SESSION_LIMIT, 25, 10, 5, 1] as const
+const SESSION_PERSIST_DEBOUNCE_MS = 50
+
+type PendingSessionWrite = {
+  runtimeKey: string
+  key: string
+  legacyKey: string
+  sessions: Session[]
+}
+
+const pendingSessionWrites = new Map<string, PendingSessionWrite>()
+let pendingSessionWriteTimer: ReturnType<typeof setTimeout> | undefined
 
 // ---------------------------------------------------------------------------
 // Storage key generation
@@ -27,11 +40,20 @@ function hashCode(str: string): string {
   return Math.abs(hash).toString(36)
 }
 
-function storagePrefix(directory: string): string {
+function legacyStoragePrefix(directory: string): string {
   const head = directory.slice(0, 12).replace(/[^a-zA-Z0-9]/g, "_")
   return `oc.dir.${head}.${hashCode(directory)}`
 }
 
+function storagePrefix(directory: string): string {
+  return storagePrefixForRuntime(getRuntimeKey() || "local", directory)
+}
+
+function storagePrefixForRuntime(runtimeKey: string, directory: string): string {
+  const head = directory.slice(0, 12).replace(/[^a-zA-Z0-9]/g, "_")
+  return `oc.dir.v2.${head}.${hashCode(`${runtimeKey}\0${directory}`)}`
+}
+
 // ---------------------------------------------------------------------------
 // Typed cache helpers
 // ---------------------------------------------------------------------------
@@ -42,9 +64,19 @@ function cacheKey(directory: string, key: CacheKey): string {
   return `${storagePrefix(directory)}.${key}`
 }
 
+function legacyCacheKey(directory: string, key: CacheKey): string {
+  return `${legacyStoragePrefix(directory)}.${key}`
+}
+
 function readCache<T>(directory: string, key: CacheKey): T | undefined {
   try {
-    const raw = localStorage.getItem(cacheKey(directory, key))
+    const currentKey = cacheKey(directory, key)
+    if (key === "sessions") {
+      const pending = pendingSessionWrites.get(currentKey)
+      if (pending) return pending.sessions as T
+    }
+    const raw = localStorage.getItem(currentKey)
+      ?? localStorage.getItem(legacyCacheKey(directory, key))
     if (!raw) return undefined
     return JSON.parse(raw) as T
   } catch {
@@ -54,17 +86,121 @@ function readCache<T>(directory: string, key: CacheKey): T | undefined {
 
 function writeCache<T>(directory: string, key: CacheKey, value: T | undefined): void {
   try {
-    const k = cacheKey(directory, key)
+    const currentKey = cacheKey(directory, key)
     if (value === undefined) {
-      localStorage.removeItem(k)
+      localStorage.removeItem(currentKey)
+      localStorage.removeItem(legacyCacheKey(directory, key))
     } else {
-      localStorage.setItem(k, JSON.stringify(value))
+      localStorage.setItem(currentKey, JSON.stringify(value))
+      localStorage.removeItem(legacyCacheKey(directory, key))
     }
   } catch {
     // localStorage quota exceeded — ignore
   }
 }
 
+function sessionRecencyTimestamp(session: Session): number {
+  const updated = session.time?.updated
+  if (typeof updated === "number" && Number.isFinite(updated)) return updated
+  const created = session.time?.created
+  return typeof created === "number" && Number.isFinite(created) ? created : 0
+}
+
+function selectRecentSessions(sessions: Session[], limit: number): Session[] {
+  if (sessions.length <= limit) return sessions
+  const recentIds = new Set(
+    [...sessions]
+      .sort((left, right) => sessionRecencyTimestamp(right) - sessionRecencyTimestamp(left) || right.id.localeCompare(left.id))
+      .slice(0, limit)
+      .map((session) => session.id),
+  )
+  return sessions.filter((session) => recentIds.has(session.id))
+}
+
+function tryWriteCacheValue<T>(key: string, legacyKey: string, value: T): boolean {
+  try {
+    const serialized = JSON.stringify(value)
+    countSyncPersistenceSerialization(serialized)
+    countSyncPersistenceStorageWrite()
+    localStorage.setItem(key, serialized)
+    localStorage.removeItem(legacyKey)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function writeSessionCache(key: string, legacyKey: string, sessions: Session[]): void {
+  const recentSessions = selectRecentSessions(sessions, PERSISTED_SESSION_LIMIT)
+  if (tryWriteCacheValue(key, legacyKey, recentSessions)) return
+
+  // Replacing a stale value can fail when unrelated localStorage data has
+  // grown. Remove that value and retain as much recent history as still fits.
+  try {
+    localStorage.removeItem(key)
+    localStorage.removeItem(legacyKey)
+  } catch {
+    return
+  }
+
+  for (const limit of SESSION_CACHE_FALLBACK_LIMITS) {
+    const candidate = selectRecentSessions(recentSessions, limit)
+    if (tryWriteCacheValue(key, legacyKey, candidate)) return
+  }
+
+  // An empty v2 value is a tombstone: never resurrect stale legacy sessions.
+  tryWriteCacheValue(key, legacyKey, [])
+}
+
+function flushPendingSessionWrites(): void {
+  if (pendingSessionWriteTimer !== undefined) {
+    clearTimeout(pendingSessionWriteTimer)
+    pendingSessionWriteTimer = undefined
+  }
+  if (pendingSessionWrites.size === 0) return
+  const writes = [...pendingSessionWrites.values()]
+  pendingSessionWrites.clear()
+  const currentRuntimeKey = getRuntimeKey() || "local"
+  for (const pending of writes) {
+    if (pending.runtimeKey !== currentRuntimeKey) continue
+    writeSessionCache(pending.key, pending.legacyKey, pending.sessions)
+  }
+}
+
+function scheduleSessionCacheWrite(directory: string, sessions: Session[]): void {
+  const runtimeKey = getRuntimeKey() || "local"
+  const key = `${storagePrefixForRuntime(runtimeKey, directory)}.sessions`
+  for (const [pendingKey, pending] of pendingSessionWrites) {
+    if (pending.runtimeKey !== runtimeKey) pendingSessionWrites.delete(pendingKey)
+  }
+  pendingSessionWrites.set(key, { runtimeKey, key, legacyKey: legacyCacheKey(directory, "sessions"), sessions })
+  if (pendingSessionWriteTimer !== undefined) return
+  pendingSessionWriteTimer = setTimeout(flushPendingSessionWrites, SESSION_PERSIST_DEBOUNCE_MS)
+}
+
+function cancelPendingSessionWrites(runtimeKey: string): void {
+  for (const [key, pending] of pendingSessionWrites) {
+    if (pending.runtimeKey === runtimeKey) pendingSessionWrites.delete(key)
+  }
+  if (pendingSessionWrites.size === 0 && pendingSessionWriteTimer !== undefined) {
+    clearTimeout(pendingSessionWriteTimer)
+    pendingSessionWriteTimer = undefined
+  }
+}
+
+subscribeRuntimeEndpointWillChange(({ previousRuntimeKey }) => cancelPendingSessionWrites(previousRuntimeKey))
+
+if (typeof window !== "undefined") {
+  window.addEventListener("pagehide", flushPendingSessionWrites, { capture: true })
+  window.addEventListener("beforeunload", flushPendingSessionWrites, { capture: true })
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") flushPendingSessionWrites()
+    })
+    document.addEventListener("freeze", flushPendingSessionWrites)
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -91,15 +227,18 @@ export function readDirCache(directory: string): PersistedDirCache {
  * can paint chats instantly on cold start. Refreshed by bootstrap loadSessions.
  */
 export function persistSessions(directory: string, sessions: Session[] | undefined): void {
-  if (!sessions || sessions.length === 0) {
+  const key = cacheKey(directory, "sessions")
+  if (!sessions) {
+    pendingSessionWrites.delete(key)
     writeCache(directory, "sessions", undefined)
     return
   }
-  // Keep the most recent N by id (ids are time-ordered hex) to bound storage.
-  const capped = sessions.length > PERSISTED_SESSION_LIMIT
-    ? [...sessions].sort((a, b) => (a.id < b.id ? 1 : a.id > b.id ? -1 : 0)).slice(0, PERSISTED_SESSION_LIMIT)
-    : sessions
-  writeCache(directory, "sessions", capped)
+  if (sessions.length === 0) {
+    pendingSessionWrites.delete(key)
+    writeSessionCache(key, legacyCacheKey(directory, "sessions"), sessions)
+    return
+  }
+  scheduleSessionCacheWrite(directory, sessions)
 }
 
 /** Write vcs info to cache */
diff --git a/packages/ui/src/sync/reconnect-recovery.test.ts b/packages/ui/src/sync/reconnect-recovery.test.ts
index 6bbbbae1..e06410c3 100644
--- a/packages/ui/src/sync/reconnect-recovery.test.ts
+++ b/packages/ui/src/sync/reconnect-recovery.test.ts
@@ -110,4 +110,50 @@ describe("mergeBootstrapSessions", () => {
       rootCount: 1,
     })
   })
+
+  test("treats a successful empty response as authoritative", () => {
+    const persisted = createSession("persisted")
+
+    expect(mergeBootstrapSessions([], [], [persisted])).toEqual({
+      sessions: [],
+      rootCount: 0,
+    })
+  })
+
+  test("preserves known children when the child-session request fails", () => {
+    const cachedParent = createSession("parent")
+    const authoritativeParent = createSession("parent", { title: "Current" })
+    const cachedChild = createSession("child", { parentID: "parent" })
+
+    expect(mergeBootstrapSessions([authoritativeParent], null, [cachedChild, cachedParent])).toEqual({
+      sessions: [cachedChild, authoritativeParent],
+      rootCount: 1,
+    })
+  })
+
+  test("overlays live session events that arrive after the request starts", () => {
+    const staleResponse = createSession("existing", { title: "Stale" })
+    const liveUpdate = createSession("existing", { title: "Live" })
+    const liveCreate = createSession("new")
+
+    expect(mergeBootstrapSessions([staleResponse], [], [liveUpdate, liveCreate], {
+      baselineRevision: 4,
+      eventRevision: { existing: 5, new: 6 },
+    })).toEqual({
+      sessions: [liveUpdate, liveCreate],
+      rootCount: 2,
+    })
+  })
+
+  test("does not resurrect a session deleted after the request starts", () => {
+    const deleted = createSession("deleted")
+
+    expect(mergeBootstrapSessions([deleted], [], [], {
+      baselineRevision: 2,
+      deletedRevision: { deleted: 3 },
+    })).toEqual({
+      sessions: [],
+      rootCount: 0,
+    })
+  })
 })
diff --git a/packages/ui/src/sync/reconnect-recovery.ts b/packages/ui/src/sync/reconnect-recovery.ts
index da1379c6..f87f0bcc 100644
--- a/packages/ui/src/sync/reconnect-recovery.ts
+++ b/packages/ui/src/sync/reconnect-recovery.ts
@@ -19,33 +19,72 @@ type ReconnectCandidateOptions = {
   viewedSession?: ViewedSessionMaterializationTarget | null
 }
 
+type BootstrapSessionRevisionOptions = {
+  baselineRevision: number
+  eventRevision?: Record<string, number>
+  deletedRevision?: Record<string, number>
+}
+
+const getParentId = (session: Session): string | null | undefined => (
+  (session as Session & { parentID?: string | null }).parentID
+)
+
+const includeAncestorSessions = (
+  parentIds: string[],
+  includedIds: Set<string>,
+  sessionsById: Map<string, Session>,
+  excludedIds?: ReadonlySet<string>,
+): void => {
+  while (parentIds.length > 0) {
+    const parentId = parentIds.pop()
+    if (!parentId || includedIds.has(parentId) || excludedIds?.has(parentId)) continue
+    const parent = sessionsById.get(parentId)
+    if (!parent) continue
+    includedIds.add(parentId)
+    const ancestorId = getParentId(parent)
+    if (ancestorId) parentIds.push(ancestorId)
+  }
+}
+
 export function mergeBootstrapSessions(
   rootSessions: Session[],
-  allSessions: Session[],
+  allSessions: Session[] | null,
   existingSessions: Session[],
+  revisions?: BootstrapSessionRevisionOptions,
 ): { sessions: Session[]; rootCount: number } {
+  const completeSessions = allSessions ?? existingSessions.filter(
+    (session) => Boolean(getParentId(session)),
+  )
   const rootIds = new Set(rootSessions.map((session) => session.id))
   const sessionsById = new Map(existingSessions.map((session) => [session.id, session]))
-  for (const session of allSessions) sessionsById.set(session.id, session)
+  for (const session of completeSessions) sessionsById.set(session.id, session)
   for (const session of rootSessions) sessionsById.set(session.id, session)
 
   const includedIds = new Set(rootIds)
   const pendingParentIds: string[] = []
-  for (const session of allSessions) {
-    const parentId = (session as Session & { parentID?: string | null }).parentID
+  for (const session of completeSessions) {
+    const parentId = getParentId(session)
     if (!parentId) continue
     includedIds.add(session.id)
     pendingParentIds.push(parentId)
   }
+  includeAncestorSessions(pendingParentIds, includedIds, sessionsById)
 
-  while (pendingParentIds.length > 0) {
-    const parentId = pendingParentIds.pop()
-    if (!parentId || includedIds.has(parentId)) continue
-    const parent = sessionsById.get(parentId)
-    if (!parent) continue
-    includedIds.add(parentId)
-    const ancestorId = (parent as Session & { parentID?: string | null }).parentID
-    if (ancestorId) pendingParentIds.push(ancestorId)
+  if (revisions) {
+    const deletedIds = new Set(
+      Object.entries(revisions.deletedRevision ?? {})
+        .filter(([, revision]) => revision > revisions.baselineRevision)
+        .map(([sessionId]) => sessionId),
+    )
+    for (const session of existingSessions) {
+      if ((revisions.eventRevision?.[session.id] ?? 0) <= revisions.baselineRevision) continue
+      sessionsById.set(session.id, session)
+      includedIds.add(session.id)
+      const parentId = getParentId(session)
+      if (parentId) pendingParentIds.push(parentId)
+    }
+    for (const sessionId of deletedIds) includedIds.delete(sessionId)
+    includeAncestorSessions(pendingParentIds, includedIds, sessionsById, deletedIds)
   }
 
   const sessions = [...includedIds]
@@ -53,7 +92,7 @@ export function mergeBootstrapSessions(
     .filter((session): session is Session => Boolean(session))
     .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
   const rootCount = sessions.reduce((count, session) => (
-    (session as Session & { parentID?: string | null }).parentID ? count : count + 1
+    getParentId(session) ? count : count + 1
   ), 0)
 
   return { sessions, rootCount }
@@ -81,7 +120,7 @@ export function getReconnectCandidateSessionIds(state: ReconnectMaterializationS
 
   const parentIds = new Set<string>()
   for (const session of state.session) {
-    const parentId = (session as Session & { parentID?: string | null }).parentID
+    const parentId = getParentId(session)
     if (parentId) {
       parentIds.add(parentId)
     }
diff --git a/packages/ui/src/sync/session-actions.test.ts b/packages/ui/src/sync/session-actions.test.ts
index 8e862696..ddcd39e8 100644
--- a/packages/ui/src/sync/session-actions.test.ts
+++ b/packages/ui/src/sync/session-actions.test.ts
@@ -12,7 +12,10 @@ let questionRejectError: unknown | null = null
 let sessionShareResult: { data?: unknown; error?: unknown; response?: { status?: number } } = {}
 let sessionUpdateResult: { data?: unknown; error?: unknown; response?: { status?: number } } = {}
 let sessionMessagesResult: { data?: unknown; error?: unknown; response?: { status?: number } } = { data: [] }
+let sessionDeleteError: unknown | null = null
 const globalUpsertedSessions: unknown[] = []
+const globalRemovedSessionIds: string[] = []
+const deletedCleanupIdentities: Array<{ runtimeKey: string; directory: string; sessionId: string }> = []
 const movedSessionDirectories: Array<{ sessionID: string; directory: string }> = []
 
 const mockScopedClient = {
@@ -135,6 +138,11 @@ mock.module("@/lib/opencode/client", () => ({
       replyCalls.push({ method: "session.update", params: { sessionID: sessionId, ...changes, directory } })
       return Promise.resolve(sessionUpdateResult.data)
     }),
+    deleteSession: mock((sessionId: string, directory?: string | null) => {
+      replyCalls.push({ method: "session.delete", params: { sessionID: sessionId, directory } })
+      if (sessionDeleteError) throw sessionDeleteError
+      return Promise.resolve(true)
+    }),
   },
 }))
 
@@ -157,6 +165,9 @@ mock.module("./session-ui-store", () => ({
         if (sessionId === "session-b") return "/other/project"
         return null
       },
+      currentSessionId: null,
+      setCurrentSession: () => {},
+      setWorktreeMetadata: () => {},
       setSessionDirectory: (sessionID: string, directory: string) => {
         movedSessionDirectories.push({ sessionID, directory })
       },
@@ -185,6 +196,7 @@ mock.module("./input-store", () => ({
 }))
 
 mock.module("@/stores/useGlobalSessionsStore", () => ({
+  resolveGlobalSessionDirectory: (session: SessionWithDirectory) => session.directory ?? session.project?.worktree ?? null,
   mergeSessionDirectoryMetadata: (incoming: Session, existing?: SessionWithDirectory | null): SessionWithDirectory => {
     if (!existing) return incoming as SessionWithDirectory
     const next = { ...(incoming as SessionWithDirectory) }
@@ -197,13 +209,24 @@ mock.module("@/stores/useGlobalSessionsStore", () => ({
   },
   useGlobalSessionsStore: {
     getState: () => ({
+      activeSessions: [],
+      archivedSessions: [],
       upsertSession: (session: unknown) => {
         globalUpsertedSessions.push(session)
       },
+      removeSessions: (ids: Iterable<string>) => {
+        globalRemovedSessionIds.push(...ids)
+      },
     }),
   },
 }))
 
+mock.module("./session-deletion-cleanup", () => ({
+  cleanupPersistedSessionState: (identity: { runtimeKey: string; directory: string; sessionId: string }) => {
+    deletedCleanupIdentities.push(identity)
+  },
+}))
+
 mock.module("./sync-refs", () => ({
   registerSessionDirectory: (sessionID: string, directory: string) => {
     registeredSessionDirectories.push({ sessionID, directory })
@@ -328,6 +351,75 @@ describe("moveSessionToDirectory", () => {
   })
 })
 
+describe("confirmed session removal", () => {
+  beforeEach(() => {
+    replyCalls.length = 0
+    globalUpsertedSessions.length = 0
+    globalRemovedSessionIds.length = 0
+    deletedCleanupIdentities.length = 0
+    sessionDeleteError = null
+    sessionUpdateResult = {}
+  })
+
+  test("does not remove live or persisted state when delete fails", async () => {
+    sessionDeleteError = new Error("delete failed")
+    const source = createStore({}, {
+      session: [{ id: "session-a", directory: "/test/project", time: { created: 1 } } as Session],
+    })
+    const { deleteSession, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    expect(await deleteSession("session-a")).toBe(false)
+    expect(source.getState().session.map((item) => item.id)).toEqual(["session-a"])
+    expect(globalRemovedSessionIds).toEqual([])
+    expect(deletedCleanupIdentities).toEqual([])
+  })
+
+  test("cleans persisted state after the server confirms deletion", async () => {
+    const source = createStore({}, {
+      session: [{ id: "session-a", directory: "/test/project", time: { created: 1 } } as Session],
+    })
+    const { deleteSession, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    expect(await deleteSession("session-a")).toBe(true)
+    expect(source.getState().session).toEqual([])
+    expect(globalRemovedSessionIds).toEqual(["session-a"])
+    expect(deletedCleanupIdentities).toHaveLength(1)
+    expect({
+      directory: deletedCleanupIdentities[0]?.directory,
+      sessionId: deletedCleanupIdentities[0]?.sessionId,
+    }).toEqual({ directory: "/test/project", sessionId: "session-a" })
+  })
+
+  test("does not archive locally until the server returns the archived session", async () => {
+    const source = createStore({}, {
+      session: [{ id: "session-a", directory: "/test/project", time: { created: 1 } } as Session],
+    })
+    const { archiveSession, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    expect(await archiveSession("session-a")).toBe(false)
+    expect(source.getState().session.map((item) => item.id)).toEqual(["session-a"])
+    expect(globalUpsertedSessions).toEqual([])
+  })
+
+  test("moves the session to archived state after server confirmation", async () => {
+    sessionUpdateResult = {
+      data: { id: "session-a", directory: "/test/project", time: { created: 1, archived: 2 } } as Session,
+    }
+    const source = createStore({}, {
+      session: [{ id: "session-a", directory: "/test/project", time: { created: 1 } } as Session],
+    })
+    const { archiveSession, setActionRefs } = await import("./session-actions")
+    setActionRefs(mockSdk as unknown as OpencodeClient, createChildStores([["/test/project", source]]), () => "/test/project")
+
+    expect(await archiveSession("session-a")).toBe(true)
+    expect(source.getState().session).toEqual([])
+    expect((globalUpsertedSessions[0] as Session)?.time?.archived).toBe(2)
+  })
+})
+
 describe("fetchMessagesForSession startup race", () => {
   test("does not reject before sync action refs are initialized", async () => {
     const { fetchMessagesForSession } = await import("./session-actions")
diff --git a/packages/ui/src/sync/session-actions.ts b/packages/ui/src/sync/session-actions.ts
index 48e28481..1826a1d9 100644
--- a/packages/ui/src/sync/session-actions.ts
+++ b/packages/ui/src/sync/session-actions.ts
@@ -10,14 +10,11 @@ import { useInputStore } from "./input-store"
 import type { ChildStoreManager } from "./child-store"
 import { computeSubtreeIds } from "./scoped-blocking-requests"
 import { opencodeClient } from "@/lib/opencode/client"
-import { mergeSessionDirectoryMetadata, useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
+import { mergeSessionDirectoryMetadata, resolveGlobalSessionDirectory, useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
 import { useConfigStore } from "@/stores/useConfigStore"
 import { registerSessionDirectory } from "./sync-refs"
 import { isSyntheticPart } from "@/lib/messages/synthetic"
-import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
-import { retry } from "./retry"
-import { isVSCodeRuntime } from "@/lib/desktop"
-import { isMobileSurfaceRuntime } from "@/lib/runtimeSurface"
+import { materializeSessionSnapshots } from "./materialization"
 import { stripMessageDiffSnapshots, stripSessionDiffSnapshots } from "./sanitize"
 import { sessionEvents } from "@/lib/sessionEvents"
 import {
@@ -28,6 +25,9 @@ import {
   type SessionMetadataRecord,
 } from "@/lib/sessionReviewMetadata"
 import { withContextObligatoryMessage, type ContextObligatoryMessage } from "@/lib/contextObligatoryMessages"
+import { getImperativeSessionMessageLoader } from "./session-message-loader"
+import { cleanupPersistedSessionState } from "./session-deletion-cleanup"
+import { getRuntimeKey } from "@/lib/runtime-switch"
 
 const MESSAGE_REFETCH_LIMIT = 100
 const SEND_CONFIRMATION_REFETCH_LIMIT = 30
@@ -49,6 +49,37 @@ let _optimisticAdd: ((input: OptimisticAddInput) => void) | null = null
 let _optimisticRemove: ((input: OptimisticRemoveInput) => void) | null = null
 let _optimisticConfirm: ((input: OptimisticConfirmInput) => void) | null = null
 
+function sessionMutationPatch(
+  state: ReturnType<DirectoryStoreApi["getState"]>,
+  sessionId: string,
+  deleted: boolean,
+) {
+  const revision = (state.sessionRevision ?? 0) + 1
+  const sessionEventRevision = { ...(state.sessionEventRevision ?? {}) }
+  const sessionDeletedRevision = { ...(state.sessionDeletedRevision ?? {}) }
+  if (deleted) {
+    sessionDeletedRevision[sessionId] = revision
+    delete sessionEventRevision[sessionId]
+  } else {
+    sessionEventRevision[sessionId] = revision
+    delete sessionDeletedRevision[sessionId]
+  }
+  return {
+    sessionListSource: "live" as const,
+    sessionRevision: revision,
+    sessionEventRevision,
+    sessionDeletedRevision,
+  }
+}
+
+function invalidateSessionLoads(sessionId: string, directories: Iterable<string | null | undefined>): void {
+  const loader = getImperativeSessionMessageLoader()
+  if (!loader) return
+  for (const directory of new Set(directories)) {
+    if (directory) loader.invalidateSession({ directory, sessionID: sessionId })
+  }
+}
+
 const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
 type SdkResult<T> = {
@@ -263,6 +294,7 @@ function reconcileSessionMove(
     question: questions.source,
     message: messages.source,
     part: parts.source,
+    ...sessionMutationPatch(sourceState, session.id, true),
   })
   destinationStore.setState({
     session: destinationSessions,
@@ -276,6 +308,7 @@ function reconcileSessionMove(
     question: questions.destination,
     message: messages.destination,
     part: parts.destination,
+    ...sessionMutationPatch(destinationState, session.id, false),
   })
 
   return movedSession
@@ -294,6 +327,8 @@ export async function moveSessionToDirectory(
   })
   assertSdkSuccess(result, "Move session")
 
+  invalidateSessionLoads(session.id, [sourceDirectory, destinationDirectory])
+
   const moved = reconcileSessionMove(session, sourceDirectory, destinationDirectory)
 
   registerSessionDirectory(session.id, destinationDirectory)
@@ -368,7 +403,6 @@ export async function waitForConnectionOrThrow(): Promise<void> {
 
 type SessionListSnapshot = {
   directory: string
-  sessions: Session[]
 }
 
 type DirectoryStoreApi = ReturnType<ChildStoreManager["ensureChild"]>
@@ -378,14 +412,11 @@ function getGlobalSessionSnapshot(sessionId: string): Session | null {
   return [...global.activeSessions, ...global.archivedSessions].find((session) => session.id === sessionId) ?? null
 }
 
-function restoreGlobalSessionSnapshot(session: Session | null): void {
-  if (!session) return
-  useGlobalSessionsStore.getState().upsertSession(session)
-}
-
 function getSessionDirectory(sessionId: string): string | undefined {
+  const globalSession = getGlobalSessionSnapshot(sessionId)
   return findSessionDirectoryInChildStores(sessionId)
     || useSessionUIStore.getState().getDirectoryForSession(sessionId)
+    || (globalSession ? resolveGlobalSessionDirectory(globalSession) ?? undefined : undefined)
     || dir()
 }
 
@@ -622,8 +653,8 @@ async function cleanupReviewMetadataBeforeDelete(sessionId: string, directory?:
   }
 }
 
-/** Optimistically remove a session from every live child store that has it. */
-function optimisticRemoveSession(sessionId: string, preferredDirectory?: string): SessionListSnapshot[] {
+/** Remove a server-confirmed session from every live child store that has it. */
+function removeSessionFromLiveStores(sessionId: string, preferredDirectory?: string): SessionListSnapshot[] {
   if (!_childStores) return []
 
   const snapshots: SessionListSnapshot[] = []
@@ -648,45 +679,46 @@ function optimisticRemoveSession(sessionId: string, preferredDirectory?: string)
     if (!current.session.some((session) => session.id === sessionId)) {
       continue
     }
-    snapshots.push({ directory, sessions: current.session })
-    store.setState({ session: current.session.filter((session) => session.id !== sessionId) })
+    snapshots.push({ directory })
+    store.setState({
+      session: current.session.filter((session) => session.id !== sessionId),
+      ...sessionMutationPatch(current, sessionId, true),
+    })
   }
 
   return snapshots
 }
 
-function restoreSessionListSnapshots(snapshots: SessionListSnapshot[]): void {
-  if (!_childStores) return
-  for (const snapshot of snapshots) {
-    const store = _childStores.children.get(snapshot.directory)
-    if (!store) continue
-    store.setState({ session: snapshot.sessions })
-  }
-}
-
 function cleanupSessionWorktreeMetadata(sessionId: string): void {
   useSessionUIStore.getState().setWorktreeMetadata(sessionId, null)
 }
 
+function finalizeConfirmedSessionDeletion(sessionId: string, sessionDirectory?: string): void {
+  const snapshots = removeSessionFromLiveStores(sessionId, sessionDirectory)
+  invalidateSessionLoads(sessionId, [...snapshots.map((snapshot) => snapshot.directory), sessionDirectory])
+  useGlobalSessionsStore.getState().removeSessions([sessionId])
+  const ui = useSessionUIStore.getState()
+  if (ui.currentSessionId === sessionId) ui.setCurrentSession(null)
+  cleanupSessionWorktreeMetadata(sessionId)
+  if (sessionDirectory) {
+    cleanupPersistedSessionState({
+      runtimeKey: getRuntimeKey(),
+      directory: sessionDirectory,
+      sessionId,
+    })
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function deleteSession(sessionId: string, _options?: Record<string, unknown>): Promise<boolean> {
   const sessionDirectory = getSessionDirectory(sessionId)
-  const snapshots = optimisticRemoveSession(sessionId, sessionDirectory)
-  const globalSnapshot = getGlobalSessionSnapshot(sessionId)
-  useGlobalSessionsStore.getState().removeSessions([sessionId])
-
-  const ui = useSessionUIStore.getState()
-  if (ui.currentSessionId === sessionId) {
-    ui.setCurrentSession(null)
-  }
   try {
     await cleanupReviewMetadataBeforeDelete(sessionId, sessionDirectory)
     const deleted = await opencodeClient.deleteSession(sessionId, sessionDirectory)
     if (deleted !== true) {
       throw new Error("session.delete failed: server did not confirm deletion")
     }
-    useGlobalSessionsStore.getState().removeSessions([sessionId])
-    cleanupSessionWorktreeMetadata(sessionId)
+    finalizeConfirmedSessionDeletion(sessionId, sessionDirectory)
     return true
   } catch (error) {
     console.error("[session-actions] deleteSession failed", error)
@@ -694,66 +726,50 @@ export async function deleteSession(sessionId: string, _options?: Record<string,
     // Subsequent delete attempts for those children return 404; treat as
     // success since the session was already deleted by the cascade.
     if ((error as { status?: number })?.status === 404) {
-      cleanupSessionWorktreeMetadata(sessionId)
+      finalizeConfirmedSessionDeletion(sessionId, sessionDirectory)
       return true
     }
-    restoreSessionListSnapshots(snapshots)
-    restoreGlobalSessionSnapshot(globalSnapshot)
     return false
   }
 }
 
 /** Delete a session specifying which directory it lives in. Used by agent groups for cross-directory deletes. */
 export async function deleteSessionInDirectory(sessionId: string, directory: string): Promise<boolean> {
-  if (!_childStores) return false
-  const snapshots = optimisticRemoveSession(sessionId, directory)
-  const globalSnapshot = getGlobalSessionSnapshot(sessionId)
-  useGlobalSessionsStore.getState().removeSessions([sessionId])
-  const ui = useSessionUIStore.getState()
-  if (ui.currentSessionId === sessionId) ui.setCurrentSession(null)
   try {
     await cleanupReviewMetadataBeforeDelete(sessionId, directory)
     const deleted = await opencodeClient.deleteSession(sessionId, directory)
     if (deleted !== true) {
       throw new Error("session.delete failed: server did not confirm deletion")
     }
-    useGlobalSessionsStore.getState().removeSessions([sessionId])
-    cleanupSessionWorktreeMetadata(sessionId)
+    finalizeConfirmedSessionDeletion(sessionId, directory)
     return true
   } catch (error) {
     console.error("[session-actions] deleteSessionInDirectory failed", error)
     if ((error as { status?: number })?.status === 404) {
-      cleanupSessionWorktreeMetadata(sessionId)
+      finalizeConfirmedSessionDeletion(sessionId, directory)
       return true
     }
-    restoreSessionListSnapshots(snapshots)
-    restoreGlobalSessionSnapshot(globalSnapshot)
     return false
   }
 }
 
 export async function archiveSession(sessionId: string): Promise<boolean> {
   const sessionDirectory = getSessionDirectory(sessionId)
-  const snapshots = optimisticRemoveSession(sessionId, sessionDirectory)
-  const globalSnapshot = getGlobalSessionSnapshot(sessionId)
   const archivedAt = Date.now()
-  useGlobalSessionsStore.getState().archiveSessions([sessionId], archivedAt)
-  const ui = useSessionUIStore.getState()
-  if (ui.currentSessionId === sessionId) {
-    ui.setCurrentSession(null)
-  }
   try {
     await cleanupReviewMetadataBeforeDelete(sessionId, sessionDirectory)
     const archived = await opencodeClient.updateSession(sessionId, { time: { archived: archivedAt } }, sessionDirectory)
     if (!archived) {
       throw new Error("session.update failed: server did not return the archived session")
     }
+    const snapshots = removeSessionFromLiveStores(sessionId, sessionDirectory)
+    invalidateSessionLoads(sessionId, [...snapshots.map((snapshot) => snapshot.directory), sessionDirectory])
     useGlobalSessionsStore.getState().upsertSession(archived)
+    const ui = useSessionUIStore.getState()
+    if (ui.currentSessionId === sessionId) ui.setCurrentSession(null)
     return true
   } catch (error) {
     console.error("[session-actions] archiveSession failed", error)
-    restoreSessionListSnapshots(snapshots)
-    restoreGlobalSessionSnapshot(globalSnapshot)
     return false
   }
 }
@@ -1288,6 +1304,16 @@ export async function revertToMessage(sessionId: string, messageId: string): Pro
 
 export async function refetchSessionMessages(sessionId: string): Promise<void> {
   const { store, directory } = dirStoreForSession(sessionId)
+  const loader = getImperativeSessionMessageLoader()
+  if (loader && directory) {
+    await loader.refreshTail({ directory, sessionID: sessionId }, MESSAGE_REFETCH_LIMIT)
+    const snapshot = loader.getSnapshot({ directory, sessionID: sessionId })
+    if (snapshot.status === "error") throw snapshot.error ?? new Error("Session message refresh failed")
+    return
+  }
+
+  // Actions can run in isolated tests before SyncProvider binds the shared
+  // loader. The application runtime always takes the shared path above.
   const result = await sdk().session.messages({ sessionID: sessionId, directory, limit: MESSAGE_REFETCH_LIMIT })
   const records = (assertSdkSuccess(result, "session.messages") ?? [])
     .filter((record: { info?: { id?: string } }) => !!record?.info?.id)
@@ -1393,75 +1419,11 @@ export async function forkFromMessage(sessionId: string, messageId: string): Pro
   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 loadingKey = `${resolvedDir}:${sessionID}`
-  if (FETCH_MESSAGES_LOADING.has(loadingKey)) return
-
-  FETCH_MESSAGES_LOADING.add(loadingKey)
-
-  try {
-    const s = sdk()
-    const store = directory
-      ? dirStoreForDirectory(directory)
-      : dirStore()
-
-    if (getSessionMaterializationStatus(store.getState(), sessionID).renderable) return
-
-    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
-
-    const latestState = store.getState()
-    const latestStatus = getSessionMaterializationStatus(latestState, sessionID)
-    if (latestStatus.renderable && (latestState.message[sessionID]?.length ?? 0) >= records.length) 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 },
-      )
-      if (!materialized.messagesChanged && !materialized.partsChanged) return state
-      return { message: materialized.message, part: materialized.part }
-    })
-  } catch {
-    // Transient failure — the reactive path in ChatContainer will retry
-  } finally {
-    FETCH_MESSAGES_LOADING.delete(loadingKey)
-  }
+  await getImperativeSessionMessageLoader()?.ensure(
+    { directory: resolvedDir, sessionID },
+    { reason: "navigation" },
+  )
 }
diff --git a/packages/ui/src/sync/session-deletion-cleanup.test.ts b/packages/ui/src/sync/session-deletion-cleanup.test.ts
new file mode 100644
index 00000000..276c9fd6
--- /dev/null
+++ b/packages/ui/src/sync/session-deletion-cleanup.test.ts
@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import type { Todo } from '@opencode-ai/sdk/v2/client';
+
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { createChatDraftIdentity, readChatDraft, writeChatDraft } from '@/lib/chatDraftPersistence';
+import { createMessageQueueTarget, useMessageQueueStore } from '@/stores/messageQueueStore';
+import { useSessionFoldersStore } from '@/stores/useSessionFoldersStore';
+import { useTodosPersistStore } from '@/stores/useTodosPersistStore';
+import { useInlineCommentDraftStore } from '@/stores/useInlineCommentDraftStore';
+import { isSessionPinned, useSessionPinnedStore } from '@/stores/useSessionPinnedStore';
+import { cleanupPersistedSessionState } from './session-deletion-cleanup';
+
+const todo: Todo = { content: 'persisted', status: 'pending', priority: 'medium' };
+
+describe('cleanupPersistedSessionState', () => {
+  beforeEach(() => {
+    useMessageQueueStore.setState({ queuedMessages: {}, quarantinedLegacyMessages: {} });
+    useTodosPersistStore.setState({ sessions: {} });
+    useInlineCommentDraftStore.setState({ drafts: {}, touchedAt: {} });
+    useSessionPinnedStore.setState({ ids: new Set(), touchedAt: {} });
+    useSessionFoldersStore.setState({ foldersMap: {}, collapsedFolderIds: new Set() });
+  });
+
+  test('clears queue and todos only for the deleted composite session', () => {
+    const runtimeKey = getRuntimeKey();
+    const deleted = createMessageQueueTarget('session-1', '/repo-a', runtimeKey)!;
+    const retained = createMessageQueueTarget('session-1', '/repo-b', runtimeKey)!;
+    useMessageQueueStore.getState().addToQueue(deleted, { content: 'delete' });
+    useMessageQueueStore.getState().addToQueue(retained, { content: 'retain' });
+    useTodosPersistStore.getState().setSessionTodos('/repo-a', 'session-1', [todo]);
+    useTodosPersistStore.getState().setSessionTodos('/repo-b', 'session-1', [todo]);
+    const deletedDraft = createChatDraftIdentity(runtimeKey, '/repo-a', 'session-1')!;
+    const retainedDraft = createChatDraftIdentity(runtimeKey, '/repo-b', 'session-1')!;
+    writeChatDraft(deletedDraft, 'delete', []);
+    writeChatDraft(retainedDraft, 'retain', []);
+    const inlineDraft = {
+      source: 'terminal' as const,
+      fileLabel: 'Terminal',
+      startLine: 1,
+      endLine: 1,
+      code: 'context',
+      language: 'text',
+      text: '',
+    };
+    useInlineCommentDraftStore.getState().addDraft({ directory: '/repo-a', sessionKey: 'session-1' }, inlineDraft);
+    useInlineCommentDraftStore.getState().addDraft({ directory: '/repo-b', sessionKey: 'session-1' }, inlineDraft);
+    useSessionPinnedStore.getState().toggle({ directory: '/repo-a', sessionId: 'session-1' });
+    useSessionPinnedStore.getState().toggle({ directory: '/repo-b', sessionId: 'session-1' });
+    const folder = useSessionFoldersStore.getState().createFolder('/repo-a', 'Active');
+    useSessionFoldersStore.getState().addSessionToFolder('/repo-a', folder.id, 'session-1');
+    const archivedFolder = useSessionFoldersStore.getState().createFolder('__archived__:/repo-a', 'Archived');
+    useSessionFoldersStore.getState().addSessionToFolder('__archived__:/repo-a', archivedFolder.id, 'session-1');
+
+    cleanupPersistedSessionState({ runtimeKey, directory: '/repo-a', sessionId: 'session-1' });
+
+    expect(useMessageQueueStore.getState().getQueueForTarget(deleted)).toEqual([]);
+    expect(useMessageQueueStore.getState().getQueueForTarget(retained)).toHaveLength(1);
+    expect(useTodosPersistStore.getState().getSessionTodos('/repo-a', 'session-1')).toBe(undefined);
+    expect(useTodosPersistStore.getState().getSessionTodos('/repo-b', 'session-1')).toEqual([todo]);
+    expect(readChatDraft(deletedDraft).text).toBe('');
+    expect(readChatDraft(retainedDraft).text).toBe('retain');
+    expect(useInlineCommentDraftStore.getState().getDrafts({ directory: '/repo-a', sessionKey: 'session-1' })).toEqual([]);
+    expect(useInlineCommentDraftStore.getState().getDrafts({ directory: '/repo-b', sessionKey: 'session-1' })).toHaveLength(1);
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-a', 'session-1')).toBe(false);
+    expect(isSessionPinned(useSessionPinnedStore.getState().ids, '/repo-b', 'session-1')).toBe(true);
+    expect(useSessionFoldersStore.getState().getSessionFolderId('/repo-a', 'session-1')).toBeNull();
+    expect(useSessionFoldersStore.getState().getSessionFolderId('__archived__:/repo-a', 'session-1')).toBeNull();
+  });
+
+  test('rejects stale runtime cleanup', () => {
+    const runtimeKey = getRuntimeKey();
+    useTodosPersistStore.getState().setSessionTodos('/repo', 'session-1', [todo]);
+
+    cleanupPersistedSessionState({ runtimeKey: `${runtimeKey}-stale`, directory: '/repo', sessionId: 'session-1' });
+
+    expect(useTodosPersistStore.getState().getSessionTodos('/repo', 'session-1')).toEqual([todo]);
+  });
+});
diff --git a/packages/ui/src/sync/session-deletion-cleanup.ts b/packages/ui/src/sync/session-deletion-cleanup.ts
new file mode 100644
index 00000000..e055dfa0
--- /dev/null
+++ b/packages/ui/src/sync/session-deletion-cleanup.ts
@@ -0,0 +1,24 @@
+import { getRuntimeKey } from '@/lib/runtime-switch';
+import { clearChatDraft, createChatDraftIdentity } from '@/lib/chatDraftPersistence';
+import { createMessageQueueTarget, useMessageQueueStore } from '@/stores/messageQueueStore';
+import { useSessionFoldersStore } from '@/stores/useSessionFoldersStore';
+import { useTodosPersistStore } from '@/stores/useTodosPersistStore';
+import { useInlineCommentDraftStore } from '@/stores/useInlineCommentDraftStore';
+import { useSessionPinnedStore } from '@/stores/useSessionPinnedStore';
+
+export const cleanupPersistedSessionState = (identity: {
+  runtimeKey: string;
+  directory: string;
+  sessionId: string;
+}): void => {
+  if (identity.runtimeKey !== getRuntimeKey() || !identity.directory || identity.directory === 'global' || !identity.sessionId) return;
+
+  const queueTarget = createMessageQueueTarget(identity.sessionId, identity.directory, identity.runtimeKey);
+  if (queueTarget) useMessageQueueStore.getState().clearQueue(queueTarget);
+  useTodosPersistStore.getState().clearSessionTodos(identity.runtimeKey, identity.directory, identity.sessionId);
+  useSessionFoldersStore.getState().removeSessionEverywhere(identity.runtimeKey, identity.sessionId);
+  useInlineCommentDraftStore.getState().clearSessionDrafts(identity.runtimeKey, identity.directory, identity.sessionId);
+  useSessionPinnedStore.getState().clearPinnedSession(identity.runtimeKey, identity.directory, identity.sessionId);
+  const chatDraftIdentity = createChatDraftIdentity(identity.runtimeKey, identity.directory, identity.sessionId);
+  if (chatDraftIdentity) clearChatDraft(chatDraftIdentity, true);
+};
diff --git a/packages/ui/src/sync/session-event-router.ts b/packages/ui/src/sync/session-event-router.ts
index d9eb3adb..a5a474fe 100644
--- a/packages/ui/src/sync/session-event-router.ts
+++ b/packages/ui/src/sync/session-event-router.ts
@@ -1,8 +1,40 @@
 import type { Event, Session } from "@opencode-ai/sdk/v2/client"
-import { useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
+import { isGlobalSessionRecencyOnlyUpdate, useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
+import { getRuntimeKey, subscribeRuntimeEndpointWillChange } from "@/lib/runtime-switch"
+import { streamPerfCount, streamPerfMark } from "@/stores/utils/streamDebug"
 import { stripSessionDiffSnapshots } from "./sanitize"
 import { shouldSkipStaleSessionEvent } from "./session-event-freshness"
 
+const pendingGlobalSessionUpdates = new Map<string, { runtimeKey: string; session: Session }>()
+
+const clearPendingGlobalSessionUpdates = (): void => {
+  pendingGlobalSessionUpdates.clear()
+}
+
+const flushPendingGlobalSessionUpdate = (sessionID: string): void => {
+  const update = pendingGlobalSessionUpdates.get(sessionID)
+  pendingGlobalSessionUpdates.delete(sessionID)
+  if (!update) return
+  const runtimeKey = getRuntimeKey()
+  if (update.runtimeKey !== runtimeKey) return
+  const currentSession = getGlobalSessionSnapshot(update.session.id)
+  if (
+    !currentSession
+    || shouldSkipStaleSessionEvent(currentSession, update.session)
+    || !isGlobalSessionRecencyOnlyUpdate(currentSession, update.session)
+  ) return
+  streamPerfMark("global_sessions.event_update_flush")
+  useGlobalSessionsStore.getState().upsertSession(update.session)
+  streamPerfCount("ui.global_sessions.event_update_publication")
+}
+
+const scheduleGlobalSessionUpdate = (session: Session): void => {
+  pendingGlobalSessionUpdates.set(session.id, { runtimeKey: getRuntimeKey(), session })
+  streamPerfCount("ui.global_sessions.event_update_deferred")
+}
+
+subscribeRuntimeEndpointWillChange(clearPendingGlobalSessionUpdates)
+
 const getSessionInfoFromPayload = (event: Event): Session | null => {
   if (event.type !== "session.created" && event.type !== "session.updated" && event.type !== "session.deleted") {
     return null
@@ -32,7 +64,13 @@ const getGlobalSessionSnapshot = (sessionId: string): Session | null => {
 }
 
 export const applySessionEventToGlobalSessions = (payload: Event): void => {
-  if (payload.type === "session.created" || payload.type === "session.updated") {
+  if (payload.type === "session.idle" || payload.type === "session.error") {
+    const sessionID = (payload as { properties?: { sessionID?: unknown } }).properties?.sessionID
+    if (typeof sessionID === "string") flushPendingGlobalSessionUpdate(sessionID)
+    return
+  }
+
+  if (payload.type === "session.created") {
     const session = getSessionInfoFromPayload(payload)
     if (session) {
       const currentSession = getGlobalSessionSnapshot(session.id)
@@ -43,9 +81,27 @@ export const applySessionEventToGlobalSessions = (payload: Event): void => {
     return
   }
 
+  if (payload.type === "session.updated") {
+    const session = getSessionInfoFromPayload(payload)
+    if (session) {
+      const currentSession = getGlobalSessionSnapshot(session.id)
+      if (!shouldSkipStaleSessionEvent(currentSession, session)) {
+        if (currentSession && isGlobalSessionRecencyOnlyUpdate(currentSession, session)) {
+          scheduleGlobalSessionUpdate(session)
+        } else {
+          pendingGlobalSessionUpdates.delete(session.id)
+          useGlobalSessionsStore.getState().upsertSession(session)
+          streamPerfCount("ui.global_sessions.event_update_immediate")
+        }
+      }
+    }
+    return
+  }
+
   if (payload.type === "session.deleted") {
     const sessionID = (payload as { properties?: { sessionID?: string } }).properties?.sessionID ?? getSessionInfoFromPayload(payload)?.id
     if (sessionID) {
+      pendingGlobalSessionUpdates.delete(sessionID)
       useGlobalSessionsStore.getState().removeSessions([sessionID])
     }
   }
diff --git a/packages/ui/src/sync/session-load-performance.ts b/packages/ui/src/sync/session-load-performance.ts
new file mode 100644
index 00000000..dcd27479
--- /dev/null
+++ b/packages/ui/src/sync/session-load-performance.ts
@@ -0,0 +1,62 @@
+const STORAGE_KEY = "openchamber_session_load_perf"
+const MAX_EVENTS = 1_000
+
+type SessionLoadPerformanceOutcome = "complete" | "error" | "stale" | "deduplicated" | "canceled"
+
+type SessionLoadPerformanceEvent = {
+  operation: string
+  runtimeKey?: string
+  directory?: string
+  sessionID?: string
+  caller?: string
+  queuedMs?: number
+  durationMs: number
+  outcome: SessionLoadPerformanceOutcome
+  retryCount?: number
+  recordCount?: number
+  at: number
+}
+
+type SessionLoadPerformanceState = {
+  events: SessionLoadPerformanceEvent[]
+}
+
+declare global {
+  interface Window {
+    __openchamberSessionLoadPerformance?: SessionLoadPerformanceState
+  }
+}
+
+const enabled = (): boolean => {
+  if (typeof window === "undefined") return false
+  try {
+    return window.localStorage.getItem(STORAGE_KEY) === "1"
+  } catch {
+    return false
+  }
+}
+
+const now = (): number => typeof performance !== "undefined" && typeof performance.now === "function"
+  ? performance.now()
+  : Date.now()
+
+export function startSessionLoadPerformanceEvent(input: Omit<SessionLoadPerformanceEvent, "at" | "durationMs" | "outcome">) {
+  if (!enabled()) return () => undefined
+  const startedAt = now()
+  return (
+    outcome: SessionLoadPerformanceOutcome,
+    details?: Partial<Pick<SessionLoadPerformanceEvent, "retryCount" | "recordCount">>,
+  ) => {
+    if (typeof window === "undefined") return
+    const state = window.__openchamberSessionLoadPerformance ?? { events: [] }
+    state.events.push({
+      ...input,
+      ...details,
+      outcome,
+      durationMs: Math.max(0, now() - startedAt),
+      at: Date.now(),
+    })
+    if (state.events.length > MAX_EVENTS) state.events.splice(0, state.events.length - MAX_EVENTS)
+    window.__openchamberSessionLoadPerformance = state
+  }
+}
diff --git a/packages/ui/src/sync/session-message-loader.test.ts b/packages/ui/src/sync/session-message-loader.test.ts
new file mode 100644
index 00000000..769ae573
--- /dev/null
+++ b/packages/ui/src/sync/session-message-loader.test.ts
@@ -0,0 +1,175 @@
+import { describe, expect, test } from "bun:test"
+import type { Message, OpencodeClient, Part } from "@opencode-ai/sdk/v2/client"
+import { ChildStoreManager } from "./child-store"
+import { SessionMessageLoader } from "./session-message-loader"
+
+const createRecord = (sessionID: string, id = "msg_1") => ({
+  info: { id, sessionID, role: "user", time: { created: 1 } } as Message,
+  parts: [{ id: `part_${id}`, messageID: id, sessionID, type: "text", text: "hello" }] as Part[],
+})
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((next) => {
+    resolve = next
+  })
+  return { promise, resolve }
+}
+
+const response = (data: ReturnType<typeof createRecord>[], cursor?: string) => ({
+  data,
+  response: { headers: { get: (name: string) => name === "x-next-cursor" ? cursor ?? null : null } },
+})
+
+const createLoader = (messages: (input: {
+  sessionID: string
+  directory?: string
+  limit?: number
+  before?: string
+}) => Promise<unknown>) => {
+  const childStores = new ChildStoreManager()
+  const sdk = { session: { messages } } as unknown as OpencodeClient
+  const loader = new SessionMessageLoader(childStores, { sdk, runtimeKey: "runtime-a" })
+  return { childStores, loader }
+}
+
+describe("SessionMessageLoader", () => {
+  test("deduplicates navigation and reactive loading for the same target", async () => {
+    const pending = deferred<ReturnType<typeof response>>()
+    let calls = 0
+    const { childStores, loader } = createLoader(async () => {
+      calls += 1
+      return pending.promise
+    })
+    const target = { directory: "/repo", sessionID: "session-a" }
+
+    const navigation = loader.ensure(target, { reason: "navigation" })
+    const reactive = loader.ensure(target, { reason: "reactive" })
+    expect(calls).toBe(1)
+
+    pending.resolve(response([createRecord(target.sessionID)]))
+    await Promise.all([navigation, reactive])
+
+    expect(loader.getSnapshot(target).status).toBe("ready")
+    expect(childStores.getChild(target.directory)?.getState().message[target.sessionID]?.length).toBe(1)
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("runs a requested tail refresh after an older in-flight load", async () => {
+    const initial = deferred<ReturnType<typeof response>>()
+    const refresh = deferred<ReturnType<typeof response>>()
+    let calls = 0
+    const limits: number[] = []
+    const { childStores, loader } = createLoader(async ({ limit }) => {
+      calls += 1
+      limits.push(limit ?? 0)
+      return calls === 1 ? initial.promise : refresh.promise
+    })
+    const target = { directory: "/repo", sessionID: "session-a" }
+
+    const loading = loader.ensure(target, { reason: "navigation" })
+    const refreshing = loader.refreshTail(target, 30)
+    const duplicateRefresh = loader.refreshTail(target, 80)
+    expect(calls).toBe(1)
+    expect(duplicateRefresh).toBe(refreshing)
+
+    initial.resolve(response([createRecord(target.sessionID, "msg_1")]))
+    await loading
+    await Promise.resolve()
+    expect(calls).toBe(2)
+    expect(limits).toEqual([50, 80])
+
+    refresh.resolve(response([createRecord(target.sessionID, "msg_2")]))
+    await Promise.all([refreshing, duplicateRefresh])
+
+    expect(childStores.getChild(target.directory)?.getState().message[target.sessionID]?.map((message) => message.id))
+      .toEqual(["msg_1", "msg_2"])
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("does not deduplicate identical session IDs across directories", async () => {
+    const calls: string[] = []
+    const { childStores, loader } = createLoader(async ({ directory, sessionID }) => {
+      calls.push(directory ?? "")
+      return response([createRecord(sessionID)])
+    })
+
+    await Promise.all([
+      loader.ensure({ directory: "/repo-a", sessionID: "shared" }),
+      loader.ensure({ directory: "/repo-b", sessionID: "shared" }),
+    ])
+
+    expect(calls.sort()).toEqual(["/repo-a", "/repo-b"])
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("exposes a retryable error without clearing an existing snapshot", async () => {
+    let fail = true
+    const { childStores, loader } = createLoader(async ({ sessionID }) => {
+      if (fail) return { error: { message: "rejected" }, response: { status: 400 } }
+      return response([createRecord(sessionID)])
+    })
+    const target = { directory: "/repo", sessionID: "session-a" }
+    const store = childStores.ensureChild(target.directory, { bootstrap: false })
+    store.setState({ message: { [target.sessionID]: [{ id: "cached", sessionID: target.sessionID, role: "user", time: { created: 0 } } as Message] } })
+
+    await loader.ensure(target, { force: true })
+    expect(loader.getSnapshot(target).status).toBe("error")
+    expect(store.getState().message[target.sessionID]?.[0]?.id).toBe("cached")
+
+    fail = false
+    await loader.ensure(target, { force: true })
+    expect(loader.getSnapshot(target).status).toBe("ready")
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("prevents an evicted in-flight request from repopulating the store", async () => {
+    const pending = deferred<ReturnType<typeof response>>()
+    const { childStores, loader } = createLoader(async () => pending.promise)
+    const target = { directory: "/repo", sessionID: "session-a" }
+
+    const loading = loader.ensure(target)
+    loader.invalidateSession(target)
+    pending.resolve(response([createRecord(target.sessionID)]))
+    await loading
+
+    expect(childStores.getChild(target.directory)?.getState().message[target.sessionID]).toBe(undefined)
+    expect(loader.getSnapshot(target).status).toBe("idle")
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("treats an empty successful response as resolved authoritative state", async () => {
+    const { childStores, loader } = createLoader(async () => response([]))
+    const target = { directory: "/repo", sessionID: "empty" }
+
+    await loader.ensure(target)
+
+    expect(loader.getSnapshot(target).resolved).toBe(true)
+    expect(loader.getSnapshot(target).complete).toBe(true)
+    expect(childStores.getChild(target.directory)?.getState().message[target.sessionID]).toEqual([])
+    loader.dispose()
+    childStores.disposeAll()
+  })
+
+  test("retries a missing message payload instead of treating it as an empty snapshot", async () => {
+    let calls = 0
+    const { childStores, loader } = createLoader(async ({ sessionID }) => {
+      calls += 1
+      return calls === 1 ? {} : response([createRecord(sessionID)])
+    })
+    const target = { directory: "/repo", sessionID: "session-a" }
+
+    await loader.ensure(target)
+
+    expect(calls).toBe(2)
+    expect(loader.getSnapshot(target).status).toBe("ready")
+    expect(childStores.getChild(target.directory)?.getState().message[target.sessionID]?.length).toBe(1)
+    loader.dispose()
+    childStores.disposeAll()
+  })
+})
diff --git a/packages/ui/src/sync/session-message-loader.ts b/packages/ui/src/sync/session-message-loader.ts
new file mode 100644
index 00000000..be6d1ec8
--- /dev/null
+++ b/packages/ui/src/sync/session-message-loader.ts
@@ -0,0 +1,619 @@
+import type { Message, OpencodeClient, Part } from "@opencode-ai/sdk/v2/client"
+import type { ChildStoreManager, DirectoryStore } from "./child-store"
+import { Binary } from "./binary"
+import { retry } from "./retry"
+import { mergeOptimisticPage, type OptimisticItem } from "./optimistic"
+import { stripMessageDiffSnapshots } from "./sanitize"
+import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
+import {
+  clearDirectorySessionPrefetch,
+  clearRuntimeSessionPrefetch,
+  clearSessionPrefetch,
+  getSessionPrefetch,
+  setSessionPrefetch,
+} from "./session-prefetch-cache"
+import { isVSCodeRuntime } from "@/lib/desktop"
+import { isMobileSurfaceRuntime } from "@/lib/runtimeSurface"
+import { normalizePath } from "@/lib/pathNormalization"
+import { startSessionLoadPerformanceEvent } from "./session-load-performance"
+
+const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
+const INITIAL_MESSAGE_PAGE_SIZE = 50
+const CONSTRAINED_INITIAL_MESSAGE_PAGE_SIZE = 30
+const HISTORY_MESSAGE_PAGE_SIZE = 100
+const INITIAL_PAGE_EXPANSION_LIMITS = [100, 150] as const
+const CONSTRAINED_INITIAL_PAGE_EXPANSION_LIMITS = [50, 80, 120] as const
+const cmp = (left: string, right: string) => left < right ? -1 : left > right ? 1 : 0
+
+export type SessionMessageTarget = {
+  directory: string
+  sessionID: string
+}
+
+export type SessionMessageLoadKind = "initial" | "older" | "refresh" | "prefetch"
+export type SessionMessageLoadStatus = "idle" | "loading" | "ready" | "error"
+
+export type SessionMessageLoadState = {
+  status: SessionMessageLoadStatus
+  loadingKind: SessionMessageLoadKind | null
+  error: Error | null
+  resolved: boolean
+  limit: number
+  cursor: string | undefined
+  complete: boolean
+  generation: number
+  updatedAt: number | undefined
+}
+
+type LoaderEntry = {
+  snapshot: SessionMessageLoadState
+  listeners: Set<() => void>
+  inflight: Promise<void> | null
+  queuedRefresh: Promise<void> | null
+  queuedRefreshLimit: number
+  optimistic: Map<string, OptimisticItem>
+}
+
+type FetchedPage = {
+  session: Message[]
+  partsByMessageID: Map<string, Part[]>
+  cursor: string | undefined
+  complete: boolean
+}
+
+type LoaderConfiguration = {
+  sdk: OpencodeClient
+  runtimeKey: string
+}
+
+const isConstrainedRuntime = () => isVSCodeRuntime() || isMobileSurfaceRuntime()
+const getInitialPageSize = () => isConstrainedRuntime()
+  ? CONSTRAINED_INITIAL_MESSAGE_PAGE_SIZE
+  : INITIAL_MESSAGE_PAGE_SIZE
+const getInitialExpansionLimits = () => isConstrainedRuntime()
+  ? CONSTRAINED_INITIAL_PAGE_EXPANSION_LIMITS
+  : INITIAL_PAGE_EXPANSION_LIMITS
+
+const isUserMessage = (message: Message): boolean => {
+  const candidate = message as Message & { clientRole?: unknown; role?: unknown }
+  const role = typeof candidate.clientRole === "string" ? candidate.clientRole : candidate.role
+  return role === "user"
+}
+
+const hasUserMessage = (messages: Message[]): boolean => messages.some(isUserMessage)
+
+const formatSdkError = (error: unknown): string => {
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  if (error && typeof error === "object" && "message" in error) {
+    const message = (error as { message?: unknown }).message
+    if (typeof message === "string" && message) return message
+  }
+  return "Session messages could not be loaded"
+}
+
+const assertSdkSuccess = (result: {
+  error?: unknown
+  response?: { status?: number }
+}, operation: string): void => {
+  if (!result.error) return
+  const status = result.response?.status
+  throw new Error(`${operation} failed${status ? ` (${status})` : ""}: ${formatSdkError(result.error)}`)
+}
+
+const sortParts = (parts: Part[]): Part[] => parts
+  .filter((part) => Boolean(part?.id))
+  .sort((left, right) => cmp(left.id, right.id))
+
+const createDefaultState = (generation = 0): SessionMessageLoadState => ({
+  status: "idle",
+  loadingKind: null,
+  error: null,
+  resolved: false,
+  limit: getInitialPageSize(),
+  cursor: undefined,
+  complete: false,
+  generation,
+  updatedAt: undefined,
+})
+
+export const EMPTY_SESSION_MESSAGE_LOAD_STATE = createDefaultState()
+
+export class SessionMessageLoader {
+  private sdk: OpencodeClient
+  private runtimeKey: string
+  private sdkEpoch = 0
+  private disposed = false
+  private readonly entries = new Map<string, LoaderEntry>()
+
+  constructor(
+    private readonly childStores: ChildStoreManager,
+    configuration: LoaderConfiguration,
+  ) {
+    this.sdk = configuration.sdk
+    this.runtimeKey = configuration.runtimeKey
+  }
+
+  configure(configuration: LoaderConfiguration): void {
+    if (this.sdk === configuration.sdk && this.runtimeKey === configuration.runtimeKey) return
+    const runtimeChanged = this.runtimeKey !== configuration.runtimeKey
+    const previousRuntimeKey = this.runtimeKey
+    this.sdk = configuration.sdk
+    this.runtimeKey = configuration.runtimeKey
+    this.sdkEpoch += 1
+    for (const entry of this.entries.values()) {
+      entry.snapshot = {
+        ...entry.snapshot,
+        status: entry.snapshot.resolved ? "ready" : "idle",
+        loadingKind: null,
+        error: null,
+        generation: entry.snapshot.generation + 1,
+      }
+      entry.inflight = null
+      this.notify(entry)
+    }
+    if (runtimeChanged) {
+      this.entries.clear()
+      clearRuntimeSessionPrefetch(previousRuntimeKey)
+    }
+  }
+
+  ensure(
+    target: SessionMessageTarget,
+    options?: { force?: boolean; reason?: "navigation" | "reactive" | "prefetch" },
+  ): Promise<void> {
+    const normalized = this.normalizeTarget(target)
+    if (!normalized || this.disposed) return Promise.resolve()
+    const entry = this.getEntry(normalized)
+    const store = this.childStores.ensureChild(normalized.directory, { bootstrap: false })
+    const materialization = getSessionMaterializationStatus(store.getState(), normalized.sessionID)
+    if (!options?.force && materialization.renderable) {
+      if (!entry.snapshot.resolved) {
+        this.patchEntry(entry, {
+          status: "ready",
+          error: null,
+          resolved: true,
+          limit: Math.max(entry.snapshot.limit, store.getState().message[normalized.sessionID]?.length ?? 0),
+        })
+      }
+      return entry.inflight ?? Promise.resolve()
+    }
+    if (entry.inflight) {
+      if (options?.reason !== "prefetch" && entry.snapshot.loadingKind === "prefetch") {
+        this.patchEntry(entry, { loadingKind: "initial" })
+      }
+      return entry.inflight
+    }
+    if (options?.force) this.bumpGeneration(entry)
+    const kind: SessionMessageLoadKind = options?.reason === "prefetch" ? "prefetch" : "initial"
+    return this.startLoad(normalized, entry, store, kind, async (isCurrent) => {
+      await this.loadInitial(normalized, entry, store, isCurrent)
+      if (!isMobileSurfaceRuntime() && isCurrent()) {
+        queueMicrotask(() => {
+          if (isCurrent() && entry.snapshot.cursor && !entry.snapshot.complete) {
+            void this.loadOlder(normalized)
+          }
+        })
+      }
+    })
+  }
+
+  prefetch(target: SessionMessageTarget): Promise<void> {
+    return this.ensure(target, { reason: "prefetch" })
+  }
+
+  loadOlder(target: SessionMessageTarget): Promise<void> {
+    const normalized = this.normalizeTarget(target)
+    if (!normalized || this.disposed) return Promise.resolve()
+    const entry = this.getEntry(normalized)
+    if (entry.inflight) return entry.inflight.then(() => this.loadOlder(normalized))
+    if (entry.snapshot.complete || !entry.snapshot.cursor) return Promise.resolve()
+    const store = this.childStores.ensureChild(normalized.directory, { bootstrap: false })
+    const cursor = entry.snapshot.cursor
+    return this.startLoad(normalized, entry, store, "older", async (isCurrent) => {
+      const page = await this.fetchPage(normalized, HISTORY_MESSAGE_PAGE_SIZE, cursor)
+      if (!isCurrent()) return
+      const committed = this.commitPage(normalized, entry, store, page, "prepend", isCurrent)
+      if (!committed || !isCurrent()) return
+      this.patchEntry(entry, {
+        status: "ready",
+        loadingKind: null,
+        error: null,
+        resolved: true,
+        limit: Math.max(entry.snapshot.limit, committed.messages.length),
+        cursor: page.cursor,
+        complete: page.complete,
+        updatedAt: Date.now(),
+      })
+      this.persistCoverage(normalized, entry.snapshot)
+    })
+  }
+
+  refreshTail(target: SessionMessageTarget, limit: number): Promise<void> {
+    const normalized = this.normalizeTarget(target)
+    if (!normalized || this.disposed) return Promise.resolve()
+    const entry = this.getEntry(normalized)
+    if (entry.inflight) {
+      entry.queuedRefreshLimit = Math.max(entry.queuedRefreshLimit, limit)
+      if (entry.queuedRefresh) return entry.queuedRefresh
+      const inflight = entry.inflight
+      const entryKey = this.keyFor(normalized)
+      const generation = entry.snapshot.generation
+      const sdkEpoch = this.sdkEpoch
+      const clearQueuedRefresh = () => {
+        if (entry.queuedRefresh !== queuedRefresh) return
+        entry.queuedRefresh = null
+        entry.queuedRefreshLimit = 0
+      }
+      const queuedRefresh = inflight.then(() => {
+        if (
+          this.disposed
+          || this.sdkEpoch !== sdkEpoch
+          || entry.snapshot.generation !== generation
+          || this.entries.get(entryKey) !== entry
+        ) {
+          clearQueuedRefresh()
+          return
+        }
+        const refreshLimit = entry.queuedRefreshLimit
+        clearQueuedRefresh()
+        return this.refreshTail(normalized, refreshLimit)
+      })
+      entry.queuedRefresh = queuedRefresh
+      return queuedRefresh
+    }
+    const store = this.childStores.ensureChild(normalized.directory, { bootstrap: false })
+    this.bumpGeneration(entry)
+    return this.startLoad(normalized, entry, store, "refresh", async (isCurrent) => {
+      const page = await this.fetchPage(normalized, Math.max(1, limit))
+      if (!isCurrent()) return
+      const committed = this.commitPage(normalized, entry, store, page, "merge", isCurrent)
+      if (!committed || !isCurrent()) return
+      this.patchEntry(entry, {
+        status: "ready",
+        loadingKind: null,
+        error: null,
+        resolved: true,
+        limit: Math.max(entry.snapshot.limit, committed.messages.length),
+        cursor: page.cursor,
+        complete: page.complete,
+        updatedAt: Date.now(),
+      })
+      this.persistCoverage(normalized, entry.snapshot)
+    })
+  }
+
+  getSnapshot(target: SessionMessageTarget): SessionMessageLoadState {
+    const normalized = this.normalizeTarget(target)
+    return normalized ? this.getEntry(normalized).snapshot : EMPTY_SESSION_MESSAGE_LOAD_STATE
+  }
+
+  subscribe(target: SessionMessageTarget, listener: () => void): () => void {
+    const normalized = this.normalizeTarget(target)
+    if (!normalized) return () => undefined
+    const entry = this.getEntry(normalized)
+    entry.listeners.add(listener)
+    return () => entry.listeners.delete(listener)
+  }
+
+  optimisticAdd(input: SessionMessageTarget & { message: Message; parts: Part[] }): void {
+    const target = this.normalizeTarget(input)
+    if (!target) return
+    const entry = this.getEntry(target)
+    entry.optimistic.set(input.message.id, { message: input.message, parts: sortParts(input.parts) })
+    const store = this.childStores.ensureChild(target.directory, { bootstrap: false })
+    const current = store.getState()
+    const messages = current.message[target.sessionID] ? [...current.message[target.sessionID]] : []
+    const result = Binary.search(messages, input.message.id, (message) => message.id)
+    if (!result.found) messages.splice(result.index, 0, input.message)
+    store.setState({
+      message: { ...current.message, [target.sessionID]: messages },
+      part: { ...current.part, [input.message.id]: sortParts(input.parts) },
+    })
+  }
+
+  optimisticRemove(input: SessionMessageTarget & { messageID: string }): void {
+    const target = this.normalizeTarget(input)
+    if (!target) return
+    const entry = this.getEntry(target)
+    entry.optimistic.delete(input.messageID)
+    const store = this.childStores.ensureChild(target.directory, { bootstrap: false })
+    const current = store.getState()
+    const existing = current.message[target.sessionID]
+    const messages = existing ? existing.filter((message) => message.id !== input.messageID) : undefined
+    const part = { ...current.part }
+    delete part[input.messageID]
+    store.setState({
+      ...(messages ? { message: { ...current.message, [target.sessionID]: messages } } : {}),
+      part,
+    })
+  }
+
+  optimisticConfirm(input: SessionMessageTarget & { messageID: string }): void {
+    const target = this.normalizeTarget(input)
+    if (!target) return
+    this.getEntry(target).optimistic.delete(input.messageID)
+  }
+
+  invalidateSession(target: SessionMessageTarget): void {
+    const normalized = this.normalizeTarget(target)
+    if (!normalized) return
+    const entry = this.entries.get(this.keyFor(normalized))
+    if (!entry) return
+    this.bumpGeneration(entry)
+    entry.inflight = null
+    entry.optimistic.clear()
+    entry.snapshot = createDefaultState(entry.snapshot.generation)
+    clearSessionPrefetch(normalized.directory, [normalized.sessionID], this.runtimeKey)
+    this.notify(entry)
+  }
+
+  invalidateDirectory(directory: string): void {
+    const normalizedDirectory = normalizePath(directory)
+    if (!normalizedDirectory) return
+    const prefix = `${this.runtimeKey}\n${normalizedDirectory}\n`
+    clearDirectorySessionPrefetch(normalizedDirectory, this.runtimeKey)
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix)) continue
+      this.bumpGeneration(entry)
+      entry.inflight = null
+      entry.optimistic.clear()
+      this.entries.delete(key)
+      this.notify(entry)
+    }
+  }
+
+  dispose(): void {
+    this.disposed = true
+    this.sdkEpoch += 1
+    for (const entry of this.entries.values()) {
+      this.bumpGeneration(entry)
+      entry.inflight = null
+      entry.optimistic.clear()
+      this.notify(entry)
+    }
+    this.entries.clear()
+    clearRuntimeSessionPrefetch(this.runtimeKey)
+  }
+
+  private normalizeTarget(target: SessionMessageTarget): SessionMessageTarget | null {
+    const directory = normalizePath(target.directory)
+    if (!directory || !target.sessionID) return null
+    return { directory, sessionID: target.sessionID }
+  }
+
+  private keyFor(target: SessionMessageTarget): string {
+    return `${this.runtimeKey}\n${target.directory}\n${target.sessionID}`
+  }
+
+  private getEntry(target: SessionMessageTarget): LoaderEntry {
+    const key = this.keyFor(target)
+    const existing = this.entries.get(key)
+    if (existing) return existing
+    const prefetched = getSessionPrefetch(target.directory, target.sessionID, this.runtimeKey)
+    const entry: LoaderEntry = {
+      snapshot: prefetched
+        ? {
+            ...createDefaultState(),
+            status: "ready",
+            resolved: true,
+            limit: prefetched.limit,
+            cursor: prefetched.cursor,
+            complete: prefetched.complete,
+            updatedAt: prefetched.at,
+          }
+        : createDefaultState(),
+      listeners: new Set(),
+      inflight: null,
+      queuedRefresh: null,
+      queuedRefreshLimit: 0,
+      optimistic: new Map(),
+    }
+    this.entries.set(key, entry)
+    return entry
+  }
+
+  private patchEntry(entry: LoaderEntry, patch: Partial<SessionMessageLoadState>): void {
+    entry.snapshot = { ...entry.snapshot, ...patch }
+    this.notify(entry)
+  }
+
+  private bumpGeneration(entry: LoaderEntry): number {
+    const generation = entry.snapshot.generation + 1
+    entry.snapshot = { ...entry.snapshot, generation }
+    return generation
+  }
+
+  private notify(entry: LoaderEntry): void {
+    for (const listener of entry.listeners) listener()
+  }
+
+  private startLoad(
+    target: SessionMessageTarget,
+    entry: LoaderEntry,
+    store: { getState: () => DirectoryStore; setState: DirectoryStoreSetter },
+    kind: SessionMessageLoadKind,
+    run: (isCurrent: () => boolean) => Promise<void>,
+  ): Promise<void> {
+    const generation = entry.snapshot.generation
+    const sdkEpoch = this.sdkEpoch
+    const finishPerformanceEvent = startSessionLoadPerformanceEvent({
+      operation: kind === "prefetch" ? "session-prefetch" : `session-messages.${kind}`,
+      runtimeKey: this.runtimeKey,
+      directory: target.directory,
+      sessionID: target.sessionID,
+      caller: kind,
+    })
+    const isCurrent = () => (
+      !this.disposed
+      && this.sdkEpoch === sdkEpoch
+      && entry.snapshot.generation === generation
+      && this.childStores.getChild(target.directory) === store
+    )
+    this.patchEntry(entry, { status: "loading", loadingKind: kind, error: null })
+    let loadPromise: Promise<void>
+    try {
+      loadPromise = run(isCurrent)
+    } catch (error) {
+      loadPromise = Promise.reject(error)
+    }
+    const promise = loadPromise
+      .then(() => finishPerformanceEvent(isCurrent() ? "complete" : "stale"))
+      .catch((error: unknown) => {
+        if (!isCurrent()) {
+          finishPerformanceEvent("stale")
+          return
+        }
+        finishPerformanceEvent("error")
+        this.patchEntry(entry, {
+          status: "error",
+          loadingKind: null,
+          error: error instanceof Error ? error : new Error(formatSdkError(error)),
+        })
+      })
+      .finally(() => {
+        if (entry.inflight === promise) entry.inflight = null
+      })
+    entry.inflight = promise
+    return promise
+  }
+
+  private async loadInitial(
+    target: SessionMessageTarget,
+    entry: LoaderEntry,
+    store: { getState: () => DirectoryStore; setState: DirectoryStoreSetter },
+    isCurrent: () => boolean,
+  ): Promise<void> {
+    const storeMessageCount = store.getState().message[target.sessionID]?.length ?? 0
+    const firstLimit = Math.max(entry.snapshot.limit, storeMessageCount, getInitialPageSize())
+    const firstPage = await this.fetchPage(target, firstLimit)
+    if (!isCurrent()) return
+    const deferFirstCommit = !firstPage.complete && !hasUserMessage(firstPage.session)
+    let committed = deferFirstCommit
+      ? { messages: firstPage.session }
+      : this.commitPage(target, entry, store, firstPage, "merge", isCurrent)
+    let acceptedPage = firstPage
+
+    if (deferFirstCommit) {
+      for (const limit of getInitialExpansionLimits()) {
+        if (limit <= firstLimit || !isCurrent()) continue
+        const expandedPage = await this.fetchPage(target, limit)
+        if (!isCurrent()) return
+        acceptedPage = expandedPage
+        const boundaryFound = hasUserMessage(expandedPage.session)
+        const isLast = limit === getInitialExpansionLimits()[getInitialExpansionLimits().length - 1]
+        if (expandedPage.complete || boundaryFound || isLast) {
+          committed = this.commitPage(target, entry, store, expandedPage, "merge", isCurrent)
+        } else {
+          committed = { messages: expandedPage.session }
+        }
+        if (expandedPage.complete || boundaryFound) break
+      }
+    }
+
+    if (!committed || !isCurrent()) return
+    this.patchEntry(entry, {
+      status: "ready",
+      loadingKind: null,
+      error: null,
+      resolved: true,
+      limit: committed.messages.length,
+      cursor: acceptedPage.cursor,
+      complete: acceptedPage.complete,
+      updatedAt: Date.now(),
+    })
+    this.persistCoverage(target, entry.snapshot)
+  }
+
+  private async fetchPage(target: SessionMessageTarget, limit: number, before?: string): Promise<FetchedPage> {
+    const result = await retry(async () => {
+      const response = await this.sdk.session.messages({
+        sessionID: target.sessionID,
+        directory: target.directory,
+        limit,
+        before,
+      })
+      assertSdkSuccess(response, "session.messages")
+      if (!Array.isArray(response.data)) {
+        const error = new Error("session.messages returned no data") as Error & { status?: number }
+        error.status = 503
+        throw error
+      }
+      return { data: response.data, response: response.response }
+    })
+    const records = result.data.filter((record: { info?: { id?: string } }) => Boolean(record?.info?.id))
+    const session = records
+      .map((record: { info: Message }) => stripMessageDiffSnapshots(record.info))
+      .sort((left: Message, right: Message) => cmp(left.id, right.id))
+    const partsByMessageID = new Map<string, Part[]>()
+    for (const record of records as Array<{ info: { id: string }; parts?: Part[] }>) {
+      partsByMessageID.set(record.info.id, sortParts(record.parts ?? []))
+    }
+    const cursor = result.response?.headers?.get?.("x-next-cursor") ?? undefined
+    return { session, partsByMessageID, cursor, complete: !cursor }
+  }
+
+  private commitPage(
+    target: SessionMessageTarget,
+    entry: LoaderEntry,
+    store: { getState: () => DirectoryStore; setState: DirectoryStoreSetter },
+    page: FetchedPage,
+    mode: "merge" | "prepend",
+    isCurrent: () => boolean,
+  ): { messages: Message[] } | null {
+    if (!isCurrent()) return null
+    const merged = mergeOptimisticPage({
+      session: page.session,
+      part: [...page.partsByMessageID].map(([id, part]) => ({ id, part })),
+      cursor: page.cursor,
+      complete: page.complete,
+    }, [...entry.optimistic.values()])
+    for (const messageID of merged.confirmed) entry.optimistic.delete(messageID)
+    const mergedPartsByMessageID = new Map(merged.part.map((candidate) => [candidate.id, candidate.part] as const))
+    const materialized = materializeSessionSnapshots(
+      store.getState(),
+      target.sessionID,
+      merged.session.map((info) => ({
+        info,
+        parts: page.partsByMessageID.get(info.id)
+          ?? mergedPartsByMessageID.get(info.id)
+          ?? [],
+      })),
+      { skipPartTypes: SKIP_PARTS, mode },
+    )
+    if (!isCurrent()) return null
+    if (materialized.messagesChanged || materialized.partsChanged) {
+      store.setState({
+        ...(materialized.messagesChanged ? { message: materialized.message } : {}),
+        ...(materialized.partsChanged ? { part: materialized.part } : {}),
+      })
+    }
+    return { messages: materialized.messages }
+  }
+
+  private persistCoverage(target: SessionMessageTarget, state: SessionMessageLoadState): void {
+    setSessionPrefetch({
+      directory: target.directory,
+      sessionID: target.sessionID,
+      limit: state.limit,
+      cursor: state.cursor,
+      complete: state.complete,
+      at: state.updatedAt,
+      runtimeKey: this.runtimeKey,
+    })
+  }
+}
+
+type DirectoryStoreSetter = (
+  partial: Partial<DirectoryStore> | ((state: DirectoryStore) => Partial<DirectoryStore> | DirectoryStore),
+) => void
+
+let imperativeLoader: SessionMessageLoader | null = null
+
+export function setImperativeSessionMessageLoader(loader: SessionMessageLoader | null): void {
+  imperativeLoader = loader
+}
+
+export function getImperativeSessionMessageLoader(): SessionMessageLoader | null {
+  return imperativeLoader
+}
diff --git a/packages/ui/src/sync/session-message-records.test.ts b/packages/ui/src/sync/session-message-records.test.ts
index 05512e87..a652b1fd 100644
--- a/packages/ui/src/sync/session-message-records.test.ts
+++ b/packages/ui/src/sync/session-message-records.test.ts
@@ -18,6 +18,16 @@ const textPart = (id: string, text: string): Part => ({
   text,
 } as Part);
 
+const taskPart = (id: string, sessionId?: string): Part => ({
+  id,
+  type: 'tool',
+  tool: 'task',
+  state: {
+    status: 'running',
+    metadata: sessionId ? { sessionId } : {},
+  },
+} as unknown as Part);
+
 const state = (partial: Partial<State>): State => ({
   ...INITIAL_STATE,
   ...partial,
@@ -65,4 +75,27 @@ describe('buildSessionMessageRecordsSnapshot', () => {
     expect(next.byId.get('assistant_1')?.parts).toBe(assistant1FinalParts);
     expect(next.byId.get('assistant_2')?.parts).toBe(assistant2InitialParts);
   });
+
+  test('publishes task session identity while other streaming part updates are suspended', () => {
+    const assistant = message('assistant_1', 'assistant');
+    const initialParts = [taskPart('task_1')];
+    const previous = buildSessionMessageRecordsSnapshot(
+      state({ message: { ses_1: [assistant] }, part: { assistant_1: initialParts } }),
+      'ses_1',
+      undefined,
+      true,
+      assistant.id,
+    );
+    const identifiedParts = [taskPart('task_1', 'child_1')];
+
+    const next = buildSessionMessageRecordsSnapshot(
+      state({ message: { ses_1: [assistant] }, part: { assistant_1: identifiedParts } }),
+      'ses_1',
+      previous,
+      true,
+      assistant.id,
+    );
+
+    expect(next.byId.get(assistant.id)?.parts).toBe(identifiedParts);
+  });
 });
diff --git a/packages/ui/src/sync/session-prefetch-cache.test.ts b/packages/ui/src/sync/session-prefetch-cache.test.ts
new file mode 100644
index 00000000..18b4f4df
--- /dev/null
+++ b/packages/ui/src/sync/session-prefetch-cache.test.ts
@@ -0,0 +1,50 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import {
+  clearDirectorySessionPrefetch,
+  clearRuntimeSessionPrefetch,
+  getSessionPrefetch,
+  setSessionPrefetch,
+} from "./session-prefetch-cache"
+
+const runtimes = ["prefetch-runtime-a", "prefetch-runtime-b"]
+
+afterEach(() => {
+  for (const runtimeKey of runtimes) clearRuntimeSessionPrefetch(runtimeKey)
+})
+
+describe("session prefetch cache", () => {
+  test("isolates colliding directory and session IDs by runtime", () => {
+    setSessionPrefetch({ directory: "/repo", sessionID: "session", limit: 10, complete: false, runtimeKey: runtimes[0] })
+    setSessionPrefetch({ directory: "/repo", sessionID: "session", limit: 20, complete: true, runtimeKey: runtimes[1] })
+
+    expect(getSessionPrefetch("/repo", "session", runtimes[0])?.limit).toBe(10)
+    expect(getSessionPrefetch("/repo", "session", runtimes[1])?.limit).toBe(20)
+  })
+
+  test("clears only the owning runtime and directory", () => {
+    setSessionPrefetch({ directory: "/repo-a", sessionID: "session", limit: 10, complete: false, runtimeKey: runtimes[0] })
+    setSessionPrefetch({ directory: "/repo-b", sessionID: "session", limit: 20, complete: false, runtimeKey: runtimes[0] })
+    setSessionPrefetch({ directory: "/repo-a", sessionID: "session", limit: 30, complete: false, runtimeKey: runtimes[1] })
+
+    clearDirectorySessionPrefetch("/repo-a", runtimes[0])
+
+    expect(getSessionPrefetch("/repo-a", "session", runtimes[0])).toBe(undefined)
+    expect(getSessionPrefetch("/repo-b", "session", runtimes[0])?.limit).toBe(20)
+    expect(getSessionPrefetch("/repo-a", "session", runtimes[1])?.limit).toBe(30)
+  })
+
+  test("bounds retained metadata globally", () => {
+    for (let index = 0; index <= 200; index += 1) {
+      setSessionPrefetch({
+        directory: "/repo",
+        sessionID: `session-${index}`,
+        limit: index,
+        complete: false,
+        runtimeKey: runtimes[0],
+      })
+    }
+
+    expect(getSessionPrefetch("/repo", "session-0", runtimes[0])).toBe(undefined)
+    expect(getSessionPrefetch("/repo", "session-200", runtimes[0])?.limit).toBe(200)
+  })
+})
diff --git a/packages/ui/src/sync/session-prefetch-cache.ts b/packages/ui/src/sync/session-prefetch-cache.ts
index e78c0e13..cdfc7b43 100644
--- a/packages/ui/src/sync/session-prefetch-cache.ts
+++ b/packages/ui/src/sync/session-prefetch-cache.ts
@@ -1,12 +1,8 @@
 /**
- * Session prefetch TTL cache — prevents redundant session fetches
- * within a short window. Port of OpenCode's session-prefetch.ts.
- *
- * Tracks: last fetch time, pagination cursor, completeness.
- * Version counter invalidates stale inflight requests after eviction.
+ * Runtime-scoped pagination metadata shared with the session message loader.
  */
 
-const SESSION_PREFETCH_TTL = 15_000
+import { getRuntimeKey } from "@/lib/runtime-switch"
 
 type Meta = {
   limit: number
@@ -15,58 +11,20 @@ type Meta = {
   at: number
 }
 
-const compositeKey = (directory: string, sessionID: string) =>
-  `${directory}\n${sessionID}`
+const MAX_PREFETCH_ENTRIES = 200
+const compositeKey = (runtimeKey: string, directory: string, sessionID: string) =>
+  `${runtimeKey}\n${directory}\n${sessionID}`
 
 const cache = new Map<string, Meta>()
-const inflight = new Map<string, Promise<Meta | undefined>>()
-const rev = new Map<string, number>()
-const listeners = new Map<string, Set<() => void>>()
 
-const version = (id: string) => rev.get(id) ?? 0
-
-const notify = (id: string) => {
-  const callbacks = listeners.get(id)
-  if (!callbacks) return
-  callbacks.forEach((callback) => callback())
-}
-
-/** Check if a prefetch/sync can be skipped (recently fetched). */
-export function shouldSkipSessionPrefetch(input: {
-  hasMessages: boolean
-  info?: Meta
-  pageSize: number
-  now?: number
-}): boolean {
-  if (!input.hasMessages) {
-    return false
-  }
-
-  const info = input.info
-  if (!info) return true
-  if (info.complete) return true
-  if (info.limit > input.pageSize) return true
-  if (info.limit < input.pageSize) return false
-  return (input.now ?? Date.now()) - info.at < SESSION_PREFETCH_TTL
-}
-
-export function getSessionPrefetch(directory: string, sessionID: string): Meta | undefined {
-  return cache.get(compositeKey(directory, sessionID))
-}
-
-export function subscribeSessionPrefetch(directory: string, sessionID: string, callback: () => void) {
-  if (!sessionID) return () => undefined
-  const id = compositeKey(directory, sessionID)
-  let callbacks = listeners.get(id)
-  if (!callbacks) {
-    callbacks = new Set()
-    listeners.set(id, callbacks)
-  }
-  callbacks.add(callback)
-  return () => {
-    callbacks?.delete(callback)
-    if (callbacks?.size === 0) listeners.delete(id)
+export function getSessionPrefetch(directory: string, sessionID: string, runtimeKey = getRuntimeKey()): Meta | undefined {
+  const id = compositeKey(runtimeKey, directory, sessionID)
+  const value = cache.get(id)
+  if (value) {
+    cache.delete(id)
+    cache.set(id, value)
   }
+  return value
 }
 
 export function setSessionPrefetch(input: {
@@ -76,25 +34,42 @@ export function setSessionPrefetch(input: {
   cursor?: string
   complete: boolean
   at?: number
+  runtimeKey?: string
 }) {
-  const id = compositeKey(input.directory, input.sessionID)
+  const id = compositeKey(input.runtimeKey ?? getRuntimeKey(), input.directory, input.sessionID)
+  cache.delete(id)
   cache.set(id, {
     limit: input.limit,
     cursor: input.cursor,
     complete: input.complete,
     at: input.at ?? Date.now(),
   })
-  notify(id)
+  while (cache.size > MAX_PREFETCH_ENTRIES) {
+    const oldest = cache.keys().next().value
+    if (!oldest) break
+    cache.delete(oldest)
+  }
 }
 
 /** Invalidate cache for specific sessions (e.g. after eviction). */
-export function clearSessionPrefetch(directory: string, sessionIDs: Iterable<string>) {
+export function clearSessionPrefetch(directory: string, sessionIDs: Iterable<string>, runtimeKey = getRuntimeKey()) {
   for (const sessionID of sessionIDs) {
     if (!sessionID) continue
-    const id = compositeKey(directory, sessionID)
-    rev.set(id, version(id) + 1)
+    const id = compositeKey(runtimeKey, directory, sessionID)
     cache.delete(id)
-    inflight.delete(id)
-    notify(id)
+  }
+}
+
+export function clearDirectorySessionPrefetch(directory: string, runtimeKey = getRuntimeKey()) {
+  const prefix = `${runtimeKey}\n${directory}\n`
+  for (const id of cache.keys()) {
+    if (id.startsWith(prefix)) cache.delete(id)
+  }
+}
+
+export function clearRuntimeSessionPrefetch(runtimeKey: string) {
+  const prefix = `${runtimeKey}\n`
+  for (const id of cache.keys()) {
+    if (id.startsWith(prefix)) cache.delete(id)
   }
 }
diff --git a/packages/ui/src/sync/session-ui-store.test.js b/packages/ui/src/sync/session-ui-store.test.js
index 725cc36e..d813800e 100644
--- a/packages/ui/src/sync/session-ui-store.test.js
+++ b/packages/ui/src/sync/session-ui-store.test.js
@@ -228,6 +228,24 @@ describe('routeMessage directory scoping', () => {
   });
 });
 
+describe('runtime worktree topology', () => {
+  test('restores independent in-memory maps across A -> B -> A', () => {
+    const topologyA = new Map([['/repo', [{ path: '/repo/a', branch: 'a' }]]]);
+    const topologyB = new Map([['/repo', [{ path: '/repo/b', branch: 'b' }]]]);
+
+    useSessionUIStore.setState({ availableWorktreesByProject: topologyA, availableWorktrees: topologyA.get('/repo') });
+    useSessionUIStore.getState().prepareForRuntimeSwitch('runtime-a');
+    useSessionUIStore.setState({ availableWorktreesByProject: topologyB, availableWorktrees: topologyB.get('/repo') });
+    useSessionUIStore.getState().prepareForRuntimeSwitch('runtime-b');
+
+    useSessionUIStore.getState().restoreForRuntimeSwitch('runtime-a');
+    expect(useSessionUIStore.getState().availableWorktreesByProject.get('/repo')?.[0]?.path).toBe('/repo/a');
+
+    useSessionUIStore.getState().restoreForRuntimeSwitch('runtime-b');
+    expect(useSessionUIStore.getState().availableWorktreesByProject.get('/repo')?.[0]?.path).toBe('/repo/b');
+  });
+});
+
 describe('openNewSessionDraft project binding', () => {
   const projectA = { id: 'proj-a', path: '/projects/alpha', label: 'Alpha' };
   const projectB = { id: 'proj-b', path: '/projects/beta', label: 'Beta' };
diff --git a/packages/ui/src/sync/session-ui-store.ts b/packages/ui/src/sync/session-ui-store.ts
index e4f92def..1e3d47b2 100644
--- a/packages/ui/src/sync/session-ui-store.ts
+++ b/packages/ui/src/sync/session-ui-store.ts
@@ -68,6 +68,7 @@ import { useSessionWorktreeStore } from "./session-worktree-store"
 import { getAttachedSessionDirectory } from "./session-worktree-contract"
 import { setSessionOpener } from "./session-navigation"
 import { getRuntimeKey } from "@/lib/runtime-switch"
+import { persistWorktreeTopology, readPersistedWorktreeTopology } from "./worktree-topology-cache"
 import { rememberRuntimeLiveStatus } from "./runtime-live-memory"
 
 export type { AttachedFile }
@@ -172,6 +173,7 @@ export function routeMessage(params: {
 
 type SendMessageOptions = {
   sessionId?: string
+  directory?: string
   delivery?: 'steer'
 }
 
@@ -392,6 +394,8 @@ type RuntimeSessionMemory = {
   sessionId: string | null
   directory: string | null
   draft: NewSessionDraftState
+  worktreeMetadata: Map<string, WorktreeMetadata>
+  availableWorktreesByProject: Map<string, WorktreeMetadata[]>
 }
 const runtimeSessionMemory = new Map<string, RuntimeSessionMemory>()
 
@@ -408,6 +412,8 @@ const writeRuntimeSessionMemory = (key: string, patch: Partial<RuntimeSessionMem
     sessionId: current?.sessionId ?? null,
     directory: current?.directory ?? null,
     draft: current?.draft ? cloneDraft(current.draft) : { ...DEFAULT_DRAFT },
+    worktreeMetadata: current?.worktreeMetadata ?? new Map(),
+    availableWorktreesByProject: current?.availableWorktreesByProject ?? new Map(),
     ...patch,
   })
 }
@@ -519,37 +525,13 @@ export async function materializeOpenDraftSession(selection: {
 // the FIRST launch — yielding a single project-scoped config load instead of a
 // worktree+project double-load. Discovery refreshes it in the background.
 // ---------------------------------------------------------------------------
-const WORKTREE_MAP_STORAGE_KEY = 'oc.worktreeMap'
-
-const loadPersistedWorktreeMap = (): Map<string, WorktreeMetadata[]> => {
-  try {
-    const raw = getDeferredSafeStorage().getItem(WORKTREE_MAP_STORAGE_KEY)
-    if (!raw) return new Map()
-    const entries = JSON.parse(raw) as Array<[string, WorktreeMetadata[]]>
-    if (!Array.isArray(entries)) return new Map()
-    return new Map(
-      entries.filter((entry) => Array.isArray(entry) && typeof entry[0] === 'string' && Array.isArray(entry[1])),
-    )
-  } catch {
-    return new Map()
-  }
-}
-
-const persistWorktreeMap = (serialized: string): void => {
-  try {
-    getDeferredSafeStorage().setItem(WORKTREE_MAP_STORAGE_KEY, serialized)
-  } catch {
-    // quota / serialization error — ignore; discovery still refreshes at runtime
-  }
-}
-
 const flattenWorktreeMap = (map: Map<string, WorktreeMetadata[]>): WorktreeMetadata[] => {
   const out: WorktreeMetadata[] = []
   for (const list of map.values()) out.push(...list)
   return out
 }
 
-const PERSISTED_WORKTREE_MAP = loadPersistedWorktreeMap()
+const PERSISTED_WORKTREE_MAP = readPersistedWorktreeTopology(runtimeMemoryKey())
 
 export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
   currentSessionId: null,
@@ -660,6 +642,8 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       sessionId: currentSessionId,
       directory,
       draft: cloneDraft(get().newSessionDraft),
+      worktreeMetadata: new Map(get().worktreeMetadata),
+      availableWorktreesByProject: new Map(get().availableWorktreesByProject),
     })
   },
 
@@ -669,6 +653,8 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
     const restoredSessionId = memory?.sessionId ?? activeSessionByRuntime.get(key) ?? null
     const restoredDraft = memory?.draft ? cloneDraft(memory.draft) : { ...DEFAULT_DRAFT }
     const restoredDirectory = memory?.directory ?? null
+    const availableWorktreesByProject = memory?.availableWorktreesByProject
+      ?? readPersistedWorktreeTopology(key)
     if (restoredDirectory) {
       useDirectoryStore.getState().setDirectory(restoredDirectory, { showOverlay: false })
     }
@@ -679,6 +665,9 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
       abortPromptSessionId: null,
       abortPromptExpiresAt: null,
       error: null,
+      worktreeMetadata: memory?.worktreeMetadata ?? new Map(),
+      availableWorktrees: flattenWorktreeMap(availableWorktreesByProject),
+      availableWorktreesByProject,
       sessionAbortFlags: new Map(),
       pendingChangesBarDismissed: new Map(),
     })
@@ -793,6 +782,23 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
   // closeNewSessionDraft
   // ---------------------------------------------------------------------------
   closeNewSessionDraft: () => {
+    const currentDraft = get().newSessionDraft
+    if (
+      !currentDraft.open
+      && currentDraft.selectedProjectId == null
+      && currentDraft.directoryOverride == null
+      && currentDraft.pendingWorktreeRequestId == null
+      && currentDraft.bootstrapPendingDirectory == null
+      && !currentDraft.preserveDirectoryOverride
+      && currentDraft.parentID == null
+      && currentDraft.title === undefined
+      && currentDraft.initialPrompt === undefined
+      && currentDraft.syntheticParts === undefined
+      && currentDraft.targetFolderId === undefined
+      && currentDraft.permissionAutoAcceptEnabled === undefined
+    ) {
+      return
+    }
     const nextDraft: NewSessionDraftState = {
         open: false,
         selectedProjectId: null,
@@ -1145,7 +1151,7 @@ export const useSessionUIStore = create<SessionUIState>()((set, get) => ({
     }
 
     const currentSessionDirectory = targetSessionId
-      ? normalizePath(get().getDirectoryForSession(targetSessionId))
+      ? normalizePath(options?.directory ?? get().getDirectoryForSession(targetSessionId))
       : null
     if (targetSessionId) {
       notifyMessageSent(targetSessionId)
@@ -1613,13 +1619,14 @@ setSessionOpener((sessionID, directory) => {
 // comparison avoids redundant localStorage writes when the Map reference
 // changed but the content is identical (e.g., re-discovery that found the
 // same worktrees).
-let lastPersistedWorktreeSerialized = ''
+const lastPersistedWorktreeSerializedByRuntime = new Map<string, string>()
 useSessionUIStore.subscribe((state, prev) => {
   if (state.availableWorktreesByProject !== prev.availableWorktreesByProject) {
+    const runtimeKey = runtimeMemoryKey()
     const serialized = JSON.stringify([...state.availableWorktreesByProject.entries()])
-    if (serialized !== lastPersistedWorktreeSerialized) {
-      lastPersistedWorktreeSerialized = serialized
-      persistWorktreeMap(serialized)
+    if (serialized !== lastPersistedWorktreeSerializedByRuntime.get(runtimeKey)) {
+      lastPersistedWorktreeSerializedByRuntime.set(runtimeKey, serialized)
+      persistWorktreeTopology(runtimeKey, state.availableWorktreesByProject)
     }
   }
 })
diff --git a/packages/ui/src/sync/streaming.test.ts b/packages/ui/src/sync/streaming.test.ts
index d6fdf1f0..326f07d6 100644
--- a/packages/ui/src/sync/streaming.test.ts
+++ b/packages/ui/src/sync/streaming.test.ts
@@ -1,7 +1,17 @@
 import { beforeEach, describe, expect, test } from "bun:test"
 import type { Message, SessionStatus } from "@opencode-ai/sdk/v2/client"
 import { INITIAL_STATE, type State } from "./types"
-import { updateStreamingState, useStreamingStore } from "./streaming"
+import {
+  touchStreamingSession,
+  updateChangedStreamingSessions,
+  updateStreamingState,
+  useStreamingStore,
+} from "./streaming"
+import {
+  getSyncPerformanceDiagnostics,
+  resetSyncPerformanceDiagnostics,
+  setSyncPerformanceDiagnosticsEnabled,
+} from "./performance-diagnostics"
 
 const message = (id: string, role: "user" | "assistant"): Message => ({
   id,
@@ -20,6 +30,7 @@ const stateWithMessages = (messages: Message[], status: SessionStatus = { type:
 
 describe("updateStreamingState", () => {
   beforeEach(() => {
+    setSyncPerformanceDiagnosticsEnabled(false)
     useStreamingStore.setState({
       streamingMessageIds: new Map(),
       messageStreamStates: new Map(),
@@ -80,4 +91,76 @@ describe("updateStreamingState", () => {
     expect(useStreamingStore.getState().streamingMessageIds.get("ses_1")).toBeNull()
     expect(useStreamingStore.getState().messageStreamStates.get("msg_assistant_1")?.phase).toBe("completed")
   })
+
+  test("does no full or incremental scans for part-only updates across 50 busy sessions", () => {
+    const session_status: NonNullable<State["session_status"]> = {}
+    const messages: State["message"] = {}
+    for (let index = 0; index < 50; index += 1) {
+      const sessionID = `ses_${index}`
+      session_status[sessionID] = { type: "busy" } as SessionStatus
+      messages[sessionID] = [
+        message(`msg_user_${index}`, "user"),
+        message(`msg_assistant_${index}`, "assistant"),
+      ]
+    }
+    const state: State = { ...INITIAL_STATE, session_status, message: messages }
+
+    setSyncPerformanceDiagnosticsEnabled(true)
+    updateStreamingState(state, 0)
+    resetSyncPerformanceDiagnostics()
+
+    for (let index = 0; index < 10_000; index += 1) {
+      const next = { ...state, part: { ...state.part, changed: [] } }
+      updateChangedStreamingSessions(next, state, 100)
+      touchStreamingSession(`ses_${index % 50}`, 100)
+    }
+
+    const diagnostics = getSyncPerformanceDiagnostics()
+    expect(diagnostics?.streamingFullReconciliations).toBe(0)
+    expect(diagnostics?.streamingIncrementalReconciliations).toBe(0)
+    expect(diagnostics?.streamingStatusEntriesVisited).toBe(0)
+    expect(diagnostics?.streamingSessionCandidatesVisited).toBe(0)
+    expect(diagnostics?.streamingMessagesVisited).toBe(0)
+    expect(diagnostics?.streamingHeartbeatAttempts).toBe(10_000)
+    expect(diagnostics?.streamingHeartbeatCommits).toBe(0)
+  })
+
+  test("updates heartbeat timestamps per session without rescanning directory state", () => {
+    const state = stateWithMessages([
+      message("msg_user_1", "user"),
+      message("msg_assistant_1", "assistant"),
+    ])
+    setSyncPerformanceDiagnosticsEnabled(true)
+    updateStreamingState(state, 0)
+    resetSyncPerformanceDiagnostics()
+
+    touchStreamingSession("ses_1", 999)
+    touchStreamingSession("ses_1", 1_000)
+
+    expect(useStreamingStore.getState().messageStreamStates.get("msg_assistant_1")?.lastUpdateAt).toBe(1_000)
+    expect(getSyncPerformanceDiagnostics()?.streamingHeartbeatAttempts).toBe(2)
+    expect(getSyncPerformanceDiagnostics()?.streamingHeartbeatCommits).toBe(1)
+    expect(getSyncPerformanceDiagnostics()?.streamingFullReconciliations).toBe(0)
+    expect(getSyncPerformanceDiagnostics()?.streamingSessionCandidatesVisited).toBe(0)
+  })
+
+  test("incrementally completes a replaced assistant message", () => {
+    const previous = stateWithMessages([
+      message("msg_user_1", "user"),
+      message("msg_assistant_1", "assistant"),
+    ])
+    updateStreamingState(previous, 10)
+    const next = stateWithMessages([
+      message("msg_user_1", "user"),
+      message("msg_assistant_1", "assistant"),
+      message("msg_assistant_2", "assistant"),
+    ])
+
+    updateChangedStreamingSessions(next, previous, 20)
+
+    const streaming = useStreamingStore.getState()
+    expect(streaming.streamingMessageIds.get("ses_1")).toBe("msg_assistant_2")
+    expect(streaming.messageStreamStates.get("msg_assistant_1")?.phase).toBe("completed")
+    expect(streaming.messageStreamStates.get("msg_assistant_2")?.phase).toBe("streaming")
+  })
 })
diff --git a/packages/ui/src/sync/streaming.ts b/packages/ui/src/sync/streaming.ts
index b580c034..ab62ac99 100644
--- a/packages/ui/src/sync/streaming.ts
+++ b/packages/ui/src/sync/streaming.ts
@@ -9,6 +9,7 @@
 import { create } from "zustand"
 import type { Message, SessionStatus } from "@opencode-ai/sdk/v2/client"
 import type { State } from "./types"
+import { countSyncPerformance } from "./performance-diagnostics"
 
 type StreamPhase = "streaming" | "cooldown" | "completed"
 
@@ -45,8 +46,20 @@ export function resetStreamingState() {
 /** Only update lastUpdateAt every this many ms to avoid 60Hz store churn */
 const STREAMING_HEARTBEAT_MS = 1000
 
-export function updateStreamingState(state: State) {
-  const now = Date.now()
+const findTrailingAssistantMessage = (messages: Message[] | undefined): Message | null => {
+  if (!messages) return null
+
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    countSyncPerformance("streamingMessagesVisited")
+    if (messages[index].role === "user") return null
+    if (messages[index].role === "assistant") return messages[index]
+  }
+
+  return null
+}
+
+export function updateStreamingState(state: State, now = Date.now()) {
+  countSyncPerformance("streamingFullReconciliations")
   const currentStore = useStreamingStore.getState()
   const currentStreamingIds = currentStore.streamingMessageIds
   const currentStreamStates = currentStore.messageStreamStates
@@ -59,6 +72,7 @@ export function updateStreamingState(state: State) {
   // Idle sessions are handled by checking against currentStreamingIds below.
   const busySessionIds = new Set<string>()
   for (const [sessionID, status] of Object.entries(state.session_status ?? {})) {
+    countSyncPerformance("streamingStatusEntriesVisited")
     if ((status as SessionStatus).type === "busy") {
       busySessionIds.add(sessionID)
     }
@@ -78,21 +92,13 @@ export function updateStreamingState(state: State) {
   }
 
   for (const sessionID of busySessionIds) {
+    countSyncPerformance("streamingSessionCandidatesVisited")
     const messages = state.message[sessionID]
     if (!messages || messages.length === 0) continue
 
     // Only the trailing assistant turn can be streaming. If a new user turn is
     // last, the next assistant message has not arrived yet.
-    let streamingMsg: Message | null = null
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].role === "user") {
-        break
-      }
-      if (messages[i].role === "assistant") {
-        streamingMsg = messages[i]
-        break
-      }
-    }
+    const streamingMsg = findTrailingAssistantMessage(messages)
 
     if (!streamingMsg) {
       const prevId = currentStreamingIds.get(sessionID)
@@ -140,3 +146,119 @@ export function updateStreamingState(state: State) {
     })
   }
 }
+
+const collectChangedSessionIds = (
+  current: Record<string, unknown> | undefined,
+  previous: Record<string, unknown> | undefined,
+  changed: Set<string>,
+  countStatusEntries = false,
+) => {
+  const currentRecord = current ?? {}
+  const previousRecord = previous ?? {}
+  for (const sessionID of Object.keys(currentRecord)) {
+    if (countStatusEntries) countSyncPerformance("streamingStatusEntriesVisited")
+    if (currentRecord[sessionID] !== previousRecord[sessionID]) changed.add(sessionID)
+  }
+  for (const sessionID of Object.keys(previousRecord)) {
+    if (Object.prototype.hasOwnProperty.call(currentRecord, sessionID)) continue
+    if (countStatusEntries) countSyncPerformance("streamingStatusEntriesVisited")
+    changed.add(sessionID)
+  }
+}
+
+export function updateChangedStreamingSessions(state: State, previous: State, now = Date.now()): void {
+  const statusChanged = state.session_status !== previous.session_status
+  const messagesChanged = state.message !== previous.message
+  if (!statusChanged && !messagesChanged) return
+
+  countSyncPerformance("streamingIncrementalReconciliations")
+  const changedSessionIds = new Set<string>()
+  if (statusChanged) {
+    collectChangedSessionIds(
+      state.session_status as Record<string, unknown> | undefined,
+      previous.session_status as Record<string, unknown> | undefined,
+      changedSessionIds,
+      true,
+    )
+  }
+  if (messagesChanged) {
+    collectChangedSessionIds(
+      state.message as Record<string, unknown> | undefined,
+      previous.message as Record<string, unknown> | undefined,
+      changedSessionIds,
+    )
+  }
+  if (changedSessionIds.size === 0) return
+
+  const currentStore = useStreamingStore.getState()
+  const nextStreamingIds = new Map(currentStore.streamingMessageIds)
+  const nextStreamStates = new Map(currentStore.messageStreamStates)
+  let changed = false
+
+  const complete = (sessionID: string, messageID: string) => {
+    if (nextStreamingIds.get(sessionID) !== null) {
+      nextStreamingIds.set(sessionID, null)
+      changed = true
+    }
+    const existing = nextStreamStates.get(messageID)
+    if (existing?.phase === "streaming") {
+      nextStreamStates.set(messageID, { ...existing, phase: "completed", completedAt: now })
+      changed = true
+    }
+  }
+
+  for (const sessionID of changedSessionIds) {
+    countSyncPerformance("streamingSessionCandidatesVisited")
+    const previousMessageID = currentStore.streamingMessageIds.get(sessionID)
+    if (state.session_status?.[sessionID]?.type !== "busy") {
+      if (previousMessageID) complete(sessionID, previousMessageID)
+      continue
+    }
+
+    const streamingMessage = findTrailingAssistantMessage(state.message[sessionID])
+
+    if (!streamingMessage) {
+      if (previousMessageID) complete(sessionID, previousMessageID)
+      continue
+    }
+
+    if (previousMessageID && previousMessageID !== streamingMessage.id) {
+      complete(sessionID, previousMessageID)
+    }
+    if (nextStreamingIds.get(sessionID) !== streamingMessage.id) {
+      nextStreamingIds.set(sessionID, streamingMessage.id)
+      changed = true
+    }
+
+    const existing = nextStreamStates.get(streamingMessage.id)
+    if (!existing || existing.phase !== "streaming") {
+      nextStreamStates.set(streamingMessage.id, {
+        phase: "streaming",
+        startedAt: existing?.startedAt ?? now,
+        lastUpdateAt: now,
+      })
+      changed = true
+    }
+  }
+
+  if (changed) {
+    useStreamingStore.setState({
+      streamingMessageIds: nextStreamingIds,
+      messageStreamStates: nextStreamStates,
+    })
+  }
+}
+
+export function touchStreamingSession(sessionID: string, now = Date.now()): void {
+  countSyncPerformance("streamingHeartbeatAttempts")
+  const current = useStreamingStore.getState()
+  const messageID = current.streamingMessageIds.get(sessionID)
+  if (!messageID) return
+  const existing = current.messageStreamStates.get(messageID)
+  if (!existing || existing.phase !== "streaming" || now - existing.lastUpdateAt < STREAMING_HEARTBEAT_MS) return
+
+  const messageStreamStates = new Map(current.messageStreamStates)
+  messageStreamStates.set(messageID, { ...existing, lastUpdateAt: now })
+  countSyncPerformance("streamingHeartbeatCommits")
+  useStreamingStore.setState({ messageStreamStates })
+}
diff --git a/packages/ui/src/sync/sync-context.tsx b/packages/ui/src/sync/sync-context.tsx
index d5e93777..8d3f72d9 100644
--- a/packages/ui/src/sync/sync-context.tsx
+++ b/packages/ui/src/sync/sync-context.tsx
@@ -10,21 +10,30 @@ import { isVSCodeRuntime } from "@/lib/desktop"
 import { isMobileSurfaceRuntime } from "@/lib/runtimeSurface"
 import { reduceGlobalEvent, applyGlobalProject, applyDirectoryEvent, type SessionMaterializationReason } from "./event-reducer"
 import { useGlobalSyncStore } from "./global-sync-store"
-import { ChildStoreManager, type DirectoryStore } from "./child-store"
+import {
+  ChildStoreManager,
+  markDirectorySessionPartChanged,
+  subscribeDirectoryPermission,
+  subscribeDirectorySessionMessages,
+  type DirectoryBootstrapContext,
+  type DirectoryBootstrapReason,
+  type DirectoryBootstrapPriority,
+  type DirectoryStore,
+} from "./child-store"
 import {
   aggregateLiveSessions,
   aggregateLiveSessionStatuses,
   areSessionListsEquivalent,
   areStatusMapsEquivalent,
   findLiveSession,
-  findLiveSessionStatus,
 } from "./live-aggregate"
 import { bootstrapGlobal, bootstrapDirectory } from "./bootstrap"
 import { retry } from "./retry"
-import { updateStreamingState } from "./streaming"
+import { touchStreamingSession, updateChangedStreamingSessions, updateStreamingState } from "./streaming"
+import { countSyncPerformance } from "./performance-diagnostics"
 import { setActionRefs } from "./session-actions"
 import { setSyncRefs, getAllSyncSessions } from "./sync-refs"
-import { stripMessageDiffSnapshots, stripSessionDiffSnapshots } from "./sanitize"
+import { stripSessionDiffSnapshots } from "./sanitize"
 import { applySessionEventToGlobalSessions } from "./session-event-router"
 import { syncDebug } from "./debug"
 import { getReconnectCandidateSessionIds, mergeBootstrapSessions } from "./reconnect-recovery"
@@ -33,24 +42,36 @@ import { usePermissionStore } from "@/stores/permissionStore"
 import { processVSCodePermissionAutoAccept } from "./vscode-permission-auto-accept"
 import { useConfigStore } from "@/stores/useConfigStore"
 import { useTodosPersistStore } from "@/stores/useTodosPersistStore"
+import { cleanupPersistedSessionState } from "./session-deletion-cleanup"
 import { toast } from "@/components/ui"
 import { appendNotification } from "./notification-store"
-import { applyGlobalSessionStatusEvent } from "./global-session-status"
+import { applyGlobalSessionStatusEvent, applyGlobalSessionStatusSnapshot, useGlobalSessionStatusStore } from "./global-session-status"
 import type { State } from "./types"
 import type { SessionStatus } from "@opencode-ai/sdk/v2/client"
 import type { PermissionRequest } from "@/types/permission"
 import type { QuestionRequest } from "@/types/question"
-import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
+import {
+  getSessionMaterializationRequestKey,
+  getSessionMaterializationStatus,
+  isSessionMaterializationStillNeeded,
+  type SessionMaterializationRequest,
+} from "./materialization"
 import { openSessionFromToast } from "./session-navigation"
 import { getPermissionToastKey, showPermissionNeededToast } from "./permission-toast"
 import { getRuntimeLiveStatusSeed, LIVE_STATUS_TTL_MS } from "./runtime-live-memory"
 import { getRuntimeKey } from "@/lib/runtime-switch"
 import { getRegisteredRuntimeAPIs } from "@/contexts/runtimeAPIRegistry"
-import { setSessionPrefetch } from "./session-prefetch-cache"
 import { listGlobalSessionPages } from "@/stores/globalSessions"
 import { areRequestArraysReferentiallyEqual, collectScopedBlockingRequests } from "./scoped-blocking-requests"
 import { EMPTY_USER_MESSAGE_HISTORY_SNAPSHOT, buildUserMessageHistorySnapshot, type UserMessageHistorySnapshot } from "./user-message-history"
 import { runtimeFetch } from "@/lib/runtime-fetch"
+import {
+  EMPTY_SESSION_MESSAGE_LOAD_STATE,
+  SessionMessageLoader,
+  getImperativeSessionMessageLoader,
+  setImperativeSessionMessageLoader,
+  type SessionMessageLoadState,
+} from "./session-message-loader"
 
 // ---------------------------------------------------------------------------
 // Context
@@ -58,6 +79,8 @@ import { runtimeFetch } from "@/lib/runtime-fetch"
 
 type SyncSystem = {
   childStores: ChildStoreManager
+  messageLoader: SessionMessageLoader
+  runtimeKey: string
   sdk: OpencodeClient
   directory: string
 }
@@ -140,23 +163,41 @@ function useLiveSyncSelector<T>(
 }
 
 // ---------------------------------------------------------------------------
-// Event handler — applies one SSE event at a time to the live store.
-// Each event reads live state, creates a shallow draft, applies, writes back.
-// React 18 batches synchronous setState calls automatically.
+// Event handler — applies ordered SSE events to a cumulative per-flush draft.
+// Per-event side effects remain ordered, while each directory store publishes
+// once and each touched top-level slice is cloned at most once per flush.
 // ---------------------------------------------------------------------------
 
+type DirectoryEventBatch = {
+  states: Map<StoreApi<DirectoryStore>, DirectoryStore>
+  clonedFields: Map<StoreApi<DirectoryStore>, Set<keyof State>>
+  changedStores: Set<StoreApi<DirectoryStore>>
+}
+
+const createDirectoryEventBatch = (): DirectoryEventBatch => ({
+  states: new Map(),
+  clonedFields: new Map(),
+  changedStores: new Set(),
+})
+
+const getDirectoryEventState = (
+  store: StoreApi<DirectoryStore>,
+  batch?: DirectoryEventBatch,
+): DirectoryStore => batch?.states.get(store) ?? store.getState()
+
+const publishDirectoryEventBatch = (batch: DirectoryEventBatch): void => {
+  for (const store of batch.changedStores) {
+    const state = batch.states.get(store)
+    if (!state) continue
+    countSyncPerformance("directoryStorePublications")
+    store.setState(state)
+  }
+}
+
 /** Read status for a session across all directories */
 export function useGlobalSessionStatus(sessionId: string): SessionStatus | undefined {
-  return useLiveSyncSelector(
-    useCallback((states) => findLiveSessionStatus(states, sessionId), [sessionId]),
-    Object.is,
-    useCallback(
-      (childStores: ChildStoreManager, notify: () => void) => childStores.subscribeAllSelected(
-        (state: State) => state.session_status?.[sessionId],
-        notify,
-      ),
-      [sessionId],
-    ),
+  return useGlobalSessionStatusStore(
+    useCallback((state) => state.statusById.get(sessionId)?.status, [sessionId]),
   )
 }
 
@@ -196,7 +237,6 @@ let globalBootstrapGeneration = 0
 const BOOT_DEBOUNCE_MS = 1500
 const RECONNECT_MESSAGE_LIMIT = 30
 const SESSION_MATERIALIZATION_MESSAGE_LIMIT = 30
-const RECONNECT_SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const ACTIVE_SESSION_WATCHDOG_INTERVAL_MS = 5_000
 const ACTIVE_SESSION_STATUS_POLL_INTERVAL_MS = 5_000
 const ACTIVE_SESSION_STALE_EVENT_MS = 20_000
@@ -221,26 +261,19 @@ function haveEquivalentSyncSnapshots(left: unknown, right: unknown): boolean {
 // ---------------------------------------------------------------------------
 // Session materialization scheduler — when local message/part state is incomplete,
 // fetch the canonical session snapshot and materialize messages and parts together.
-// Tracked per-directory, deduplicated, and auto-expiring.
+// Tracked per-runtime and directory, deduplicated, and auto-expiring.
 // ---------------------------------------------------------------------------
 
 type PendingSessionMaterialization = {
+  runtimeKey: string
   sessionID: string
   directory: string
   enqueuedAt: number
   request: SessionMaterializationRequest
 }
 
-type SessionMaterializationRequest = {
-  reason: SessionMaterializationReason
-  messageID?: string
-  partID?: string
-}
-
 const SESSION_MATERIALIZATION_COOLDOWN_MS = 5_000
-const pendingSessionMaterializations = new Map<string, PendingSessionMaterialization>() // key: directory:sessionID
-
-const materializationKey = (directory: string, sessionID: string) => `${directory}:${sessionID}`
+const pendingSessionMaterializations = new Map<string, PendingSessionMaterialization>()
 
 function enqueueSessionMaterialization(
   directory: string,
@@ -249,27 +282,66 @@ function enqueueSessionMaterialization(
   request: SessionMaterializationRequest,
 ) {
   if (!directory || directory === "global" || !sessionID) return
-  const k = materializationKey(directory, sessionID)
+  const runtimeKey = getRuntimeKey()
+  const k = getSessionMaterializationRequestKey(runtimeKey, directory, sessionID)
   const existing = pendingSessionMaterializations.get(k)
   if (existing && Date.now() - existing.enqueuedAt < SESSION_MATERIALIZATION_COOLDOWN_MS) return
 
-  pendingSessionMaterializations.set(k, { sessionID, directory, enqueuedAt: Date.now(), request })
+  const pending = { runtimeKey, sessionID, directory, enqueuedAt: Date.now(), request }
+  pendingSessionMaterializations.set(k, pending)
+  countSyncPerformance("materializationEnqueues")
+  if (request.reason === "empty-assistant-message") {
+    countSyncPerformance("materializationEmptyAssistantEnqueues")
+  } else if (request.reason === "missing-owning-message") {
+    countSyncPerformance("materializationMissingMessageEnqueues")
+  } else if (request.reason === "orphan-delta" || request.reason === "missing-delta-part") {
+    countSyncPerformance("materializationMissingPartEnqueues")
+  } else {
+    countSyncPerformance("materializationLifecycleEnqueues")
+  }
 
-  // Defer to next microtask so we don't hold up the current event batch
-  void Promise.resolve().then(async () => {
+  const run = async () => {
+    if (pending.runtimeKey !== getRuntimeKey()) {
+      if (pendingSessionMaterializations.get(k) === pending) {
+        pendingSessionMaterializations.delete(k)
+      }
+      return
+    }
     const store = childStores.getChild(directory)
     if (!store) {
-      pendingSessionMaterializations.delete(k)
+      if (pendingSessionMaterializations.get(k) === pending) {
+        pendingSessionMaterializations.delete(k)
+      }
       return
     }
     try {
+      if (!isSessionMaterializationStillNeeded(store.getState(), sessionID, request)) {
+        countSyncPerformance("materializationPreflightSkips")
+        return
+      }
+      countSyncPerformance("materializationRequests")
       await materializeSessionFromServer(directory, sessionID, store, request)
     } catch {
       // Transient failure — next SSE event or reconnect will catch up.
     } finally {
-      pendingSessionMaterializations.delete(k)
+      const remainingCooldown = SESSION_MATERIALIZATION_COOLDOWN_MS - (Date.now() - pending.enqueuedAt)
+      if (remainingCooldown <= 0) {
+        if (pendingSessionMaterializations.get(k) === pending) {
+          pendingSessionMaterializations.delete(k)
+        }
+      } else {
+        setTimeout(() => {
+          if (pendingSessionMaterializations.get(k) === pending) {
+            pendingSessionMaterializations.delete(k)
+          }
+        }, remainingCooldown)
+      }
     }
-  })
+  }
+
+  // Start after the current ordered event batch, then recheck local state
+  // before issuing HTTP in case another event in the batch repaired it.
+  void Promise.resolve().then(run)
 }
 
 async function materializeSessionFromServer(
@@ -286,40 +358,12 @@ async function materializeSessionFromServer(
     messageID: options?.messageID,
     partID: options?.partID,
   })
-  const scopedClient = opencodeClient.getScopedSdkClient(directory)
-  const result = await retry(async () => {
-    const response = await scopedClient.session.messages({ sessionID, limit: SESSION_MATERIALIZATION_MESSAGE_LIMIT })
-    assertSdkSuccess(response, "session.messages")
-    return response
-  })
-  const records = (result.data ?? []).filter((record: { info?: { id?: string } }) => !!record?.info?.id)
-  if (records.length === 0) return
-  const cursor = result.response?.headers?.get?.("x-next-cursor") ?? undefined
-  setSessionPrefetch({
-    directory,
-    sessionID,
-    limit: records.length,
-    cursor,
-    complete: !cursor,
-  })
-
-  if (options?.isStale?.()) return
-
-  store.setState((state: DirectoryStore) => {
-    const materialized = materializeSessionSnapshots(
-      state,
-      sessionID,
-      records.map((record: { info: Message; parts?: Part[] }) => ({
-        info: stripMessageDiffSnapshots(record.info),
-        parts: record.parts ?? [],
-      })),
-      { skipPartTypes: RECONNECT_SKIP_PARTS },
-    )
-    if (!materialized.messagesChanged && !materialized.partsChanged) {
-      return state
-    }
-    return { message: materialized.message, part: materialized.part }
-  })
+  const loader = getImperativeSessionMessageLoader()
+  if (!loader || options?.isStale?.()) return
+  await loader.refreshTail({ directory, sessionID }, SESSION_MATERIALIZATION_MESSAGE_LIMIT)
+  if (loader.getSnapshot({ directory, sessionID }).status === "error") {
+    throw loader.getSnapshot({ directory, sessionID }).error ?? new Error("Session materialization failed")
+  }
 
   if (statusBeforeMaterialization && statusBeforeMaterialization.type !== "idle" && !options?.isStale?.()) {
     await resyncDirectorySessionStatuses(directory, store, [sessionID], "authoritative")
@@ -344,6 +388,17 @@ function pruneExternallyViewedSessions(now = Date.now()) {
 }
 const pendingQuestionToastIds = new Set<string>()
 const pendingPermissionToastIds = new Set<string>()
+const pendingVSCodePermissionEvents = new Map<string, symbol>()
+
+const getVSCodePermissionEventKey = (
+  runtimeKey: string,
+  directory: string,
+  sessionID?: string,
+  requestID?: string,
+): string | null => {
+  const requestKey = getPermissionToastKey(sessionID, requestID)
+  return requestKey ? JSON.stringify([runtimeKey, directory, requestKey]) : null
+}
 
 const getQuestionToastKey = (sessionID?: string, requestID?: string) => {
   if (!sessionID || !requestID) return null
@@ -552,6 +607,9 @@ async function resyncDirectorySessionStatuses(
   // of active sessions — reconciled per `mode` (absence ≠ idle under monotonic).
   if (nextStatuses === null) return null
   applySessionStatusSnapshot(store, nextStatuses, candidateSessionIds, mode)
+  if (mode === "authoritative") {
+    applyGlobalSessionStatusSnapshot(directory, nextStatuses, candidateSessionIds)
+  }
   return nextStatuses
 }
 
@@ -647,12 +705,19 @@ const getSessionIdFromPayload = (event: Event): string | null => {
     || event.type === "question.asked"
     || event.type === "question.replied"
     || event.type === "question.rejected"
-    || event.type === "session.deleted"
   ) {
     const sessionID = props.sessionID
     return typeof sessionID === "string" && sessionID.length > 0 ? sessionID : null
   }
 
+  if (event.type === "session.deleted") {
+    const sessionID = props.sessionID
+    if (typeof sessionID === "string" && sessionID.length > 0) return sessionID
+    const info = props.info
+    const id = info && typeof info === "object" ? (info as { id?: unknown }).id : undefined
+    return typeof id === "string" && id.length > 0 ? id : null
+  }
+
   if (event.type === "message.part.updated") {
     const sessionID = props.sessionID
     if (typeof sessionID === "string" && sessionID.length > 0) {
@@ -857,9 +922,10 @@ const findSessionInChildStores = (
   sessionID: string,
   childStores: ChildStoreManager,
   routingIndex: EventRoutingIndex,
+  batch?: DirectoryEventBatch,
 ): string | null => {
   for (const [dir, store] of childStores.children) {
-    const state = store.getState()
+    const state = getDirectoryEventState(store, batch)
     if (
       state.session.some((s) => s.id === sessionID)
       || Object.prototype.hasOwnProperty.call(state.message, sessionID)
@@ -877,10 +943,11 @@ const childStoreHasSessionState = (
   childStores: ChildStoreManager,
   directory: string,
   sessionID: string,
+  batch?: DirectoryEventBatch,
 ): boolean => {
   const store = childStores.getChild(directory)
   if (!store) return false
-  const state = store.getState()
+  const state = getDirectoryEventState(store, batch)
   return state.session.some((session) => session.id === sessionID)
     || Object.prototype.hasOwnProperty.call(state.message, sessionID)
     || Object.prototype.hasOwnProperty.call(state.session_status ?? {}, sessionID)
@@ -890,10 +957,11 @@ const childStoreHasMessagePartState = (
   childStores: ChildStoreManager,
   directory: string,
   messageID: string,
+  batch?: DirectoryEventBatch,
 ): boolean => {
   const store = childStores.getChild(directory)
   if (!store) return false
-  return Object.prototype.hasOwnProperty.call(store.getState().part, messageID)
+  return Object.prototype.hasOwnProperty.call(getDirectoryEventState(store, batch).part, messageID)
 }
 
 const getActiveDirectoryFallback = (childStores: ChildStoreManager): string | null => {
@@ -906,12 +974,13 @@ const resolveDirectoryFromRoutingIndex = (
   rawDirectory: string,
   payload: Event,
   childStores: ChildStoreManager,
+  batch?: DirectoryEventBatch,
 ): string => {
   const normalizedDirectory = normalizeEventDirectory(rawDirectory)
 
   const sessionID = getSessionIdFromPayload(payload)
   if (sessionID) {
-    if (normalizedDirectory && normalizedDirectory !== "global" && childStoreHasSessionState(childStores, normalizedDirectory, sessionID)) {
+    if (normalizedDirectory && normalizedDirectory !== "global" && childStoreHasSessionState(childStores, normalizedDirectory, sessionID, batch)) {
       setIndexedSessionDirectory(routingIndex, sessionID, normalizedDirectory)
       return normalizedDirectory
     }
@@ -923,7 +992,7 @@ const resolveDirectoryFromRoutingIndex = (
 
     // Routing index miss — scan child stores for this session.
     // Covers optimistic sessions not yet indexed and events with wrong/empty directory.
-    const found = findSessionInChildStores(sessionID, childStores, routingIndex)
+    const found = findSessionInChildStores(sessionID, childStores, routingIndex, batch)
     if (found) {
       return found
     }
@@ -931,7 +1000,7 @@ const resolveDirectoryFromRoutingIndex = (
 
   const messageID = getMessageIdFromPayload(payload)
   if (messageID) {
-    if (normalizedDirectory && normalizedDirectory !== "global" && childStoreHasMessagePartState(childStores, normalizedDirectory, messageID)) {
+    if (normalizedDirectory && normalizedDirectory !== "global" && childStoreHasMessagePartState(childStores, normalizedDirectory, messageID, batch)) {
       return normalizedDirectory
     }
 
@@ -945,7 +1014,7 @@ const resolveDirectoryFromRoutingIndex = (
 
     // Scan child stores for a store that has parts for this message
     for (const [dir, store] of childStores.children) {
-      if (Object.prototype.hasOwnProperty.call(store.getState().part, messageID)) {
+      if (Object.prototype.hasOwnProperty.call(getDirectoryEventState(store, batch).part, messageID)) {
         return dir
       }
     }
@@ -1230,36 +1299,19 @@ async function resyncDirectoryAfterReconnect(
   const scopedClient = opencodeClient.getScopedSdkClient(directory)
   await Promise.all(candidateSessionIds.map(async (sessionId) => {
     syncDebug.recovery.materializing({ reason, directory, sessionID: sessionId })
-    const [sessionResponse, messageResponse] = await Promise.all([
+    const loader = getImperativeSessionMessageLoader()
+    const [sessionResponse] = await Promise.all([
       retry(async () => {
         const response = await scopedClient.session.get({ sessionID: sessionId })
         assertSdkSuccess(response, "session.get")
         return response
       }).catch(() => null),
-      retry(async () => {
-        const response = await scopedClient.session.messages({ sessionID: sessionId, limit: RECONNECT_MESSAGE_LIMIT })
-        assertSdkSuccess(response, "session.messages")
-        return response
-      }).catch(() => null),
+      loader?.refreshTail({ directory, sessionID: sessionId }, RECONNECT_MESSAGE_LIMIT) ?? Promise.resolve(),
     ])
     const session = sessionResponse?.data
-    const records = messageResponse?.data
-    if (!session || !records) return
-    const cursor = messageResponse.response?.headers?.get?.("x-next-cursor") ?? undefined
-    setSessionPrefetch({
-      directory,
-      sessionID: sessionId,
-      limit: records.length,
-      cursor,
-      complete: !cursor,
-    })
+    if (!session) return
 
     const nextSession = stripSessionDiffSnapshots(session)
-    const nextMessages = records
-      .filter((record) => !!record?.info?.id)
-      .map((record) => stripMessageDiffSnapshots(record.info))
-      .sort((a, b) => cmp(a.id, b.id))
-
     store.setState((state: DirectoryStore) => {
       const sessionIndex = state.session.findIndex((item) => item.id === nextSession.id)
       let sessions = state.session
@@ -1280,30 +1332,18 @@ async function resyncDirectoryAfterReconnect(
         sessionChanged = true
       }
 
-      const materialized = materializeSessionSnapshots(
-        state,
-        sessionId,
-        records.map((record) => ({
-          info: stripMessageDiffSnapshots(record.info),
-          parts: record.parts ?? [],
-        })),
-        { skipPartTypes: RECONNECT_SKIP_PARTS },
-      )
-      const messagesChanged = materialized.messagesChanged
-      const partsChanged = materialized.partsChanged
-      if (!sessionChanged && !messagesChanged && !partsChanged) {
+      if (!sessionChanged) {
         return state
       }
 
       return {
-        ...(sessionChanged ? { session: sessions, sessionTotal } : {}),
-        ...(messagesChanged ? { message: materialized.message } : {}),
-        ...(partsChanged ? { part: materialized.part } : {}),
+        session: sessions,
+        sessionTotal,
       }
     })
 
     setIndexedSessionDirectory(routingIndex, nextSession.id, directory)
-    setIndexedSessionMessages(routingIndex, sessionId, directory, nextMessages)
+    setIndexedSessionMessages(routingIndex, sessionId, directory, store.getState().message[sessionId] ?? [])
   }))
 
   await resyncBlockingRequestsForDirectory(directory, store, candidateSessionIds)
@@ -1316,22 +1356,33 @@ function handleEvent(
   payload: Event,
   childStores: ChildStoreManager,
   routingIndex: EventRoutingIndex,
+  expectedRuntimeKey: string,
   skipVSCodeAutoAccept = false,
+  streamingDirectory?: string,
+  batch?: DirectoryEventBatch,
 ) {
   if ((payload as { type?: unknown }).type === "openchamber:permission-auto-accept.updated") {
     const properties = (payload as unknown as { properties?: unknown }).properties
     if (properties && typeof properties === "object") {
-      const snapshot = properties as { sessions?: unknown }
+      const snapshot = properties as { sessions?: unknown; revision?: unknown }
       if (snapshot.sessions && typeof snapshot.sessions === "object") {
         usePermissionStore.getState().applySnapshot({
           sessions: snapshot.sessions as Record<string, boolean>,
-        })
+          revision: typeof snapshot.revision === "number" ? snapshot.revision : undefined,
+        }, expectedRuntimeKey)
       }
     }
     return
   }
 
-  const directory = resolveDirectoryFromRoutingIndex(routingIndex, rawDirectory, payload, childStores)
+  const directory = resolveDirectoryFromRoutingIndex(routingIndex, rawDirectory, payload, childStores, batch)
+
+  if (payload.type === "session.deleted" && expectedRuntimeKey === getRuntimeKey()) {
+    const sessionID = getSessionIdFromPayload(payload)
+    if (sessionID && directory && directory !== "global") {
+      cleanupPersistedSessionState({ runtimeKey: expectedRuntimeKey, directory, sessionId: sessionID })
+    }
+  }
 
   if (handleUiNotificationEvent(payload, directory)) {
     return
@@ -1367,9 +1418,12 @@ function handleEvent(
         for (const dir of childStores.children.keys()) {
           const store = childStores.getChild(dir)
           if (store && store.getState().status !== "loading") {
-            // Mark as loading to trigger re-bootstrap
-            store.setState({ status: "loading" as const })
-            childStores.ensureChild(dir)
+            childStores.requestBootstrap({
+              directory: dir,
+              priority: dir === opencodeClient.getDirectory() ? "selected" : "background",
+              reason: "server-connected",
+              force: true,
+            })
           }
         }
       }
@@ -1387,7 +1441,7 @@ function handleEvent(
     // (trailing slashes, case differences, events with wrong directory).
     const sessionID = getSessionIdFromPayload(payload)
     if (sessionID) {
-      const fallbackDir = findSessionInChildStores(sessionID, childStores, routingIndex)
+      const fallbackDir = findSessionInChildStores(sessionID, childStores, routingIndex, batch)
       if (fallbackDir) {
         store = childStores.getChild(fallbackDir)
         resolvedDirectory = fallbackDir
@@ -1414,10 +1468,20 @@ function handleEvent(
   if (payload.type === "permission.asked") {
     const permission = payload.properties as PermissionRequest
     if (isVSCodeRuntime() && !skipVSCodeAutoAccept) {
+      const eventKey = getVSCodePermissionEventKey(expectedRuntimeKey, resolvedDirectory, permission.sessionID, permission.id)
+      const eventToken = Symbol(eventKey ?? permission.id)
+      if (eventKey) pendingVSCodePermissionEvents.set(eventKey, eventToken)
       updateRoutingIndexFromEvent(routingIndex, resolvedDirectory, payload)
-      void processVSCodePermissionAutoAccept(permission, resolvedDirectory).then((accepted) => {
-        if (!accepted) handleEvent(rawDirectory, payload, childStores, routingIndex, true)
-      })
+      const completePermissionCheck = (accepted: boolean) => {
+        if (eventKey && pendingVSCodePermissionEvents.get(eventKey) !== eventToken) return
+        if (eventKey) pendingVSCodePermissionEvents.delete(eventKey)
+        if (expectedRuntimeKey !== getRuntimeKey()) return
+        if (!accepted) handleEvent(rawDirectory, payload, childStores, routingIndex, expectedRuntimeKey, true, streamingDirectory)
+      }
+      void processVSCodePermissionAutoAccept(permission, resolvedDirectory).then(
+        completePermissionCheck,
+        () => completePermissionCheck(false),
+      )
       return
     }
     if (!isVSCodeRuntime() && usePermissionStore.getState().isSessionAutoAccepting(permission.sessionID)) {
@@ -1439,6 +1503,8 @@ function handleEvent(
   if (payload.type === "permission.replied") {
     const props = payload.properties as { sessionID?: string; requestID?: string }
     const toastKey = getPermissionToastKey(props.sessionID, props.requestID)
+    const eventKey = getVSCodePermissionEventKey(expectedRuntimeKey, resolvedDirectory, props.sessionID, props.requestID)
+    if (eventKey) pendingVSCodePermissionEvents.delete(eventKey)
     if (toastKey) {
       pendingPermissionToastIds.delete(toastKey)
       toast.dismiss(`permission-${toastKey}`)
@@ -1481,7 +1547,7 @@ function handleEvent(
     const props = payload.properties as { sessionID?: string; error?: { message?: string; code?: string } }
     const sessionID = props.sessionID
     // Skip subtask sessions — only top-level sessions generate notifications
-    const storeState = store.getState()
+    const storeState = getDirectoryEventState(store, batch)
     const session = storeState.session.find((s) => s.id === sessionID)
     if (session && (session as { parentID?: string }).parentID) {
       // subtask — skip notification
@@ -1505,7 +1571,7 @@ function handleEvent(
   if (payload.type === "session.idle") {
     const idleSessionId = getSessionIdFromPayload(payload)
     if (idleSessionId && resolvedDirectory && resolvedDirectory !== "global") {
-      const sessionState = store.getState()
+      const sessionState = getDirectoryEventState(store, batch)
       const idleSession = sessionState.session.find((s) => s.id === idleSessionId)
       const parentID = idleSession
         ? (idleSession as Session & { parentID?: string | null }).parentID
@@ -1519,80 +1585,119 @@ function handleEvent(
   // Read live state, create targeted draft cloning ONLY fields that event
   // type will mutate. This preserves reference identity for untouched slices
   // so Zustand selectors skip re-renders for unrelated subscribers.
-  const current = store.getState()
+  const current = getDirectoryEventState(store, batch)
   const draft: State = { ...current }
+  const clonedFields = batch?.clonedFields.get(store) ?? new Set<keyof State>()
+  const newlyClonedFields: Array<keyof State> = []
+  const cloneField = <K extends keyof State>(field: K, clone: (value: State[K]) => State[K]) => {
+    if (clonedFields.has(field)) return
+    Object.assign(draft, { [field]: clone(current[field]) })
+    newlyClonedFields.push(field)
+  }
 
   switch (payload.type) {
     case "session.created":
     case "session.updated":
     case "session.deleted":
-      draft.session = [...current.session]
-      draft.permission = { ...current.permission }
-      draft.todo = { ...current.todo }
-      draft.part = { ...current.part }
+      cloneField("session", (value) => [...value])
+      cloneField("permission", (value) => ({ ...value }))
+      cloneField("todo", (value) => ({ ...value }))
+      cloneField("part", (value) => ({ ...value }))
+      cloneField("sessionEventRevision", (value) => ({ ...(value ?? {}) }))
+      cloneField("sessionDeletedRevision", (value) => ({ ...(value ?? {}) }))
       break
     case "session.diff":
-      draft.session_diff = { ...current.session_diff }
+      cloneField("session_diff", (value) => ({ ...value }))
       break
     case "session.status":
     case "session.idle":
     case "session.error":
-      draft.session_status = { ...(current.session_status ?? {}) }
+      cloneField("session_status", (value) => ({ ...(value ?? {}) }))
       break
     case "todo.updated":
-      draft.todo = { ...current.todo }
+      cloneField("todo", (value) => ({ ...value }))
       break
     case "message.updated":
-      draft.message = { ...current.message }
+      cloneField("message", (value) => ({ ...value }))
       break
     case "message.removed":
-      draft.message = { ...current.message }
-      draft.part = { ...current.part }
+      cloneField("message", (value) => ({ ...value }))
+      cloneField("part", (value) => ({ ...value }))
       break
     case "message.part.updated":
     case "message.part.removed":
     case "message.part.delta":
-      draft.part = { ...current.part }
+      cloneField("part", (value) => ({ ...value }))
       break
     case "vcs.branch.updated":
       break
     case "permission.asked":
     case "permission.replied":
-      draft.permission = { ...current.permission }
+      cloneField("permission", (value) => ({ ...value }))
       break
     case "question.asked":
     case "question.replied":
     case "question.rejected":
-      draft.question = { ...current.question }
+      cloneField("question", (value) => ({ ...value }))
       break
     case "lsp.updated":
-      draft.lsp = [...current.lsp]
+      cloneField("lsp", (value) => [...value])
       break
     default:
       break
   }
 
+  countSyncPerformance("reducerEvents")
   const reducerResult = applyDirectoryEvent(draft, payload, {
     onSetSessionTodo: (sessionID, todos) => {
-      useTodosPersistStore.getState().setSessionTodos(sessionID, todos)
+      useTodosPersistStore.getState().setSessionTodos(resolvedDirectory, sessionID, todos)
     },
   })
   const reducerChanged = typeof reducerResult === "boolean" ? reducerResult : reducerResult.changed
   const materializationResult = typeof reducerResult === "boolean" ? undefined : reducerResult.materialization
 
   if (reducerChanged) {
-    store.setState(draft)
-    const sessionID = getSessionIdFromPayload(payload) ?? undefined
-    const messageID = getMessageIdFromPayload(payload) ?? undefined
+    countSyncPerformance("reducerChangedEvents")
+    const eventSessionID = getSessionIdFromPayload(payload) ?? undefined
+    const eventMessageID = getMessageIdFromPayload(payload) ?? undefined
+    if (payload.type.startsWith("message.part.") && eventMessageID) {
+      const partSessionID = eventSessionID ?? routingIndex.messageSessionById.get(eventMessageID)
+      if (partSessionID) markDirectorySessionPartChanged(store, partSessionID, eventMessageID)
+    }
+    if (batch) {
+      batch.states.set(store, draft as DirectoryStore)
+      batch.changedStores.add(store)
+      if (newlyClonedFields.length > 0) {
+        newlyClonedFields.forEach((field) => clonedFields.add(field))
+        batch.clonedFields.set(store, clonedFields)
+      }
+    } else {
+      countSyncPerformance("directoryStorePublications")
+      store.setState(draft)
+    }
+    const sessionID = eventSessionID
+    const messageID = eventMessageID
+    if (
+      payload.type.startsWith("message.part.")
+      && normalizeEventDirectory(resolvedDirectory) === normalizeEventDirectory(streamingDirectory ?? "")
+    ) {
+      const heartbeatSessionID = sessionID ?? (messageID ? routingIndex.messageSessionById.get(messageID) : undefined)
+      if (heartbeatSessionID) touchStreamingSession(heartbeatSessionID)
+    }
+    const archived = payload.type === "session.updated"
+      && Boolean(((payload.properties as { info?: Session }).info)?.time.archived)
+    if (sessionID && (payload.type === "session.deleted" || archived)) {
+      getImperativeSessionMessageLoader()?.invalidateSession({ directory: resolvedDirectory, sessionID })
+    }
     syncDebug.dispatch.eventApplied(payload.type, sessionID, messageID)
 
     // Snapshot materialization on message.updated: if the message was inserted or
     // replaced but draft.part[messageID] is empty, the parts were lost or
     // never arrived. Recover the session so the UI doesn't render a blank bubble.
     if (sessionID && messageID && payload.type === "message.updated") {
-      const after = store.getState()
+      const after = getDirectoryEventState(store, batch)
       const info = (payload.properties as { info: Message }).info
-      if (info.role === "assistant" && (!after.part[messageID] || after.part[messageID].length === 0)) {
+      if (info.role === "assistant" && !Object.prototype.hasOwnProperty.call(after.part, messageID)) {
         enqueueSessionMaterialization(resolvedDirectory, sessionID, childStores, {
           reason: "empty-assistant-message",
           messageID,
@@ -1685,9 +1790,21 @@ export function SyncProvider(props: {
   const childStoresRef = useRef<ChildStoreManager | null>(null)
   if (!childStoresRef.current) childStoresRef.current = new ChildStoreManager()
   const childStores = childStoresRef.current
+  const runtimeKey = getRuntimeKey()
+  const messageLoaderRef = useRef<SessionMessageLoader | null>(null)
+  if (!messageLoaderRef.current) {
+    messageLoaderRef.current = new SessionMessageLoader(childStores, {
+      sdk: props.sdk,
+      runtimeKey,
+    })
+  }
+  const messageLoader = messageLoaderRef.current
+  messageLoader.configure({ sdk: props.sdk, runtimeKey })
   const routingIndexRef = useRef<EventRoutingIndex | null>(null)
   if (!routingIndexRef.current) routingIndexRef.current = createEventRoutingIndex()
   const routingIndex = routingIndexRef.current
+  const currentDirectoryRef = useRef(props.directory)
+  currentDirectoryRef.current = props.directory
   const lastStreamActivityAtRef = useRef(0)
   const lastStatusPollAtByDirectoryRef = useRef(new Map<string, number>())
   const lastFullResyncAtByDirectoryRef = useRef(new Map<string, number>())
@@ -1701,10 +1818,12 @@ export function SyncProvider(props: {
   const system = useMemo<SyncSystem>(
     () => ({
       childStores,
+      messageLoader,
+      runtimeKey,
       sdk: props.sdk,
       directory: props.directory,
     }),
-    [childStores, props.sdk, props.directory],
+    [childStores, messageLoader, props.sdk, props.directory, runtimeKey],
   )
 
   const triggerDirectoryResync = useCallback((directory: string, reason: SessionMaterializationReason) => {
@@ -1730,33 +1849,38 @@ export function SyncProvider(props: {
   }, [props.sdk])
 
   useEffect(() => {
-    const bootingDirs = new Set<string>()
-
-    childStores.configure({
-      onBootstrap: (directory) => {
-        if (bootingDirs.has(directory)) return
-        bootingDirs.add(directory)
-
+    return childStores.configure({
+      bootstrapConcurrency: 2,
+      onBootstrap: async (context: DirectoryBootstrapContext) => {
+        const { directory } = context
         const store = childStores.getChild(directory)
-        if (!store) return
+        if (!store || !context.isCurrent()) return
 
-        const runBootstrap = async (attempt: number) => {
+        const runBootstrap = async (attempt: number): Promise<"complete" | "failed" | "stale"> => {
+          if (!context.isCurrent()) return "stale"
           const globalState = useGlobalSyncStore.getState()
-          await bootstrapDirectory({
+          const result = await bootstrapDirectory({
             directory,
             sdk: props.sdk,
             getState: () => store.getState(),
             set: (patch) => {
+              if (!context.isCurrent()) return
               store.setState(patch)
+              if (patch.session_status) {
+                applyGlobalSessionStatusSnapshot(directory, patch.session_status, store.getState().session.map((session) => session.id))
+              }
               if (patch.session || patch.message) {
                 ingestDirectoryStateIntoRoutingIndex(routingIndex, directory, store.getState())
               }
             },
+            isStale: () => !context.isCurrent(),
             global: {
               config: globalState.config,
               projects: globalState.projects,
             },
             loadSessions: (dir) => retry(async () => {
+              if (!context.isCurrent()) return
+              const baselineRevision = store.getState().sessionRevision ?? 0
               const rootSessions = (await listGlobalSessionPages(props.sdk, {
                 directory: dir,
                 archived: false,
@@ -1768,7 +1892,7 @@ export function SyncProvider(props: {
 
               // Also load child sessions (sub-agent delegations) with pagination
               // so pending questions can scope to them immediately after restart.
-              let allSessions: typeof rootSessions = []
+              let allSessions: typeof rootSessions | null = null
               try {
                 allSessions = await listGlobalSessionPages(props.sdk, {
                   directory: dir,
@@ -1779,26 +1903,27 @@ export function SyncProvider(props: {
               } catch {
                 // Child load is best-effort; fall back to roots only.
               }
+              if (!context.isCurrent()) return
 
               // A cold OpenCode process can briefly return children before its
               // roots query catches up. Recover referenced parents from the
               // broader response or cache instead of publishing orphan rows.
-              const currentSessions = store.getState().session
-              const { sessions, rootCount } = mergeBootstrapSessions(rootSessions, allSessions, currentSessions)
-              // Race guard: if the list came back empty but event pipeline
-              // already populated the store, don't clobber. OpenCode can
-              // answer HTTP with empty sessions while WS delivers session
-              // events for the same data (disk warmup race on app launch).
-              if (sessions.length === 0 && currentSessions.length > 0) {
-                console.warn(
-                  `[bootstrap] experimental.session.list returned empty for ${dir}; preserving ${currentSessions.length} existing sessions`,
-                )
-                return
-              }
-              store.setState({ session: sessions, sessionTotal: rootCount, limit: Math.max(sessions.length, 50) })
+              const current = store.getState()
+              const { sessions, rootCount } = mergeBootstrapSessions(rootSessions, allSessions, current.session, {
+                baselineRevision,
+                eventRevision: current.sessionEventRevision,
+                deletedRevision: current.sessionDeletedRevision,
+              })
+              store.setState({
+                session: sessions,
+                sessionTotal: rootCount,
+                sessionListSource: "authoritative",
+                limit: Math.max(sessions.length, 50),
+              })
               ingestDirectoryStateIntoRoutingIndex(routingIndex, directory, store.getState())
             }),
           })
+          if (result !== "complete" || !context.isCurrent()) return result
 
           // VS Code-only race: the bridge can answer with an empty 200 (instead
           // of a retryable 503) while OpenCode is still warming up, which the two
@@ -1810,30 +1935,33 @@ export function SyncProvider(props: {
           // the directory genuinely has no sessions (e.g. a deleted worktree only
           // referenced by archived sessions). Re-running the full bootstrap 6×2s
           // per such directory is the startup log storm.
-          if (isVSCodeRuntime()) {
+          if (isVSCodeRuntime() && context.isCurrent()) {
             const state = store.getState()
             if (state.session.length === 0 && attempt < 5) {
               console.warn(`[bootstrap] sessions empty for ${directory} after attempt ${attempt + 1}; retrying in 2s`)
               await new Promise((r) => setTimeout(r, 2000))
+              if (!context.isCurrent()) return "stale"
               store.setState({ status: "loading" as const })
-              await runBootstrap(attempt + 1)
+              return runBootstrap(attempt + 1)
             } else if (state.session.length === 0) {
               console.warn(`[bootstrap] sessions empty for ${directory} after ${attempt + 1} attempts; giving up`)
             }
           }
+          return "complete"
         }
 
-        runBootstrap(0).finally(() => {
-          bootingDirs.delete(directory)
-        })
+        const result = await runBootstrap(0)
+        if (result === "failed") throw new Error(`Directory bootstrap failed for ${directory}`)
       },
       onDispose: (directory) => {
-        bootingDirs.delete(directory)
+        messageLoader.invalidateDirectory(directory)
+        lastStatusPollAtByDirectoryRef.current.delete(directory)
+        lastFullResyncAtByDirectoryRef.current.delete(directory)
+        lastChildDiscoveryAtByDirectoryRef.current.delete(directory)
       },
-      isBooting: (directory) => bootingDirs.has(directory),
       isLoadingSessions: () => false,
     })
-  }, [childStores, props.sdk, routingIndex])
+  }, [childStores, messageLoader, props.sdk, routingIndex])
 
   // Bootstrap global state — set bootingRoot/bootedAt to suppress
   // redundant refresh events during startup
@@ -1872,7 +2000,7 @@ export function SyncProvider(props: {
       routeDirectory: (directory, payload) => {
         return resolveDirectoryFromRoutingIndex(routingIndex, directory, payload, childStores)
       },
-      onEvent: (directory, payload) => {
+      onEvents: (directory, payloads) => {
         // Track ALL stream activity (including heartbeats) as proof of
         // connection health. The watchdog stale check uses this to distinguish
         // a genuinely dead stream (no heartbeats for 20s) from a quiet-but-
@@ -1880,16 +2008,23 @@ export function SyncProvider(props: {
         // heartbeats here caused issue #1656: the stale timer fired for any
         // quiet session, triggering redundant full resyncs every ~15s.
         lastStreamActivityAtRef.current = Date.now()
-        dispatchVSCodeRuntimeNotificationEvent(directory, payload)
-        if (payload.type === "installation.update-available") {
-          const version = typeof (payload.properties as { version?: unknown })?.version === "string"
-            ? (payload.properties as { version: string }).version
-            : ""
-          if (version) {
-            dispatchOpenCodeUpdateAvailableUnlessBundled({ version })
+        const batch = createDirectoryEventBatch()
+        try {
+          for (const payload of payloads) {
+            dispatchVSCodeRuntimeNotificationEvent(directory, payload)
+            if (payload.type === "installation.update-available") {
+              const version = typeof (payload.properties as { version?: unknown })?.version === "string"
+                ? (payload.properties as { version: string }).version
+                : ""
+              if (version) {
+                dispatchOpenCodeUpdateAvailableUnlessBundled({ version })
+              }
+            }
+            handleEvent(directory, payload, childStores, routingIndex, runtimeKey, false, currentDirectoryRef.current, batch)
           }
+        } finally {
+          publishDirectoryEventBatch(batch)
         }
-        handleEvent(directory, payload, childStores, routingIndex)
       },
       onReconnect: () => {
         useConfigStore.setState({
@@ -1940,7 +2075,7 @@ export function SyncProvider(props: {
       }
       pipeline.cleanup()
     }
-  }, [props.sdk, childStores, routingIndex, messageStreamTransport, triggerDirectoryResync])
+  }, [props.sdk, childStores, routingIndex, messageStreamTransport, runtimeKey, triggerDirectoryResync])
 
   useEffect(() => {
     let stopped = false
@@ -2074,7 +2209,10 @@ export function SyncProvider(props: {
   useEffect(() => {
     let seedExpiryTimer: ReturnType<typeof setTimeout> | undefined
     if (props.directory) {
-      const store = childStores.ensureChild(props.directory)
+      const store = childStores.ensureChild(props.directory, {
+        priority: "selected",
+        reason: "current-directory",
+      })
       const statusSeed = getRuntimeLiveStatusSeed(getRuntimeKey(), props.directory)
       if (statusSeed) {
         store.setState((state: DirectoryStore) => ({
@@ -2106,6 +2244,7 @@ export function SyncProvider(props: {
 
   // Set refs so non-React code (session-actions, session-ui-store) can access sync state
   useEffect(() => {
+    setImperativeSessionMessageLoader(messageLoader)
     setSyncRefs(props.sdk, childStores, props.directory, (sessionID, dir) => {
       setIndexedSessionDirectory(routingIndex, sessionID, dir)
     })
@@ -2114,7 +2253,17 @@ export function SyncProvider(props: {
       childStores,
       () => opencodeClient.getDirectory() || props.directory,
     )
-  }, [props.sdk, props.directory, childStores, routingIndex])
+    return () => {
+      if (getImperativeSessionMessageLoader() === messageLoader) {
+        setImperativeSessionMessageLoader(null)
+      }
+    }
+  }, [props.sdk, props.directory, childStores, messageLoader, routingIndex])
+
+  useEffect(() => () => {
+    messageLoader.dispose()
+    childStores.disposeAll()
+  }, [childStores, messageLoader])
 
   // Subscribe to child store for streaming state derivation
   useEffect(() => {
@@ -2122,8 +2271,8 @@ export function SyncProvider(props: {
     const store = childStores.getChild(props.directory)
     if (!store) return
     updateStreamingState(store.getState())
-    const unsubscribe = store.subscribe((state) => {
-      updateStreamingState(state)
+    const unsubscribe = store.subscribe((state, previous) => {
+      updateChangedStreamingSessions(state, previous)
     })
     return unsubscribe
   }, [props.directory, childStores])
@@ -2146,11 +2295,45 @@ export function SyncProvider(props: {
  */
 export function useDirectoryStore(
   directory?: string,
-  options?: { bootstrap?: boolean },
+  options?: {
+    bootstrap?: boolean
+    priority?: DirectoryBootstrapPriority
+    reason?: DirectoryBootstrapReason
+  },
 ): StoreApi<DirectoryStore> {
   const system = useSyncSystem()
   const dir = directory ?? system.directory
-  return system.childStores.ensureChild(dir, options)
+  const store = system.childStores.ensureChild(dir, options)
+
+  useEffect(() => {
+    system.childStores.pin(dir)
+    return () => system.childStores.unpin(dir)
+  }, [dir, system.childStores])
+
+  return store
+}
+
+export function useSessionMessageLoader(): SessionMessageLoader {
+  return useSyncSystem().messageLoader
+}
+
+export function useSessionMessageLoadState(sessionID: string, directory?: string): SessionMessageLoadState {
+  const system = useSyncSystem()
+  const runtimeKey = system.runtimeKey
+  const target = useMemo(() => ({ directory: directory ?? system.directory, sessionID }), [directory, sessionID, system.directory])
+  return React.useSyncExternalStore(
+    useCallback((notify) => {
+      void runtimeKey
+      return sessionID && target.directory ? system.messageLoader.subscribe(target, notify) : () => undefined
+    }, [sessionID, system.messageLoader, runtimeKey, target]),
+    useCallback(() => {
+      void runtimeKey
+      return sessionID && target.directory
+        ? system.messageLoader.getSnapshot(target)
+        : EMPTY_SESSION_MESSAGE_LOAD_STATE
+    }, [sessionID, system.messageLoader, runtimeKey, target]),
+    useCallback(() => EMPTY_SESSION_MESSAGE_LOAD_STATE, []),
+  )
 }
 
 /** Select from the current directory's store */
@@ -2168,7 +2351,9 @@ export function useSessionMessages(sessionID: string, directory?: string) {
   }, [sessionID, store])
   const subscribe = useCallback((notify: () => void) => {
     if (!sessionID) return () => undefined
-    return store.subscribe(notify)
+    return store.subscribe((state, previous) => {
+      if (state.message[sessionID] !== previous.message[sessionID]) notify()
+    })
   }, [sessionID, store])
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
@@ -2201,21 +2386,23 @@ export function useSessionStatus(sessionID: string, directory?: string) {
   }, [sessionID, store])
   const subscribe = useCallback((notify: () => void) => {
     if (!sessionID) return () => undefined
-    return store.subscribe(notify)
+    return store.subscribe((state, previous) => {
+      if (state.session_status?.[sessionID] !== previous.session_status?.[sessionID]) notify()
+    })
   }, [sessionID, store])
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
 
 /** Get permissions for a specific session */
-export function useSessionPermissions(sessionID: string, directory?: string) {
-  const store = useDirectoryStore(directory)
+export function useSessionPermissions(sessionID: string, directory?: string, options?: { bootstrap?: boolean }) {
+  const store = useDirectoryStore(directory, options)
   const getSnapshot = useCallback(() => {
     if (!sessionID) return EMPTY_PERMISSION_REQUESTS
     return store.getState().permission[sessionID] ?? EMPTY_PERMISSION_REQUESTS
   }, [sessionID, store])
   const subscribe = useCallback((notify: () => void) => {
     if (!sessionID) return () => undefined
-    return store.subscribe(notify)
+    return subscribeDirectoryPermission(store, sessionID, notify)
   }, [sessionID, store])
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
@@ -2319,9 +2506,11 @@ export function useSession(sessionID?: string | null, directory?: string) {
 
   const subscribe = useCallback((notify: () => void) => {
     if (directory) {
-      return childStores.ensureChild(directory).subscribe(notify)
+      return childStores.ensureChild(directory, { bootstrap: false }).subscribe((state, previous) => {
+        if (state.session !== previous.session) notify()
+      })
     }
-    return childStores.subscribeAll(notify)
+    return childStores.subscribeAllSelected((state) => state.session, notify)
   }, [childStores, directory])
 
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
@@ -2496,6 +2685,37 @@ const isSuspendExemptShellBridge = (state: State, info: Message, parts: Part[] |
   })
 }
 
+type TaskToolPart = Extract<Part, { type: "tool" }>
+
+const isTaskToolPart = (part: Part | undefined): part is TaskToolPart => (
+  part?.type === "tool" && part.tool?.trim().toLowerCase() === "task"
+)
+
+const readTaskSessionId = (part: Part | undefined): string | undefined => {
+  if (!isTaskToolPart(part)) return undefined
+  const metadata = (part.state as { metadata?: unknown } | undefined)?.metadata
+  if (!metadata || typeof metadata !== "object") return undefined
+  const record = metadata as { sessionId?: unknown; sessionID?: unknown }
+  const value = typeof record.sessionId === "string" ? record.sessionId : record.sessionID
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
+const hasTaskSessionIdentityChange = (previous: Part[], current: Part[] | undefined): boolean => {
+  let previousTaskCount = 0
+  for (const part of previous) {
+    if (!isTaskToolPart(part)) continue
+    previousTaskCount += 1
+    const currentPart = current?.find((candidate) => candidate.id === part.id && isTaskToolPart(candidate))
+    if (!currentPart || readTaskSessionId(part) !== readTaskSessionId(currentPart)) return true
+  }
+
+  let currentTaskCount = 0
+  for (const part of current ?? EMPTY_PARTS) {
+    if (isTaskToolPart(part)) currentTaskCount += 1
+  }
+  return previousTaskCount !== currentTaskCount
+}
+
 const snapshotPartsMatchState = (snapshot: SessionMessageRecordsSnapshot, state: State): boolean => {
   for (const record of snapshot.list) {
     if (snapshot.suspendPartUpdates) {
@@ -2503,6 +2723,7 @@ const snapshotPartsMatchState = (snapshot: SessionMessageRecordsSnapshot, state:
       if (
         (!suspendedID || record.info.id === suspendedID)
         && !isSuspendExemptShellBridge(state, record.info, state.part[record.info.id])
+        && !hasTaskSessionIdentityChange(record.parts, state.part[record.info.id])
       ) {
         continue
       }
@@ -2582,6 +2803,7 @@ export function buildSessionMessageRecordsSnapshot(
       && previousRecord
       && (!suspendedPartUpdatesMessageID || message.id === suspendedPartUpdatesMessageID)
       && !isSuspendExemptShellBridge(state, message, state.part[message.id])
+      && !hasTaskSessionIdentityChange(previousRecord.parts, state.part[message.id])
     const parts = shouldSuspendParts
       ? previousRecord.parts
       : (state.part[message.id] ?? EMPTY_PARTS)
@@ -2627,6 +2849,39 @@ export function useSessionMessageCount(sessionID: string, directory?: string): n
   )
 }
 
+export function useSessionRenderable(sessionID: string, directory?: string): boolean {
+  const store = useDirectoryStore(directory)
+  const renderableRef = useRef(false)
+  const getSnapshot = useCallback(() => {
+    const renderable = Boolean(sessionID && getSessionMaterializationStatus(store.getState(), sessionID).renderable)
+    renderableRef.current = renderable
+    return renderable
+  }, [sessionID, store])
+  const subscribe = useCallback(
+    (notify: () => void) => sessionID
+      ? subscribeDirectorySessionMessages(store, sessionID, (change) => {
+          const state = store.getState()
+          const remainsRenderable = change.partMessageIDs.every((messageID) => (
+            Object.prototype.hasOwnProperty.call(state.part, messageID)
+          ))
+          if (
+            !change.messagesChanged
+            && !change.reset
+            && change.partMessageIDs.length > 0
+            && renderableRef.current
+            && remainsRenderable
+          ) {
+            countSyncPerformance("sessionRenderableNotificationSkips")
+            return
+          }
+          notify()
+        })
+      : () => undefined,
+    [sessionID, store],
+  )
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
+}
+
 export function useSessionTextMessages(sessionID: string, directory?: string): SessionTextMessage[] {
   const records = useSessionMessageRecords(sessionID, directory)
 
@@ -2652,7 +2907,29 @@ export function useUserMessageHistory(sessionID: string, directory?: string): st
 
   const subscribe = useCallback((notify: () => void) => {
     if (!sessionID) return () => undefined
-    return store.subscribe(notify)
+    const unsubscribeMessages = subscribeDirectorySessionMessages(store, sessionID, (change) => {
+      if (!change.messagesChanged && !change.reset && change.partMessageIDs.length > 0) {
+        const records = snapshotRef.current.sessionID === sessionID ? snapshotRef.current.records : []
+        const affectsUserHistory = change.partMessageIDs.some((messageID) => (
+          records.some((record) => record.message.id === messageID)
+        ))
+        if (!affectsUserHistory) {
+          countSyncPerformance("userMessageHistoryNotificationSkips")
+          return
+        }
+      }
+      notify()
+    })
+    const unsubscribeSession = store.subscribe((state, previous) => {
+      if (state.session === previous.session) return
+      const currentRevert = state.session.find((session) => session.id === sessionID)?.revert?.messageID
+      const previousRevert = previous.session.find((session) => session.id === sessionID)?.revert?.messageID
+      if (currentRevert !== previousRevert) notify()
+    })
+    return () => {
+      unsubscribeMessages()
+      unsubscribeSession()
+    }
   }, [sessionID, store])
 
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
@@ -2668,7 +2945,7 @@ export function useUserMessageHistory(sessionID: string, directory?: string): st
 export function useSessionMessageRecords(
   sessionID: string,
   directory?: string,
-  options?: { suspendPartUpdates?: boolean; suspendPartUpdatesForMessageId?: string | null },
+  options?: { enabled?: boolean; suspendPartUpdates?: boolean; suspendPartUpdatesForMessageId?: string | null },
 ) {
   const store = useDirectoryStore(directory)
   const snapshotRef = useRef<SessionMessageRecordsSnapshot>({
@@ -2686,6 +2963,9 @@ export function useSessionMessageRecords(
     if (!sessionID) {
       return EMPTY_SESSION_MESSAGE_RECORDS
     }
+    if (options?.enabled === false) {
+      return snapshotRef.current.sessionID === sessionID ? snapshotRef.current.list : EMPTY_SESSION_MESSAGE_RECORDS
+    }
 
     const state = store.getState()
     const suspendPartUpdates = Boolean(options?.suspendPartUpdates)
@@ -2716,12 +2996,45 @@ export function useSessionMessageRecords(
     snapshotRef.current = nextSnapshot
     rememberSessionMessageRecordsSnapshot(store, nextSnapshot)
     return nextSnapshot.list
-  }, [options?.suspendPartUpdates, options?.suspendPartUpdatesForMessageId, sessionID, store])
+  }, [options?.enabled, options?.suspendPartUpdates, options?.suspendPartUpdatesForMessageId, sessionID, store])
 
   const subscribe = useCallback((notify: () => void) => {
-    if (!sessionID) return () => undefined
-    return store.subscribe(notify)
-  }, [sessionID, store])
+    if (!sessionID || options?.enabled === false) return () => undefined
+    const unsubscribeMessages = subscribeDirectorySessionMessages(store, sessionID, (change) => {
+      const suspendPartUpdates = Boolean(options?.suspendPartUpdates)
+      const suspendedPartUpdatesMessageID = options?.suspendPartUpdatesForMessageId ?? undefined
+      if (!change.messagesChanged && !change.reset && suspendPartUpdates && change.partMessageIDs.length > 0) {
+        const state = store.getState()
+        const snapshot = snapshotRef.current.sessionID === sessionID ? snapshotRef.current : undefined
+        const allChangesSuspended = change.partMessageIDs.every((messageID) => {
+          if (suspendedPartUpdatesMessageID && messageID !== suspendedPartUpdatesMessageID) return false
+          const message = snapshot?.byId.get(messageID)?.info
+          const previousParts = snapshot?.byId.get(messageID)?.parts
+          return Boolean(
+            message
+            && previousParts
+            && !isSuspendExemptShellBridge(state, message, state.part[messageID])
+            && !hasTaskSessionIdentityChange(previousParts, state.part[messageID]),
+          )
+        })
+        if (allChangesSuspended) {
+          countSyncPerformance("sessionMessageRecordNotificationSkips")
+          return
+        }
+      }
+      notify()
+    })
+    const unsubscribeSession = store.subscribe((state, previous) => {
+      if (state.session === previous.session) return
+      const currentRevert = state.session.find((session) => session.id === sessionID)?.revert?.messageID
+      const previousRevert = previous.session.find((session) => session.id === sessionID)?.revert?.messageID
+      if (currentRevert !== previousRevert) notify()
+    })
+    return () => {
+      unsubscribeMessages()
+      unsubscribeSession()
+    }
+  }, [options?.enabled, options?.suspendPartUpdates, options?.suspendPartUpdatesForMessageId, sessionID, store])
 
   return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
 }
diff --git a/packages/ui/src/sync/types.ts b/packages/ui/src/sync/types.ts
index d95cdac9..edb88e1a 100644
--- a/packages/ui/src/sync/types.ts
+++ b/packages/ui/src/sync/types.ts
@@ -51,6 +51,10 @@ export type State = {
   path: Path
   session: Session[]
   sessionTotal: number
+  sessionListSource?: "empty" | "persisted" | "live" | "authoritative"
+  sessionRevision?: number
+  sessionEventRevision?: Record<string, number>
+  sessionDeletedRevision?: Record<string, number>
   session_status: Record<string, SessionStatus>
   session_diff: Record<string, FileDiff[]>
   todo: Record<string, Todo[]>
@@ -121,6 +125,10 @@ export const INITIAL_STATE: State = {
   command: [],
   session: [],
   sessionTotal: 0,
+  sessionListSource: "empty",
+  sessionRevision: 0,
+  sessionEventRevision: {},
+  sessionDeletedRevision: {},
   session_status: {},
   session_diff: {},
   todo: {},
diff --git a/packages/ui/src/sync/use-sync.ts b/packages/ui/src/sync/use-sync.ts
index 9a50ad01..dd7ee58a 100644
--- a/packages/ui/src/sync/use-sync.ts
+++ b/packages/ui/src/sync/use-sync.ts
@@ -1,41 +1,40 @@
-import { useCallback, useRef, useMemo } from "react"
+import { useCallback, useMemo } from "react"
 import type { Message, Part } from "@opencode-ai/sdk/v2/client"
 import { Binary } from "./binary"
 import { retry } from "./retry"
 import { SESSION_CACHE_LIMIT, type State } from "./types"
 import { pickSessionCacheEvictions } from "./session-cache"
 import {
-  mergeOptimisticPage,
-  type OptimisticItem,
-} from "./optimistic"
-import { dropCachedSessionMessageRecordsSnapshots, useDirectoryStore, useSyncSDK, useSyncDirectory, useChildStoreManager } from "./sync-context"
+  dropCachedSessionMessageRecordsSnapshots,
+  useChildStoreManager,
+  useDirectoryStore,
+  useSessionMessageLoader,
+  useSyncDirectory,
+  useSyncSDK,
+} from "./sync-context"
 import { dropSessionCaches, getProtectedSessionCacheIds } from "./session-cache"
-import { stripMessageDiffSnapshots, stripSessionDiffSnapshots } from "./sanitize"
+import { stripSessionDiffSnapshots } from "./sanitize"
 import { isVSCodeRuntime } from "@/lib/desktop"
 import { isMobileSurfaceRuntime } from "@/lib/runtimeSurface"
-import {
-  shouldSkipSessionPrefetch,
-  getSessionPrefetch,
-  setSessionPrefetch,
-  clearSessionPrefetch,
-} from "./session-prefetch-cache"
-import { getSessionMaterializationStatus, materializeSessionSnapshots } from "./materialization"
+import { clearSessionPrefetch } from "./session-prefetch-cache"
+import { getSessionMaterializationStatus } from "./materialization"
+import { getRuntimeKey } from "@/lib/runtime-switch"
 
-const SKIP_PARTS = new Set(["patch", "step-start", "step-finish"])
 const INITIAL_MESSAGE_PAGE_SIZE = 50
 const VSCODE_INITIAL_MESSAGE_PAGE_SIZE = 30
 const MOBILE_INITIAL_MESSAGE_PAGE_SIZE = 30
-const HISTORY_MESSAGE_PAGE_SIZE = 100
-const INITIAL_PAGE_EXPANSION_LIMITS = [100, 150] as const
-const VSCODE_INITIAL_PAGE_EXPANSION_LIMITS = [50, 80, 120] as const
 const MAX_SEEN_DIRS = 30
 const VSCODE_SESSION_CACHE_LIMIT = 4
 const MOBILE_SESSION_CACHE_LIMIT = 4
-const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 
 // Shared across useSync() instances so cache eviction is based on app-level
 // session recency, not whichever component happened to call sync first.
-const seenByDirectory = new Map<string, Set<string>>()
+type SeenDirectoryEntry = {
+  runtimeKey: string
+  directory: string
+  sessions: Set<string>
+}
+const seenByDirectory = new Map<string, SeenDirectoryEntry>()
 
 // Shared across useSync() hook instances. Chat, model controls, and sidebar can
 // all request the same session during startup; coalesce them into one HTTP load.
@@ -47,13 +46,6 @@ const syncSessionInflightByKey = new Map<string, Promise<void>>()
 // sidebar) from having each completed fetch fight for focus.
 const syncSessionGenerationByKey = new Map<string, number>()
 
-type SyncMeta = {
-  limit: number
-  cursor: string | undefined
-  complete: boolean
-  loading: boolean
-}
-
 type SdkResult<T> = {
   data?: T
   error?: unknown
@@ -84,7 +76,6 @@ function assertSdkSuccess<T>(result: SdkResult<T>, operation: string): void {
 }
 
 const isConstrainedSessionRuntime = () => isVSCodeRuntime() || isMobileSurfaceRuntime()
-const getConstrainedInitialPageExpansionMax = () => VSCODE_INITIAL_PAGE_EXPANSION_LIMITS[VSCODE_INITIAL_PAGE_EXPANSION_LIMITS.length - 1]
 const getEffectiveSessionCacheLimit = () => {
   if (isVSCodeRuntime()) return VSCODE_SESSION_CACHE_LIMIT
   if (isMobileSurfaceRuntime()) return MOBILE_SESSION_CACHE_LIMIT
@@ -95,26 +86,6 @@ const getInitialMessagePageSize = () => {
   if (isMobileSurfaceRuntime()) return MOBILE_INITIAL_MESSAGE_PAGE_SIZE
   return INITIAL_MESSAGE_PAGE_SIZE
 }
-const getInitialPageExpansionLimits = () => isConstrainedSessionRuntime()
-  ? VSCODE_INITIAL_PAGE_EXPANSION_LIMITS
-  : INITIAL_PAGE_EXPANSION_LIMITS
-const getDefaultMeta = (): SyncMeta => ({ limit: getInitialMessagePageSize(), cursor: undefined, complete: false, loading: false })
-
-function getPrefetchMeta(directory: string, sessionID: string): SyncMeta | undefined {
-  const info = getSessionPrefetch(directory, sessionID)
-  if (!info) return undefined
-  return {
-    limit: info.limit,
-    cursor: info.cursor,
-    complete: info.complete,
-    loading: false,
-  }
-}
-
-function sortParts(parts: Part[]) {
-  return parts.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id))
-}
-
 function isHeavyConstrainedSessionCache(state: Pick<State, "message" | "part">, sessionID: string): boolean {
   const messages = state.message[sessionID]
   if (!messages || messages.length === 0) return false
@@ -149,31 +120,12 @@ export function useSync() {
   const directory = useSyncDirectory()
   const store = useDirectoryStore()
   const childStores = useChildStoreManager()
-
-  // Refs for mutable tracking (no re-renders)
-  const optimistic = useRef(new Map<string, Map<string, OptimisticItem>>())
-  const meta = useRef(new Map<string, SyncMeta>())
+  const messageLoader = useSessionMessageLoader()
+  const runtimeKey = getRuntimeKey()
 
   const keyFor = useCallback(
-    (sessionID: string) => `${directory}\n${sessionID}`,
-    [directory],
-  )
-
-  const getMetaFor = useCallback(
-    (sessionID: string) => {
-      const key = keyFor(sessionID)
-      return meta.current.get(key) ?? getPrefetchMeta(directory, sessionID) ?? getDefaultMeta()
-    },
-    [directory, keyFor],
-  )
-
-  const setMetaFor = useCallback(
-    (sessionID: string, patch: Partial<{ limit: number; cursor: string | undefined; complete: boolean; loading: boolean }>) => {
-      const key = keyFor(sessionID)
-      const current = meta.current.get(key) ?? getPrefetchMeta(directory, sessionID) ?? getDefaultMeta()
-      meta.current.set(key, { ...current, ...patch })
-    },
-    [directory, keyFor],
+    (sessionID: string, directoryOverride = directory) => `${runtimeKey}\n${directoryOverride}\n${sessionID}`,
+    [directory, runtimeKey],
   )
 
   // Session cache eviction — two levels of LRU:
@@ -182,7 +134,7 @@ export function useSync() {
   // Evict all cached session data for given IDs from a directory's store
   const evict = useCallback(
     (dir: string, sessionIDs: string[]) => {
-      if (sessionIDs.length === 0) return
+      if (sessionIDs.length === 0 || getRuntimeKey() !== runtimeKey) return
       const dirStore = childStores.getChild(dir)
       if (!dirStore) return
 
@@ -202,45 +154,49 @@ export function useSync() {
 
       // Clear meta + optimistic + prefetch cache for evicted sessions
       for (const id of sessionIDs) {
-        optimistic.current.delete(`${dir}\n${id}`)
-        meta.current.delete(`${dir}\n${id}`)
+        messageLoader.invalidateSession({ directory: dir, sessionID: id })
       }
       clearSessionPrefetch(dir, sessionIDs)
     },
-    [childStores],
+    [childStores, messageLoader, runtimeKey],
   )
 
   // Get or create the seen-set for a directory. LRU reorder on access.
   // When seen directories exceed MAX_SEEN_DIRS, evict the oldest directory's caches.
   // LRU reorder on access. Evicts oldest directory when exceeding MAX_SEEN_DIRS.
-  const seenFor = useCallback(() => {
-    const existing = seenByDirectory.get(directory)
+  const seenFor = useCallback((targetDirectory: string) => {
+    const cacheKey = `${runtimeKey}\n${targetDirectory}`
+    const existing = seenByDirectory.get(cacheKey)
     if (existing) {
       // LRU reorder: delete + re-insert moves to end (most recent)
-      seenByDirectory.delete(directory)
-      seenByDirectory.set(directory, existing)
-      return existing
+      seenByDirectory.delete(cacheKey)
+      seenByDirectory.set(cacheKey, existing)
+      return existing.sessions
     }
-    const created = new Set<string>()
-    seenByDirectory.set(directory, created)
+    const created: SeenDirectoryEntry = { runtimeKey, directory: targetDirectory, sessions: new Set() }
+    seenByDirectory.set(cacheKey, created)
 
     // Evict oldest directories if over limit
     while (seenByDirectory.size > MAX_SEEN_DIRS) {
       const first = seenByDirectory.keys().next().value
       if (!first) break
-      const staleSessionIds = [...(seenByDirectory.get(first) ?? [])]
+      const stale = seenByDirectory.get(first)
       seenByDirectory.delete(first)
-      evict(first, staleSessionIds)
+      if (stale?.runtimeKey === runtimeKey) evict(stale.directory, [...stale.sessions])
     }
 
-    return created
-  }, [directory, evict])
+    return created.sessions
+  }, [evict, runtimeKey])
 
   // Touch a session — triggers both directory-level and session-level eviction
   const touch = useCallback(
-    (sessionID: string) => {
-      const s = seenFor()
-      const protectedIds = getProtectedSessionCacheIds(store.getState())
+    (sessionID: string, targetDirectory = directory) => {
+      if (getRuntimeKey() !== runtimeKey) return
+      const s = seenFor(targetDirectory)
+      const targetStore = targetDirectory === directory
+        ? store
+        : childStores.ensureChild(targetDirectory, { bootstrap: false })
+      const protectedIds = getProtectedSessionCacheIds(targetStore.getState())
       const cacheLimit = getEffectiveSessionCacheLimit()
       const stale = pickSessionCacheEvictions({
         seen: s,
@@ -248,266 +204,38 @@ export function useSync() {
         limit: cacheLimit,
         preserve: protectedIds,
       })
-      evict(directory, stale)
+      evict(targetDirectory, stale)
 
       if (isConstrainedSessionRuntime()) {
-        const state = store.getState()
+        const state = targetStore.getState()
         const keep = new Set([sessionID, ...s, ...protectedIds])
         const prefetched = Object.keys(state.message).filter((id) => !keep.has(id))
-        evict(directory, prefetched)
+        evict(targetDirectory, prefetched)
 
         // One very large inactive session can create memory/GC pressure that
         // makes later small-session switches feel slow. Keep it while active,
         // but do not retain it as a warm cache in constrained shells.
-        const afterPrefetchEviction = prefetched.length > 0 ? store.getState() : state
+          const afterPrefetchEviction = prefetched.length > 0 ? targetStore.getState() : state
         const heavyInactive = Object.keys(afterPrefetchEviction.message).filter((id) => {
           if (id === sessionID || protectedIds.has(id)) return false
           return isHeavyConstrainedSessionCache(afterPrefetchEviction, id)
         })
         if (heavyInactive.length > 0) {
           for (const id of heavyInactive) s.delete(id)
-          evict(directory, heavyInactive)
+          evict(targetDirectory, heavyInactive)
         }
       }
     },
-    [directory, seenFor, evict, store],
-  )
-
-  // Optimistic operations
-  const getOptimistic = useCallback(
-    (sessionID: string, directoryOverride?: string | null): OptimisticItem[] => {
-      const key = `${directoryOverride || directory}\n${sessionID}`
-      return [...(optimistic.current.get(key)?.values() ?? [])]
-    },
-    [directory],
-  )
-
-  const setOptimistic = useCallback(
-    (sessionID: string, item: OptimisticItem, directoryOverride?: string | null) => {
-      const key = `${directoryOverride || directory}\n${sessionID}`
-      const list = optimistic.current.get(key)
-      const sorted: OptimisticItem = { message: item.message, parts: sortParts(item.parts) }
-      if (list) {
-        list.set(item.message.id, sorted)
-      } else {
-        optimistic.current.set(key, new Map([[item.message.id, sorted]]))
-      }
-    },
-    [directory],
-  )
-
-  const clearOptimistic = useCallback(
-    (sessionID: string, messageID?: string, directoryOverride?: string | null) => {
-      const key = `${directoryOverride || directory}\n${sessionID}`
-      if (!messageID) {
-        optimistic.current.delete(key)
-        return
-      }
-      const list = optimistic.current.get(key)
-      if (!list) return
-      list.delete(messageID)
-      if (list.size === 0) optimistic.current.delete(key)
-    },
-    [directory],
-  )
-
-  const getOptimisticStore = useCallback(
-    (directoryOverride?: string | null) => {
-      if (!directoryOverride || directoryOverride === directory) return store
-      return childStores.ensureChild(directoryOverride, { bootstrap: false })
-    },
-    [childStores, directory, store],
-  )
-
-  // Fetch messages from API
-  const fetchMessages = useCallback(
-    async (sessionID: string, limit: number, before?: string) => {
-      const result = await retry(async () => {
-        const response = await sdk.session.messages({ sessionID, directory, limit, before })
-        assertSdkSuccess(response, "session.messages")
-        return response
-      })
-      const items = (result.data ?? []).filter((x: { info?: { id?: string } }) => !!x?.info?.id)
-      const session = items
-        .map((x: { info: Message }) => stripMessageDiffSnapshots(x.info))
-        .sort((a: Message, b: Message) => cmp(a.id, b.id))
-      const part = items.map((x: { info: { id: string }; parts: Part[] }) => ({
-        id: x.info.id,
-        part: sortParts(x.parts),
-      }))
-      const cursor = result.response?.headers?.get?.("x-next-cursor") ?? undefined
-      return { session, part, cursor, complete: !cursor }
-    },
-    [sdk, directory],
-  )
-
-  // Load messages for a session
-  const loadMessages = useCallback(
-    async (sessionID: string, options?: { before?: string; mode?: "replace" | "prepend"; isStale?: () => boolean }) => {
-      const m = getMetaFor(sessionID)
-      if (m.loading) return
-      setMetaFor(sessionID, { loading: true })
-
-      try {
-        // Commit a fetched page to the store: merge optimistic items, run
-        // materialization, and write the result so the UI can render it.
-        // Returns the committed meta so the caller can update pagination
-        // state once at the end. The store write happens here (per page) so
-        // the hydrating skeleton disappears after the first fetch instead of
-        // waiting for the full expansion sequence.
-        const commitMessagesToStore = (
-          page: Awaited<ReturnType<typeof fetchMessages>>,
-          mode: "replace" | "prepend" | undefined,
-          isStale?: () => boolean,
-        ) => {
-          if (isStale?.()) {
-            return { messages: [], cursor: page.cursor, complete: page.complete }
-          }
-
-          const items = getOptimistic(sessionID)
-          const merged = mergeOptimisticPage(page, items)
-          for (const messageID of merged.confirmed) {
-            clearOptimistic(sessionID, messageID)
-          }
-
-          const current = store.getState()
-          const materialized = materializeSessionSnapshots(
-            current,
-            sessionID,
-            merged.session.map((info) => ({
-              info,
-              parts: merged.part.find((item) => item.id === info.id)?.part ?? [],
-            })),
-            { skipPartTypes: SKIP_PARTS, mode: mode === "prepend" ? "prepend" : "merge" },
-          )
-
-          // materializeSessionSnapshots is synchronous today, so this check
-          // is defense-in-depth: it guards the store write if materialization
-          // ever becomes async or yields between the check above and setState.
-          if (isStale?.()) {
-            return { messages: [], cursor: merged.cursor, complete: merged.complete }
-          }
-
-          if (materialized.messagesChanged || materialized.partsChanged) {
-            store.setState({
-              ...(materialized.messagesChanged ? { message: materialized.message } : {}),
-              ...(materialized.partsChanged ? { part: materialized.part } : {}),
-            })
-          }
-          return { messages: materialized.messages, cursor: merged.cursor, complete: merged.complete }
-        }
-
-        // Live events can append messages without growing m.limit. A resync
-        // must cover everything already rendered or it can manufacture an
-        // "older" cursor for history that is already on screen.
-        const storeMessageCount = store.getState().message[sessionID]?.length ?? 0
-        const limit = options?.before
-          ? HISTORY_MESSAGE_PAGE_SIZE
-          : Math.max(m.limit, storeMessageCount)
-        const page = await fetchMessages(sessionID, limit, options?.before)
-
-        // Commit the first page to the store immediately so the hydrating
-        // skeleton disappears after a single round-trip — but only when the
-        // page already contains a user message boundary. If the tail is
-        // assistant/tool-only (a very large final turn), committing now would
-        // drop the skeleton and render an empty chat (turn projection skips
-        // assistant messages without a user parent), which looks like a fresh
-        // session instead of a loading state. In that case defer the first
-        // commit to the expansion loop below, which fetches older records
-        // until a user boundary appears and commits that page instead.
-        //
-        // The deferral only applies to the initial fetch (no `before`).
-        // Prepend mode (loading older history) always commits — messages are
-        // already rendered, so there is no skeleton to protect, and skipping
-        // the store write would drop the fetched older messages entirely.
-        //
-        // The deferred fallback carries page.session (not []) so that if the
-        // expansion loop is ever a no-op (e.g. all nextLimit <= limit after a
-        // constant change), the final setMetaFor reflects the real fetched
-        // count instead of overwriting it with 0.
-        const deferFirstCommit =
-          !options?.before && !page.complete && !hasUserMessage(page.session)
-        let committed = deferFirstCommit
-          ? { messages: page.session, cursor: page.cursor, complete: page.complete }
-          : commitMessagesToStore(page, options?.mode, options?.isStale)
-
-        // If the first commit detected a stale session, bail out immediately
-        // instead of relying on downstream guards to skip the final setMetaFor.
-        if (options?.isStale?.()) {
-          setMetaFor(sessionID, { loading: false })
-          return
-        }
-
-        // Keep the initial page small for switch performance. Some sessions
-        // have a very large final turn, so the latest records can
-        // contain only assistant/tool records and no user boundary. That makes
-        // turn projection render an empty chat until the user manually loads
-        // older messages. Expand only this initial tail fetch, with a hard cap.
-        // Each expanded page is committed to the store incrementally so the
-        // user sees content as soon as a user boundary appears, instead of
-        // waiting for the full expansion sequence before the first paint.
-        if (!options?.before && !page.complete && !hasUserMessage(page.session)) {
-          const expansionLimits = getInitialPageExpansionLimits().filter((nextLimit) => nextLimit > limit)
-          for (let index = 0; index < expansionLimits.length; index += 1) {
-            const nextLimit = expansionLimits[index]
-            if (options?.isStale?.()) {
-              setMetaFor(sessionID, { loading: false })
-              return
-            }
-            const expandedPage = await fetchMessages(sessionID, nextLimit)
-            if (options?.isStale?.()) {
-              setMetaFor(sessionID, { loading: false })
-              return
-            }
-            const hasBoundary = hasUserMessage(expandedPage.session)
-            const isFinalExpansion = index === expansionLimits.length - 1
-            if (expandedPage.complete || hasBoundary || isFinalExpansion) {
-              committed = commitMessagesToStore(expandedPage, options?.mode, options?.isStale)
-            } else {
-              committed = {
-                messages: expandedPage.session,
-                cursor: expandedPage.cursor,
-                complete: expandedPage.complete,
-              }
-            }
-            if (options?.isStale?.()) {
-              setMetaFor(sessionID, { loading: false })
-              return
-            }
-            if (expandedPage.complete || hasBoundary) break
-          }
-        }
-
-        if (options?.isStale?.()) {
-          setMetaFor(sessionID, { loading: false })
-          return
-        }
-
-        setMetaFor(sessionID, {
-          limit: committed.messages.length,
-          cursor: committed.cursor,
-          complete: committed.complete,
-          loading: false,
-        })
-        setSessionPrefetch({
-          directory,
-          sessionID,
-          limit: committed.messages.length,
-          cursor: committed.cursor,
-          complete: committed.complete,
-        })
-      } catch {
-        setMetaFor(sessionID, { loading: false })
-      }
-    },
-    [store, fetchMessages, getMetaFor, setMetaFor, getOptimistic, clearOptimistic, directory],
+    [childStores, directory, seenFor, evict, runtimeKey, store],
   )
 
   // Sync a session (load if not cached)
   const syncSession = useCallback(
-    async (sessionID: string, force?: boolean) => {
-      touch(sessionID)
-      const key = keyFor(sessionID)
+    async (sessionID: string, force?: boolean, directoryOverride?: string) => {
+      if (getRuntimeKey() !== runtimeKey) return
+      const targetDirectory = directoryOverride || directory
+      touch(sessionID, targetDirectory)
+      const key = keyFor(sessionID, targetDirectory)
 
       // Dedup inflight requests
       const existing = syncSessionInflightByKey.get(key)
@@ -520,39 +248,14 @@ export function useSync() {
       syncSessionGenerationByKey.set(key, generation)
       const isStale = () => syncSessionGenerationByKey.get(key) !== generation
 
-      const current = store.getState()
-      const m = getMetaFor(sessionID)
+      const targetStore = targetDirectory === directory
+        ? store
+        : childStores.ensureChild(targetDirectory, { bootstrap: false })
+      const current = targetStore.getState()
       const materialization = getSessionMaterializationStatus(current, sessionID)
-      const cached = materialization.hasMessages && materialization.renderable && m.limit > 0
-      const prefetchInfo = !force ? getSessionPrefetch(directory, sessionID) : undefined
-      const knownCachedLimit = Math.max(m.limit, prefetchInfo?.limit ?? 0)
-      const needsConstrainedInitialTurnBoundary = isConstrainedSessionRuntime()
-        && cached
-        && !hasUserMessage(current.message[sessionID])
-        && knownCachedLimit < getConstrainedInitialPageExpansionMax()
-        && !m.complete
-        && prefetchInfo?.complete !== true
-        && Boolean(m.cursor ?? prefetchInfo?.cursor)
-      if (needsConstrainedInitialTurnBoundary && prefetchInfo && prefetchInfo.limit > m.limit) {
-        setMetaFor(sessionID, {
-          limit: prefetchInfo.limit,
-          cursor: prefetchInfo.cursor,
-          complete: prefetchInfo.complete,
-        })
-      }
-      const cachedReady = cached && !needsConstrainedInitialTurnBoundary
+      const cachedReady = materialization.hasMessages && materialization.renderable
       const hasSession = Binary.search(current.session, sessionID, (s) => s.id).found
       if (cachedReady && hasSession && !force) return
-
-      // Skip if recently fetched (TTL)
-      if (!force && !needsConstrainedInitialTurnBoundary) {
-        if (shouldSkipSessionPrefetch({
-          hasMessages: cachedReady,
-          info: prefetchInfo,
-          pageSize: getInitialMessagePageSize(),
-        })) return
-      }
-
       const shouldLoadMessages = Boolean(!cachedReady || force)
       const shouldFetchSession = shouldFetchSessionForRenderableSync({ hasSession, shouldLoadMessages, force: Boolean(force) })
       const promise = (async () => {
@@ -561,13 +264,13 @@ export function useSync() {
             ? (async () => {
                 try {
                   const result = await retry(async () => {
-                    const response = await sdk.session.get({ sessionID, directory })
+                    const response = await sdk.session.get({ sessionID, directory: targetDirectory })
                     assertSdkSuccess(response, "session.get")
                     return response
                   })
                   if (result.data && !isStale()) {
                     const nextSession = stripSessionDiffSnapshots(result.data)
-                    const s = store.getState()
+                    const s = targetStore.getState()
                     const sessions = [...s.session]
                     const idx = Binary.search(sessions, sessionID, (s) => s.id)
                     if (idx.found) {
@@ -576,7 +279,7 @@ export function useSync() {
                       sessions.splice(idx.index, 0, nextSession)
                     }
                     if (!isStale()) {
-                      store.setState({ session: sessions })
+                      targetStore.setState({ session: sessions })
                     }
                   }
                 } catch (e) {
@@ -584,128 +287,115 @@ export function useSync() {
                 }
               })()
             : Promise.resolve(),
-          shouldLoadMessages ? loadMessages(sessionID, { isStale }) : Promise.resolve(),
+          shouldLoadMessages
+            ? messageLoader.ensure(
+                { directory: targetDirectory, sessionID },
+                { force, reason: "reactive" },
+              )
+            : Promise.resolve(),
         ])
-
-        // Progressive mount (desktop/VS Code): after the initial page
-        // resolves, if the session isn't stale and the server indicated more
-        // messages, dispatch a second fetch to prepend older history — it
-        // gives the scroll container headroom so the scroll-up trigger fires
-        // seamlessly. Mobile deliberately opts out: it has no scroll-position
-        // trigger at all — ALL older history loads happen through the
-        // explicit "load older" button at the top, so every prepend lands
-        // from a resting state the user initiated. (The initial page itself,
-        // including the turn-boundary extension, is unaffected.)
-        if (!isStale() && !isMobileSurfaceRuntime()) {
-          const currentMeta = getMetaFor(sessionID)
-          if (currentMeta.cursor && !currentMeta.complete) {
-            loadMessages(sessionID, { before: currentMeta.cursor, mode: "prepend", isStale })
-          }
-        }
       })()
 
       syncSessionInflightByKey.set(key, promise)
-      promise.finally(() => {
+      const clearInflightRequest = () => {
         if (syncSessionInflightByKey.get(key) === promise) {
           syncSessionInflightByKey.delete(key)
+          if (syncSessionGenerationByKey.get(key) === generation) {
+            syncSessionGenerationByKey.delete(key)
+          }
         }
-      })
+      }
+      void promise.then(clearInflightRequest, clearInflightRequest)
       return promise
     },
-    [store, sdk, keyFor, touch, getMetaFor, setMetaFor, loadMessages, directory],
+    [childStores, directory, keyFor, messageLoader, runtimeKey, sdk, store, touch],
   )
 
   // Load more (pagination)
   const loadMore = useCallback(
-    async (sessionID: string) => {
-      touch(sessionID)
-      const m = getMetaFor(sessionID)
-      if (m.loading || m.complete || !m.cursor) return
-      await loadMessages(sessionID, { before: m.cursor, mode: "prepend" })
+    async (sessionID: string, directoryOverride?: string) => {
+      const targetDirectory = directoryOverride || directory
+      touch(sessionID, targetDirectory)
+      await messageLoader.loadOlder({ directory: targetDirectory, sessionID })
     },
-    [touch, getMetaFor, loadMessages],
+    [directory, messageLoader, touch],
+  )
+
+  const prefetchSession = useCallback(
+    async (sessionID: string, targetDirectory: string) => {
+      if (getRuntimeKey() !== runtimeKey) return
+      await messageLoader.prefetch({ directory: targetDirectory, sessionID })
+      if (messageLoader.getSnapshot({ directory: targetDirectory, sessionID }).status === "ready") {
+        touch(sessionID, targetDirectory)
+      }
+    },
+    [messageLoader, runtimeKey, touch],
   )
 
   const hasMore = useCallback(
-    (sessionID: string) => {
-      const m = getMetaFor(sessionID)
-      return !m.complete && !!m.cursor
+    (sessionID: string, directoryOverride?: string) => {
+      const state = messageLoader.getSnapshot({ directory: directoryOverride || directory, sessionID })
+      return !state.complete && Boolean(state.cursor)
     },
-    [getMetaFor],
+    [directory, messageLoader],
   )
 
   const isLoading = useCallback(
-    (sessionID: string) => getMetaFor(sessionID).loading,
-    [getMetaFor],
+    (sessionID: string, directoryOverride?: string) => messageLoader
+      .getSnapshot({ directory: directoryOverride || directory, sessionID }).status === "loading",
+    [directory, messageLoader],
   )
 
   // True only when a fetch has positively confirmed the history is fully
   // loaded (no next cursor). Distinct from !hasMore(), which is also true for
   // sessions whose meta simply hasn't been populated yet.
   const isComplete = useCallback(
-    (sessionID: string) => getMetaFor(sessionID).complete,
-    [getMetaFor],
+    (sessionID: string, directoryOverride?: string) => messageLoader
+      .getSnapshot({ directory: directoryOverride || directory, sessionID }).complete,
+    [directory, messageLoader],
   )
 
   // Optimistic add (for prompt submission)
   const optimisticAdd = useCallback(
     (input: { sessionID: string; directory?: string | null; message: Message; parts: Part[] }) => {
-      setOptimistic(input.sessionID, { message: input.message, parts: input.parts }, input.directory)
-      const targetStore = getOptimisticStore(input.directory)
-      const current = targetStore.getState()
-      const message = { ...current.message }
-      const part = { ...current.part }
-
-      // Insert message
-      const messages = message[input.sessionID] ? [...message[input.sessionID]] : []
-      const result = Binary.search(messages, input.message.id, (m) => m.id)
-      if (!result.found) messages.splice(result.index, 0, input.message)
-      message[input.sessionID] = messages
-
-      // Insert parts
-      part[input.message.id] = sortParts(input.parts)
-
-      targetStore.setState({ message, part })
+      messageLoader.optimisticAdd({
+        directory: input.directory || directory,
+        sessionID: input.sessionID,
+        message: input.message,
+        parts: input.parts,
+      })
     },
-    [getOptimisticStore, setOptimistic],
+    [directory, messageLoader],
   )
 
   // Optimistic remove (for rollback on error)
   const optimisticRemove = useCallback(
     (input: { sessionID: string; directory?: string | null; messageID: string }) => {
-      clearOptimistic(input.sessionID, input.messageID, input.directory)
-      const targetStore = getOptimisticStore(input.directory)
-      const current = targetStore.getState()
-      const message = { ...current.message }
-      const part = { ...current.part }
-
-      const messages = message[input.sessionID]
-      if (messages) {
-        const next = [...messages]
-        const result = Binary.search(next, input.messageID, (m) => m.id)
-        if (result.found) {
-          next.splice(result.index, 1)
-          message[input.sessionID] = next
-        }
-      }
-      delete part[input.messageID]
-
-      targetStore.setState({ message, part })
+      messageLoader.optimisticRemove({
+        directory: input.directory || directory,
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+      })
     },
-    [clearOptimistic, getOptimisticStore],
+    [directory, messageLoader],
   )
 
   const optimisticConfirm = useCallback(
     (input: { sessionID: string; directory?: string | null; messageID: string }) => {
-      clearOptimistic(input.sessionID, input.messageID, input.directory)
+      messageLoader.optimisticConfirm({
+        directory: input.directory || directory,
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+      })
     },
-    [clearOptimistic],
+    [directory, messageLoader],
   )
 
   return useMemo(
     () => ({
       ensureSessionRenderable: syncSession,
       syncSession,
+      prefetchSession,
       loadMore,
       hasMore,
       isLoading,
@@ -716,6 +406,6 @@ export function useSync() {
         confirm: optimisticConfirm,
       },
     }),
-    [syncSession, loadMore, hasMore, isLoading, isComplete, optimisticAdd, optimisticRemove, optimisticConfirm],
+    [syncSession, prefetchSession, loadMore, hasMore, isLoading, isComplete, optimisticAdd, optimisticRemove, optimisticConfirm],
   )
 }
diff --git a/packages/ui/src/sync/worktree-topology-cache.test.ts b/packages/ui/src/sync/worktree-topology-cache.test.ts
new file mode 100644
index 00000000..7bdf37cb
--- /dev/null
+++ b/packages/ui/src/sync/worktree-topology-cache.test.ts
@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, test } from "bun:test"
+import type { WorktreeMetadata } from "@/types/worktree"
+import { persistWorktreeTopology, readPersistedWorktreeTopology } from "./worktree-topology-cache"
+
+class TestStorage implements Storage {
+  readonly values = new Map<string, string>()
+  get length() { return this.values.size }
+  clear() { this.values.clear() }
+  getItem(key: string) { return this.values.get(key) ?? null }
+  key(index: number) { return [...this.values.keys()][index] ?? null }
+  removeItem(key: string) { this.values.delete(key) }
+  setItem(key: string, value: string) { this.values.set(key, value) }
+}
+
+const worktree = (path: string): WorktreeMetadata => ({ path, branch: path.split("/").pop() ?? "main" }) as WorktreeMetadata
+let storage: TestStorage
+
+beforeEach(() => {
+  storage = new TestStorage()
+})
+
+describe("worktree topology persistence", () => {
+  test("restores independent runtime topologies across A -> B -> A", () => {
+    persistWorktreeTopology("runtime-a", new Map([["/repo", [worktree("/repo/a")]]]), storage)
+    persistWorktreeTopology("runtime-b", new Map([["/repo", [worktree("/repo/b")]]]), storage)
+
+    expect(readPersistedWorktreeTopology("runtime-a", storage).get("/repo")?.[0]?.path).toBe("/repo/a")
+    expect(readPersistedWorktreeTopology("runtime-b", storage).get("/repo")?.[0]?.path).toBe("/repo/b")
+  })
+
+  test("claims the legacy topology for only the first runtime", () => {
+    storage.setItem("oc.worktreeMap", JSON.stringify([["/repo", [worktree("/repo/legacy")]]]))
+
+    expect(readPersistedWorktreeTopology("runtime-a", storage).get("/repo")?.[0]?.path).toBe("/repo/legacy")
+    expect(readPersistedWorktreeTopology("runtime-b", storage).size).toBe(0)
+    expect(storage.getItem("oc.worktreeMap")).toBeNull()
+  })
+
+  test("bounds retained runtime namespaces", () => {
+    for (let index = 0; index < 10; index += 1) {
+      persistWorktreeTopology(`runtime-${index}`, new Map([[`/repo-${index}`, [worktree(`/repo-${index}/wt`)]]]), storage)
+    }
+
+    const envelope = JSON.parse(storage.getItem("oc.worktreeMap.v2") ?? "{}") as { runtimes?: Record<string, unknown> }
+    expect(Object.keys(envelope.runtimes ?? {})).toHaveLength(8)
+  })
+})
diff --git a/packages/ui/src/sync/worktree-topology-cache.ts b/packages/ui/src/sync/worktree-topology-cache.ts
new file mode 100644
index 00000000..76ed5093
--- /dev/null
+++ b/packages/ui/src/sync/worktree-topology-cache.ts
@@ -0,0 +1,99 @@
+import type { WorktreeMetadata } from "@/types/worktree"
+import { getDeferredSafeStorage } from "@/stores/utils/safeStorage"
+
+const STORAGE_KEY = "oc.worktreeMap.v2"
+const LEGACY_STORAGE_KEY = "oc.worktreeMap"
+const MAX_RUNTIME_TOPOLOGIES = 8
+
+type PersistedTopology = {
+  updatedAt: number
+  entries: Array<[string, WorktreeMetadata[]]>
+}
+
+type PersistedTopologyEnvelope = {
+  version: 2
+  legacyClaimed: boolean
+  runtimes: Record<string, PersistedTopology>
+}
+
+const emptyEnvelope = (): PersistedTopologyEnvelope => ({ version: 2, legacyClaimed: false, runtimes: {} })
+
+const parseEntries = (value: unknown): Array<[string, WorktreeMetadata[]]> => {
+  if (!Array.isArray(value)) return []
+  return value.filter((entry): entry is [string, WorktreeMetadata[]] => (
+    Array.isArray(entry)
+    && typeof entry[0] === "string"
+    && Array.isArray(entry[1])
+  ))
+}
+
+const readEnvelope = (storage: Storage): PersistedTopologyEnvelope => {
+  try {
+    const raw = storage.getItem(STORAGE_KEY)
+    if (!raw) return emptyEnvelope()
+    const parsed = JSON.parse(raw) as Partial<PersistedTopologyEnvelope>
+    if (parsed.version !== 2 || !parsed.runtimes || typeof parsed.runtimes !== "object") return emptyEnvelope()
+    const runtimes: Record<string, PersistedTopology> = {}
+    for (const [runtimeKey, topology] of Object.entries(parsed.runtimes)) {
+      const entries = parseEntries(topology?.entries)
+      if (!runtimeKey || entries.length === 0) continue
+      runtimes[runtimeKey] = {
+        updatedAt: typeof topology.updatedAt === "number" ? topology.updatedAt : 0,
+        entries,
+      }
+    }
+    return { version: 2, legacyClaimed: parsed.legacyClaimed === true, runtimes }
+  } catch {
+    return emptyEnvelope()
+  }
+}
+
+const writeEnvelope = (storage: Storage, envelope: PersistedTopologyEnvelope): void => {
+  const retained = Object.entries(envelope.runtimes)
+    .sort(([, left], [, right]) => right.updatedAt - left.updatedAt)
+    .slice(0, MAX_RUNTIME_TOPOLOGIES)
+  storage.setItem(STORAGE_KEY, JSON.stringify({ ...envelope, runtimes: Object.fromEntries(retained) }))
+}
+
+export function readPersistedWorktreeTopology(
+  runtimeKey: string,
+  storage: Storage = getDeferredSafeStorage(),
+): Map<string, WorktreeMetadata[]> {
+  const envelope = readEnvelope(storage)
+  const topology = envelope.runtimes[runtimeKey]
+  if (topology) return new Map(topology.entries)
+  if (envelope.legacyClaimed) return new Map()
+
+  try {
+    const legacyEntries = parseEntries(JSON.parse(storage.getItem(LEGACY_STORAGE_KEY) ?? "[]"))
+    envelope.legacyClaimed = true
+    if (legacyEntries.length > 0) {
+      envelope.runtimes[runtimeKey] = { updatedAt: Date.now(), entries: legacyEntries }
+    }
+    writeEnvelope(storage, envelope)
+    storage.removeItem(LEGACY_STORAGE_KEY)
+    return new Map(legacyEntries)
+  } catch {
+    return new Map()
+  }
+}
+
+export function persistWorktreeTopology(
+  runtimeKey: string,
+  topology: Map<string, WorktreeMetadata[]>,
+  storage: Storage = getDeferredSafeStorage(),
+): void {
+  if (!runtimeKey) return
+  try {
+    const envelope = readEnvelope(storage)
+    envelope.legacyClaimed = true
+    envelope.runtimes[runtimeKey] = {
+      updatedAt: Date.now(),
+      entries: [...topology.entries()],
+    }
+    writeEnvelope(storage, envelope)
+    storage.removeItem(LEGACY_STORAGE_KEY)
+  } catch {
+    // Discovery remains authoritative in memory when persistence is unavailable.
+  }
+}
diff --git a/packages/vscode/src/DOCUMENTATION.md b/packages/vscode/src/DOCUMENTATION.md
index eb4085ba..0479c22d 100644
--- a/packages/vscode/src/DOCUMENTATION.md
+++ b/packages/vscode/src/DOCUMENTATION.md
@@ -59,7 +59,7 @@ Keep `bridge.ts` as a thin orchestration layer that delegates message handling t
 
 - `bridge-permission-auto-accept-runtime.ts`
   - Owns the persisted VS Code permission auto-accept policy and its GET/PUT bridge contract.
-  - Broadcasts policy snapshots to every active OpenChamber webview. Permission replies remain foreground UI-owned because VS Code does not run the OpenChamber server runtime.
+  - Serializes reads and read-modify-write updates, persists a monotonic policy revision, and broadcasts the exact committed snapshot to every active OpenChamber webview. Permission replies remain foreground UI-owned because VS Code does not run the OpenChamber server runtime.
 
 ## Extension guideline
 
diff --git a/packages/vscode/src/bridge-permission-auto-accept-runtime.test.ts b/packages/vscode/src/bridge-permission-auto-accept-runtime.test.ts
index b48de738..ba64cdcd 100644
--- a/packages/vscode/src/bridge-permission-auto-accept-runtime.test.ts
+++ b/packages/vscode/src/bridge-permission-auto-accept-runtime.test.ts
@@ -24,14 +24,36 @@ describe('VS Code permission auto-accept policy bridge', () => {
     }, context, dependencies);
 
     assert.equal(response?.success, true);
-    assert.deepEqual(response?.data, { sessions: { root: true } });
-    assert.deepEqual(broadcasts, [{ sessions: { root: true } }]);
+    assert.deepEqual(response?.data, { sessions: { root: true }, revision: 1 });
+    assert.deepEqual(broadcasts, [{ sessions: { root: true }, revision: 1 }]);
 
     const reloaded = await handlePermissionAutoAcceptBridgeMessage({
       id: '2',
       type: 'api:permission-auto-accept:get',
     }, context, dependencies);
-    assert.deepEqual(reloaded?.data, { sessions: { root: true } });
+    assert.deepEqual(reloaded?.data, { sessions: { root: true }, revision: 1 });
+  });
+
+  test('serializes concurrent writes without losing policy entries', async () => {
+    const context = createContext();
+    const dependencies = { broadcast: async () => undefined };
+    const first = handlePermissionAutoAcceptBridgeMessage({
+      id: '1',
+      type: 'api:permission-auto-accept:set',
+      payload: { sessionId: 'root', enabled: true },
+    }, context, dependencies);
+    const second = handlePermissionAutoAcceptBridgeMessage({
+      id: '2',
+      type: 'api:permission-auto-accept:set',
+      payload: { sessionId: 'child', enabled: false },
+    }, context, dependencies);
+
+    await Promise.all([first, second]);
+    const reloaded = await handlePermissionAutoAcceptBridgeMessage({
+      id: '3',
+      type: 'api:permission-auto-accept:get',
+    }, context, dependencies);
+    assert.deepEqual(reloaded?.data, { sessions: { root: true, child: false }, revision: 2 });
   });
 
   test('rejects malformed policy writes', async () => {
diff --git a/packages/vscode/src/bridge-permission-auto-accept-runtime.ts b/packages/vscode/src/bridge-permission-auto-accept-runtime.ts
index 6f34e456..fe756d2a 100644
--- a/packages/vscode/src/bridge-permission-auto-accept-runtime.ts
+++ b/packages/vscode/src/bridge-permission-auto-accept-runtime.ts
@@ -9,6 +9,7 @@ type PolicyContext = {
 
 export type PermissionAutoAcceptSnapshot = {
   sessions: Record<string, boolean>;
+  revision: number;
 };
 
 const normalizeSnapshot = (value: unknown): PermissionAutoAcceptSnapshot => {
@@ -22,25 +23,50 @@ const normalizeSnapshot = (value: unknown): PermissionAutoAcceptSnapshot => {
   for (const [sessionId, enabled] of entries) {
     if (sessionId && typeof enabled === 'boolean') sessions[sessionId] = enabled;
   }
-  return { sessions };
+  const revision = Number.isSafeInteger((source as { revision?: unknown }).revision)
+    && Number((source as { revision?: unknown }).revision) >= 0
+    ? Number((source as { revision?: unknown }).revision)
+    : 0;
+  return { sessions, revision };
 };
 
 const readPermissionAutoAcceptPolicy = (context: PolicyContext) =>
   normalizeSnapshot(context.globalState.get(STORAGE_KEY));
 
+const operationQueues = new WeakMap<object, Promise<void>>();
+
+const serialize = async <T>(context: PolicyContext, operation: () => Promise<T>): Promise<T> => {
+  const owner = context.globalState as object;
+  const previous = operationQueues.get(owner) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => { release = resolve; });
+  const queued = previous.catch(() => undefined).then(() => current);
+  operationQueues.set(owner, queued);
+  await previous.catch(() => undefined);
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (operationQueues.get(owner) === queued) operationQueues.delete(owner);
+  }
+};
+
 async function setPermissionAutoAcceptPolicy(
   context: PolicyContext,
   sessionId: string,
   enabled: boolean,
   broadcast: (snapshot: PermissionAutoAcceptSnapshot) => PromiseLike<unknown>,
 ) {
-  const current = readPermissionAutoAcceptPolicy(context);
-  const snapshot = {
-    sessions: { ...current.sessions, [sessionId]: enabled },
-  };
-  await context.globalState.update(STORAGE_KEY, snapshot);
-  await broadcast(snapshot);
-  return snapshot;
+  return serialize(context, async () => {
+    const current = readPermissionAutoAcceptPolicy(context);
+    const snapshot = {
+      sessions: { ...current.sessions, [sessionId]: enabled },
+      revision: current.revision + 1,
+    };
+    await context.globalState.update(STORAGE_KEY, snapshot);
+    await broadcast(snapshot);
+    return snapshot;
+  });
 }
 
 export async function handlePermissionAutoAcceptBridgeMessage(
@@ -54,7 +80,8 @@ export async function handlePermissionAutoAcceptBridgeMessage(
   if (!context) return { id: message.id, type: message.type, success: false, error: 'Extension context is unavailable' };
 
   if (message.type === 'api:permission-auto-accept:get') {
-    return { id: message.id, type: message.type, success: true, data: readPermissionAutoAcceptPolicy(context) };
+    const snapshot = await serialize(context, async () => readPermissionAutoAcceptPolicy(context));
+    return { id: message.id, type: message.type, success: true, data: snapshot };
   }
 
   const payload = message.payload && typeof message.payload === 'object'
diff --git a/packages/vscode/src/opencodeAuth.ts b/packages/vscode/src/opencodeAuth.ts
index 2563c978..cbac7e14 100644
--- a/packages/vscode/src/opencodeAuth.ts
+++ b/packages/vscode/src/opencodeAuth.ts
@@ -28,15 +28,18 @@ const readAuthFile = (): AuthFile => {
 const writeAuthFile = (auth: AuthFile): void => {
   try {
     if (!fs.existsSync(OPENCODE_DATA_DIR)) {
-      fs.mkdirSync(OPENCODE_DATA_DIR, { recursive: true });
+      fs.mkdirSync(OPENCODE_DATA_DIR, { recursive: true, mode: 0o700 });
     }
+    if (process.platform !== 'win32') fs.chmodSync(OPENCODE_DATA_DIR, 0o700);
 
     if (fs.existsSync(AUTH_FILE)) {
       const backupFile = `${AUTH_FILE}.openchamber.backup`;
       fs.copyFileSync(AUTH_FILE, backupFile);
+      if (process.platform !== 'win32') fs.chmodSync(backupFile, 0o600);
     }
 
-    fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), 'utf8');
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { encoding: 'utf8', mode: 0o600 });
+    if (process.platform !== 'win32') fs.chmodSync(AUTH_FILE, 0o600);
   } catch (error) {
     console.error('Failed to write auth file:', error);
     throw new Error('Failed to write OpenCode auth configuration');
diff --git a/packages/vscode/webview/main.tsx b/packages/vscode/webview/main.tsx
index 5e5351bb..1a1d1ad2 100644
--- a/packages/vscode/webview/main.tsx
+++ b/packages/vscode/webview/main.tsx
@@ -1808,9 +1808,13 @@ onCommand('settingsSynced', () => {
 
 onCommand('permissionAutoAcceptSynced', (payload) => {
   if (!payload || typeof payload !== 'object') return;
-  const sessions = (payload as { sessions?: unknown }).sessions;
+  const snapshot = payload as { sessions?: unknown; revision?: unknown };
+  const sessions = snapshot.sessions;
   if (!sessions || typeof sessions !== 'object') return;
-  usePermissionStore.getState().applySnapshot({ sessions: sessions as Record<string, boolean> });
+  usePermissionStore.getState().applySnapshot({
+    sessions: sessions as Record<string, boolean>,
+    revision: typeof snapshot.revision === 'number' ? snapshot.revision : undefined,
+  });
 });
 
 // Listen for active editor file changes from the extension
diff --git a/packages/web/server/index.js b/packages/web/server/index.js
index a1715a11..1929a105 100644
--- a/packages/web/server/index.js
+++ b/packages/web/server/index.js
@@ -448,10 +448,7 @@ const sessionRuntime = createSessionRuntime({
   broadcastEvent: broadcastGlobalUiEvent,
 });
 
-const getActiveSessionCount = () => {
-  const snapshot = sessionRuntime.getSessionActivitySnapshot();
-  return Object.values(snapshot).filter((entry) => entry.type === 'busy').length;
-};
+const getActiveSessionCount = () => sessionRuntime.getActiveSessionCount();
 
 const getUpstreamStallTimeoutMs = () => (
   getActiveSessionCount() > 1
diff --git a/packages/web/server/lib/github/DOCUMENTATION.md b/packages/web/server/lib/github/DOCUMENTATION.md
index 461f52c2..2eb32532 100644
--- a/packages/web/server/lib/github/DOCUMENTATION.md
+++ b/packages/web/server/lib/github/DOCUMENTATION.md
@@ -111,6 +111,7 @@
 - Closed or merged PR -> stop regular polling.
 - Hidden tab -> skip polling.
 - Non-forced refreshes use a `90s` TTL.
+- Failed non-forced attempts also observe the `90s` TTL so transient server or rate-limit failures cannot retry on every sidebar update. Forced user/action refreshes bypass this guard.
 
 ## Background tracking rules
 
diff --git a/packages/web/server/lib/opencode/DOCUMENTATION.md b/packages/web/server/lib/opencode/DOCUMENTATION.md
index 17283258..c36dbc27 100644
--- a/packages/web/server/lib/opencode/DOCUMENTATION.md
+++ b/packages/web/server/lib/opencode/DOCUMENTATION.md
@@ -87,6 +87,7 @@ This module provides OpenCode server integration utilities for the web server ru
 - Returned API:
   - `processOpenCodeSsePayload(payload)`
   - `getSessionActivitySnapshot()`
+  - `getActiveSessionCount()`
   - `getSessionStateSnapshot()`
   - `getSessionAttentionSnapshot()`
   - `getSessionState(sessionId)`
@@ -97,6 +98,8 @@ This module provides OpenCode server integration utilities for the web server ru
   - `resetAllSessionActivityToIdle()`
   - `dispose()`
 
+The runtime maintains active-session count incrementally from idempotent activity phase transitions. Upstream stall-timeout and lifecycle health checks read it in O(1); the hourly cleanup removes activity phases older than 24 hours without broadcasting synthetic state transitions. Snapshot generation remains reserved for the session-activity API.
+
 ## Public exports (lifecycle.js)
 - `createOpenCodeLifecycleRuntime(dependencies)`: creates lifecycle runtime for managed/external OpenCode process orchestration.
 - Returned API:
@@ -112,6 +115,7 @@ This module provides OpenCode server integration utilities for the web server ru
 
 ## Public exports (env-runtime.js)
 - `createOpenCodeEnvRuntime(dependencies)`: creates runtime that owns OpenCode CLI environment and binary discovery state.
+- OpenCode CLI resolution order is persisted settings, environment overrides, bundled Desktop CLI when available, PATH, known install locations, then platform shell discovery.
 - Returned API:
   - `applyLoginShellEnvSnapshot()`
   - `getLoginShellEnvSnapshot()`
diff --git a/packages/web/server/lib/opencode/env-runtime.js b/packages/web/server/lib/opencode/env-runtime.js
index 32b82686..15f6bb15 100644
--- a/packages/web/server/lib/opencode/env-runtime.js
+++ b/packages/web/server/lib/opencode/env-runtime.js
@@ -347,9 +347,9 @@ export const createOpenCodeEnvRuntime = (deps) => {
       }
     }
 
-    // The bundled CLI is the LAST resort (see bundledOpenCodeCliFallback at the
-    // exit points below): a user's own OpenCode install — PATH, known install
-    // locations, or shell-resolved — must win over the pinned bundled copy.
+    const bundled = bundledOpenCodeCliFallback();
+    if (bundled) return bundled;
+
     const resolvedFromPath = searchPathFor('opencode');
     if (resolvedFromPath) {
       clearWslOpencodeResolution();
@@ -427,7 +427,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
       // Do not auto-detect OpenCode from WSL. OpenCode sessions are keyed by
       // server-visible directories, and mixing Windows paths with WSL paths
       // creates duplicate/missing project state in the desktop app.
-      return bundledOpenCodeCliFallback();
+      return null;
     }
 
     const shells = [process.env.SHELL, '/bin/zsh', '/bin/bash', '/bin/sh'].filter(Boolean);
@@ -451,7 +451,7 @@ export const createOpenCodeEnvRuntime = (deps) => {
       }
     }
 
-    return bundledOpenCodeCliFallback();
+    return null;
   };
 
   const resolveNodeCliPath = () => {
diff --git a/packages/web/server/lib/opencode/env-runtime.test.js b/packages/web/server/lib/opencode/env-runtime.test.js
index dcfe184f..f4b52068 100644
--- a/packages/web/server/lib/opencode/env-runtime.test.js
+++ b/packages/web/server/lib/opencode/env-runtime.test.js
@@ -163,7 +163,7 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('settings');
   });
 
-  it('prefers a user-installed OpenCode from PATH over the bundled CLI', () => {
+  it('prefers the bundled CLI over a user-installed OpenCode from PATH', () => {
     const bundledDir = createTempDir('openchamber-bundled-opencode-');
     const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
     const pathDir = createTempDir('openchamber-path-opencode-');
@@ -179,8 +179,8 @@ describe('OpenCode env runtime', () => {
     delete process.env.OPENCODE_BINARY;
     const { runtime, state } = createRuntime({});
 
-    expect(runtime.resolveOpencodeCliPath()).toBe(pathBinary);
-    expect(state.resolvedOpencodeBinarySource).toBe('path');
+    expect(runtime.resolveOpencodeCliPath()).toBe(bundledBinary);
+    expect(state.resolvedOpencodeBinarySource).toBe('bundled');
   });
 
   it('keeps explicit OpenCode binary ahead of bundled CLI', () => {
@@ -202,7 +202,7 @@ describe('OpenCode env runtime', () => {
     expect(state.resolvedOpencodeBinarySource).toBe('env');
   });
 
-  it('falls back to the bundled OpenCode CLI from Electron resourcesPath when nothing else is installed', () => {
+  it('resolves the bundled OpenCode CLI from Electron resourcesPath', () => {
     const resourcesPath = createTempDir('openchamber-resources-');
     const bundledDir = path.join(resourcesPath, 'opencode-cli');
     const bundledBinary = path.join(bundledDir, process.platform === 'win32' ? 'opencode.exe' : 'opencode');
@@ -218,8 +218,6 @@ describe('OpenCode env runtime', () => {
     process.env.PATH = createTempDir('openchamber-empty-path-');
     delete process.env.OPENCHAMBER_BUNDLED_OPENCODE_CLI_DIR;
     delete process.env.OPENCODE_BINARY;
-    // The bundled CLI is the LAST resort now — hide the machine's own installs
-    // from the home-directory fallbacks and shell discovery.
     const emptyHome = createTempDir('openchamber-empty-home-');
     const { runtime, state } = createRuntime({}, {
       spawnSync: () => ({ status: 1, stdout: '', stderr: '' }),
diff --git a/packages/web/server/lib/opencode/session-runtime.js b/packages/web/server/lib/opencode/session-runtime.js
index 680d51ea..071deda3 100644
--- a/packages/web/server/lib/opencode/session-runtime.js
+++ b/packages/web/server/lib/opencode/session-runtime.js
@@ -1,6 +1,7 @@
 const SESSION_COOLDOWN_DURATION_MS = 2000;
 const SESSION_STATE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const SESSION_ATTENTION_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const SESSION_ACTIVITY_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const SESSION_STATE_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 
 const extractSessionStatusUpdate = (payload) => {
@@ -37,26 +38,12 @@ const extractSessionStatusUpdate = (payload) => {
   };
 };
 
-const deriveSessionActivityTransitions = (payload) => {
-  const update = extractSessionStatusUpdate(payload);
-  if (!update) {
-    return [];
-  }
-
-  if (update.type === 'busy' || update.type === 'retry') {
-    return [{ sessionId: update.sessionId, phase: 'busy' }];
-  }
-  if (update.type === 'idle') {
-    return [{ sessionId: update.sessionId, phase: 'cooldown' }];
-  }
-  return [];
-};
-
 export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, broadcastEvent }) => {
   const sessionActivityPhases = new Map();
   const sessionActivityCooldowns = new Map();
   const sessionStates = new Map();
   const sessionAttentionStates = new Map();
+  let activeSessionCount = 0;
 
   const getOrCreateAttentionState = (sessionId) => {
     if (!sessionId || typeof sessionId !== 'string') return null;
@@ -90,6 +77,11 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
       sessionActivityCooldowns.delete(sessionId);
     }
 
+    const wasActive = current?.phase === 'busy';
+    const isActive = phase === 'busy';
+    if (wasActive !== isActive) {
+      activeSessionCount = Math.max(0, activeSessionCount + (isActive ? 1 : -1));
+    }
     sessionActivityPhases.set(sessionId, { phase, updatedAt: Date.now() });
 
     if (phase === 'cooldown') {
@@ -287,11 +279,14 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
     return result;
   };
 
+  const getActiveSessionCount = () => activeSessionCount;
+
   const resetAllSessionActivityToIdle = () => {
     for (const timer of sessionActivityCooldowns.values()) {
       clearTimeout(timer);
     }
     sessionActivityCooldowns.clear();
+    activeSessionCount = 0;
     const now = Date.now();
     for (const [sessionId] of sessionActivityPhases) {
       sessionActivityPhases.set(sessionId, { phase: 'idle', updatedAt: now });
@@ -310,26 +305,33 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
         sessionAttentionStates.delete(sessionId);
       }
     }
+    for (const [sessionId, data] of sessionActivityPhases) {
+      if (now - data.updatedAt <= SESSION_ACTIVITY_MAX_AGE_MS) continue;
+      const timer = sessionActivityCooldowns.get(sessionId);
+      if (timer) clearTimeout(timer);
+      sessionActivityCooldowns.delete(sessionId);
+      sessionActivityPhases.delete(sessionId);
+      if (data.phase === 'busy') activeSessionCount = Math.max(0, activeSessionCount - 1);
+    }
   };
 
   const cleanupInterval = setInterval(cleanupOldSessionStates, SESSION_STATE_CLEANUP_INTERVAL_MS);
 
   const processOpenCodeSsePayload = (payload) => {
-    const transitions = deriveSessionActivityTransitions(payload);
-    for (const activity of transitions) {
-      setSessionActivityPhase(activity.sessionId, activity.phase);
+    const update = extractSessionStatusUpdate(payload);
+    if (!update) return;
+
+    if (update.type === 'busy' || update.type === 'retry') {
+      setSessionActivityPhase(update.sessionId, 'busy');
+    } else if (update.type === 'idle') {
+      setSessionActivityPhase(update.sessionId, 'cooldown');
     }
 
-    if (payload && payload.type === 'session.status') {
-      const update = extractSessionStatusUpdate(payload);
-      if (update) {
-        updateSessionState(update.sessionId, update.type, update.eventId || `sse-${Date.now()}`, {
-          attempt: update.attempt,
-          message: update.message,
-          next: update.next,
-        });
-      }
-    }
+    updateSessionState(update.sessionId, update.type, update.eventId || `sse-${Date.now()}`, {
+      attempt: update.attempt,
+      message: update.message,
+      next: update.next,
+    });
   };
 
   const dispose = () => {
@@ -338,11 +340,16 @@ export const createSessionRuntime = ({ writeSseEvent, getNotificationClients, br
       clearTimeout(timer);
     }
     sessionActivityCooldowns.clear();
+    sessionActivityPhases.clear();
+    sessionStates.clear();
+    sessionAttentionStates.clear();
+    activeSessionCount = 0;
   };
 
   return {
     processOpenCodeSsePayload,
     getSessionActivitySnapshot,
+    getActiveSessionCount,
     getSessionStateSnapshot,
     getSessionAttentionSnapshot,
     getSessionState,
diff --git a/packages/web/server/lib/opencode/session-runtime.test.js b/packages/web/server/lib/opencode/session-runtime.test.js
index 11fbcbf7..56e0f02a 100644
--- a/packages/web/server/lib/opencode/session-runtime.test.js
+++ b/packages/web/server/lib/opencode/session-runtime.test.js
@@ -148,4 +148,84 @@ describe('session runtime', () => {
       vi.useRealTimers();
     }
   });
+
+  it('maintains an idempotent active session count', () => {
+    const runtime = createSessionRuntime({
+      writeSseEvent() {},
+      getNotificationClients: () => new Set(),
+      broadcastEvent() {},
+    });
+    runtimes.push(runtime);
+    const status = (sessionID, type) => runtime.processOpenCodeSsePayload({
+      type: 'session.status',
+      properties: { sessionID, status: { type } },
+    });
+
+    expect(runtime.getActiveSessionCount()).toBe(0);
+    status('session-1', 'busy');
+    status('session-1', 'busy');
+    status('session-1', 'retry');
+    expect(runtime.getActiveSessionCount()).toBe(1);
+
+    status('session-2', 'busy');
+    expect(runtime.getActiveSessionCount()).toBe(2);
+
+    status('session-1', 'idle');
+    expect(runtime.getActiveSessionCount()).toBe(1);
+    status('session-1', 'idle');
+    expect(runtime.getActiveSessionCount()).toBe(1);
+
+    runtime.resetAllSessionActivityToIdle();
+    expect(runtime.getActiveSessionCount()).toBe(0);
+  });
+
+  it('restores activity when busy interrupts cooldown without timer underflow', () => {
+    vi.useFakeTimers();
+    const runtime = createSessionRuntime({
+      writeSseEvent() {},
+      getNotificationClients: () => new Set(),
+      broadcastEvent() {},
+    });
+    const status = (type) => runtime.processOpenCodeSsePayload({
+      type: 'session.status',
+      properties: { sessionID: 'session-1', status: { type } },
+    });
+
+    try {
+      status('busy');
+      status('idle');
+      expect(runtime.getActiveSessionCount()).toBe(0);
+
+      status('retry');
+      expect(runtime.getActiveSessionCount()).toBe(1);
+      vi.advanceTimersByTime(2000);
+
+      expect(runtime.getActiveSessionCount()).toBe(1);
+      expect(runtime.getSessionActivitySnapshot()['session-1']).toEqual({ type: 'busy' });
+    } finally {
+      runtime.dispose();
+      vi.useRealTimers();
+    }
+  });
+
+  it('releases retained session state when disposed', () => {
+    const runtime = createSessionRuntime({
+      writeSseEvent() {},
+      getNotificationClients: () => new Set(),
+      broadcastEvent() {},
+    });
+    runtimes.push(runtime);
+
+    runtime.processOpenCodeSsePayload({
+      type: 'session.status',
+      properties: { sessionID: 'session-1', status: { type: 'busy' } },
+    });
+    runtime.markUserMessageSent('session-1');
+    runtime.dispose();
+
+    expect(runtime.getActiveSessionCount()).toBe(0);
+    expect(runtime.getSessionActivitySnapshot()).toEqual({});
+    expect(runtime.getSessionStateSnapshot()).toEqual({});
+    expect(runtime.getSessionAttentionSnapshot()).toEqual({});
+  });
 });
diff --git a/packages/web/server/lib/opencode/settings-helpers.js b/packages/web/server/lib/opencode/settings-helpers.js
index 73be3c5e..b8e21eee 100644
--- a/packages/web/server/lib/opencode/settings-helpers.js
+++ b/packages/web/server/lib/opencode/settings-helpers.js
@@ -201,6 +201,10 @@ export const createSettingsHelpers = (dependencies) => {
       }
       result.permissionAutoAccept = {
         sessions,
+        revision: Number.isSafeInteger(candidate.permissionAutoAccept.revision)
+          && candidate.permissionAutoAccept.revision >= 0
+          ? candidate.permissionAutoAccept.revision
+          : 0,
       };
     }
     if (typeof candidate.desktopUiPassword === 'string') {
diff --git a/packages/web/server/lib/opencode/settings-helpers.test.js b/packages/web/server/lib/opencode/settings-helpers.test.js
index 65006b7d..b6aff598 100644
--- a/packages/web/server/lib/opencode/settings-helpers.test.js
+++ b/packages/web/server/lib/opencode/settings-helpers.test.js
@@ -134,6 +134,7 @@ describe('settings helpers', () => {
     })).toEqual({
       permissionAutoAccept: {
         sessions: { root: true, child: false },
+        revision: 0,
       },
     });
   });
diff --git a/packages/web/server/lib/opencode/settings-runtime.js b/packages/web/server/lib/opencode/settings-runtime.js
index 0ca7619e..aeddf473 100644
--- a/packages/web/server/lib/opencode/settings-runtime.js
+++ b/packages/web/server/lib/opencode/settings-runtime.js
@@ -502,14 +502,18 @@ export const createSettingsRuntime = (deps) => {
 
   const writeSettingsToDisk = async (settings) => {
     try {
-      await fsPromises.mkdir(path.dirname(SETTINGS_FILE_PATH), { recursive: true });
+      const settingsDirectory = path.dirname(SETTINGS_FILE_PATH);
+      await fsPromises.mkdir(settingsDirectory, { recursive: true, mode: 0o700 });
+      if (process.platform !== 'win32') await fsPromises.chmod(settingsDirectory, 0o700);
       // Atomic write: Electron main and ssh-manager read this file via plain
       // readFile + JSON.parse and silently coerce parse errors to {}. A
       // partial read during a non-atomic writeFile would make their next
       // read-modify-write wipe the settings file.
       const tmp = `${SETTINGS_FILE_PATH}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), 'utf8');
+      await fsPromises.writeFile(tmp, JSON.stringify(settings, null, 2), { encoding: 'utf8', mode: 0o600 });
+      if (process.platform !== 'win32') await fsPromises.chmod(tmp, 0o600);
       await replaceFile(tmp, SETTINGS_FILE_PATH);
+      if (process.platform !== 'win32') await fsPromises.chmod(SETTINGS_FILE_PATH, 0o600);
     } catch (error) {
       console.warn('Failed to write settings file:', error);
       throw error;
diff --git a/packages/web/server/lib/opencode/settings-runtime.test.js b/packages/web/server/lib/opencode/settings-runtime.test.js
index 1994fe3c..7a6b8e69 100644
--- a/packages/web/server/lib/opencode/settings-runtime.test.js
+++ b/packages/web/server/lib/opencode/settings-runtime.test.js
@@ -39,6 +39,18 @@ const createRuntime = async () => {
 };
 
 describe('settings runtime', () => {
+  it.skipIf(process.platform === 'win32')('writes settings with restrictive directory and file permissions', async () => {
+    const { runtime, settingsFilePath, tempRoot, cleanup } = await createRuntime();
+    try {
+      await runtime.writeSettingsToDisk({ desktopUiPassword: 'secret' });
+
+      expect((await fsPromises.stat(tempRoot)).mode & 0o777).toBe(0o700);
+      expect((await fsPromises.stat(settingsFilePath)).mode & 0o777).toBe(0o600);
+    } finally {
+      await cleanup();
+    }
+  });
+
   it('only remaps project plan paths within the migrated storage directory', async () => {
     const { runtime, settingsFilePath, tempRoot, cleanup } = await createRuntime();
     try {
diff --git a/packages/web/server/lib/permission-auto-accept/runtime.js b/packages/web/server/lib/permission-auto-accept/runtime.js
index e492688e..c06e4385 100644
--- a/packages/web/server/lib/permission-auto-accept/runtime.js
+++ b/packages/web/server/lib/permission-auto-accept/runtime.js
@@ -12,7 +12,8 @@ const normalizePolicy = (value) => {
   for (const [sessionId, enabled] of entries) {
     if (sessionId && typeof enabled === 'boolean') sessions[sessionId] = enabled;
   }
-  return { sessions };
+  const revision = Number.isSafeInteger(source.revision) && source.revision >= 0 ? source.revision : 0;
+  return { sessions, revision };
 };
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -38,6 +39,7 @@ export function createPermissionAutoAcceptRuntime({
 
   const snapshot = () => ({
     sessions: { ...policy.sessions },
+    revision: policy.revision,
   });
 
   const load = async () => {
@@ -76,6 +78,7 @@ export function createPermissionAutoAcceptRuntime({
     const result = await persistUpdate((current) => ({
       ...current,
       sessions: { ...current.sessions, [sessionId.trim()]: enabled },
+      revision: current.revision + 1,
     }));
     if (enabled) await reconcilePending({ directories: [directory] });
     return result;
diff --git a/packages/web/server/lib/permission-auto-accept/runtime.test.js b/packages/web/server/lib/permission-auto-accept/runtime.test.js
index f47bc0ad..7af74c5d 100644
--- a/packages/web/server/lib/permission-auto-accept/runtime.test.js
+++ b/packages/web/server/lib/permission-auto-accept/runtime.test.js
@@ -38,9 +38,18 @@ describe('permission auto-accept runtime', () => {
     const second = createRuntime({ stored: first.getSettings() });
     await expect(second.runtime.load()).resolves.toEqual({
       sessions: { root: true },
+      revision: 1,
     });
   });
 
+  it('increments the authoritative policy revision', async () => {
+    const { runtime, getSettings } = createRuntime();
+
+    await expect(runtime.setSessionPolicy('root', true)).resolves.toMatchObject({ revision: 1 });
+    await expect(runtime.setSessionPolicy('child', false)).resolves.toMatchObject({ revision: 2 });
+    expect(getSettings().permissionAutoAccept.revision).toBe(2);
+  });
+
   it('uses nearest explicit ancestor policy for subagents', async () => {
     const { runtime, emit } = createRuntime({
       stored: { permissionAutoAccept: { sessions: { root: true, child: false } } },
@@ -132,6 +141,6 @@ describe('permission auto-accept runtime', () => {
       .map(([url]) => new URL(url).pathname);
     expect(replyPaths).toEqual(['/permission/root-pending/reply']);
     expect(fetchImpl.mock.calls.some(([url]) => new URL(url).searchParams.get('directory') === '/project')).toBe(true);
-    expect(await runtime.load()).toEqual({ sessions: { root: true } });
+    expect(await runtime.load()).toEqual({ sessions: { root: true }, revision: 1 });
   });
 });
diff --git a/packages/web/server/lib/session-folders/routes.js b/packages/web/server/lib/session-folders/routes.js
index ea5fdb6f..c88496d4 100644
--- a/packages/web/server/lib/session-folders/routes.js
+++ b/packages/web/server/lib/session-folders/routes.js
@@ -1,5 +1,33 @@
 const MAX_BODY_BYTES = 4 * 1024 * 1024;
 
+const isObjectRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+const hasValidFolderShape = (folder) => (
+  isObjectRecord(folder)
+  && typeof folder.id === 'string'
+  && typeof folder.name === 'string'
+  && Array.isArray(folder.sessionIds)
+  && folder.sessionIds.every((sessionId) => typeof sessionId === 'string')
+  && typeof folder.createdAt === 'number'
+  && Number.isFinite(folder.createdAt)
+  && (folder.parentId === undefined || folder.parentId === null || typeof folder.parentId === 'string')
+);
+
+const hasValidFoldersMapShape = (foldersMap) => (
+  isObjectRecord(foldersMap)
+  && Object.values(foldersMap).every((folders) => (
+    Array.isArray(folders) && folders.every(hasValidFolderShape)
+  ))
+);
+
+const hasValidFolderSnapshotShape = (snapshot) => (
+  isObjectRecord(snapshot)
+  && snapshot.version === 1
+  && hasValidFoldersMapShape(snapshot.foldersMap)
+  && Array.isArray(snapshot.collapsedFolderIds)
+  && snapshot.collapsedFolderIds.every((folderId) => typeof folderId === 'string')
+);
+
 export const registerSessionFoldersRoutes = (app, dependencies) => {
   const {
     fsPromises,
@@ -8,6 +36,7 @@ export const registerSessionFoldersRoutes = (app, dependencies) => {
   } = dependencies;
 
   const filePath = path.join(openchamberDataDir, 'sessions-directories.json');
+  let saveQueue = Promise.resolve();
 
   const ensureDir = async () => {
     await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
@@ -20,13 +49,21 @@ export const registerSessionFoldersRoutes = (app, dependencies) => {
         throw error;
       });
       if (!raw) {
-        return res.json({ version: 1, foldersMap: {}, collapsedFolderIds: [], updatedAt: 0 });
+        return res.json({ version: 1, exists: false });
       }
       try {
         const parsed = JSON.parse(raw);
-        return res.json(parsed);
+        if (
+          !hasValidFolderSnapshotShape(parsed)
+          || typeof parsed.updatedAt !== 'number'
+          || !Number.isFinite(parsed.updatedAt)
+          || parsed.updatedAt <= 0
+        ) {
+          return res.status(500).json({ error: 'Stored session folders have an invalid shape' });
+        }
+        return res.json({ ...parsed, exists: true });
       } catch {
-        return res.json({ version: 1, foldersMap: {}, collapsedFolderIds: [], updatedAt: 0 });
+        return res.status(500).json({ error: 'Stored session folders are malformed' });
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Failed to read session folders';
@@ -36,28 +73,59 @@ export const registerSessionFoldersRoutes = (app, dependencies) => {
 
   app.post('/api/session-folders', async (req, res) => {
     const body = req.body;
-    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    if (!isObjectRecord(body)) {
       return res.status(400).json({ error: 'Body must be an object' });
     }
+    if (!hasValidFolderSnapshotShape(body)) {
+      return res.status(400).json({ error: 'Invalid session folders payload' });
+    }
     const serialized = JSON.stringify(body, null, 2);
     if (Buffer.byteLength(serialized, 'utf8') > MAX_BODY_BYTES) {
       return res.status(413).json({ error: 'Payload too large' });
     }
-    let tmp;
-    let saved = false;
-    try {
-      await ensureDir();
-      tmp = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      await fsPromises.writeFile(tmp, serialized, 'utf8');
-      await fsPromises.rename(tmp, filePath);
-      saved = true;
-      return res.json({ success: true });
-    } catch (error) {
-      if (tmp && !saved) {
-        await fsPromises.unlink(tmp).catch(() => {});
-      }
-      const message = error instanceof Error ? error.message : 'Failed to write session folders';
-      return res.status(500).json({ error: message });
+    if (typeof body.updatedAt !== 'number' || !Number.isFinite(body.updatedAt) || body.updatedAt <= 0) {
+      return res.status(400).json({ error: 'updatedAt must be a positive finite number' });
     }
+
+    const save = async () => {
+      let tmp;
+      let saved = false;
+      try {
+        const currentRaw = await fsPromises.readFile(filePath, 'utf8').catch((error) => {
+          if (error && error.code === 'ENOENT') return null;
+          throw error;
+        });
+        if (currentRaw) {
+          try {
+            const current = JSON.parse(currentRaw);
+            const currentUpdatedAt = hasValidFolderSnapshotShape(current)
+              && typeof current.updatedAt === 'number'
+              && Number.isFinite(current.updatedAt)
+              ? current.updatedAt
+              : 0;
+            if (currentUpdatedAt >= body.updatedAt) {
+              return res.json({ success: true, ignored: true });
+            }
+          } catch { /* A valid new snapshot repairs malformed prior state. */ }
+        }
+
+        await ensureDir();
+        tmp = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        await fsPromises.writeFile(tmp, serialized, 'utf8');
+        await fsPromises.rename(tmp, filePath);
+        saved = true;
+        return res.json({ success: true });
+      } catch (error) {
+        if (tmp && !saved) {
+          await fsPromises.unlink(tmp).catch(() => {});
+        }
+        const message = error instanceof Error ? error.message : 'Failed to write session folders';
+        return res.status(500).json({ error: message });
+      }
+    };
+
+    const pendingSave = saveQueue.then(save, save);
+    saveQueue = pendingSave.then(() => undefined, () => undefined);
+    return pendingSave;
   });
 };
diff --git a/packages/web/server/lib/session-folders/routes.test.js b/packages/web/server/lib/session-folders/routes.test.js
index 750b47ab..c2e00ca1 100644
--- a/packages/web/server/lib/session-folders/routes.test.js
+++ b/packages/web/server/lib/session-folders/routes.test.js
@@ -43,11 +43,25 @@ const createMockResponse = () => {
   };
 };
 
+const missingFile = async () => {
+  const error = new Error('missing');
+  error.code = 'ENOENT';
+  throw error;
+};
+
+const folderPayload = (updatedAt) => ({
+  version: 1,
+  foldersMap: {},
+  collapsedFolderIds: [],
+  updatedAt,
+});
+
 describe('session folders routes', () => {
   it('uses unique temp files for concurrent saves', async () => {
     const { app, getRoute } = createRouteRegistry();
     const tempPaths = [];
     const fsPromises = {
+      readFile: vi.fn(missingFile),
       mkdir: vi.fn(async () => {}),
       writeFile: vi.fn(async (tempPath) => {
         tempPaths.push(tempPath);
@@ -65,8 +79,8 @@ describe('session folders routes', () => {
     const handler = getRoute('POST', '/api/session-folders');
 
     await Promise.all([
-      handler({ body: { version: 1, updatedAt: 1 } }, createMockResponse()),
-      handler({ body: { version: 1, updatedAt: 2 } }, createMockResponse()),
+      handler({ body: folderPayload(1) }, createMockResponse()),
+      handler({ body: folderPayload(2) }, createMockResponse()),
     ]);
 
     expect(tempPaths).toHaveLength(2);
@@ -77,6 +91,7 @@ describe('session folders routes', () => {
   it('removes the temp file when rename fails', async () => {
     const { app, getRoute } = createRouteRegistry();
     const fsPromises = {
+      readFile: vi.fn(missingFile),
       mkdir: vi.fn(async () => {}),
       writeFile: vi.fn(async () => {}),
       rename: vi.fn(async () => {
@@ -94,9 +109,131 @@ describe('session folders routes', () => {
     const handler = getRoute('POST', '/api/session-folders');
     const response = createMockResponse();
 
-    await handler({ body: { version: 1, updatedAt: 1 } }, response);
+    await handler({ body: folderPayload(1) }, response);
 
     expect(response.statusCode).toBe(500);
     expect(fsPromises.unlink).toHaveBeenCalledWith(expect.stringContaining('sessions-directories.json.tmp-'));
   });
+
+  it('does not present a missing disk file as an authoritative empty snapshot', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    const fsPromises = { readFile: vi.fn(missingFile) };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    await getRoute('GET', '/api/session-folders')({}, response);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual({ version: 1, exists: false });
+  });
+
+  it('rejects malformed disk state instead of clearing valid browser state', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    const fsPromises = { readFile: vi.fn(async () => '{broken') };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    await getRoute('GET', '/api/session-folders')({}, response);
+
+    expect(response.statusCode).toBe(500);
+  });
+
+  it('rejects structurally invalid folder entries from disk', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    const malformedPayload = {
+      ...folderPayload(10),
+      foldersMap: { project: [{ id: 'folder', name: 'Folder', sessionIds: 'session-1', createdAt: 1 }] },
+    };
+    const fsPromises = { readFile: vi.fn(async () => JSON.stringify(malformedPayload)) };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    await getRoute('GET', '/api/session-folders')({}, response);
+
+    expect(response.statusCode).toBe(500);
+    expect(response.body).toEqual({ error: 'Stored session folders have an invalid shape' });
+  });
+
+  it('keeps the newest folder snapshot when an older write arrives later', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    let persisted = JSON.stringify(folderPayload(20));
+    const fsPromises = {
+      readFile: vi.fn(async () => persisted),
+      mkdir: vi.fn(async () => {}),
+      writeFile: vi.fn(async (_tempPath, value) => {
+        persisted = value;
+      }),
+      rename: vi.fn(async () => {}),
+      unlink: vi.fn(async () => {}),
+    };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    await getRoute('POST', '/api/session-folders')({ body: folderPayload(10) }, response);
+
+    expect(response.body).toEqual({ success: true, ignored: true });
+    expect(fsPromises.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('keeps the existing folder snapshot when a duplicate revision has different data', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    const persistedPayload = { ...folderPayload(20), foldersMap: { existing: [] } };
+    const fsPromises = {
+      readFile: vi.fn(async () => JSON.stringify(persistedPayload)),
+      mkdir: vi.fn(async () => {}),
+      writeFile: vi.fn(async () => {}),
+      rename: vi.fn(async () => {}),
+      unlink: vi.fn(async () => {}),
+    };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    const duplicateRevision = { ...folderPayload(20), foldersMap: { replacement: [] } };
+    await getRoute('POST', '/api/session-folders')({ body: duplicateRevision }, response);
+
+    expect(response.body).toEqual({ success: true, ignored: true });
+    expect(fsPromises.writeFile).not.toHaveBeenCalled();
+  });
+
+  it('allows a valid snapshot to repair structurally invalid prior state', async () => {
+    const { app, getRoute } = createRouteRegistry();
+    const fsPromises = {
+      readFile: vi.fn(async () => JSON.stringify({ version: 1, updatedAt: 999, foldersMap: null })),
+      mkdir: vi.fn(async () => {}),
+      writeFile: vi.fn(async () => {}),
+      rename: vi.fn(async () => {}),
+      unlink: vi.fn(async () => {}),
+    };
+    registerSessionFoldersRoutes(app, {
+      fsPromises,
+      path,
+      openchamberDataDir: '/tmp/openchamber-test',
+    });
+
+    const response = createMockResponse();
+    await getRoute('POST', '/api/session-folders')({ body: folderPayload(10) }, response);
+
+    expect(response.body).toEqual({ success: true });
+    expect(fsPromises.writeFile).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/packages/web/src/api/settings.ts b/packages/web/src/api/settings.ts
index 4aa75c32..d787fbee 100644
--- a/packages/web/src/api/settings.ts
+++ b/packages/web/src/api/settings.ts
@@ -5,9 +5,7 @@ const SETTINGS_ENDPOINT = '/api/config/settings';
 const RELOAD_ENDPOINT = '/api/config/reload';
 
 const sanitizePayload = (data: unknown): SettingsPayload => {
-  if (!data || typeof data !== 'object') {
-    return {};
-  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('Invalid settings response');
   return data as SettingsPayload;
 };
 
@@ -22,7 +20,7 @@ export const createWebSettingsAPI = (): SettingsAPI => ({
       throw new Error(`Failed to load settings: ${response.statusText}`);
     }
 
-    const payload = sanitizePayload(await response.json().catch(() => ({})));
+    const payload = sanitizePayload(await response.json());
     return {
       settings: payload,
       source: 'web',
@@ -44,7 +42,7 @@ export const createWebSettingsAPI = (): SettingsAPI => ({
       throw new Error(error.error || 'Failed to save settings');
     }
 
-    const payload = sanitizePayload(await response.json().catch(() => ({})));
+    const payload = sanitizePayload(await response.json());
     return payload;
   },
 
diff --git a/scripts/profile-browser.md b/scripts/profile-browser.md
new file mode 100644
index 00000000..82102516
--- /dev/null
+++ b/scripts/profile-browser.md
@@ -0,0 +1,54 @@
+# Browser performance capture
+
+Start OpenChamber locally, then run:
+
+```bash
+bun run profile:browser
+```
+
+The command opens an isolated Chrome profile. On the first run, complete any
+login or setup in that window, prepare the sessions and screen you want to
+measure, then return to the terminal and press Enter. Use OpenChamber normally
+for the next 60 seconds.
+
+Google Chrome is selected first on macOS, with Chrome Canary and Chromium as
+fallbacks. Other Chromium-based browsers are used only when explicitly selected
+with `--chrome /path/to/executable`.
+
+The generated `artifacts/browser-profile-*/` directory contains:
+
+- `summary.json`: long-task, memory, network, sync-operation, and UI streaming/render metrics. `failedRequests` includes transport failures and HTTP 4xx/5xx responses, while `httpErrorResponses` isolates HTTP errors;
+- `trace.json`: import into Chrome DevTools Performance with **Load profile**;
+- `network.har`: import into Chrome DevTools Network with **Import HAR**.
+
+`summary.json.longTaskAttribution` correlates long tasks with global-session
+lifecycle publications, session navigation, and targeted sidebar/message-list
+renders. One task may appear under multiple marks when phases overlap.
+
+Chrome trace finalization is allowed up to two minutes for large captures. If
+Chrome still does not emit its completion event, the command preserves the
+summary, HAR, and all trace events received so far instead of discarding the
+entire recording. In that case `summary.json` sets `traceComplete` to `false`,
+and trace-derived long-task totals should be treated as lower bounds.
+
+Trace events are streamed to disk instead of being serialized into one large
+JavaScript string. Summary and HAR files are written first, so they remain
+available even if the trace file cannot be completed. `traceFileComplete`
+reports whether `trace.json` finished writing.
+
+The HAR omits response bodies and redacts cookies, authorization headers, and
+sensitive URL parameters. The trace applies the same key and URL-parameter
+redaction, but profiling artifacts can still reveal project paths and endpoint
+names. Do not publish them without review.
+
+The capture bypasses the PWA service worker and reloads without the browser cache before recording, so repeated optimization runs execute the current local build instead of a previously cached bundle. Network recording begins after that reload, so startup asset downloads are not included in the HAR totals.
+
+Useful options:
+
+```bash
+bun run profile:browser -- --duration 120
+bun run profile:browser -- --url http://localhost:4173
+bun run profile:browser -- --output /tmp/openchamber-profile
+```
+
+Run `bun run profile:browser -- --help` for all options.
diff --git a/scripts/profile-browser.mjs b/scripts/profile-browser.mjs
new file mode 100644
index 00000000..1455d1a3
--- /dev/null
+++ b/scripts/profile-browser.mjs
@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process"
+import { createServer } from "node:net"
+import { mkdir, writeFile } from "node:fs/promises"
+import { createWriteStream, existsSync } from "node:fs"
+import { homedir, platform } from "node:os"
+import { join, resolve } from "node:path"
+import { createInterface } from "node:readline/promises"
+import process from "node:process"
+
+const HELP = `Usage: bun run profile:browser -- [options]
+
+Options:
+  --url <url>             OpenChamber URL (default: http://localhost:3000)
+  --duration <seconds>    Recording duration after Enter (default: 60)
+  --output <directory>    Artifact directory (default: artifacts/browser-profile-<time>)
+  --chrome <path>         Chrome/Chromium executable
+  --profile-dir <path>    Reusable isolated Chrome profile
+  --headless              Run without a visible browser
+  --no-prompt             Start after a 5 second preparation delay
+  --help                  Show this help
+
+The command records a Chrome performance trace, a redacted HAR, browser metrics,
+and OpenChamber's numeric sync counters. It never records response bodies.`
+
+const parseArgs = (argv) => {
+  const options = {
+    url: "http://localhost:3000",
+    duration: 60,
+    output: null,
+    chrome: null,
+    profileDir: join(homedir(), ".openchamber", "browser-profile-google-chrome"),
+    headless: false,
+    prompt: true,
+  }
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index]
+    if (value === "--help") return { ...options, help: true }
+    if (value === "--headless") options.headless = true
+    else if (value === "--no-prompt") options.prompt = false
+    else if (value === "--url") options.url = argv[++index]
+    else if (value === "--duration") options.duration = Number(argv[++index])
+    else if (value === "--output") options.output = argv[++index]
+    else if (value === "--chrome") options.chrome = argv[++index]
+    else if (value === "--profile-dir") options.profileDir = argv[++index]
+    else throw new Error(`Unknown option: ${value}`)
+  }
+  if (!Number.isFinite(options.duration) || options.duration <= 0) {
+    throw new Error("--duration must be a positive number")
+  }
+  new URL(options.url)
+  return options
+}
+
+const chromeCandidates = () => {
+  if (platform() === "darwin") {
+    return [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    ]
+  }
+  if (platform() === "win32") {
+    return [
+      join(process.env.PROGRAMFILES ?? "", "Google/Chrome/Application/chrome.exe"),
+      join(process.env["PROGRAMFILES(X86)"] ?? "", "Google/Chrome/Application/chrome.exe"),
+      join(process.env.LOCALAPPDATA ?? "", "Google/Chrome/Application/chrome.exe"),
+    ]
+  }
+  return ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser"]
+}
+
+const resolveChrome = (explicit) => {
+  if (explicit) {
+    const candidate = resolve(explicit)
+    if (!existsSync(candidate)) throw new Error(`Chrome executable not found: ${candidate}`)
+    return candidate
+  }
+  const candidate = chromeCandidates().find((path) => path && existsSync(path))
+  if (!candidate) throw new Error("Chrome/Chromium was not found. Pass its path with --chrome.")
+  return candidate
+}
+
+const reservePort = () => new Promise((resolvePort, reject) => {
+  const server = createServer()
+  server.unref()
+  server.on("error", reject)
+  server.listen(0, "127.0.0.1", () => {
+    const address = server.address()
+    if (!address || typeof address === "string") {
+      server.close()
+      reject(new Error("Could not reserve a Chrome debugging port"))
+      return
+    }
+    const port = address.port
+    server.close(() => resolvePort(port))
+  })
+})
+
+const wait = (milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds))
+
+const waitForJson = async (url, timeoutMs = 15_000) => {
+  const deadline = Date.now() + timeoutMs
+  let lastError
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url)
+      if (response.ok) return await response.json()
+    } catch (error) {
+      lastError = error
+    }
+    await wait(100)
+  }
+  throw new Error(`Chrome debugging endpoint did not start: ${lastError?.message ?? url}`)
+}
+
+const createPageTarget = async (port) => {
+  const baseUrl = `http://127.0.0.1:${port}`
+  await waitForJson(`${baseUrl}/json/version`)
+
+  try {
+    const response = await fetch(`${baseUrl}/json/new?${encodeURIComponent("about:blank")}`, { method: "PUT" })
+    if (response.ok) {
+      const target = await response.json()
+      if (target?.type === "page" && target.webSocketDebuggerUrl) return target
+    }
+  } catch {
+    // Some Chromium variants do not expose /json/new; use their startup page.
+  }
+
+  const targets = await waitForJson(`${baseUrl}/json`)
+  const target = targets.find((entry) => entry.type === "page" && entry.webSocketDebuggerUrl)
+  if (!target) throw new Error("Chrome did not expose or create a page target")
+  return target
+}
+
+class CdpClient {
+  constructor(url) {
+    this.socket = new WebSocket(url)
+    this.nextId = 1
+    this.pending = new Map()
+    this.listeners = new Map()
+  }
+
+  async connect() {
+    await new Promise((resolveConnect, reject) => {
+      this.socket.addEventListener("open", resolveConnect, { once: true })
+      this.socket.addEventListener("error", reject, { once: true })
+    })
+    this.socket.addEventListener("message", (event) => {
+      const message = JSON.parse(String(event.data))
+      if (message.id) {
+        const pending = this.pending.get(message.id)
+        if (!pending) return
+        this.pending.delete(message.id)
+        if (message.error) pending.reject(new Error(message.error.message))
+        else pending.resolve(message.result ?? {})
+        return
+      }
+      for (const listener of this.listeners.get(message.method) ?? []) listener(message.params ?? {})
+    })
+  }
+
+  send(method, params = {}) {
+    const id = this.nextId++
+    return new Promise((resolveSend, reject) => {
+      this.pending.set(id, { resolve: resolveSend, reject: reject })
+      this.socket.send(JSON.stringify({ id, method, params }))
+    })
+  }
+
+  on(method, listener) {
+    const listeners = this.listeners.get(method) ?? new Set()
+    listeners.add(listener)
+    this.listeners.set(method, listeners)
+    return () => listeners.delete(listener)
+  }
+
+  once(method, timeoutMs = 15_000) {
+    return new Promise((resolveEvent, reject) => {
+      const timeout = setTimeout(() => {
+        unsubscribe()
+        reject(new Error(`Timed out waiting for ${method}`))
+      }, timeoutMs)
+      const unsubscribe = this.on(method, (params) => {
+        clearTimeout(timeout)
+        unsubscribe()
+        resolveEvent(params)
+      })
+    })
+  }
+
+  close() {
+    this.socket.close()
+  }
+}
+
+const SENSITIVE_HEADER = /authorization|cookie|token|secret|password|api[-_]?key|x-openchamber/i
+const SENSITIVE_QUERY = /token|secret|password|auth|key|code|credential/i
+
+const redactHeaders = (headers = {}) => Object.entries(headers).map(([name, value]) => ({
+  name,
+  value: SENSITIVE_HEADER.test(name) ? "[REDACTED]" : String(value),
+}))
+
+const redactUrl = (value) => {
+  try {
+    const url = new URL(value)
+    for (const name of [...url.searchParams.keys()]) {
+      if (SENSITIVE_QUERY.test(name)) url.searchParams.set(name, "[REDACTED]")
+    }
+    return url.toString()
+  } catch {
+    return value
+  }
+}
+
+const redactTraceJson = (key, value) => {
+  if (SENSITIVE_HEADER.test(key)) return "[REDACTED]"
+  if (typeof value === "string" && /^https?:\/\//i.test(value)) return redactUrl(value)
+  return value
+}
+
+const writeTraceFile = (path, traceEvents) => new Promise((resolveWrite, rejectWrite) => {
+  const stream = createWriteStream(path, { encoding: "utf8" })
+  let index = 0
+
+  const writeNext = () => {
+    while (index < traceEvents.length) {
+      const prefix = index === 0 ? "" : ","
+      const serialized = JSON.stringify(traceEvents[index], redactTraceJson)
+      index += 1
+      if (!stream.write(`${prefix}${serialized}`)) {
+        stream.once("drain", writeNext)
+        return
+      }
+    }
+    stream.end("]}")
+  }
+
+  stream.on("error", rejectWrite)
+  stream.on("finish", resolveWrite)
+  stream.write('{"traceEvents":[')
+  writeNext()
+})
+
+const createHar = (records, pageUrl, startedAt) => ({
+  log: {
+    version: "1.2",
+    creator: { name: "OpenChamber browser profiler", version: "1" },
+    pages: [{ startedDateTime: startedAt, id: "page_1", title: "OpenChamber profile", pageTimings: {} }],
+    entries: [...records.values()].map((record) => {
+      const start = record.wallTime ? new Date(record.wallTime * 1000).toISOString() : startedAt
+      const duration = record.finishedAt && record.startedAt
+        ? Math.max(0, (record.finishedAt - record.startedAt) * 1000)
+        : 0
+      return {
+        pageref: "page_1",
+        startedDateTime: start,
+        time: duration,
+        request: {
+          method: record.request?.method ?? "GET",
+          url: redactUrl(record.request?.url ?? pageUrl),
+          httpVersion: "HTTP/1.1",
+          headers: redactHeaders(record.request?.headers),
+          queryString: [],
+          cookies: [],
+          headersSize: -1,
+          bodySize: record.request?.postData ? Buffer.byteLength(record.request.postData) : 0,
+        },
+        response: {
+          status: record.response?.status ?? 0,
+          statusText: record.response?.statusText ?? (record.failed ? "Failed" : ""),
+          httpVersion: record.response?.protocol ?? "",
+          headers: redactHeaders(record.response?.headers),
+          cookies: [],
+          content: {
+            size: record.encodedDataLength ?? 0,
+            mimeType: record.response?.mimeType ?? "",
+          },
+          redirectURL: "",
+          headersSize: -1,
+          bodySize: record.encodedDataLength ?? -1,
+        },
+        cache: {},
+        timings: { blocked: -1, dns: -1, connect: -1, send: 0, wait: duration, receive: 0, ssl: -1 },
+        _resourceType: record.type ?? null,
+        _failed: record.failed ?? null,
+      }
+    }),
+  },
+})
+
+const metricMap = (metrics = []) => Object.fromEntries(metrics.map(({ name, value }) => [name, value]))
+
+const LONG_TASK_ATTRIBUTION_MARKS = [
+  "openchamber.global_sessions.event_update_flush",
+  "openchamber.navigation.session_select",
+  "openchamber.navigation.session_state_set",
+  "openchamber.react.session_sidebar_render",
+  "openchamber.react.message_list_render",
+]
+
+const buildLongTaskAttribution = (traceEvents, longTasks) => {
+  const marks = traceEvents.filter((event) => LONG_TASK_ATTRIBUTION_MARKS.includes(event.name))
+  return Object.fromEntries(LONG_TASK_ATTRIBUTION_MARKS.map((markName) => {
+    const matchingMarks = marks.filter((event) => event.name === markName)
+    const matchingTasks = longTasks.filter((task) => matchingMarks.some((mark) => (
+      mark.pid === task.pid
+      && mark.tid === task.tid
+      && Number(mark.ts) >= Number(task.ts)
+      && Number(mark.ts) <= Number(task.ts) + Number(task.dur)
+    )))
+    const durations = matchingTasks.map((task) => Number(task.dur) / 1000)
+    return [markName, {
+      marks: matchingMarks.length,
+      longTasks: matchingTasks.length,
+      totalLongTaskMs: Number(durations.reduce((total, duration) => total + duration, 0).toFixed(3)),
+      longestTaskMs: Number(durations.reduce((max, duration) => Math.max(max, duration), 0).toFixed(3)),
+    }]
+  }))
+}
+
+const evaluateValue = async (client, expression) => {
+  const result = await client.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true })
+  return result.result?.value ?? null
+}
+
+const main = async () => {
+  const options = parseArgs(process.argv.slice(2))
+  if (options.help) {
+    console.log(HELP)
+    return
+  }
+
+  const chrome = resolveChrome(options.chrome)
+  const timestamp = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-")
+  const output = resolve(options.output ?? join("artifacts", `browser-profile-${timestamp}`))
+  const profileDir = resolve(options.profileDir)
+  await mkdir(output, { recursive: true })
+  await mkdir(profileDir, { recursive: true })
+  const port = await reservePort()
+  const chromeArgs = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${profileDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-networking",
+    "about:blank",
+  ]
+  if (options.headless) chromeArgs.unshift("--headless=new", "--disable-gpu")
+
+  const chromeProcess = spawn(chrome, chromeArgs, { stdio: "ignore" })
+  let client
+  try {
+    console.log(`Using browser: ${chrome}`)
+    const target = await createPageTarget(port)
+    client = new CdpClient(target.webSocketDebuggerUrl)
+    await client.connect()
+    await Promise.all([
+      client.send("Page.enable"),
+      client.send("Runtime.enable"),
+      client.send("Network.enable", { maxTotalBufferSize: 0, maxResourceBufferSize: 0 }),
+      client.send("Performance.enable"),
+    ])
+    // Profile the current local build rather than a service-worker-cached
+    // bundle from an earlier optimization run.
+    await client.send("Network.setBypassServiceWorker", { bypass: true })
+
+    const loaded = client.once("Page.loadEventFired", 30_000)
+    await client.send("Page.navigate", { url: options.url })
+    await loaded
+    await evaluateValue(client, `
+      localStorage.setItem("openchamber_sync_perf", "1")
+      localStorage.setItem("openchamber_stream_perf", "1")
+    `)
+    const reloaded = client.once("Page.loadEventFired", 30_000)
+    await client.send("Page.reload", { ignoreCache: true })
+    await reloaded
+
+    if (options.prompt && !options.headless && process.stdin.isTTY) {
+      const readline = createInterface({ input: process.stdin, output: process.stdout })
+      console.log(`\nChrome opened ${options.url}. Prepare the sessions and screen you want to measure.`)
+      await readline.question("Press Enter to start recording... ")
+      readline.close()
+    } else {
+      console.log("Waiting 5 seconds before recording...")
+      await wait(5_000)
+    }
+
+    await evaluateValue(client, `window.__openchamberSyncPerformance?.reset()`)
+    await evaluateValue(client, `window.__openchamberStreamPerformance?.setEnabled(true)`)
+    await evaluateValue(client, `window.__openchamberStreamPerformance?.reset()`)
+    const records = new Map()
+    const traceEvents = []
+    const startedAt = new Date().toISOString()
+    const unsubscribers = [
+      client.on("Network.requestWillBeSent", (event) => {
+        records.set(event.requestId, {
+          request: event.request,
+          type: event.type,
+          startedAt: event.timestamp,
+          wallTime: event.wallTime,
+        })
+      }),
+      client.on("Network.responseReceived", (event) => {
+        const record = records.get(event.requestId)
+        if (record) record.response = event.response
+      }),
+      client.on("Network.loadingFinished", (event) => {
+        const record = records.get(event.requestId)
+        if (record) {
+          record.finishedAt = event.timestamp
+          record.encodedDataLength = event.encodedDataLength
+        }
+      }),
+      client.on("Network.loadingFailed", (event) => {
+        const record = records.get(event.requestId)
+        if (record) {
+          record.finishedAt = event.timestamp
+          record.failed = event.errorText
+        }
+      }),
+      client.on("Tracing.dataCollected", ({ value }) => traceEvents.push(...(value ?? []))),
+    ]
+
+    const beforeMetrics = metricMap((await client.send("Performance.getMetrics")).metrics)
+    const beforeHeap = await client.send("Runtime.getHeapUsage")
+    await client.send("Tracing.start", {
+      transferMode: "ReportEvents",
+      categories: [
+        "devtools.timeline",
+        "v8.execute",
+        "blink.user_timing",
+        "loading",
+        "disabled-by-default-devtools.timeline",
+        "disabled-by-default-devtools.timeline.frame",
+      ].join(","),
+    })
+
+    console.log(`Recording for ${options.duration} seconds. Use OpenChamber normally during this window.`)
+    await wait(options.duration * 1000)
+    const afterMetrics = metricMap((await client.send("Performance.getMetrics")).metrics)
+    const afterHeap = await client.send("Runtime.getHeapUsage")
+    const syncCounters = await evaluateValue(client, `window.__openchamberSyncPerformance?.getSnapshot() ?? null`)
+    const streamPerformance = await evaluateValue(client, `window.__openchamberStreamPerformance?.getSnapshot() ?? null`)
+    const traceCompleteEvent = client.once("Tracing.tracingComplete", 120_000)
+    let traceComplete = true
+    try {
+      await client.send("Tracing.end")
+      await traceCompleteEvent
+    } catch (error) {
+      traceComplete = false
+      void traceCompleteEvent.catch(() => undefined)
+      console.warn(`Chrome did not confirm trace completion; saving the collected partial trace: ${error.message}`)
+      // Allow already-buffered Tracing.dataCollected events a final turn before writing.
+      await wait(2_000)
+    }
+    for (const unsubscribe of unsubscribers) unsubscribe()
+
+    const longTasks = traceEvents.filter((event) => event.name === "RunTask" && Number(event.dur) >= 50_000)
+    const longTaskAttribution = buildLongTaskAttribution(traceEvents, longTasks)
+    const failedRequests = [...records.values()].filter((record) => (
+      record.failed || Number(record.response?.status) >= 400
+    )).length
+    const httpErrorResponses = [...records.values()].filter((record) => Number(record.response?.status) >= 400).length
+    const summary = {
+      recordedAt: startedAt,
+      url: redactUrl(options.url),
+      durationSeconds: options.duration,
+      requests: records.size,
+      failedRequests,
+      httpErrorResponses,
+      transferredBytes: [...records.values()].reduce((total, record) => total + (record.encodedDataLength ?? 0), 0),
+      longTasksOver50ms: longTasks.length,
+      longestTaskMs: longTasks.reduce((max, event) => Math.max(max, Number(event.dur) / 1000), 0),
+      longTaskAttribution,
+      performanceMetricsBefore: beforeMetrics,
+      performanceMetricsAfter: afterMetrics,
+      heapBefore: beforeHeap,
+      heapAfter: afterHeap,
+      syncCounters,
+      streamPerformance,
+      traceComplete,
+      traceFileComplete: false,
+      privacy: "Headers and sensitive URL parameters are redacted. Response bodies are not captured.",
+    }
+
+    const summaryPath = join(output, "summary.json")
+    await Promise.all([
+      writeFile(join(output, "network.har"), JSON.stringify(createHar(records, options.url, startedAt), null, 2)),
+      writeFile(summaryPath, JSON.stringify(summary, null, 2)),
+    ])
+    try {
+      await writeTraceFile(join(output, "trace.json"), traceEvents)
+      summary.traceFileComplete = true
+      await writeFile(summaryPath, JSON.stringify(summary, null, 2))
+    } catch (error) {
+      console.warn(`Trace file write failed; summary and HAR were preserved: ${error.message}`)
+    }
+    console.log(`\nProfile saved to ${output}`)
+    if (!traceComplete) console.log("Trace completion was not confirmed; summary, HAR, and the collected partial trace were preserved.")
+    if (!summary.traceFileComplete) console.log("Trace file is incomplete; summary and HAR are available.")
+    console.log(`Long tasks over 50 ms: ${summary.longTasksOver50ms}; requests: ${summary.requests}`)
+  } finally {
+    client?.close()
+    if (!chromeProcess.killed) chromeProcess.kill("SIGTERM")
+  }
+}
+
+main().catch((error) => {
+  console.error(`Browser profiling failed: ${error.message}`)
+  process.exitCode = 1
+})