fix(chat): release live follow on middle-button pan, Shift+Space, and nested wheel

Merge main and reshape the follow opt-out to the gestures the timeline was
missing: a middle-button press starts the platform autoscroll pan (the only
scroll gesture on wheel-less mice and tablets with a pointer), Shift+Space
scrolls up from the keyboard, and an upward wheel over a nested scroller that
still has room above stays with that scroller instead of releasing the chat.

The grace re-pin timer and scroll-direction tracking are dropped: returning to
within the end band already re-arms follow, and the mode machine is built
without timers on purpose. Pause/Break never move the viewport and are not
gestures.

Closes #1640

packages/ui/src/App.tsx

@@ -7,6 +7,7 @@ import { Toaster } from '@/components/ui/sonner';
 import { Button } from '@/components/ui/button';
 import { MemoryDebugPanel } from '@/components/ui/MemoryDebugPanel';
 import { setStreamPerfEnabled } from '@/stores/utils/streamDebug';
+import { setRequestsInFlightTrackingEnabled } from '@/stores/utils/requestsInFlight';
 import { ErrorBoundary } from '@/components/ui/ErrorBoundary';
 // useEventStream removed — replaced by SyncProvider + SyncBridge
 import { useMenuActions } from '@/hooks/useMenuActions';
@@ -19,6 +20,7 @@ import { useWebNotificationStream } from '@/hooks/useWebNotificationStream';
 import { useAgentMemorySync } from '@/hooks/useAgentMemorySync';
 import { usePwaInstallPrompt } from '@/hooks/usePwaInstallPrompt';
 import { useWindowTitle } from '@/hooks/useWindowTitle';
+import { useRootScrollLock } from '@/hooks/useRootScrollLock';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { isDesktopLocalOriginActive, isDesktopShell, restartDesktopApp, invokeDesktop } from '@/lib/desktop';
 import {
@@ -279,6 +281,13 @@ function App({ apis }: AppProps) {
     };
   }, [showMemoryDebug]);
 
+  React.useEffect(() => {
+    setRequestsInFlightTrackingEnabled(showMemoryDebug);
+    return () => {
+      setRequestsInFlightTrackingEnabled(false);
+    };
+  }, [showMemoryDebug]);
+
   React.useEffect(() => {
     applyMobileKeyboardMode(mobileKeyboardMode);
   }, [mobileKeyboardMode]);
@@ -709,6 +718,8 @@ function App({ apis }: AppProps) {
 
   useWindowTitle();
 
+  useRootScrollLock();
+
   useRouter();
 
   const handleToggleMemoryDebug = React.useCallback(() => {

packages/ui/src/apps/ElectronMiniChatApp.tsx

@@ -8,6 +8,7 @@ import { MiniChatLayout } from '@/components/mini-chat/MiniChatLayout';
 import { AppLinkConfirmDialog } from '@/components/chat/AppLinkConfirmDialog';
 import { usePushVisibilityBeacon } from '@/hooks/usePushVisibilityBeacon';
 import { useWindowTitle } from '@/hooks/useWindowTitle';
+import { useRootScrollLock } from '@/hooks/useRootScrollLock';
 import { opencodeClient } from '@/lib/opencode/client';
 import type { RuntimeAPIs } from '@/lib/api/types';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
@@ -318,6 +319,7 @@ export function ElectronMiniChatApp({ apis }: ElectronMiniChatAppProps) {
   useMiniChatKeyboardShortcuts();
   usePushVisibilityBeacon({ enabled: true });
   useWindowTitle();
+  useRootScrollLock();
 
   return (
     <ErrorBoundary>

packages/ui/src/apps/MobileSessionsSheet.tsx

@@ -41,6 +41,8 @@ import { ScrollShadow } from '@/components/ui/ScrollShadow';
 import { toast } from '@/components/ui';
 import { useThemeSystem } from '@/contexts/useThemeSystem';
 import { getProjectLabel, normalizePath } from './mobilePaths';
+import { CHAT_DRAFT_PROJECT_ID, isChatDirectoryPath } from '@/lib/chatDirectories';
+import { partitionSidebarSessions } from '@/components/session/sidebar/list/sessionCollection';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import { useI18n } from '@/lib/i18n';
 import { matchesRankQuery, rankByQuery } from '@/lib/search/fuzzySearch';
@@ -1022,6 +1024,27 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
     return merged.filter((session) => !session.time?.archived);
   }, [globalActiveSessions, liveSessions]);
 
+  // Managed Chats (sessions under ~/.config/openchamber/chats) are not owned
+  // by any registered project; they get their own section above the project
+  // tree, the same split the desktop sidebar makes. Temporary /btw forks are
+  // dropped here as well.
+  const { projectSessions, chatSessions } = React.useMemo(
+    () => partitionSidebarSessions(sessions, false),
+    [sessions],
+  );
+  const chatsBucket = React.useMemo<WorktreeBucket>(() => ({
+    key: CHAT_DRAFT_PROJECT_ID,
+    label: '',
+    path: '',
+    worktree: null,
+    sessions: orderSessionsByLifecycleScopes(chatSessions, pinnedSessionIds, sessionOrderRanks),
+  }), [chatSessions, pinnedSessionIds, sessionOrderRanks]);
+  const chatsBucketKey = `${CHAT_DRAFT_PROJECT_ID}::${CHAT_DRAFT_PROJECT_ID}`;
+  const chatRootCount = React.useMemo(
+    () => chatSessions.filter((session) => !getParentId(session)).length,
+    [chatSessions],
+  );
+
   const normalizedQuery = query.trim().toLowerCase();
 
   // On open, bring the current session (or at least its project) into view —
@@ -1070,7 +1093,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
       for (const worktree of node.project.worktrees) ensureBucket(node, worktree.path, worktree);
     }
 
-    for (const session of sessions) {
+    for (const session of projectSessions) {
       const directory = getSessionDirectory(session);
       if (!directory) continue;
       const normalizedDirectory = normalizePath(directory);
@@ -1093,7 +1116,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
     }
 
     return nodes;
-  }, [activeProjectId, pinnedSessionIds, projectsMeta, sessionOrderRanks, sessions]);
+  }, [activeProjectId, pinnedSessionIds, projectSessions, projectsMeta, sessionOrderRanks]);
 
   const normalizedDirectory = normalizePath(currentDirectory);
 
@@ -1149,8 +1172,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
   // Paginated, tree-aware list of a bucket's sessions: top-level sessions paginate,
   // and a parent with subsessions can be expanded to reveal its children (nested,
   // recursively). Pagination counts only top-level sessions.
-  const renderBucketSessions = (node: ProjectNode, bucket: WorktreeBucket, indent: number) => {
-    const bucketKey = `${node.project.id}::${bucket.key}`;
+  const renderBucketSessions = (bucketKey: string, bucket: WorktreeBucket, indent: number) => {
 
     // Group children by parent within this bucket, and treat sessions whose parent
     // is not in this bucket as top-level so nothing is hidden.
@@ -1336,13 +1358,14 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
   const buildSessionContextLabel = React.useCallback(
     (session: Session): string => {
       const directory = getSessionDirectory(session);
+      if (isChatDirectoryPath(directory)) return t('mobile.sessions.section.chats');
       const project = findExactProjectMatch(projectsMeta, directory);
       if (!project) return getProjectLabel(directory) || directory;
       const matchedWorktree = findExactWorktreeMatch(project, normalizePath(directory));
       if (matchedWorktree?.branch) return `${project.label} · ${matchedWorktree.branch}`;
       return project.label;
     },
-    [projectsMeta],
+    [projectsMeta, t],
   );
 
   const handleSelectProject = (project: ProjectMeta) => {
@@ -1481,7 +1504,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
               ) : null}
             </div>
           </div>
-          {projectsMeta.length === 0 ? (
+          {projectsMeta.length === 0 && chatSessions.length === 0 ? (
             <MobileSessionsEmpty
               title={t('mobile.sessions.empty.noProjectsTitle')}
               description={t('mobile.sessions.empty.noProjectsDescription')}
@@ -1601,7 +1624,56 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
             </div>
           ) : (
             <div className="flex flex-col">
-              {orderedNodes.map((node, nodeIndex) => {
+              {(() => {
+                const chatsExpanded = projectExpandedMap[CHAT_DRAFT_PROJECT_ID] ?? true;
+                const chatsLabel = t('mobile.sessions.section.chats');
+                return (
+                  <section>
+                    <div className="flex min-h-12 w-full items-center">
+                      <button
+                        type="button"
+                        className="flex min-h-12 min-w-0 flex-1 items-center gap-2 px-3 py-1.5 text-left transition-colors hover:bg-interactive-hover focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-inset"
+                        onClick={() => {
+                          if (revealedRowId) {
+                            handleRowKeyRevealedChange(revealedRowId, false);
+                            return;
+                          }
+                          toggleProject(CHAT_DRAFT_PROJECT_ID, chatsExpanded);
+                        }}
+                        aria-expanded={chatsExpanded}
+                        aria-label={
+                          chatsExpanded
+                            ? t('sessions.sidebar.group.collapseAria', { label: chatsLabel })
+                            : t('sessions.sidebar.group.expandAria', { label: chatsLabel })
+                        }
+                        style={{ touchAction: 'manipulation' }}
+                      >
+                        <span className="flex size-8 shrink-0 items-center justify-center overflow-hidden rounded-lg bg-[var(--surface-muted)] text-muted-foreground">
+                          <Icon name="chat-4" className="size-4" />
+                        </span>
+                        <span className="block min-w-0 flex-1 truncate typography-ui-label font-semibold text-foreground">
+                          {chatsLabel}
+                        </span>
+                        <span className="shrink-0 typography-micro text-muted-foreground tabular-nums">
+                          {chatRootCount}
+                        </span>
+                      </button>
+                    </div>
+                    {chatsExpanded ? (
+                      <div className="pb-2">
+                        {chatsBucket.sessions.length > 0 ? (
+                          renderBucketSessions(chatsBucketKey, chatsBucket, PROJECT_SESSION_INDENT)
+                        ) : (
+                          <p className="px-3 pb-1 typography-micro text-muted-foreground" style={{ paddingLeft: PROJECT_SESSION_INDENT }}>
+                            {t('sessions.sidebar.activity.chatsEmpty')}
+                          </p>
+                        )}
+                      </div>
+                    ) : null}
+                  </section>
+                );
+              })()}
+              {orderedNodes.map((node) => {
                 const projectExpanded = isProjectExpanded(node);
                 const buckets = normalizedQuery
                   ? node.buckets.filter((bucket) =>
@@ -1614,7 +1686,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
                 return (
                   <section
                     key={node.project.id}
-                    className={cn(nodeIndex > 0 && 'border-t border-border/70')}
+                    className="border-t border-border/70"
                   >
                     <MobileSwipeActionsRow
                       actionsWidth={96}
@@ -1712,7 +1784,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
                           return (
                             <>
                               {rootBucket && rootBucket.sessions.length > 0
-                                ? renderBucketSessions(node, rootBucket, PROJECT_SESSION_INDENT)
+                                ? renderBucketSessions(`${node.project.id}::${rootBucket.key}`, rootBucket, PROJECT_SESSION_INDENT)
                                 : null}
                               {worktreeBuckets.map((bucket) => {
                                 const worktreeExpanded = isWorktreeExpanded(node, bucket);
@@ -1787,7 +1859,7 @@ export const MobileSessionsSheet: React.FC<MobileSessionsSheetProps> = ({ open,
                                     </button>
                                     </MobileSwipeActionsRow>
                                     {worktreeExpanded
-                                      ? renderBucketSessions(node, bucket, PROJECT_SESSION_INDENT)
+                                      ? renderBucketSessions(`${node.project.id}::${bucket.key}`, bucket, PROJECT_SESSION_INDENT)
                                       : null}
                                   </div>
                                 );

packages/ui/src/apps/VSCodeApp.tsx

@@ -14,6 +14,7 @@ import { usePushVisibilityBeacon } from '@/hooks/usePushVisibilityBeacon';
 import { useGlobalSessionsPolling } from '@/hooks/useGlobalSessionsPolling';
 import { useRouter } from '@/hooks/useRouter';
 import { useWindowTitle } from '@/hooks/useWindowTitle';
+import { useRootScrollLock } from '@/hooks/useRootScrollLock';
 import { opencodeClient } from '@/lib/opencode/client';
 import type { RuntimeAPIs } from '@/lib/api/types';
 import { runtimeFetch } from '@/lib/runtime-fetch';
@@ -57,6 +58,7 @@ export function VSCodeApp({ apis }: VSCodeAppProps) {
   useAppFontEffects();
   usePushVisibilityBeacon({ enabled: true });
   useWindowTitle();
+  useRootScrollLock();
   useRouter();
   useGlobalSessionsPolling(panelType !== 'agentManager');
 

packages/ui/src/components/auth/SessionAuthGate.behavior.test.tsx

@@ -303,6 +303,19 @@ mock.module('@/lib/passkeys', () => ({
   registerCurrentDevicePasskey: mock(() => Promise.resolve(null)),
 }));
 
+const authSessionStore = {
+  state: 'ok' as const,
+  markAuthenticated: mock(() => undefined),
+};
+
+mock.module('@/lib/runtime-auth-expiry', () => ({
+  installAuthSessionFocusWatch: mock(() => undefined),
+  useAuthSessionStore: Object.assign(
+    (selector: (store: typeof authSessionStore) => unknown) => selector(authSessionStore),
+    { getState: () => authSessionStore },
+  ),
+}));
+
 const { SessionAuthGate } = await import('./SessionAuthGate');
 
 const flushEffects = async () => {

packages/ui/src/components/browser/BrowserPane.tsx

@@ -339,6 +339,25 @@ const WebviewBrowser: React.FC<BrowserPaneProps> = ({ initialUrl, directory, tab
     }
 
     if (action === 'browser.capture') {
+      // A user may close the panel after browser.open. Chromium then removes
+      // the zero-width webview's composited surface and capturePage() fails
+      // with UnknownVizError. Reveal this existing browser tab again and let
+      // the layout paint before asking Electron for the image.
+      useUIStore.getState().openContextBrowser(directory, webview.getURL());
+      const surfaceDeadline = Date.now() + 1_200;
+      let previousWidth = 0;
+      let stableSamples = 0;
+      while (stableSamples < 2 && Date.now() < surfaceDeadline) {
+        const width = webview.getBoundingClientRect().width;
+        stableSamples = width >= 2 && Math.abs(width - previousWidth) < 0.5
+          ? stableSamples + 1
+          : 0;
+        previousWidth = width;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      await new Promise<void>((resolve) => {
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+      });
       // Wait for a settled page first: a screenshot of a half-painted layout is
       // worse than none, because it looks like a finished one.
       await waitForIdle();
@@ -450,7 +469,7 @@ const WebviewBrowser: React.FC<BrowserPaneProps> = ({ initialUrl, directory, tab
       await waitForIdle();
     }
     return result;
-  }, [annotationHost, loadUrl, waitForIdle]);
+  }, [annotationHost, directory, loadUrl, waitForIdle]);
 
   React.useEffect(
     () => registerBrowserController({ run: runControlAction }),

packages/ui/src/components/chat/ChatInput.tsx

@@ -35,7 +35,8 @@ import {
 import { ReviewFlowDialog, type ReviewFlowExecution } from '@/components/session/ReviewFlowDialog';
 import { BtwPanel } from './btw/BtwPanel';
 import { useBtwPanelState } from './btw/useBtwPanelState';
-import { destroyBtwSession, startBtwSession, type BtwSessionRef } from '@/lib/btw';
+import { wasPromotedBtwSession } from '@/lib/sessionBtwMetadata';
+import { buildBtwSyntheticTexts, destroyBtwSession, startBtwSession, type BtwSessionRef } from '@/lib/btw';
 import { AttachedFilesList, AttachedVSCodeFileChips, ActiveEditorFileSuggestion } from './FileAttachment';
 import { lazyWithChunkRecovery } from '@/lib/chunkLoadRecovery';
 import type { ToolPopupContent } from './message/types';
@@ -104,10 +105,12 @@ import {
     type ComposerEditorHandle,
 } from './composer/editor/ComposerEditor';
 import { createComposerEditorViewStore } from './composer/editor/viewStore';
+import { composerAutoCorrect } from './composer/editor/autocorrect';
 import {
     appendInlineText,
     appendWithLineBreaks,
     buildImagePasteInsertion,
+    getMarkdownAutoPairEdit,
     shouldWrapSelectionAsLink,
     withInlineInsertionBoundaries,
 } from './composer/text';
@@ -338,6 +341,10 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
         [btwDirectory, btwSessionId, currentSessionId],
     );
     const isBtwActive = Boolean(btwSessionRef) && !btwPanel.collapsed;
+    // A session promoted out of `/btw` keeps the boundary instructions in its
+    // transcript — there is no way to delete a message part — so it has to say
+    // they no longer apply.
+    const isPromotedBtwSession = wasPromotedBtwSession(btwPanel.parentSession);
     const activeRuntimeKey = getRuntimeKey();
     const chatDraftIdentity = React.useMemo(
         () => createChatDraftIdentity(
@@ -1010,6 +1017,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
 
         if (!providerIdToSend || !modelIdToSend) {
             console.warn('Cannot send message: provider or model not selected');
+            toast.error(t('chat.chatInput.toast.noModelSelected'));
             return;
         }
 
@@ -1126,7 +1134,10 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
             composerText: !queuedOnly && inputSnapshot.hasContent ? inputSnapshot.message : null,
             composerAttachments: attachedFiles,
             inlineComments: drafts,
-            syntheticTexts: syntheticParts?.map((part) => part.text) ?? [],
+            syntheticTexts: [
+                ...buildBtwSyntheticTexts({ isBtwActive, isPromotedBtwSession }),
+                ...(syntheticParts?.map((part) => part.text) ?? []),
+            ],
             linkedIssue: linkedIssue
                 ? { number: linkedIssue.number, title: linkedIssue.title, url: linkedIssue.url, contextText: linkedIssue.contextText }
                 : null,
@@ -1620,39 +1631,18 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
             const selEnd = ta?.getSelection().end ?? -1;
 
             if (ta && selStart >= 0) {
-                const applyEdit = (next: string, caretStart: number, caretEnd: number) => {
+                const edit = getMarkdownAutoPairEdit(message, e.key, selStart, selEnd);
+                if (edit) {
                     e.preventDefault();
-                    setMessage(next);
-                    composerRef.current?.setSelection(caretStart, caretEnd);
-                    updateAutocompleteState(next, caretEnd);
-                };
-
-                // Wrap the current selection: select text, press ` * _ ~ ( [ { " '
-                const WRAP_PAIRS: Record<string, [string, string]> = {
-                    '`': ['`', '`'], '*': ['*', '*'], '_': ['_', '_'], '~': ['~', '~'],
-                    '(': ['(', ')'], '[': ['[', ']'], '{': ['{', '}'],
-                    '"': ['"', '"'], "'": ["'", "'"],
-                };
-                if (selEnd > selStart && WRAP_PAIRS[e.key]) {
-                    const [open, close] = WRAP_PAIRS[e.key];
-                    const selected = message.slice(selStart, selEnd);
-                    const next = `${message.slice(0, selStart)}${open}${selected}${close}${message.slice(selEnd)}`;
-                    applyEdit(next, selStart + open.length, selEnd + open.length);
+                    ta.replaceRange(
+                        edit.from,
+                        edit.to,
+                        edit.insert,
+                        edit.selectionStart,
+                        edit.selectionEnd,
+                    );
                     return;
                 }
-
-                // Typing the third backtick at line start expands into a fenced
-                // code block with the caret on the empty middle line (Slack-like).
-                if (e.key === '`' && selStart === selEnd) {
-                    const before = message.slice(0, selStart);
-                    if (/(^|\n)``$/.test(before)) {
-                        const after = message.slice(selEnd);
-                        const next = `${before}\`\n\n\`\`\`${after}`;
-                        const caret = before.length + 2; // after the completed ``` and first newline
-                        applyEdit(next, caret, caret);
-                        return;
-                    }
-                }
             }
         }
 
@@ -2851,7 +2841,7 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
                                             : t(useCompactChatPlaceholder ? 'chat.chatInput.placeholder.chatCompact' : 'chat.chatInput.placeholder.chat')
                                         : t('chat.chatInput.placeholder.selectSession')}
                                 editable={Boolean(currentSessionId || newSessionDraftOpen)}
-                                autoCorrect={isMobile}
+                                autoCorrect={composerAutoCorrect({ isMobile })}
                                 autoCapitalize={isMobile ? 'sentences' : 'none'}
                                 spellCheck={isMobile || inputSpellcheckEnabled}
                                 fillContainer={isComposerExpanded}

packages/ui/src/components/chat/CommandAutocomplete.tsx

@@ -1,7 +1,6 @@
 import React from 'react';
 import { cn, fuzzyMatch } from '@/lib/utils';
 import { useSessionUIStore } from '@/sync/session-ui-store';
-import { useSessionMessages } from '@/sync/sync-context';
 import { useCommandsStore } from '@/stores/useCommandsStore';
 import { useSkillsStore } from '@/stores/useSkillsStore';
 import { ScrollableOverlay } from '@/components/ui/ScrollableOverlay';
@@ -66,8 +65,6 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
 }, ref) => {
   const { t } = useI18n();
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
-  const sessionMessages = useSessionMessages(currentSessionId ?? '');
-  const hasMessagesInCurrentSession = sessionMessages.length > 0;
   const hasSession = Boolean(currentSessionId);
   const hasNewSessionDraft = useSessionUIStore((state) => Boolean(state.newSessionDraft?.open));
   const canStartSessionCommand = hasSession || hasNewSessionDraft;
@@ -140,7 +137,7 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
         }));
 
         const builtInCommands: CommandInfo[] = [
-          ...(hasSession && !hasMessagesInCurrentSession
+          ...(hasSession
             ? [{ id: 'openchamber:init', name: 'init', source: 'openchamber' as const, description: t('chat.commandAutocomplete.command.initDescription'), isBuiltIn: true }]
             : []
           ),
@@ -200,10 +197,9 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
         ];
         const allCommands = mergeCommandAutocompleteItems(builtInCommands, customCommands, skillCommands);
 
-        const allowInitCommand = !hasMessagesInCurrentSession;
-        const filtered = (searchQuery
+        const filtered = searchQuery
           ? allCommands.filter(cmd => commandMatchesSearch(cmd, searchQuery))
-          : allCommands).filter(cmd => allowInitCommand || cmd.name !== 'init');
+          : allCommands;
 
         filtered.sort((a, b) => {
           const aStartsWith = a.name.toLowerCase().startsWith(searchQuery.toLowerCase());
@@ -216,9 +212,8 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
         setCommands(filtered);
       } catch {
 
-        const allowInitCommand = !hasMessagesInCurrentSession;
         const builtInCommands: CommandInfo[] = [
-          ...(hasSession && !hasMessagesInCurrentSession
+          ...(hasSession
             ? [{ id: 'openchamber:init', name: 'init', source: 'openchamber' as const, description: t('chat.commandAutocomplete.command.initDescription'), isBuiltIn: true }]
             : []
           ),
@@ -277,12 +272,12 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
           ),
         ];
 
-        const filtered = (searchQuery
+        const filtered = searchQuery
           ? builtInCommands.filter(cmd =>
               fuzzyMatch(cmd.name, searchQuery) ||
               (cmd.description && fuzzyMatch(cmd.description, searchQuery))
             )
-          : builtInCommands).filter(cmd => allowInitCommand || cmd.name !== 'init');
+          : builtInCommands;
 
         setCommands(filtered);
       } finally {
@@ -291,7 +286,7 @@ export const CommandAutocomplete = React.forwardRef<CommandAutocompleteHandle, C
     };
 
     loadCommands();
-  }, [searchQuery, hasMessagesInCurrentSession, hasSession, canStartSessionCommand, canUseReviewHandoffFlow, commandsWithMetadata, skills, t]);
+  }, [searchQuery, hasSession, canStartSessionCommand, canUseReviewHandoffFlow, commandsWithMetadata, skills, t]);
 
   React.useEffect(() => {
     setSelectedIndex(0);

packages/ui/src/components/chat/MarkdownRenderer.tsx

@@ -47,8 +47,12 @@ export const MarkdownRenderer: React.FC<React.ComponentPropsWithoutRef<typeof Ma
   </React.Suspense>
 );
 
-export const SimpleMarkdownRenderer: React.FC<React.ComponentPropsWithoutRef<typeof SimpleMarkdownRendererLazy>> = (props) => (
-  <React.Suspense fallback={<MobileMarkdownFallback {...props} />}>
+type SimpleMarkdownRendererProps = React.ComponentPropsWithoutRef<typeof SimpleMarkdownRendererLazy> & {
+  fallbackContent?: React.ReactNode;
+};
+
+export const SimpleMarkdownRenderer: React.FC<SimpleMarkdownRendererProps> = ({ fallbackContent, ...props }) => (
+  <React.Suspense fallback={fallbackContent ?? <MobileMarkdownFallback {...props} />}>
     <SimpleMarkdownRendererLazy {...props} />
   </React.Suspense>
 );

packages/ui/src/components/chat/ModelControls.tsx

@@ -2283,7 +2283,12 @@ export const ModelControls: React.FC<ModelControlsProps> = ({
                 : 'Default';
 
             return (
-                <span className={cn('typography-micro whitespace-nowrap', wasAdjusted ? 'text-foreground' : 'text-muted-foreground')}>
+                <span className={cn(
+                    'typography-micro whitespace-nowrap',
+                    isHighlighted
+                        ? (wasAdjusted ? 'text-interactive-selection-foreground' : 'text-interactive-selection-foreground/70')
+                        : (wasAdjusted ? 'text-foreground' : 'text-muted-foreground'),
+                )}>
                     Thinking: {displayLabel}
                 </span>
             );

packages/ui/src/components/chat/QuestionCard.tsx

@@ -15,6 +15,7 @@ import * as sessionActions from '@/sync/session-actions';
 import { useI18n } from '@/lib/i18n';
 import { serializeQuestionAsJson, serializeQuestionAsMarkdown } from './questionSerializers';
 import { QUESTION_CUSTOM_TEXTAREA_MIN_HEIGHT, getQuestionCustomTextareaHeight } from './questionTextareaSizing';
+import { QuestionMarkdown } from './QuestionMarkdown';
 
 interface QuestionCardProps {
   question: QuestionRequest;
@@ -423,7 +424,11 @@ export const QuestionCard: React.FC<QuestionCardProps> = ({ question }) => {
               </div>
             ) : activeQuestion ? (
               <>
-                <div className="typography-meta font-medium text-foreground mb-1.5">{activeQuestion.question}</div>
+                <QuestionMarkdown
+                  content={activeQuestion.question}
+                  size="meta"
+                  className="font-medium text-foreground mb-1.5"
+                />
 
                 {isMultiple ? (
                   <div className="typography-micro text-muted-foreground mb-1.5">{t('chat.questionCard.selectMultiple')}</div>

packages/ui/src/components/chat/QuestionMarkdown.test.tsx

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'bun:test';
+import { renderToStaticMarkup } from 'react-dom/server';
+
+import { QuestionMarkdown } from './QuestionMarkdown';
+
+// The markdown renderer is lazy, so a synchronous server render always emits the
+// Suspense fallback QuestionMarkdown supplies. That fallback is the surface that
+// has to keep the exact question text and the question typography classes.
+describe('QuestionMarkdown', () => {
+  test('renders the question content verbatim', () => {
+    const content = 'Choose **one** from `mode`: [details](https://example.com)';
+
+    const html = renderToStaticMarkup(<QuestionMarkdown content={content} size="meta" />);
+
+    expect(html).toBe(
+      `<div class="question-markdown typography-meta whitespace-pre-wrap">${content}</div>`,
+    );
+  });
+
+  test('applies meta typography and caller classes', () => {
+    const html = renderToStaticMarkup(
+      <QuestionMarkdown content="Meta" size="meta" className="font-medium text-foreground" />,
+    );
+
+    expect(html).toContain('class="question-markdown typography-meta font-medium text-foreground whitespace-pre-wrap"');
+  });
+
+  test('applies micro typography and caller classes', () => {
+    const html = renderToStaticMarkup(
+      <QuestionMarkdown content="Micro" size="micro" className="text-muted-foreground" />,
+    );
+
+    expect(html).toContain('class="question-markdown typography-micro text-muted-foreground whitespace-pre-wrap"');
+  });
+});

packages/ui/src/components/chat/QuestionMarkdown.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+
+import { cn } from '@/lib/utils';
+import { SimpleMarkdownRenderer } from './MarkdownRenderer';
+
+interface QuestionMarkdownProps {
+  content: string;
+  size: 'meta' | 'micro';
+  className?: string;
+}
+
+export function QuestionMarkdown({ content, size, className }: QuestionMarkdownProps) {
+  const classes = cn('question-markdown', size === 'meta' ? 'typography-meta' : 'typography-micro', className);
+
+  return (
+    <SimpleMarkdownRenderer
+      content={content}
+      variant="tool"
+      className={classes}
+      fallbackContent={<div className={cn(classes, 'whitespace-pre-wrap')}>{content}</div>}
+    />
+  );
+}

packages/ui/src/components/chat/btw/useBtwPanelState.ts

@@ -5,6 +5,8 @@ import { getBtwBoundaryMessageID, getBtwSessionID } from '@/lib/sessionBtwMetada
 import { useBtwStore } from '@/stores/useBtwStore';
 
 export type BtwPanelState = {
+  /** The session the composer is in — the one `/btw` would fork. */
+  parentSession: Session | null;
   /** The active fork for this parent, or null when no panel should exist. */
   btwSessionId: string | null;
   btwSession: Session | null;
@@ -40,6 +42,7 @@ export function useBtwPanelState(
   const destroying = Boolean(uiState?.destroying);
   const btwSessionId = btwSession && !destroying ? linkedBtwSessionId : null;
   return {
+    parentSession: parentSession ?? null,
     btwSessionId,
     btwSession: btwSessionId ? btwSession : null,
     // SAFETY: the SDK Session type omits the server's `directory` field; this

packages/ui/src/components/chat/composer/DOCUMENTATION.md

@@ -60,6 +60,15 @@ copy.
 exactly what gets sent, so nothing downstream serializes a rich document model
 back into a prompt.
 
+The document is not, however, the string it was given: CodeMirror normalizes
+line endings, so a `\r\n` pair becomes one break and the document ends up
+shorter than the inserted string. **Never derive a caret position from the
+length of text you are inserting** — a caret past the end makes `dispatch`
+throw, the transaction never applies, and the un-normalized text stays in React
+state to crash again on the next restore. Every edit that moves the caret goes
+through `replaceWithCaret` (`editor/documentEdits.ts`), which measures the
+change instead of the string.
+
 The composer previously painted a transparent `<textarea>` over a mirror
 `<div>`. That restricted highlighting to styles which do not change glyph
 advance width — colour, background, underline — because anything else made the
@@ -112,6 +121,14 @@ token: themes define `--interactive-selection` with its own alpha, so mixing it
 with transparent again is nearly invisible. The iOS system overlay owns its
 visible selection fill.
 
+The content element keeps the existing correction policy: on in the mobile UI,
+off elsewhere. CodeMirror also reads the attribute and reverts Apple and
+Android's insert-period-on-double-space only when its value is exactly `off`.
+`editor/autocorrect.ts` uses the HTML standard's
+[ASCII case-insensitive `autocorrect` keywords](https://html.spec.whatwg.org/multipage/interaction.html#attr-autocorrect)
+to keep desktop word correction off while avoiding that CodeMirror-only
+revert. Its platform checks deliberately match CodeMirror's own browser flags.
+
 `composerLanguage.ts` retokenizes the whole document on every change. The
 composer holds a prompt, not a source file: it is short enough that a full pass
 is cheaper and far simpler than incremental mapping, and it keeps the editor

packages/ui/src/components/chat/composer/__tests__/text.test.ts

@@ -4,6 +4,7 @@ import {
     appendInlineText,
     appendWithLineBreaks,
     buildImagePasteInsertion,
+    getMarkdownAutoPairEdit,
     shouldWrapSelectionAsLink,
     withInlineInsertionBoundaries,
 } from '../text';
@@ -119,3 +120,39 @@ describe('shouldWrapSelectionAsLink', () => {
         expect(shouldWrapSelectionAsLink('https://x.dev', '[docs](https://y.dev)')).toBe(false);
     });
 });
+
+describe('getMarkdownAutoPairEdit', () => {
+    test('completes a fenced block with the caret on the middle line', () => {
+        expect(getMarkdownAutoPairEdit('``', '`', 2, 2)).toEqual({
+            from: 2,
+            to: 2,
+            insert: '`\n\n```',
+            selectionStart: 4,
+            selectionEnd: 4,
+        });
+    });
+
+    test('completes a fence at the start of any line', () => {
+        expect(getMarkdownAutoPairEdit('intro\n``tail', '`', 8, 8)).toEqual({
+            from: 8,
+            to: 8,
+            insert: '`\n\n```',
+            selectionStart: 10,
+            selectionEnd: 10,
+        });
+    });
+
+    test('does not complete two backticks in the middle of a line', () => {
+        expect(getMarkdownAutoPairEdit('text ``', '`', 7, 7)).toBeNull();
+    });
+
+    test('wraps selected text and keeps the text selected', () => {
+        expect(getMarkdownAutoPairEdit('hello', '*', 1, 4)).toEqual({
+            from: 1,
+            to: 4,
+            insert: '*ell*',
+            selectionStart: 2,
+            selectionEnd: 5,
+        });
+    });
+});

packages/ui/src/components/chat/composer/editor/ComposerEditor.tsx

@@ -34,7 +34,9 @@ import {
 
 import { cn } from '@/lib/utils';
 import type { ComposerLanguageContext } from '../language/tokenize';
+import type { ComposerAutoCorrect } from './autocorrect';
 import { composerLanguage, setLanguageContext } from './composerLanguage';
+import { replaceWithCaret } from './documentEdits';
 import type { ComposerEditorViewStore } from './viewStore';
 import { composerEditorTheme, composerSelectionExtension } from './theme';
 import { handleComposerHostMouseDown } from './hostMouseDown';
@@ -63,8 +65,8 @@ export interface ComposerEditorHandle {
     selectAll(): void;
     /** Replace the current selection, leaving the caret after the insertion. */
     insertText(text: string): void;
-    /** Replace an explicit range; the caret lands at `caret` or after the text. */
-    replaceRange(from: number, to: number, text: string, caret?: number): void;
+    /** Replace a range; selection defaults to a caret after the inserted text. */
+    replaceRange(from: number, to: number, text: string, selectionStart?: number, selectionEnd?: number): void;
     /** Viewport coordinates of the caret, for positioning popups. */
     caretCoords(position?: number): { top: number; bottom: number; left: number } | null;
     /** The scrollable element, for measuring and scroll compensation. */
@@ -89,8 +91,11 @@ export interface ComposerEditorProps {
     placeholder?: string;
     editable?: boolean;
     spellCheck?: boolean;
-    /** Mobile keyboards; ignored on desktop. */
-    autoCorrect?: boolean;
+    /**
+     * The content element's autocorrect keyword. See `autocorrect.ts` for the
+     * case-sensitive CodeMirror workaround.
+     */
+    autoCorrect?: ComposerAutoCorrect;
     autoCapitalize?: 'none' | 'sentences';
     /** Fill the available height instead of growing with the content. */
     fillContainer?: boolean;
@@ -157,7 +162,7 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
             placeholder,
             editable = true,
             spellCheck = false,
-            autoCorrect = false,
+            autoCorrect = 'off',
             autoCapitalize = 'none',
             fillContainer = false,
             maxLines = 8,
@@ -287,7 +292,7 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
                         }),
                         EditorView.contentAttributes.of({
                             spellcheck: String(handlersRef.current.spellCheck ?? false),
-                            autocorrect: handlersRef.current.autoCorrect ? 'on' : 'off',
+                            autocorrect: handlersRef.current.autoCorrect ?? 'off',
                             autocapitalize: handlersRef.current.autoCapitalize ?? 'none',
                             ...(handlersRef.current['aria-label']
                                 ? { 'aria-label': handlersRef.current['aria-label'] }
@@ -347,17 +352,14 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
             // A stale value echo can differ from CodeMirror's newer document,
             // and replacing it would interrupt the IME session and move the caret.
             if (view.compositionStarted) return;
-            view.dispatch({
-                changes: { from: 0, to: current.length, insert: value },
-                // An external rewrite (draft restore, history navigation,
-                // "add to chat", dictation insert) lands the caret at the END,
-                // matching what a plain textarea did when its value was
-                // replaced. Every rewrite that reaches here appends or
-                // replaces wholesale; keeping the old caret instead left it
-                // stranded before the inserted text, and the next insertion
-                // or keystroke landed inside the previous one.
-                selection: { anchor: value.length },
-            });
+            // An external rewrite (draft restore, history navigation,
+            // "add to chat", dictation insert) lands the caret at the END,
+            // matching what a plain textarea did when its value was replaced.
+            // Every rewrite that reaches here appends or replaces wholesale;
+            // keeping the old caret instead left it stranded before the
+            // inserted text, and the next insertion or keystroke landed inside
+            // the previous one.
+            view.dispatch(replaceWithCaret(view.state, 0, current.length, value));
             // A large insert can push the caret below the fold, and a
             // transaction-time `scrollIntoView` cannot reach it: wrapped-line
             // heights are still estimates during the update, and the
@@ -454,7 +456,7 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
             if (!view) return;
             const content = view.contentDOM;
             content.setAttribute('spellcheck', String(spellCheck));
-            content.setAttribute('autocorrect', autoCorrect ? 'on' : 'off');
+            content.setAttribute('autocorrect', autoCorrect);
             content.setAttribute('autocapitalize', autoCapitalize);
         }, [autoCapitalize, autoCorrect, spellCheck]);
 
@@ -511,17 +513,18 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
                 if (!view || !text) return;
                 const { from, to } = view.state.selection.main;
                 view.dispatch({
-                    changes: { from, to, insert: text },
-                    selection: { anchor: from + text.length },
+                    ...replaceWithCaret(view.state, from, to, text),
                     userEvent: 'input.type',
                 });
             },
-            replaceRange(from, to, text, caret) {
+            replaceRange(from, to, text, selectionStart, selectionEnd = selectionStart) {
                 const view = viewRef.current;
                 if (!view) return;
+                const caret = selectionStart === undefined
+                    ? undefined
+                    : { anchor: selectionStart, head: selectionEnd ?? selectionStart };
                 view.dispatch({
-                    changes: { from, to, insert: text },
-                    selection: { anchor: caret ?? from + text.length },
+                    ...replaceWithCaret(view.state, from, to, text, caret),
                     userEvent: 'input.type',
                 });
             },

packages/ui/src/components/chat/composer/editor/__tests__/autocorrect.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { composerAutoCorrect, type ComposerAutoCorrect } from '../autocorrect';
+
+const platform = (overrides: Partial<Navigator>): Navigator => ({
+    maxTouchPoints: 0,
+    platform: '',
+    userAgent: '',
+    vendor: '',
+    ...overrides,
+} as Navigator);
+
+const codeMirrorKeepsDoubleSpacePeriod = (
+    autoCorrect: ComposerAutoCorrect,
+): boolean => autoCorrect !== 'off';
+
+const affectedPlatforms: Array<[string, Navigator]> = [
+    ['macOS', platform({ platform: 'MacIntel' })],
+    ['iPhone', platform({
+        platform: 'iPhone',
+        userAgent: 'Mozilla/5.0 Mobile/15E148 Safari/604.1',
+        vendor: 'Apple Computer, Inc.',
+    })],
+    ['iPadOS touch detection', platform({
+        maxTouchPoints: 5,
+        userAgent: 'Mozilla/5.0 Version/17.4 Safari/605.1.15',
+        vendor: 'Apple Computer, Inc.',
+    })],
+    ['Android', platform({
+        platform: 'Linux armv8l',
+        userAgent: 'Mozilla/5.0 (Linux; Android 14; Pixel 8)',
+    })],
+];
+
+const unaffectedPlatforms: Array<[string, Navigator]> = [
+    ['Windows', platform({ platform: 'Win32' })],
+    ['Linux', platform({ platform: 'Linux x86_64' })],
+];
+
+describe('composerAutoCorrect', () => {
+    test('matches the pinned CodeMirror period-revert guard', () => {
+        const source = readFileSync(
+            fileURLToPath(import.meta.resolve('@codemirror/view')),
+            'utf8',
+        );
+        const semantics = source
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace(/\s+/g, '');
+
+        expect(/getAttribute\(["']autocorrect["']\)==["']off["']/.test(semantics)).toBe(true);
+        expect(semantics).toContain(
+            'constios=safari&&(/Mobile\\/\\w+/.test(nav.userAgent)||nav.maxTouchPoints>2)',
+        );
+        expect(semantics).toContain('mac:ios||/Mac/.test(nav.platform)');
+        expect(semantics).toContain('android:/Android\\b/.test(nav.userAgent)');
+    });
+
+    for (const [name, navigator] of affectedPlatforms) {
+        test(`preserves the ${name} platform period without enabling autocorrect`, () => {
+            const autoCorrect = composerAutoCorrect({ isMobile: false, navigator });
+
+            expect(autoCorrect.toLowerCase()).toBe('off');
+            // @codemirror/view 6.39.13 reverts the native period only for exact "off".
+            expect(codeMirrorKeepsDoubleSpacePeriod(autoCorrect)).toBe(true);
+        });
+    }
+
+    for (const [name, navigator] of unaffectedPlatforms) {
+        test(`leaves desktop correction off on ${name}`, () => {
+            expect(composerAutoCorrect({ isMobile: false, navigator })).toBe('off');
+        });
+    }
+
+    test('uses CodeMirror platform detection rather than a macOS user agent', () => {
+        expect(composerAutoCorrect({
+            isMobile: false,
+            navigator: platform({
+                platform: 'Linux x86_64',
+                userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)',
+            }),
+        })).toBe('off');
+    });
+
+    test('preserves the existing mobile autocorrect policy', () => {
+        expect(composerAutoCorrect({
+            isMobile: true,
+            navigator: platform({ platform: 'Win32' }),
+        })).toBe('on');
+    });
+});

packages/ui/src/components/chat/composer/editor/__tests__/documentEdits.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test';
+import { EditorState } from '@codemirror/state';
+
+import { replaceWithCaret } from '../documentEdits';
+
+const apply = (doc: string, from: number, to: number, insert: string, caret?: { anchor: number; head: number }) => {
+    const state = EditorState.create({ doc });
+    const next = state.update(replaceWithCaret(state, from, to, insert, caret)).state;
+    return { text: next.doc.toString(), selection: next.selection.main };
+};
+
+describe('replaceWithCaret', () => {
+    test('puts the caret at the end of a wholesale replacement', () => {
+        const { text, selection } = apply('old', 0, 3, 'a new draft');
+
+        expect(text).toBe('a new draft');
+        expect(selection.anchor).toBe(11);
+        expect(selection.head).toBe(11);
+    });
+
+    // Issue #3013: CodeMirror collapses `\r\n` into one line break, so a caret
+    // taken from the JS string length falls outside the document and dispatch
+    // throws `RangeError: Selection points outside of document`.
+    test('keeps the caret inside the document when CRLF is normalized away', () => {
+        const { text, selection } = apply('a', 0, 1, 'x\r\ny');
+
+        expect(text).toBe('x\ny');
+        expect(selection.anchor).toBe(3);
+    });
+
+    test('survives a draft made only of CRLF breaks', () => {
+        const { text, selection } = apply('a', 0, 1, '\r\n\r\n\r\n');
+
+        expect(text).toBe('\n\n\n');
+        expect(selection.anchor).toBe(3);
+    });
+
+    test('places the caret after text inserted at the selection', () => {
+        const { text, selection } = apply('hello world', 5, 5, ',\r\n there');
+
+        expect(text).toBe('hello,\n there world');
+        expect(selection.anchor).toBe(13);
+    });
+
+    test('honours an explicit caret', () => {
+        const { selection } = apply('hello', 0, 5, 'goodbye', { anchor: 2, head: 4 });
+
+        expect(selection.anchor).toBe(2);
+        expect(selection.head).toBe(4);
+    });
+
+    test('clamps an explicit caret that the normalized document cannot hold', () => {
+        const { text, selection } = apply('a', 0, 1, 'x\r\ny', { anchor: 4, head: 4 });
+
+        expect(text).toBe('x\ny');
+        expect(selection.anchor).toBe(3);
+    });
+});

packages/ui/src/components/chat/composer/editor/__tests__/writebackCompositionGuard.test.ts

@@ -19,7 +19,7 @@ describe('composer value writeback composition guard (issue #2527)', () => {
         const effect = writebackEffect();
         const equalityCheck = effect.indexOf('if (current === value) return;');
         const compositionGuard = effect.indexOf('if (view.compositionStarted) return;');
-        const dispatch = effect.indexOf('view.dispatch({');
+        const dispatch = effect.indexOf('view.dispatch(');
 
         expect(equalityCheck).toBeGreaterThan(-1);
         expect(compositionGuard).toBeGreaterThan(equalityCheck);

packages/ui/src/components/chat/composer/editor/autocorrect.ts

@@ -0,0 +1,24 @@
+export type ComposerAutoCorrect = 'on' | 'off' | 'Off';
+
+type PlatformNavigator = Pick<Navigator,
+    'maxTouchPoints' | 'platform' | 'userAgent' | 'vendor'
+>;
+
+/** Keep desktop autocorrect off without triggering CodeMirror's period revert. */
+export function composerAutoCorrect(options: {
+    isMobile: boolean;
+    navigator?: PlatformNavigator;
+}): ComposerAutoCorrect {
+    if (options.isMobile) return 'on';
+
+    const nav = options.navigator
+        ?? (typeof navigator === 'undefined'
+            ? { maxTouchPoints: 0, platform: '', userAgent: '', vendor: '' }
+            : navigator);
+    // These must match CodeMirror's flags because its revert checks exact "off".
+    const ios = /Apple Computer/.test(nav.vendor)
+        && (/Mobile\/\w+/.test(nav.userAgent) || nav.maxTouchPoints > 2);
+    return ios || /Mac/.test(nav.platform) || /Android\b/.test(nav.userAgent)
+        ? 'Off'
+        : 'off';
+}

packages/ui/src/components/chat/composer/editor/documentEdits.ts

@@ -0,0 +1,33 @@
+import type { EditorState, TransactionSpec } from '@codemirror/state';
+
+/**
+ * Replace a document range and leave the caret inside the resulting document.
+ *
+ * CodeMirror normalizes line endings on the way in: a `\r\n` pair becomes one
+ * line break, so the inserted string is longer than the text it produces. A
+ * caret derived from the JavaScript string therefore lands past the end of the
+ * document and `dispatch` throws `RangeError: Selection points outside of
+ * document`. The transaction never applies, so the un-normalized text stays in
+ * React state, gets persisted as a draft, and crashes the chat again on every
+ * restore (issue #3013).
+ *
+ * Deriving the caret from the change set instead keeps it correct for whatever
+ * CodeMirror actually inserted, without this module having to know the
+ * normalization rules.
+ */
+export const replaceWithCaret = (
+    state: EditorState,
+    from: number,
+    to: number,
+    insert: string,
+    caret?: { anchor: number; head: number },
+): TransactionSpec => {
+    const changes = state.changes({ from, to, insert });
+    const clamp = (position: number): number => Math.min(Math.max(position, 0), changes.newLength);
+    // What CodeMirror inserted, measured on the document rather than on the
+    // string: the new length minus everything the change left untouched.
+    const insertedLength = changes.newLength - (state.doc.length - (to - from));
+    const anchor = caret ? clamp(caret.anchor) : from + insertedLength;
+    const head = caret ? clamp(caret.head) : anchor;
+    return { changes, selection: { anchor, head } };
+};

packages/ui/src/components/chat/composer/editor/theme.ts

@@ -20,6 +20,8 @@ export const COMPOSER_EDITOR_THEME_SPEC = {
     '&.cm-focused': { outline: 'none' },
     '.cm-content': {
         padding: '0',
+        // Keep the drawn empty-document cursor inside the scroller's horizontal clip.
+        paddingInlineStart: '1px',
         fontFamily: 'inherit',
         fontSize: 'inherit',
         lineHeight: 'inherit',

packages/ui/src/components/chat/composer/text.ts

@@ -104,3 +104,61 @@ export function shouldWrapSelectionAsLink(url: string, selected: string): boolea
         && selected.trim().length > 0
         && !selected.includes('](');
 }
+
+const MARKDOWN_WRAP_PAIRS: Record<string, [string, string]> = {
+    '`': ['`', '`'],
+    '*': ['*', '*'],
+    '_': ['_', '_'],
+    '~': ['~', '~'],
+    '(': ['(', ')'],
+    '[': ['[', ']'],
+    '{': ['{', '}'],
+    '"': ['"', '"'],
+    "'": ["'", "'"],
+};
+
+/**
+ * Markdown source-mode conveniences handled before CodeMirror inserts a key.
+ * The returned text change and selection belong to one editor transaction so
+ * the caret cannot be applied against the previous document.
+ */
+export function getMarkdownAutoPairEdit(
+    value: string,
+    key: string,
+    selectionStart: number,
+    selectionEnd: number,
+): {
+    from: number;
+    to: number;
+    insert: string;
+    selectionStart: number;
+    selectionEnd: number;
+} | null {
+    const pair = MARKDOWN_WRAP_PAIRS[key];
+    if (selectionEnd > selectionStart && pair) {
+        const selected = value.slice(selectionStart, selectionEnd);
+        const [open, close] = pair;
+        return {
+            from: selectionStart,
+            to: selectionEnd,
+            insert: `${open}${selected}${close}`,
+            selectionStart: selectionStart + open.length,
+            selectionEnd: selectionEnd + open.length,
+        };
+    }
+
+    if (key === '`' && selectionStart === selectionEnd) {
+        const before = value.slice(0, selectionStart);
+        if (/(^|\n)``$/.test(before)) {
+            return {
+                from: selectionStart,
+                to: selectionEnd,
+                insert: '`\n\n```',
+                selectionStart: selectionStart + 2,
+                selectionEnd: selectionStart + 2,
+            };
+        }
+    }
+
+    return null;
+}

packages/ui/src/components/chat/composerHighlight.ts

@@ -103,7 +103,7 @@ const STYLE_CLASS: Record<AnyStyle, string> = {
     mentionAgent: 'text-[var(--status-success)]',
     mentionCommand: 'text-[var(--primary)]',
     mentionSnippet: 'text-[var(--status-warning)]',
-    code: 'rounded-[3px] bg-[var(--surface-subtle)] text-[var(--markdown-inline-code)]',
+    code: 'rounded-[6px] bg-[var(--markdown-inline-code-bg)] text-[var(--markdown-inline-code)]',
     codeFence: 'bg-[var(--surface-subtle)] text-[var(--markdown-inline-code)]',
     // A `~path` is written for the reader's benefit, not to attach anything —
     // it takes the same colour as a file mention, since it names the same kind

packages/ui/src/components/chat/lib/scroll/timelineScrollIntent.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from 'bun:test';
+
+import { isFollowReleaseKey, isMiddleButtonPan, nestedScrollableConsumesWheelUp } from './timelineScrollIntent';
+
+const key = (
+    k: string,
+    modifiers: Partial<Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'>> = {},
+) => ({ key: k, altKey: false, ctrlKey: false, metaKey: false, shiftKey: false, ...modifiers });
+
+describe('isFollowReleaseKey', () => {
+    test('upward navigation keys release follow', () => {
+        for (const k of ['ArrowUp', 'PageUp', 'Home']) expect(isFollowReleaseKey(key(k))).toBe(true);
+        expect(isFollowReleaseKey(key(' ', { shiftKey: true }))).toBe(true);
+    });
+
+    test('downward keys, plain space, and modified shortcuts do not', () => {
+        for (const k of ['ArrowDown', 'PageDown', 'End', ' ', 'Pause', 'Enter']) {
+            expect(isFollowReleaseKey(key(k))).toBe(false);
+        }
+        expect(isFollowReleaseKey(key('Home', { ctrlKey: true }))).toBe(false);
+        expect(isFollowReleaseKey(key('ArrowUp', { metaKey: true }))).toBe(false);
+        expect(isFollowReleaseKey(key('ArrowUp', { altKey: true }))).toBe(false);
+    });
+});
+
+// The helpers only use Element#closest, scrollTop, and identity, so a minimal
+// DOM stand-in built on EventTarget is enough — no renderer or jsdom.
+class FakeElement extends EventTarget {
+    scrollTop = 0;
+    constructor(private readonly scrollable: boolean, private readonly parent: FakeElement | null = null) {
+        super();
+    }
+    closest(selector: string): FakeElement | null {
+        if (selector !== '[data-scrollable]') throw new Error(`unexpected selector ${selector}`);
+        if (this.scrollable) return this;
+        return this.parent?.closest(selector) ?? null;
+    }
+}
+// SAFETY: the helpers narrow with `instanceof Element` / `instanceof HTMLElement`;
+// registering the fakes under those globals keeps the narrowing honest in bun.
+const installDomGlobals = () => {
+    const previous = { Element: globalThis.Element, HTMLElement: globalThis.HTMLElement };
+    Object.assign(globalThis, { Element: FakeElement, HTMLElement: FakeElement });
+    return () => Object.assign(globalThis, previous);
+};
+// With the globals above installed, FakeElement IS the HTMLElement the helpers
+// narrow to; reading it back through the global bridges the static type without
+// asserting anything the runtime does not hold.
+const asRoot = (element: FakeElement): HTMLElement => {
+    if (!(element instanceof globalThis.HTMLElement)) throw new Error('DOM globals not installed');
+    return element;
+};
+
+describe('nested scroller handling', () => {
+    test('an upward wheel over a nested scroller with room above stays there', () => {
+        const restore = installDomGlobals();
+        try {
+            const root = new FakeElement(false);
+            const box = new FakeElement(true, root);
+            const inner = new FakeElement(false, box);
+            box.scrollTop = 40;
+            expect(nestedScrollableConsumesWheelUp(asRoot(root), inner)).toBe(true);
+            box.scrollTop = 0;
+            expect(nestedScrollableConsumesWheelUp(asRoot(root), inner)).toBe(false);
+            expect(nestedScrollableConsumesWheelUp(asRoot(root), new FakeElement(false, root))).toBe(false);
+        } finally {
+            restore();
+        }
+    });
+
+    test('a middle-button press pans the timeline unless it lands in a nested scroller', () => {
+        const restore = installDomGlobals();
+        try {
+            const root = new FakeElement(false);
+            const row = new FakeElement(false, root);
+            const box = new FakeElement(true, root);
+            expect(isMiddleButtonPan(asRoot(root), { button: 1, target: row })).toBe(true);
+            expect(isMiddleButtonPan(asRoot(root), { button: 1, target: box })).toBe(false);
+            expect(isMiddleButtonPan(asRoot(root), { button: 0, target: row })).toBe(false);
+        } finally {
+            restore();
+        }
+    });
+});

packages/ui/src/components/chat/lib/scroll/timelineScrollIntent.ts

@@ -0,0 +1,41 @@
+// Gesture classification for the chat timeline's follow opt-out.
+//
+// The timeline releases live follow on REAL upward gestures only. Wheel and
+// touch carry their direction; this module answers the same question for the
+// inputs that do not: which keys mean "scroll up", when a middle-button press
+// starts a pan, and when an upward wheel belongs to a nested scroller (a tool
+// output box) that can still consume it. Pure functions, no DOM ownership,
+// so the rules are testable without a renderer.
+
+// A nested scroller inside the timeline marks itself with this attribute
+// (see ToolPart). Wheel-up over it scrolls the box, not the conversation, for
+// as long as the box has room above.
+const NESTED_SCROLLABLE_SELECTOR = '[data-scrollable]';
+
+export const isFollowReleaseKey = (
+    event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>,
+): boolean => {
+    // Modified keys are shortcuts, not navigation.
+    if (event.altKey || event.ctrlKey || event.metaKey) return false;
+    if (event.key === ' ') return event.shiftKey;
+    return event.key === 'ArrowUp' || event.key === 'PageUp' || event.key === 'Home';
+};
+
+const nestedScrollable = (root: HTMLElement, target: EventTarget | null): HTMLElement | null => {
+    if (!(target instanceof Element)) return null;
+    const nested = target.closest(NESTED_SCROLLABLE_SELECTOR);
+    return nested instanceof HTMLElement && nested !== root ? nested : null;
+};
+
+// An upward wheel over a nested scroller that still has content above stays
+// with that scroller; the timeline must not treat it as leaving the end.
+export const nestedScrollableConsumesWheelUp = (root: HTMLElement, target: EventTarget | null): boolean => {
+    const nested = nestedScrollable(root, target);
+    return nested !== null && nested.scrollTop > 0;
+};
+
+// Middle-button press starts the platform's autoscroll pan (Windows/Linux
+// Chromium); the pan then scrolls without wheel events, so the press itself is
+// the gesture. Inside a nested scroller the pan belongs to that scroller.
+export const isMiddleButtonPan = (root: HTMLElement, event: Pick<MouseEvent, 'button' | 'target'>): boolean =>
+    event.button === 1 && nestedScrollable(root, event.target) === null;

packages/ui/src/components/chat/markdown/markdownCore.test.ts

@@ -19,6 +19,15 @@ const sanitizeHooks: {
   afterSanitizeAttributes?: (node: unknown) => void;
 } = {};
 
+// Mirrors DOMPurify's default URI policy: approved schemes plus relative URLs.
+const DOMPURIFY_ALLOWED_URI_RE =
+  // Keep this byte-aligned with DOMPurify's default IS_ALLOWED_URI expression.
+  // eslint-disable-next-line no-useless-escape
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+const URI_ATTRIBUTE_WHITESPACE_RE =
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+
 Object.assign(globalThis, {
   window: {},
   HTMLAnchorElement: TestAnchorElement,
@@ -36,7 +45,10 @@ mock.module('dompurify', () => ({
       sanitizeHooks.uponSanitizeAttribute?.(anchor, data);
       sanitizeHooks.afterSanitizeAttributes?.(anchor);
 
-      return data.forceKeepAttr || /^(?:https?|mailto|tel):/i.test(href) ? attribute : '';
+      const normalizedHref = href.replace(URI_ATTRIBUTE_WHITESPACE_RE, '');
+      return data.forceKeepAttr || DOMPURIFY_ALLOWED_URI_RE.test(normalizedHref)
+        ? attribute
+        : '';
     }),
   },
 }));
@@ -279,3 +291,30 @@ describe('Markdown images', () => {
     expect(html).not.toContain('data-openchamber-markdown-image');
   });
 });
+
+describe('CJK-aware link parsing', () => {
+  const hrefOf = (html: string): string | null => /<a\b[^>]*href="([^"]*)"/.exec(html)?.[1] ?? null;
+
+  test('bare URL followed by a CJK annotation trims the annotation from the href', () => {
+    const html = renderMarkdownSync('访问 https://example.com/docs（中文说明）了解更多');
+    expect(hrefOf(html)).toBe('https://example.com/docs');
+  });
+
+  test('bare URL followed by CJK punctuation trims the punctuation', () => {
+    expect(hrefOf(renderMarkdownSync('地址 https://example.com/guide，详见'))).toBe(
+      'https://example.com/guide',
+    );
+    expect(hrefOf(renderMarkdownSync('官网 https://example.com。'))).toBe('https://example.com');
+  });
+
+  test('correct links are unaffected', () => {
+    expect(hrefOf(renderMarkdownSync('官方文档见 [这里](https://docs.example.com)（中文说明）'))).toBe(
+      'https://docs.example.com',
+    );
+    expect(hrefOf(renderMarkdownSync('[下载](https://dl.example.com/安装包（正式版）)'))).toBe(
+      'https://dl.example.com/安装包（正式版）',
+    );
+    expect(hrefOf(renderMarkdownSync('[a](url(1))'))).toBe('url(1)');
+    expect(hrefOf(renderMarkdownSync('[a](url "title")'))).toBe('url');
+  });
+});

packages/ui/src/components/chat/markdown/markdownCore.ts

@@ -1,4 +1,5 @@
 import { Marked, marked, type Tokens } from 'marked';
+import markedLinkifyIt from 'marked-linkify-it';
 import remend from 'remend';
 import katex from 'katex';
 import DOMPurify from 'dompurify';
@@ -331,10 +332,15 @@ const blockMathExtension = {
   },
 };
 
-const createParser = (imageMode: MarkdownImageMode) => new Marked().use({
-  gfm: true,
-  breaks: false,
-  extensions: [inlineMathExtension, blockMathExtension],
+// marked's GFM autolink swallows CJK punctuation after a bare URL, so switch
+// to marked-linkify-it, which treats Unicode punctuation as a URL boundary.
+// Plain CJK characters right after a URL are still consumed, matching GitHub.
+const createParser = (imageMode: MarkdownImageMode) => new Marked().use(
+  markedLinkifyIt({ fuzzyLink: false }),
+  {
+    gfm: true,
+    breaks: false,
+    extensions: [inlineMathExtension, blockMathExtension],
   renderer: {
     // Assistant output is untrusted. Markdown constructs still render as HTML,
     // but raw HTML must remain visible text so it cannot introduce active DOM

packages/ui/src/components/chat/message/parts/ToolPart.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'bun:test';
 
 import { getStreamingOutputAppend, getToolOutput, renderTerminalOutput } from './toolOutput';
 import { readTaskTagSessionIdFromOutput } from './taskSessionIdParser';
-import { tryParseJsonOutput } from '../toolRenderers';
+import { parseDiffToUnified, tryParseJsonOutput } from '../toolRenderers';
 import { getStreamingThrottleText } from '../../hooks/useStreamingTextThrottle';
 import { getToolDescriptionFallback } from './toolRenderUtils';
 
@@ -42,6 +42,29 @@ describe('getToolOutput', () => {
     });
 });
 
+describe('parseDiffToUnified', () => {
+    test('handles a streamed diff with a bare Index header', () => {
+        expect(parseDiffToUnified('Index:')).toEqual([]);
+        expect(parseDiffToUnified('Index:\n@@ -1,1 +1,1 @@\n-old\n+new')).toEqual([
+            {
+                file: 'file',
+                oldStart: 1,
+                newStart: 1,
+                lines: [
+                    { type: 'removed', lineNumber: 1, content: 'old' },
+                    { type: 'added', lineNumber: 1, content: 'new' },
+                ],
+            },
+        ]);
+    });
+
+    test('preserves spaces when extracting the indexed filename', () => {
+        const [hunk] = parseDiffToUnified('Index: src/my file.ts\n@@ -1,1 +1,1 @@\n-old\n+new');
+
+        expect(hunk?.file).toBe('my file.ts');
+    });
+});
+
 describe('renderTerminalOutput', () => {
     test('renders carriage-return progress updates as their latest value', () => {
         expect(renderTerminalOutput('Downloading 10%\r\u001B[2KDownloading 90%')).toBe('Downloading 90%');

packages/ui/src/components/chat/message/parts/ToolPart.tsx

@@ -4,6 +4,7 @@ import { useMobileAppActions } from '@/apps/mobileAppContext';
 import { RuntimeAPIContext } from '@/contexts/runtimeAPIContext';
 import { cn } from '@/lib/utils';
 import { SimpleMarkdownRenderer } from '../../MarkdownRenderer';
+import { QuestionMarkdown } from '../../QuestionMarkdown';
 import { MessageFilesDisplay } from '../../FileAttachment';
 import { getToolMetadata } from '@/lib/toolHelpers';
 import type { ToolPart as ToolPartType, ToolState as ToolStateUnion, FilePart } from '@opencode-ai/sdk/v2';
@@ -31,6 +32,7 @@ import {
     renderTodoOutput,
     tryParseJsonOutput,
     coerceToText,
+    capToolOutputText,
 } from '../toolRenderers';
 import { JsonTreeViewer } from '@/components/ui/JsonTreeViewer';
 import { JsonSummaryView } from './JsonSummaryView';
@@ -44,9 +46,9 @@ import {
     buildTaskSummaryEntriesFromSession,
     normalizeTaskSummaryEntries,
     parseTaskMetadataBlock,
+    prepareTaskToolOutput,
     readTaskSessionIdFromOutput,
     readTaskSessionIdFromRecord,
-    stripTaskMetadataFromOutput,
     type TaskToolSummaryEntry,
 } from './taskToolModel';
 import { areRenderRelevantPartsEqual } from '../renderCompare';
@@ -605,11 +607,15 @@ const getToolOutputText = (
     part: ToolPartType,
     metadata: Record<string, unknown> | undefined,
 ): string => {
+    // Cap oversized payloads before JSON.parse / syntax highlighting / DOM work
+    // so a single huge tool output can't trigger a V8 Zone-allocation OOM that
+    // hard-crashes the renderer (issue #2265).
+    const capped = capToolOutputText(output);
     if (part.tool === 'bash') {
-        return output;
+        return capped;
     }
 
-    return formatEditOutput(output, part.tool, metadata);
+    return formatEditOutput(capped, part.tool, metadata);
 };
 
 const StreamingPlainTextOutput: React.FC<{ output: string }> = ({ output }) => {
@@ -998,9 +1004,7 @@ const TaskToolSummary: React.FC<{
     const showToolFileIcons = useUIStore((state) => state.showToolFileIcons);
     const runtime = React.useContext(RuntimeAPIContext);
 
-    const trimmedOutput = typeof output === 'string'
-        ? stripTaskMetadataFromOutput(output)
-        : '';
+    const trimmedOutput = prepareTaskToolOutput(output);
     const hasOutput = trimmedOutput.length > 0;
     const [isOutputExpanded, setIsOutputExpanded] = React.useState(false);
 
@@ -1407,7 +1411,7 @@ const ToolExpandedContent: React.FC<ToolExpandedContentProps> = React.memo(({
                         <div className="space-y-2">
                             {parsedQA.map((qa, index) => (
                                 <div key={index} className="space-y-0.5">
-                                    <div className="typography-micro text-muted-foreground">{qa.question}</div>
+                                    <QuestionMarkdown content={qa.question} size="micro" className="text-muted-foreground" />
                                     <div className="typography-meta text-foreground whitespace-pre-wrap">{qa.answer}</div>
                                 </div>
                             ))}
@@ -1444,7 +1448,7 @@ const ToolExpandedContent: React.FC<ToolExpandedContentProps> = React.memo(({
                                 {q.header ? (
                                     <div className="typography-micro text-muted-foreground">{coerceToText(q.header)}</div>
                                 ) : null}
-                                <div className="typography-meta text-foreground">{coerceToText(q.question)}</div>
+                                <QuestionMarkdown content={coerceToText(q.question)} size="meta" className="text-foreground" />
                                 {Array.isArray(q.options) && q.options.length > 0 ? (
                                     <div className="flex flex-wrap gap-1 mt-0.5">
                                         {q.options.map((opt) => (
@@ -1965,6 +1969,7 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
         return null;
     }, [descriptionPath, normalizedPartTool, stateWithData, input]);
     const runtime = React.useContext(RuntimeAPIContext);
+    const mobileActions = useMobileAppActions();
 
     const openApplyPatchFile = (file: Record<string, unknown>, event: React.MouseEvent<HTMLButtonElement>) => {
         if (!runtime?.editor) {
@@ -2030,6 +2035,9 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
     };
 
     const handleMainKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
+        // Nested buttons (quick-open, copy) handle their own Enter/Space; the row
+        // must not swallow the key and toggle instead.
+        if (event.target !== event.currentTarget) return;
         if (event.key !== 'Enter' && event.key !== ' ') {
             return;
         }
@@ -2037,6 +2045,54 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
         handleMainClick(event);
     };
 
+    // Quick-open target for the file-link icon in the tool header. Resolves the
+    // primary file path (and, for diff tools, the first changed line + diff) so
+    // the user can open the file in the side panel (web/desktop) or editor
+    // (VS Code) without expanding the tool card. Reuses the same path helpers as
+    // handleMainClick above; the difference is the web fallback — handleMainClick
+    // only opens when runtime.editor is available, this icon also falls back to
+    // useUIStore.openContextFile{AtLine} so the file opens in the right pane.
+    const quickOpenTarget = React.useMemo<{ absolutePath: string; line?: number; toolDiff?: string; toolName: string } | null>(() => {
+        if (isTaskTool) return null;
+        const toolName = normalizedPartTool || part.tool;
+        const filePath = getPrimaryToolPath(toolName, input, metadata);
+        if (typeof filePath !== 'string') return null;
+        const absolutePath = toAbsoluteFilePath(currentDirectory, filePath);
+        let line: number | undefined;
+        let toolDiff: string | undefined;
+        if (toolName === 'edit' || toolName === 'multiedit' || toolName === 'apply_patch') {
+            line = getFirstChangedLineFromMetadata(toolName, metadata, filePath);
+            toolDiff = getPrimaryDiffFromMetadata(toolName, metadata, filePath);
+        }
+        return { absolutePath, line, toolDiff, toolName };
+    }, [isTaskTool, normalizedPartTool, part.tool, input, metadata, currentDirectory]);
+
+    const openQuickTarget = () => {
+        if (!quickOpenTarget) return;
+        const { absolutePath, line, toolDiff, toolName } = quickOpenTarget;
+        if (runtime?.editor) {
+            if (runtime.runtime.isVSCode && toolDiff && (toolName === 'edit' || toolName === 'multiedit' || toolName === 'apply_patch')) {
+                const label = `${getRelativePath(absolutePath, currentDirectory)} (changes)`;
+                void runtime.editor.openDiff('', absolutePath, label, { line, patch: toolDiff });
+                return;
+            }
+            runtime.editor.openFile(absolutePath, line);
+            return;
+        }
+        const uiStore = useUIStore.getState();
+        if (typeof line === 'number' && Number.isFinite(line)) {
+            uiStore.openContextFileAtLine(currentDirectory, absolutePath, Math.max(1, Math.trunc(line)), 1);
+        } else {
+            uiStore.openContextFile(currentDirectory, absolutePath);
+        }
+        mobileActions?.openFiles();
+    };
+
+    const handleQuickOpen = (event: React.MouseEvent<HTMLButtonElement>) => {
+        event.stopPropagation();
+        openQuickTarget();
+    };
+
     const iconStyle = !isTaskTool && isError ? TOOL_ERROR_ICON_STYLE : TOOL_NORMAL_ICON_STYLE;
     const titleStyle = !isTaskTool && isError ? TOOL_ERROR_TITLE_STYLE : TOOL_NORMAL_TITLE_STYLE;
     const shouldRenderTaskSummary = useDeferredExpandedContent(isTaskTool && (taskSummaryEntries.length > 0 || isActive || shouldTreatAsFinalized || !!taskSessionId));
@@ -2130,7 +2186,7 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
                                     {isExpanded ? <Icon name="arrow-down-s" className="h-3.5 w-3.5" /> : <Icon name="arrow-right-s" className="h-3.5 w-3.5" />}
                                 </div>
                             </div>
-                            <div className="flex items-center gap-2 min-w-0 flex-1">
+                            <div className={cn('flex items-center min-w-0 flex-1', quickOpenTarget ? 'gap-1' : 'gap-2')}>
                                 <MinDurationShineText
                                     active={Boolean(isActive && !isError)}
                                     minDurationMs={300}
@@ -2140,6 +2196,23 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
                                 >
                                     {displayName}
                                 </MinDurationShineText>
+                                {quickOpenTarget ? (
+                                    <button
+                                        type="button"
+                                        onClick={handleQuickOpen}
+                                        className={cn(
+                                            'flex-shrink-0 inline-flex h-4 w-4 items-center justify-center rounded transition-opacity hover:bg-[var(--surface-hover)]',
+                                            // Coarse pointers never hover, so the icon has to rest visible
+                                            // there or it stays invisible while remaining tappable.
+                                            'opacity-0 group-hover/tool:opacity-60 hover:opacity-100 focus-visible:opacity-100 pointer-coarse:opacity-60',
+                                        )}
+                                        style={{ color: 'var(--tools-icon)' }}
+                                        title={t('chat.toolPart.openFile')}
+                                        aria-label={t('chat.toolPart.openFile')}
+                                    >
+                                        <Icon name="external-link" className="h-3 w-3" />
+                                    </button>
+                                ) : null}
                             </div>
                             {normalizedPartTool === 'bash' && typeof effectiveTimeStart === 'number' ? (
                                 <span className={cn('flex-shrink-0 tabular-nums text-muted-foreground/80', TOOL_ROW_DESCRIPTION_CLASS)}>

packages/ui/src/components/chat/message/parts/taskToolModel.test.ts

@@ -4,9 +4,11 @@ import type { Message, Part } from '@opencode-ai/sdk/v2';
 import {
     buildTaskSummaryEntriesFromSession,
     parseTaskMetadataBlock,
+    prepareTaskToolOutput,
     readTaskSessionIdFromRecord,
     readTaskSessionIdFromOutput,
 } from './taskToolModel';
+import { TOOL_OUTPUT_MAX_CHARS } from '../toolRenderers';
 
 describe('taskToolModel', () => {
     test('reads the current OpenCode running-state identity contract', () => {
@@ -39,4 +41,19 @@ describe('taskToolModel', () => {
             state: { status: 'completed', title: undefined, input: { filePath: 'a.ts' } },
         }]);
     });
+
+    test('strips task metadata and caps oversized task output before markdown rendering', () => {
+        const oversized = 'x'.repeat(TOOL_OUTPUT_MAX_CHARS + 5_000);
+        const output = `${oversized}\n<task_metadata>{"sessionID":"child-1"}</task_metadata>`;
+        const prepared = prepareTaskToolOutput(output);
+
+        expect(prepared.length).toBeLessThan(oversized.length);
+        expect(prepared).toContain('output truncated');
+        expect(prepared).not.toContain('task_metadata');
+    });
+
+    test('leaves normal task output untouched', () => {
+        expect(prepareTaskToolOutput('done\n<task_metadata>{"sessionID":"child-1"}</task_metadata>')).toBe('done');
+        expect(prepareTaskToolOutput(undefined)).toBe('');
+    });
 });

packages/ui/src/components/chat/message/parts/taskToolModel.ts

@@ -1,5 +1,6 @@
 import type { MessageRecord } from '@/lib/messageCompletion';
 
+import { capToolOutputText } from '../toolRenderers';
 import { readTaskTagSessionIdFromOutput } from './taskSessionIdParser';
 
 export type TaskToolSummaryEntry = {
@@ -131,3 +132,12 @@ export const buildTaskSummaryEntriesFromSession = (messages: MessageRecord[]): T
 export const stripTaskMetadataFromOutput = (output: string): string => {
     return output.replace(/\n*<task_metadata>[\s\S]*?<\/task_metadata>\s*$/i, '').trimEnd();
 };
+
+// The task tool renders its output through the markdown parser instead of the
+// shared tool-output path, so it needs the same size guard as
+// `getToolOutputText` (issue #2265): an unbounded single string reaching the
+// parser can exhaust V8's Zone allocator and crash the renderer.
+export const prepareTaskToolOutput = (output: string | undefined): string => {
+    if (!output) return '';
+    return capToolOutputText(stripTaskMetadataFromOutput(output));
+};

packages/ui/src/components/chat/message/toolRenderers.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from 'bun:test';
+
+import { capToolOutputText, TOOL_OUTPUT_MAX_CHARS } from './toolRenderers';
+
+// Regression coverage for issue #2265: the desktop renderer hard-crashes with a
+// V8 "Zone Allocation failed" OOM when a tool returns oversized external content
+// (e.g. a fetched Google Slides page with full-resolution base64 images inlined),
+// because the whole payload previously flowed through JSON.parse / syntax
+// highlighting / DOM rendering as a single unbounded JS string. capToolOutputText
+// is the bounded size guard that runs before any of that work.
+describe('capToolOutputText (issue #2265 renderer OOM guard)', () => {
+    test('exposes a sane positive default cap', () => {
+        expect(typeof TOOL_OUTPUT_MAX_CHARS).toBe('number');
+        expect(TOOL_OUTPUT_MAX_CHARS).toBeGreaterThan(0);
+    });
+
+    test('returns short output unchanged', () => {
+        const output = 'hello world';
+        expect(capToolOutputText(output)).toBe(output);
+    });
+
+    test('returns output at exactly the cap unchanged', () => {
+        const output = 'a'.repeat(TOOL_OUTPUT_MAX_CHARS);
+        expect(capToolOutputText(output)).toBe(output);
+        expect(capToolOutputText(output).length).toBe(TOOL_OUTPUT_MAX_CHARS);
+    });
+
+    test('caps oversized output and never emits the full string', () => {
+        const oversized = 'x'.repeat(TOOL_OUTPUT_MAX_CHARS + 10_000);
+        const capped = capToolOutputText(oversized);
+
+        // The pathological full-size string must not survive to the renderer.
+        expect(capped.length).toBeLessThan(oversized.length);
+        // Head of the payload is preserved for the user.
+        expect(capped.startsWith('x'.repeat(1000))).toBe(true);
+        // A truncation notice is appended so the truncation is visible.
+        expect(capped).toContain('output truncated');
+        expect(capped).toContain('10000 more characters');
+    });
+
+    test('honors a custom cap', () => {
+        const output = 'abcdefghij'; // 10 chars
+        const capped = capToolOutputText(output, 4);
+        expect(capped.startsWith('abcd')).toBe(true);
+        expect(capped).toContain('output truncated');
+        // Only the first 4 chars of the original body are retained.
+        expect(capped).not.toContain('efghij');
+    });
+
+    test('simulated large webfetch payload is bounded well below original size', () => {
+        // ~6MB single string, matching the 5MB-20MB Zone-allocation trigger range
+        // described in the issue (a Slides page with embedded base64 images).
+        const base64Blob = 'QUJD'.repeat(1_500_000); // 6,000,000 chars
+        const capped = capToolOutputText(base64Blob);
+
+        expect(base64Blob.length).toBeGreaterThan(5_000_000);
+        expect(capped.length).toBeLessThan(TOOL_OUTPUT_MAX_CHARS + 256);
+        expect(capped).toContain('renderer from running out of memory');
+    });
+
+    test('non-string input is returned unchanged (defensive)', () => {
+        // @ts-expect-error verifying runtime robustness against non-string inputs
+        expect(capToolOutputText(undefined)).toBeUndefined();
+        // @ts-expect-error verifying runtime robustness against non-string inputs
+        expect(capToolOutputText(null)).toBeNull();
+    });
+});

packages/ui/src/components/chat/message/toolRenderers.tsx

@@ -22,6 +22,28 @@ export const coerceToText = (value: unknown, fallback = ''): string => {
     }
 };
 
+// Guards the renderer process against V8 "Zone Allocation failed" OOM crashes
+// (issue #2265). When a tool returns oversized external content — e.g. a fetched
+// web page with full-resolution base64 images inlined — the entire payload flows
+// through this module as a single JS string that is JSON.parsed, syntax
+// highlighted, and attached to the DOM. A large enough single string exceeds
+// V8's Zone allocator and hard-crashes the renderer before any virtualization or
+// CSS clip can help. Capping the string length before that work happens keeps a
+// useful head of the output while preventing the pathological allocation.
+export const TOOL_OUTPUT_MAX_CHARS = 512 * 1024;
+
+export const capToolOutputText = (
+    output: string,
+    maxChars: number = TOOL_OUTPUT_MAX_CHARS,
+): string => {
+    if (typeof output !== 'string' || output.length <= maxChars) {
+        return output;
+    }
+    const omitted = output.length - maxChars;
+    const notice = `\n\n… [output truncated: ${omitted} more characters not shown to prevent the renderer from running out of memory]`;
+    return output.slice(0, maxChars) + notice;
+};
+
 const hasLspDiagnostics = (output: string): boolean => {
     if (!output) return false;
     return output.includes('<diagnostics')
@@ -575,7 +597,7 @@ export const parseDiffToUnified = (diffText: string): UnifiedDiffHunk[] => {
 
         if (line.startsWith('Index:') || line.startsWith('===') || line.startsWith('---') || line.startsWith('+++')) {
             if (line.startsWith('Index:')) {
-                currentFile = line.split(' ')[1].split('/').pop() || 'file';
+                currentFile = line.slice('Index:'.length).trim().split('/').pop() || 'file';
             }
             i++;
             continue;

packages/ui/src/components/chat/work-status/DOCUMENTATION.md

@@ -95,11 +95,11 @@ which requests only providers enabled for this panel.
 
 | Block | Source | Notes |
 |---|---|---|
-| Context + cost | `contextUsage.ts` over `useSessionMessages`, `Session.cost` | see below — the store getters cannot serve this |
+| Context + cost | `contextUsage.ts` over `useSessionMessages`; cost via `useSubagentCostRollup` (own cost + every descendant subagent, recursively) | see below — the store getters cannot serve this |
 | Branch, ahead/behind, attention | `useGitStore` directory state | warmed via `runBackgroundNetworkTask(ensureStatus)` and refreshed from Git mutation hints |
 | Changed files | `useGitStore` status `files` + `diffStats` | working tree, not session-authored edits |
 | PR + checks | `useFreshestPrVisualSummaryForBranch` | **read-only**; follows the freshest remote-keyed entry for the branch |
-| Subagents | child sessions from `useAllLiveSessions` (`parentID`) + `useAllSessionStatuses` | |
+| Subagents | child sessions from `useAllLiveSessions` (`parentID`) + `useAllSessionStatuses`; per-row cost from `useSubagentCostRollup`'s `perChildCost` (each child's own subtree total, so nested subagent-of-subagent cost rolls up under its immediate parent row) | |
 | Subagent blockers | directory `permission` / `question` maps | one subscription covers every child |
 | Usage | `components/usage/usageGroups.ts` over `useQuotaStore` | grouping shared with the mobile popover; presentation is not |
 | Linked threads | `lib/linkedIssues.ts` over session metadata | written by the flows that attach an issue or PR |

packages/ui/src/components/chat/work-status/WorkStatusPrimaryGroup.tsx

@@ -4,7 +4,7 @@ import { useGitStore } from '@/stores/useGitStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
 import { runBackgroundNetworkTask } from '@/lib/background-network';
 import { useFreshestPrVisualSummaryForBranch } from '@/stores/useGitHubPrStatusStore';
-import { useSession, useSessionMessages } from '@/sync/sync-context';
+import { useSessionMessages } from '@/sync/sync-context';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { useUIStore } from '@/stores/useUIStore';
 import { useProjectsStore } from '@/stores/useProjectsStore';
@@ -14,6 +14,8 @@ import { resolveUsageTone } from '@/lib/quota';
 import { sessionEvents } from '@/lib/sessionEvents';
 import { normalizePath } from '@/lib/pathNormalization';
 import { computeContextUsage } from './contextUsage';
+import { formatCost } from './subagentCost';
+import { useSubagentCostRollup } from './useSubagentCostRollup';
 import {
   WorkStatusCallout,
   WorkStatusMeter,
@@ -33,11 +35,6 @@ type Props = {
   showRepository: boolean;
 };
 
-// Spend is read against a budget, so it keeps its real precision instead of
-// collapsing to two decimals. Trailing zeros are dropped so exact values stay
-// short.
-const trimZeros = (value: string): string => (value.includes('.') ? value.replace(/0+$/, '').replace(/\.$/, '') : value);
-const formatCost = (cost: number): string => `$${trimZeros(cost.toFixed(4))}`;
 // Matches the header readout exactly: one decimal, capped the same way, so the
 // two places that report context fill never disagree by a rounding step.
 const formatPercent = (percent: number): string => `${Math.min(percent, 999).toFixed(1)}%`;
@@ -49,7 +46,6 @@ const formatPercent = (percent: number): string => `${Math.min(percent, 999).toF
  */
 export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory, goalRow, showSession, showRepository }) => {
   const { t } = useI18n();
-  const session = useSession(sessionId ?? '', directory ?? undefined);
   const { git } = useRuntimeAPIs();
   const ensureStatus = useGitStore((state) => state.ensureStatus);
   const fetchStatus = useGitStore((state) => state.fetchStatus);
@@ -195,7 +191,16 @@ export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory,
     : usageTone === 'warn' ? 'var(--status-warning)'
       : 'var(--status-success)';
 
-  const cost = typeof session?.cost === 'number' && session.cost > 0 ? session.cost : null;
+  // Rollup total: own cost plus every descendant subagent's cost, recursively
+  // (see useSubagentCostRollup). Shown here instead of session.cost alone, so
+  // spend that ran in a spawned subagent doesn't hide from the reader.
+  const { totalCost, ownCost, subagentCost, subagentCount } = useSubagentCostRollup(sessionId);
+  const cost = totalCost !== null && totalCost > 0 ? totalCost : null;
+  // The total answers "what has this cost"; the split answers "why is it more
+  // than the session I am looking at". Only worth a line once subagents exist —
+  // without them the total *is* the session's own cost and the row would
+  // restate the number directly above it.
+  const showCostBreakdown = cost !== null && subagentCount > 0 && subagentCost > 0;
   const hasSession = showSession && (usagePercent !== null || cost !== null || Boolean(goalRow));
   const hasRepository = showRepository && Boolean(branch || changed || prSummary || attentionLabel);
 
@@ -224,6 +229,17 @@ export const WorkStatusPrimaryGroup: React.FC<Props> = ({ sessionId, directory,
                 )}
               />
               <WorkStatusMeter percent={usagePercent} color={meterColor} />
+              {/* Caption, not a row: it explains the figure above it rather
+                  than reporting a reading of its own, so it carries no icon
+                  and no label column. */}
+              {showCostBreakdown ? (
+                <p className="mx-1 mb-1 truncate text-[11px] leading-4 text-muted-foreground tabular-nums">
+                  {t('chat.workStatus.cost.breakdown', {
+                    session: formatCost(ownCost),
+                    subagents: formatCost(subagentCost),
+                  })}
+                </p>
+              ) : null}
             </>
           ) : null}
           {/* Below the context readout: the goal is a standing instruction,

packages/ui/src/components/chat/work-status/WorkStatusSubagentsSection.tsx

@@ -7,6 +7,8 @@ import { isVSCodeRuntime } from '@/lib/desktop';
 import { isEmbeddedSessionChat } from '@/components/layout/contextPanelEmbeddedChat';
 import { WorkStatusCollapsibleSection, WorkStatusRow, WorkStatusValue } from './WorkStatusPrimitives';
 import { useReportWorkStatusPresence } from './presenceContext';
+import { formatCost } from './subagentCost';
+import { useSubagentCostRollup } from './useSubagentCostRollup';
 import type { State } from '@/sync/types';
 
 type Props = {
@@ -32,6 +34,11 @@ export const WorkStatusSubagentsSection: React.FC<Props> = ({ sessionId, directo
     [liveSessions, sessionId],
   );
 
+  // Each child's own subtree total (its cost plus every descendant of its
+  // own), so nested subagent-of-subagent cost rolls up under the immediate
+  // child row shown here rather than disappearing.
+  const { perChildCost } = useSubagentCostRollup(sessionId);
+
   // One subscription covers every child: per-session hooks would multiply
   // store subscriptions by the number of subagents.
   const permissions = useDirectorySync(React.useCallback((state: State) => state.permission, []));
@@ -88,20 +95,26 @@ export const WorkStatusSubagentsSection: React.FC<Props> = ({ sessionId, directo
           const asked = (questions[child.id]?.length ?? 0) > 0;
           const busy = statuses[child.id]?.type === 'busy';
           const label = child.title?.trim() || t('chat.workStatus.subagent.untitled');
+          const childCost = perChildCost.get(child.id) ?? 0;
           return (
             <WorkStatusRow
               key={child.id}
               onClick={directory ? () => openChildSession(child.id, label) : undefined}
               ariaLabel={t('chat.workStatus.action.openSubagent', { name: label })}
               label={label}
-              value={blocked ? (
-                <WorkStatusValue tone="warning">{t('chat.workStatus.subagent.needsPermission')}</WorkStatusValue>
-              ) : asked ? (
-                <WorkStatusValue tone="warning">{t('chat.workStatus.subagent.askedQuestion')}</WorkStatusValue>
-              ) : busy ? (
-                <WorkStatusValue tone="info">{t('chat.workStatus.subagent.working')}</WorkStatusValue>
-              ) : (
-                <WorkStatusValue tone="muted">{t('chat.workStatus.subagent.done')}</WorkStatusValue>
+              value={(
+                <>
+                  {blocked ? (
+                    <WorkStatusValue tone="warning">{t('chat.workStatus.subagent.needsPermission')}</WorkStatusValue>
+                  ) : asked ? (
+                    <WorkStatusValue tone="warning">{t('chat.workStatus.subagent.askedQuestion')}</WorkStatusValue>
+                  ) : busy ? (
+                    <WorkStatusValue tone="info">{t('chat.workStatus.subagent.working')}</WorkStatusValue>
+                  ) : (
+                    <WorkStatusValue tone="muted">{t('chat.workStatus.subagent.done')}</WorkStatusValue>
+                  )}
+                  {childCost > 0 ? <WorkStatusValue tone="muted">{formatCost(childCost)}</WorkStatusValue> : null}
+                </>
               )}
             />
           );

packages/ui/src/components/chat/work-status/subagentCost.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from 'bun:test';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { buildChildrenIndex, computeSubtreeCost, formatCost } from './subagentCost';
+
+function makeSession(id: string, cost: number | undefined, parentID?: string): Session {
+  return {
+    id,
+    slug: id,
+    projectID: 'project',
+    directory: '/project',
+    title: id,
+    version: '1',
+    time: { created: 0, updated: 0 },
+    cost,
+    parentID,
+  };
+}
+
+describe('buildChildrenIndex', () => {
+  test('groups sessions by parentID', () => {
+    const root = makeSession('root', 1);
+    const childA = makeSession('a', 2, 'root');
+    const childB = makeSession('b', 3, 'root');
+    const index = buildChildrenIndex([root, childA, childB]);
+    expect(index.get('root')).toEqual([childA, childB]);
+  });
+});
+
+describe('formatCost', () => {
+  test('prefixes with $ and trims trailing zeros', () => {
+    expect(formatCost(1.5)).toBe('$1.5');
+    expect(formatCost(0.0001)).toBe('$0.0001');
+    expect(formatCost(2)).toBe('$2');
+  });
+});
+
+describe('computeSubtreeCost', () => {
+  test('sums a flat root with two direct children', () => {
+    const root = makeSession('root', 1);
+    const childA = makeSession('a', 2, 'root');
+    const childB = makeSession('b', 3, 'root');
+    const sessions = [root, childA, childB];
+    const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+    const childrenByParent = buildChildrenIndex(sessions);
+    expect(computeSubtreeCost('root', sessionsById, childrenByParent)).toBe(6);
+  });
+
+  test('rolls up cost through nested descendants', () => {
+    const root = makeSession('root', 1);
+    const child = makeSession('child', 2, 'root');
+    const grandchild = makeSession('grandchild', 4, 'child');
+    const sessions = [root, child, grandchild];
+    const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+    const childrenByParent = buildChildrenIndex(sessions);
+    expect(computeSubtreeCost('root', sessionsById, childrenByParent)).toBe(7);
+    expect(computeSubtreeCost('child', sessionsById, childrenByParent)).toBe(6);
+  });
+
+  test('does not double-count or infinite-loop on a cycle', () => {
+    const a = makeSession('a', 1, 'b');
+    const b = makeSession('b', 2, 'a');
+    const sessions = [a, b];
+    const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+    const childrenByParent = buildChildrenIndex(sessions);
+    expect(computeSubtreeCost('a', sessionsById, childrenByParent)).toBe(3);
+  });
+
+  test('treats zero and undefined cost as zero, not a break', () => {
+    const root = makeSession('root', 0);
+    const child = makeSession('child', undefined, 'root');
+    const sessions = [root, child];
+    const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+    const childrenByParent = buildChildrenIndex(sessions);
+    expect(computeSubtreeCost('root', sessionsById, childrenByParent)).toBe(0);
+  });
+
+  test('returns 0 for an unknown id', () => {
+    const sessionsById = new Map<string, Session>();
+    const childrenByParent = new Map<string, Session[]>();
+    expect(computeSubtreeCost('missing', sessionsById, childrenByParent)).toBe(0);
+  });
+});

packages/ui/src/components/chat/work-status/subagentCost.ts

@@ -0,0 +1,56 @@
+import type { Session } from '@opencode-ai/sdk/v2';
+
+// Spend is read against a budget, so it keeps its real precision instead of
+// collapsing to two decimals. Trailing zeros are dropped so exact values stay
+// short. Relocated from WorkStatusPrimaryGroup.tsx so both that component and
+// WorkStatusSubagentsSection share one implementation.
+const trimZeros = (value: string): string =>
+  (value.includes('.') ? value.replace(/0+$/, '').replace(/\.$/, '') : value);
+
+export const formatCost = (cost: number): string => `$${trimZeros(cost.toFixed(4))}`;
+
+/**
+ * Groups a flat live-session list by parentID. One pass, O(n). Sessions
+ * without a parentID (roots) are simply absent as keys — callers look up a
+ * specific id's children via `.get(id) ?? []`.
+ */
+export function buildChildrenIndex(sessions: Session[]): Map<string, Session[]> {
+  const index = new Map<string, Session[]>();
+  for (const session of sessions) {
+    const parentID = session.parentID;
+    if (!parentID) continue;
+    const existing = index.get(parentID);
+    if (existing) {
+      existing.push(session);
+    } else {
+      index.set(parentID, [session]);
+    }
+  }
+  return index;
+}
+
+function sessionCost(session: Session | undefined): number {
+  return session?.cost ?? 0;
+}
+
+/**
+ * Own cost plus every descendant's cost, recursively. Cycle-guarded with a
+ * visited set: parentID should form a tree, but this does not trust that
+ * invariant blindly (mirrors opencode-session-cost's src/cost.ts).
+ */
+export function computeSubtreeCost(
+  id: string,
+  sessionsById: Map<string, Session>,
+  childrenByParent: Map<string, Session[]>,
+  visited: Set<string> = new Set(),
+): number {
+  if (visited.has(id)) return 0;
+  visited.add(id);
+
+  let total = sessionCost(sessionsById.get(id));
+  const children = childrenByParent.get(id) ?? [];
+  for (const child of children) {
+    total += computeSubtreeCost(child.id, sessionsById, childrenByParent, visited);
+  }
+  return total;
+}

packages/ui/src/components/chat/work-status/useSubagentCostRollup.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'bun:test';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { computeRollup } from './useSubagentCostRollup';
+
+function makeSession(id: string, cost: number, parentID?: string): Session {
+  return {
+    id,
+    slug: id,
+    projectID: 'project',
+    directory: '/project',
+    title: id,
+    version: '1',
+    time: { created: 0, updated: 0 },
+    cost,
+    parentID,
+  };
+}
+
+const sessions: Session[] = [
+  makeSession('root', 1),
+  makeSession('a', 2, 'root'),
+  makeSession('b', 3, 'root'),
+  makeSession('a1', 5, 'a'),
+];
+
+describe('computeRollup', () => {
+  test('sums own cost plus every descendant', () => {
+    const result = computeRollup(sessions, 'root');
+    expect(result.totalCost).toBe(11);
+    expect(result.subagentCount).toBe(3);
+  });
+
+  test('splits the total into the session own cost and the subagent share', () => {
+    const result = computeRollup(sessions, 'root');
+    expect(result.ownCost).toBe(1);
+    expect(result.subagentCost).toBe(10);
+    expect(result.ownCost + result.subagentCost).toBe(result.totalCost);
+  });
+
+  test('reports a zero subagent share for a session with no children', () => {
+    const result = computeRollup(sessions, 'a1');
+    expect(result.ownCost).toBe(5);
+    expect(result.subagentCost).toBe(0);
+    expect(result.totalCost).toBe(5);
+  });
+
+  test('maps each direct child to its own subtree cost', () => {
+    const result = computeRollup(sessions, 'root');
+    expect(result.perChildCost.get('a')).toBe(7);
+    expect(result.perChildCost.get('b')).toBe(3);
+  });
+
+  test('returns null total for a null sessionId', () => {
+    const result = computeRollup(sessions, null);
+    expect(result.totalCost).toBeNull();
+    expect(result.subagentCount).toBe(0);
+  });
+
+  test('returns null total for an unknown sessionId', () => {
+    const result = computeRollup(sessions, 'missing');
+    expect(result.totalCost).toBeNull();
+  });
+
+  test('sum of perChildCost plus root cost equals totalCost', () => {
+    const result = computeRollup(sessions, 'root');
+    const childSum = Array.from(result.perChildCost.values()).reduce((sum, v) => sum + v, 0);
+    const rootOwnCost = 1;
+    expect(childSum + rootOwnCost).toBe(result.totalCost);
+  });
+});

packages/ui/src/components/chat/work-status/useSubagentCostRollup.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { useAllLiveSessions } from '@/sync/sync-context';
+import { buildChildrenIndex, computeSubtreeCost } from './subagentCost';
+
+export type SubagentCostRollup = {
+  totalCost: number | null;
+  /** The root session's own spend, excluding every subagent. */
+  ownCost: number;
+  /** Everything the subagents cost between them: `totalCost - ownCost`. */
+  subagentCost: number;
+  subagentCount: number;
+  perChildCost: Map<string, number>;
+};
+
+const EMPTY_ROLLUP: SubagentCostRollup = {
+  totalCost: null,
+  ownCost: 0,
+  subagentCost: 0,
+  subagentCount: 0,
+  perChildCost: new Map(),
+};
+
+function countDescendants(id: string, childrenByParent: Map<string, Session[]>, visited: Set<string>): number {
+  if (visited.has(id)) return 0;
+  visited.add(id);
+  const kids = childrenByParent.get(id) ?? [];
+  let count = kids.length;
+  for (const kid of kids) count += countDescendants(kid.id, childrenByParent, visited);
+  return count;
+}
+
+/**
+ * Pure core of useSubagentCostRollup, kept separate so it can be unit-tested
+ * directly against a plain session array instead of rendering the hook.
+ */
+export function computeRollup(liveSessions: Session[], sessionId: string | null): SubagentCostRollup {
+  if (!sessionId) return EMPTY_ROLLUP;
+
+  const sessionsById = new Map(liveSessions.map((session) => [session.id, session]));
+  if (!sessionsById.has(sessionId)) return EMPTY_ROLLUP;
+
+  const childrenByParent = buildChildrenIndex(liveSessions);
+  const totalCost = computeSubtreeCost(sessionId, sessionsById, childrenByParent);
+
+  const perChildCost = new Map<string, number>();
+  let subagentCost = 0;
+  for (const child of childrenByParent.get(sessionId) ?? []) {
+    const childSubtree = computeSubtreeCost(child.id, sessionsById, childrenByParent);
+    perChildCost.set(child.id, childSubtree);
+    subagentCost += childSubtree;
+  }
+
+  // Derived by subtraction rather than read back off the session, so the split
+  // always adds up to the total the panel shows even if a cycle guard trimmed
+  // part of the walk.
+  const ownCost = totalCost - subagentCost;
+  const subagentCount = countDescendants(sessionId, childrenByParent, new Set());
+
+  return { totalCost, ownCost, subagentCost, subagentCount, perChildCost };
+}
+
+/**
+ * Own cost plus every descendant subagent's cost, recursively summed, for a
+ * given root session. Reads the same `useAllLiveSessions()` subscription
+ * WorkStatusSubagentsSection already holds — no new store subscription.
+ */
+export function useSubagentCostRollup(sessionId: string | null): SubagentCostRollup {
+  const liveSessions = useAllLiveSessions();
+  return React.useMemo(() => computeRollup(liveSessions, sessionId), [liveSessions, sessionId]);
+}

packages/ui/src/components/layout/ContextPanel.tsx

@@ -452,13 +452,12 @@ export const ContextPanel: React.FC = () => {
 
   // Lets an agent's browser.open create the tab it needs when none is open yet.
   // Registered from the panel because opening a tab is panel state, not
-  // something the browser view itself can do before it exists. Background on
-  // purpose: an agent working a page must not pop the panel open (or steal
-  // the active surface) under the user — the tab mounts invisibly, and the
-  // rail is where the user opens it when curious.
+  // something the browser view itself can do before it exists. Reveal the
+  // panel so Electron gives the webview a composited surface; capturePage()
+  // cannot capture the zero-width webview inside a closed panel.
   React.useEffect(() => {
     if (!effectiveDirectory) return;
-    return registerBrowserOpener((url) => openContextBrowser(effectiveDirectory, url, { reveal: false }));
+    return registerBrowserOpener((url) => openContextBrowser(effectiveDirectory, url));
   }, [effectiveDirectory, openContextBrowser]);
   const reorderContextPanelTabs = useUIStore((state) => state.reorderContextPanelTabs);
   const setSelectedFilePath = useFilesViewTabsStore((state) => state.setSelectedPath);

packages/ui/src/components/layout/Header.tsx

@@ -71,7 +71,7 @@ import { copyTextToClipboard } from '@/lib/clipboard';
 import { buildExportFilename, downloadAsMarkdown, formatSessionAsMarkdown, saveAsMarkdownDesktop } from '@/lib/exportSession';
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog';
 import { Button } from '@/components/ui/button';
-import { startSessionTreeWorktreeMove, useIsSessionWorktreeMovePending } from '@/lib/worktrees/sessionWorktreeMove';
+import { buildSessionTreeMoveMessages, requestSessionTreeMove, useIsSessionWorktreeMovePending } from '@/lib/worktrees/sessionWorktreeMove';
 
 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';
 
@@ -1059,12 +1059,15 @@ export const Header: React.FC = () => {
       }
     }
 
-    startSessionTreeWorktreeMove({
+    requestSessionTreeMove({
+      kind: 'quick',
       root,
       descendants,
       sourceDirectory: sessionDirectory,
-      successMessage: t('sessions.sidebar.session.moveToWorktree.success'),
-      failureMessage: t('sessions.sidebar.session.moveToWorktree.failed'),
+      messages: buildSessionTreeMoveMessages(t, {
+        success: 'sessions.sidebar.session.moveToWorktree.success',
+        failure: 'sessions.sidebar.session.moveToWorktree.failed',
+      }),
     });
   }, [currentSessionId, isCurrentSessionActive, isCurrentSessionMovingToWorktree, sessionDirectory, t]);
 

packages/ui/src/components/layout/MainLayout.tsx

@@ -11,6 +11,7 @@ import { HelpDialog } from '../ui/HelpDialog';
 import { OpenCodeStatusDialog } from '../ui/OpenCodeStatusDialog';
 import { SessionSidebar } from '@/components/session/SessionSidebar';
 import { SessionDialogs } from '@/components/session/SessionDialogs';
+import { SessionWorktreeMoveConfirmDialog } from '@/components/session/sidebar/SessionWorktreeMoveConfirmDialog';
 import { ScheduledTasksDialog } from '@/components/session/ScheduledTasksDialog';
 import { ArchiveView } from '@/components/views/ArchiveView';
 import { WorktreesView } from '@/components/views/WorktreesView';
@@ -19,6 +20,11 @@ import { MultiRunLauncher } from '@/components/multirun';
 
 import { useUIStore } from '@/stores/useUIStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
+import {
+  cancelSessionTreeMove,
+  confirmSessionTreeMove,
+  useSessionTreeMoveConfirmation,
+} from '@/lib/worktrees/sessionWorktreeMove';
 import { useUpdatePolling } from '@/hooks/useUpdatePolling';
 import { useDeviceInfo } from '@/lib/device';
 import { cn } from '@/lib/utils';
@@ -80,6 +86,8 @@ export const MainLayout: React.FC = () => {
 
     useUpdatePolling();
 
+    const sessionTreeMoveConfirmation = useSessionTreeMoveConfirmation();
+
     React.useEffect(() => {
         const previous = useUIStore.getState().isMobile;
         if (previous !== isMobile) {
@@ -97,6 +105,12 @@ export const MainLayout: React.FC = () => {
                 <HelpDialog />
                 <OpenCodeStatusDialog />
                 <SessionDialogs />
+                <SessionWorktreeMoveConfirmDialog
+                    value={sessionTreeMoveConfirmation}
+                    onMoveSessionOnly={() => confirmSessionTreeMove(false)}
+                    onMoveAllChanges={() => confirmSessionTreeMove(true)}
+                    onCancel={cancelSessionTreeMove}
+                />
 
                 {/* Persistent top-left controls (toggle + project actions) that
                     stay put while the sidebar/header animate beneath them. */}

packages/ui/src/components/layout/VSCodeLayout.tsx

@@ -5,7 +5,8 @@ import { SessionDialogs } from '@/components/session/SessionDialogs';
 import { ChatView } from '@/components/views/ChatView';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useViewportStore } from '@/sync/viewport-store';
-import { useSessions, useDirectorySync, useSession, useSessionMessages, useSessionMessagesResolved } from '@/sync/sync-context';
+import { useSessions, useDirectorySync, useSessionMessages, useSessionMessagesResolved } from '@/sync/sync-context';
+import { useSubagentCostRollup } from '@/components/chat/work-status/useSubagentCostRollup';
 import { useConfigStore } from '@/stores/useConfigStore';
 import { resolveGlobalSessionDirectory, useGlobalSessionsStore } from '@/stores/useGlobalSessionsStore';
 import { contextTokensFromBreakdown } from '@/stores/utils/tokenUtils';
@@ -671,7 +672,9 @@ const VSCodeHeader: React.FC<VSCodeHeaderProps> = ({ title, showBack, onBack, on
   const providers = useConfigStore((state) => state.providers);
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const activeProjectId = useProjectsStore((state) => state.activeProjectId);
-  const currentSession = useSession(currentSessionId ?? '');
+  // Same rollup the work-status panel reports, so the header and the panel
+  // never disagree about what this session has cost.
+  const { totalCost: sessionTotalCost } = useSubagentCostRollup(currentSessionId ?? null);
   const currentSessionMessages = useSessionMessages(currentSessionId ?? '');
   const currentSessionMessagesResolved = useSessionMessagesResolved(currentSessionId ?? '');
   const quotaResults = useQuotaStore((state) => state.results);
@@ -1028,7 +1031,7 @@ const VSCodeHeader: React.FC<VSCodeHeaderProps> = ({ title, showBack, onBack, on
           percentage={stableContextUsage.percentage}
           contextLimit={stableContextUsage.contextLimit}
           outputLimit={stableContextUsage.outputLimit ?? 0}
-          cost={(currentSession?.cost ?? 0) > 0 ? currentSession?.cost : null}
+          cost={(sessionTotalCost ?? 0) > 0 ? sessionTotalCost : null}
           className="h-9 shrink-0 pl-1 pr-1 typography-ui-label"
           valueClassName="font-semibold leading-none"
           hideIcon

packages/ui/src/components/layout/__tests__/issue-3175-browserCaptureRevealsPanel.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Regression coverage for https://github.com/openchamber/openchamber/issues/3175
+ *
+ * A full ContextPanel mount is not available in bun test because its import
+ * graph includes a Vite worker URL. This test follows the source-level guard
+ * pattern used by the neighboring ContextPanel regression tests and exercises
+ * the real store behavior that the registered opener delegates to.
+ */
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { useUIStore } from '@/stores/useUIStore';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const contextPanelSource = readFileSync(join(__dirname, '..', 'ContextPanel.tsx'), 'utf-8');
+const browserPaneSource = readFileSync(join(__dirname, '..', '..', 'browser', 'BrowserPane.tsx'), 'utf-8');
+const DIRECTORY = '/path/to/repository';
+
+beforeEach(() => {
+  useUIStore.setState({ contextPanelByDirectory: {}, contextRailOrder: [] });
+});
+
+describe('issue #3175 browser capture while the context panel is closed', () => {
+  test('registers the agent browser opener without suppressing panel reveal', () => {
+    expect(contextPanelSource).toContain(
+      'registerBrowserOpener((url) => openContextBrowser(effectiveDirectory, url))',
+    );
+    expect(contextPanelSource).not.toContain(
+      'openContextBrowser(effectiveDirectory, url, { reveal: false })',
+    );
+  });
+
+  test('opening the agent browser gives its webview a visible panel surface', () => {
+    useUIStore.getState().openContextBrowser(DIRECTORY, 'https://example.com');
+
+    const panel = useUIStore.getState().contextPanelByDirectory[DIRECTORY];
+    expect(panel.isOpen).toBe(true);
+    expect(panel.tabs).toHaveLength(1);
+    expect(panel.tabs[0]?.mode).toBe('browser');
+    expect(panel.tabs[0]?.targetPath).toBe('https://example.com');
+  });
+
+  test('reveals the browser again if it was closed before capture', () => {
+    expect(browserPaneSource).toContain(
+      'openContextBrowser(directory, webview.getURL())',
+    );
+  });
+});

packages/ui/src/components/model-picker/ModelPickerList.tsx

@@ -690,7 +690,9 @@ export const ModelPickerList: React.FC<ModelPickerListProps> = ({
               onMouseMove={handleMouseActivity}
               className={cn(
                 'w-full text-left px-2 py-1.5 rounded-md typography-meta flex items-center gap-2 cursor-pointer',
-                !disabled && (isHighlighted ? 'bg-interactive-selection' : 'hover:bg-interactive-hover/50'),
+                !disabled && (isHighlighted
+                  ? 'bg-interactive-selection text-interactive-selection-foreground'
+                  : 'hover:bg-interactive-hover/50'),
                 disabled && 'cursor-not-allowed opacity-60',
                 rowClassName,
               )}
@@ -703,9 +705,9 @@ export const ModelPickerList: React.FC<ModelPickerListProps> = ({
                 ) : null}
                 {showProviderLogo ? <ProviderLogo providerId={entry.providerID} className="h-3.5 w-3.5 flex-shrink-0" /> : null}
                 <span className="font-medium truncate">{getModelDisplayName(entry.model)}</span>
-                {contextTokens ? <span className="typography-micro text-muted-foreground flex-shrink-0">{contextTokens}</span> : null}
+                {contextTokens ? <span className={cn('typography-micro flex-shrink-0', isHighlighted ? 'text-interactive-selection-foreground/70' : 'text-muted-foreground')}>{contextTokens}</span> : null}
               </div>
-              {count > 0 ? <span className="typography-micro text-muted-foreground flex-shrink-0">x{count}</span> : null}
+              {count > 0 ? <span className={cn('typography-micro flex-shrink-0', isHighlighted ? 'text-interactive-selection-foreground/70' : 'text-muted-foreground')}>x{count}</span> : null}
               {renderRowEnd?.(entry, { isHighlighted, isSelected })}
               {isSelected ? <Icon name="check" className="h-4 w-4 text-primary flex-shrink-0" /> : null}
               {onToggleFavorite ? (

packages/ui/src/components/multirun/MultiRunLauncher.tsx

@@ -32,7 +32,6 @@ import { startDesktopWindowDrag } from '@/lib/desktopNative';
 import { useI18n } from '@/lib/i18n';
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
-const MAX_MODELS_PER_GROUP = 5;
 
 interface MultiRunAttachedFile {
   id: string;
@@ -727,7 +726,6 @@ const RunGroupCard: React.FC<RunGroupCardProps> = ({
   const snippetRef = React.useRef<SnippetAutocompleteHandle>(null);
 
   const handleAddModel = React.useCallback((model: ModelSelectionWithId) => {
-    if (group.models.length >= MAX_MODELS_PER_GROUP) return;
     onUpdate(group.id, { models: [...group.models, model] });
   }, [group.id, group.models, onUpdate]);
 
@@ -987,7 +985,7 @@ const RunGroupCard: React.FC<RunGroupCardProps> = ({
       <div className="flex flex-col gap-1.5">
         <FieldLabel
           required
-          info={<InfoTip>{t('multirun.launcher.models.info', { max: MAX_MODELS_PER_GROUP })}</InfoTip>}
+          info={<InfoTip>{t('multirun.launcher.models.info')}</InfoTip>}
         >
           {t('multirun.launcher.models.label')}
         </FieldLabel>
@@ -997,7 +995,6 @@ const RunGroupCard: React.FC<RunGroupCardProps> = ({
           onRemove={handleRemoveModel}
           onUpdate={handleUpdateModel}
           minModels={1}
-          maxModels={MAX_MODELS_PER_GROUP}
         />
       </div>
     </div>

packages/ui/src/components/sections/agents/AgentsSidebar.tsx

@@ -250,6 +250,7 @@ export const AgentsSidebar: React.FC<AgentsSidebarProps> = ({ onItemSelect }) =>
       disable: draftAgent.disable,
     });
     setSelectedAgent(newName);
+    onItemSelect?.();
 
   };
 

packages/ui/src/components/sections/openchamber/GitHubSettings.test.tsx

@@ -0,0 +1,61 @@
+import React from "react";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { I18nProvider } from "@/lib/i18n";
+import { useGitHubAuthStore } from "@/stores/useGitHubAuthStore";
+
+import { GitHubSettings } from "./GitHubSettings";
+
+const serverAuthState = useGitHubAuthStore.getInitialState();
+
+const resetServerAuthState = () => {
+  Object.assign(serverAuthState, {
+    status: null,
+    isLoading: false,
+    hasChecked: false,
+  });
+};
+
+const renderSettings = () =>
+  renderToStaticMarkup(
+    <I18nProvider>
+      <GitHubSettings />
+    </I18nProvider>,
+  );
+
+describe("GitHubSettings", () => {
+  beforeEach(resetServerAuthState);
+  afterEach(resetServerAuthState);
+
+  test("stays hidden during the initial auth status load", () => {
+    serverAuthState.isLoading = true;
+
+    expect(renderSettings()).toBe("");
+  });
+
+  test("stays mounted while a checked status is refreshing, then shows reconnect state", () => {
+    Object.assign(serverAuthState, {
+      status: {
+        connected: true,
+        user: { login: "octocat" },
+      },
+      isLoading: true,
+      hasChecked: true,
+    });
+
+    const refreshingMarkup = renderSettings();
+    expect(refreshingMarkup).toContain("octocat");
+    expect(refreshingMarkup).toContain("Disconnect");
+
+    Object.assign(serverAuthState, {
+      status: { connected: false },
+      isLoading: false,
+      hasChecked: true,
+    });
+
+    const disconnectedMarkup = renderSettings();
+    expect(disconnectedMarkup).toContain("Not Connected");
+    expect(disconnectedMarkup).toContain("Connect GitHub");
+  });
+});

packages/ui/src/components/sections/openchamber/GitHubSettings.tsx

@@ -256,7 +256,7 @@ export const GitHubSettings: React.FC = () => {
     }
   }, [runtimeGitHub, setStatus, t]);
 
-  if (isLoading) {
+  if (isLoading && !hasChecked) {
     return null;
   }
 

packages/ui/src/components/sections/openchamber/PasskeySettings.tsx

@@ -219,7 +219,7 @@ export const PasskeySettings: React.FC = () => {
             {passkeys.map((passkey) => (
               <SettingsFieldRow
                 key={passkey.id}
-                label={<span className="truncate">{passkey.label}</span>}
+                label={<span title={passkey.label}>{passkey.label}</span>}
                 alignEnd={false}
                 controlClassName="justify-between sm:flex-1"
               >

packages/ui/src/components/sections/openchamber/TunnelSettings.tsx

@@ -205,7 +205,7 @@ const getFallbackInstallCommand = (provider: string, platform = getClientInstall
   if (platform === 'darwin') {
     return 'brew install cloudflared';
   }
-  return 'https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/';
+  return 'https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/';
 };
 
 const createTunnelDependencyInstallInfo = (provider: string, checkData?: TunnelCheckResponse): TunnelDependencyInstallInfo => {

packages/ui/src/components/sections/shared/SettingsPageLayout.tsx

@@ -75,13 +75,13 @@ export const SettingsPageLayout: React.FC<SettingsPageLayoutProps> = ({
                   hasTitleChrome ? (
                     <div className="flex min-w-0 items-center gap-2">
                       {titleLeading}
-                      <h1 className={cn(SETTINGS_PAGE_TITLE_CLASS, 'min-w-0 truncate')}>{title}</h1>
+                      <h1 data-settings-page-heading tabIndex={-1} className={cn(SETTINGS_PAGE_TITLE_CLASS, 'min-w-0 truncate')}>{title}</h1>
                       {/* A status badge carries a fixed word; compressing it
                           wraps the text inside its own pill. */}
                       <span className="shrink-0">{titleAccessory}</span>
                     </div>
                   ) : (
-                    <h1 className={SETTINGS_PAGE_TITLE_CLASS}>{title}</h1>
+                    <h1 data-settings-page-heading tabIndex={-1} className={SETTINGS_PAGE_TITLE_CLASS}>{title}</h1>
                   )
                 ) : (
                   title

packages/ui/src/components/sections/shared/SettingsSection.tsx

@@ -310,8 +310,8 @@ export const SettingsFieldRow: React.FC<SettingsFieldRowProps> = ({
       )}
     >
       <div className="min-w-0 @xl:w-56 @xl:shrink-0">
-        <div className="flex items-center gap-1.5">
-          <div className={SETTINGS_FIELD_LABEL_CLASS}>{label}</div>
+        <div className="flex min-w-0 items-center gap-1.5">
+          <div className={cn('min-w-0 truncate', SETTINGS_FIELD_LABEL_CLASS)}>{label}</div>
           {info != null ? <SettingsInfoHint>{info}</SettingsInfoHint> : null}
         </div>
         {description != null ? (

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

@@ -359,7 +359,7 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
   const canSubmitClone = canAddProject && cloneRemoteUrl.trim().length > 0;
   const highlightedRow = rows[highlightedIndex] ?? null;
   const hasHighlightedBrowseItem = Boolean(
-    highlightedRow && (highlightedRow.type === 'up' || (highlightedRow.type === 'directory' && !highlightedRow.disabled))
+    highlightedRow && (highlightedRow.type === 'up' || highlightedRow.type === 'directory')
   );
   const submitModifierLabel = formatShortcutForDisplay('mod');
   const submitActionLabel = isAlreadyAdded
@@ -414,11 +414,11 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
     handleClose();
   }, [handleClose, isMobile, openNewSessionDraft, setSessionSwitcherOpen]);
 
-  const handleQuickAdd = React.useCallback((event: React.MouseEvent, path: string) => {
+  const handleQuickAdd = React.useCallback(async (event: React.MouseEvent, path: string) => {
     event.stopPropagation();
     const normalized = normalizeDirectoryPath(path);
     if (normalized && addedProjectPaths.has(normalized)) return;
-    const project = addProject(path);
+    const project = await addProject(path);
     if (!project) {
       toast.error(t('directoryExplorerDialog.toast.failedToAddProject'), {
         description: t('directoryExplorerDialog.toast.selectValidDirectoryPath'),
@@ -452,7 +452,7 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
       } else if (shouldCreateSelection) {
         await opencodeClient.createDirectory(target, { asProject: true });
       }
-      const project = addProject(selectedTarget);
+      const project = await addProject(selectedTarget);
       if (!project) {
         toast.error(t('directoryExplorerDialog.toast.failedToAddProject'), {
           description: t('directoryExplorerDialog.toast.selectValidDirectoryPath'),
@@ -483,7 +483,6 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
       if (row.path) browseToDisplayPath(row.path);
       return;
     }
-    if (row.disabled) return;
     browseToEntry(row);
   }, [browseToDisplayPath, browseToEntry]);
 
@@ -662,7 +661,6 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
                     }
                   }}
                   type="button"
-                  disabled={row.type === 'directory' && row.disabled}
                   onMouseEnter={() => setHighlightedIndex(index)}
                   onMouseDown={(event) => event.preventDefault()}
                   onClick={() => executeRow(row)}
@@ -670,7 +668,7 @@ export const DirectoryExplorerDialog: React.FC<DirectoryExplorerDialogProps> = (
                     'flex w-full cursor-pointer items-center gap-2 rounded-lg px-2 py-1.5 text-left transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/50',
                     isActive && 'bg-interactive-selection text-interactive-selection-foreground',
                     !isActive && 'hover:bg-interactive-hover/50',
-                    row.type === 'directory' && row.disabled && 'cursor-not-allowed opacity-45 hover:bg-transparent'
+                    row.type === 'directory' && row.disabled && 'opacity-45'
                   )}
                 >
                   {row.type === 'up' ? (

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

@@ -1207,10 +1207,10 @@ export function NewWorktreeDialog({
                           </div>
                         )}
 
-                        {existingBranchRankedGroups.otherLocal.length > 0 && (
+                        {!hasExistingBranchQuery && existingBranchRankedGroups.otherLocal.length > 0 && (
                           <div className="space-y-2">
                             <div className="typography-small font-semibold text-foreground px-2">
-                              {hasExistingBranchQuery ? t('session.newWorktree.otherLocalBranches') : t('session.newWorktree.localBranches')}
+                              {t('session.newWorktree.localBranches')}
                             </div>
                             <div className="space-y-1">
                               {existingBranchRankedGroups.otherLocal.map((branch) => (
@@ -1239,10 +1239,10 @@ export function NewWorktreeDialog({
                           </div>
                         )}
 
-                        {existingBranchRankedGroups.otherRemote.length > 0 && (
+                        {!hasExistingBranchQuery && existingBranchRankedGroups.otherRemote.length > 0 && (
                           <div className="space-y-2">
                             <div className="typography-small font-semibold text-foreground px-2">
-                              {hasExistingBranchQuery ? t('session.newWorktree.otherRemoteBranches') : t('session.newWorktree.remoteBranches')}
+                              {t('session.newWorktree.remoteBranches')}
                             </div>
                             <div className="space-y-1">
                               {existingBranchRankedGroups.otherRemote.map((branch) => (
@@ -1466,10 +1466,10 @@ export function NewWorktreeDialog({
                           </div>
                         )}
 
-                        {sourceBranchRankedGroups.otherLocal.length > 0 && (
+                        {!hasSourceBranchQuery && sourceBranchRankedGroups.otherLocal.length > 0 && (
                           <div className="space-y-2">
                             <div className="typography-small font-semibold text-foreground px-2">
-                              {hasSourceBranchQuery ? t('session.newWorktree.otherLocalBranches') : t('session.newWorktree.localBranches')}
+                              {t('session.newWorktree.localBranches')}
                             </div>
                             <div className="space-y-1">
                               {sourceBranchRankedGroups.otherLocal.map((branch) => (
@@ -1493,10 +1493,10 @@ export function NewWorktreeDialog({
                           </div>
                         )}
 
-                        {sourceBranchRankedGroups.otherRemote.length > 0 && (
+                        {!hasSourceBranchQuery && sourceBranchRankedGroups.otherRemote.length > 0 && (
                           <div className="space-y-2">
                             <div className="typography-small font-semibold text-foreground px-2">
-                              {hasSourceBranchQuery ? t('session.newWorktree.otherRemoteBranches') : t('session.newWorktree.remoteBranches')}
+                              {t('session.newWorktree.remoteBranches')}
                             </div>
                             <div className="space-y-1">
                               {sourceBranchRankedGroups.otherRemote.map((branch) => (
@@ -1675,10 +1675,9 @@ export function NewWorktreeDialog({
                                 </div>
                               )}
 
-                              {existingBranchRankedGroups.otherLocal.length > 0 && (
+                              {!hasExistingBranchQuery && existingBranchRankedGroups.otherLocal.length > 0 && (
                                 <>
-                                  {hasExistingBranchQuery && <CommandSeparator />}
-                                  <CommandGroup heading={hasExistingBranchQuery ? t('session.newWorktree.otherLocalBranches') : t('session.newWorktree.localBranches')}>
+                                  <CommandGroup heading={t('session.newWorktree.localBranches')}>
                                     {existingBranchRankedGroups.otherLocal.map((branch) => (
                                       <CommandItem
                                         key={`local-${branch}`}
@@ -1700,12 +1699,12 @@ export function NewWorktreeDialog({
                                 </>
                               )}
 
-                              {existingBranchRankedGroups.otherRemote.length > 0 && (
+                              {!hasExistingBranchQuery && existingBranchRankedGroups.otherRemote.length > 0 && (
                                 <>
-                                  {(existingBranchRankedGroups.otherLocal.length > 0 || hasExistingBranchQuery) && (
+                                  {existingBranchRankedGroups.otherLocal.length > 0 && (
                                     <CommandSeparator />
                                   )}
-                                  <CommandGroup heading={hasExistingBranchQuery ? t('session.newWorktree.otherRemoteBranches') : t('session.newWorktree.remoteBranches')}>
+                                  <CommandGroup heading={t('session.newWorktree.remoteBranches')}>
                                     {existingBranchRankedGroups.otherRemote.map((branch) => (
                                       <CommandItem
                                         key={`remote-${branch}`}
@@ -1914,10 +1913,9 @@ export function NewWorktreeDialog({
                                 </div>
                               )}
 
-                              {sourceBranchRankedGroups.otherLocal.length > 0 && (
+                              {!hasSourceBranchQuery && sourceBranchRankedGroups.otherLocal.length > 0 && (
                                 <>
-                                  {hasSourceBranchQuery && <CommandSeparator />}
-                                  <CommandGroup heading={hasSourceBranchQuery ? t('session.newWorktree.otherLocalBranches') : t('session.newWorktree.localBranches')}>
+                                  <CommandGroup heading={t('session.newWorktree.localBranches')}>
                                     {sourceBranchRankedGroups.otherLocal.map((branch) => (
                                       <CommandItem
                                         key={`local-${branch}`}
@@ -1934,12 +1932,12 @@ export function NewWorktreeDialog({
                                 </>
                               )}
 
-                              {sourceBranchRankedGroups.otherRemote.length > 0 && (
+                              {!hasSourceBranchQuery && sourceBranchRankedGroups.otherRemote.length > 0 && (
                                 <>
-                                  {(sourceBranchRankedGroups.otherLocal.length > 0 || hasSourceBranchQuery) && (
+                                  {sourceBranchRankedGroups.otherLocal.length > 0 && (
                                     <CommandSeparator />
                                   )}
-                                  <CommandGroup heading={hasSourceBranchQuery ? t('session.newWorktree.otherRemoteBranches') : t('session.newWorktree.remoteBranches')}>
+                                  <CommandGroup heading={t('session.newWorktree.remoteBranches')}>
                                     {sourceBranchRankedGroups.otherRemote.map((branch) => (
                                       <CommandItem
                                         key={`remote-${branch}`}

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

@@ -40,6 +40,14 @@ import { runBackgroundNetworkTask } from '@/lib/background-network';
 import { buildKnownSessionDirectories } from './sidebar/list/sessionListDirectories';
 import { z } from 'zod';
 import { subscribeOpenchamberEvents } from '@/lib/openchamberEvents';
+import {
+  commitDiscoveredRawWorktreesByProject,
+  ensureRawWorktreesByProjectScope,
+  startSessionWorktreeMenuLoad,
+  type RawWorktreesByProjectScope,
+  type StartSessionWorktreeMenuLoadArgs,
+} from './sidebar/sessionWorktreeMenu';
+import { resolveProjectRef } from '@/lib/worktreeSessionCreator';
 
 const PROJECT_ACTIVE_SESSION_STORAGE_KEY = 'oc.sessions.activeSessionByProject';
 const EMPTY_STRING_ARRAY: string[] = [];
@@ -189,6 +197,11 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
   const [worktreeDiscoveryRevision, requestWorktreeDiscovery] = React.useReducer((revision) => revision + 1, 0);
   const isWorktreeTopologyLoading = !isVSCode && resolvedWorktreeTopologyKey !== projectWorktreeDiscoveryKey;
   const [unresolvedWorktreeProjectPaths, setUnresolvedWorktreeProjectPaths] = React.useState<ReadonlySet<string>>(new Set());
+  const rawWorktreesByProjectRef = React.useRef<RawWorktreesByProjectScope>({
+    runtimeKey: null,
+    revision: 0,
+    worktreesByProject: new Map(),
+  });
 
   React.useEffect(() => {
     let cancelled = false;
@@ -198,14 +211,25 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
       const projectEntries = useProjectsStore.getState().projects;
       if (projectEntries.length === 0 || isVSCode) {
         if (!cancelled) {
+          rawWorktreesByProjectRef.current = {
+            runtimeKey: null,
+            revision: 0,
+            worktreesByProject: new Map(),
+          };
           setUnresolvedWorktreeProjectPaths(new Set());
           setResolvedWorktreeTopologyKey(projectWorktreeDiscoveryKey);
         }
         return;
       }
 
-      const knownWorktreesByProject = useSessionUIStore.getState().availableWorktreesByProject;
-      const worktreesByProject = new Map(knownWorktreesByProject);
+      const knownPublishedWorktreesByProject = useSessionUIStore.getState().availableWorktreesByProject;
+      const seededRawScope = ensureRawWorktreesByProjectScope({
+        rawWorktreesByProjectRef,
+        publishedWorktreesByProject: knownPublishedWorktreesByProject,
+        runtimeKey: discoveryRuntimeKey,
+      });
+      const capturedRawRevision = seededRawScope.revision;
+      const worktreesByProject = new Map(seededRawScope.worktreesByProject);
       const unresolvedProjectPaths = new Set<string>();
 
       // Constrain fanout: previously `Promise.all(projects.map(...))` could
@@ -258,18 +282,26 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
           worktreesByProject.delete(projectPath);
         }
       }
-      const partitionedWorktreesByProject = partitionWorktreesByRegisteredProject(projectEntries, worktreesByProject);
-      const allWorktrees = [...partitionedWorktreesByProject.values()].flat();
-      // Newly appearing worktrees sort to the top of their project's
-      // worktree list (see worktreeFirstSeen.ts).
-      recordWorktreesSeen(allWorktrees.map((worktree) => worktree.path), Date.now());
-
-      // Skip update if nothing changed — see worktreeMapsEqual JSDoc.
-      if (!worktreeMapsEqual(partitionedWorktreesByProject, knownWorktreesByProject)) {
-        useSessionUIStore.setState({
-          availableWorktrees: allWorktrees,
-          availableWorktreesByProject: partitionedWorktreesByProject,
-        });
+      const committed = commitDiscoveredRawWorktreesByProject({
+        rawWorktreesByProjectRef,
+        runtimeKey: discoveryRuntimeKey,
+        capturedRevision: capturedRawRevision,
+        nextRawWorktreesByProject: worktreesByProject,
+        publishedWorktreesByProject: knownPublishedWorktreesByProject,
+        partitionWorktreesByRegisteredProject,
+        projects: projectEntries,
+        worktreeMapsEqual,
+        recordWorktreesSeen,
+        publishTopology: (next) => {
+          useSessionUIStore.setState(next);
+        },
+        requestRediscovery: () => {
+          requestWorktreeDiscovery();
+        },
+        now: () => Date.now(),
+      });
+      if (!committed) {
+        return;
       }
       setUnresolvedWorktreeProjectPaths(unresolvedProjectPaths);
       setResolvedWorktreeTopologyKey(projectWorktreeDiscoveryKey);
@@ -367,7 +399,6 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
   }, []);
 
 
-
   const normalizedProjects = React.useMemo(() => {
     return projects.flatMap((project) => {
       const normalizedPath = normalizePath(project.path);
@@ -527,6 +558,29 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
     openMultiRunLauncher();
   }, [mobileVariant, openMultiRunLauncher, setSessionSwitcherOpen]);
 
+  const handleSessionWorktreeMenuLoad = React.useCallback((args: StartSessionWorktreeMenuLoadArgs) => {
+    const resolvedProject = args.projectId
+      ? (projects.find((candidate) => candidate.id === args.projectId) ?? null)
+      : (args.sourceDirectory ? resolveProjectRef(args.sourceDirectory) : null);
+    return startSessionWorktreeMenuLoad(args, {
+      projects,
+      getCurrentProjects: () => useProjectsStore.getState().projects,
+      rawWorktreesByProjectRef,
+      getPublishedWorktreesByProject: () => useSessionUIStore.getState().availableWorktreesByProject,
+      resolveProject: (directory) => resolveProjectRef(directory),
+      listProjectWorktrees,
+      partitionWorktreesByRegisteredProject,
+      worktreeMapsEqual,
+      recordWorktreesSeen,
+      publishTopology: (next) => {
+        useSessionUIStore.setState(next);
+      },
+      getRuntimeKey,
+      now: () => Date.now(),
+      projectRootBranch: resolvedProject ? (projectRootBranches.get(resolvedProject.id) ?? null) : null,
+    });
+  }, [projectRootBranches, projects]);
+
   const handleOpenNewSessionDraftFromHeader = React.useCallback(() => {
     useUIStore.getState().closeMainSurfaces();
     if (mobileVariant) {
@@ -637,6 +691,7 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
           openProjectEditDialog: setEditingProjectDialogId,
           removeProject,
           reorderProjects,
+          startSessionWorktreeMenuLoad: handleSessionWorktreeMenuLoad,
           initialActiveSessionByProject,
           persistActiveSessionByProject,
           projectViewActions: projectView.actions,

packages/ui/src/components/session/sidebar/DOCUMENTATION.md

@@ -11,6 +11,21 @@ kept at this root in `types.ts` and `utils.tsx`.
 - `sessions/` owns session rows, row actions, expansion, ownership, and activity indicators.
 - `recent/` owns Recent and managed Chats activity projections.
 - `folders/` owns folder DnD, bulk actions, archived folders, and folder UI.
+- Root session right-click and overflow menus expose `Move to worktree`: a submenu
+  listing the canonical primary and linked worktree destinations, with the current
+  target disabled and a separate `New worktree...` action. Opening the submenu
+  refreshes the worktree topology. Moving transfers the full idle subtree. Clean
+  and non-Git sources move session-only; a dirty Git source prompts to move only
+  the session, move all source changes, or cancel. Descendants move first without
+  changes and roll back session-only if a later descendant fails. The root moves
+  last and carries source changes once, which prevents rollback from replaying the
+  transferred patch into the source.
+- Failure cleanup: a worktree created for the move is removed only after a
+  definite failure. When the change-carrying request fails without confirming
+  its outcome, that worktree is KEPT (it may hold the only copy of the user's
+  changes), both directories are refreshed authoritatively because the session
+  may have moved server-side, and the toast points the user at the destination.
+  Existing destinations are never removed; they get the same guidance.
 
 `MainLayout` and `VSCodeLayout` call `useSessionListSync({ isVSCode })`
 unconditionally. The hook publishes complete directory bootstrap demand,
@@ -27,11 +42,35 @@ existing data; it is never treated as an authoritative empty list.
 
 Web and desktop show managed Chats before optional Recent activity. Chats use
 their shared managed root for folders and never expose worktree actions. Project
-display can be all projects or one selected project. VS Code excludes worktrees
-and managed Chats, while retaining its workspace-scoped grouped list and inline
-archived buckets.
+display can be all projects or one selected project. The mobile sessions sheet
+(`apps/MobileSessionsSheet.tsx`) partitions the same way through
+`partitionSidebarSessions` and lists Chats as a collapsible section above the
+project tree, with no Recent projection. VS Code excludes worktrees and managed
+Chats, while retaining its workspace-scoped grouped list and inline archived
+buckets.
 
 Directory demand always includes known project roots and worktrees. Visibility
 only changes priority. Row mounts must not start bootstrap work. Selection and
 activity subscriptions stay session-scoped so a structural list update does not
 make every row observe unrelated streaming updates.
+
+## 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 do not trigger a rebuild. The separate lifecycle rank invalidates ordering only on `settled ↔ active` transitions, with root sessions ranked among roots and child sessions only among siblings of the same parent.
+- Opening the root-session `Move to worktree` submenu force-refreshes the owning project's worktree topology so externally created worktrees appear without a full reload. While that refresh runs, the menu keeps the last known primary/linked topology visible; if the refresh fails, the stale topology remains and the load failure state stays explicit. Failure cleanup never removes or manages an existing destination worktree.
+- CLI/server-created sessions use the low-frequency OpenChamber control event stream to refresh only the created session directory. The same event retriggers bounded worktree discovery so a newly created external worktree gains ownership without a view reload; it does not re-enable broad session or streaming subscriptions.
+- Recent membership includes active root sessions immediately even when their last committed `time.updated` falls outside the 48-hour window. Children and archived sessions remain excluded, and inactive roots remain timestamp-based. The active-ID subscription is disabled while the sidebar is hidden and ignores retry/status detail changes, avoiding streaming-frequency rerenders.
+- 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.
+- Directory permission failures remain visible even when stale sessions are retained. Flat groups inspect every represented root/worktree directory; local Desktop may open the native picker for the exact failed directory, while other runtimes keep the ordinary Retry action.
+- 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.

packages/ui/src/components/session/sidebar/SessionWorktreeMoveConfirmDialog.test.tsx

@@ -0,0 +1,107 @@
+import React from 'react';
+import { describe, expect, mock, test } from 'bun:test';
+import { renderToStaticMarkup } from 'react-dom/server';
+
+import { I18nProvider } from '@/lib/i18n';
+import type { Session } from '@opencode-ai/sdk/v2';
+import type {
+  SessionTreeMoveIntent,
+  SessionTreeMoveMessages,
+} from '@/lib/worktrees/sessionWorktreeMove';
+
+type MockDialogProps = React.PropsWithChildren<{
+  open?: boolean;
+  id?: string;
+  className?: string;
+}>;
+
+mock.module('@/components/ui/dialog', () => ({
+  Dialog: ({ children, open = true }: MockDialogProps) => (open ? <>{children}</> : null),
+  DialogContent: ({ children, id, className }: MockDialogProps) => (
+    <div id={id} className={className}>{children}</div>
+  ),
+  DialogDescription: ({ children }: MockDialogProps) => <p>{children}</p>,
+  DialogFooter: ({ children, className }: MockDialogProps) => <div className={className}>{children}</div>,
+  DialogHeader: ({ children }: MockDialogProps) => <div>{children}</div>,
+  DialogTitle: ({ children }: MockDialogProps) => <h2>{children}</h2>,
+}));
+
+const { SessionWorktreeMoveConfirmDialog } = await import('./SessionWorktreeMoveConfirmDialog');
+
+const makeMoveMessages = (): SessionTreeMoveMessages => ({
+  success: 'move succeeded',
+  failure: 'move failed',
+  sourceVerificationFailed: 'source verification failed',
+  applyChangesFailed: 'apply changes failed',
+  changesMayBeInDestination: 'changes may be in destination',
+});
+
+const makeExistingIntent = (): SessionTreeMoveIntent => ({
+  kind: 'existing',
+  root: {
+    id: 'root',
+    slug: 'root',
+    projectID: 'project-1',
+    directory: '/source',
+    title: 'Root session',
+    version: '1',
+    time: { created: 0, updated: 0 },
+  } satisfies Session,
+  descendants: [],
+  sourceDirectory: '/source',
+  destination: {
+    path: '/destination',
+    projectDirectory: '/repo',
+    branch: 'feature',
+    label: 'Destination',
+    worktreeStatus: 'ready',
+    worktreeSource: 'existing',
+  },
+  messages: makeMoveMessages(),
+});
+
+describe('SessionWorktreeMoveConfirmDialog', () => {
+  test('renders stable semantic hooks, dirty file count, and the staged warning', () => {
+    const markup = renderToStaticMarkup(
+      <I18nProvider>
+        <SessionWorktreeMoveConfirmDialog
+          value={{
+            intent: makeExistingIntent(),
+            dirtyFileCount: 2,
+            stagedFileCount: 1,
+          }}
+          onMoveSessionOnly={() => {}}
+          onMoveAllChanges={() => {}}
+          onCancel={() => {}}
+        />
+      </I18nProvider>,
+    );
+
+    expect(markup).toContain('id="session-worktree-move-confirm-dialog"');
+    expect(markup).toContain('data-session-worktree-move-action="session-only"');
+    expect(markup).toContain('data-session-worktree-move-action="all-changes"');
+    expect(markup).toContain('data-session-worktree-move-action="cancel"');
+    expect(markup).toContain('autofocus=""');
+    expect(markup).toContain('2');
+    expect(markup).toContain('data-session-worktree-move-staged-warning="true"');
+  });
+
+  test('omits the staged warning when no staged files are present', () => {
+    const markup = renderToStaticMarkup(
+      <I18nProvider>
+        <SessionWorktreeMoveConfirmDialog
+          value={{
+            intent: makeExistingIntent(),
+            dirtyFileCount: 3,
+            stagedFileCount: 0,
+          }}
+          onMoveSessionOnly={() => {}}
+          onMoveAllChanges={() => {}}
+          onCancel={() => {}}
+        />
+      </I18nProvider>,
+    );
+
+    expect(markup).not.toContain('data-session-worktree-move-staged-warning="true"');
+  });
+});

packages/ui/src/components/session/sidebar/SessionWorktreeMoveConfirmDialog.tsx

@@ -0,0 +1,81 @@
+import React from 'react';
+
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { useI18n } from '@/lib/i18n';
+import type { SessionTreeMoveConfirmation } from '@/lib/worktrees/sessionWorktreeMove';
+
+export type SessionWorktreeMoveConfirmDialogProps = {
+  value: SessionTreeMoveConfirmation | null;
+  onMoveSessionOnly: () => void;
+  onMoveAllChanges: () => void;
+  onCancel: () => void;
+};
+
+export function SessionWorktreeMoveConfirmDialog(props: SessionWorktreeMoveConfirmDialogProps): React.ReactNode {
+  const { t } = useI18n();
+  const { value, onMoveSessionOnly, onMoveAllChanges, onCancel } = props;
+
+  return (
+    <Dialog open={Boolean(value)} onOpenChange={(open) => { if (!open) onCancel(); }}>
+      <DialogContent
+        id="session-worktree-move-confirm-dialog"
+        showCloseButton={false}
+        className="max-w-md gap-5"
+      >
+        <DialogHeader>
+          <DialogTitle>{t('sessions.sidebar.session.moveToWorktree.confirm.title')}</DialogTitle>
+          <DialogDescription>
+            {t('sessions.sidebar.session.moveToWorktree.confirm.changedFiles', {
+              count: value?.dirtyFileCount ?? 0,
+            })}{' '}
+            {t('sessions.sidebar.session.moveToWorktree.confirm.ownership')}
+          </DialogDescription>
+        </DialogHeader>
+        <div className="space-y-2 typography-ui-label text-muted-foreground">
+          <p>{t('sessions.sidebar.session.moveToWorktree.confirm.sessionOnlyHelp')}</p>
+          <p>{t('sessions.sidebar.session.moveToWorktree.confirm.allChangesHelp')}</p>
+          {value && value.stagedFileCount > 0 ? (
+            <p data-session-worktree-move-staged-warning="true">
+              {t('sessions.sidebar.session.moveToWorktree.confirm.stagedWarning')}
+            </p>
+          ) : null}
+          <p>{t('sessions.sidebar.session.moveToWorktree.confirm.baseWarning')}</p>
+        </div>
+        <DialogFooter className="gap-2 sm:justify-end">
+          <Button
+            type="button"
+            variant="neutral"
+            data-session-worktree-move-action="cancel"
+            onClick={onCancel}
+          >
+            {t('sessions.sidebar.session.moveToWorktree.confirm.cancel')}
+          </Button>
+          <Button
+            type="button"
+            variant="outline"
+            data-session-worktree-move-action="all-changes"
+            onClick={onMoveAllChanges}
+          >
+            {t('sessions.sidebar.session.moveToWorktree.confirm.allChanges')}
+          </Button>
+          <Button
+            type="button"
+            autoFocus
+            data-session-worktree-move-action="session-only"
+            onClick={onMoveSessionOnly}
+          >
+            {t('sessions.sidebar.session.moveToWorktree.confirm.sessionOnly')}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

packages/ui/src/components/session/sidebar/list/SessionProjectCollection.tsx

@@ -6,6 +6,7 @@ import { useUIStore } from '@/stores/useUIStore';
 import { useGitHubAuthStore } from '@/stores/useGitHubAuthStore';
 import { getGitHubPrStatusKey, useGitHubPrStatusStore } from '@/stores/useGitHubPrStatusStore';
 import { useRuntimeAPIs } from '@/hooks/useRuntimeAPIs';
+import type { SessionTreeItemProps } from '../sessions/SessionTreeItem';
 import { useArchivedAutoFolders } from '../folders/useArchivedAutoFolders';
 import { ProjectSessionSelectionEffect } from '../projects/useProjectSessionSelection';
 import type { WorktreeMetadata } from '@/types/worktree';
@@ -103,6 +104,7 @@ type SessionProjectCollectionProps = {
     openProjectEditDialog: (id: string) => void;
     removeProject: (id: string) => void;
     reorderProjects: (fromIndex: number, toIndex: number) => void;
+    startSessionWorktreeMenuLoad: SessionTreeItemProps['startSessionWorktreeMenuLoad'];
     renderProjectStatusIndicator?: (projectId: string, groups: SessionGroup[]) => React.ReactNode;
     initialActiveSessionByProject: Map<string, string>;
     persistActiveSessionByProject: (value: Map<string, string>) => void;
@@ -330,6 +332,7 @@ const VisibleSessionProjects: React.FC<SessionProjectCollectionProps> = ({ topol
     setDeleteSessionConfirm,
     startFolderRename,
     setCopiedSessionId,
+    startSessionWorktreeMenuLoad: actions.startSessionWorktreeMenuLoad,
     folderRename,
     setFolderRenameDraft,
     clearFolderRename,
@@ -350,6 +353,7 @@ const VisibleSessionProjects: React.FC<SessionProjectCollectionProps> = ({ topol
     deleteSessionConfirm,
     copiedSessionId,
     setCopiedSessionId,
+    actions.startSessionWorktreeMenuLoad,
     rowActions,
     toggleParent,
     view.hideDirectoryControls,
@@ -457,12 +461,14 @@ const VisibleSessionProjects: React.FC<SessionProjectCollectionProps> = ({ topol
       setDeleteSessionConfirm={setDeleteSessionConfirm}
       startFolderRename={startFolderRename}
       setCopiedSessionId={setCopiedSessionId}
+      startSessionWorktreeMenuLoad={actions.startSessionWorktreeMenuLoad}
       chatSessions={collection.chatSessions}
       renderChatsSection={renderChatsSection}
       onNewChat={handleOpenNewChat}
       showRecentSection={showRecentSection && !singleProjectMode}
     /> : null
   ), [
+    actions.startSessionWorktreeMenuLoad,
     alwaysShowActions,
     collection.childrenMap,
     collection.pinnedSessionIds,

packages/ui/src/components/session/sidebar/projects/SessionGroupSection.behavior.test.tsx

@@ -138,6 +138,10 @@ const createProps = (): SessionGroupSectionProps => ({
   deleteSessionConfirm: null,
   setDeleteSessionConfirm: () => undefined,
   setCopiedSessionId: () => undefined,
+  startSessionWorktreeMenuLoad: () => ({
+    cachedTargets: [],
+    refreshTargets: Promise.resolve([]),
+  }),
   onToggleCollapsedGroup: () => undefined,
   folderRename: null,
   setFolderRenameDraft: () => undefined,

packages/ui/src/components/session/sidebar/projects/SessionGroupSection.tsx

@@ -108,6 +108,7 @@ export type SessionGroupSectionProps = {
   | 'setDeleteSessionConfirm'
   | 'startFolderRename'
   | 'setCopiedSessionId'
+  | 'startSessionWorktreeMenuLoad'
 >;
 
 const CollapsedFolderActivity: React.FC<{
@@ -253,6 +254,7 @@ const areGroupPropsEqual = (prev: SessionGroupSectionProps, next: SessionGroupSe
     && prev.setDeleteSessionConfirm === next.setDeleteSessionConfirm
     && prev.startFolderRename === next.startFolderRename
     && prev.setCopiedSessionId === next.setCopiedSessionId
+    && prev.startSessionWorktreeMenuLoad === next.startSessionWorktreeMenuLoad
     && prev.setFolderRenameDraft === next.setFolderRenameDraft
     && prev.clearFolderRename === next.clearFolderRename
   );
@@ -852,10 +854,11 @@ function SessionGroupSectionBase(props: SessionGroupSectionProps): React.ReactNo
                setSessionSearchQuery={props.setSessionSearchQuery}
                setIsSessionSearchOpen={props.setIsSessionSearchOpen}
                deleteSessionConfirm={props.deleteSessionConfirm}
-               setDeleteSessionConfirm={props.setDeleteSessionConfirm}
-               startFolderRename={props.startFolderRename}
-               setCopiedSessionId={props.setCopiedSessionId}
-            />)}
+              setDeleteSessionConfirm={props.setDeleteSessionConfirm}
+              startFolderRename={props.startFolderRename}
+              setCopiedSessionId={props.setCopiedSessionId}
+              startSessionWorktreeMenuLoad={props.startSessionWorktreeMenuLoad}
+             />)}
           </SessionFolderItem>
         )}
       </DroppableFolderWrapper>
@@ -962,7 +965,8 @@ function SessionGroupSectionBase(props: SessionGroupSectionProps): React.ReactNo
      setDeleteSessionConfirm={props.setDeleteSessionConfirm}
      startFolderRename={props.startFolderRename}
      setCopiedSessionId={props.setCopiedSessionId}
-  />;
+     startSessionWorktreeMenuLoad={props.startSessionWorktreeMenuLoad}
+   />;
 
   const body = (
     <SessionFolderDndScope

packages/ui/src/components/session/sidebar/projects/SessionProjectScroller.tsx

@@ -58,6 +58,7 @@ type SessionProjectScrollerGroupProps = Pick<SessionGroupSectionProps,
   | 'setDeleteSessionConfirm'
   | 'startFolderRename'
   | 'setCopiedSessionId'
+  | 'startSessionWorktreeMenuLoad'
 > & {
   pinnedSessionIds: Set<string>;
   sessionOrderIndex: Map<string, number>;

packages/ui/src/components/session/sidebar/recent/RecentSessionSection.tsx

@@ -49,6 +49,7 @@ type Props = {
   | 'setDeleteSessionConfirm'
   | 'startFolderRename'
   | 'setCopiedSessionId'
+  | 'startSessionWorktreeMenuLoad'
 >;
 
 export const RecentSessionSection: React.FC<Props> = (props) => {
@@ -162,6 +163,7 @@ export const RecentSessionSection: React.FC<Props> = (props) => {
       setDeleteSessionConfirm={props.setDeleteSessionConfirm}
       startFolderRename={props.startFolderRename}
       setCopiedSessionId={props.setCopiedSessionId}
+      startSessionWorktreeMenuLoad={props.startSessionWorktreeMenuLoad}
     />
   );
 };

packages/ui/src/components/session/sidebar/recent/SidebarActivitySections.tsx

@@ -63,6 +63,7 @@ type Props = {
   | 'setDeleteSessionConfirm'
   | 'startFolderRename'
   | 'setCopiedSessionId'
+  | 'startSessionWorktreeMenuLoad'
 >;
 
 type RenderExtras = SessionNodeRenderExtras;
@@ -198,6 +199,7 @@ export function SidebarActivitySections(props: Props): React.ReactNode {
             setDeleteSessionConfirm={props.setDeleteSessionConfirm}
             startFolderRename={props.startFolderRename}
             setCopiedSessionId={props.setCopiedSessionId}
+            startSessionWorktreeMenuLoad={props.startSessionWorktreeMenuLoad}
           />
         );
 

packages/ui/src/components/session/sidebar/sessionWorktreeMenu.test.ts

@@ -0,0 +1,549 @@
+import { describe, expect, test } from 'bun:test';
+import type { WorktreeMetadata } from '@/types/worktree';
+import {
+  buildSessionWorktreeMenuTargets,
+  commitDiscoveredRawWorktreesByProject,
+  getSessionWorktreeMenuState,
+  markRawWorktreesByProjectMutation,
+  startSessionWorktreeMenuLoad,
+} from './sessionWorktreeMenu';
+
+const rawScope = (runtimeKey: string | null, entries: Array<[string, WorktreeMetadata[]]>) => ({
+  current: {
+    runtimeKey,
+    revision: 0,
+    worktreesByProject: new Map<string, WorktreeMetadata[]>(entries),
+  },
+});
+
+const worktree = (overrides: Partial<WorktreeMetadata> = {}): WorktreeMetadata => ({
+  path: '/repo-feature',
+  projectDirectory: '/repo',
+  branch: 'feature',
+  label: 'feature',
+  name: 'feature',
+  worktreeStatus: 'ready',
+  worktreeSource: 'existing',
+  ...overrides,
+});
+
+const createDeferred = <T>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+};
+
+describe('buildSessionWorktreeMenuTargets', () => {
+  test('adds the canonical main worktree, includes the current source, dedupes by path, and sorts linked targets', () => {
+    const targets = buildSessionWorktreeMenuTargets({
+      projectPath: '/repo-linked',
+      discoveredWorktrees: [
+        worktree({ path: '/repo-zebra', branch: 'zebra', label: 'zebra', name: 'zebra' }),
+        worktree({ path: '/repo-alpha', branch: 'alpha', label: 'alpha', name: 'alpha' }),
+        worktree({ path: '/repo-current', branch: 'current', label: 'current', name: 'current' }),
+        worktree({ path: '/repo-alpha/', branch: 'alpha', label: 'alpha duplicate', name: 'alpha-duplicate' }),
+      ],
+      sourceDirectory: '/repo-current/',
+      currentWorktree: worktree({
+        path: '/repo-current',
+        projectDirectory: '/repo',
+        branch: 'current',
+        label: 'Current branch',
+      }),
+    });
+
+    expect(targets.map((target) => ({
+      path: target.metadata.path,
+      isPrimary: target.isPrimary,
+      isCurrent: target.isCurrent,
+    }))).toEqual([
+      { path: '/repo', isPrimary: true, isCurrent: false },
+      { path: '/repo-alpha', isPrimary: false, isCurrent: false },
+      { path: '/repo-current', isPrimary: false, isCurrent: true },
+      { path: '/repo-zebra', isPrimary: false, isCurrent: false },
+    ]);
+    expect(targets[0]?.metadata.worktreeStatus).toBe('ready');
+    expect(targets[0]?.metadata.worktreeSource).toBe('existing');
+  });
+
+  test('prefers discovered primary metadata instead of synthetic fallback metadata', () => {
+    const targets = buildSessionWorktreeMenuTargets({
+      projectPath: '/repo-linked',
+      discoveredWorktrees: [
+        worktree({
+          path: '/repo',
+          projectDirectory: '/repo',
+          branch: 'main',
+          label: 'main',
+          name: 'repo-primary',
+          headState: 'branch',
+        }),
+      ],
+      sourceDirectory: '/repo-linked',
+      currentWorktree: worktree({
+        path: '/repo-linked',
+        projectDirectory: '/repo',
+        branch: 'feature',
+        label: 'feature',
+      }),
+    });
+
+    expect(targets[0]?.isPrimary).toBe(true);
+    expect(targets[0]?.metadata.path).toBe('/repo');
+    expect(targets[0]?.metadata.branch).toBe('main');
+    expect(targets[0]?.metadata.label).toBe('main');
+    expect(targets[0]?.metadata.name).toBe('repo-primary');
+    expect(targets[0]?.metadata.headState).toBe('branch');
+  });
+
+  test('sorts linked targets by effective compact label when branch is missing', () => {
+    const targets = buildSessionWorktreeMenuTargets({
+      projectPath: '/repo',
+      discoveredWorktrees: [
+        worktree({ path: '/repo-zed', branch: '', label: '', name: 'zed' }),
+        worktree({ path: '/repo-alpha', branch: '', label: '', name: 'alpha' }),
+        worktree({ path: '/repo-beta', branch: 'beta', label: 'beta', name: 'beta' }),
+      ],
+      sourceDirectory: '/repo-current',
+      currentWorktree: worktree({ path: '/repo-current', projectDirectory: '/repo', branch: '', label: '', name: 'current' }),
+    });
+
+    expect(targets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-alpha',
+      '/repo-beta',
+      '/repo-current',
+      '/repo-zed',
+    ]);
+  });
+
+  test('uses the owning project root branch for a synthetic primary when git omits the queried checkout', () => {
+    const targets = buildSessionWorktreeMenuTargets({
+      projectPath: '/repo',
+      discoveredWorktrees: [
+        worktree({ path: '/repo-feature', projectDirectory: '/repo', branch: 'feature', label: 'feature' }),
+      ],
+      sourceDirectory: '/repo-feature',
+      currentWorktree: worktree({ path: '/repo-feature', projectDirectory: '/repo', branch: 'feature', label: 'feature' }),
+      projectRootBranch: 'main',
+    });
+
+    expect(targets[0]?.isPrimary).toBe(true);
+    expect(targets[0]?.metadata.path).toBe('/repo');
+    expect(targets[0]?.metadata.branch).toBe('main');
+    expect(targets[0]?.metadata.label).toBe('main');
+    expect(targets[0]?.metadata.headState).toBe('branch');
+  });
+});
+
+describe('commitDiscoveredRawWorktreesByProject', () => {
+  test('rejects an older aggregate commit after a newer targeted mutation and requests one bounded rediscovery', () => {
+    const rawRef = rawScope('runtime-1', [
+      ['/repo', [worktree({ path: '/repo-old', projectDirectory: '/repo', branch: 'old', label: 'old' })]],
+    ]);
+    const reruns: string[] = [];
+    const published: Array<unknown> = [];
+    const capturedRevision = rawRef.current.revision;
+
+    markRawWorktreesByProjectMutation(rawRef, 'runtime-1');
+
+    const committed = commitDiscoveredRawWorktreesByProject({
+      rawWorktreesByProjectRef: rawRef,
+      runtimeKey: 'runtime-1',
+      capturedRevision,
+      nextRawWorktreesByProject: new Map([
+        ['/repo', [worktree({ path: '/repo-stale', projectDirectory: '/repo', branch: 'stale', label: 'stale' })]],
+      ]),
+      publishedWorktreesByProject: new Map(),
+      partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+      projects: [{ id: 'owner', path: '/repo' }],
+      worktreeMapsEqual: () => false,
+      recordWorktreesSeen: () => {},
+      publishTopology: (next) => {
+        published.push(next);
+      },
+      requestRediscovery: () => {
+        reruns.push('rerun');
+      },
+      now: () => 123,
+    });
+
+    expect(committed).toBe(false);
+    expect(reruns).toEqual(['rerun']);
+    expect(rawRef.current.worktreesByProject.get('/repo')?.map((entry) => entry.path)).toEqual(['/repo-old']);
+    expect(published).toEqual([]);
+  });
+});
+
+describe('startSessionWorktreeMenuLoad', () => {
+  test('returns cached targets immediately, forces only the owning project refresh, and publishes refreshed topology', async () => {
+    const calls: Array<{ projectId: string; force: boolean }> = [];
+    const published: Array<{ availableWorktrees: WorktreeMetadata[]; availableWorktreesByProject: Map<string, WorktreeMetadata[]> }> = [];
+    const rawRef = rawScope('runtime-1', [
+        ['/repo-linked', [worktree({ path: '/repo-existing', branch: 'existing', label: 'existing', name: 'existing' })]],
+        ['/repo-other', [worktree({ path: '/other-worktree', projectDirectory: '/repo-other', branch: 'other', label: 'other', name: 'other' })]],
+      ]);
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-current',
+        currentWorktree: worktree({ path: '/repo-current', branch: 'current', label: 'current' }),
+      },
+      {
+        projects: [
+          { id: 'linked', path: '/repo-linked' },
+          { id: 'other', path: '/repo-other' },
+        ],
+        getCurrentProjects: () => [
+          { id: 'linked', path: '/repo-linked' },
+          { id: 'other', path: '/repo-other' },
+        ],
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => new Map(),
+        resolveProject: () => null,
+        listProjectWorktrees: async (project, options) => {
+          calls.push({ projectId: project.id, force: options.force });
+          return [
+            worktree({ path: '/repo-new', branch: 'aaa', label: 'aaa', name: 'aaa' }),
+            worktree({ path: '/repo-current', branch: 'current', label: 'current', name: 'current' }),
+          ];
+        },
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: (next) => {
+          published.push(next);
+        },
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    expect(load.cachedTargets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-current',
+      '/repo-existing',
+    ]);
+
+    const freshTargets = await load.refreshTargets;
+
+    expect(calls).toEqual([{ projectId: 'linked', force: true }]);
+    expect(freshTargets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-new',
+      '/repo-current',
+    ]);
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')?.map((entry) => entry.path)).toEqual([
+      '/repo-new',
+      '/repo-current',
+    ]);
+    expect(published).toHaveLength(1);
+    expect(published[0]?.availableWorktreesByProject.get('/repo-linked')?.map((entry) => entry.path)).toEqual([
+      '/repo-new',
+      '/repo-current',
+    ]);
+  });
+
+  test('rejects refresh failures without mutating topology and keeps cached targets available for the menu', async () => {
+    const published: Array<unknown> = [];
+    const existing = worktree({ path: '/repo-existing', branch: 'existing', label: 'existing', name: 'existing' });
+    const rawRef = rawScope('runtime-1', [
+        ['/repo-linked', [existing]],
+      ]);
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-current',
+        currentWorktree: worktree({ path: '/repo-current', branch: 'current', label: 'current' }),
+      },
+      {
+        projects: [{ id: 'linked', path: '/repo-linked' }],
+        getCurrentProjects: () => [{ id: 'linked', path: '/repo-linked' }],
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => new Map([['/repo-linked', [existing]]]),
+        resolveProject: () => null,
+        listProjectWorktrees: async () => {
+          throw new Error('git failed');
+        },
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: (next) => {
+          published.push(next);
+        },
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    expect(load.cachedTargets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-current',
+      '/repo-existing',
+    ]);
+    const refreshError = await load.refreshTargets.catch((error) => error);
+    expect(refreshError).toBeInstanceOf(Error);
+    expect(refreshError.message).toBe('git failed');
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')).toEqual([existing]);
+    expect(published).toEqual([]);
+  });
+
+  test('seeds an empty raw scope from published topology so a failed first refresh preserves prior topology', async () => {
+    const publishedTopology = new Map<string, WorktreeMetadata[]>([
+      ['/repo-linked', [worktree({ path: '/repo-existing', branch: 'existing', label: 'existing', name: 'existing' })]],
+    ]);
+    const rawRef = rawScope(null, []);
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-current',
+        currentWorktree: worktree({ path: '/repo-current', branch: 'current', label: 'current' }),
+      },
+      {
+        projects: [{ id: 'linked', path: '/repo-linked' }],
+        getCurrentProjects: () => [{ id: 'linked', path: '/repo-linked' }],
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => publishedTopology,
+        resolveProject: () => null,
+        listProjectWorktrees: async () => {
+          throw new Error('git failed');
+        },
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => true,
+        recordWorktreesSeen: () => {},
+        publishTopology: () => {
+          throw new Error('should not publish on failed refresh');
+        },
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    expect(load.cachedTargets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-current',
+      '/repo-existing',
+    ]);
+    const refreshError = await load.refreshTargets.catch((error) => error);
+    expect(refreshError).toBeInstanceOf(Error);
+    expect(refreshError.message).toBe('git failed');
+    expect(rawRef.current.runtimeKey).toBe('runtime-1');
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')?.map((entry) => entry.path)).toEqual(['/repo-existing']);
+  });
+
+  test('applies a non-owner shared-repository refresh to the owner raw and published topology', async () => {
+    const published: Array<{ availableWorktreesByProject: Map<string, WorktreeMetadata[]> }> = [];
+    const ownerExisting = worktree({ path: '/repo-old', branch: 'old', label: 'old', name: 'old' });
+    const rawRef = rawScope('runtime-1', [
+      ['/repo', [ownerExisting]],
+      ['/repo-linked', [worktree({ path: '/repo-other-stale', branch: 'stale', label: 'stale', name: 'stale' })]],
+    ]);
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-linked',
+        currentWorktree: worktree({ path: '/repo-linked', projectDirectory: '/repo', branch: 'feature', label: 'feature' }),
+      },
+      {
+        projects: [
+          { id: 'owner', path: '/repo' },
+          { id: 'linked', path: '/repo-linked' },
+        ],
+        getCurrentProjects: () => [
+          { id: 'owner', path: '/repo' },
+          { id: 'linked', path: '/repo-linked' },
+        ],
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => new Map([['/repo', [ownerExisting]]]),
+        resolveProject: () => null,
+        listProjectWorktrees: async () => [
+          worktree({ path: '/repo-new', projectDirectory: '/repo', branch: 'new', label: 'new', name: 'new' }),
+        ],
+        partitionWorktreesByRegisteredProject: (projects, worktreesByProject) => {
+          const ownerPath = projects[0]!.path;
+          return new Map([[ownerPath, worktreesByProject.get(ownerPath) ?? []]]);
+        },
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: (next) => {
+          published.push({ availableWorktreesByProject: next.availableWorktreesByProject });
+        },
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    await load.refreshTargets;
+
+    expect(rawRef.current.worktreesByProject.get('/repo')?.map((entry) => entry.path)).toEqual(['/repo-new']);
+    expect(published[0]?.availableWorktreesByProject.get('/repo')?.map((entry) => entry.path)).toEqual(['/repo-new']);
+  });
+
+  test('re-seeds raw topology on runtime change and ignores stale completions', async () => {
+    let runtimeKey = 'runtime-2';
+    const refreshDeferred = createDeferred<WorktreeMetadata[]>();
+    const published: Array<unknown> = [];
+    const rawRef = rawScope('runtime-1', [
+      ['/old-runtime-repo', [worktree({ path: '/old-runtime-worktree', projectDirectory: '/old-runtime-repo' })]],
+    ]);
+    const publishedCurrentRuntime = new Map<string, WorktreeMetadata[]>([
+      ['/repo-linked', [worktree({ path: '/repo-existing', branch: 'existing', label: 'existing', name: 'existing' })]],
+    ]);
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-current',
+        currentWorktree: worktree({ path: '/repo-current', branch: 'current', label: 'current' }),
+      },
+      {
+        projects: [{ id: 'linked', path: '/repo-linked' }],
+        getCurrentProjects: () => [{ id: 'linked', path: '/repo-linked' }],
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => publishedCurrentRuntime,
+        resolveProject: () => null,
+        listProjectWorktrees: async () => refreshDeferred.promise,
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: (next) => {
+          published.push(next);
+        },
+        getRuntimeKey: () => runtimeKey,
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    expect(load.cachedTargets.map((target) => target.metadata.path)).toEqual([
+      '/repo',
+      '/repo-current',
+      '/repo-existing',
+    ]);
+    expect(rawRef.current.runtimeKey).toBe('runtime-2');
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')?.map((entry) => entry.path)).toEqual(['/repo-existing']);
+
+    runtimeKey = 'runtime-3';
+    refreshDeferred.resolve([worktree({ path: '/repo-new', projectDirectory: '/repo', branch: 'new', label: 'new', name: 'new' })]);
+
+    const refreshError = await load.refreshTargets.catch((error) => error);
+    expect(refreshError).toBeInstanceOf(Error);
+    expect(refreshError.message).toBe('Runtime changed during worktree refresh');
+    expect(rawRef.current.runtimeKey).toBe('runtime-2');
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')?.map((entry) => entry.path)).toEqual(['/repo-existing']);
+    expect(published).toEqual([]);
+  });
+
+  test('rejects a deferred refresh when the owning project is removed before commit', async () => {
+    const refreshDeferred = createDeferred<WorktreeMetadata[]>();
+    const existing = worktree({ path: '/repo-existing', branch: 'existing', label: 'existing', name: 'existing' });
+    const published: Array<{ availableWorktreesByProject: Map<string, WorktreeMetadata[]> }> = [];
+    const rawRef = rawScope('runtime-1', [
+      ['/repo-linked', [existing]],
+    ]);
+    let currentProjects = [{ id: 'linked', path: '/repo-linked' }];
+
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: 'linked',
+        sourceDirectory: '/repo-current',
+        currentWorktree: worktree({ path: '/repo-current', branch: 'current', label: 'current' }),
+      },
+      {
+        projects: currentProjects,
+        rawWorktreesByProjectRef: rawRef,
+        getPublishedWorktreesByProject: () => new Map([['/repo-linked', [existing]]]),
+        resolveProject: () => null,
+        listProjectWorktrees: async () => refreshDeferred.promise,
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: (next) => {
+          published.push({ availableWorktreesByProject: next.availableWorktreesByProject });
+        },
+        getCurrentProjects: () => currentProjects,
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: null,
+      },
+    );
+
+    currentProjects = [];
+    refreshDeferred.resolve([
+      worktree({ path: '/repo-new', projectDirectory: '/repo', branch: 'new', label: 'new', name: 'new' }),
+    ]);
+
+    const refreshError = await load.refreshTargets.catch((error) => error);
+
+    expect(refreshError).toBeInstanceOf(Error);
+    expect(refreshError.message).toBe('Project removed during worktree refresh');
+    expect(rawRef.current.worktreesByProject.get('/repo-linked')).toEqual([existing]);
+    expect(published).toEqual([]);
+  });
+
+  test('falls back to resolving the owning configured project from the source directory when projectId is missing', async () => {
+    const calls: string[] = [];
+    const load = startSessionWorktreeMenuLoad(
+      {
+        projectId: null,
+        sourceDirectory: '/repo-feature',
+        currentWorktree: worktree({ path: '/repo-feature', projectDirectory: '/repo', branch: 'feature', label: 'feature' }),
+      },
+      {
+        projects: [{ id: 'owner', path: '/repo' }],
+        getCurrentProjects: () => [{ id: 'owner', path: '/repo' }],
+        rawWorktreesByProjectRef: rawScope('runtime-1', []),
+        getPublishedWorktreesByProject: () => new Map(),
+        resolveProject: (directory) => {
+          calls.push(directory);
+          return { id: 'owner', path: '/repo' };
+        },
+        listProjectWorktrees: async (project) => [
+          worktree({ path: '/repo-another', projectDirectory: project.path, branch: 'another', label: 'another', name: 'another' }),
+        ],
+        partitionWorktreesByRegisteredProject: (_projects, worktreesByProject) => new Map(worktreesByProject),
+        worktreeMapsEqual: () => false,
+        recordWorktreesSeen: () => {},
+        publishTopology: () => {},
+        getRuntimeKey: () => 'runtime-1',
+        now: () => 123,
+        projectRootBranch: 'main',
+      },
+    );
+
+    expect(calls).toEqual(['/repo-feature']);
+    expect(load.cachedTargets.map((target) => target.metadata.path)).toEqual(['/repo', '/repo-feature']);
+    const refreshTargets = await load.refreshTargets;
+    expect(refreshTargets.map((target) => ({
+      path: target.metadata.path,
+      branch: target.metadata.branch,
+    }))).toEqual([
+      { path: '/repo', branch: 'main' },
+      { path: '/repo-another', branch: 'another' },
+      { path: '/repo-feature', branch: 'feature' },
+    ]);
+  });
+});
+
+describe('getSessionWorktreeMenuState', () => {
+  test('keeps the new worktree action available when refresh fails without cached targets', () => {
+    expect(getSessionWorktreeMenuState({
+      targets: [],
+      isRefreshing: false,
+      loadFailed: true,
+    })).toEqual({
+      refreshState: 'error',
+      showNewWorktreeAction: true,
+    });
+  });
+});

packages/ui/src/components/session/sidebar/sessionWorktreeMenu.ts

@@ -0,0 +1,409 @@
+import type { ProjectRef } from '@/lib/worktrees/worktreeManager';
+import type { WorktreeMetadata } from '@/types/worktree';
+import { normalizePath } from '@/lib/pathNormalization';
+
+export type SessionWorktreeMenuTarget = {
+  metadata: WorktreeMetadata;
+  isPrimary: boolean;
+  isCurrent: boolean;
+};
+
+export type StartSessionWorktreeMenuLoadArgs = {
+  projectId: string | null;
+  sourceDirectory: string | null;
+  currentWorktree: WorktreeMetadata | null;
+};
+
+export type StartSessionWorktreeMenuLoadResult = {
+  cachedTargets: SessionWorktreeMenuTarget[];
+  refreshTargets: Promise<SessionWorktreeMenuTarget[]>;
+};
+
+type SessionWorktreeMenuState = {
+  refreshState: 'loading' | 'error' | null;
+  showNewWorktreeAction: boolean;
+};
+
+type StartSessionWorktreeMenuLoadDependencies = {
+  projects: ReadonlyArray<ProjectRef>;
+  getCurrentProjects: () => ReadonlyArray<ProjectRef>;
+  rawWorktreesByProjectRef: { current: RawWorktreesByProjectScope };
+  getPublishedWorktreesByProject: () => Map<string, WorktreeMetadata[]>;
+  resolveProject: (directory: string) => ProjectRef | null;
+  listProjectWorktrees: (project: ProjectRef, options: { force: true }) => Promise<WorktreeMetadata[]>;
+  partitionWorktreesByRegisteredProject: (
+    projects: ReadonlyArray<Pick<ProjectRef, 'path'>>,
+    worktreesByProject: ReadonlyMap<string, WorktreeMetadata[]>,
+  ) => Map<string, WorktreeMetadata[]>;
+  worktreeMapsEqual: (
+    a: Map<string, WorktreeMetadata[]>,
+    b: Map<string, WorktreeMetadata[]>,
+  ) => boolean;
+  recordWorktreesSeen: (paths: Iterable<string | null | undefined>, seenAt: number) => void;
+  publishTopology: (next: {
+    availableWorktrees: WorktreeMetadata[];
+    availableWorktreesByProject: Map<string, WorktreeMetadata[]>;
+  }) => void;
+  getRuntimeKey: () => string;
+  now: () => number;
+  projectRootBranch: string | null;
+};
+
+type RequestRediscovery = () => void;
+
+export type RawWorktreesByProjectScope = {
+  runtimeKey: string | null;
+  revision: number;
+  worktreesByProject: Map<string, WorktreeMetadata[]>;
+};
+
+export const markRawWorktreesByProjectMutation = (
+  rawWorktreesByProjectRef: { current: RawWorktreesByProjectScope },
+  runtimeKey: string,
+): number => {
+  if (rawWorktreesByProjectRef.current.runtimeKey !== runtimeKey) {
+    return rawWorktreesByProjectRef.current.revision;
+  }
+  rawWorktreesByProjectRef.current = {
+    ...rawWorktreesByProjectRef.current,
+    revision: rawWorktreesByProjectRef.current.revision + 1,
+  };
+  return rawWorktreesByProjectRef.current.revision;
+};
+
+const cloneWorktreesByProject = (
+  worktreesByProject: ReadonlyMap<string, WorktreeMetadata[]>,
+): Map<string, WorktreeMetadata[]> => {
+  return new Map(
+    [...worktreesByProject.entries()].map(([projectPath, worktrees]) => [projectPath, worktrees.map((worktree) => cloneMetadata(worktree))]),
+  );
+};
+
+export const ensureRawWorktreesByProjectScope = (args: {
+  rawWorktreesByProjectRef: { current: RawWorktreesByProjectScope };
+  publishedWorktreesByProject: Map<string, WorktreeMetadata[]>;
+  runtimeKey: string;
+}): RawWorktreesByProjectScope => {
+  const shouldReseed = args.rawWorktreesByProjectRef.current.runtimeKey !== args.runtimeKey
+    || (args.rawWorktreesByProjectRef.current.worktreesByProject.size === 0 && args.publishedWorktreesByProject.size > 0);
+
+  if (shouldReseed) {
+    args.rawWorktreesByProjectRef.current = {
+      runtimeKey: args.runtimeKey,
+      revision: args.rawWorktreesByProjectRef.current.runtimeKey === args.runtimeKey
+        ? args.rawWorktreesByProjectRef.current.revision
+        : 0,
+      worktreesByProject: cloneWorktreesByProject(args.publishedWorktreesByProject),
+    };
+  }
+
+  return args.rawWorktreesByProjectRef.current;
+};
+
+const compareLinkedTargets = (a: SessionWorktreeMenuTarget, b: SessionWorktreeMenuTarget): number => {
+  const aLabel = a.metadata.branch || a.metadata.name || a.metadata.label || a.metadata.path;
+  const bLabel = b.metadata.branch || b.metadata.name || b.metadata.label || b.metadata.path;
+  const labelCompare = aLabel.localeCompare(bLabel, undefined, { sensitivity: 'base' });
+  if (labelCompare !== 0) {
+    return labelCompare;
+  }
+
+  return a.metadata.path.localeCompare(b.metadata.path, undefined, { sensitivity: 'base' });
+};
+
+const buildFallbackLabel = (path: string): string => {
+  const parts = path.split('/').filter(Boolean);
+  return parts[parts.length - 1] ?? path;
+};
+
+const cloneMetadata = (metadata: WorktreeMetadata): WorktreeMetadata => ({
+  ...metadata,
+  path: normalizePath(metadata.path) ?? metadata.path,
+  projectDirectory: normalizePath(metadata.projectDirectory) ?? metadata.projectDirectory,
+  worktreeRoot: normalizePath(metadata.worktreeRoot ?? metadata.path) ?? metadata.worktreeRoot,
+});
+
+const buildSyntheticWorktreeMetadata = (args: {
+  path: string;
+  projectDirectory: string;
+  currentWorktree: WorktreeMetadata | null;
+  projectRootBranch?: string | null;
+}): WorktreeMetadata => {
+  const { currentWorktree, path, projectDirectory, projectRootBranch } = args;
+  const currentPath = normalizePath(currentWorktree?.path ?? null);
+  const isCurrentPath = currentPath === path;
+  const syntheticBranch = isCurrentPath ? (currentWorktree?.branch ?? '') : (projectRootBranch ?? '');
+
+  const syntheticMetadata: WorktreeMetadata = {
+    path,
+    projectDirectory,
+    branch: syntheticBranch,
+    label: isCurrentPath
+      ? (currentWorktree?.label || currentWorktree?.branch || currentWorktree?.name || buildFallbackLabel(path))
+      : (projectRootBranch || buildFallbackLabel(path)),
+    name: isCurrentPath ? currentWorktree?.name : undefined,
+    worktreeRoot: isCurrentPath
+      ? (normalizePath(currentWorktree?.worktreeRoot ?? path) ?? path)
+      : path,
+    worktreeStatus: isCurrentPath
+      ? (currentWorktree?.worktreeStatus ?? 'ready')
+      : 'ready',
+    worktreeSource: isCurrentPath
+      ? (currentWorktree?.worktreeSource ?? 'existing')
+      : 'existing',
+    headState: isCurrentPath ? currentWorktree?.headState : (projectRootBranch ? 'branch' : undefined),
+  };
+
+  return isCurrentPath && currentWorktree
+    ? { ...currentWorktree, ...syntheticMetadata }
+    : syntheticMetadata;
+};
+
+export const buildSessionWorktreeMenuTargets = (args: {
+  projectPath: string | null;
+  discoveredWorktrees: ReadonlyArray<WorktreeMetadata>;
+  sourceDirectory: string | null;
+  currentWorktree: WorktreeMetadata | null;
+  projectRootBranch?: string | null;
+}): SessionWorktreeMenuTarget[] => {
+  const normalizedProjectPath = normalizePath(args.projectPath ?? null);
+  const normalizedSourceDirectory = normalizePath(args.sourceDirectory ?? null)
+    ?? normalizePath(args.currentWorktree?.path ?? null);
+  const discoveredPrimaryPath = normalizePath(
+    args.discoveredWorktrees.find((worktree) => normalizePath(worktree.projectDirectory ?? null))?.projectDirectory ?? null,
+  );
+  const currentPrimaryPath = normalizePath(args.currentWorktree?.projectDirectory ?? null);
+  const primaryPath = discoveredPrimaryPath ?? currentPrimaryPath ?? normalizedProjectPath;
+
+  const targetsByPath = new Map<string, SessionWorktreeMenuTarget>();
+  const pushTarget = (target: SessionWorktreeMenuTarget): void => {
+    const normalizedPath = normalizePath(target.metadata.path ?? null);
+    if (!normalizedPath || targetsByPath.has(normalizedPath)) {
+      return;
+    }
+    targetsByPath.set(normalizedPath, {
+      ...target,
+      metadata: cloneMetadata({
+        ...target.metadata,
+        path: normalizedPath,
+      }),
+    });
+  };
+
+  for (const worktree of args.discoveredWorktrees) {
+    const normalizedPath = normalizePath(worktree.path ?? null);
+    if (!normalizedPath) {
+      continue;
+    }
+    pushTarget({
+      metadata: cloneMetadata({
+        ...worktree,
+        path: normalizedPath,
+        projectDirectory: normalizePath(worktree.projectDirectory ?? null) ?? primaryPath ?? normalizedProjectPath ?? normalizedPath,
+      }),
+      isPrimary: primaryPath === normalizedPath,
+      isCurrent: normalizedSourceDirectory === normalizedPath,
+    });
+  }
+
+  if (primaryPath && !targetsByPath.has(primaryPath)) {
+    pushTarget({
+      metadata: buildSyntheticWorktreeMetadata({
+        path: primaryPath,
+        projectDirectory: primaryPath,
+        currentWorktree: args.currentWorktree,
+        projectRootBranch: args.projectRootBranch,
+      }),
+      isPrimary: true,
+      isCurrent: normalizedSourceDirectory === primaryPath,
+    });
+  }
+
+  if (normalizedSourceDirectory && !targetsByPath.has(normalizedSourceDirectory)) {
+    pushTarget({
+      metadata: buildSyntheticWorktreeMetadata({
+        path: normalizedSourceDirectory,
+        projectDirectory: primaryPath ?? normalizedProjectPath ?? normalizedSourceDirectory,
+        currentWorktree: args.currentWorktree,
+        projectRootBranch: args.projectRootBranch,
+      }),
+      isPrimary: primaryPath === normalizedSourceDirectory,
+      isCurrent: true,
+    });
+  }
+
+  const primaryTargets: SessionWorktreeMenuTarget[] = [];
+  const linkedTargets: SessionWorktreeMenuTarget[] = [];
+  for (const target of targetsByPath.values()) {
+    if (target.isPrimary) {
+      primaryTargets.push(target);
+      continue;
+    }
+    linkedTargets.push(target);
+  }
+
+  primaryTargets.sort((a, b) => a.metadata.path.localeCompare(b.metadata.path, undefined, { sensitivity: 'base' }));
+  linkedTargets.sort(compareLinkedTargets);
+  return [...primaryTargets, ...linkedTargets];
+};
+
+export const startSessionWorktreeMenuLoad = (
+  args: StartSessionWorktreeMenuLoadArgs,
+  deps: StartSessionWorktreeMenuLoadDependencies,
+): StartSessionWorktreeMenuLoadResult => {
+  const runtimeKey = deps.getRuntimeKey();
+  const publishedWorktreesByProject = deps.getPublishedWorktreesByProject();
+  const rawScope = ensureRawWorktreesByProjectScope({
+    rawWorktreesByProjectRef: deps.rawWorktreesByProjectRef,
+    publishedWorktreesByProject,
+    runtimeKey,
+  });
+  const projectById = args.projectId
+    ? deps.projects.find((candidate) => candidate.id === args.projectId) ?? null
+    : null;
+  const project = projectById ?? (args.sourceDirectory ? deps.resolveProject(args.sourceDirectory) : null);
+  const normalizedProjectPath = normalizePath(project?.path ?? null);
+  const cachedTargets = buildSessionWorktreeMenuTargets({
+    projectPath: normalizedProjectPath,
+    discoveredWorktrees: normalizedProjectPath
+      ? (rawScope.worktreesByProject.get(normalizedProjectPath) ?? [])
+      : [],
+    sourceDirectory: args.sourceDirectory,
+    currentWorktree: args.currentWorktree,
+    projectRootBranch: deps.projectRootBranch,
+  });
+
+  return {
+    cachedTargets,
+    refreshTargets: (async () => {
+      if (!project || !normalizedProjectPath) {
+        throw new Error('Unable to resolve worktree project');
+      }
+
+      const refreshedWorktrees = await deps.listProjectWorktrees(project, { force: true });
+
+      if (deps.getRuntimeKey() !== runtimeKey) {
+        throw new Error('Runtime changed during worktree refresh');
+      }
+
+      const currentProjects = deps.getCurrentProjects();
+      const currentProject = currentProjects.find((candidate) => candidate.id === project.id) ?? null;
+      if (!currentProject || normalizePath(currentProject.path ?? null) !== normalizedProjectPath) {
+        throw new Error('Project removed during worktree refresh');
+      }
+
+      const currentRawScope = ensureRawWorktreesByProjectScope({
+        rawWorktreesByProjectRef: deps.rawWorktreesByProjectRef,
+        publishedWorktreesByProject: deps.getPublishedWorktreesByProject(),
+        runtimeKey,
+      });
+      const nextRawTopology = cloneWorktreesByProject(currentRawScope.worktreesByProject);
+      const nextProjectWorktrees = [...refreshedWorktrees]
+        .map((worktree) => cloneMetadata(worktree))
+        .sort((a, b) => compareLinkedTargets(
+          { metadata: a, isPrimary: false, isCurrent: false },
+          { metadata: b, isPrimary: false, isCurrent: false },
+        ));
+
+      const refreshedRepositoryRoot = normalizePath(
+        nextProjectWorktrees.find((worktree) => normalizePath(worktree.projectDirectory ?? null))?.projectDirectory
+          ?? args.currentWorktree?.projectDirectory
+          ?? project.path,
+      );
+      const matchingProjectPaths = new Set<string>([normalizedProjectPath]);
+      for (const [projectPath, worktrees] of nextRawTopology.entries()) {
+        const repositoryRoot = normalizePath(
+          worktrees.find((worktree) => normalizePath(worktree.projectDirectory ?? null))?.projectDirectory ?? projectPath,
+        );
+        if (repositoryRoot && repositoryRoot === refreshedRepositoryRoot) {
+          matchingProjectPaths.add(projectPath);
+        }
+      }
+      for (const projectPath of matchingProjectPaths) {
+        if (nextProjectWorktrees.length === 0) {
+          nextRawTopology.delete(projectPath);
+          continue;
+        }
+        nextRawTopology.set(projectPath, nextProjectWorktrees.map((worktree) => cloneMetadata(worktree)));
+      }
+
+      markRawWorktreesByProjectMutation(deps.rawWorktreesByProjectRef, runtimeKey);
+      deps.rawWorktreesByProjectRef.current = {
+        runtimeKey,
+        revision: deps.rawWorktreesByProjectRef.current.revision,
+        worktreesByProject: nextRawTopology,
+      };
+
+      const partitionedWorktreesByProject = deps.partitionWorktreesByRegisteredProject(currentProjects, nextRawTopology);
+      const allWorktrees = [...partitionedWorktreesByProject.values()].flat();
+      deps.recordWorktreesSeen(allWorktrees.map((worktree) => worktree.path), deps.now());
+
+      const latestPublishedWorktreesByProject = deps.getPublishedWorktreesByProject();
+      if (!deps.worktreeMapsEqual(partitionedWorktreesByProject, latestPublishedWorktreesByProject)) {
+        deps.publishTopology({
+          availableWorktrees: allWorktrees,
+          availableWorktreesByProject: partitionedWorktreesByProject,
+        });
+      }
+
+      return buildSessionWorktreeMenuTargets({
+        projectPath: normalizedProjectPath,
+        discoveredWorktrees: nextProjectWorktrees,
+        sourceDirectory: args.sourceDirectory,
+        currentWorktree: args.currentWorktree,
+        projectRootBranch: deps.projectRootBranch,
+      });
+    })(),
+  };
+};
+
+export const commitDiscoveredRawWorktreesByProject = (args: {
+  rawWorktreesByProjectRef: { current: RawWorktreesByProjectScope };
+  runtimeKey: string;
+  capturedRevision: number;
+  nextRawWorktreesByProject: Map<string, WorktreeMetadata[]>;
+  publishedWorktreesByProject: Map<string, WorktreeMetadata[]>;
+  partitionWorktreesByRegisteredProject: StartSessionWorktreeMenuLoadDependencies['partitionWorktreesByRegisteredProject'];
+  projects: ReadonlyArray<Pick<ProjectRef, 'id' | 'path'>>;
+  worktreeMapsEqual: StartSessionWorktreeMenuLoadDependencies['worktreeMapsEqual'];
+  recordWorktreesSeen: StartSessionWorktreeMenuLoadDependencies['recordWorktreesSeen'];
+  publishTopology: StartSessionWorktreeMenuLoadDependencies['publishTopology'];
+  requestRediscovery: RequestRediscovery;
+  now: () => number;
+}): boolean => {
+  if (args.rawWorktreesByProjectRef.current.runtimeKey !== args.runtimeKey) {
+    return false;
+  }
+  if (args.rawWorktreesByProjectRef.current.revision !== args.capturedRevision) {
+    args.requestRediscovery();
+    return false;
+  }
+  const partitionedWorktreesByProject = args.partitionWorktreesByRegisteredProject(args.projects, args.nextRawWorktreesByProject);
+  const allWorktrees = [...partitionedWorktreesByProject.values()].flat();
+  args.recordWorktreesSeen(allWorktrees.map((worktree) => worktree.path), args.now());
+  args.rawWorktreesByProjectRef.current = {
+    runtimeKey: args.runtimeKey,
+    revision: args.capturedRevision,
+    worktreesByProject: new Map(args.nextRawWorktreesByProject),
+  };
+  if (!args.worktreeMapsEqual(partitionedWorktreesByProject, args.publishedWorktreesByProject)) {
+    args.publishTopology({
+      availableWorktrees: allWorktrees,
+      availableWorktreesByProject: partitionedWorktreesByProject,
+    });
+  }
+  return true;
+};
+
+export const getSessionWorktreeMenuState = (args: {
+  targets: ReadonlyArray<SessionWorktreeMenuTarget>;
+  isRefreshing: boolean;
+  loadFailed: boolean;
+}): SessionWorktreeMenuState => {
+  return {
+    refreshState: args.isRefreshing
+      ? 'loading'
+      : (args.loadFailed && args.targets.length === 0 ? 'error' : null),
+    showNewWorktreeAction: true,
+  };
+};

packages/ui/src/components/session/sidebar/sessions/SessionNodeItem.tsx

@@ -26,7 +26,7 @@ import { useGlobalSessionStatus, useSessionPermissions, useSessionQuestionCount
 import { useSessionMessageRecordsForExport } from '@/sync/use-sync';
 import { useViewportStore, viewportSessionKey } from '@/sync/viewport-store';
 import { DraggableSessionRow } from '../folders/sessionFolderDnd';
-import { nodeContainsSessionId, nodeHasPinnedMembershipChange, selectQuestionBadgeSessionScopes } from './sessionNodeItemUtils';
+import { canShowSessionWorktreeMenu, getSessionWorktreeMenuDisabled, nodeContainsSessionId, nodeHasPinnedMembershipChange, selectQuestionBadgeSessionScopes } from './sessionNodeItemUtils';
 import type { SessionNode } from '../types';
 import { formatProjectLabel, formatSessionCompactDateLabel, formatSessionDateLabel, normalizePath, renderHighlightedText } from '../utils';
 import { useProjectsStore } from '@/stores/useProjectsStore';
@@ -42,16 +42,26 @@ import { getSessionGoal } from '@/lib/sessionGoalMetadata';
 import { sessionGoalStatusColor, sessionGoalStatusLabelKey } from '@/lib/sessionGoalPresentation';
 import { getRuntimeBearerTokenSync } from '@/lib/runtime-auth';
 import { getRuntimeApiBaseUrl } from '@/lib/runtime-switch';
-import { getChatsRootFromDirectory, isChatDirectoryPath } from '@/lib/chatDirectories';
+import { getChatsRootFromDirectory } from '@/lib/chatDirectories';
 import { parseMultiRunSessionTitle } from '@/lib/multirun/title';
 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 {
+  buildSessionTreeMoveMessages,
+  requestSessionTreeMove,
+  useIsSessionWorktreeMovePending,
+} from '@/lib/worktrees/sessionWorktreeMove';
 import { streamPerfCount } from '@/stores/utils/streamDebug';
 import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useSessionFoldersStore } from '@/stores/useSessionFoldersStore';
 import { useUIStore } from '@/stores/useUIStore';
+import type { WorktreeMetadata } from '@/types/worktree';
+import {
+  getSessionWorktreeMenuState,
+  type SessionWorktreeMenuTarget,
+  type StartSessionWorktreeMenuLoadResult,
+} from '../sessionWorktreeMenu';
 
 type SecondaryMeta = {
   projectLabel?: string | null;
@@ -88,6 +98,11 @@ export type SessionNodeItemProps = {
   createFolderAndStartRename: (scopeKey: string, parentId?: string | null) => { id: string } | null;
   handleDeleteSession: (session: Session, source?: { archivedBucket?: boolean; hardDelete?: boolean; skipConfirm?: boolean }) => void;
   handleRestoreSession: (session: Session) => void;
+  startSessionWorktreeMenuLoad: (args: {
+    projectId: string | null;
+    sourceDirectory: string | null;
+    currentWorktree: WorktreeMetadata | null;
+  }) => StartSessionWorktreeMenuLoadResult;
   mobileVariant: boolean;
   alwaysShowActions: boolean;
   secondaryMeta?: SecondaryMeta | null;
@@ -271,6 +286,7 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
     createFolderAndStartRename,
     handleDeleteSession,
     handleRestoreSession,
+    startSessionWorktreeMenuLoad,
     mobileVariant,
     alwaysShowActions,
     secondaryMeta,
@@ -430,6 +446,12 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
   // tick of the counter it only decides to mount.
   const hasActivityDuration = useHasSessionActivityDuration(session.id, isStreaming);
   const isMovingToWorktree = useIsSessionWorktreeMovePending(session.id);
+  const currentWorktreeMetadata = node.worktree ?? useSessionUIStore.getState().getWorktreeMetadata(session.id) ?? null;
+  const [worktreeTargets, setWorktreeTargets] = React.useState<SessionWorktreeMenuTarget[]>([]);
+  const [worktreeTargetsLoading, setWorktreeTargetsLoading] = React.useState(false);
+  const [worktreeTargetsLoadFailed, setWorktreeTargetsLoadFailed] = React.useState(false);
+  const worktreeSubmenuOpenRef = React.useRef(false);
+  const worktreeLoadSequenceRef = React.useRef(0);
   const sessionPermissions = useSessionPermissions(session.id, sessionDirectory ?? undefined, { bootstrap: false });
   const sessionGoal = getSessionGoal(resolvedSession);
   const sessionGoalGlyph = sessionGoal ? (
@@ -879,6 +901,41 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
     }
   };
 
+  const handleWorktreeSubmenuOpenChange = (open: boolean) => {
+    worktreeSubmenuOpenRef.current = open;
+    worktreeLoadSequenceRef.current += 1;
+    const loadSequence = worktreeLoadSequenceRef.current;
+    if (!open) {
+      setWorktreeTargetsLoading(false);
+      setWorktreeTargetsLoadFailed(false);
+      return;
+    }
+    const load = startSessionWorktreeMenuLoad({
+      projectId: projectId ?? null,
+      sourceDirectory: sessionDirectory,
+      currentWorktree: currentWorktreeMetadata,
+    });
+    setWorktreeTargets(load.cachedTargets);
+    setWorktreeTargetsLoading(true);
+    setWorktreeTargetsLoadFailed(false);
+    void load.refreshTargets
+      .then((freshTargets) => {
+        if (!worktreeSubmenuOpenRef.current || worktreeLoadSequenceRef.current !== loadSequence) {
+          return;
+        }
+        setWorktreeTargets(freshTargets);
+        setWorktreeTargetsLoading(false);
+        setWorktreeTargetsLoadFailed(false);
+      })
+      .catch(() => {
+        if (!worktreeSubmenuOpenRef.current || worktreeLoadSequenceRef.current !== loadSequence) {
+          return;
+        }
+        setWorktreeTargetsLoading(false);
+        setWorktreeTargetsLoadFailed(true);
+      });
+  };
+
   const renderSessionMenuItems = ({
     Item,
     Separator,
@@ -935,38 +992,115 @@ function SessionNodeItemComponent(props: SessionNodeItemProps): React.ReactNode
         <Icon name="download" className="mr-1 h-4 w-4" />
         {t('sessions.sidebar.session.menu.exportMarkdown')}
       </Item>
-      {!isSubtaskSession && !archivedBucket && !isVSCode && !isChatDirectoryPath(sessionDirectory) ? (
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <span className="block">
-              <Item
-                disabled={!sessionDirectory || isStreaming || isMovingToWorktree}
-                onClick={() => {
-                  if (!sessionDirectory || isStreaming || isMovingToWorktree) return;
-                  startSessionTreeWorktreeMove({
-                    root: resolvedSession,
-                    descendants: collectNodeDescendantSessions(node),
-                    sourceDirectory: sessionDirectory,
-                    successMessage: t('sessions.sidebar.session.moveToWorktree.success'),
-                    failureMessage: t('sessions.sidebar.session.moveToWorktree.failed'),
-                  });
-                }}
-                className="w-full [&>svg]:mr-1"
-              >
-                <Icon name="folder-shared" className="mr-1 h-4 w-4" />
-                {t('sessions.sidebar.session.menu.moveToWorktree')}
-              </Item>
-            </span>
-          </TooltipTrigger>
-          <TooltipContent side="right" className="max-w-72">
-            {isMovingToWorktree
-              ? t('sessions.sidebar.session.moveToWorktree.tooltipMoving')
-              : isStreaming
-                ? t('sessions.sidebar.session.moveToWorktree.tooltipBusy')
-                : t('sessions.sidebar.session.moveToWorktree.tooltip')}
-          </TooltipContent>
-        </Tooltip>
-      ) : null}
+      {canShowSessionWorktreeMenu({ isSubtaskSession, archivedBucket: Boolean(archivedBucket), isVSCode, sessionDirectory }) ? (() => {
+        const isWorktreeMenuDisabled = getSessionWorktreeMenuDisabled({
+          sessionDirectory,
+          isStreaming,
+          isMovingToWorktree,
+        });
+        const worktreeMenuState = getSessionWorktreeMenuState({
+          targets: worktreeTargets,
+          isRefreshing: worktreeTargetsLoading,
+          loadFailed: worktreeTargetsLoadFailed,
+        });
+        return (
+          <Sub onOpenChange={handleWorktreeSubmenuOpenChange}>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <SubTrigger
+                  disabled={isWorktreeMenuDisabled}
+                  className="w-full [&>svg]:mr-1"
+                  data-session-worktree-submenu-trigger={session.id}
+                >
+                  <Icon name="folder-shared" className="mr-1 h-4 w-4" />
+                  {t('sessions.sidebar.session.menu.moveToWorktreeTargets')}
+                </SubTrigger>
+              </TooltipTrigger>
+              <TooltipContent side="right" className="max-w-72">
+                {isMovingToWorktree
+                  ? t('sessions.sidebar.session.moveToWorktree.tooltipMoving')
+                  : isStreaming
+                    ? t('sessions.sidebar.session.moveToWorktree.tooltipBusy')
+                    : t('sessions.sidebar.session.moveToWorktree.tooltipTargets')}
+              </TooltipContent>
+            </Tooltip>
+            <SubContent className="min-w-[220px]" data-session-worktree-submenu={session.id}>
+              {worktreeTargets.map((target) => {
+                const targetPath = normalizePath(target.metadata.path ?? null) ?? target.metadata.path;
+                const itemLabel = target.isPrimary
+                  ? t('sessions.sidebar.session.moveToWorktree.main')
+                  : (target.metadata.label || target.metadata.branch || target.metadata.name || target.metadata.path);
+                const isDisabled = target.isCurrent || target.metadata.worktreeStatus !== 'ready';
+
+                return (
+                  <Item
+                    key={targetPath}
+                    disabled={isDisabled}
+                    title={target.metadata.path}
+                    data-session-worktree-target={targetPath}
+                    onClick={() => {
+                      if (isDisabled || !sessionDirectory) {
+                        return;
+                      }
+                      requestSessionTreeMove({
+                        kind: 'existing',
+                        root: resolvedSession,
+                        descendants: collectNodeDescendantSessions(node),
+                        sourceDirectory: sessionDirectory,
+                        destination: target.metadata,
+                        messages: buildSessionTreeMoveMessages(t, {
+                          success: 'sessions.sidebar.session.moveToWorktree.existingSuccess',
+                          failure: 'sessions.sidebar.session.moveToWorktree.existingFailed',
+                        }),
+                      });
+                    }}
+                  >
+                    <span className="flex min-w-0 flex-1 items-center gap-1 truncate">
+                      <span className="truncate">{itemLabel}</span>
+                      {target.isCurrent ? <span className="sr-only">{t('sessions.sidebar.session.moveToWorktree.current')}</span> : null}
+                    </span>
+                    {target.isCurrent ? <Icon name="check" className="ml-2 h-3.5 w-3.5 flex-shrink-0 text-primary" aria-hidden="true" /> : null}
+                  </Item>
+                );
+              })}
+              {worktreeMenuState.refreshState === 'loading' ? (
+                <Item disabled data-session-worktree-refresh-state="loading" className="py-0.5 text-muted-foreground typography-micro">
+                  {t('sessions.sidebar.session.moveToWorktree.refreshing')}
+                </Item>
+              ) : null}
+              {worktreeMenuState.refreshState === 'error' ? (
+                <Item disabled data-session-worktree-refresh-state="error" className="py-0.5 text-muted-foreground typography-micro">
+                  {t('sessions.sidebar.session.moveToWorktree.loadFailed')}
+                </Item>
+              ) : null}
+              <Separator />
+              {worktreeMenuState.showNewWorktreeAction ? (
+                <Item
+                  disabled={isWorktreeMenuDisabled}
+                  data-session-worktree-new-action="true"
+                  onClick={() => {
+                    if (isWorktreeMenuDisabled || !sessionDirectory) return;
+                    requestSessionTreeMove({
+                      kind: 'quick',
+                      root: resolvedSession,
+                      descendants: collectNodeDescendantSessions(node),
+                      sourceDirectory: sessionDirectory,
+                      messages: buildSessionTreeMoveMessages(t, {
+                        success: 'sessions.sidebar.session.moveToWorktree.success',
+                        failure: 'sessions.sidebar.session.moveToWorktree.failed',
+                      }),
+                    });
+                  }}
+                  className="[&>svg]:mr-1"
+                >
+                  <Icon name="add" className="mr-1 h-4 w-4" />
+                  {t('sessions.sidebar.session.menu.newWorktree')}
+                </Item>
+              ) : null}
+            </SubContent>
+          </Sub>
+        );
+      })() : null}
       {isMultiRunLikeSession ? (
         <Item onClick={() => setFusionDialogOpen(true)} className="[&>svg]:mr-1">
           <FusionIcon className="mr-1 h-4 w-4" />
@@ -1628,6 +1762,7 @@ const areSessionNodeItemPropsEqual = (prev: SessionNodeItemProps, next: SessionN
     && prev.createFolderAndStartRename === next.createFolderAndStartRename
     && prev.handleDeleteSession === next.handleDeleteSession
     && prev.handleRestoreSession === next.handleRestoreSession
+    && prev.startSessionWorktreeMenuLoad === next.startSessionWorktreeMenuLoad
     && prev.children === next.children;
 };
 

packages/ui/src/components/session/sidebar/sessions/SessionTreeItem.behavior.test.tsx

@@ -3,6 +3,7 @@ import React, { act } from 'react';
 import { createRoot } from 'react-dom/client';
 import type { Session } from '@opencode-ai/sdk/v2';
 import type { SessionNodeItemProps } from './SessionNodeItem';
+import type { SessionTreeItemProps } from './SessionTreeItem';
 import { installHookTestDom } from '../test-utils/testDom';
 import { I18nProvider } from '@/lib/i18n';
 
@@ -39,6 +40,11 @@ mock.module('./hooks/useSessionActions', () => ({
 
 const { SessionTreeItem } = await import('./SessionTreeItem');
 
+const noopStartSessionWorktreeMenuLoad: SessionTreeItemProps['startSessionWorktreeMenuLoad'] = () => ({
+  cachedTargets: [],
+  refreshTargets: Promise.resolve([]),
+});
+
 const session = (id: string): Session => ({
   id,
   slug: id,
@@ -91,6 +97,7 @@ describe('SessionTreeItem public behavior', () => {
         setDeleteSessionConfirm={noop}
         startFolderRename={noop}
         setCopiedSessionId={setCopiedSessionId}
+        startSessionWorktreeMenuLoad={noopStartSessionWorktreeMenuLoad}
         mobileVariant={false}
         alwaysShowActions={false}
         {...context}

packages/ui/src/components/session/sidebar/sessions/SessionTreeItem.tsx

@@ -39,6 +39,7 @@ export type SessionTreeItemProps = SessionTreeItemRenderProps & Pick<SessionNode
   | 'setEditTitle'
   | 'toggleParent'
   | 'setOpenSidebarMenuKey'
+  | 'startSessionWorktreeMenuLoad'
 > & {
   allowReselect: boolean;
   onSessionSelected?: (sessionId: string) => void;
@@ -88,6 +89,7 @@ export function SessionTreeItem({
   startFolderRename,
   copiedSessionId,
   setCopiedSessionId,
+  startSessionWorktreeMenuLoad,
   mobileVariant,
   alwaysShowActions,
 }: SessionTreeItemProps): React.ReactNode {
@@ -160,11 +162,12 @@ export function SessionTreeItem({
       openSidebarMenuKey={openSidebarMenuKey}
       setOpenSidebarMenuKey={setOpenSidebarMenuKey}
       createFolderAndStartRename={createFolderAndStartRename}
-       handleDeleteSession={sessionActions.handleDeleteSession}
-       handleRestoreSession={sessionActions.handleRestoreSession}
-      mobileVariant={mobileVariant}
-      alwaysShowActions={alwaysShowActions}
-       pinnedSessionIds={pinnedSessionIds}
+        handleDeleteSession={sessionActions.handleDeleteSession}
+        handleRestoreSession={sessionActions.handleRestoreSession}
+       startSessionWorktreeMenuLoad={startSessionWorktreeMenuLoad}
+       mobileVariant={mobileVariant}
+       alwaysShowActions={alwaysShowActions}
+        pinnedSessionIds={pinnedSessionIds}
       node={node}
       depth={depth}
       groupDirectory={groupDirectory}
@@ -201,11 +204,12 @@ export function SessionTreeItem({
            setIsSessionSearchOpen={setIsSessionSearchOpen}
            deleteSessionConfirm={deleteSessionConfirm}
            setDeleteSessionConfirm={setDeleteSessionConfirm}
-           startFolderRename={startFolderRename}
-           setCopiedSessionId={setCopiedSessionId}
-          mobileVariant={mobileVariant}
-          alwaysShowActions={alwaysShowActions}
-          depth={depth + 1}
+            startFolderRename={startFolderRename}
+            setCopiedSessionId={setCopiedSessionId}
+            startSessionWorktreeMenuLoad={startSessionWorktreeMenuLoad}
+           mobileVariant={mobileVariant}
+           alwaysShowActions={alwaysShowActions}
+           depth={depth + 1}
           {...childContext}
           renderExtras={childRenderExtrasFor?.(child)}
         />

packages/ui/src/components/session/sidebar/sessions/sessionNodeItemUtils.test.ts

@@ -2,7 +2,14 @@ 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, selectQuestionBadgeSessionScopes } from './sessionNodeItemUtils';
+import {
+  computeNodeStructureKey,
+  canShowSessionWorktreeMenu,
+  getSessionWorktreeMenuDisabled,
+  nodeHasPinnedMembershipChange,
+  selectFolderRootNodes,
+  selectQuestionBadgeSessionScopes,
+} from './sessionNodeItemUtils';
 import type { SessionNode } from '../types';
 
 const session = (id: string, title: string): Session => ({
@@ -158,3 +165,49 @@ describe('selectFolderRootNodes', () => {
     expect(selectFolderRootNodes(['missing-root', 'child'], new Map([['child', child]]))).toEqual([child]);
   });
 });
+
+describe('getSessionWorktreeMenuDisabled', () => {
+  test('shares the parent trigger disabled contract with the new worktree action', () => {
+    expect(getSessionWorktreeMenuDisabled({
+      sessionDirectory: '/repo-feature',
+      isStreaming: false,
+      isMovingToWorktree: false,
+    })).toBe(false);
+
+    expect(getSessionWorktreeMenuDisabled({
+      sessionDirectory: null,
+      isStreaming: false,
+      isMovingToWorktree: false,
+    })).toBe(true);
+
+    expect(getSessionWorktreeMenuDisabled({
+      sessionDirectory: '/repo-feature',
+      isStreaming: true,
+      isMovingToWorktree: false,
+    })).toBe(true);
+
+    expect(getSessionWorktreeMenuDisabled({
+      sessionDirectory: '/repo-feature',
+      isStreaming: false,
+      isMovingToWorktree: true,
+    })).toBe(true);
+  });
+});
+
+describe('canShowSessionWorktreeMenu', () => {
+  test('hides worktree moves for managed Chat directories', () => {
+    expect(canShowSessionWorktreeMenu({
+      isSubtaskSession: false,
+      archivedBucket: false,
+      isVSCode: false,
+      sessionDirectory: '/home/test/.config/openchamber/chats/2026-08-25/session-1',
+    })).toBe(false);
+
+    expect(canShowSessionWorktreeMenu({
+      isSubtaskSession: false,
+      archivedBucket: false,
+      isVSCode: false,
+      sessionDirectory: '/repo',
+    })).toBe(true);
+  });
+});

packages/ui/src/components/session/sidebar/sessions/sessionNodeItemUtils.ts

@@ -1,6 +1,7 @@
 import { getRuntimeKey } from '@/lib/runtime-switch';
 import { matchesRankQuery } from '@/lib/search/fuzzySearch';
 import { normalizePath } from '@/lib/pathNormalization';
+import { isChatDirectoryPath } from '@/lib/chatDirectories';
 import { resolveGlobalSessionDirectory } from '@/stores/useGlobalSessionsStore';
 import { getPinnedSessionKey } from '@/stores/useSessionPinnedStore';
 import type { SessionNode } from '../types';
@@ -78,6 +79,31 @@ export type QuestionBadgeSessionScope = {
   sessionIDs: string[];
 };
 
+export const canShowSessionWorktreeMenu = ({
+  isSubtaskSession,
+  archivedBucket,
+  isVSCode,
+  sessionDirectory,
+}: {
+  isSubtaskSession: boolean;
+  archivedBucket: boolean;
+  isVSCode: boolean;
+  sessionDirectory: string | null;
+}): boolean => !isSubtaskSession
+  && !archivedBucket
+  && !isVSCode
+  && !isChatDirectoryPath(sessionDirectory);
+
+export const getSessionWorktreeMenuDisabled = ({
+  sessionDirectory,
+  isStreaming,
+  isMovingToWorktree,
+}: {
+  sessionDirectory: string | null;
+  isStreaming: boolean;
+  isMovingToWorktree: boolean;
+}): boolean => !sessionDirectory || isStreaming || isMovingToWorktree;
+
 /**
  * Choose which (directory, sessionIDs) scopes a sidebar row's pending-question
  * badge should count. An expanded row counts only its own session; a collapsed

packages/ui/src/components/ui/MemoryDebugPanel.tsx

@@ -7,6 +7,7 @@ import { MEMORY_LIMITS } from '@/stores/types/sessionTypes';
 import { useGitHubPrStatusStore } from '@/stores/useGitHubPrStatusStore';
 import { getBackgroundTrimLimit } from '@/stores/types/sessionTypes';
 import { getStreamPerfSnapshot, getVsCodeStreamPerfSnapshot, resetStreamPerf, type StreamPerfSnapshot } from '@/stores/utils/streamDebug';
+import { getRequestsInFlightSnapshot, resetRequestsInFlight, type RequestsInFlightSnapshot } from '@/stores/utils/requestsInFlight';
 import { Card } from '@/components/ui/card';
 import { Button } from '@/components/ui/button';
 import { Tooltip, TooltipTrigger, TooltipContent } from '@/components/ui/tooltip';
@@ -18,7 +19,7 @@ interface DebugPanelProps {
   onClose?: () => void;
 }
 
-type DebugTab = 'memory' | 'streaming';
+type DebugTab = 'memory' | 'streaming' | 'requests';
 
 const formatDuration = (durationMs: number): string => {
   if (durationMs < 1000) {
@@ -35,6 +36,10 @@ const formatDuration = (durationMs: number): string => {
   return `${minutes}m ${remainderSeconds}s`;
 };
 
+// Fixed-width seconds format ("XX.XX s") for the percentile series so the
+// legend/labels don't jitter as values change. Pair with `tabular-nums`.
+const formatSeconds = (durationMs: number): string => `${(durationMs / 1000).toFixed(2)} s`;
+
 const MetricCard: React.FC<{ label: string; value: React.ReactNode }> = ({ label, value }) => {
   return (
     <div
@@ -99,6 +104,74 @@ const PerfSection: React.FC<{ title: string; snapshot: StreamPerfSnapshot; empty
   );
 };
 
+type LineSeries = { samples: number[]; color: string; filled?: boolean };
+
+const LineChart: React.FC<{
+  series: LineSeries[];
+  peak: number;
+  windowSeconds: number;
+  ariaLabel: string;
+  maxLabel: string;
+}> = ({ series, peak, windowSeconds, ariaLabel, maxLabel }) => {
+  const width = windowSeconds;
+  const height = 56;
+  const padTop = 4;
+  const n = series.reduce((max, s) => Math.max(max, s.samples.length), 0);
+  const scale = peak > 0 ? (height - padTop) / peak : 0;
+  const xFor = (i: number): number => width - n + i;
+  const yFor = (v: number): number => height - v * scale;
+  const baseline = height;
+
+  return (
+    <div className="relative w-full">
+      <span className="pointer-events-none absolute left-0 top-0 typography-meta text-[var(--surface-muted-foreground)]">{maxLabel}</span>
+      <svg
+        viewBox={`0 0 ${width} ${height}`}
+        preserveAspectRatio="none"
+        className="h-14 w-full"
+        role="img"
+        aria-label={ariaLabel}
+      >
+        <line
+          x1={0}
+          y1={baseline}
+          x2={width}
+          y2={baseline}
+          stroke="var(--interactive-border)"
+          strokeWidth={1}
+          vectorEffect="non-scaling-stroke"
+        />
+        {series.map((s, si) => {
+          const sn = s.samples.length;
+          if (sn === 0) return null;
+          const points = s.samples.map((v, i) => `${xFor(i)},${yFor(v).toFixed(2)}`);
+          const linePath = `M ${points.join(' L ')}`;
+          return (
+            <React.Fragment key={si}>
+              {s.filled ? (
+                <path
+                  d={`M ${xFor(0)},${baseline} L ${points.join(' L ')} L ${xFor(sn - 1)},${baseline} Z`}
+                  fill={`color-mix(in srgb, ${s.color} 18%, transparent)`}
+                  stroke="none"
+                />
+              ) : null}
+              <path
+                d={linePath}
+                fill="none"
+                stroke={s.color}
+                strokeWidth={1.5}
+                strokeLinejoin="round"
+                strokeLinecap="round"
+                vectorEffect="non-scaling-stroke"
+              />
+            </React.Fragment>
+          );
+        })}
+      </svg>
+    </div>
+  );
+};
+
 const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
   const { t } = useI18n();
   const [activeTab, setActiveTab] = React.useState<DebugTab>('memory');
@@ -110,6 +183,15 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
   const totalGitHubRequests = useGitHubPrStatusStore((state) => state.totalRequestCount);
   const [streamSnapshot, setStreamSnapshot] = React.useState<StreamPerfSnapshot>(() => getStreamPerfSnapshot());
   const [vscodeStreamSnapshot, setVsCodeStreamSnapshot] = React.useState<StreamPerfSnapshot>(() => getVsCodeStreamPerfSnapshot());
+  const [requestsSnapshot, setRequestsSnapshot] = React.useState<RequestsInFlightSnapshot>(() => getRequestsInFlightSnapshot());
+  const ageLines = [
+    { label: 'p50', current: requestsSnapshot.ageP50, samples: requestsSnapshot.p50Samples, color: 'var(--status-success)' },
+    { label: 'p90', current: requestsSnapshot.ageP90, samples: requestsSnapshot.p90Samples, color: 'var(--status-info)' },
+    { label: 'p99', current: requestsSnapshot.ageP99, samples: requestsSnapshot.p99Samples, color: 'var(--status-warning)' },
+    { label: 'max', current: requestsSnapshot.ageMax, samples: requestsSnapshot.maxSamples, color: 'var(--status-error)' },
+  ];
+  const countMax = requestsSnapshot.samples.reduce((m, v) => Math.max(m, v), 0);
+  const percentileMax = ageLines.reduce((m, l) => l.samples.reduce((mm, v) => Math.max(mm, v), m), 0);
   const streamMetricCounts = React.useMemo(() => {
     const counts = new Map<string, number>();
     streamSnapshot.entries.forEach((entry) => {
@@ -130,6 +212,7 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
     const refresh = () => {
       setStreamSnapshot(getStreamPerfSnapshot());
       setVsCodeStreamSnapshot(getVsCodeStreamPerfSnapshot());
+      setRequestsSnapshot(getRequestsInFlightSnapshot());
     };
 
     refresh();
@@ -218,11 +301,10 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
     >
       <div className="mb-3 flex items-center justify-between gap-2">
         <div className="flex items-center gap-2">
-          {activeTab === 'memory' ? (
-            <Icon name="database-2" className="h-4 w-4 text-[var(--surface-foreground)]" />
-          ) : (
-            <Icon name="bar-chart-box" className="h-4 w-4 text-[var(--surface-foreground)]" />
-          )}
+          <Icon
+            name={activeTab === 'memory' ? 'database-2' : activeTab === 'streaming' ? 'bar-chart-box' : 'pulse'}
+            className="h-4 w-4 text-[var(--surface-foreground)]"
+          />
           <h3 className="typography-ui-label font-semibold text-[var(--surface-foreground)]">{t('memoryDebugPanel.title')}</h3>
         </div>
         <div className="flex items-center gap-1">
@@ -244,6 +326,18 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
               </Button>
             </>
           ) : null}
+          {activeTab === 'requests' ? (
+            <Button
+              size="xs"
+              variant="ghost"
+              onClick={() => {
+                resetRequestsInFlight();
+                setRequestsSnapshot(getRequestsInFlightSnapshot());
+              }}
+            >
+              <Icon name="refresh" className="h-3.5 w-3.5" />
+            </Button>
+          ) : null}
           {onClose ? (
             <Button size="icon" variant="ghost" className="h-6 w-6" onClick={onClose}>
               <Icon name="close" className="h-4 w-4" />
@@ -272,6 +366,14 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
         >
           {t('memoryDebugPanel.tabs.streaming')}
         </Button>
+        <Button
+          size="sm"
+          variant={activeTab === 'requests' ? 'secondary' : 'ghost'}
+          className="flex-1"
+          onClick={() => setActiveTab('requests')}
+        >
+          {t('memoryDebugPanel.tabs.requests')}
+        </Button>
       </div>
 
       {activeTab === 'memory' ? (
@@ -366,7 +468,7 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
             </Tooltip>
           </div>
         </div>
-      ) : (
+      ) : activeTab === 'streaming' ? (
         <div className="space-y-3">
           <div className="flex items-center justify-between gap-2 rounded-md border border-[var(--interactive-border)] px-3 py-2 typography-meta text-[var(--surface-muted-foreground)]">
             <span>
@@ -409,6 +511,70 @@ const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
             />
           ) : null}
         </div>
+      ) : (
+        <div className="space-y-3">
+          <div className="grid grid-cols-2 gap-2 typography-meta">
+            <MetricCard label={t('memoryDebugPanel.requests.totalRequests')} value={`${requestsSnapshot.totalSettled} / ${requestsSnapshot.totalStarted}`} />
+            <MetricCard
+              label={t('memoryDebugPanel.requests.tracking')}
+              value={requestsSnapshot.startedAt ? formatDuration(requestsSnapshot.durationMs) : t('memoryDebugPanel.common.idle')}
+            />
+          </div>
+
+          {requestsSnapshot.samples.length === 0 ? (
+            <div
+              className="rounded-md p-3 typography-meta text-[var(--surface-muted-foreground)]"
+              style={{ backgroundColor: 'color-mix(in srgb, var(--surface-muted) 45%, transparent)' }}
+            >
+              {t('memoryDebugPanel.requests.noSamples')}
+            </div>
+          ) : (
+            <div className="space-y-1.5">
+              <div className="flex items-center justify-between typography-meta">
+                <span className="text-[var(--surface-muted-foreground)]">{t('memoryDebugPanel.requests.inFlight')}</span>
+                <span>
+                  <span className="font-medium text-[var(--surface-foreground)]">{requestsSnapshot.inFlight}</span>
+                  <span className="text-[var(--surface-muted-foreground)]"> · {t('memoryDebugPanel.requests.peak')} </span>
+                  <span className="font-medium text-[var(--surface-foreground)]">{requestsSnapshot.peak}</span>
+                </span>
+              </div>
+              <LineChart
+                series={[{ samples: requestsSnapshot.samples, color: 'var(--status-info)', filled: true }]}
+                peak={countMax}
+                windowSeconds={requestsSnapshot.windowSeconds}
+                ariaLabel={t('memoryDebugPanel.requests.chartLabel', { peak: requestsSnapshot.peak })}
+                maxLabel={`${countMax}`}
+              />
+
+              <div className="flex items-center justify-between typography-meta">
+                <span className="text-[var(--surface-muted-foreground)]">{t('memoryDebugPanel.requests.duration')}</span>
+                <span className="font-medium tabular-nums text-[var(--surface-foreground)]">{formatSeconds(requestsSnapshot.peakAgeMs)}</span>
+              </div>
+              <LineChart
+                series={ageLines.map((line) => ({ samples: line.samples, color: line.color }))}
+                peak={percentileMax}
+                windowSeconds={requestsSnapshot.windowSeconds}
+                ariaLabel={t('memoryDebugPanel.requests.percentileChartLabel')}
+                maxLabel={formatSeconds(percentileMax)}
+              />
+
+              <div className="flex flex-wrap items-center gap-x-3 gap-y-1 typography-meta">
+                {ageLines.map((line) => (
+                  <span key={line.label} className="flex items-center gap-1">
+                    <span className="inline-block h-2 w-2 rounded-full" style={{ backgroundColor: line.color }} />
+                    <span className="text-[var(--surface-muted-foreground)]">{line.label}</span>
+                    <span className="font-medium tabular-nums text-[var(--surface-foreground)]">{formatSeconds(line.current)}</span>
+                  </span>
+                ))}
+              </div>
+
+              <div className="flex items-center justify-between typography-meta text-[var(--surface-muted-foreground)]">
+                <span>{t('memoryDebugPanel.requests.windowHint', { seconds: requestsSnapshot.windowSeconds })}</span>
+                <span>{t('memoryDebugPanel.requests.now')}</span>
+              </div>
+            </div>
+          )}
+        </div>
       )}
     </Card>
   );

packages/ui/src/components/views/GitView.tsx

@@ -1347,8 +1347,10 @@ export const GitView: React.FC<GitViewProps> = ({ isActive }) => {
     }
 
     try {
-      await git.checkoutBranch(currentDirectory, normalized);
-      toast.success(t('gitView.toast.checkedOut', { name: normalized }));
+      // Picking a remote-tracking branch checks out the local branch that
+      // tracks it, so report the branch the repository actually landed on.
+      const result = await git.checkoutBranch(currentDirectory, normalized);
+      toast.success(t('gitView.toast.checkedOut', { name: result?.branch || normalized }));
       await refreshStatusAndBranches();
       await refreshLog();
     } catch (err) {

packages/ui/src/components/views/SettingsView.tsx

@@ -214,6 +214,7 @@ export const SettingsView: React.FC<SettingsViewProps> = ({ onClose, forceMobile
   const [pendingSearchItemId, setPendingSearchItemId] = React.useState<string | null>(null);
   const [activeSearchResultIndex, setActiveSearchResultIndex] = React.useState(0);
   const containerRef = React.useRef<HTMLDivElement>(null);
+  const shouldFocusMobilePageContentRef = React.useRef(false);
   const searchResultRefs = React.useRef<(HTMLButtonElement | null)[]>([]);
   const activeSearchResultIndexRef = React.useRef(0);
   const keyboardSearchNavigationRef = React.useRef(false);
@@ -764,12 +765,30 @@ export const SettingsView: React.FC<SettingsViewProps> = ({ onClose, forceMobile
   }, [runtimeCtx.isVSCode]);
 
   const handleMobilePageSidebarItemSelect = React.useCallback(() => {
+    shouldFocusMobilePageContentRef.current = true;
     setMobileStage('page-content');
     if (settingsSlug === 'skills.installed') {
       pushMobileSplitDetailHistory(settingsSlug);
     }
   }, [pushMobileSplitDetailHistory, settingsSlug]);
 
+  React.useEffect(() => {
+    if (!isMobile || mobileStage !== 'page-content' || !shouldFocusMobilePageContentRef.current) {
+      return;
+    }
+
+    shouldFocusMobilePageContentRef.current = false;
+    const frame = window.requestAnimationFrame(() => {
+      containerRef.current
+        ?.querySelector<HTMLElement>('[data-settings-page-heading]')
+        ?.focus({ preventScroll: true });
+    });
+
+    return () => {
+      window.cancelAnimationFrame(frame);
+    };
+  }, [isMobile, mobileStage, settingsSlug]);
+
   const handleBack = React.useCallback(() => {
     if (backButtonTargetsPageSidebar) {
       const currentDetail = typeof window !== 'undefined'

packages/ui/src/components/views/agent-manager/AgentManagerEmptyState.tsx

@@ -22,8 +22,6 @@ import { useI18n } from '@/lib/i18n';
 
 /** Max file size in bytes (10MB) */
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
-/** Max number of concurrent runs */
-const MAX_MODELS = 5;
 
 /** Attached file for agent manager */
 interface AttachedFile {
@@ -132,11 +130,8 @@ export const AgentManagerEmptyState: React.FC<AgentManagerEmptyStateProps> = ({
   }, [projectRef]);
 
   const handleAddModel = React.useCallback((model: ModelSelectionWithId) => {
-    if (selectedModels.length >= MAX_MODELS) {
-      return;
-    }
     setSelectedModels((prev) => [...prev, model]);
-  }, [selectedModels.length]);
+  }, []);
 
   const handleRemoveModel = React.useCallback((index: number) => {
     setSelectedModels((prev) => prev.filter((_, i) => i !== index));
@@ -529,7 +524,6 @@ export const AgentManagerEmptyState: React.FC<AgentManagerEmptyStateProps> = ({
             onUpdate={handleUpdateModel}
             minModels={1}
             addButtonLabel={t('agentManager.empty.models.addModel')}
-            maxModels={5}
           />
         </div>
 

packages/ui/src/hooks/useChatTimelineScroll.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import {
-    isAutoFollowReleaseKey,
-    shouldDelayAutoFollowRepin,
-    shouldRepinReleasedAutoFollow,
-} from './useChatTimelineScroll';
-
-const keyEvent = (
-    key: string,
-    modifiers: Partial<Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'>> = {},
-): Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'> => ({
-    altKey: false,
-    ctrlKey: false,
-    key,
-    metaKey: false,
-    shiftKey: false,
-    ...modifiers,
-});
-
-describe('chat timeline scroll intent', () => {
-    test('recognizes upward navigation without stealing modified shortcuts', () => {
-        expect(isAutoFollowReleaseKey(keyEvent('ArrowUp'))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent('PageUp'))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent('Home'))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent(' ', { shiftKey: true }))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent('Pause'))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent('Break'))).toBe(true);
-        expect(isAutoFollowReleaseKey(keyEvent('ArrowUp', { ctrlKey: true }))).toBe(false);
-        expect(isAutoFollowReleaseKey(keyEvent(' ', { shiftKey: false }))).toBe(false);
-    });
-
-    test('delays re-pinning only for downward or exact-bottom movement', () => {
-        expect(shouldRepinReleasedAutoFollow(false, false)).toBe(false);
-        expect(shouldRepinReleasedAutoFollow(true, false)).toBe(true);
-        expect(shouldRepinReleasedAutoFollow(false, true)).toBe(true);
-        expect(shouldDelayAutoFollowRepin(null, 100, 1200)).toBe(false);
-        expect(shouldDelayAutoFollowRepin(100, 500, 1200)).toBe(true);
-        expect(shouldDelayAutoFollowRepin(100, 1300, 1200)).toBe(false);
-    });
-});

packages/ui/src/hooks/useChatTimelineScroll.ts

@@ -13,46 +13,11 @@ import {
     type TimelineListMeasurementState,
     type TimelineScrollMode,
 } from '@/components/chat/lib/scroll/timelineScrollAnchoring';
-
-export const isAutoFollowReleaseKey = (
-    event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>,
-): boolean => {
-    if (event.altKey || event.ctrlKey || event.metaKey) return false;
-    if (event.key === ' ' && event.shiftKey) return true;
-    return event.key === 'ArrowUp'
-        || event.key === 'PageUp'
-        || event.key === 'Home'
-        || event.key === 'Pause'
-        || event.key === 'Break';
-};
-
-const nestedScrollableTarget = (root: HTMLElement, target: EventTarget | null): HTMLElement | null => {
-    if (!(target instanceof Element)) return null;
-    const nested = target.closest('[data-scrollable]');
-    if (!(nested instanceof HTMLElement) || nested === root) return null;
-    return nested;
-};
-
-export const isMiddleButtonAutoScrollIntent = (
-    root: HTMLElement,
-    event: Pick<MouseEvent, 'button' | 'target'>,
-): boolean => event.button === 1 && !nestedScrollableTarget(root, event.target);
-
-export const shouldRepinReleasedAutoFollow = (
-    scrollingDown: boolean,
-    atTrueBottom: boolean,
-): boolean => scrollingDown || atTrueBottom;
-
-const nestedScrollableCanConsumeUp = (root: HTMLElement, target: EventTarget | null): boolean => {
-    const nested = nestedScrollableTarget(root, target);
-    return nested !== null && nested.scrollTop > 0;
-};
-
-export const shouldDelayAutoFollowRepin = (
-    releasedAt: number | null,
-    currentTime: number,
-    graceMs: number,
-): boolean => releasedAt !== null && currentTime - releasedAt < graceMs;
+import {
+    isFollowReleaseKey,
+    isMiddleButtonPan,
+    nestedScrollableConsumesWheelUp,
+} from '@/components/chat/lib/scroll/timelineScrollIntent';
 
 // ──────────────────────────────────────────────────────────────────────────
 // Chat timeline scroll ownership.
@@ -76,8 +41,8 @@ export const shouldDelayAutoFollowRepin = (
 // gesture bumps a generation counter; any in-flight automatic movement compares
 // its captured generation against the current one and aborts if they differ.
 // That comparison replaces the timer windows the previous implementation needed
-// to tell its own writes apart from the user's; the only timer here is the short
-// grace period for an explicit release near the live edge.
+// to tell its own writes apart from the user's, which is why there are no
+// guard/settle/entry-stick timers here.
 // ──────────────────────────────────────────────────────────────────────────
 
 // The subset of the list ref this hook drives. Declared structurally so the
@@ -141,9 +106,6 @@ export interface UseChatTimelineScrollResult {
 // Hiding is always immediate.
 const SHOW_SCROLL_BUTTON_DELAY_MS = 150;
 const SAVE_DEBOUNCE_MS = 150;
-const TOUCH_FINGER_DOWN_THRESHOLD_PX = 2;
-const AUTO_MATCH_TOLERANCE_PX = 2;
-const REPIN_GRACE_AFTER_RELEASE_MS = 1200;
 // The anchor scroll is animated; `scrollend` is the authoritative completion
 // signal, and this bounds the wait for browsers that drop it.
 const ANCHOR_SETTLE_FALLBACK_MS = 750;
@@ -206,10 +168,6 @@ export const useChatTimelineScroll = ({
     currentSessionIdRef.current = currentSessionId;
     const currentSessionKeyRef = React.useRef(currentSessionKey);
     currentSessionKeyRef.current = currentSessionKey;
-    const lastScrollOffsetRef = React.useRef(0);
-    const lastScrollDirectionDownRef = React.useRef(false);
-    const delayedRepinTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
-    const lastExplicitReleaseAtRef = React.useRef<number | null>(null);
 
     const updateViewportAnchor = useViewportStore((state) => state.updateViewportAnchor);
 
@@ -220,20 +178,6 @@ export const useChatTimelineScroll = ({
         }
     }, []);
 
-    const clearDelayedRepin = React.useCallback(() => {
-        if (delayedRepinTimerRef.current !== null) {
-            clearTimeout(delayedRepinTimerRef.current);
-            delayedRepinTimerRef.current = null;
-        }
-    }, []);
-
-    const recordScrollDirection = React.useCallback((scrollOffset: number) => {
-        if (scrollOffset === lastScrollOffsetRef.current) return;
-        const previousOffset = lastScrollOffsetRef.current;
-        lastScrollOffsetRef.current = scrollOffset;
-        lastScrollDirectionDownRef.current = scrollOffset > previousOffset + 0.5;
-    }, []);
-
     const hideScrollButton = React.useCallback(() => {
         cancelShowButtonTimer();
         setShowScrollButton(false);
@@ -265,14 +209,10 @@ export const useChatTimelineScroll = ({
     // in. The anchored END SPACE stays — collapsing it mid-gesture clamps the
     // viewport back to the end — only the anchor machinery is disarmed.
     const onManualNavigation = React.useCallback(() => {
-        clearDelayedRepin();
-        lastExplicitReleaseAtRef.current = null;
         userGenerationRef.current += 1;
         modeRef.current = 'free-scrolling';
         liveFollowGenerationRef.current = null;
-        userOwnsScrollRef.current = true;
         setUserOwnsScroll(true);
-        setIsPinned(false);
         // The end may already have been left by our own movement, in which
         // case no further at-end transition will fire — and while an animated
         // follow glide trails the live edge, isAtEndRef is deliberately not
@@ -282,7 +222,6 @@ export const useChatTimelineScroll = ({
         const atEndNow = (listState ? resolveTimelineIsAtEnd(listState) : undefined) ?? isAtEndRef.current;
         isAtEndRef.current = atEndNow;
         if (!atEndNow) {
-            setIsPinned(false);
             cancelShowButtonTimer();
             setShowScrollButton(true);
         }
@@ -296,12 +235,7 @@ export const useChatTimelineScroll = ({
             cancelAnimationFrame(anchorRestoreFrameRef.current);
             anchorRestoreFrameRef.current = null;
         }
-    }, [cancelShowButtonTimer, clearDelayedRepin]);
-
-    const releaseFromUserIntent = React.useCallback(() => {
-        onManualNavigation();
-        lastExplicitReleaseAtRef.current = performance.now();
-    }, [onManualNavigation]);
+    }, [cancelShowButtonTimer]);
 
     const isLiveFollowActive = React.useCallback(() => (
         liveFollowGenerationRef.current === userGenerationRef.current
@@ -363,11 +297,8 @@ export const useChatTimelineScroll = ({
     }, []);
 
     const goToBottom = React.useCallback((mode: 'instant' | 'smooth' = 'instant') => {
-        clearDelayedRepin();
-        lastExplicitReleaseAtRef.current = null;
         isAtEndRef.current = true;
         setIsPinned(true);
-        userOwnsScrollRef.current = false;
         setUserOwnsScroll(false);
         modeRef.current = 'following-end';
         // Returning to the end is an explicit opt back IN to live follow.
@@ -390,23 +321,15 @@ export const useChatTimelineScroll = ({
                 void listRef.current?.scrollToEnd({ animated: false });
             }, delay));
         }
-    }, [clearAnchor, clearDelayedRepin, clearGoToBottomReasserts, hideScrollButton]);
+    }, [clearAnchor, clearGoToBottomReasserts, hideScrollButton]);
 
-    const scheduleRepinAfterGrace = React.useCallback((delayMs: number) => {
-        if (delayedRepinTimerRef.current !== null) return;
-        const generation = userGenerationRef.current;
-        delayedRepinTimerRef.current = setTimeout(() => {
-            delayedRepinTimerRef.current = null;
-            if (userGenerationRef.current !== generation || modeRef.current !== 'free-scrolling') return;
-            const state = listRef.current?.getState();
-            if (!state || resolveTimelineIsAtEnd(state) !== true) return;
-            const scrollNode = listRef.current?.getScrollableNode() ?? scrollRef.current;
-            const atTrueBottom = scrollNode !== null
-                && scrollNode.scrollHeight - scrollNode.scrollTop - scrollNode.clientHeight <= AUTO_MATCH_TOLERANCE_PX;
-            if (!shouldRepinReleasedAutoFollow(lastScrollDirectionDownRef.current, atTrueBottom)) return;
-            goToBottom('instant');
-        }, Math.max(0, delayMs));
-    }, [goToBottom]);
+    // User preference: with auto-follow off, streaming growth never moves the
+    // viewport. Sending from the live edge still parks the new message at the
+    // top, but no glide or end-follow correction runs afterwards; sending from
+    // mid-history leaves the viewport untouched.
+    const streamingAutoFollowEnabled = useUIStore((state) => state.streamingAutoFollowEnabled);
+    const streamingAutoFollowEnabledRef = React.useRef(streamingAutoFollowEnabled);
+    streamingAutoFollowEnabledRef.current = streamingAutoFollowEnabled;
 
     // Sending arms the anchor. The message id is not known here (the optimistic
     // row is created by the store), so the next new user message id claims it.
@@ -418,11 +341,13 @@ export const useChatTimelineScroll = ({
     const anchorPositionInstantRef = React.useRef(false);
 
     const scrollToBottomOnSend = React.useCallback(() => {
-        clearDelayedRepin();
-        lastExplicitReleaseAtRef.current = null;
+        // With auto-follow off, a reader who scrolled away from the end stays
+        // exactly where they are: the sent message is not anchored and the
+        // scroll-to-bottom pill (already showing) leads to it. From the live
+        // edge, sending anchors the new turn as usual.
+        if (!streamingAutoFollowEnabledRef.current && !isAtEndRef.current) return;
         anchorPositionInstantRef.current = !isAtEndRef.current;
         isAtEndRef.current = true;
-        userOwnsScrollRef.current = false;
         setUserOwnsScroll(false);
         modeRef.current = 'anchoring-new-turn';
         liveFollowGenerationRef.current = userGenerationRef.current;
@@ -436,7 +361,7 @@ export const useChatTimelineScroll = ({
         settledAnchorRef.current = null;
         activeAnchorIndexRef.current = null;
         hideScrollButton();
-    }, [clearDelayedRepin, hideScrollButton]);
+    }, [hideScrollButton]);
 
     // Claim the anchor as soon as the sent row exists in the timeline. The
     // comparison is against the baseline captured when the send armed the
@@ -459,10 +384,7 @@ export const useChatTimelineScroll = ({
 
         // Entering a session always returns to the live edge. Late async growth
         // is handled by the list staying at the end, not by a timed hold.
-        clearDelayedRepin();
-        lastExplicitReleaseAtRef.current = null;
         isAtEndRef.current = true;
-        userOwnsScrollRef.current = false;
         setUserOwnsScroll(false);
         modeRef.current = 'following-end';
         liveFollowGenerationRef.current = userGenerationRef.current;
@@ -470,7 +392,7 @@ export const useChatTimelineScroll = ({
         hideScrollButton();
         void listRef.current?.scrollToEnd({ animated: false });
         return false;
-    }, [clearAnchor, clearDelayedRepin, hideScrollButton]);
+    }, [clearAnchor, hideScrollButton]);
 
     // ── list callbacks ──────────────────────────────────────────────────────
     const registerList = React.useCallback((list: TimelineListHandle | null) => {
@@ -481,9 +403,6 @@ export const useChatTimelineScroll = ({
     }, []);
 
     const onIsAtEndChange = React.useCallback((isAtEnd: boolean) => {
-        const listState = listRef.current?.getState();
-        if (listState) recordScrollDirection(listState.scroll);
-
         // While an automatic movement owns the viewport, leaving the end is our
         // own doing (the anchored turn parks mid-timeline, the glide trails its
         // target between corrections) — not a reason to offer the pill. Only a
@@ -492,38 +411,6 @@ export const useChatTimelineScroll = ({
             hideScrollButton();
             return;
         }
-
-        if (isAtEnd && modeRef.current === 'free-scrolling') {
-            const releasedAt = lastExplicitReleaseAtRef.current;
-            const scrollNode = listRef.current?.getScrollableNode() ?? scrollRef.current;
-            const atTrueBottom = scrollNode !== null
-                && scrollNode.scrollHeight - scrollNode.scrollTop - scrollNode.clientHeight <= AUTO_MATCH_TOLERANCE_PX;
-
-            isAtEndRef.current = true;
-            if (!shouldRepinReleasedAutoFollow(lastScrollDirectionDownRef.current, atTrueBottom)) {
-                clearDelayedRepin();
-                setIsPinned(false);
-                hideScrollButton();
-                queueSave();
-                return;
-            }
-            setIsPinned(false);
-            if (releasedAt !== null) {
-                const currentTime = performance.now();
-                if (shouldDelayAutoFollowRepin(releasedAt, currentTime, REPIN_GRACE_AFTER_RELEASE_MS)) {
-                    scheduleRepinAfterGrace(REPIN_GRACE_AFTER_RELEASE_MS - (currentTime - releasedAt));
-                    hideScrollButton();
-                    queueSave();
-                    return;
-                }
-                lastExplicitReleaseAtRef.current = null;
-            }
-            clearDelayedRepin();
-            goToBottom('instant');
-            return;
-        }
-
-        if (!isAtEnd) clearDelayedRepin();
         if (isAtEndRef.current === isAtEnd) return;
         isAtEndRef.current = isAtEnd;
         setIsPinned(isAtEnd);
@@ -532,7 +419,6 @@ export const useChatTimelineScroll = ({
                 modeRef.current = 'following-end';
             }
             liveFollowGenerationRef.current = userGenerationRef.current;
-            userOwnsScrollRef.current = false;
             setUserOwnsScroll(false);
             hideScrollButton();
         } else {
@@ -541,7 +427,7 @@ export const useChatTimelineScroll = ({
             scheduleShowScrollButton();
         }
         queueSave();
-    }, [clearDelayedRepin, goToBottom, hideScrollButton, isLiveFollowActive, queueSave, recordScrollDirection, scheduleRepinAfterGrace, scheduleShowScrollButton]);
+    }, [hideScrollButton, isLiveFollowActive, queueSave, scheduleShowScrollButton]);
 
     // Park the anchored row near the top once the list has measured it.
     const onAnchorReady = React.useCallback((messageId: string, anchorIndex: number) => {
@@ -672,13 +558,6 @@ export const useChatTimelineScroll = ({
         first: null,
         second: null,
     });
-    // User preference: with auto-follow off, streaming growth never moves the
-    // viewport — the anchored user message still parks at the top on send, but
-    // no glide or end-follow correction runs afterwards.
-    const streamingAutoFollowEnabled = useUIStore((state) => state.streamingAutoFollowEnabled);
-    const streamingAutoFollowEnabledRef = React.useRef(streamingAutoFollowEnabled);
-    streamingAutoFollowEnabledRef.current = streamingAutoFollowEnabled;
-
     // While the list width is resizing, every pinning write fights the
     // per-frame row re-measure and the pinned viewport shakes. Corrections
     // stand down for the whole resize and the visible content is held by the
@@ -720,6 +599,27 @@ export const useChatTimelineScroll = ({
         };
     }, [scrollNode]);
 
+    // Keep the live edge in view after content growth. Within a viewport of
+    // the end the remaining distance is glided so a revealed block and the
+    // scroll read as one motion; further behind, the viewport first jumps to
+    // one screen above the end and glides only that last screen, so the
+    // reader is never left staring at a gap several screens tall. Writes go
+    // to the scroll node directly: routing each chunk through the list's
+    // scrollToEnd bookkeeping roughly doubled frame production when measured.
+    // A user gesture interrupts the native smooth scroll on its own, and the
+    // gesture handler drops live follow so no later correction re-engages.
+    const followEnd = React.useCallback(() => {
+        const node = scrollRef.current;
+        if (!node) return;
+        const end = node.scrollHeight - node.clientHeight;
+        const distance = end - node.scrollTop;
+        if (distance <= 1) return;
+        if (distance > node.clientHeight) {
+            node.scrollTop = end - node.clientHeight;
+        }
+        node.scrollTo({ top: end, behavior: 'smooth' });
+    }, []);
+
     const onTimelineDataChange = React.useCallback(() => {
         if (widthResizingRef.current) return;
 
@@ -775,12 +675,18 @@ export const useChatTimelineScroll = ({
         }
         if (!isLiveFollowActive()) return;
 
-        // Since @legendapp/list 3.3.x, maintainScrollAtEnd follows content
-        // growth on its own — including a tail row growing in place — and
-        // releases when the user scrolls away. Following the end therefore
-        // needs no correction here; this handler only serves the
-        // anchored-turn glide below.
-        if (modeRef.current === 'following-end') return;
+        // Following the end is owned here, not left to the list's
+        // maintainScrollAtEnd. The list's animated maintain is single-flight:
+        // growth that lands while a glide is still in flight is dropped until
+        // the next trigger, and its re-pin threshold is a tenth of the
+        // viewport. In a narrow viewport (the VS Code sidebar) one revealed
+        // block is several viewports tall, so every block left the reader a
+        // second behind and multiple screens above the live edge — measured
+        // at 45% of the stream time spent 500-1600px behind at 420x640.
+        if (modeRef.current === 'following-end') {
+            followEnd();
+            return;
+        }
 
         const frames = dataChangeFramesRef.current;
         if (frames.first !== null) cancelAnimationFrame(frames.first);
@@ -829,7 +735,7 @@ export const useChatTimelineScroll = ({
 
             });
         });
-    }, [isLiveFollowActive, scheduleShowScrollButton]);
+    }, [followEnd, isLiveFollowActive, scheduleShowScrollButton]);
 
     // The streaming tail grows inside one row without changing the entries
     // array, so data-change callbacks are silent for the entire stream. The
@@ -848,14 +754,11 @@ export const useChatTimelineScroll = ({
     }, [scrollNode]);
 
     // ── gesture opt-out ─────────────────────────────────────────────────────
-    const releaseFromUserIntentRef = React.useRef(releaseFromUserIntent);
-    releaseFromUserIntentRef.current = releaseFromUserIntent;
+    const onManualNavigationRef = React.useRef(onManualNavigation);
+    onManualNavigationRef.current = onManualNavigation;
 
     React.useEffect(() => {
         if (!scrollNode) return;
-        const initialScroll = listRef.current?.getState().scroll ?? scrollNode.scrollTop;
-        lastScrollOffsetRef.current = initialScroll;
-        lastScrollDirectionDownRef.current = false;
 
         // A gesture is meaningful when the viewport can move up AT ALL:
         // either the real rows overflow the viewport, or there is scrolled
@@ -871,11 +774,15 @@ export const useChatTimelineScroll = ({
             return realContentOverflowsViewport(list);
         };
         const gesture = () => {
-            releaseFromUserIntentRef.current();
+            onManualNavigationRef.current();
         };
         const handleWheel = (event: WheelEvent) => {
-            // Scrolling toward the end is not opting out of follow.
-            if (event.deltaY < 0 && !nestedScrollableCanConsumeUp(scrollNode, event.target) && canScrollUp()) gesture();
+            // Scrolling toward the end is not opting out of follow, and an
+            // upward wheel that a nested scroller still consumes never
+            // reaches the timeline.
+            if (event.deltaY < 0 && !nestedScrollableConsumesWheelUp(scrollNode, event.target) && canScrollUp()) {
+                gesture();
+            }
         };
         // Touch mirrors wheel by finger direction, not by having already left
         // the end: while a stream keeps re-pinning the viewport, waiting for
@@ -892,48 +799,30 @@ export const useChatTimelineScroll = ({
             touchLastY = y;
             if (y === null) return;
             // A downward finger drags the content up — the touch wheel-up.
-            const draggedUp = lastY !== null && y - lastY > TOUCH_FINGER_DOWN_THRESHOLD_PX;
-            if ((draggedUp || !isAtEndRef.current)
-                && !nestedScrollableCanConsumeUp(scrollNode, event.target)
-                && canScrollUp()) gesture();
+            const draggedUp = lastY !== null && y > lastY;
+            if ((draggedUp || !isAtEndRef.current) && canScrollUp()) gesture();
         };
         const handleTouchEnd = () => {
             touchLastY = null;
         };
         const handlePointerDown = (event: PointerEvent) => {
-            if (event.button === 1) {
-                if (isMiddleButtonAutoScrollIntent(scrollNode, event) && canScrollUp()) gesture();
+            // A middle-button pan scrolls without wheel events (and is the
+            // only scroll gesture for wheel-less mice), so the press is the
+            // opt-out. Otherwise the scrollbar track is the scroll node
+            // itself; a tap on a row only breaks follow when the viewport
+            // already left the end.
+            if (isMiddleButtonPan(scrollNode, event)) {
+                if (canScrollUp()) gesture();
                 return;
             }
-            // The scrollbar track is the scroll node itself; a tap on a row
-            // only breaks follow when the viewport already left the end.
             if ((event.target === scrollNode || !isAtEndRef.current) && canScrollUp()) gesture();
         };
         const handleKeyDown = (event: KeyboardEvent) => {
-            if (isAutoFollowReleaseKey(event) && canScrollUp()) gesture();
+            if (isFollowReleaseKey(event) && canScrollUp()) gesture();
         };
         const handleScroll = () => {
-            const scrollOffset = listRef.current?.getState().scroll ?? scrollNode.scrollTop;
-            const previousOffset = lastScrollOffsetRef.current;
-            recordScrollDirection(scrollOffset);
-            if (scrollOffset !== previousOffset && scrollOffset <= previousOffset + 0.5) {
-                clearDelayedRepin();
-            }
-            const state = listRef.current?.getState();
-            if (modeRef.current === 'free-scrolling' && resolveTimelineIsAtEnd(state) === true) {
-                onIsAtEndChange(true);
-            }
             queueSave();
         };
-        const handleMouseDown = (event: MouseEvent) => {
-            if ('PointerEvent' in globalThis) return;
-            if (isMiddleButtonAutoScrollIntent(scrollNode, event) && canScrollUp()) gesture();
-        };
-        const handleOverlayScrollbarPointerDown = (event: PointerEvent) => {
-            const target = event.target;
-            if (!(target instanceof Element) || !target.closest('[data-overlay-scrollbar-thumb]')) return;
-            if (canScrollUp()) gesture();
-        };
 
         scrollNode.addEventListener('wheel', handleWheel, { passive: true });
         scrollNode.addEventListener('touchstart', handleTouchStart, { passive: true });
@@ -941,10 +830,8 @@ export const useChatTimelineScroll = ({
         scrollNode.addEventListener('touchend', handleTouchEnd, { passive: true });
         scrollNode.addEventListener('touchcancel', handleTouchEnd, { passive: true });
         scrollNode.addEventListener('pointerdown', handlePointerDown, { passive: true });
-        scrollNode.addEventListener('mousedown', handleMouseDown, { passive: true });
         scrollNode.addEventListener('keydown', handleKeyDown);
         scrollNode.addEventListener('scroll', handleScroll, { passive: true });
-        window.addEventListener('pointerdown', handleOverlayScrollbarPointerDown, true);
 
         return () => {
             scrollNode.removeEventListener('wheel', handleWheel);
@@ -953,12 +840,10 @@ export const useChatTimelineScroll = ({
             scrollNode.removeEventListener('touchend', handleTouchEnd);
             scrollNode.removeEventListener('touchcancel', handleTouchEnd);
             scrollNode.removeEventListener('pointerdown', handlePointerDown);
-            scrollNode.removeEventListener('mousedown', handleMouseDown);
             scrollNode.removeEventListener('keydown', handleKeyDown);
             scrollNode.removeEventListener('scroll', handleScroll);
-            window.removeEventListener('pointerdown', handleOverlayScrollbarPointerDown, true);
         };
-    }, [clearDelayedRepin, onIsAtEndChange, queueSave, realContentOverflowsViewport, recordScrollDirection, scrollNode]);
+    }, [queueSave, realContentOverflowsViewport, scrollNode]);
 
     // ── session lifecycle ───────────────────────────────────────────────────
     const lastSessionKeyRef = React.useRef<string | null>(null);
@@ -970,16 +855,13 @@ export const useChatTimelineScroll = ({
         MessageFreshnessDetector.getInstance().recordSessionStart(currentSessionId);
         // Persist the outgoing session's position before the new one takes over.
         flushSave();
-        clearDelayedRepin();
-        lastExplicitReleaseAtRef.current = null;
         isAtEndRef.current = true;
-        userOwnsScrollRef.current = false;
         setUserOwnsScroll(false);
         modeRef.current = 'following-end';
         liveFollowGenerationRef.current = userGenerationRef.current;
         clearAnchor();
         hideScrollButton();
-    }, [clearAnchor, clearDelayedRepin, currentSessionId, currentSessionKey, flushSave, hideScrollButton]);
+    }, [clearAnchor, currentSessionId, currentSessionKey, flushSave, hideScrollButton]);
 
     // Suppress the overlay scrollbar thumb while automatic movement owns the
     // scroll position, so it does not jump on each correction.
@@ -989,13 +871,12 @@ export const useChatTimelineScroll = ({
 
     React.useEffect(() => () => {
         cancelShowButtonTimer();
-        clearDelayedRepin();
         if (saveTimerRef.current !== null) clearTimeout(saveTimerRef.current);
         if (anchorRestoreFrameRef.current !== null) cancelAnimationFrame(anchorRestoreFrameRef.current);
         const frames = dataChangeFramesRef.current;
         if (frames.first !== null) cancelAnimationFrame(frames.first);
         if (frames.second !== null) cancelAnimationFrame(frames.second);
-    }, [cancelShowButtonTimer, clearDelayedRepin]);
+    }, [cancelShowButtonTimer]);
 
     // ── active-turn spy ─────────────────────────────────────────────────────
     // Reads turn positions straight from the DOM, so it is unaffected by which

packages/ui/src/hooks/useRootScrollLock.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test';
+
+import { isRootScrollTarget, resetRootScroll } from './useRootScrollLock';
+
+type FakeElement = EventTarget & { id: string; scrollTop: number; scrollLeft: number };
+
+const element = (id: string): FakeElement => Object.assign(new EventTarget(), { id, scrollTop: 0, scrollLeft: 0 });
+
+/** Installs a minimal stand-in for `document` for the duration of `run`. */
+const withDocument = (setup: { root?: FakeElement }, run: () => void) => {
+  const fakeDocument = {
+    documentElement: element('html'),
+    body: element('body'),
+    getElementById: (id: string) => (setup.root && setup.root.id === id ? setup.root : null),
+  };
+  // The hook only reads documentElement/body/getElementById from `document`;
+  // this stand-in provides exactly those members for a DOM-less test process.
+  const hadDocument = 'document' in globalThis;
+  const previous = hadDocument ? globalThis.document : undefined;
+  Reflect.set(globalThis, 'document', fakeDocument);
+  try {
+    run();
+  } finally {
+    if (hadDocument) Reflect.set(globalThis, 'document', previous);
+    else Reflect.deleteProperty(globalThis, 'document');
+  }
+};
+
+describe('resetRootScroll', () => {
+  test('snaps every root scroll offset back to zero and reports the reset', () => {
+    const root = element('root');
+    withDocument({ root }, () => {
+      document.documentElement.scrollTop = 48;
+      document.body.scrollLeft = 12;
+      root.scrollTop = 200;
+      expect(resetRootScroll()).toBe(true);
+      expect(document.documentElement.scrollTop).toBe(0);
+      expect(document.body.scrollLeft).toBe(0);
+      expect(root.scrollTop).toBe(0);
+    });
+  });
+
+  test('reports nothing to do when the root is already at zero', () => {
+    withDocument({}, () => {
+      expect(resetRootScroll()).toBe(false);
+    });
+  });
+});
+
+describe('isRootScrollTarget', () => {
+  test('recognises the document, html and body as root scroll sources', () => {
+    withDocument({}, () => {
+      expect(isRootScrollTarget(document)).toBe(true);
+      expect(isRootScrollTarget(document.documentElement)).toBe(true);
+      expect(isRootScrollTarget(document.body)).toBe(true);
+    });
+  });
+
+  test('ignores scroll events from inner containers', () => {
+    withDocument({}, () => {
+      expect(isRootScrollTarget(element('chat-timeline'))).toBe(false);
+    });
+  });
+});

packages/ui/src/hooks/useRootScrollLock.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+
+/**
+ * The document root (`html`, `body`, `#root`) is `overflow: hidden` and must
+ * never scroll — every scrollable area lives in a dedicated container. Chromium
+ * still scrolls hidden-overflow ancestors programmatically, most visibly when
+ * a textarea caret moves out of view (PageUp/PageDown in the prompt box, or a
+ * long prompt being typed) and the browser scrolls it into view. Once that
+ * happens the whole app shifts up, hides the title bar, and nothing the user
+ * does with the wheel or keyboard can scroll it back.
+ *
+ * Snap every root scroll straight back to zero.
+ */
+
+const rootScrollTargets = (): HTMLElement[] => {
+  const targets = [document.documentElement, document.body];
+  const appRoot = document.getElementById('root');
+  if (appRoot) targets.push(appRoot);
+  return targets;
+};
+
+export const resetRootScroll = (): boolean => {
+  let reset = false;
+  for (const target of rootScrollTargets()) {
+    if (target.scrollTop !== 0) {
+      target.scrollTop = 0;
+      reset = true;
+    }
+    if (target.scrollLeft !== 0) {
+      target.scrollLeft = 0;
+      reset = true;
+    }
+  }
+  return reset;
+};
+
+export const isRootScrollTarget = (target: EventTarget | null): boolean =>
+  target === document || rootScrollTargets().some((element) => element === target);
+
+export const useRootScrollLock = (): void => {
+  React.useEffect(() => {
+    const handleScroll = (event: Event) => {
+      if (isRootScrollTarget(event.target)) resetRootScroll();
+    };
+    // Capture: the root's own scroll events don't bubble to inner listeners,
+    // and scroll events from inner containers are filtered out above.
+    document.addEventListener('scroll', handleScroll, { capture: true, passive: true });
+    resetRootScroll();
+    return () => document.removeEventListener('scroll', handleScroll, { capture: true });
+  }, []);
+};

packages/ui/src/index.css

@@ -1039,6 +1039,18 @@ html:not(.dark) .chat-scroll {
   font-size: var(--text-code) !important;
 }
 
+.question-markdown > .markdown-content.markdown-tool {
+  font-size: inherit !important;
+}
+
+.question-markdown > .markdown-content > [data-md-block]:first-child > :first-child {
+  margin-top: 0;
+}
+
+.question-markdown > .markdown-content > [data-md-block]:last-child > :last-child {
+  margin-bottom: 0;
+}
+
 /* Reasoning markdown renders at meta size, dimmed. */
 .markdown-content.markdown-reasoning {
   font-size: var(--text-markdown);
@@ -1138,8 +1150,10 @@ html:not(.dark) .chat-scroll {
 
 /* Override Streamdown's hardcoded bg-muted for inline code - use theme colors instead */
 .markdown-content code[data-markdown="inline-code"] {
-  background-color: var(--markdown-inline-code-bg, var(--surface-muted)) !important;
+  background-color: var(--markdown-inline-code-bg, var(--surface-subtle)) !important;
   color: var(--markdown-inline-code, var(--foreground)) !important;
+  padding: 0.125rem 0.3125rem;
+  border-radius: 0.375rem;
   word-break: break-all;
   overflow-wrap: break-word;
 }

packages/ui/src/lib/api/types.ts

@@ -807,6 +807,8 @@ export interface VSCodeAPI {
   pickFiles?(options?: { extensions?: string[] }): Promise<unknown>;
   saveImage?(payload: unknown): Promise<unknown>;
   saveMarkdown?(payload: unknown): Promise<unknown>;
+  /** Add a directory as a VS Code workspace folder; resolves with the full folder list after the add. */
+  addWorkspaceFolder?(path: string): Promise<Array<{ name: string; path: string }>>;
 }
 
 export interface PushSubscribePayload {

packages/ui/src/lib/btw.test.ts

@@ -16,6 +16,7 @@ const upsertedSessions: unknown[] = [];
 const childStoreSessions: Session[] = [];
 const currentSessionSwitches: string[] = [];
 const metadataPatches: Array<{ sessionId: string; result: Record<string, unknown> }> = [];
+const parentSyncMessages: Message[] = [];
 
 mock.module('@/lib/opencode/client', () => ({
   opencodeClient: {
@@ -48,6 +49,7 @@ mock.module('@/stores/useGlobalSessionsStore', () => ({
 }));
 mock.module('@/sync/sync-refs', () => ({
   registerSessionDirectory: (sessionId: string, directory: string) => { registeredDirectories.push(`${sessionId}:${directory}`); },
+  getSyncMessages: () => parentSyncMessages,
   getSyncChildStores: () => ({
     children: new Map([['/project', {
       getState: () => ({ session: childStoreSessions }),
@@ -56,7 +58,7 @@ mock.module('@/sync/sync-refs', () => ({
   }),
 }));
 
-const { btwSessionTitle, startBtwSession, destroyBtwSession, promoteBtwSession, filterBtwTailMessages } =
+const { btwSessionTitle, startBtwSession, destroyBtwSession, promoteBtwSession, filterBtwTailMessages, findLastCompletedAssistantMessageID, BTW_BOUNDARY_INSTRUCTION, BTW_PROMOTION_NOTICE, buildBtwSyntheticTexts } =
   await import('@/lib/btw');
 const { useBtwStore } = await import('@/stores/useBtwStore');
 
@@ -74,6 +76,15 @@ const record = (id: string): { info: Message; parts: Part[] } => ({
   parts: [],
 });
 
+// SAFETY: `findLastCompletedAssistantMessageID` reads only `id`, `role` and
+// `time`, which are the fields spelled out here.
+const assistantMessage = (id: string, completed?: number) =>
+  ({ id, sessionID: 'parent-1', role: 'assistant', time: { created: 1, completed } }) as Message;
+
+// SAFETY: same narrow read as `assistantMessage`.
+const userMessage = (id: string) =>
+  ({ id, sessionID: 'parent-1', role: 'user', time: { created: 1 } }) as Message;
+
 const startInput = {
   parentSessionId: 'parent-1',
   question: 'wtf is kafka',
@@ -90,6 +101,7 @@ beforeEach(() => {
   childStoreSessions.length = 0;
   currentSessionSwitches.length = 0;
   metadataPatches.length = 0;
+  parentSyncMessages.length = 0;
   useBtwStore.setState({ byParent: {} });
   forkSessionImpl = () => Promise.reject(new Error('no forkSession stub'));
   getSessionMessagesImpl = () => Promise.resolve([record('msg-boundary')]);
@@ -121,6 +133,17 @@ describe('filterBtwTailMessages', () => {
   });
 });
 
+describe('findLastCompletedAssistantMessageID', () => {
+  test('skips an assistant turn that is still streaming', () => {
+    const messages = [assistantMessage('msg-1', 10), userMessage('msg-2'), assistantMessage('msg-3')];
+    expect(findLastCompletedAssistantMessageID(messages)).toBe('msg-1');
+  });
+
+  test('a session with no completed assistant turn has no fork point', () => {
+    expect(findLastCompletedAssistantMessageID([userMessage('msg-1')])).toBe(null);
+  });
+});
+
 describe('startBtwSession', () => {
   test('forks, marks the fork, links the parent, and routes the question to the fork', async () => {
     forkSessionImpl = (sessionId, messageId, directory) => {
@@ -151,6 +174,45 @@ describe('startBtwSession', () => {
     expect(useBtwStore.getState().byParent).toEqual({});
   });
 
+  test('forks at the last completed assistant turn, not at the in-flight one', async () => {
+    parentSyncMessages.push(assistantMessage('msg-1', 10), userMessage('msg-2'), assistantMessage('msg-3'));
+    const forkPoints: Array<string | undefined> = [];
+    forkSessionImpl = (_sessionId, messageId) => {
+      forkPoints.push(messageId);
+      return Promise.resolve(makeSession('fork-1', '/project'));
+    };
+
+    await startBtwSession(startInput);
+
+    expect(forkPoints).toEqual(['msg-1']);
+  });
+
+  test('the boundary falls back to the fork point when the cloned tail reads empty', async () => {
+    parentSyncMessages.push(assistantMessage('msg-1', 10));
+    forkSessionImpl = () => Promise.resolve(makeSession('fork-1', '/project'));
+    getSessionMessagesImpl = () => Promise.resolve([]);
+
+    await startBtwSession(startInput);
+
+    // Not `null`: a null boundary would show the whole inherited transcript.
+    expect(metadataPatches[0]?.result).toEqual({
+      openchamber: { kind: 'btw', originalSessionID: 'parent-1', btwBoundaryMessageID: 'msg-1' },
+    });
+  });
+
+  test('the first question carries the boundary instruction as a synthetic part', async () => {
+    forkSessionImpl = () => Promise.resolve(makeSession('fork-1', '/project'));
+    const sentParts: unknown[] = [];
+    sendMessageImpl = (...args) => {
+      sentParts.push(args[6]);
+      return Promise.resolve();
+    };
+
+    await startBtwSession(startInput);
+
+    expect(sentParts).toEqual([[{ text: BTW_BOUNDARY_INSTRUCTION, synthetic: true }]]);
+  });
+
   test('an empty parent produces a marker without a boundary', async () => {
     forkSessionImpl = () => Promise.resolve(makeSession('fork-1', '/project'));
     getSessionMessagesImpl = () => Promise.resolve([]);
@@ -229,7 +291,9 @@ describe('promoteBtwSession', () => {
 
     expect(metadataPatches).toEqual([
       { sessionId: 'parent-1', result: {} },
-      { sessionId: 'fork-1', result: {} },
+      // The fork stops being a btw session but stays marked as promoted: its
+      // transcript still carries the boundary instructions.
+      { sessionId: 'fork-1', result: { openchamber: { btwPromoted: true } } },
     ]);
     expect(currentSessionSwitches).toEqual(['fork-1']);
   });
@@ -240,3 +304,24 @@ describe('promoteBtwSession', () => {
     expect(currentSessionSwitches).toEqual([]);
   });
 });
+
+describe('buildBtwSyntheticTexts', () => {
+  test('a send routed to an active fork carries only the boundary instruction', () => {
+    // Regression: a promoted parent that opens a new btw fork used to send the
+    // promotion notice into the fork alongside the boundary instruction, telling
+    // the fork both that btw constraints apply and that they no longer apply.
+    expect(buildBtwSyntheticTexts({ isBtwActive: true, isPromotedBtwSession: true }))
+      .toEqual([BTW_BOUNDARY_INSTRUCTION]);
+    expect(buildBtwSyntheticTexts({ isBtwActive: true, isPromotedBtwSession: false }))
+      .toEqual([BTW_BOUNDARY_INSTRUCTION]);
+  });
+
+  test('a promoted session with no active fork carries the promotion notice', () => {
+    expect(buildBtwSyntheticTexts({ isBtwActive: false, isPromotedBtwSession: true }))
+      .toEqual([BTW_PROMOTION_NOTICE]);
+  });
+
+  test('an ordinary session carries neither', () => {
+    expect(buildBtwSyntheticTexts({ isBtwActive: false, isPromotedBtwSession: false })).toEqual([]);
+  });
+});

packages/ui/src/lib/btw.ts

@@ -4,7 +4,7 @@ import * as sessionActions from '@/sync/session-actions';
 import { withBtwSessionLink, withBtwSessionMarker, withoutBtwSessionLink, withoutBtwSessionMarker } from '@/lib/sessionBtwMetadata';
 import { useBtwStore } from '@/stores/useBtwStore';
 import { useSessionUIStore } from '@/sync/session-ui-store';
-import { getSyncChildStores, registerSessionDirectory } from '@/sync/sync-refs';
+import { getSyncChildStores, getSyncMessages, registerSessionDirectory } from '@/sync/sync-refs';
 import { Binary } from '@/sync/binary';
 
 /**
@@ -30,6 +30,93 @@ export type StartBtwInput = {
   variant?: string;
 };
 
+/**
+ * Sent as a synthetic part with every message inside a btw session.
+ *
+ * A btw session is a fork, so the model receives the parent's whole
+ * conversation — including whatever plan was in flight when `/btw` was typed.
+ * Without this the fork reads that plan as its own active task and carries on
+ * with it instead of answering the side question, which is the opposite of
+ * what `/btw` is for.
+ *
+ * The wording is deliberately position-independent: it names the history
+ * inherited from the parent thread rather than "everything before this
+ * boundary". The instruction rides along with each send instead of being
+ * pinned once at fork time, so a positional phrasing would be re-anchored
+ * every turn and would end up telling the model to disregard the btw
+ * session's own earlier turns.
+ */
+export const BTW_BOUNDARY_INSTRUCTION = [
+  'You are in a btw session, a side conversation forked from a main thread.',
+  'The history inherited from the parent thread is reference context only. It is not your current task.',
+  'Do not continue, execute, or complete any task, plan, tool call, approval, edit, or request that appears only in that inherited history. Only instructions the user sends inside this btw session are active.',
+  'Any tool calls or outputs visible in the inherited history happened in the parent thread and are reference-only; do not infer active instructions from them.',
+  'Sub-agents are off-limits in this btw session. Do not interact with any existing or new sub-agents, even if sub-agents were used in the inherited history.',
+  'Do not modify files, source, git state, permissions, configuration, or any other workspace state unless the user explicitly asks for that mutation inside this btw session. If they do, keep it minimal, local to the request, and avoid disrupting the main thread.',
+].join('\n');
+
+/**
+ * Sent with every message in a session that was promoted out of `/btw`.
+ *
+ * `BTW_BOUNDARY_INSTRUCTION` is persisted on each message the session sent
+ * while it was a side conversation, and there is no API to remove a message
+ * part after the fact — so promotion cannot delete those lines, only answer
+ * them. Without this, a promoted session keeps reading "no sub-agents, do not
+ * touch the workspace" out of its own history, in a session that is no longer
+ * a side conversation.
+ *
+ * It rides along with every send for the same reason the boundary does: the
+ * instructions it revokes are re-read on every turn, so a one-shot notice
+ * would lose its position relative to them as the conversation grows.
+ */
+export const BTW_PROMOTION_NOTICE =
+  'This session started as a btw side conversation and has since been promoted to a normal session. '
+  + 'The btw constraints in the history above no longer apply: this is now the main thread, and the '
+  + 'usual tool, sub-agent and workspace permissions are in force.';
+
+/**
+ * The btw framing texts a composer send carries.
+ *
+ * The boundary instruction rides with every send routed to an active btw fork,
+ * so the inherited transcript stays reference material for the whole side
+ * conversation. The promotion notice is the opposite case: it tells a promoted
+ * session that the btw constraints in its own history are lifted. A send routed
+ * to a fresh fork is never that session, so the two never travel together.
+ */
+export const buildBtwSyntheticTexts = (state: {
+  isBtwActive: boolean;
+  isPromotedBtwSession: boolean;
+}): string[] => {
+  if (state.isBtwActive) return [BTW_BOUNDARY_INSTRUCTION];
+  return state.isPromotedBtwSession ? [BTW_PROMOTION_NOTICE] : [];
+};
+
+/** The boundary as an `additionalParts` entry for `sendMessage`. */
+const btwBoundaryParts = (): Array<{ text: string; synthetic: true }> =>
+  [{ text: BTW_BOUNDARY_INSTRUCTION, synthetic: true }];
+
+/**
+ * The parent's last assistant turn that actually finished.
+ *
+ * `/btw` is typically typed *while* the main thread is working — that is the
+ * moment a side question comes up. Forking at HEAD then clones a turn that is
+ * still streaming: the fork inherits a truncated assistant message and the
+ * user instruction that provoked it as the newest, most salient thing in its
+ * context. Anchoring the fork to the last completed turn instead means the
+ * inherited transcript is always a settled conversation.
+ *
+ * Returns `null` when the parent has no completed assistant turn yet (a brand
+ * new session); the caller then keeps the previous fork-at-HEAD behavior.
+ */
+export const findLastCompletedAssistantMessageID = (messages: readonly Message[]): string | null => {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== 'assistant') continue;
+    if (message.time.completed !== undefined) return message.id;
+  }
+  return null;
+};
+
 export const btwSessionTitle = (question: string): string => `btw: ${question}`;
 
 /**
@@ -53,7 +140,16 @@ export async function startBtwSession(input: StartBtwInput): Promise<Session> {
   setPanelState(input.parentSessionId, { creating: true });
   try {
     await sessionActions.waitForConnectionOrThrow();
-    const forked = await opencodeClient.forkSession(input.parentSessionId, undefined, input.directory);
+    // Fork at the parent's last completed assistant turn rather than at HEAD,
+    // so a `/btw` typed mid-turn does not inherit a half-finished one.
+    const forkPointMessageID = findLastCompletedAssistantMessageID(
+      getSyncMessages(input.parentSessionId, input.directory),
+    );
+    const forked = await opencodeClient.forkSession(
+      input.parentSessionId,
+      forkPointMessageID ?? undefined,
+      input.directory,
+    );
 
     // The server may canonicalize the worktree path; the prompt must use the
     // same directory identity as the forked session.
@@ -67,7 +163,14 @@ export async function startBtwSession(input: StartBtwInput): Promise<Session> {
       // id of the newest cloned message. Message ids are server-generated and
       // ascending, so everything the fork produces sorts after it.
       const newestCloned = await opencodeClient.getSessionMessages(forked.id, 1, sessionDirectory);
-      const boundaryMessageID = newestCloned[newestCloned.length - 1]?.info.id ?? null;
+      // A `null` boundary makes the panel show every inherited message, so an
+      // empty read must not be taken as "the fork inherited nothing" when we
+      // know it did: having picked a fork point proves the parent had turns.
+      // Fall back to that id — the fork's own messages are created later and
+      // still sort after it, so the tail stays complete either way.
+      const boundaryMessageID = newestCloned[newestCloned.length - 1]?.info.id
+        ?? forkPointMessageID
+        ?? null;
 
       // The fork inherits the parent's metadata and title wholesale: replace
       // the metadata with the btw marker, and rename it (rename is
@@ -95,7 +198,10 @@ export async function startBtwSession(input: StartBtwInput): Promise<Session> {
           input.agent,
           [],
           undefined,
-          undefined,
+          // The very first question already needs the boundary: the fork is at
+          // its most dangerous here, with the parent's in-flight plan as the
+          // newest thing in its context.
+          btwBoundaryParts(),
           input.variant,
           'normal',
           { sessionId: forked.id, directory: sessionDirectory },

packages/ui/src/lib/desktop.ts

@@ -810,7 +810,11 @@ export const restartToApplyUpdate = async (): Promise<boolean> => {
     return false;
   }
 
-  return restartDesktopApp();
+  // Unlike a plain restart, an install failure (rejected signature, disabled
+  // updater session) must reach the update dialog instead of being reduced to
+  // a boolean the caller cannot explain.
+  await invokeDesktop('desktop_restart');
+  return true;
 };
 
 export const restartDesktopApp = async (): Promise<boolean> => {

packages/ui/src/lib/fileOpenLimits.ts

@@ -1,4 +1,4 @@
-export const MAX_OPEN_FILE_LINES = 5_000;
+export const MAX_OPEN_FILE_LINES = 20_000;
 
 export const countLinesWithLimit = (content: string, limit: number): number => {
   if (!content) {

packages/ui/src/lib/i18n/bootstrap.ts

@@ -228,6 +228,25 @@ const DE_MESSAGES: BootstrapMessages = {
   loadingData: (providersText, agentsText) => `Daten werden geladen (${providersText}, ${agentsText})…`,
 };
 
+const TR_MESSAGES: BootstrapMessages = {
+  startingApi: 'OpenCode API başlatılıyor…',
+  initializing: 'Başlatılıyor…',
+  connecting: 'Bağlanıyor…',
+  connected: 'Bağlandı!',
+  connectionError: 'Bağlantı hatası',
+  disconnected: 'Bağlantı kesildi',
+  reconnecting: 'Yeniden bağlanıyor…',
+  initialDataLoadFailed: 'OpenCode bağlandı ancak ilk veri yükleme başarısız oldu.',
+  cliNotFound: 'OpenCode CLI bulunamadı. Lütfen önce kurun.',
+  providersReady: '✓ Sağlayıcılar',
+  providersLoading: '… Sağlayıcılar',
+  agentsReady: '✓ Agent\'ler',
+  agentsLoading: '… Agent\'ler',
+  startingDevServer: (hostLabel) => `Webview dev sunucusu başlatılıyor (${hostLabel})...`,
+  waitingDevServer: (hostLabel, attempt) => `Webview dev sunucusu bekleniyor (${hostLabel})... deneme ${attempt}`,
+  loadingData: (providersText, agentsText) => `Veriler yükleniyor (${providersText}, ${agentsText})…`,
+};
+
 export const getBootstrapMessages = (locale: Locale): BootstrapMessages => {
   return BOOTSTRAP_MESSAGES[locale];
 };
@@ -244,6 +263,7 @@ const BOOTSTRAP_MESSAGES: Record<Locale, BootstrapMessages> = {
   ko: KO_MESSAGES,
   pl: PL_MESSAGES,
   ja: JA_MESSAGES,
+  tr: TR_MESSAGES,
 };
 
 export const readStoredLocaleForBootstrap = (): Locale => {

packages/ui/src/lib/i18n/intl.ts

@@ -13,6 +13,7 @@ const INTL_LOCALE_BY_LOCALE: Record<Locale, string> = {
   ko: 'ko-KR',
   pl: 'pl-PL',
   ja: 'ja-JP',
+  tr: 'tr-TR',
 };
 
 const getIntlLocale = (locale: Locale): string => INTL_LOCALE_BY_LOCALE[locale] ?? 'en-US';

packages/ui/src/lib/i18n/messages.test.ts

@@ -11,6 +11,7 @@ import { dict as ptBrDict } from './messages/pt-BR';
 import { dict as ukDict } from './messages/uk';
 import { dict as zhCnDict } from './messages/zh-CN';
 import { dict as zhTwDict } from './messages/zh-TW';
+import { dict as trDict } from './messages/tr';
 
 const localeDictionaries = {
   en: enDict,
@@ -24,6 +25,7 @@ const localeDictionaries = {
   pl: plDict,
   'zh-CN': zhCnDict,
   'zh-TW': zhTwDict,
+  tr: trDict,
 } as const;
 
 describe('i18n dictionaries', () => {

packages/ui/src/lib/i18n/messages/de.settings.ts

@@ -1882,7 +1882,7 @@ export const settingsDict = {
   'settings.openchamber.visual.section.streaming': 'Streaming',
   'settings.openchamber.visual.field.streamingAutoFollow': 'Neuen Inhalten beim Streaming folgen',
   'settings.openchamber.visual.field.streamingAutoFollowAria': 'Neuen Inhalten automatisch folgen, während eine Antwort gestreamt wird',
-  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'Während eine Antwort eintrifft, folgt die Ansicht laufend dem neuesten Inhalt. Deaktivieren, um die Ansicht ruhig zu halten und manuell zu scrollen.',
+  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'Während eine Antwort eintrifft, folgt die Ansicht laufend dem neuesten Inhalt. Deaktivieren, um die Ansicht ruhig zu halten und manuell zu scrollen; das Senden einer Nachricht aus der Mitte des Chats lässt die Ansicht dann ebenfalls an Ort und Stelle.',
   'settings.openchamber.visual.section.messageAppearance': 'Nachrichten-Erscheinungsbild',
   'settings.openchamber.visual.section.toolsAndFiles': 'Werkzeuge & Dateien',
   'settings.openchamber.visual.section.composer': 'Komponist',

packages/ui/src/lib/i18n/messages/de.ts

@@ -15,6 +15,7 @@ export const dict = {
   'common.language.korean': 'Koreanisch',
   'common.language.polish': 'Polnisch',
   'common.language.japanese': 'Japanisch',
+  'common.language.turkish': 'Türkisch',
   'common.revealPath.finder': 'Im Finder anzeigen',
   'common.revealPath.fileExplorer': 'In Datei-Explorer öffnen',
   'common.revealPath.fileManager': 'In Dateimanager öffnen',
@@ -102,6 +103,7 @@ export const dict = {
   'mobile.sessions.section.worktrees': 'Worktrees',
   'mobile.sessions.section.otherProjects': 'Projekt wechseln',
   'mobile.sessions.section.projects': 'Projekte',
+  'mobile.sessions.section.chats': 'Chats',
   'mobile.sessions.empty.noProjectsTitle': 'Noch keine Projekte',
   'mobile.sessions.empty.noProjectsDescription': 'Füge ein Projekt hinzu, um mit deinem Code zu chatten.',
   'mobile.sessions.empty.noSessionsTitle': 'Noch keine Sitzungen',
@@ -348,7 +350,7 @@ export const dict = {
   'multirun.launcher.attachments.attach': 'Anhängen',
   'multirun.launcher.attachments.tooltip': 'Denselben Dateien an alle Durchläufe senden',
   'multirun.launcher.models.label': 'Modelle',
-  'multirun.launcher.models.info': 'Wählen Sie 2-{max} Modelle. Das gleiche Modell kann mehrfach hinzugefügt werden.',
+  'multirun.launcher.models.info': 'Wählen Sie 2 oder mehr Modelle. Das gleiche Modell kann mehrfach hinzugefügt werden.',
   'multirun.launcher.toast.fileTooLarge': 'Datei "{fileName}" ist zu groß (max. 10MB)',
   'multirun.launcher.toast.attachFailed': 'Fehler beim Anhängen von "{fileName}"',
   'multirun.launcher.toast.attachedSingle': '{count} Datei angehängt',
@@ -1779,8 +1781,6 @@ export const dict = {
   'session.newWorktree.noMatchingBranches': 'Keine übereinstimmenden Branches',
   'session.newWorktree.localBranches': 'Lokale Branches',
   'session.newWorktree.remoteBranches': 'Remote-Branches',
-  'session.newWorktree.otherLocalBranches': 'Andere lokale Branches',
-  'session.newWorktree.otherRemoteBranches': 'Andere Remote-Branches',
   'session.newWorktree.branchName': 'Branch-Name',
   'session.newWorktree.branchNamePlaceholder': 'feature/mein-geil-feature',
   'session.newWorktree.actions.change': 'Ändern',
@@ -2107,6 +2107,7 @@ export const dict = {
   'chat.chatInput.toast.attachmentsTooLarge': 'Anhänge sind zu groß zum Senden. Bitte versuche, die Anzahl oder Größe der Bilder zu reduzieren.',
   'chat.chatInput.toast.sendAttachmentsFailed': 'Fehler beim Senden der Anhänge. Versuche weniger Dateien oder kleinere Bilder.',
   'chat.chatInput.toast.messageSendFailed': 'Nachricht konnte nicht gesendet werden. Anhänge wurden wiederhergestellt.',
+  'chat.chatInput.toast.noModelSelected': 'Wähle vor dem Senden einen Anbieter und ein Modell aus.',
   'chat.chatInput.toast.clipboardAttachFailed': 'Fehler beim Anhängen des Bildes aus der Zwischenablage',
   'chat.chatInput.toast.addedFileMentions': '{count} Datei(er) hinzugefügt',
   'chat.chatInput.toast.attachFileFailed': 'Fehler beim Anhängen der Datei',
@@ -2155,6 +2156,7 @@ export const dict = {
   'chat.toolPart.showRawJson': 'Rohe JSON anzeigen',
   'chat.toolPart.showFormattedJson': 'Formatierte JSON anzeigen',
   'chat.toolPart.showNavigableJson': 'Navigierbare JSON anzeigen',
+  'chat.toolPart.openFile': 'Datei öffnen',
   'chat.toolPart.openFileAtFirstChange': 'Datei bei erster Änderung öffnen',
   'chat.toolPart.openFileDiff': 'Datei-Unterschied öffnen',
   'chat.toolPart.copyOutput': 'Ausgabe kopieren',
@@ -2789,6 +2791,10 @@ export const dict = {
   'updateDialog.status.updating': 'Aktualisierung läuft...',
   'updateDialog.error.updateFailed': 'Aktualisierung fehlgeschlagen',
   'updateDialog.error.takingLonger': 'Die Aktualisierung dauert länger als erwartet. Warten Sie einen Moment und aktualisieren Sie die Seite oder führen Sie folgenden Befehl aus: openchamber update',
+  'updateDialog.error.signatureRejected': 'Das heruntergeladene Update wurde abgelehnt: Seine Codesignatur passt nicht zu dieser Installation. Meist bedeutet das, dass die laufende Kopie nicht aus einer offiziellen signierten Version stammt. Installieren Sie OpenChamber aus einer offiziellen Version und aktualisieren Sie erneut.',
+  'updateDialog.error.updaterDisabled': 'Der Updater wurde nach einer fehlgeschlagenen Installation gestoppt. Beenden Sie OpenChamber, öffnen Sie es erneut und versuchen Sie das Update noch einmal.',
+  'updateDialog.error.restartFailed': 'Neustart zum Installieren des Updates fehlgeschlagen.',
+  'updateDialog.error.restartUnavailable': 'Das Installieren des Updates erfordert die OpenChamber-Desktop-App.',
   'mobileUpdate.toast.available.title': 'OpenChamber-Update verfügbar',
   'mobileUpdate.toast.available.description': 'Version {version} ist für Android bereit.',
   'mobileUpdate.toast.actions.download': 'Herunterladen',
@@ -2809,6 +2815,7 @@ export const dict = {
   'memoryDebugPanel.title': 'Debug Panel',
   'memoryDebugPanel.tabs.memory': 'Speicher',
   'memoryDebugPanel.tabs.streaming': 'Streaming',
+  'memoryDebugPanel.tabs.requests': 'Anfragen',
   'memoryDebugPanel.section.sessionsInMemory': 'Sitzungen im Speicher',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UI-Streaming-Metriken',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Code Bridge Metriken',
@@ -2846,6 +2853,16 @@ export const dict = {
   'memoryDebugPanel.streaming.copy.copied': 'Streaming-Debug-JSON kopiert',
   'memoryDebugPanel.streaming.copy.failed': 'Fehler beim Kopieren der JSON-Datei',
   'memoryDebugPanel.streaming.copy.hint': 'Kopieren exportiert sowohl UI- als auch VS Code-Streaming-Metriken als JSON',
+  'memoryDebugPanel.requests.inFlight': 'Laufend',
+  'memoryDebugPanel.requests.peak': 'Spitze',
+  'memoryDebugPanel.requests.duration': 'Dauer',
+  'memoryDebugPanel.requests.totalRequests': 'Gesamtanfragen',
+  'memoryDebugPanel.requests.tracking': 'Aufzeichnung',
+  'memoryDebugPanel.requests.now': 'jetzt',
+  'memoryDebugPanel.requests.noSamples': 'Noch keine Anfragen aufgezeichnet. Lassen Sie dieses Panel geöffnet, um Fetch-Aktivität zu erfassen.',
+  'memoryDebugPanel.requests.chartLabel': 'Laufende Fetch-Anfragen im Zeitverlauf, Spitze {peak}',
+  'memoryDebugPanel.requests.windowHint': 'letzte {seconds}s',
+  'memoryDebugPanel.requests.percentileChartLabel': 'Perzentile des Alters laufender Anfragen (p50, p90, p99, max) im Zeitverlauf',
   'memoryDebugPanel.common.idle': 'inaktiv',
   'memoryDebugPanel.common.live': 'live',
   'memoryDebugPanel.common.notAvailable': 'n/a',
@@ -2909,7 +2926,7 @@ export const dict = {
   'quota.window.premium': 'Premium-Interaktionen',
   'quota.window.chat': 'Chat-Anfragen',
   'quota.window.completions': 'Vervollständigungen',
-  'quota.window.premiumInteractions': 'Premium-Interaktionen',
+  'quota.window.premiumInteractions': 'KI-Guthaben',
   'terminalView.actions.attachSelection': 'Ausgewählte Ausgabe anhängen',
   'terminalView.actions.restart': 'Terminal neu starten',
   'chat.message.terminalContext': '{terminal}, Zeilen {start}-{end}',
@@ -2977,11 +2994,33 @@ export const dict = {
   'sessions.sidebar.session.copyId.success': 'Sitzungs-ID kopiert',
   'sessions.sidebar.session.copyId.error': 'Sitzungs-ID konnte nicht kopiert werden',
   'sessions.sidebar.session.menu.moveToWorktree': 'In neuen Worktree verschieben',
+  'sessions.sidebar.session.menu.moveToWorktreeTargets': 'In Worktree verschieben',
+  'sessions.sidebar.session.menu.newWorktree': 'Neuer Worktree...',
   'sessions.sidebar.session.moveToWorktree.success': 'Sitzung in einen neuen Worktree verschoben',
   'sessions.sidebar.session.moveToWorktree.failed': 'Sitzung konnte nicht in einen neuen Worktree verschoben werden',
-  'sessions.sidebar.session.moveToWorktree.tooltip': 'Erstellt einen neuen Worktree aus dem aktuellen Branch, überträgt nicht gespeicherte Änderungen und verschiebt diese Sitzung samt Untersitzungen dorthin.',
+  'sessions.sidebar.session.moveToWorktree.main': 'Haupt-Worktree',
+  'sessions.sidebar.session.moveToWorktree.refreshing': 'Worktrees werden aktualisiert...',
+  'sessions.sidebar.session.moveToWorktree.loadFailed': 'Worktrees konnten nicht geladen werden',
+  'sessions.sidebar.session.moveToWorktree.current': 'Aktueller Worktree',
+  'sessions.sidebar.session.moveToWorktree.existingSuccess': 'Sitzung in Worktree verschoben',
+  'sessions.sidebar.session.moveToWorktree.existingFailed': 'Sitzung konnte nicht in Worktree verschoben werden',
+  'sessions.sidebar.session.moveToWorktree.tooltipTargets': 'Zeigt vorhandene Worktrees und die Option, für diese Sitzung einen neuen zu erstellen.',
+  'sessions.sidebar.session.moveToWorktree.tooltip': 'Erstellt einen neuen Worktree aus dem aktuellen Branch und verschiebt diese Sitzung samt Untersitzungen dorthin. Bei ungespeicherten Änderungen in der Quelle wählst du, ob sie mit verschoben werden.',
   'sessions.sidebar.session.moveToWorktree.tooltipBusy': 'Verfügbar, wenn die Sitzung inaktiv ist. Warten Sie oder beenden Sie die aktuelle Aktivität.',
   'sessions.sidebar.session.moveToWorktree.tooltipMoving': 'Diese Sitzung wird bereits in einen neuen Worktree verschoben.',
+  'sessions.sidebar.session.moveToWorktree.confirm.title': 'Die Quelle hat ungespeicherte Änderungen',
+  'sessions.sidebar.session.moveToWorktree.confirm.changedFiles': 'Geänderte Dateien in diesem Worktree: {count}.',
+  'sessions.sidebar.session.moveToWorktree.confirm.ownership': 'OpenCode verfolgt diese Änderungen nach Verzeichnis, nicht nach Sitzung.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnlyHelp': 'Verschiebt diese Sitzung und ihre Untersitzungen, ohne die Quelldateien zu verändern.',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChangesHelp': 'Überträgt die Änderungen im Sitzungsverzeichnis. Nicht committete und unversionierte Dateien verlassen die Quelle nach Erfolg.',
+  'sessions.sidebar.session.moveToWorktree.confirm.stagedWarning': 'Gemappte (staged) Änderungen bleiben in der Quelle und werden ans Ziel kopiert.',
+  'sessions.sidebar.session.moveToWorktree.confirm.baseWarning': 'Die Übertragung kann fehlschlagen, wenn das Ziel eine andere Git-Basis verwendet.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnly': 'Nur Sitzung verschieben',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChanges': 'Alle Quelländerungen verschieben',
+  'sessions.sidebar.session.moveToWorktree.confirm.cancel': 'Abbrechen',
+  'sessions.sidebar.session.moveToWorktree.sourceVerificationFailed': 'Die Änderungen in der Quelle konnten nicht geprüft werden. Es wurde kein Worktree und keine Sitzung geändert.',
+  'sessions.sidebar.session.moveToWorktree.applyChangesFailed': 'Das Ziel konnte die Änderungen der Quelle nicht übernehmen. Sitzung und Änderungen wurden nicht verschoben. Versuche es erneut und wähle Nur Sitzung verschieben.',
+  'sessions.sidebar.session.moveToWorktree.changesMayBeInDestination': 'Die Verbindung brach ab, bevor das Ziel den Wechsel bestätigt hat. Die Sitzung wurde möglicherweise nicht verschoben, und deine nicht committeten Änderungen liegen eventuell schon im Ziel-Worktree. Sieh dort nach, bevor du es erneut versuchst.',
   'sessions.sidebar.session.export.failedLoadHistory': 'Die vollständige Sitzungshistorie konnte nicht geladen werden',
   'sessions.sidebar.session.status.movingToWorktree': 'Sitzung wird in einen neuen Worktree verschoben',
   'gitView.header.updateBranch': 'Branch aktualisieren',
@@ -3111,6 +3150,7 @@ export const dict = {
   'updateDialog.changelog.title': 'Neuigkeiten',
   'chat.workStatus.ariaLabel': 'Arbeitsstatus',
   'chat.workStatus.context.label': 'Kontext',
+  'chat.workStatus.cost.breakdown': 'Sitzung {session} · Unteragenten {subagents}',
   'chat.workStatus.git.changedFileSingle': '{count} Datei geändert',
   'chat.workStatus.git.changedFilePlural': '{count} Dateien geändert',
   'chat.workStatus.pr.untitled': 'Pull Request ohne Titel',

packages/ui/src/lib/i18n/messages/en.settings.ts

@@ -1955,7 +1955,7 @@ export const settingsDict = {
   'settings.openchamber.visual.section.streaming': 'Streaming',
   'settings.openchamber.visual.field.streamingAutoFollow': 'Follow new content while streaming',
   'settings.openchamber.visual.field.streamingAutoFollowAria': 'Automatically follow new content while a response streams',
-  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'While a reply streams in, the view keeps gliding to the newest content. Turn this off to keep the view still and scroll manually.',
+  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'While a reply streams in, the view keeps gliding to the newest content. Turn this off to keep the view still and scroll manually; sending a message while scrolled up then also leaves the view where it is.',
   'settings.openchamber.visual.section.messageAppearance': 'Message Appearance',
   'settings.openchamber.visual.section.toolsAndFiles': 'Tools & Files',
   'settings.openchamber.visual.section.composer': 'Composer',

packages/ui/src/lib/i18n/messages/en.ts

@@ -37,6 +37,7 @@ export const dict = {
   'common.language.korean': 'Korean',
   'common.language.polish': 'Polish',
   'common.language.japanese': 'Japanese',
+  'common.language.turkish': 'Turkish',
   'common.revealPath.finder': 'Reveal in Finder',
   'common.revealPath.fileExplorer': 'Open in File Explorer',
   'common.revealPath.fileManager': 'Open in File Manager',
@@ -129,6 +130,7 @@ export const dict = {
   'mobile.sessions.section.worktrees': 'Worktrees',
   'mobile.sessions.section.otherProjects': 'Switch project',
   'mobile.sessions.section.projects': 'Projects',
+  'mobile.sessions.section.chats': 'Chats',
   'mobile.sessions.empty.noProjectsTitle': 'No projects yet',
   'mobile.sessions.empty.noProjectsDescription': 'Add a project to start chatting with your code.',
   'mobile.sessions.empty.noSessionsTitle': 'No sessions yet',
@@ -383,7 +385,7 @@ export const dict = {
   'multirun.launcher.attachments.attach': 'Attach',
   'multirun.launcher.attachments.tooltip': 'Same files sent to all runs',
   'multirun.launcher.models.label': 'Models',
-  'multirun.launcher.models.info': 'Select 2-{max} models. Same model can be added multiple times.',
+  'multirun.launcher.models.info': 'Select 2 or more models. Same model can be added multiple times.',
   'multirun.launcher.toast.fileTooLarge': 'File "{fileName}" is too large (max 10MB)',
   'multirun.launcher.toast.attachFailed': 'Failed to attach "{fileName}"',
   'multirun.launcher.toast.attachedSingle': 'Attached {count} file',
@@ -536,11 +538,33 @@ export const dict = {
   'sessions.sidebar.session.menu.unshare': 'Unshare',
   'sessions.sidebar.session.menu.exportMarkdown': 'Export Markdown',
   'sessions.sidebar.session.menu.moveToWorktree': 'Move to new worktree',
+  'sessions.sidebar.session.menu.moveToWorktreeTargets': 'Move to worktree',
+  'sessions.sidebar.session.menu.newWorktree': 'New worktree...',
   'sessions.sidebar.session.moveToWorktree.success': 'Session moved to a new worktree',
   'sessions.sidebar.session.moveToWorktree.failed': 'Failed to move session to a new worktree',
-  'sessions.sidebar.session.moveToWorktree.tooltip': 'Creates a new worktree from the current branch, transfers uncommitted changes, and moves this session and its sub-sessions there.',
+  'sessions.sidebar.session.moveToWorktree.main': 'Main worktree',
+  'sessions.sidebar.session.moveToWorktree.refreshing': 'Refreshing worktrees...',
+  'sessions.sidebar.session.moveToWorktree.loadFailed': 'Worktrees could not be loaded',
+  'sessions.sidebar.session.moveToWorktree.current': 'Current worktree',
+  'sessions.sidebar.session.moveToWorktree.existingSuccess': 'Session moved to worktree',
+  'sessions.sidebar.session.moveToWorktree.existingFailed': 'Failed to move session to worktree',
+  'sessions.sidebar.session.moveToWorktree.tooltipTargets': 'Shows existing worktrees and the option to create a new one for this session.',
+  'sessions.sidebar.session.moveToWorktree.tooltip': 'Creates a new worktree from the current branch and moves this session and its sub-sessions there. When the source has uncommitted changes, you choose whether to move them.',
   'sessions.sidebar.session.moveToWorktree.tooltipBusy': 'Available when the session is idle. Stop or wait for the current activity to finish.',
   'sessions.sidebar.session.moveToWorktree.tooltipMoving': 'This session is already being moved to a new worktree.',
+  'sessions.sidebar.session.moveToWorktree.confirm.title': 'Source has uncommitted changes',
+  'sessions.sidebar.session.moveToWorktree.confirm.changedFiles': 'Changed files in this worktree: {count}.',
+  'sessions.sidebar.session.moveToWorktree.confirm.ownership': 'OpenCode tracks these changes by directory, not by session.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnlyHelp': 'Move this session and its sub-sessions while leaving every source file unchanged.',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChangesHelp': 'Transfer changes under the session directory. Unstaged and untracked files leave the source after success.',
+  'sessions.sidebar.session.moveToWorktree.confirm.stagedWarning': 'Staged changes remain in the source and are copied to the destination.',
+  'sessions.sidebar.session.moveToWorktree.confirm.baseWarning': 'The transfer can fail when the destination uses a different Git base.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnly': 'Move session only',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChanges': 'Move all source changes',
+  'sessions.sidebar.session.moveToWorktree.confirm.cancel': 'Cancel',
+  'sessions.sidebar.session.moveToWorktree.sourceVerificationFailed': 'Source changes could not be verified. No worktree or session was changed.',
+  'sessions.sidebar.session.moveToWorktree.applyChangesFailed': 'The destination could not accept the source changes. The session and source changes were not moved. Retry and choose Move session only.',
+  'sessions.sidebar.session.moveToWorktree.changesMayBeInDestination': 'The connection dropped before the destination confirmed the move. The session may not have moved, and your uncommitted changes may already be in the destination worktree. Check there before retrying.',
   'sessions.sidebar.session.menu.runFusion': 'Run fusion',
   'sessions.sidebar.session.menu.openInSidePanel': 'Open in Side Panel',
   'sessions.sidebar.session.actions.openInEditor': 'Open in Editor',
@@ -1958,8 +1982,6 @@ export const dict = {
   'session.newWorktree.noMatchingBranches': 'No matching branches',
   'session.newWorktree.localBranches': 'Local branches',
   'session.newWorktree.remoteBranches': 'Remote branches',
-  'session.newWorktree.otherLocalBranches': 'Other local branches',
-  'session.newWorktree.otherRemoteBranches': 'Other remote branches',
   'session.newWorktree.branchName': 'Branch Name',
   'session.newWorktree.branchNamePlaceholder': 'feature/my-awesome-feature',
   'session.newWorktree.actions.change': 'Change',
@@ -2302,6 +2324,7 @@ export const dict = {
   'chat.chatInput.toast.attachmentsTooLarge': 'Attachments are too large to send. Please try reducing the number or size of images.',
   'chat.chatInput.toast.sendAttachmentsFailed': 'Failed to send attachments. Try fewer files or smaller images.',
   'chat.chatInput.toast.messageSendFailed': 'Message failed to send. Attachments restored.',
+  'chat.chatInput.toast.noModelSelected': 'Select a provider and model before sending.',
   'chat.chatInput.toast.clipboardAttachFailed': 'Failed to attach image from clipboard',
   'chat.chatInput.toast.addedFileMentions': 'Added {count} file mention(s)',
   'chat.chatInput.toast.attachFileFailed': 'Failed to attach file',
@@ -2351,6 +2374,7 @@ export const dict = {
   'chat.toolPart.showRawJson': 'Show raw JSON',
    'chat.toolPart.showFormattedJson': 'Show formatted JSON',
    'chat.toolPart.showNavigableJson': 'Show navigable JSON',
+   'chat.toolPart.openFile': 'Open file',
    'chat.toolPart.openFileAtFirstChange': 'Open file at first change',
    'chat.toolPart.openFileDiff': 'Open file diff',
   'chat.toolPart.copyOutput': 'Copy output',
@@ -2990,6 +3014,10 @@ export const dict = {
   'updateDialog.status.updating': 'Updating...',
   'updateDialog.error.updateFailed': 'Update failed',
   'updateDialog.error.takingLonger': 'Update is taking longer than expected. Wait a bit and refresh, or run: openchamber update',
+  'updateDialog.error.signatureRejected': 'The downloaded update was rejected: its code signature does not match this installation. This usually means the running copy was not installed from an official signed release. Install OpenChamber from an official release, then update again.',
+  'updateDialog.error.updaterDisabled': 'The updater stopped after a failed install. Quit OpenChamber, open it again, and retry the update.',
+  'updateDialog.error.restartFailed': 'Could not restart to install the update.',
+  'updateDialog.error.restartUnavailable': 'Installing the update requires the OpenChamber desktop app.',
   'mobileUpdate.toast.available.title': 'OpenChamber update available',
   'mobileUpdate.toast.available.description': 'Version {version} is ready for Android.',
   'mobileUpdate.toast.actions.download': 'Download',
@@ -3010,6 +3038,7 @@ export const dict = {
   'memoryDebugPanel.title': 'Debug Panel',
   'memoryDebugPanel.tabs.memory': 'Memory',
   'memoryDebugPanel.tabs.streaming': 'Streaming',
+  'memoryDebugPanel.tabs.requests': 'Requests',
   'memoryDebugPanel.section.sessionsInMemory': 'Sessions in Memory',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UI Streaming Metrics',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Code Bridge Metrics',
@@ -3047,6 +3076,16 @@ export const dict = {
   'memoryDebugPanel.streaming.copy.copied': 'Streaming debug JSON copied',
   'memoryDebugPanel.streaming.copy.failed': 'Failed to copy JSON',
   'memoryDebugPanel.streaming.copy.hint': 'Copy exports both UI and VS Code streaming metrics as JSON',
+  'memoryDebugPanel.requests.inFlight': 'In flight',
+  'memoryDebugPanel.requests.peak': 'Peak',
+  'memoryDebugPanel.requests.duration': 'Duration',
+  'memoryDebugPanel.requests.totalRequests': 'Total Requests',
+  'memoryDebugPanel.requests.tracking': 'Tracking',
+  'memoryDebugPanel.requests.now': 'now',
+  'memoryDebugPanel.requests.noSamples': 'No requests tracked yet. Keep this panel open to record fetch activity.',
+  'memoryDebugPanel.requests.chartLabel': 'Fetch requests in flight over time, peak {peak}',
+  'memoryDebugPanel.requests.windowHint': 'last {seconds}s',
+  'memoryDebugPanel.requests.percentileChartLabel': 'In-flight request age percentiles (p50, p90, p99, max) over time',
   'memoryDebugPanel.common.idle': 'idle',
   'memoryDebugPanel.common.live': 'live',
   'memoryDebugPanel.common.notAvailable': 'n/a',
@@ -3110,9 +3149,10 @@ export const dict = {
   'quota.window.premium': 'Premium Interactions',
   'quota.window.chat': 'Chat Requests',
   'quota.window.completions': 'Completions',
-  'quota.window.premiumInteractions': 'Premium interactions',
+  'quota.window.premiumInteractions': 'AI Credits',
   'chat.workStatus.ariaLabel': 'Work status',
   'chat.workStatus.context.label': 'Context',
+  'chat.workStatus.cost.breakdown': 'Session {session} · Subagents {subagents}',
   'chat.workStatus.git.changedFileSingle': '{count} file changed',
   'chat.workStatus.git.changedFilePlural': '{count} files changed',
   'chat.workStatus.pr.untitled': 'Untitled pull request',

packages/ui/src/lib/i18n/messages/es.settings.ts

@@ -1932,7 +1932,7 @@ export const settingsDict = {
   "settings.openchamber.visual.section.streaming": "Streaming",
   "settings.openchamber.visual.field.streamingAutoFollow": "Seguir el contenido nuevo durante el streaming",
   "settings.openchamber.visual.field.streamingAutoFollowAria": "Seguir automáticamente el contenido nuevo mientras se transmite una respuesta",
-  "settings.openchamber.visual.field.streamingAutoFollowInfo": "Mientras llega una respuesta, la vista se desplaza hacia el contenido más reciente. Desactívalo para mantener la vista quieta y desplazarte manualmente.",
+  "settings.openchamber.visual.field.streamingAutoFollowInfo": "Mientras llega una respuesta, la vista se desplaza hacia el contenido más reciente. Desactívalo para mantener la vista quieta y desplazarte manualmente; enviar un mensaje desde la mitad del chat tampoco moverá la vista.",
   "settings.openchamber.visual.section.messageAppearance": "Apariencia de los mensajes",
   "settings.openchamber.visual.section.toolsAndFiles": "Herramientas y archivos",
   "settings.openchamber.visual.section.composer": "Compositor",

packages/ui/src/lib/i18n/messages/es.ts

@@ -38,6 +38,7 @@ export const dict: Record<I18nKey, string> = {
   "common.language.korean": "Coreano",
   "common.language.polish": "Polaco",
   "common.language.japanese": "Japonés",
+  "common.language.turkish": "Turco",
   "common.revealPath.finder": "Mostrar en Finder",
   "common.revealPath.fileExplorer": "Abrir en File Explorer",
   "common.revealPath.fileManager": "Abrir en gestor de archivos",
@@ -130,6 +131,7 @@ export const dict: Record<I18nKey, string> = {
   "mobile.sessions.section.worktrees": "Worktrees",
   "mobile.sessions.section.otherProjects": "Cambiar de proyecto",
   "mobile.sessions.section.projects": "Proyectos",
+  "mobile.sessions.section.chats": "Chats",
   "mobile.sessions.empty.noProjectsTitle": "Sin proyectos",
   "mobile.sessions.empty.noProjectsDescription": "Agrega un proyecto para empezar a chatear con tu código.",
   "mobile.sessions.empty.noSessionsTitle": "Sin sesiones",
@@ -384,7 +386,7 @@ export const dict: Record<I18nKey, string> = {
   "multirun.launcher.attachments.attach": "Adjuntar",
   "multirun.launcher.attachments.tooltip": "Archivos idénticos enviados a todas las ejecuciones",
   "multirun.launcher.models.label": "Modelos",
-  "multirun.launcher.models.info": "Selecciona 2-{max} modelos. El mismo modelo puede añadirse varias veces.",
+  "multirun.launcher.models.info": "Selecciona 2 o más modelos. El mismo modelo puede añadirse varias veces.",
   "multirun.launcher.toast.fileTooLarge": "El archivo \"{fileName}\" es demasiado grande (máximo 10MB)",
   "multirun.launcher.toast.attachFailed": "No se pudo adjuntar \"{fileName}\"",
   "multirun.launcher.toast.attachedSingle": "Archivo adjuntado ({count})",
@@ -537,11 +539,33 @@ export const dict: Record<I18nKey, string> = {
   "sessions.sidebar.session.menu.unshare": "Dejar de compartir",
   "sessions.sidebar.session.menu.exportMarkdown": "Exportar Markdown",
   "sessions.sidebar.session.menu.moveToWorktree": "Mover a un worktree nuevo",
+  "sessions.sidebar.session.menu.moveToWorktreeTargets": "Mover a worktree",
+  "sessions.sidebar.session.menu.newWorktree": "Nuevo worktree...",
   "sessions.sidebar.session.moveToWorktree.success": "Sesión movida a un worktree nuevo",
   "sessions.sidebar.session.moveToWorktree.failed": "No se pudo mover la sesión a un worktree nuevo",
-  "sessions.sidebar.session.moveToWorktree.tooltip": "Crea un worktree nuevo desde la rama actual, transfiere los cambios sin confirmar y mueve allí esta sesión y sus subsesiones.",
+  "sessions.sidebar.session.moveToWorktree.main": "Worktree principal",
+  "sessions.sidebar.session.moveToWorktree.refreshing": "Actualizando worktrees...",
+  "sessions.sidebar.session.moveToWorktree.loadFailed": "No se pudieron cargar los worktrees",
+  "sessions.sidebar.session.moveToWorktree.current": "Worktree actual",
+  "sessions.sidebar.session.moveToWorktree.existingSuccess": "Sesión movida al worktree",
+  "sessions.sidebar.session.moveToWorktree.existingFailed": "No se pudo mover la sesión al worktree",
+  "sessions.sidebar.session.moveToWorktree.tooltipTargets": "Muestra los worktrees existentes y la opción de crear uno nuevo para esta sesión.",
+  "sessions.sidebar.session.moveToWorktree.tooltip": "Crea un worktree nuevo desde la rama actual y mueve allí esta sesión y sus subsesiones. Si la fuente tiene cambios sin confirmar, decides si se transfieren.",
   "sessions.sidebar.session.moveToWorktree.tooltipBusy": "Disponible cuando la sesión está inactiva. Detén la actividad actual o espera a que termine.",
   "sessions.sidebar.session.moveToWorktree.tooltipMoving": "Esta sesión ya se está moviendo a un worktree nuevo.",
+  "sessions.sidebar.session.moveToWorktree.confirm.title": "La fuente tiene cambios sin confirmar",
+  "sessions.sidebar.session.moveToWorktree.confirm.changedFiles": "Archivos modificados en este worktree: {count}.",
+  "sessions.sidebar.session.moveToWorktree.confirm.ownership": "OpenCode rastrea estos cambios por directorio, no por sesión.",
+  "sessions.sidebar.session.moveToWorktree.confirm.sessionOnlyHelp": "Mueve esta sesión y sus subsesiones dejando intacto cada archivo de la fuente.",
+  "sessions.sidebar.session.moveToWorktree.confirm.allChangesHelp": "Transfiere los cambios del directorio de la sesión. Los archivos sin confirmar y sin rastrear salen de la fuente tras el éxito.",
+  "sessions.sidebar.session.moveToWorktree.confirm.stagedWarning": "Los cambios en el índice permanecen en la fuente y se copian al destino.",
+  "sessions.sidebar.session.moveToWorktree.confirm.baseWarning": "La transferencia puede fallar si el destino usa una base de Git distinta.",
+  "sessions.sidebar.session.moveToWorktree.confirm.sessionOnly": "Mover solo la sesión",
+  "sessions.sidebar.session.moveToWorktree.confirm.allChanges": "Mover todos los cambios de la fuente",
+  "sessions.sidebar.session.moveToWorktree.confirm.cancel": "Cancelar",
+  "sessions.sidebar.session.moveToWorktree.sourceVerificationFailed": "No se pudieron verificar los cambios de la fuente. No se modificó ningún worktree ni sesión.",
+  "sessions.sidebar.session.moveToWorktree.applyChangesFailed": "El destino no pudo aceptar los cambios de la fuente. No se movieron la sesión ni los cambios. Reintenta y elige Mover solo la sesión.",
+  "sessions.sidebar.session.moveToWorktree.changesMayBeInDestination": "La conexión se cortó antes de que el destino confirmara el movimiento. Puede que la sesión no se haya movido y que tus cambios sin confirmar ya estén en el worktree de destino. Compruébalo antes de volver a intentarlo.",
   "sessions.sidebar.session.menu.runFusion": "Ejecutar fusion",
   "sessions.sidebar.session.menu.openInSidePanel": "Abrir en panel lateral",
   "sessions.sidebar.session.actions.openInEditor": "Abrir en el editor",
@@ -1936,8 +1960,6 @@ export const dict: Record<I18nKey, string> = {
   "session.newWorktree.noMatchingBranches": "No hay ramas coincidentes",
   "session.newWorktree.localBranches": "Ramas locales",
   "session.newWorktree.remoteBranches": "Ramas remotas",
-  "session.newWorktree.otherLocalBranches": "Otras ramas locales",
-  "session.newWorktree.otherRemoteBranches": "Otras ramas remotas",
   "session.newWorktree.branchName": "Nombre de la rama",
   "session.newWorktree.branchNamePlaceholder": "feature/my-awesome-feature",
   "session.newWorktree.actions.change": "Cambiar",
@@ -2268,6 +2290,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.chatInput.toast.attachmentsTooLarge": "Los adjuntos son demasiado grandes para enviar. Intenta reducir la cantidad o el tamaño de las imágenes.",
   "chat.chatInput.toast.sendAttachmentsFailed": "No se pudieron enviar los adjuntos. Intenta con menos archivos o imágenes más pequeñas.",
   "chat.chatInput.toast.messageSendFailed": "El mensaje no se pudo enviar. Los adjuntos se restauraron.",
+  "chat.chatInput.toast.noModelSelected": "Selecciona un proveedor y un modelo antes de enviar.",
   "chat.chatInput.toast.clipboardAttachFailed": "No se pudo adjuntar la imagen desde el portapapeles",
   "chat.chatInput.toast.addedFileMentions": "Se añadieron {count} mención(es) de archivo",
   "chat.chatInput.toast.attachFileFailed": "No se pudo adjuntar el archivo",
@@ -2317,6 +2340,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.toolPart.showRawJson": "Mostrar JSON sin formato",
   "chat.toolPart.showFormattedJson": "Mostrar JSON formateado",
   "chat.toolPart.showNavigableJson": "Mostrar JSON navegable",
+  "chat.toolPart.openFile": "Abrir archivo",
   "chat.toolPart.openFileAtFirstChange": "Abrir archivo en el primer cambio",
   "chat.toolPart.openFileDiff": "Abrir diferencias del archivo",
   "chat.toolPart.copyOutput": "Copiar salida",
@@ -2956,6 +2980,10 @@ export const dict: Record<I18nKey, string> = {
   "updateDialog.status.updating": "Actualizando...",
   "updateDialog.error.updateFailed": "No se pudo actualizar",
   "updateDialog.error.takingLonger": "La actualización está tardando más de lo esperado. Espera un poco y refresca, o ejecuta: openchamber update",
+  "updateDialog.error.signatureRejected": "La actualización descargada fue rechazada: su firma de código no coincide con esta instalación. Normalmente significa que la copia en ejecución no se instaló desde una versión oficial firmada. Instala OpenChamber desde una versión oficial y vuelve a actualizar.",
+  "updateDialog.error.updaterDisabled": "El actualizador se detuvo tras una instalación fallida. Cierra OpenChamber, ábrelo de nuevo y reintenta la actualización.",
+  "updateDialog.error.restartFailed": "No se pudo reiniciar para instalar la actualización.",
+  "updateDialog.error.restartUnavailable": "Instalar la actualización requiere la aplicación de escritorio de OpenChamber.",
   "mobileUpdate.toast.available.title": "Actualización de OpenChamber disponible",
   "mobileUpdate.toast.available.description": "La versión {version} está lista para Android.",
   "mobileUpdate.toast.actions.download": "Descargar",
@@ -2976,6 +3004,7 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.title": "Panel de depuración",
   "memoryDebugPanel.tabs.memory": "Memoria",
   "memoryDebugPanel.tabs.streaming": "Transmisión",
+  "memoryDebugPanel.tabs.requests": "Solicitudes",
   "memoryDebugPanel.section.sessionsInMemory": "Sesiones en memoria",
   "memoryDebugPanel.section.uiStreamingMetrics": "Métricas de streaming de UI",
   "memoryDebugPanel.section.vscodeBridgeMetrics": "Métricas del puente de VS Code",
@@ -3013,6 +3042,16 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.streaming.copy.copied": "JSON de depuración en streaming copiado",
   "memoryDebugPanel.streaming.copy.failed": "No se pudo copiar JSON",
   "memoryDebugPanel.streaming.copy.hint": "Copia exportaciones de métricas de UI como de métricas de VS Code en formato JSON",
+  "memoryDebugPanel.requests.inFlight": "En curso",
+  "memoryDebugPanel.requests.peak": "Pico",
+  "memoryDebugPanel.requests.duration": "Duración",
+  "memoryDebugPanel.requests.totalRequests": "Solicitudes totales",
+  "memoryDebugPanel.requests.tracking": "Seguimiento",
+  "memoryDebugPanel.requests.now": "ahora",
+  "memoryDebugPanel.requests.noSamples": "Aún no se han registrado solicitudes. Mantén este panel abierto para registrar la actividad de fetch.",
+  "memoryDebugPanel.requests.chartLabel": "Solicitudes fetch en curso a lo largo del tiempo, pico {peak}",
+  "memoryDebugPanel.requests.windowHint": "últimos {seconds}s",
+  "memoryDebugPanel.requests.percentileChartLabel": "Percentiles de antigüedad de solicitudes en curso (p50, p90, p99, máx) a lo largo del tiempo",
   "memoryDebugPanel.common.idle": "inactivo",
   "memoryDebugPanel.common.live": "en vivo",
   "memoryDebugPanel.common.notAvailable": "n/a",
@@ -3111,9 +3150,10 @@ export const dict: Record<I18nKey, string> = {
   "quota.window.premium": "Premium Interactions",
   "quota.window.chat": "Chat Requests",
   "quota.window.completions": "Completions",
-  "quota.window.premiumInteractions": "Premium interactions",
+  "quota.window.premiumInteractions": "Créditos de IA",
   'chat.workStatus.ariaLabel': 'Estado del trabajo',
   'chat.workStatus.context.label': 'Contexto',
+  'chat.workStatus.cost.breakdown': "Sesión {session} · Subagentes {subagents}",
   'chat.workStatus.git.changedFileSingle': '{count} archivo modificado',
   'chat.workStatus.git.changedFilePlural': '{count} archivos modificados',
   'chat.workStatus.pr.untitled': 'Pull request sin título',

packages/ui/src/lib/i18n/messages/fr.settings.ts

@@ -1846,7 +1846,7 @@ export const settingsDict = {
   'settings.openchamber.visual.section.streaming': 'Streaming',
   'settings.openchamber.visual.field.streamingAutoFollow': 'Suivre le nouveau contenu pendant le streaming',
   'settings.openchamber.visual.field.streamingAutoFollowAria': 'Suivre automatiquement le nouveau contenu pendant la diffusion d’une réponse',
-  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'Pendant qu’une réponse arrive, la vue glisse vers le contenu le plus récent. Désactivez pour garder la vue immobile et défiler manuellement.',
+  'settings.openchamber.visual.field.streamingAutoFollowInfo': 'Pendant qu’une réponse arrive, la vue glisse vers le contenu le plus récent. Désactivez pour garder la vue immobile et défiler manuellement ; envoyer un message depuis le milieu de la conversation laisse alors aussi la vue en place.',
   'settings.openchamber.visual.section.messageAppearance': 'Apparence des messages',
   'settings.openchamber.visual.section.toolsAndFiles': 'Outils et fichiers',
   'settings.openchamber.visual.section.composer': 'Zone de saisie',

packages/ui/src/lib/i18n/messages/fr.ts

@@ -37,6 +37,7 @@ export const dict = {
   'common.language.korean': 'Coréen',
   'common.language.polish': 'Polonais',
   'common.language.japanese': 'Japonais',
+  'common.language.turkish': 'Turc',
   'common.revealPath.finder': 'Révéler dans le Finder',
   'common.revealPath.fileExplorer': 'Ouvrir dans l\'explorateur de fichiers',
   'common.revealPath.fileManager': 'Ouvrir dans le gestionnaire de fichiers',
@@ -215,7 +216,7 @@ export const dict = {
   'multirun.launcher.attachments.attach': 'Attacher',
   'multirun.launcher.attachments.tooltip': 'Mêmes fichiers envoyés à toutes les exécutions',
   'multirun.launcher.models.label': 'Modèles',
-  'multirun.launcher.models.info': 'Sélectionnez les modèles 2-{max}. Le même modèle peut être ajouté plusieurs fois.',
+  'multirun.launcher.models.info': 'Sélectionnez 2 modèles ou plus. Le même modèle peut être ajouté plusieurs fois.',
   'multirun.launcher.toast.fileTooLarge': 'Le fichier "{fileName}" est trop volumineux (max 10 Mo)',
   'multirun.launcher.toast.attachFailed': 'Échec de la connexion de "{fileName}"',
   'multirun.launcher.toast.attachedSingle': 'Fichier {count} joint',
@@ -367,11 +368,33 @@ export const dict = {
   'sessions.sidebar.session.menu.unshare': 'Annuler le partage',
   'sessions.sidebar.session.menu.exportMarkdown': 'Exporter le Markdown',
   'sessions.sidebar.session.menu.moveToWorktree': 'Déplacer vers un nouveau worktree',
+  'sessions.sidebar.session.menu.moveToWorktreeTargets': 'Déplacer vers un worktree',
+  'sessions.sidebar.session.menu.newWorktree': 'Nouveau worktree...',
   'sessions.sidebar.session.moveToWorktree.success': 'Session déplacée vers un nouveau worktree',
   'sessions.sidebar.session.moveToWorktree.failed': 'Impossible de déplacer la session vers un nouveau worktree',
-  'sessions.sidebar.session.moveToWorktree.tooltip': 'Crée un nouveau worktree depuis la branche actuelle, transfère les modifications non validées et y déplace cette session et ses sous-sessions.',
+  'sessions.sidebar.session.moveToWorktree.main': 'Worktree principal',
+  'sessions.sidebar.session.moveToWorktree.refreshing': 'Actualisation des worktrees...',
+  'sessions.sidebar.session.moveToWorktree.loadFailed': 'Impossible de charger les worktrees',
+  'sessions.sidebar.session.moveToWorktree.current': 'Worktree actuel',
+  'sessions.sidebar.session.moveToWorktree.existingSuccess': 'Session déplacée vers le worktree',
+  'sessions.sidebar.session.moveToWorktree.existingFailed': 'Impossible de déplacer la session vers le worktree',
+  'sessions.sidebar.session.moveToWorktree.tooltipTargets': 'Affiche les worktrees existants et l’option d’en créer un nouveau pour cette session.',
+  'sessions.sidebar.session.moveToWorktree.tooltip': 'Crée un nouveau worktree depuis la branche actuelle et y déplace cette session et ses sous-sessions. Si la source contient des modifications non validées, vous choisissez de les transférer ou non.',
   'sessions.sidebar.session.moveToWorktree.tooltipBusy': 'Disponible lorsque la session est inactive. Arrêtez l’activité en cours ou attendez sa fin.',
   'sessions.sidebar.session.moveToWorktree.tooltipMoving': 'Cette session est déjà en cours de déplacement vers un nouveau worktree.',
+  'sessions.sidebar.session.moveToWorktree.confirm.title': 'La source contient des modifications non validées',
+  'sessions.sidebar.session.moveToWorktree.confirm.changedFiles': 'Fichiers modifiés dans ce worktree : {count}.',
+  'sessions.sidebar.session.moveToWorktree.confirm.ownership': 'OpenCode suit ces modifications par répertoire, pas par session.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnlyHelp': 'Déplace cette session et ses sous-sessions en laissant chaque fichier source inchangé.',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChangesHelp': 'Transfère les modifications du répertoire de la session. Les fichiers non indexés et non suivis quittent la source après succès.',
+  'sessions.sidebar.session.moveToWorktree.confirm.stagedWarning': 'Les modifications indexées restent dans la source et sont copiées vers la destination.',
+  'sessions.sidebar.session.moveToWorktree.confirm.baseWarning': 'Le transfert peut échouer si la destination utilise une base Git différente.',
+  'sessions.sidebar.session.moveToWorktree.confirm.sessionOnly': 'Déplacer la session uniquement',
+  'sessions.sidebar.session.moveToWorktree.confirm.allChanges': 'Déplacer toutes les modifications de la source',
+  'sessions.sidebar.session.moveToWorktree.confirm.cancel': 'Annuler',
+  'sessions.sidebar.session.moveToWorktree.sourceVerificationFailed': 'Les modifications de la source n’ont pas pu être vérifiées. Aucun worktree ni session n’a été modifié.',
+  'sessions.sidebar.session.moveToWorktree.applyChangesFailed': 'La destination n’a pas pu accepter les modifications de la source. La session et les modifications n’ont pas été déplacées. Réessayez et choisissez Déplacer la session uniquement.',
+  'sessions.sidebar.session.moveToWorktree.changesMayBeInDestination': 'La connexion a été perdue avant que la destination ne confirme le déplacement. La session n’a peut-être pas été déplacée, et vos modifications non validées se trouvent peut-être déjà dans le worktree de destination. Vérifiez-le avant de réessayer.',
   'sessions.sidebar.session.menu.runFusion': 'Exécuter la fusion',
   'sessions.sidebar.session.menu.openInSidePanel': 'Ouvrir dans le panneau latéral',
   'sessions.sidebar.session.actions.openInEditor': 'Ouvrir dans l\'éditeur',
@@ -1716,8 +1739,6 @@ export const dict = {
   'session.newWorktree.noMatchingBranches': 'Aucune branche correspondante',
   'session.newWorktree.localBranches': 'Branches locales',
   'session.newWorktree.remoteBranches': 'Branches du dépôt distant',
-  'session.newWorktree.otherLocalBranches': 'Autres branches locales',
-  'session.newWorktree.otherRemoteBranches': 'Autres branches du remote',
   'session.newWorktree.branchName': 'Nom de la branche',
   'session.newWorktree.branchNamePlaceholder': 'fonctionnalité/ma-fonctionnalité-géniale',
   'session.newWorktree.actions.change': 'Changement',
@@ -2015,6 +2036,7 @@ export const dict = {
   'chat.chatInput.toast.attachmentsTooLarge': 'Les pièces jointes sont trop volumineuses pour être envoyées. Veuillez essayer de réduire le nombre ou la taille des images.',
   'chat.chatInput.toast.sendAttachmentsFailed': 'Échec de l\'envoi des pièces jointes. Essayez moins de fichiers ou des images plus petites.',
   'chat.chatInput.toast.messageSendFailed': 'Le message n\'a pas pu être envoyé. Pièces jointes restaurées.',
+  'chat.chatInput.toast.noModelSelected': 'Sélectionnez un fournisseur et un modèle avant d\'envoyer.',
   'chat.chatInput.toast.clipboardAttachFailed': 'Échec de la pièce jointe de l\'image du presse-papiers',
   'chat.chatInput.toast.addedFileMentions': 'Ajout des mentions du fichier {count}',
   'chat.chatInput.toast.attachFileFailed': 'Impossible de joindre le fichier',
@@ -2682,6 +2704,10 @@ export const dict = {
   'updateDialog.status.updating': 'Mise à jour...',
   'updateDialog.error.updateFailed': 'La mise à jour a échoué',
   'updateDialog.error.takingLonger': 'La mise à jour prend plus de temps que prévu. Attendez un peu et actualisez, ou exécutez : openchamber update',
+  'updateDialog.error.signatureRejected': 'La mise à jour téléchargée a été rejetée : sa signature de code ne correspond pas à cette installation. Cela signifie généralement que la copie en cours n’a pas été installée depuis une version officielle signée. Installez OpenChamber depuis une version officielle, puis relancez la mise à jour.',
+  'updateDialog.error.updaterDisabled': 'Le programme de mise à jour s’est arrêté après une installation échouée. Quittez OpenChamber, rouvrez-le, puis réessayez la mise à jour.',
+  'updateDialog.error.restartFailed': 'Impossible de redémarrer pour installer la mise à jour.',
+  'updateDialog.error.restartUnavailable': 'L’installation de la mise à jour nécessite l’application de bureau OpenChamber.',
   'mobileUpdate.toast.available.title': 'Mise à jour OpenChamber disponible',
   'mobileUpdate.toast.available.description': 'La version {version} est prête pour Android.',
   'mobileUpdate.toast.actions.download': 'Télécharger',
@@ -2702,6 +2728,7 @@ export const dict = {
   'memoryDebugPanel.title': 'Panneau de débogage',
   'memoryDebugPanel.tabs.memory': 'Mémoire',
   'memoryDebugPanel.tabs.streaming': 'Streaming',
+  'memoryDebugPanel.tabs.requests': 'Requêtes',
   'memoryDebugPanel.section.sessionsInMemory': 'Sessions en mémoire',
   'memoryDebugPanel.section.uiStreamingMetrics': 'Métriques de streaming de l\'interface utilisateur',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'Métriques du pont VS Code',
@@ -2739,6 +2766,16 @@ export const dict = {
   'memoryDebugPanel.streaming.copy.copied': 'Débogage en streaming JSON copié',
   'memoryDebugPanel.streaming.copy.failed': 'Échec de la copie de JSON',
   'memoryDebugPanel.streaming.copy.hint': 'La copie exporte les métriques de streaming de l\'interface utilisateur et de VS Code en tant que JSON.',
+  'memoryDebugPanel.requests.inFlight': 'En cours',
+  'memoryDebugPanel.requests.peak': 'Pic',
+  'memoryDebugPanel.requests.duration': 'Durée',
+  'memoryDebugPanel.requests.totalRequests': 'Requêtes totales',
+  'memoryDebugPanel.requests.tracking': 'Suivi',
+  'memoryDebugPanel.requests.now': 'maintenant',
+  'memoryDebugPanel.requests.noSamples': 'Aucune requête enregistrée. Gardez ce panneau ouvert pour enregistrer l\'activité fetch.',
+  'memoryDebugPanel.requests.chartLabel': 'Requêtes fetch en cours dans le temps, pic {peak}',
+  'memoryDebugPanel.requests.windowHint': '{seconds}s dernières',
+  'memoryDebugPanel.requests.percentileChartLabel': 'Percentiles d\'âge des requêtes en cours (p50, p90, p99, max) dans le temps',
   'memoryDebugPanel.common.idle': 'inactif',
   'memoryDebugPanel.common.live': 'en direct',
   'memoryDebugPanel.common.notAvailable': 'n / A',
@@ -2802,7 +2839,7 @@ export const dict = {
   'quota.window.premium': 'Interactions premium',
   'quota.window.chat': 'Requêtes de chat',
   'quota.window.completions': 'Complétions',
-  'quota.window.premiumInteractions': 'Interactions premium',
+  'quota.window.premiumInteractions': 'Crédits IA',
   'layout.mainTab.diagram': 'Diagramme',
   'mobile.nav.aria': 'Navigation mobile',
   'mobile.connect.welcome.title': 'Se connecter à OpenChamber',
@@ -2881,6 +2918,7 @@ export const dict = {
   'mobile.sessions.section.worktrees': 'Worktrees',
   'mobile.sessions.section.otherProjects': 'Changer de projet',
   'mobile.sessions.section.projects': 'Projets',
+  'mobile.sessions.section.chats': 'Discussions',
   'mobile.sessions.empty.noProjectsTitle': 'Aucun projet pour le moment',
   'mobile.sessions.empty.noProjectsDescription': 'Ajoutez un projet pour commencer à discuter avec votre code.',
   'mobile.sessions.empty.noSessionsTitle': 'Aucune session pour le moment',
@@ -3092,6 +3130,7 @@ export const dict = {
   'chat.toolPart.showRawJson': 'Afficher le JSON brut',
   'chat.toolPart.showFormattedJson': 'Afficher le JSON formaté',
   'chat.toolPart.showNavigableJson': 'Afficher le JSON navigable',
+  'chat.toolPart.openFile': 'Ouvrir le fichier',
   'chat.toolPart.openFileAtFirstChange': 'Ouvrir le fichier à la première modification',
   'chat.toolPart.openFileDiff': 'Ouvrir les différences du fichier',
   'chat.toolPart.copyOutput': 'Copier la sortie',
@@ -3111,6 +3150,7 @@ export const dict = {
   'vscodeLayout.actions.cancel': 'Annuler',
   'chat.workStatus.ariaLabel': 'État du travail',
   'chat.workStatus.context.label': 'Contexte',
+  'chat.workStatus.cost.breakdown': 'Session {session} · Sous-agents {subagents}',
   'chat.workStatus.git.changedFileSingle': '{count} fichier modifié',
   'chat.workStatus.git.changedFilePlural': '{count} fichiers modifiés',
   'chat.workStatus.pr.untitled': 'Pull request sans titre',