Merge main

packages/electron/main.mjs

@@ -33,6 +33,7 @@ import {
 } from './linux-autostart.mjs';
 import { unsupportedAppSpecificOpenError, validateLocalPath } from './path-open-utils.mjs';
 import { shouldAllowBrowserPanelCertificateError } from './browser-panel-security.mjs';
+import { createRendererRecoveryPolicy } from './renderer-recovery.mjs';
 import { mintOutsideFileGrant } from '@openchamber/web/server/lib/fs/routes.js';
 
 const execFileAsync = promisify(execFile);
@@ -2496,6 +2497,7 @@ const createBrowserWindow = ({ label, restoreGeometry, url, runtimeConfig = {} }
   };
 
   const browserWindow = new BrowserWindow(options);
+  const rendererRecoveryPolicy = createRendererRecoveryPolicy();
   browserWindow.__ocLabel = label || nextWindowLabel();
   browserWindow.__ocRuntimeConfig = { apiBaseUrl: desktopApiBaseUrl, clientToken: desktopClientToken, requestHeaders: desktopRequestHeaders };
   browserWindow.__ocInitScript = buildInitScript(desktopLocalOrigin, state.bootOutcome, desktopApiBaseUrl, desktopClientToken, desktopRequestHeaders);
@@ -2656,6 +2658,19 @@ const createBrowserWindow = ({ label, restoreGeometry, url, runtimeConfig = {} }
   browserWindow.webContents.on('zoom-changed', () => {
     browserWindow.webContents.setZoomFactor(1);
   });
+  browserWindow.webContents.on('render-process-gone', (_event, details) => {
+    if (!rendererRecoveryPolicy.shouldReload(details.reason)) return;
+    log.warn('[electron] renderer exited unexpectedly; reloading window', {
+      label: browserWindow.__ocLabel,
+      reason: details.reason,
+      exitCode: details.exitCode,
+    });
+    setTimeout(() => {
+      if (!browserWindow.isDestroyed()) {
+        browserWindow.webContents.reload();
+      }
+    }, 100);
+  });
 
   browserWindow.webContents.on('dom-ready', () => {
     if (browserWindow.__ocLabel === 'main') {

packages/electron/renderer-recovery.mjs

@@ -0,0 +1,30 @@
+const RECOVERY_WINDOW_MS = 60_000;
+const MAX_RECOVERY_ATTEMPTS = 3;
+
+const RECOVERABLE_REASONS = new Set([
+  'abnormal-exit',
+  'crashed',
+  'oom',
+  'memory-eviction',
+]);
+
+export const createRendererRecoveryPolicy = (now = Date.now) => {
+  let windowStartedAt = 0;
+  let attempts = 0;
+
+  return {
+    shouldReload: (reason) => {
+      if (!RECOVERABLE_REASONS.has(reason)) return false;
+
+      const currentTime = now();
+      if (currentTime - windowStartedAt >= RECOVERY_WINDOW_MS) {
+        windowStartedAt = currentTime;
+        attempts = 0;
+      }
+      if (attempts >= MAX_RECOVERY_ATTEMPTS) return false;
+
+      attempts += 1;
+      return true;
+    },
+  };
+};

packages/electron/renderer-recovery.test.mjs

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createRendererRecoveryPolicy } from './renderer-recovery.mjs';
+
+test('allows a bounded number of reloads for recoverable renderer failures', () => {
+  const policy = createRendererRecoveryPolicy(() => 1_000);
+
+  assert.equal(policy.shouldReload('crashed'), true);
+  assert.equal(policy.shouldReload('oom'), true);
+  assert.equal(policy.shouldReload('abnormal-exit'), true);
+  assert.equal(policy.shouldReload('memory-eviction'), false);
+});
+
+test('ignores clean and externally killed renderer exits', () => {
+  const policy = createRendererRecoveryPolicy(() => 1_000);
+
+  assert.equal(policy.shouldReload('clean-exit'), false);
+  assert.equal(policy.shouldReload('killed'), false);
+  assert.equal(policy.shouldReload('launch-failed'), false);
+});
+
+test('resets the recovery budget after the recovery window', () => {
+  let currentTime = 1_000;
+  const policy = createRendererRecoveryPolicy(() => currentTime);
+
+  assert.equal(policy.shouldReload('crashed'), true);
+  assert.equal(policy.shouldReload('crashed'), true);
+  assert.equal(policy.shouldReload('crashed'), true);
+  assert.equal(policy.shouldReload('crashed'), false);
+
+  currentTime += 60_000;
+  assert.equal(policy.shouldReload('crashed'), true);
+});

packages/mobile/android/app/src/main/AndroidManifest.xml

@@ -1,17 +1,12 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <!-- usesCleartextTraffic: OpenChamber connects to user-hosted servers over
-         plain http:// on the local network (LAN transport). Android blocks all
-         cleartext HTTP by default (targetSdk >= 28), which silently failed every
-         LAN probe and forced Android onto relay-only. This mirrors the iOS ATS
-         exceptions (NSAllowsArbitraryLoadsInWebContent + NSAllowsLocalNetworking). -->
     <application
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:usesCleartextTraffic="true"
         android:theme="@style/AppTheme">
         <activity
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation"

packages/mobile/android/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+            <certificates src="user" />
+        </trust-anchors>
+    </base-config>
+</network-security-config>

packages/ui/package.json

@@ -67,6 +67,7 @@
     "http-proxy-middleware": "^3.0.5",
     "katex": "^0.17.0",
     "marked": "^17.0.3",
+    "marked-linkify-it": "^4.0.2",
     "morphdom": "^2.7.7",
     "motion": "^12.23.24",
     "next-themes": "^0.4.6",

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';
@@ -279,6 +280,13 @@ function App({ apis }: AppProps) {
     };
   }, [showMemoryDebug]);
 
+  React.useEffect(() => {
+    setRequestsInFlightTrackingEnabled(showMemoryDebug);
+    return () => {
+      setRequestsInFlightTrackingEnabled(false);
+    };
+  }, [showMemoryDebug]);
+
   React.useEffect(() => {
     applyMobileKeyboardMode(mobileKeyboardMode);
   }, [mobileKeyboardMode]);

packages/ui/src/apps/MobileApp.tsx

@@ -22,6 +22,7 @@ import { useUpdatePolling } from '@/hooks/useUpdatePolling';
 import { useWindowTitle } from '@/hooks/useWindowTitle';
 import { opencodeClient } from '@/lib/opencode/client';
 import type { RuntimeAPIs } from '@/lib/api/types';
+import type { ProjectRef } from '@/lib/projectContextApi';
 import { readTabletLayout, useOrientation, useTabletLayout } from '@/lib/device';
 import { useHardwareKeyboard } from '@/lib/hardwareKeyboard';
 import { useI18n } from '@/lib/i18n';
@@ -111,7 +112,7 @@ const MobileShell: React.FC<{ onActiveConnectionDeleted: () => void }> = ({ onAc
   const [workspaceTab, setWorkspaceTab] = React.useState<MobileWorkspaceTab>('changes');
   // A plan opened from the workspace drawer's Notes tab, shown as a fullscreen
   // layer on top of it (back returns to the notes).
-  const [openPlan, setOpenPlan] = React.useState<{ id: string; title: string } | null>(null);
+  const [openPlan, setOpenPlan] = React.useState<{ id: string; title: string; projectRef: ProjectRef } | null>(null);
   const [settingsInitialMobileStage, setSettingsInitialMobileStage] = React.useState<'nav' | 'page-content'>('nav');
   // When set, the Changes surface opens directly into the per-file diff for this path.
   const [pendingChangesDiff, setPendingChangesDiff] = React.useState<{ path: string; staged: boolean } | null>(null);
@@ -542,7 +543,7 @@ const MobileShell: React.FC<{ onActiveConnectionDeleted: () => void }> = ({ onAc
           >
             <ErrorBoundary>
               <PlanView
-                projectPlanId={openPlan.id}
+                savedProjectPlan={{ projectRef: openPlan.projectRef, planId: openPlan.id }}
                 onNavigatedToChat={() => {
                   closeSurface();
                   closeWorkspace();

packages/ui/src/apps/MobileWorkspaceDrawer.tsx

@@ -9,6 +9,7 @@ import { ErrorBoundary } from '@/components/ui/ErrorBoundary';
 import { SortableTabsStrip, type SortableTabsStripItem } from '@/components/ui/sortable-tabs-strip';
 import { TerminalView } from '@/components/views/TerminalView';
 import { useI18n } from '@/lib/i18n';
+import type { ProjectRef } from '@/lib/projectContextApi';
 import { cn } from '@/lib/utils';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
 import { useMcpConfigStore } from '@/stores/useMcpConfigStore';
@@ -105,7 +106,7 @@ export const MobileWorkspaceDrawer: React.FC<{
   /** When set, the Changes tab opens directly into the per-file diff. */
   pendingChangesDiff: { path: string; staged: boolean } | null;
   /** Notes tab: opens a plan fullscreen (layered above the drawer). */
-  onOpenPlan: (plan: { id: string; title: string }) => void;
+  onOpenPlan: (plan: { id: string; title: string; projectRef: ProjectRef }) => void;
   /** MCP tab: jump to the MCP settings page pre-seeded with a new server draft. */
   onOpenMcpSettings: () => void;
   variant?: 'drawer' | 'panel';

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 { BTW_BOUNDARY_INSTRUCTION, BTW_PROMOTION_NOTICE, 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,14 @@ const ChatInputComponent: React.FC<ChatInputProps> = ({
             composerText: !queuedOnly && inputSnapshot.hasContent ? inputSnapshot.message : null,
             composerAttachments: attachedFiles,
             inlineComments: drafts,
-            syntheticTexts: syntheticParts?.map((part) => part.text) ?? [],
+            // btw mode: the boundary rides with every send, not just the
+            // first one, so the inherited transcript stays reference material
+            // for the whole side conversation.
+            syntheticTexts: [
+                ...(isBtwActive ? [BTW_BOUNDARY_INSTRUCTION] : []),
+                ...(isPromotedBtwSession ? [BTW_PROMOTION_NOTICE] : []),
+                ...(syntheticParts?.map((part) => part.text) ?? []),
+            ],
             linkedIssue: linkedIssue
                 ? { number: linkedIssue.number, title: linkedIssue.title, url: linkedIssue.url, contextText: linkedIssue.contextText }
                 : null,
@@ -1620,39 +1635,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 +2845,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/ChatMessage.tsx

@@ -21,7 +21,7 @@ import { deriveMessageRole } from './message/messageRole';
 import { filterVisibleParts, normalizeParts } from './message/partUtils';
 import { normalizeUserDisplayParts } from './message/normalizeUserDisplayParts';
 import { isHiddenUserMessage } from './message/hiddenUserMessage';
-import { flattenAssistantTextParts } from '@/lib/messages/messageText';
+import { flattenAssistantTextParts, flattenUserTextParts } from '@/lib/messages/messageText';
 import { isLikelyProviderAuthFailure, PROVIDER_AUTH_FAILURE_MESSAGE } from '@/lib/messages/providerAuthError';
 import { getProviderModelDisplayName } from '@/lib/modelDisplay';
 import { lazyWithChunkRecovery } from '@/lib/chunkLoadRecovery';
@@ -702,40 +702,7 @@ const ChatMessage: React.FC<ChatMessageProps> = ({
 
     const messageTextContent = React.useMemo(() => {
         if (isUser) {
-            const shellOutputs = displayParts
-                .filter((part): part is Part & { type: 'text'; shellAction?: { output?: unknown } } => part.type === 'text')
-                .map((part) => {
-                    const output = part.shellAction?.output;
-                    return typeof output === 'string' ? output.trim() : '';
-                })
-                .filter((output) => output.length > 0);
-
-            if (shellOutputs.length > 0) {
-                return shellOutputs.join('\n\n');
-            }
-
-            const shellCommands = displayParts
-                .filter((part): part is Part & { type: 'text'; shellAction?: { command?: unknown } } => part.type === 'text')
-                .map((part) => {
-                    const command = part.shellAction?.command;
-                    return typeof command === 'string' ? command.trim() : '';
-                })
-                .filter((command) => command.length > 0);
-
-            if (shellCommands.length > 0) {
-                return shellCommands.join('\n');
-            }
-
-            const textParts = displayParts
-                .filter((part): part is Part & { type: 'text'; text?: string; content?: string } => part.type === 'text')
-                .map((part) => {
-                    const text = part.text || part.content || '';
-                    return text.trim();
-                })
-                .filter((text) => text.length > 0);
-
-            const combined = textParts.join('\n');
-            return combined.replace(/\n\s*\n+/g, '\n');
+            return flattenUserTextParts(displayParts);
         }
 
         if (assistantErrorText && assistantErrorText.trim().length > 0) {

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,25 @@
+import { describe, expect, test } from 'bun:test';
+
+import { SimpleMarkdownRenderer } from './MarkdownRenderer';
+import { QuestionMarkdown } from './QuestionMarkdown';
+
+describe('QuestionMarkdown', () => {
+  test('delegates exact content to the tool markdown renderer', () => {
+    const content = 'Choose **one** from `mode`: [details](https://example.com)';
+    const element = QuestionMarkdown({ content, size: 'meta' });
+
+    expect(element.type).toBe(SimpleMarkdownRenderer);
+    expect(element.props.content).toBe(content);
+    expect(element.props.variant).toBe('tool');
+    expect(element.props.fallbackContent.props.children).toBe(content);
+    expect(element.props.fallbackContent.props.className).toContain('whitespace-pre-wrap');
+  });
+
+  test('preserves question typography size and caller classes', () => {
+    const meta = QuestionMarkdown({ content: 'Meta', size: 'meta', className: 'font-medium text-foreground' });
+    const micro = QuestionMarkdown({ content: 'Micro', size: 'micro', className: 'text-muted-foreground' });
+
+    expect(meta.props.className).toBe('question-markdown typography-meta font-medium text-foreground');
+    expect(micro.props.className).toBe('question-markdown typography-micro text-muted-foreground');
+  });
+});

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

@@ -112,6 +112,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,6 +34,7 @@ import {
 
 import { cn } from '@/lib/utils';
 import type { ComposerLanguageContext } from '../language/tokenize';
+import type { ComposerAutoCorrect } from './autocorrect';
 import { composerLanguage, setLanguageContext } from './composerLanguage';
 import type { ComposerEditorViewStore } from './viewStore';
 import { composerEditorTheme, composerSelectionExtension } from './theme';
@@ -63,8 +64,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 +90,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 +161,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 +291,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'] }
@@ -454,7 +458,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]);
 
@@ -516,12 +520,13 @@ export const ComposerEditor = React.forwardRef<ComposerEditorHandle, ComposerEdi
                     userEvent: 'input.type',
                 });
             },
-            replaceRange(from, to, text, caret) {
+            replaceRange(from, to, text, selectionStart, selectionEnd = selectionStart) {
                 const view = viewRef.current;
                 if (!view) return;
+                const anchor = selectionStart ?? from + text.length;
                 view.dispatch({
                     changes: { from, to, insert: text },
-                    selection: { anchor: caret ?? from + text.length },
+                    selection: { anchor, head: selectionEnd ?? anchor },
                     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/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/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)] px-[0.3125rem] py-0.5',
     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/markdown/decorate.ts

@@ -156,9 +156,8 @@ const layoutCodeLines = (pre: HTMLPreElement): void => {
     row.setAttribute('data-md-code-line', '');
 
     const number = document.createElement('span');
-    number.setAttribute('data-md-code-line-number', '');
+    number.setAttribute('data-md-code-line-number', String(index + 1));
     number.setAttribute('aria-hidden', 'true');
-    number.textContent = String(index + 1);
 
     const content = document.createElement('span');
     content.setAttribute('data-md-code-line-content', '');
@@ -168,7 +167,6 @@ const layoutCodeLines = (pre: HTMLPreElement): void => {
     } else {
       content.textContent = sourceLine;
     }
-
     row.append(number, content);
     fragment.appendChild(row);
     if (index < sourceLines.length - 1 || hasTrailingNewline) {
@@ -543,6 +541,67 @@ const closeAllMenus = (container: HTMLElement): void => {
   }
 };
 
+const getContainingMarkdownCode = (node: Node): HTMLElement | null => {
+  const element = node.nodeType === 1 ? node as Element : node.parentElement;
+  return element?.closest<HTMLElement>('pre code[data-md-code-lines]') ?? null;
+};
+
+const getMarkdownCodeSelectionText = (range: Range): string | null => {
+  const code = getContainingMarkdownCode(range.startContainer);
+  if (!code || code !== getContainingMarkdownCode(range.endContainer)) return null;
+  // Line numbers are CSS-generated, so the DOM range is already the exact
+  // source selection, including boundaries between rows and empty lines.
+  return range.toString();
+};
+
+type MarkdownCopyState = {
+  registrations: number;
+  handler: (event: ClipboardEvent) => void;
+  menuHandler: (event: Event) => void;
+};
+
+const markdownCopyStates = new WeakMap<Document, MarkdownCopyState>();
+
+const registerMarkdownCodeCopy = (doc: Document): (() => void) => {
+  let state = markdownCopyStates.get(doc);
+  if (!state) {
+    const getSelectedText = (): string | null => {
+      const selection = doc.getSelection();
+      if (!selection || selection.rangeCount !== 1 || selection.isCollapsed) return null;
+      return getMarkdownCodeSelectionText(selection.getRangeAt(0));
+    };
+    const handler = (event: ClipboardEvent) => {
+      if (!event.clipboardData) return;
+      const text = getSelectedText();
+      if (text === null) return;
+      event.preventDefault();
+      event.stopPropagation();
+      event.clipboardData.setData('text/plain', text);
+    };
+    const menuHandler = (event: Event) => {
+      const text = getSelectedText();
+      if (text === null) return;
+      event.preventDefault();
+      void copyTextToClipboard(text);
+    };
+    state = { registrations: 0, handler, menuHandler };
+    markdownCopyStates.set(doc, state);
+    doc.addEventListener('copy', handler, true);
+    doc.defaultView?.addEventListener('openchamber:copy', menuHandler);
+  }
+  state.registrations += 1;
+
+  return () => {
+    const current = markdownCopyStates.get(doc);
+    if (!current) return;
+    current.registrations -= 1;
+    if (current.registrations > 0) return;
+    doc.removeEventListener('copy', current.handler, true);
+    doc.defaultView?.removeEventListener('openchamber:copy', current.menuHandler);
+    markdownCopyStates.delete(doc);
+  };
+};
+
 /**
  * Attach a single delegated click listener for all in-markdown actions: code
  * copy, table copy/download menus, mermaid copy/download, loopback preview.
@@ -552,6 +611,7 @@ export const attachMarkdownInteractions = (
   container: HTMLElement,
   ctx: DecorateContext,
 ): (() => void) => {
+  const unregisterCodeCopy = registerMarkdownCodeCopy(container.ownerDocument);
   const handleClick = (event: MouseEvent) => {
     const target = event.target;
     if (!(target instanceof Element)) return;
@@ -658,5 +718,8 @@ export const attachMarkdownInteractions = (
   };
 
   container.addEventListener('click', handleClick);
-  return () => container.removeEventListener('click', handleClick);
+  return () => {
+    unregisterCodeCopy();
+    container.removeEventListener('click', handleClick);
+  };
 };

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

@@ -279,3 +279,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';
@@ -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 }) => {
@@ -1407,7 +1413,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 +1450,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 +1971,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) {
@@ -2037,6 +2044,61 @@ 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 handleQuickOpenKeyDown = (event: React.KeyboardEvent<HTMLButtonElement>) => {
+        if (event.key !== 'Enter' && event.key !== ' ') return;
+        event.preventDefault();
+        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 +2192,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="flex items-center gap-1 min-w-0 flex-1">
                                 <MinDurationShineText
                                     active={Boolean(isActive && !isError)}
                                     minDurationMs={300}
@@ -2140,6 +2202,22 @@ const ToolPartContent: React.FC<ToolPartProps> = ({
                                 >
                                     {displayName}
                                 </MinDurationShineText>
+                                {quickOpenTarget ? (
+                                    <button
+                                        type="button"
+                                        onClick={handleQuickOpen}
+                                        onKeyDown={handleQuickOpenKeyDown}
+                                        className={cn(
+                                            'flex-shrink-0 inline-flex h-4 w-4 items-center justify-center rounded transition-opacity hover:bg-[var(--surface-hover)]',
+                                            'opacity-0 group-hover/tool:opacity-60 hover:opacity-100 focus-visible:opacity-100',
+                                        )}
+                                        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/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/layout/ContextPanel.tsx

@@ -943,7 +943,12 @@ export const ContextPanel: React.FC = () => {
             : activeTab?.mode === 'notes'
                 ? <ProjectContextPanel />
         : activeTab?.mode === 'plan'
-            ? <React.Suspense fallback={null}><PlanView targetPath={activeTab.targetPath} projectPlanId={activeTab.projectPlanId} /></React.Suspense>
+            ? <React.Suspense fallback={null}><PlanView
+                targetPath={activeTab.targetPath}
+                savedProjectPlan={activeTab.projectPlanId && activeTab.projectPlanRef
+                  ? { projectRef: activeTab.projectPlanRef, planId: activeTab.projectPlanId }
+                  : null}
+              /></React.Suspense>
             : null;
 
   const browserTabs = React.useMemo(

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

@@ -6,63 +6,53 @@ import { useProjectsStore } from '@/stores/useProjectsStore';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
 import { formatDirectoryName } from '@/lib/utils';
 import { useSessionUIStore } from '@/sync/session-ui-store';
-import { CHAT_DRAFT_PROJECT_ID, getChatsRootForHome, getChatsRootFromDirectory, isChatDirectoryPath } from '@/lib/chatDirectories';
+import { useProjectContextOwner } from '@/hooks/useProjectContextOwner';
+import { CHAT_DRAFT_PROJECT_ID } from '@/lib/chatDirectories';
+import type { ProjectRef } from '@/lib/projectContextApi';
 import { useI18n } from '@/lib/i18n';
 
 export const ProjectContextPanel: React.FC<{
   onActionComplete?: () => void;
-  onOpenPlan?: (plan: { id: string; title: string }) => void;
+  onOpenPlan?: (plan: { id: string; title: string; projectRef: ProjectRef }) => void;
 }> = ({ onActionComplete, onOpenPlan }) => {
-  const activeProjectId = useProjectsStore((state) => state.activeProjectId);
-  const projects = useProjectsStore((state) => state.projects);
   const homeDirectory = useDirectoryStore((state) => state.homeDirectory);
   const { t } = useI18n();
   const gitDirectories = useGitStore((state) => state.directories);
-  const isChatContext = useSessionUIStore((state) => (
-    state.newSessionDraft.open
-      ? state.newSessionDraft.target === 'chat'
-      : isChatDirectoryPath(state.currentSessionDirectory)
-  ));
   const chatSessionDirectory = useSessionUIStore((state) => state.currentSessionDirectory);
-  const chatsRoot = getChatsRootFromDirectory(chatSessionDirectory) ?? getChatsRootForHome(homeDirectory);
 
-  const activeProject = React.useMemo(() => {
-    if (isChatContext) return null;
-    if (activeProjectId) {
-      return projects.find((project) => project.id === activeProjectId) ?? projects[0] ?? null;
-    }
-    return projects[0] ?? null;
-  }, [activeProjectId, isChatContext, projects]);
+  // One owner decision shared with the panel, agent memory, and PlanView:
+  // chats resolve to the Chats owner, worktrees to their project, and an
+  // unrecognized directory owns nothing (null) rather than borrowing
+  // whichever project happens to be active.
+  const projectRef = useProjectContextOwner(chatSessionDirectory);
 
-  const projectRef = React.useMemo(() => {
-    if (isChatContext && chatsRoot) {
-      return { id: CHAT_DRAFT_PROJECT_ID, path: chatsRoot };
-    }
-    if (!activeProject) {
-      return null;
-    }
-    return {
-      id: activeProject.id,
-      path: activeProject.path,
-    };
-  }, [activeProject, chatsRoot, isChatContext]);
+  // Display-only lookup: a user-renamed project label wins over the directory
+  // name. The owner decision stays with the hook — this must not reintroduce
+  // a fallback.
+  const projects = useProjectsStore((state) => state.projects);
+  const labeledProject = React.useMemo(
+    () => (projectRef ? projects.find((project) => project.id === projectRef.id) ?? null : null),
+    [projectRef, projects],
+  );
 
   const projectLabel = React.useMemo(() => {
-    if (isChatContext) return t('sessions.sidebar.activity.chatsTitle');
-    if (!activeProject) {
+    if (!projectRef) {
       return null;
     }
-    return activeProject.label?.trim()
-      || formatDirectoryName(activeProject.path, homeDirectory)
-      || activeProject.path;
-  }, [activeProject, homeDirectory, isChatContext, t]);
+    if (projectRef.id === CHAT_DRAFT_PROJECT_ID) {
+      return t('sessions.sidebar.activity.chatsTitle');
+    }
+    return labeledProject?.label?.trim()
+      || formatDirectoryName(projectRef.path, homeDirectory)
+      || projectRef.path;
+  }, [homeDirectory, labeledProject, projectRef, t]);
 
   const canCreateWorktree = React.useMemo(() => {
-    if (!activeProject) {
+    if (!projectRef || projectRef.id === CHAT_DRAFT_PROJECT_ID) {
       return false;
     }
-    return gitDirectories.get(activeProject.path)?.isGitRepo === true;
-  }, [activeProject, gitDirectories]);
+    return gitDirectories.get(projectRef.path)?.isGitRepo === true;
+  }, [gitDirectories, projectRef]);
 
   return (
     /* The panel scrolls its own tab content; a scroller here would nest. */

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.test.tsx

@@ -0,0 +1,228 @@
+import React from 'react';
+import { describe, expect, mock, test } from 'bun:test';
+import { renderToStaticMarkup } from 'react-dom/server';
+
+type ClickEvent = { stopPropagation: () => void };
+type ClickHandler = (event: ClickEvent) => void;
+type ChildrenProps = { children?: React.ReactNode };
+type ClickableProps = ChildrenProps & { onClick?: ClickHandler };
+type TriggerProps = ChildrenProps & { render?: React.ReactNode };
+
+interface AgentDraftSnapshot {
+  name: string;
+  scope: string;
+  description?: string;
+  model?: string | null;
+  variant?: string;
+  temperature?: number;
+  top_p?: number;
+  prompt?: string;
+  mode?: string;
+  permission?: Record<string, string>;
+  disable?: boolean;
+}
+
+interface AgentRecord {
+  name: string;
+  description: string;
+  model: { providerID: string; modelID: string };
+  variant: string;
+  temperature: number;
+  topP: number;
+  prompt: string;
+  mode: string;
+  permission: Array<{ permission: string; pattern: string; action: 'allow' | 'ask' | 'deny' }>;
+  scope: string;
+  disable: boolean;
+}
+
+interface AgentStoreState {
+  selectedAgentName: string | null;
+  agents: AgentRecord[];
+  setAgentDraft: (draft: AgentDraftSnapshot) => void;
+  setSelectedAgent: (name: string) => void;
+  createAgent: () => Promise<{ ok: boolean }>;
+  deleteAgent: () => Promise<{ ok: boolean }>;
+  loadAgents: () => Promise<void>;
+}
+
+const sourceAgent: AgentRecord = {
+  name: 'writer',
+  description: 'Writes concise documentation',
+  model: { providerID: 'openai', modelID: 'gpt-4.1' },
+  variant: 'fast',
+  temperature: 0.4,
+  topP: 0.8,
+  prompt: 'Write clear documentation.',
+  mode: 'subagent',
+  permission: [{ permission: 'bash', pattern: '*', action: 'ask' }],
+  scope: 'project',
+  disable: true,
+};
+
+let recordedDraft: AgentDraftSnapshot | null = null;
+let selectedAgentName: string | null = null;
+let duplicateMenuClick: ClickHandler | null = null;
+let mobileDevice = true;
+
+const agentStore: AgentStoreState = {
+  selectedAgentName: null,
+  agents: [sourceAgent],
+  setAgentDraft: (draft) => {
+    recordedDraft = draft;
+  },
+  setSelectedAgent: (name) => {
+    selectedAgentName = name;
+  },
+  createAgent: async () => ({ ok: true }),
+  deleteAgent: async () => ({ ok: true }),
+  loadAgents: async () => {},
+};
+
+function useAgentsStore<Selected>(selector: (state: AgentStoreState) => Selected): Selected {
+  return selector(agentStore);
+}
+
+function useShallow<Selector>(selector: Selector): Selector {
+  return selector;
+}
+
+mock.module('@/components/ui/button', () => ({
+  Button: ({ children, onClick }: ClickableProps) => <button onClick={onClick}>{children}</button>,
+}));
+
+mock.module('@/components/ui/input', () => ({
+  Input: () => <input />,
+}));
+
+mock.module('@/components/ui', () => ({
+  toast: { error: () => {}, success: () => {}, warning: () => {} },
+}));
+
+mock.module('@/lib/device', () => ({
+  isMobileDeviceViaCSS: () => mobileDevice,
+}));
+
+mock.module('@/components/ui/dialog', () => ({
+  Dialog: ({ children }: ChildrenProps) => <>{children}</>,
+  DialogContent: ({ children }: ChildrenProps) => <div>{children}</div>,
+  DialogDescription: ({ children }: ChildrenProps) => <div>{children}</div>,
+  DialogFooter: ({ children }: ChildrenProps) => <div>{children}</div>,
+  DialogHeader: ({ children }: ChildrenProps) => <div>{children}</div>,
+  DialogTitle: ({ children }: ChildrenProps) => <div>{children}</div>,
+}));
+
+mock.module('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: ({ children }: ChildrenProps) => <>{children}</>,
+  DropdownMenuContent: ({ children }: ChildrenProps) => <div>{children}</div>,
+  DropdownMenuItem: ({ children, onClick }: ClickableProps) => {
+    if (React.Children.toArray(children).includes('Duplicate')) {
+      duplicateMenuClick = onClick ?? null;
+    }
+    return <button onClick={onClick}>{children}</button>;
+  },
+  DropdownMenuTrigger: ({ children }: ChildrenProps) => <>{children}</>,
+}));
+
+mock.module('@/components/ui/context-menu', () => ({
+  ContextMenu: ({ children }: ChildrenProps) => <>{children}</>,
+  ContextMenuContent: ({ children }: ChildrenProps) => <div>{children}</div>,
+  ContextMenuItem: ({ children }: ChildrenProps) => <div>{children}</div>,
+  ContextMenuTrigger: ({ children, render }: TriggerProps) => <>{render}{children}</>,
+}));
+
+mock.module('@/hooks/useSettingsDirectory', () => ({
+  useSettingsDirectory: () => '/workspace',
+}));
+
+mock.module('@/stores/useAgentsStore', () => ({
+  useAgentsStore,
+  selectAgentsForDirectory: (state: AgentStoreState) => state.agents,
+  isAgentBuiltIn: () => false,
+  isAgentHidden: () => false,
+}));
+
+mock.module('zustand/react/shallow', () => ({ useShallow }));
+
+mock.module('@/lib/utils', () => ({
+  cn: (...classes: Array<string | false | null | undefined>) => classes.filter(Boolean).join(' '),
+}));
+
+mock.module('@/components/ui/ScrollableOverlay', () => ({
+  ScrollableOverlay: ({ children }: ChildrenProps) => <div>{children}</div>,
+}));
+
+mock.module('@/components/sections/shared/SettingsProjectSelector', () => ({
+  SettingsProjectSelector: () => null,
+}));
+
+mock.module('@/components/sections/shared/SidebarGroup', () => ({
+  SidebarGroup: ({ children }: ChildrenProps) => <>{children}</>,
+}));
+
+mock.module('@/components/icon/Icon', () => ({
+  Icon: () => null,
+}));
+
+mock.module('@/lib/i18n', () => ({
+  useI18n: () => ({
+    t: (key: string) => (key === 'settings.common.actions.duplicate' ? 'Duplicate' : key),
+  }),
+}));
+
+mock.module('@/components/sections/shared/SettingsSection', () => ({
+  SETTINGS_PANEL_TITLE_CLASS: '',
+}));
+
+const { AgentsSidebar } = await import('./AgentsSidebar');
+
+function getDuplicateMenuClick(): ClickHandler {
+  if (!duplicateMenuClick) {
+    throw new Error('Expected the duplicate action to be rendered');
+  }
+  return duplicateMenuClick;
+}
+
+describe('AgentsSidebar duplicate action', () => {
+  test('notifies the mobile split-view parent once after preparing a prefilled agent draft', () => {
+    recordedDraft = null;
+    selectedAgentName = null;
+    duplicateMenuClick = null;
+    mobileDevice = true;
+    let mobileTransitionCount = 0;
+
+    renderToStaticMarkup(
+      <AgentsSidebar onItemSelect={() => { mobileTransitionCount += 1; }} />,
+    );
+
+    getDuplicateMenuClick()({ stopPropagation: () => {} });
+
+    expect(recordedDraft).toEqual({
+      name: 'writer-copy',
+      scope: 'project',
+      description: 'Writes concise documentation',
+      model: 'openai/gpt-4.1',
+      variant: 'fast',
+      temperature: 0.4,
+      top_p: 0.8,
+      prompt: 'Write clear documentation.',
+      mode: 'subagent',
+      permission: { bash: 'ask' },
+      disable: true,
+    });
+    expect(selectedAgentName).toBe('writer-copy');
+    expect(mobileTransitionCount).toBe(1);
+  });
+
+  test('does not require a mobile transition callback on desktop', () => {
+    recordedDraft = null;
+    selectedAgentName = null;
+    duplicateMenuClick = null;
+    mobileDevice = false;
+
+    renderToStaticMarkup(<AgentsSidebar />);
+
+    getDuplicateMenuClick()({ stopPropagation: () => {} });
+    expect(selectedAgentName).toBe('writer-copy');
+  });
+});

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/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/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/project-context/DOCUMENTATION.md

@@ -60,6 +60,18 @@ Leaving the section or the project closes it, so its editor never sits over a
 list it no longer matches. Hosts that own a fullscreen plan surface (mobile)
 still pass `onOpenPlan` and keep theirs.
 
+The panel owns the only source of truth for which project a plan belongs to,
+and it never lets the editor guess. `PlanView` receives the owner as
+`savedProjectPlan={{ projectRef, planId }}` — load and autosave both go to that
+exact project. An earlier version let the editor re-derive the project from the
+current directory, which silently opened an empty document for plans stored
+under the managed Chats owner (`openchamber:chats`), for plans opened from a
+worktree the directory lookup missed, and for plan tabs restored after a
+reload. Persisted plan tabs carry `projectPlanRef` for the same reason; a saved-plan
+tab persisted with an id but no owner is dropped on rehydrate rather than
+reopened against a guessed project. A plain session plan tab legitimately has
+neither an id nor an owner and is kept.
+
 ## Pins belong to one session
 
 Notes and plans are project data, but attaching one writes its id to the current
@@ -106,10 +118,16 @@ its own tool. It feeds this panel only — what a session is told about memory i
 decided server-side by `packages/web/server/lib/session-knowledge`, so it
 reaches sessions that have no UI at all and survives compaction.
 
-Both sides resolve a worktree to its project before touching the store — the
-client through `resolveProjectForSessionDirectory`, the server through
-`agent-memory/project-resolution`. Keying by the session directory instead filed
-a worktree's memories under a project nothing reads.
+`useProjectContextOwner` is the client authority shared by this panel and the
+memory sync. It resolves managed chat directories to the Chats root and a
+worktree to its project before either consumer touches a store. The server uses
+`agent-memory/project-resolution` for the same worktree rule. Keying by a
+worktree session directory would file memories under a project nothing reads.
+
+Project memory is rendered only when the store's `projectPath` matches the
+panel owner. An owner switch hides the previous project's entries before the
+new request starts. A failed request marks the new owner unavailable instead of
+presenting that hidden list as authoritative empty memory.
 
 Turning the switch back on re-reads the store only after the setting has
 finished being written. The switch flips the client immediately, which makes the

packages/ui/src/components/session/project-context/MemorySection.tsx

@@ -11,7 +11,7 @@ import { useI18n } from '@/lib/i18n';
 import { AGENT_MEMORY_BODY_MAX_LENGTH, AGENT_MEMORY_TITLE_MAX_LENGTH, type AgentMemoryEntry, type AgentMemoryScope } from '@/lib/agentMemoryApi';
 import { classifyMemory, memoryViewKey, type MemoryBadge } from '@/lib/agentMemoryBadges';
 import { cn } from '@/lib/utils';
-import { useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
+import { selectProjectMemoryForPath, useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
 import { useUIStore } from '@/stores/useUIStore';
 
 /**
@@ -160,7 +160,7 @@ export const MemorySection: React.FC<{
   const [expandedId, setExpandedId] = React.useState<string | null>(null);
 
   const globalEntries = useAgentMemoryStore((state) => state.global);
-  const projectEntries = useAgentMemoryStore((state) => state.project);
+  const projectEntries = useAgentMemoryStore((state) => selectProjectMemoryForPath(state, projectPath));
   const globalFailed = useAgentMemoryStore((state) => state.globalFailed);
   const projectFailed = useAgentMemoryStore((state) => state.projectFailed);
   const deleteEntry = useAgentMemoryStore((state) => state.deleteEntry);

packages/ui/src/components/session/project-context/PlansSection.tsx

@@ -5,7 +5,7 @@ import { toast } from '@/components/ui';
 import { Icon } from '@/components/icon/Icon';
 import { requestFileAccess } from '@/lib/desktop';
 import { getCurrentIntlLocale, useI18n } from '@/lib/i18n';
-import { parsePlanMarkdown, type ProjectPlanLink, type ProjectRef } from '@/lib/projectContextApi';
+import { parsePlanMarkdown, resolveProjectContextId, type ProjectPlanLink, type ProjectRef } from '@/lib/projectContextApi';
 import { runtimeFetch } from '@/lib/runtime-fetch';
 import { cn } from '@/lib/utils';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
@@ -23,8 +23,9 @@ export const PlansSection: React.FC<{
   plans: ProjectPlanLink[];
   /** Panel-wide filter, matched against plan titles. */
   query: string;
-  /** Hosts without a ContextPanel (mobile) render their own plan viewer. */
-  onOpenPlan?: (plan: { id: string; title: string }) => void;
+  /** Hosts without a ContextPanel (mobile) render their own plan viewer. The
+      plan carries its owner so the host viewer never guesses the project. */
+  onOpenPlan?: (plan: { id: string; title: string; projectRef: ProjectRef }) => void;
   pinnedPlanIds: ReadonlySet<string>;
   onTogglePinned: (planId: string, pinned: boolean) => Promise<boolean>;
 }> = ({ projectRef, plans, query, onOpenPlan, pinnedPlanIds, onTogglePinned }) => {
@@ -155,7 +156,7 @@ export const PlansSection: React.FC<{
   const handleOpenPlan = React.useCallback(
     (plan: ProjectPlanLink) => {
       if (onOpenPlan) {
-        onOpenPlan({ id: plan.id, title: plan.title });
+        onOpenPlan({ id: plan.id, title: plan.title, projectRef });
         return;
       }
       const panelDirectory = currentDirectory?.trim() || projectRef.path.trim();
@@ -165,11 +166,15 @@ export const PlansSection: React.FC<{
       openContextPanelTab(panelDirectory, {
         mode: 'plan',
         projectPlanId: plan.id,
-        dedupeKey: `plan:${plan.id}`,
+        projectPlanRef: projectRef,
+        // Storage identity is derived from the project path, not the settings
+        // id, so the tab identity uses the same derivation. Two projects
+        // sharing a settings id but not a path must not merge plan tabs.
+        dedupeKey: `plan:${resolveProjectContextId(projectRef)}:${plan.id}`,
         label: plan.title,
       });
     },
-    [currentDirectory, onOpenPlan, openContextPanelTab, projectRef.path]
+    [currentDirectory, onOpenPlan, openContextPanelTab, projectRef]
   );
 
   return (

packages/ui/src/components/session/project-context/ProjectNotesTodoPanel.tsx

@@ -7,7 +7,7 @@ import { Input } from '@/components/ui/input';
 import { useI18n } from '@/lib/i18n';
 import { resolveProjectContextId, type ProjectRef, type ProjectTodoItem } from '@/lib/projectContextApi';
 import { cn } from '@/lib/utils';
-import { useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
+import { selectProjectMemoryForPath, useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
 import { countHighlightedMemories, memoryViewKey } from '@/lib/agentMemoryBadges';
 import { EMPTY_PROJECT_CONTEXT_ENTRY, useProjectContextStore } from '@/stores/useProjectContextStore';
 import { useUIStore } from '@/stores/useUIStore';
@@ -29,8 +29,9 @@ interface ProjectNotesTodoPanelProps {
   canCreateWorktree?: boolean;
   onActionComplete?: () => void;
   /** When provided, opening a plan calls this instead of the desktop context
-      panel tab — hosts without ContextPanel (mobile) render their own viewer. */
-  onOpenPlan?: (plan: { id: string; title: string }) => void;
+      panel tab — hosts without ContextPanel (mobile) render their own viewer.
+      The plan carries its owner so the host's viewer cannot guess wrong. */
+  onOpenPlan?: (plan: { id: string; title: string; projectRef: ProjectRef }) => void;
   className?: string;
 }
 
@@ -133,7 +134,9 @@ export const ProjectNotesTodoPanel: React.FC<ProjectNotesTodoPanelProps> = ({
   const memoryDisabledByServer = useAgentMemoryStore((state) => state.disabled);
   const memoryVisible = memoryEnabled && !memoryDisabledByServer;
   const globalMemory = useAgentMemoryStore((state) => state.global);
-  const projectMemory = useAgentMemoryStore((state) => state.project);
+  const projectMemory = useAgentMemoryStore(
+    (state) => selectProjectMemoryForPath(state, projectRef?.path ?? null),
+  );
 
   const isMobile = useUIStore((state) => state.isMobile);
   const storedTab = useUIStore((state) => state.projectContextTab);
@@ -499,10 +502,10 @@ export const ProjectNotesTodoPanel: React.FC<ProjectNotesTodoPanelProps> = ({
           />
         ) : null}
 
-        {activeTab === 'plans' && openPlan ? (
+        {activeTab === 'plans' && openPlan && projectRef ? (
           <React.Suspense fallback={null}>
             <PlanView
-              projectPlanId={openPlan.id}
+              savedProjectPlan={{ projectRef, planId: openPlan.id }}
               onNavigatedToChat={() => setOpenPlan(null)}
             />
           </React.Suspense>

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,7 +104,75 @@ const PerfSection: React.FC<{ title: string; snapshot: StreamPerfSnapshot; empty
   );
 };
 
-const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
+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>
+  );
+};
+
+export const DebugPanel: React.FC<DebugPanelProps> = ({ onClose }) => {
   const { t } = useI18n();
   const [activeTab, setActiveTab] = React.useState<DebugTab>('memory');
   const [copyState, setCopyState] = React.useState<'idle' | 'copied' | 'error'>('idle');
@@ -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/PlanView.tsx

@@ -38,7 +38,10 @@ import { useEffectiveDirectory } from '@/hooks/useEffectiveDirectory';
 import { EditorView } from '@codemirror/view';
 import { copyTextToClipboard } from '@/lib/clipboard';
 import { generateBranchName } from '@/lib/git/branchNameGenerator';
-import { fetchProjectPlan, parsePlanMarkdown } from '@/lib/projectContextApi';
+import { fetchProjectPlan, parsePlanMarkdown, resolveProjectContextId, type SavedProjectPlanTarget } from '@/lib/projectContextApi';
+import { CHAT_DRAFT_PROJECT_ID } from '@/lib/chatDirectories';
+import { createPlanSaveQueue } from '@/lib/planSaveQueue';
+import { getRuntimeKey, subscribeRuntimeEndpointChanged } from '@/lib/runtime-switch';
 import { useProjectContextStore } from '@/stores/useProjectContextStore';
 import { createWorktreeSessionForNewBranch } from '@/lib/worktreeSessionCreator';
 import { TodoSendDialog, type TodoSendExecution } from '@/components/session/TodoSendDialog';
@@ -49,9 +52,12 @@ import { useI18n } from '@/lib/i18n';
 
 type PlanViewProps = {
   targetPath?: string | null;
-  /** Saved project plan to open. Project plans are server-owned and addressed
-      by id; they never carry a client-visible filesystem path. */
-  projectPlanId?: string | null;
+  /** Saved project plan to open, with the project that owns it. The owner is
+      part of the prop so the view never guesses it from the current directory:
+      plan tabs outlive directory changes (persisted context tabs, mobile
+      overlays), and for managed chats the owner is not a registered project a
+      directory lookup could ever find. */
+  savedProjectPlan?: SavedProjectPlanTarget | null;
   /** Called after a send action routes the user to the chat — hosts that show
       PlanView in an overlay (mobile fullscreen surface) close it here. */
   onNavigatedToChat?: () => void;
@@ -149,12 +155,16 @@ const resolveProjectRefForDirectory = (
   return match ? { id: match.id, path: match.path } : null;
 };
 
+const subscribeActiveRuntimeKey = (onStoreChange: () => void): (() => void) => {
+  return subscribeRuntimeEndpointChanged(() => onStoreChange());
+};
+
 type SelectedLineRange = {
   start: number;
   end: number;
 };
 
-export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPlanId = null, onNavigatedToChat }) => {
+export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, savedProjectPlan = null, onNavigatedToChat }) => {
   const { t } = useI18n();
   const currentSessionId = useSessionUIStore((state) => state.currentSessionId);
   const createSession = useSessionUIStore((state) => state.createSession);
@@ -170,6 +180,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
   const effectiveDirectory = useEffectiveDirectory() ?? '';
   const setSessionSwitcherOpen = useUIStore((state) => state.setSessionSwitcherOpen);
   const runtimeApis = useRuntimeAPIs();
+  const activeRuntimeKey = React.useSyncExternalStore(subscribeActiveRuntimeKey, getRuntimeKey, getRuntimeKey);
   const { isMobile } = useDeviceInfo();
   const { currentTheme } = useThemeSystem();
 
@@ -190,9 +201,37 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
     () => resolveProjectRefForDirectory(projectDirectory, projects, activeProjectId),
     [activeProjectId, projectDirectory, projects],
   );
+  // Destructured to primitives so the load/save effects key on stable values
+  // instead of a descriptor object rebuilt on every parent render.
+  const savedPlanProjectId = savedProjectPlan?.projectRef.id ?? null;
+  const savedPlanProjectPath = savedProjectPlan?.projectRef.path ?? null;
+  const savedPlanProjectRef = React.useMemo(
+    () => savedPlanProjectId && savedPlanProjectPath
+      ? { id: savedPlanProjectId, path: savedPlanProjectPath }
+      : null,
+    [savedPlanProjectId, savedPlanProjectPath],
+  );
+  const savedPlanId = savedProjectPlan?.planId ?? null;
+  // Stable logical identity, composed from primitives: an effect keyed on the
+  // descriptor object would reload — and flush — the same plan whenever a
+  // parent rebuilds the owner object with identical values.
+  const savedPlanKey = savedPlanProjectRef && savedPlanId
+    ? JSON.stringify(['saved-plan', activeRuntimeKey, resolveProjectContextId(savedPlanProjectRef), savedPlanId])
+    : null;
+  // Managed chats have no project directory to create a session in: their
+  // sessions live in per-session directories under the chats root, which
+  // createSession cannot prepare. Until a managed-chat send path exists,
+  // Improve/Implement stay unavailable for plans stored under the Chats
+  // owner — an OpenCode session created directly in the shared root would
+  // break the managed-chats model.
+  const isManagedChatPlan = savedPlanProjectRef?.id === CHAT_DRAFT_PROJECT_ID;
   const canCreateWorktree = React.useMemo(
-    () => (currentProjectRef ? gitDirectories.get(currentProjectRef.path)?.isGitRepo === true : false),
-    [currentProjectRef, gitDirectories],
+    () => {
+      // Worktree creation follows the session the plan would be sent to.
+      const sendTarget = savedPlanProjectRef ?? currentProjectRef;
+      return sendTarget ? gitDirectories.get(sendTarget.path)?.isGitRepo === true : false;
+    },
+    [currentProjectRef, gitDirectories, savedPlanProjectRef],
   );
   const [pendingPlanSend, setPendingPlanSend] = React.useState<PendingPlanSend | null>(null);
   const [isPlanSendSubmitting, setIsPlanSendSubmitting] = React.useState(false);
@@ -202,7 +241,6 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
   // `resolvedPath` so nothing downstream can mistake a project plan for a file
   // the user could open, edit, or be shown a path for.
   const [loadedProjectPlanId, setLoadedProjectPlanId] = React.useState<string | null>(null);
-  const savePlan = useProjectContextStore((state) => state.savePlan);
   const hasDocument = Boolean(resolvedPath) || Boolean(loadedProjectPlanId);
   const displayPath = React.useMemo(() => {
     if (!resolvedPath || !sessionDirectory || !homeDirectory) {
@@ -214,6 +252,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
   const { isPlaying: isTTSPlaying, play: playTTS, stop: stopTTS } = useMessageTTS();
   const showMessageTTSButtons = useConfigStore((state) => state.showMessageTTSButtons);
   const [saveError, setSaveError] = React.useState<string | null>(null);
+  const [loadError, setLoadError] = React.useState<string | null>(null);
   const planFileLabel = React.useMemo(() => {
     return displayPath ? displayPath.split('/').pop() || t('planView.file.defaultName') : t('planView.file.defaultName');
   }, [displayPath, t]);
@@ -381,9 +420,96 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
     return extensions;
   }, [currentTheme, resolvedPath, editorFontSize]);
 
+  // Pending-save bookkeeping for the open document. One ref record, not state:
+  // debounced writes and close-time flushes must read the newest buffer and
+  // revision without another render. `editRevision` advances on every editor
+  // change; `savedRevision` only after a successful write of that exact
+  // revision, so a slow in-flight save can never mark newer edits as saved.
+  // `key` and `runtimeKey` make every write self-identifying: content never
+  // crosses documents or runtimes, no matter when a queued write settles.
+  const docRef = React.useRef<{
+    key: string | null;
+    target: SavedProjectPlanTarget | { filePath: string } | null;
+    content: string;
+    editRevision: number;
+    savedRevision: number;
+    runtimeKey: string;
+  }>({ key: null, target: null, content: '', editRevision: 0, savedRevision: 0, runtimeKey: '' });
+  const saveQueue = React.useState(createPlanSaveQueue)[0];
+
+  // Filesystem writes keep the runtime adapter precedence the view always
+  // used: the active RuntimeAPIs first, the registry as fallback.
+  const writeDocument = React.useCallback(async (target: NonNullable<typeof docRef.current['target']>, text: string): Promise<void> => {
+    if ('filePath' in target) {
+      const files = runtimeApis.files ?? getRegisteredRuntimeAPIs()?.files;
+      if (files?.writeFile) {
+        const result = await files.writeFile(target.filePath, text);
+        if (!result?.success) {
+          throw new Error('Plan file write failed');
+        }
+        return;
+      }
+      const response = await runtimeFetch('/api/fs/write', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: target.filePath, content: text }),
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to write plan file (${response.status})`);
+      }
+      return;
+    }
+    const saved = await useProjectContextStore.getState().savePlan(target.projectRef, target.planId, text);
+    if (!saved) {
+      throw new Error('Plan save rejected: the plan no longer exists');
+    }
+  }, [runtimeApis.files]);
+  const writeDocumentRef = React.useRef(writeDocument);
+  writeDocumentRef.current = writeDocument;
+
+  // Queue any unflushed edits. Runs on document switches and on unmount, both
+  // of which cancel the debounced save — without this the last 350ms of typing
+  // is silently dropped. The queue orders it behind any write already in
+  // flight for the same document, and the captured runtime key stops content
+  // from one host being written into another after a runtime switch.
+  const scheduleSave = React.useCallback(() => {
+    const doc = docRef.current;
+    if (!doc.key || !doc.target || doc.editRevision <= doc.savedRevision) {
+      return;
+    }
+    const captured = {
+      key: doc.key,
+      target: doc.target,
+      content: doc.content,
+      revision: doc.editRevision,
+      runtimeKey: doc.runtimeKey,
+      write: writeDocumentRef.current,
+    };
+    saveQueue.schedule(captured.key, captured.revision, async () => {
+      if (getRuntimeKey() !== captured.runtimeKey) {
+        // The runtime switched while this write waited: writing through the
+        // new connection would land one host's edits on another.
+        return;
+      }
+      await captured.write(captured.target, captured.content);
+      const current = docRef.current;
+      if (current.key === captured.key) {
+        current.savedRevision = Math.max(current.savedRevision, captured.revision);
+        // A recovered save clears the stale failure banner.
+        setSaveError(null);
+      }
+    }).catch((error) => {
+      if (docRef.current.key === captured.key) {
+        setSaveError(error instanceof Error ? error.message : 'Plan save failed');
+      }
+    });
+  }, [saveQueue]);
+
   React.useEffect(() => {
     // Saved project plans opened via context panel should work even when session plan mode is off.
-    if (!planModeEnabled && !targetPath && !projectPlanId) {
+    if (!planModeEnabled && !targetPath && !savedPlanId) {
+      scheduleSave();
+      docRef.current = { key: null, target: null, content: '', editRevision: 0, savedRevision: 0, runtimeKey: '' };
       setResolvedPath(null);
       setLoadedProjectPlanId(null);
       setContent('');
@@ -416,31 +542,49 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
     };
 
     const run = async () => {
+      // Flush the outgoing document before the bookkeeping is replaced, so
+      // edits typed within the debounce window survive a plan switch. React
+      // reuses this component instance across saved-plan tabs.
+      scheduleSave();
+      docRef.current = { key: null, target: null, content: '', editRevision: 0, savedRevision: 0, runtimeKey: '' };
       setResolvedPath(null);
       setLoadedProjectPlanId(null);
       setContent('');
       setSaveError(null);
+      setLoadError(null);
 
-      if (projectPlanId) {
-        if (!currentProjectRef) {
-          return;
-        }
+      if (savedPlanId && savedPlanProjectRef && savedPlanKey) {
+        // A plan re-opened while its own flush is still writing must read the
+        // post-write state, not race it. The queue reset afterwards is safe:
+        // every write for this key has settled, and the reloaded document
+        // restarts its revision counter at zero.
+        await saveQueue.pendingFor(savedPlanKey);
+        if (cancelled) return;
+        saveQueue.reset(savedPlanKey);
         setLoading(true);
         try {
-          const plan = await fetchProjectPlan(currentProjectRef, projectPlanId);
+          const plan = await fetchProjectPlan(savedPlanProjectRef, savedPlanId);
           if (cancelled) return;
           if (!plan) {
             // The plan or its markdown is gone. Leave the view empty and
             // unsaveable rather than presenting an editor that would recreate
             // a document the user deleted.
-            setSaveError(t('planView.error.loadFailed'));
+            setLoadError('Plan not found');
             return;
           }
+          docRef.current = {
+            key: savedPlanKey,
+            target: { projectRef: savedPlanProjectRef, planId: savedPlanId },
+            content: plan.raw,
+            editRevision: 0,
+            savedRevision: 0,
+            runtimeKey: activeRuntimeKey,
+          };
           setContent(plan.raw);
-          setLoadedProjectPlanId(projectPlanId);
+          setLoadedProjectPlanId(savedPlanId);
         } catch (error) {
           if (cancelled) return;
-          setSaveError(error instanceof Error ? error.message : t('planView.error.loadFailed'));
+          setLoadError(error instanceof Error ? error.message : 'Plan load failed');
         } finally {
           if (!cancelled) setLoading(false);
         }
@@ -448,10 +592,22 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
       }
 
       if (targetPath) {
+        const fileKey = JSON.stringify(['plan-file', activeRuntimeKey, targetPath]);
+        await saveQueue.pendingFor(fileKey);
+        if (cancelled) return;
+        saveQueue.reset(fileKey);
         setLoading(true);
         try {
           const text = await readText(targetPath);
           if (cancelled) return;
+          docRef.current = {
+            key: fileKey,
+            target: { filePath: targetPath },
+            content: text,
+            editRevision: 0,
+            savedRevision: 0,
+            runtimeKey: activeRuntimeKey,
+          };
           setResolvedPath(targetPath);
           setContent(text);
         } catch {
@@ -477,10 +633,9 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
         const homePath = resolveTilde(buildHomePlanPath(session.time.created, session.slug), homeDirectory || null);
 
         let resolved: string | null = null;
-        let text: string | null = null;
 
         try {
-          text = await readText(repoPath);
+          await readText(repoPath);
           resolved = repoPath;
         } catch {
           // ignore
@@ -488,7 +643,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
 
         if (!resolved) {
           try {
-            text = await readText(homePath);
+            await readText(homePath);
             resolved = homePath;
           } catch {
             // ignore
@@ -497,12 +652,26 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
 
         if (cancelled) return;
 
-        if (!resolved || text === null) {
+        if (!resolved) {
           setResolvedPath(null);
           setContent('');
           return;
         }
 
+        const sessionFileKey = JSON.stringify(['plan-file', activeRuntimeKey, resolved]);
+        await saveQueue.pendingFor(sessionFileKey);
+        if (cancelled) return;
+        const text = await readText(resolved);
+        if (cancelled) return;
+        saveQueue.reset(sessionFileKey);
+        docRef.current = {
+          key: sessionFileKey,
+          target: { filePath: resolved },
+          content: text,
+          editRevision: 0,
+          savedRevision: 0,
+          runtimeKey: activeRuntimeKey,
+        };
         setResolvedPath(resolved);
         setContent(text);
       } catch {
@@ -519,55 +688,42 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
     return () => {
       cancelled = true;
     };
-  }, [currentProjectRef, homeDirectory, planModeEnabled, projectPlanId, runtimeApis.files, sessionDirectory, session?.slug, session?.time?.created, t, targetPath]);
+  }, [activeRuntimeKey, homeDirectory, planModeEnabled, runtimeApis.files, savedPlanId, savedPlanKey, savedPlanProjectRef, saveQueue, scheduleSave, session?.slug, session?.time?.created, sessionDirectory, targetPath]);
 
+  // Synchronous buffer tracking: if an edit and an unmount land in the same
+  // batch, the passive content effect would never run and a flush would save
+  // a stale buffer.
+  const handleContentChange = React.useCallback((next: string) => {
+    docRef.current.content = next;
+    docRef.current.editRevision += 1;
+    setContent(next);
+  }, []);
+
+  // The debounced write and the close/switch flush go through the same queue
+  // (scheduleSave), so two saves of one document can never complete out of
+  // order and a flush never duplicates a debounce of the same revision.
   React.useEffect(() => {
     if (!resolvedPath && !loadedProjectPlanId) {
       return;
     }
 
-    const controller = window.setTimeout(async () => {
-      setSaveError(null);
-      try {
-        if (loadedProjectPlanId) {
-          if (!currentProjectRef) {
-            throw new Error(t('planView.error.writeFailed'));
-          }
-          const saved = await savePlan(currentProjectRef, loadedProjectPlanId, content);
-          if (!saved) {
-            throw new Error(t('planView.error.writeFailed'));
-          }
-          return;
-        }
-
-        if (!resolvedPath) {
-          return;
-        }
-
-        if (runtimeApis.files?.writeFile) {
-          const result = await runtimeApis.files.writeFile(resolvedPath, content);
-          if (!result?.success) {
-            throw new Error(t('planView.error.writeFailed'));
-          }
-        } else {
-          const response = await runtimeFetch('/api/fs/write', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ path: resolvedPath, content }),
-          });
-          if (!response.ok) {
-            throw new Error(t('planView.error.writePlanFileFailed', { status: response.status }));
-          }
-        }
-      } catch (error) {
-        setSaveError(error instanceof Error ? error.message : t('planView.error.saveFailed'));
-      }
+    const controller = window.setTimeout(() => {
+      scheduleSave();
     }, 350);
 
     return () => {
       window.clearTimeout(controller);
     };
-  }, [content, currentProjectRef, loadedProjectPlanId, resolvedPath, runtimeApis.files, savePlan, t]);
+  }, [content, loadedProjectPlanId, resolvedPath, scheduleSave]);
+
+  // Closing the view inside the 350ms debounce window would drop the last
+  // edits: the cleanup above cancels the timer. Same for switching documents,
+  // which the load effect handles before replacing the bookkeeping.
+  React.useEffect(() => {
+    return () => {
+      scheduleSave();
+    };
+  }, [scheduleSave]);
 
   React.useEffect(() => {
     return () => {
@@ -584,7 +740,11 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
 
   const handleConfirmPlanSend = React.useCallback(
     async (execution: TodoSendExecution) => {
-      if (!currentProjectRef || !pendingPlanSend) {
+      // A saved plan sends against its own project — the one it is stored
+      // under — not against whatever directory the viewer is currently in.
+      // For filesystem plans those are the same directory.
+      const sendTargetProject = savedPlanProjectRef ?? currentProjectRef;
+      if (!sendTargetProject || !pendingPlanSend || isManagedChatPlan) {
         return;
       }
 
@@ -601,32 +761,45 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
           plan_path: resolvedPath ?? '',
         },
       );
-      const syntheticParts = [{ synthetic: true as const, text: instructionsText }];
+      // Saved project plans have no file path for the agent to read. Without
+      // this the instructions say "read that file" with an empty path and the
+      // plan contents never reach the session, so the plan substance rides
+      // along in the synthetic message instead.
+      const planSubstance = resolvedPath
+        ? instructionsText
+        : [
+            instructionsText,
+            '',
+            'The plan is not stored as a file in the repository and has no file path. Its full current contents follow below this note and are the source of truth for the plan. Where the instructions above refer to the plan file, treat the plan as stored in OpenChamber project knowledge (it is edited through the OpenChamber UI): propose plan revisions as plan text in the chat rather than editing a file.',
+            '',
+            content,
+          ].join('\n');
+      const syntheticParts = [{ synthetic: true as const, text: planSubstance }];
       setIsPlanSendSubmitting(true);
 
       try {
         routeToChat();
 
         let sessionId: string | null = null;
-        let directoryHint: string | null = currentProjectRef.path;
+        let directoryHint: string | null = sendTargetProject.path;
 
         if (pendingPlanSend.target === 'worktree') {
           if (!canCreateWorktree) {
             return;
           }
-          const created = await createWorktreeSessionForNewBranch(currentProjectRef.path, generateBranchName());
+          const created = await createWorktreeSessionForNewBranch(sendTargetProject.path, generateBranchName());
           if (!created?.id) {
             return;
           }
           sessionId = created.id;
           directoryHint = created.path;
         } else {
-          const sessionResult = await createSession(undefined, currentProjectRef.path, null);
+          const sessionResult = await createSession(undefined, sendTargetProject.path, null);
           if (!sessionResult?.id) {
             return;
           }
           sessionId = sessionResult.id;
-          directoryHint = sessionResult.directory ?? currentProjectRef.path;
+          directoryHint = sessionResult.directory ?? sendTargetProject.path;
           initializeNewOpenChamberSession(sessionResult.id, useConfigStore.getState().agents ?? []);
         }
 
@@ -664,8 +837,10 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
         // source. Here we only compose header + full content.
         const goalObjective = execution.runAsGoal === true
           ? [
-              `Implement the plan "${sendPromptTitle}" end-to-end${resolvedPath ? ` (plan file: ${resolvedPath})` : ''}.`,
-              'Re-read that file for full details — it is the source of truth.',
+              `Implement the plan "${sendPromptTitle}" end-to-end${resolvedPath ? ` (plan file: ${resolvedPath})` : ' (the full plan follows)'}.`,
+              resolvedPath
+                ? 'Re-read that file for full details — it is the source of truth.'
+                : 'The full plan follows in this message and is the source of truth.',
               '',
               content,
             ].join('\n')
@@ -687,7 +862,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
         setIsPlanSendSubmitting(false);
       }
     },
-    [canCreateWorktree, content, createSession, currentProjectRef, initializeNewOpenChamberSession, pendingPlanSend, resolvedPath, routeToChat, sendMessage, sendPromptTitle, setCurrentSession]
+    [canCreateWorktree, content, createSession, currentProjectRef, initializeNewOpenChamberSession, isManagedChatPlan, pendingPlanSend, resolvedPath, routeToChat, savedPlanProjectRef, sendMessage, sendPromptTitle, setCurrentSession]
   );
 
   const blockWidgets = React.useMemo(() => {
@@ -716,6 +891,11 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
       <div className="flex min-w-0 items-center gap-2 border-b border-border/40 px-3 py-1.5 flex-shrink-0">
         <div className="min-w-0 flex-1">
           <div className="typography-ui-label font-medium truncate">{parsedTitle}</div>
+          {loadError ? (
+            <div className="typography-micro text-[color:var(--status-error)] truncate" title={loadError}>
+              {t('planView.error.loadFailed')}
+            </div>
+          ) : null}
           {saveError ? (
             <div className="typography-micro text-[color:var(--status-error)] truncate" title={saveError}>
               {t('planView.error.saveFailed')}
@@ -733,7 +913,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
                       size="sm"
                       className="h-5 w-5 p-0"
                       aria-label={t('planView.actions.improvePlanAria')}
-                      disabled={!content.trim()}
+                      disabled={!content.trim() || isManagedChatPlan}
                     >
                       <Icon name="loop-right-ai" className="size-4" />
                     </Button>
@@ -742,7 +922,10 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
                 <TooltipContent sideOffset={8}>{t('planView.actions.improve')}</TooltipContent>
               </Tooltip>
               <DropdownMenuContent align="end">
-                <DropdownMenuItem onClick={() => setPendingPlanSend({ action: 'improve', target: 'session' })}>
+                <DropdownMenuItem
+                  onClick={() => setPendingPlanSend({ action: 'improve', target: 'session' })}
+                  disabled={isManagedChatPlan}
+                >
                   {t('planView.actions.sendToNewSession')}
                 </DropdownMenuItem>
                 <DropdownMenuItem
@@ -762,7 +945,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
                       size="sm"
                       className="h-5 w-5 p-0"
                       aria-label={t('planView.actions.implementPlanAria')}
-                      disabled={!content.trim()}
+                      disabled={!content.trim() || isManagedChatPlan}
                     >
                       <Icon name="code-ai" className="size-4" />
                     </Button>
@@ -771,7 +954,10 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
                 <TooltipContent sideOffset={8}>{t('planView.actions.implement')}</TooltipContent>
               </Tooltip>
               <DropdownMenuContent align="end">
-                <DropdownMenuItem onClick={() => setPendingPlanSend({ action: 'implement', target: 'session' })}>
+                <DropdownMenuItem
+                  onClick={() => setPendingPlanSend({ action: 'implement', target: 'session' })}
+                  disabled={isManagedChatPlan}
+                >
                   {t('planView.actions.sendToNewSession')}
                 </DropdownMenuItem>
                 <DropdownMenuItem
@@ -853,7 +1039,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
           }
         }}
         target={pendingPlanSend?.target ?? 'session'}
-        projectDirectory={currentProjectRef?.path ?? null}
+        projectDirectory={savedPlanProjectRef?.path ?? currentProjectRef?.path ?? null}
         submitting={isPlanSendSubmitting}
         allowRunAsGoal
         onConfirm={handleConfirmPlanSend}
@@ -885,7 +1071,7 @@ export const PlanView: React.FC<PlanViewProps> = ({ targetPath = null, projectPl
                   <div className="relative h-full" ref={editorWrapperRef}>
                     <CodeMirrorEditor
                       value={content}
-                      onChange={setContent}
+                      onChange={handleContentChange}
                       readOnly={false}
                       className="h-full"
                       extensions={editorExtensions}

packages/ui/src/components/views/SettingsView.mobile-focus.test.tsx

@@ -0,0 +1,438 @@
+import React, { act } from 'react';
+import { describe, expect, mock, test } from 'bun:test';
+import { createRoot, type Root } from 'react-dom/client';
+
+type ChildrenProps = { children?: React.ReactNode };
+type AgentsSidebarProps = { onItemSelect?: () => void };
+type SettingsPageLayoutProps = {
+  children: React.ReactNode;
+  title?: React.ReactNode;
+  showSaveStatus?: boolean;
+};
+
+interface FakeNode {
+  nodeType: number;
+  nodeName: string;
+  tagName: string;
+  namespaceURI: string;
+  ownerDocument: FakeDocument;
+  parentNode: FakeNode | null;
+  childNodes: FakeNode[];
+  style: { setProperty: () => void; getPropertyValue: () => string };
+  classList: FakeClassList;
+  attributes: Map<string, string>;
+  textContent: string;
+  nodeValue: string | null;
+  focusOptions?: FocusOptions;
+  appendChild: (child: FakeNode) => FakeNode;
+  insertBefore: (child: FakeNode, before: FakeNode | null) => FakeNode;
+  removeChild: (child: FakeNode) => FakeNode;
+  setAttribute: (name: string, value: string) => void;
+  removeAttribute: (name: string) => void;
+  getAttribute: (name: string) => string | null;
+  hasAttribute: (name: string) => boolean;
+  addEventListener: () => void;
+  removeEventListener: () => void;
+  contains: (child: FakeNode | null) => boolean;
+  querySelector: (selector: string) => FakeNode | null;
+  focus: (options?: FocusOptions) => void;
+}
+
+interface FakeDocument {
+  nodeType: number;
+  nodeName: string;
+  defaultView: FakeWindow | null;
+  body: FakeNode | null;
+  documentElement: FakeNode | null;
+  activeElement: FakeNode | null;
+  createElement: (tag: string) => FakeNode & Element;
+  createElementNS: (_namespace: string, tag: string) => FakeNode & Element;
+  createTextNode: (text: string) => FakeNode & Element;
+  addEventListener: () => void;
+  removeEventListener: () => void;
+}
+
+interface FakeWindow {
+  document: FakeDocument;
+  navigator: { userAgent: string; platform: string; maxTouchPoints: number };
+  history: { state: null; back: () => void; pushState: () => void };
+  location: { href: string };
+  requestAnimationFrame: (callback: FrameRequestCallback) => number;
+  cancelAnimationFrame: (frame: number) => void;
+  addEventListener: () => void;
+  removeEventListener: () => void;
+  HTMLIFrameElement: typeof FakeElement;
+  HTMLFrameSetElement: typeof FakeElement;
+  HTMLInputElement: typeof FakeElement;
+  HTMLTextAreaElement: typeof FakeElement;
+  HTMLSelectElement: typeof FakeElement;
+  HTMLOptionElement: typeof FakeElement;
+  HTMLAnchorElement: typeof FakeElement;
+}
+
+type GlobalStubValue = FakeDocument | FakeWindow | FakeWindow['navigator'] | FakeWindow['location'] | typeof FakeElement | boolean;
+
+class FakeElement {}
+
+class FakeClassList {
+  private readonly classes = new Set<string>();
+
+  add(...classes: string[]) {
+    classes.forEach((className) => this.classes.add(className));
+  }
+
+  remove(...classes: string[]) {
+    classes.forEach((className) => this.classes.delete(className));
+  }
+
+  contains(className: string) {
+    return this.classes.has(className);
+  }
+}
+
+function makeNode(tag: string, ownerDocument: FakeDocument, nodeType = 1): FakeNode & Element {
+  const attributes = new Map<string, string>();
+  const properties: FakeNode = {
+    nodeType,
+    nodeName: nodeType === 3 ? '#text' : tag.toUpperCase(),
+    tagName: nodeType === 3 ? '#text' : tag.toUpperCase(),
+    namespaceURI: 'http://www.w3.org/1999/xhtml',
+    ownerDocument,
+    parentNode: null,
+    childNodes: [],
+    style: {
+      setProperty: () => {},
+      getPropertyValue: () => '',
+    },
+    classList: new FakeClassList(),
+    attributes,
+    textContent: '',
+    nodeValue: null,
+    appendChild(child) {
+      this.childNodes.push(child);
+      child.parentNode = this;
+      return child;
+    },
+    insertBefore(child, before) {
+      const index = before ? this.childNodes.indexOf(before) : -1;
+      if (index === -1) {
+        this.childNodes.push(child);
+      } else {
+        this.childNodes.splice(index, 0, child);
+      }
+      child.parentNode = this;
+      return child;
+    },
+    removeChild(child) {
+      const index = this.childNodes.indexOf(child);
+      if (index !== -1) {
+        this.childNodes.splice(index, 1);
+      }
+      child.parentNode = null;
+      return child;
+    },
+    setAttribute(name, value) {
+      attributes.set(name, value);
+    },
+    removeAttribute(name) {
+      attributes.delete(name);
+    },
+    getAttribute(name) {
+      return attributes.get(name) ?? null;
+    },
+    hasAttribute(name) {
+      return attributes.has(name);
+    },
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    contains(child) {
+      if (child === this) {
+        return true;
+      }
+      return this.childNodes.some((nodeChild) => nodeChild.contains(child));
+    },
+    querySelector(selector) {
+      if (selector !== '[data-settings-page-heading]') {
+        return null;
+      }
+      if (this.hasAttribute('data-settings-page-heading')) {
+        return this;
+      }
+      for (const child of this.childNodes) {
+        const match = child.querySelector(selector);
+        if (match) {
+          return match;
+        }
+      }
+      return null;
+    },
+    focus(options) {
+      this.focusOptions = options;
+      this.ownerDocument.activeElement = this;
+    },
+  };
+  const node: FakeNode & Element = Object.assign(Object.create(FakeElement.prototype), properties);
+  return node;
+}
+
+function installDomStub() {
+  const descriptors = new Map<string, PropertyDescriptor | undefined>();
+  const setGlobal = (name: string, value: GlobalStubValue) => {
+    descriptors.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+    Object.defineProperty(globalThis, name, { configurable: true, writable: true, value });
+  };
+  const frames = new Map<number, FrameRequestCallback>();
+  let nextFrame = 1;
+  const documentStub: FakeDocument = {
+    nodeType: 9,
+    nodeName: '#document',
+    defaultView: null,
+    body: null,
+    documentElement: null,
+    activeElement: null,
+    createElement: (tag) => makeNode(tag, documentStub),
+    createElementNS: (_namespace, tag) => makeNode(tag, documentStub),
+    createTextNode: (text) => {
+      const node = makeNode('#text', documentStub, 3);
+      node.nodeValue = text;
+      node.textContent = text;
+      return node;
+    },
+    addEventListener: () => {},
+    removeEventListener: () => {},
+  };
+  const windowStub: FakeWindow = {
+    document: documentStub,
+    navigator: { userAgent: 'test', platform: 'test', maxTouchPoints: 0 },
+    history: { state: null, back: () => {}, pushState: () => {} },
+    location: { href: 'http://localhost/' },
+    requestAnimationFrame: (callback) => {
+      const frame = nextFrame;
+      nextFrame += 1;
+      frames.set(frame, callback);
+      return frame;
+    },
+    cancelAnimationFrame: (frame) => {
+      frames.delete(frame);
+    },
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    HTMLIFrameElement: FakeElement,
+    HTMLFrameSetElement: FakeElement,
+    HTMLInputElement: FakeElement,
+    HTMLTextAreaElement: FakeElement,
+    HTMLSelectElement: FakeElement,
+    HTMLOptionElement: FakeElement,
+    HTMLAnchorElement: FakeElement,
+  };
+  documentStub.defaultView = windowStub;
+  documentStub.body = makeNode('body', documentStub);
+  documentStub.documentElement = makeNode('html', documentStub);
+  documentStub.activeElement = documentStub.body;
+
+  setGlobal('document', documentStub);
+  setGlobal('window', windowStub);
+  setGlobal('navigator', windowStub.navigator);
+  setGlobal('location', windowStub.location);
+  setGlobal('Element', FakeElement);
+  setGlobal('HTMLElement', FakeElement);
+  setGlobal('HTMLIFrameElement', FakeElement);
+  setGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+
+  return {
+    container: documentStub.createElement('div'),
+    document: documentStub,
+    frameCount: () => frames.size,
+    flushFrames: () => {
+      const callbacks = Array.from(frames.values());
+      frames.clear();
+      callbacks.forEach((callback) => callback(Date.now()));
+    },
+    restore: () => {
+      for (const [name, descriptor] of descriptors) {
+        if (descriptor) {
+          Object.defineProperty(globalThis, name, descriptor);
+        } else {
+          Reflect.deleteProperty(globalThis, name);
+        }
+      }
+    },
+  };
+}
+
+const Empty = () => null;
+const uiStore = {
+  settingsPage: 'agents',
+  isSettingsDialogOpen: true,
+  setSettingsPage: () => {},
+};
+type UiStoreValue = (typeof uiStore)[keyof typeof uiStore];
+const agentsMeta = { slug: 'agents', title: 'Agents', group: 'opencode', kind: 'split' };
+let sidebarOnItemSelect: (() => void) | undefined;
+let SettingsPageLayout: React.ComponentType<SettingsPageLayoutProps> | null = null;
+
+mock.module('@/lib/utils', () => ({
+  cn: (...classes: Array<string | false | null | undefined>) => classes.filter(Boolean).join(' '),
+  getModifierLabel: () => 'Ctrl',
+}));
+mock.module('@/stores/useUIStore', () => ({
+  useUIStore: (selector: (state: typeof uiStore) => UiStoreValue) => selector(uiStore),
+}));
+mock.module('@/hooks/useSettingsDirectory', () => ({ useSettingsDirectory: () => '/workspace' }));
+mock.module('@/stores/useProjectsStore', () => ({
+  useProjectsStore: (selector: (state: { activeProjectId: null }) => null) => selector({ activeProjectId: null }),
+}));
+mock.module('@/stores/useAgentsStore', () => ({
+  refreshAfterOpenCodeRestart: async () => {},
+  useAgentsStore: { getState: () => ({ loadAgents: async () => {} }) },
+}));
+mock.module('@/stores/useCommandsStore', () => ({ useCommandsStore: { getState: () => ({ loadCommands: async () => {} }) } }));
+mock.module('@/stores/useMcpConfigStore', () => ({ useMcpConfigStore: { getState: () => ({ loadMcpConfigs: async () => {} }) } }));
+mock.module('@/stores/useSnippetsStore', () => ({ useSnippetsStore: { getState: () => ({ loadSnippets: async () => {} }) } }));
+mock.module('@/stores/useSkillsStore', () => ({ useSkillsStore: { getState: () => ({ loadSkills: async () => {} }) } }));
+mock.module('@/stores/useSkillsCatalogStore', () => ({ useSkillsCatalogStore: { getState: () => ({ loadCatalog: async () => {} }) } }));
+mock.module('@/stores/useConfigStore', () => ({ useConfigStore: { getState: () => ({ providers: [], setSelectedProvider: () => {} }) } }));
+mock.module('@/stores/usePendingOpenCodeRestartStore', () => ({
+  selectPendingOpenCodeRestartCount: () => 0,
+  usePendingOpenCodeRestartStore: () => 0,
+}));
+mock.module('@/components/ui/tooltip', () => ({
+  Tooltip: ({ children }: ChildrenProps) => <>{children}</>,
+  TooltipTrigger: ({ children }: ChildrenProps) => <>{children}</>,
+}));
+mock.module('@/components/ui/ErrorBoundary', () => ({ ErrorBoundary: ({ children }: ChildrenProps) => <>{children}</> }));
+mock.module('@/components/ui/ScrollableOverlay', () => ({ ScrollableOverlay: ({ children }: ChildrenProps) => <div>{children}</div> }));
+mock.module('@/components/sections/shared/SettingsSection', () => ({
+  SETTINGS_DESCRIPTION_CLASS: '',
+  SETTINGS_PAGE_TITLE_CLASS: '',
+  SETTINGS_SECTION_TITLE_CLASS: '',
+}));
+mock.module('@/lib/persistence', () => ({
+  getSettingsSaveState: () => 'idle',
+  subscribeToSettingsSaveState: () => () => {},
+}));
+mock.module('@/components/icon/Icon', () => ({ Icon: Empty }));
+mock.module('@/components/icons/McpIcon', () => ({ McpIcon: Empty }));
+mock.module('@/lib/i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+mock.module('@/lib/device', () => ({
+  useDeviceInfo: () => ({ isMobile: false }),
+}));
+mock.module('@/lib/desktop', () => ({
+  getDesktopHomeDirectory: async () => null,
+  isDesktopLocalOriginActive: () => false,
+  isDesktopShell: () => false,
+  isVSCodeRuntime: () => false,
+  isWebRuntime: () => true,
+}));
+mock.module('@/lib/platform', () => ({ isWindowsArm64: () => false }));
+mock.module('@/lib/settings/metadata', () => ({
+  SETTINGS_PAGE_METADATA: [agentsMeta],
+  getSettingsNavIcon: () => 'settings-3',
+  getSettingsPageMeta: (slug: string) => slug === 'agents' ? agentsMeta : null,
+  resolveSettingsSlug: (slug: string) => slug === 'agents' ? 'agents' : 'home',
+}));
+mock.module('@/lib/settings/search', () => ({ buildSettingsSearchResults: () => [] }));
+mock.module('@/components/views/OpenCodeReloadFooterAction', () => ({ OpenCodeReloadFooterAction: Empty }));
+mock.module('@/components/sections/agents/AgentsSidebar', () => ({
+  AgentsSidebar: ({ onItemSelect }: AgentsSidebarProps) => {
+    sidebarOnItemSelect = onItemSelect;
+    return <button type="button" onClick={onItemSelect}>Duplicate</button>;
+  },
+}));
+mock.module('@/components/sections/agents/AgentsPage', () => ({
+  AgentsPage: () => {
+    const Layout = SettingsPageLayout;
+    if (!Layout) {
+      throw new Error('SettingsPageLayout must load before SettingsView');
+    }
+    return <Layout title="New agent" showSaveStatus={false}><div /></Layout>;
+  },
+}));
+
+for (const [module, exports] of [
+  ['@/components/sections/behavior/BehaviorPage', ['BehaviorPage']],
+  ['@/components/sections/commands/CommandsSidebar', ['CommandsSidebar']],
+  ['@/components/sections/commands/CommandsPage', ['CommandsPage']],
+  ['@/components/sections/mcp/McpSidebar', ['McpSidebar']],
+  ['@/components/sections/mcp/McpPage', ['McpPage']],
+  ['@/components/sections/plugins', ['PluginsSidebar', 'PluginsPage']],
+  ['@/components/sections/skills/SkillsSidebar', ['SkillsSidebar']],
+  ['@/components/sections/skills/SkillsPage', ['SkillsPage']],
+  ['@/components/sections/projects/ProjectsSidebar', ['ProjectsSidebar']],
+  ['@/components/sections/projects/ProjectsPage', ['ProjectsPage']],
+  ['@/components/sections/remote-instances/RemoteInstancesPage', ['RemoteInstancesPage']],
+  ['@/components/sections/providers/ProvidersSidebar', ['ProvidersSidebar']],
+  ['@/components/sections/providers/ProvidersPage', ['ProvidersPage']],
+  ['@/components/sections/usage/UsageSidebar', ['UsageSidebar']],
+  ['@/components/sections/usage/UsagePage', ['UsagePage']],
+  ['@/components/sections/magic-prompts/MagicPromptsSidebar', ['MagicPromptsSidebar']],
+  ['@/components/sections/magic-prompts/MagicPromptsPage', ['MagicPromptsPage']],
+  ['@/components/sections/snippets/SnippetsSidebar', ['SnippetsSidebar']],
+  ['@/components/sections/snippets/SnippetsPage', ['SnippetsPage']],
+  ['@/components/sections/git-identities/GitPage', ['GitPage']],
+  ['@/components/sections/integrations/IntegrationsPage', ['IntegrationsPage']],
+  ['@/components/sections/openchamber/OpenChamberPage', ['OpenChamberPage']],
+  ['@/components/sections/openchamber/AboutSettings', ['AboutSettings']],
+] as const) {
+  mock.module(module, () => Object.fromEntries(exports.map((name) => [name, Empty])));
+}
+
+SettingsPageLayout = (await import('../sections/shared/SettingsPageLayout')).SettingsPageLayout;
+const { SettingsView } = await import('./SettingsView');
+
+describe('SettingsView mobile split-page focus', () => {
+  test('focuses the rendered editor heading after a mobile sidebar selection', async () => {
+    const dom = installDomStub();
+    const root: Root = createRoot(dom.container);
+    sidebarOnItemSelect = undefined;
+
+    try {
+      await act(async () => {
+        root.render(<SettingsView forceMobile initialMobileStage="page-sidebar" />);
+      });
+
+      expect(sidebarOnItemSelect).toBeDefined();
+      await act(async () => {
+        sidebarOnItemSelect?.();
+      });
+
+      const heading = dom.container.querySelector('[data-settings-page-heading]');
+      expect(heading).not.toBeNull();
+      expect(heading?.getAttribute('tabindex')).toBe('-1');
+      expect(dom.document.activeElement).toBe(dom.document.body);
+      expect(dom.frameCount()).toBe(1);
+
+      await act(async () => {
+        dom.flushFrames();
+      });
+
+      expect(dom.document.activeElement).toBe(heading);
+      expect(heading?.focusOptions).toEqual({ preventScroll: true });
+    } finally {
+      await act(async () => {
+        root.unmount();
+      });
+      dom.restore();
+    }
+  });
+
+  test('does not pass the mobile selection callback to desktop split pages', async () => {
+    const dom = installDomStub();
+    const root: Root = createRoot(dom.container);
+    sidebarOnItemSelect = undefined;
+
+    try {
+      await act(async () => {
+        root.render(<SettingsView forceMobile={false} />);
+      });
+
+      expect(sidebarOnItemSelect).toBe(undefined);
+      expect(dom.frameCount()).toBe(0);
+    } finally {
+      await act(async () => {
+        root.unmount();
+      });
+      dom.restore();
+    }
+  });
+});

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/useAgentMemorySync.ts

@@ -13,12 +13,10 @@
 
 import React from 'react';
 
-import { resolveProjectForSessionDirectory } from '@/lib/projectResolution';
 import { subscribeOpenchamberEvents } from '@/lib/openchamberEvents';
 import { useAgentMemoryStore } from '@/stores/useAgentMemoryStore';
-import { useProjectsStore } from '@/stores/useProjectsStore';
-import { useSessionUIStore } from '@/sync/session-ui-store';
 import { useUIStore } from '@/stores/useUIStore';
+import { useProjectContextOwner } from '@/hooks/useProjectContextOwner';
 
 /**
  * The directory is a parameter rather than read from `useEffectiveDirectory`,
@@ -29,18 +27,9 @@ export const useAgentMemorySync = (directory: string | null): void => {
   const enabled = useUIStore((state) => (
     state.agentMemoryFeatureAvailable && state.agentMemoryToolEnabled
   ));
-  const projects = useProjectsStore((state) => state.projects);
-  const availableWorktreesByProject = useSessionUIStore((state) => state.availableWorktreesByProject);
-  const effectiveDirectory = directory ?? '';
   const load = useAgentMemoryStore((state) => state.load);
-
-  const projectPath = React.useMemo(() => {
-    if (!effectiveDirectory) {
-      return null;
-    }
-    const resolved = resolveProjectForSessionDirectory(projects, availableWorktreesByProject, effectiveDirectory);
-    return resolved?.path ?? null;
-  }, [availableWorktreesByProject, effectiveDirectory, projects]);
+  const owner = useProjectContextOwner(directory);
+  const projectPath = owner?.path ?? null;
 
   React.useEffect(() => {
     if (!enabled) {

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

@@ -0,0 +1,90 @@
+import { describe, expect, test } from 'bun:test';
+
+import { CHAT_DRAFT_PROJECT_ID } from '@/lib/chatDirectories';
+import { resolveProjectContextOwner } from './useProjectContextOwner';
+
+const projects = [
+  { id: 'openchamber', path: '/workspace/openchamber', label: 'OpenChamber' },
+];
+
+describe('resolveProjectContextOwner', () => {
+  test('resolves a managed chat directory to the Chats root instead of the active project', () => {
+    const owner = resolveProjectContextOwner({
+      projects,
+      worktreesByProject: new Map(),
+      directory: '/Users/test/.config/openchamber/chats/2026-08-27/session-a',
+      activeProjectId: 'openchamber',
+      chatDraftOpen: false,
+      chatDraftTarget: 'project',
+      homeDirectory: '/Users/test',
+    });
+
+    expect(owner).toEqual({
+      id: CHAT_DRAFT_PROJECT_ID,
+      path: '/Users/test/.config/openchamber/chats',
+    });
+  });
+
+  test('resolves a worktree session to its owning project', () => {
+    const owner = resolveProjectContextOwner({
+      projects,
+      worktreesByProject: new Map([
+        ['/workspace/openchamber', [{
+          path: '/workspace/openchamber-feature',
+          projectDirectory: '/workspace/openchamber',
+          branch: 'feature',
+          label: 'feature',
+        }]],
+      ]),
+      directory: '/workspace/openchamber-feature',
+      activeProjectId: null,
+      chatDraftOpen: false,
+      chatDraftTarget: 'project',
+      homeDirectory: '/Users/test',
+    });
+
+    expect(owner).toEqual({ id: 'openchamber', path: '/workspace/openchamber' });
+  });
+
+  test('returns null for a recognized directory that owns nothing, instead of borrowing the active project', () => {
+    const owner = resolveProjectContextOwner({
+      projects,
+      worktreesByProject: new Map(),
+      directory: '/some/other/project',
+      activeProjectId: 'openchamber',
+      chatDraftOpen: false,
+      chatDraftTarget: 'project',
+      homeDirectory: '/Users/test',
+    });
+
+    expect(owner).toBeNull();
+  });
+
+  test('falls back to the active project only when there is no directory at all', () => {
+    const owner = resolveProjectContextOwner({
+      projects,
+      worktreesByProject: new Map(),
+      directory: null,
+      activeProjectId: 'openchamber',
+      chatDraftOpen: false,
+      chatDraftTarget: 'project',
+      homeDirectory: '/Users/test',
+    });
+
+    expect(owner).toEqual({ id: 'openchamber', path: '/workspace/openchamber' });
+  });
+
+  test('never falls back to the first project when the active project is unknown', () => {
+    const owner = resolveProjectContextOwner({
+      projects,
+      worktreesByProject: new Map(),
+      directory: null,
+      activeProjectId: 'missing-project',
+      chatDraftOpen: false,
+      chatDraftTarget: 'project',
+      homeDirectory: '/Users/test',
+    });
+
+    expect(owner).toBeNull();
+  });
+});

packages/ui/src/hooks/useProjectContextOwner.ts

@@ -0,0 +1,89 @@
+import React from 'react';
+
+import { CHAT_DRAFT_PROJECT_ID, getChatsRootForHome, getChatsRootFromDirectory } from '@/lib/chatDirectories';
+import { normalizePath } from '@/lib/pathNormalization';
+import { resolveProjectForSessionDirectory } from '@/lib/projectResolution';
+import type { ProjectRef } from '@/lib/projectContextApi';
+import { useDirectoryStore } from '@/stores/useDirectoryStore';
+import { useProjectsStore } from '@/stores/useProjectsStore';
+import { useSessionUIStore } from '@/sync/session-ui-store';
+import type { WorktreeMetadata } from '@/types/worktree';
+import type { ProjectEntry } from '@/lib/api/types';
+
+interface ProjectContextOwnerInput {
+  projects: ProjectEntry[];
+  worktreesByProject: Map<string, WorktreeMetadata[]>;
+  directory: string | null;
+  activeProjectId: string | null;
+  chatDraftOpen: boolean;
+  chatDraftTarget: 'chat' | 'project';
+  homeDirectory: string | null;
+}
+
+export const resolveProjectContextOwner = ({
+  projects,
+  worktreesByProject,
+  directory,
+  activeProjectId,
+  chatDraftOpen,
+  chatDraftTarget,
+  homeDirectory,
+}: ProjectContextOwnerInput): ProjectRef | null => {
+  const chatsRoot = getChatsRootFromDirectory(directory) ?? getChatsRootForHome(homeDirectory);
+  const normalizedDirectory = normalizePath(directory);
+  const normalizedChatsRoot = normalizePath(chatsRoot);
+  const ownsChats = chatDraftOpen
+    ? chatDraftTarget === 'chat'
+    : Boolean(normalizedDirectory && normalizedChatsRoot && (
+      normalizedDirectory === normalizedChatsRoot || normalizedDirectory.startsWith(`${normalizedChatsRoot}/`)
+    ));
+
+  if (ownsChats && chatsRoot) {
+    return { id: CHAT_DRAFT_PROJECT_ID, path: chatsRoot };
+  }
+
+  const sessionProject = resolveProjectForSessionDirectory(projects, worktreesByProject, directory);
+  if (sessionProject) {
+    return { id: sessionProject.id, path: sessionProject.path };
+  }
+
+  // A concrete directory that resolves to nothing owns nothing. Falling back
+  // to the active project here showed one project's knowledge under another
+  // project's name (the "plans open empty" bug), so the panel stays empty
+  // instead of lying. The active-project fallback is only for states with no
+  // directory at all, such as a new-session draft that has not landed yet.
+  if (normalizedDirectory) {
+    return null;
+  }
+
+  const activeProject = projects.find((project) => project.id === activeProjectId) ?? null;
+  return activeProject ? { id: activeProject.id, path: activeProject.path } : null;
+};
+
+/** The single owner used by Project knowledge and agent-memory synchronization. */
+export const useProjectContextOwner = (directory: string | null): ProjectRef | null => {
+  const projects = useProjectsStore((state) => state.projects);
+  const activeProjectId = useProjectsStore((state) => state.activeProjectId);
+  const homeDirectory = useDirectoryStore((state) => state.homeDirectory);
+  const worktreesByProject = useSessionUIStore((state) => state.availableWorktreesByProject);
+  const chatDraftOpen = useSessionUIStore((state) => state.newSessionDraft.open);
+  const chatDraftTarget = useSessionUIStore((state) => state.newSessionDraft.target);
+
+  return React.useMemo(() => resolveProjectContextOwner({
+    projects,
+    worktreesByProject,
+    directory,
+    activeProjectId,
+    chatDraftOpen,
+    chatDraftTarget,
+    homeDirectory,
+  }), [
+    activeProjectId,
+    chatDraftOpen,
+    chatDraftTarget,
+    directory,
+    homeDirectory,
+    projects,
+    worktreesByProject,
+  ]);
+};

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;
 }
@@ -1432,6 +1446,10 @@ html:not(.dark) .chat-scroll {
   white-space: nowrap;
 }
 
+.markdown-content [data-md-code-line-number]::before {
+  content: attr(data-md-code-line-number);
+}
+
 .markdown-content [data-md-code-line-content] {
   min-width: 0;
 }

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 } =
   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']);
   });

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,76 @@ 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 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 +123,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 +146,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 +181,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/clipboard.test.ts

@@ -1,6 +1,9 @@
 import { afterEach, describe, expect, test } from 'bun:test';
 
+import { marked } from 'marked';
+
 import { copyMarkdownToClipboard } from './clipboard';
+import { flattenAssistantTextParts } from './messages/messageText';
 
 const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
 const originalClipboardItem = Object.getOwnPropertyDescriptor(globalThis, 'ClipboardItem');
@@ -84,4 +87,52 @@ describe('copyMarkdownToClipboard', () => {
     expect(result).toEqual({ ok: true, method: 'clipboard' });
     expect(fallbackText).toBe('# title');
   });
+
+  test('assistant copy payload keeps Markdown block separation in every clipboard format', async () => {
+    let writtenItem: { data: Record<string, Blob> } | undefined;
+    class FakeClipboardItem {
+      static supports(type: string): boolean {
+        return type === 'text/markdown';
+      }
+
+      readonly data: Record<string, Blob>;
+
+      constructor(data: Record<string, Blob>) {
+        this.data = data;
+      }
+    }
+
+    Object.defineProperty(globalThis, 'ClipboardItem', { configurable: true, value: FakeClipboardItem });
+    Object.defineProperty(globalThis, 'navigator', {
+      configurable: true,
+      value: {
+        clipboard: {
+          write: async (items: Array<{ data: Record<string, Blob> }>) => {
+            writtenItem = items[0];
+          },
+        },
+      },
+    });
+
+    const parts = [
+      { id: 'p0', sessionID: 's', messageID: 'm', type: 'text', text: '第一段' },
+      { id: 'p1', sessionID: 's', messageID: 'm', type: 'text', text: '第二段' },
+      { id: 'p2', sessionID: 's', messageID: 'm', type: 'text', text: '```js\nconsole.log(1)\n\n\nconsole.log(2)\n```' },
+      { id: 'p3', sessionID: 's', messageID: 'm', type: 'text', text: '第三段' },
+    ];
+
+    // Same path as ChatMessage.tsx handleCopyMessage:
+    const text = flattenAssistantTextParts(parts as Parameters<typeof flattenAssistantTextParts>[0]);
+    const html = marked.parse(text, { gfm: true, breaks: false }) as string;
+    const result = await copyMarkdownToClipboard(text, html);
+
+    const expected = '第一段\n\n第二段\n\n```js\nconsole.log(1)\n\n\nconsole.log(2)\n```\n\n第三段';
+    expect(result).toEqual({ ok: true, method: 'clipboard' });
+    expect(await writtenItem?.data['text/plain']?.text()).toBe(expected);
+    expect(await writtenItem?.data['text/markdown']?.text()).toBe(expected);
+    const htmlText = await writtenItem?.data['text/html']?.text();
+    expect(htmlText).toContain('<p>第一段</p>');
+    expect(htmlText).toContain('<p>第二段</p>');
+    expect(htmlText).not.toContain('<p>第一段\n第二段</p>');
+  });
 });

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/messages/de.ts

@@ -348,7 +348,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',
@@ -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',
@@ -2909,7 +2911,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}',

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

@@ -383,7 +383,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',
@@ -1958,8 +1958,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 +2300,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 +2350,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',
@@ -3010,6 +3010,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 +3048,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,7 +3121,7 @@ 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}',

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

@@ -384,7 +384,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})",
@@ -1936,8 +1936,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 +2266,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 +2316,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",
@@ -2976,6 +2976,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 +3014,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,7 +3122,7 @@ 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}",

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

@@ -215,7 +215,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',
@@ -1716,8 +1716,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 +2013,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',
@@ -2702,6 +2701,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 +2739,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 +2812,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',
@@ -3092,6 +3102,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',

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

@@ -384,7 +384,7 @@ export const dict: Record<I18nKey, string> = {
   'multirun.launcher.attachments.attach': '添付',
   'multirun.launcher.attachments.tooltip': '同じファイルをすべての実行に送信',
   'multirun.launcher.models.label': 'モデル',
-  'multirun.launcher.models.info': '2～{max}モデルを選択。同じモデルを複数回追加できます。',
+  'multirun.launcher.models.info': '2つ以上のモデルを選択。同じモデルを複数回追加できます。',
   'multirun.launcher.toast.fileTooLarge': 'ファイル「{fileName}」が大きすぎます（最大10MB）',
   'multirun.launcher.toast.attachFailed': '「{fileName}」の添付に失敗しました',
   'multirun.launcher.toast.attachedSingle': '{count}ファイルを添付しました',
@@ -2298,6 +2298,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.chatInput.toast.attachmentsTooLarge': '添付ファイルが大きすぎて送信できません。画像の数またはサイズを減らしてください。',
   'chat.chatInput.toast.sendAttachmentsFailed': '添付ファイルの送信に失敗しました。ファイルを減らすかサイズを小さくしてください。',
   'chat.chatInput.toast.messageSendFailed': 'メッセージの送信に失敗しました。添付ファイルは復元されました。',
+  'chat.chatInput.toast.noModelSelected': '送信する前にプロバイダーとモデルを選択してください。',
   'chat.chatInput.toast.clipboardAttachFailed': 'クリップボードからの画像添付に失敗しました',
   'chat.chatInput.toast.addedFileMentions': '{count}件のファイルメンションを追加しました',
   'chat.chatInput.toast.attachFileFailed': 'ファイルの添付に失敗しました',
@@ -2350,6 +2351,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.toolPart.showRawJson': '生JSONを表示',
   'chat.toolPart.showFormattedJson': '整形JSONを表示',
   'chat.toolPart.showNavigableJson': 'ナビゲーション可能なJSONを表示',
+  'chat.toolPart.openFile': 'ファイルを開く',
   'chat.toolPart.openFileAtFirstChange': '最初の変更箇所でファイルを開く',
   'chat.toolPart.openFileDiff': 'ファイル差分を開く',
   'chat.toolPart.copyOutput': '出力をコピー',
@@ -3006,6 +3008,7 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.title': 'デバッグパネル',
   'memoryDebugPanel.tabs.memory': 'メモリ',
   'memoryDebugPanel.tabs.streaming': 'ストリーミング',
+  'memoryDebugPanel.tabs.requests': 'リクエスト',
   'memoryDebugPanel.section.sessionsInMemory': 'メモリ内のセッション',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UIストリーミングメトリクス',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Codeブリッジメトリクス',
@@ -3043,6 +3046,16 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.streaming.copy.copied': 'ストリーミングデバッグJSONをコピーしました',
   'memoryDebugPanel.streaming.copy.failed': 'JSONのコピーに失敗しました',
   'memoryDebugPanel.streaming.copy.hint': 'UIとVS Codeの両方のストリーミングメトリクスをJSONとしてエクスポートします',
+  'memoryDebugPanel.requests.inFlight': '実行中',
+  'memoryDebugPanel.requests.peak': 'ピーク',
+  'memoryDebugPanel.requests.duration': '期間',
+  'memoryDebugPanel.requests.totalRequests': '合計リクエスト',
+  'memoryDebugPanel.requests.tracking': 'トラッキング',
+  'memoryDebugPanel.requests.now': '現在',
+  'memoryDebugPanel.requests.noSamples': 'まだリクエストが記録されていません。fetchアクティビティを記録するには、このパネルを開いたままにしてください。',
+  'memoryDebugPanel.requests.chartLabel': '経時的な実行中fetchリクエスト、ピーク {peak}',
+  'memoryDebugPanel.requests.windowHint': '過去 {seconds}秒',
+  'memoryDebugPanel.requests.percentileChartLabel': '経時的な実行中リクエストの経過時間パーセンタイル（p50、p90、p99、最大）',
   'memoryDebugPanel.common.idle': '待機中',
   'memoryDebugPanel.common.live': 'ライブ',
   'memoryDebugPanel.common.notAvailable': 'N/A',
@@ -3109,7 +3122,7 @@ export const dict: Record<I18nKey, string> = {
   'onboarding.localSetup.actions.checkAndContinue': 'インストール完了、確認して続行',
   'onboarding.localSetup.status.autoContinue': '検出され次第自動的に続行します。',
   'updateDialog.changelog.title': '新機能',
-  'quota.window.premiumInteractions': 'プレミアムインタラクション',
+  'quota.window.premiumInteractions': 'AIクレジット',
 
   'chat.workStatus.ariaLabel': '作業状況',
   'chat.workStatus.context.label': 'コンテキスト',

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

@@ -384,7 +384,7 @@ export const dict: Record<I18nKey, string> = {
   'multirun.launcher.attachments.attach': '첨부',
   'multirun.launcher.attachments.tooltip': '같은 파일을 모든 실행에 보냅니다',
   'multirun.launcher.models.label': '모델',
-  'multirun.launcher.models.info': '모델을 2~{max}개 선택하세요. 같은 모델을 여러 번 추가할 수 있습니다.',
+  'multirun.launcher.models.info': '모델을 2개 이상 선택하세요. 같은 모델을 여러 번 추가할 수 있습니다.',
   'multirun.launcher.toast.fileTooLarge': '파일 "{fileName}"이 너무 큽니다(최대 10MB)',
   'multirun.launcher.toast.attachFailed': '"{fileName}" 첨부 실패',
   'multirun.launcher.toast.attachedSingle': '파일 {count}개 첨부됨',
@@ -1960,8 +1960,6 @@ export const dict: Record<I18nKey, string> = {
   'session.newWorktree.noMatchingBranches': '일치하는 브랜치가 없습니다',
   'session.newWorktree.localBranches': '로컬 브랜치',
   'session.newWorktree.remoteBranches': '리모트 브랜치',
-  'session.newWorktree.otherLocalBranches': '기타 로컬 브랜치',
-  'session.newWorktree.otherRemoteBranches': '기타 리모트 브랜치',
   'session.newWorktree.branchName': '브랜치 이름',
   'session.newWorktree.branchNamePlaceholder': 'feature/my-awesome-feature',
   'session.newWorktree.actions.change': '변경',
@@ -2302,6 +2300,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.chatInput.toast.attachmentsTooLarge': '첨부 파일이 너무 커서 보낼 수 없습니다. 이미지 수나 크기를 줄여 보세요.',
   'chat.chatInput.toast.sendAttachmentsFailed': '첨부 파일 전송 실패. 파일 수나 이미지 크기를 줄여 보세요.',
   'chat.chatInput.toast.messageSendFailed': '메시지 전송에 실패했습니다. 첨부 파일을 복원했습니다.',
+  'chat.chatInput.toast.noModelSelected': '전송하기 전에 제공업체와 모델을 선택하세요.',
   'chat.chatInput.toast.clipboardAttachFailed': '클립보드 이미지 첨부 실패',
   'chat.chatInput.toast.addedFileMentions': '파일 멘션 {count}개 추가됨',
   'chat.chatInput.toast.attachFileFailed': '첨부 파일 실패',
@@ -2351,6 +2350,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.toolPart.showRawJson': '원시 JSON 표시',
   'chat.toolPart.showFormattedJson': '형식화된 JSON 표시',
   'chat.toolPart.showNavigableJson': '탐색 가능한 JSON 표시',
+  'chat.toolPart.openFile': '파일 열기',
   'chat.toolPart.openFileAtFirstChange': '첫 번째 변경 위치에서 파일 열기',
   'chat.toolPart.openFileDiff': '파일 diff 열기',
   'chat.toolPart.copyOutput': '출력 복사',
@@ -3010,6 +3010,7 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.title': '디버그 패널',
   'memoryDebugPanel.tabs.memory': '메모리',
   'memoryDebugPanel.tabs.streaming': '스트리밍',
+  'memoryDebugPanel.tabs.requests': '요청',
   'memoryDebugPanel.section.sessionsInMemory': '메모리 내 세션',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UI 스트리밍 지표',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Code 브리지 지표',
@@ -3047,6 +3048,16 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.streaming.copy.copied': '스트리밍 디버그 JSON 복사 완료',
   'memoryDebugPanel.streaming.copy.failed': 'JSON 복사 실패',
   'memoryDebugPanel.streaming.copy.hint': 'UI와 VS Code 스트리밍 메트릭을 JSON으로 복사합니다',
+  'memoryDebugPanel.requests.inFlight': '진행 중',
+  'memoryDebugPanel.requests.peak': '최대',
+  'memoryDebugPanel.requests.duration': '지속 시간',
+  'memoryDebugPanel.requests.totalRequests': '전체 요청',
+  'memoryDebugPanel.requests.tracking': '추적 중',
+  'memoryDebugPanel.requests.now': '현재',
+  'memoryDebugPanel.requests.noSamples': '아직 기록된 요청이 없습니다. fetch 활동을 기록하려면 이 패널을 열어 두세요.',
+  'memoryDebugPanel.requests.chartLabel': '시간에 따른 진행 중인 fetch 요청, 최대 {peak}',
+  'memoryDebugPanel.requests.windowHint': '최근 {seconds}초',
+  'memoryDebugPanel.requests.percentileChartLabel': '진행 중 요청 수명 백분위수(p50, p90, p99, max)의 시간별 변화',
   'memoryDebugPanel.common.idle': '유휴',
   'memoryDebugPanel.common.live': '실시간',
   'memoryDebugPanel.common.notAvailable': 'n/a',
@@ -3110,7 +3121,7 @@ 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': 'AI 크레딧',
   'chat.workStatus.ariaLabel': '작업 상태',
   'chat.workStatus.context.label': '컨텍스트',
   'chat.workStatus.cost.breakdown': '세션 {session} · 서브 에이전트 {subagents}',

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

@@ -522,7 +522,7 @@ export const dict: Record<I18nKey, string> = {
   'multirun.launcher.attachments.attach': 'Dołącz',
   'multirun.launcher.attachments.tooltip': 'Te same pliki wysłane do wszystkich uruchomień',
   'multirun.launcher.models.label': 'Modele',
-  'multirun.launcher.models.info': 'Wybierz od 2 do {max} modeli. Ten sam model może być dodany wielokrotnie.',
+  'multirun.launcher.models.info': 'Wybierz 2 lub więcej modeli. Ten sam model może być dodany wielokrotnie.',
   'multirun.launcher.toast.fileTooLarge': 'Plik "{fileName}" jest zbyt duży (max 10MB)',
   'multirun.launcher.toast.attachFailed': 'Nie udało się dołączyć "{fileName}"',
   'multirun.launcher.toast.attachedSingle': 'Dołączono {count} plik',
@@ -1278,6 +1278,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.chatInput.toast.clipboardAttachFailed': 'Nie udało się dołączyć obrazu ze schowka',
   'chat.chatInput.toast.compactFailed': 'Nie udało się skompaktować sesji',
   'chat.chatInput.toast.messageSendFailed': 'Nie udało się wysłać wiadomości. Załączniki zostały przywrócone.',
+  'chat.chatInput.toast.noModelSelected': 'Wybierz dostawcę i model przed wysłaniem.',
   'chat.chatInput.toast.openSessionFirst': 'Najpierw otwórz sesję',
   'chat.chatInput.toast.reviewFailed': 'Nie udało się przejrzeć zmian',
   'chat.chatInput.toast.planFeatureFailed': 'Nie udało się rozpocząć planowania funkcji',
@@ -1432,6 +1433,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.toolPart.showRawJson': 'Pokaż surowy JSON',
   'chat.toolPart.showFormattedJson': 'Pokaż sformatowany JSON',
   'chat.toolPart.showNavigableJson': 'Pokaż nawigowalny JSON',
+  'chat.toolPart.openFile': 'Otwórz plik',
   'chat.toolPart.openFileAtFirstChange': 'Otwórz plik przy pierwszej zmianie',
   'chat.toolPart.openFileDiff': 'Otwórz różnice pliku',
   'chat.toolPart.copyOutput': 'Kopiuj wyjście',
@@ -2568,8 +2570,19 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.streaming.copy.copied': 'Skopiowano JSON debugowania streamingu',
   'memoryDebugPanel.streaming.copy.failed': 'Nie udało się skopiować JSON',
   'memoryDebugPanel.streaming.copy.hint': 'Kopiowanie eksportuje metryki streamingu zarówno UI, jak i VS Code w formacie JSON',
+  'memoryDebugPanel.requests.inFlight': 'W trakcie',
+  'memoryDebugPanel.requests.peak': 'Szczyt',
+  'memoryDebugPanel.requests.duration': 'Czas trwania',
+  'memoryDebugPanel.requests.totalRequests': 'Łączne żądania',
+  'memoryDebugPanel.requests.tracking': 'Śledzenie',
+  'memoryDebugPanel.requests.now': 'teraz',
+  'memoryDebugPanel.requests.noSamples': 'Brak żądań. Utrzymuj ten panel otwarty, aby rejestrować aktywność fetch.',
+  'memoryDebugPanel.requests.chartLabel': 'Żądania fetch w trakcie w czasie, szczyt {peak}',
+  'memoryDebugPanel.requests.windowHint': 'ostatnie {seconds}s',
+  'memoryDebugPanel.requests.percentileChartLabel': 'Percentyle wieku żądań w trakcie (p50, p90, p99, max) w czasie',
   'memoryDebugPanel.tabs.memory': 'Pamięć',
   'memoryDebugPanel.tabs.streaming': 'Streaming',
+  'memoryDebugPanel.tabs.requests': 'Żądania',
   'memoryDebugPanel.title': 'Panel debugowania',
   'memoryDebugPanel.tooltip.logCurrentState': 'Zaloguj bieżący stan pamięci do konsoli przeglądarki',
   'openChamberLogo.aria.logo': 'Logo OpenChamber',
@@ -2821,8 +2834,6 @@ export const dict: Record<I18nKey, string> = {
   'session.newWorktree.newSessionTitle': 'Nowa sesja',
   'session.newWorktree.noBranchesFound': 'Nie znaleziono gałęzi',
   'session.newWorktree.noMatchingBranches': 'Brak pasujących gałęzi',
-  'session.newWorktree.otherLocalBranches': 'Pozostałe lokalne gałęzie',
-  'session.newWorktree.otherRemoteBranches': 'Pozostałe zdalne gałęzie',
   'session.newWorktree.prNumber': 'PR #{number}',
   'session.newWorktree.remoteBranches': 'Zdalne gałęzie',
   'session.newWorktree.resetToMatchBranchName': 'Zresetuj do nazwy zgodnej z gałęzią',
@@ -3127,7 +3138,7 @@ 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': 'Kredyty AI',
   'chat.workStatus.ariaLabel': 'Stan pracy',
   'chat.workStatus.context.label': 'Kontekst',
   'chat.workStatus.cost.breakdown': 'Sesja {session} · Podagenci {subagents}',

packages/ui/src/lib/i18n/messages/pt-BR.ts

@@ -384,7 +384,7 @@ export const dict: Record<I18nKey, string> = {
   "multirun.launcher.attachments.attach": "Anexar",
   "multirun.launcher.attachments.tooltip": "Arquivos idênticos enviados a todas as execuções",
   "multirun.launcher.models.label": "Modelos",
-  "multirun.launcher.models.info": "Selecione 2-{max} modelos. O mesmo modelo pode ser adicionado várias vezes.",
+  "multirun.launcher.models.info": "Selecione 2 ou mais modelos. O mesmo modelo pode ser adicionado várias vezes.",
   "multirun.launcher.toast.fileTooLarge": "O arquivo \"{fileName}\" é grande demais (máximo 10MB)",
   "multirun.launcher.toast.attachFailed": "Não foi possível anexar \"{fileName}\"",
   "multirun.launcher.toast.attachedSingle": "Arquivo anexado ({count})",
@@ -1936,8 +1936,6 @@ export const dict: Record<I18nKey, string> = {
   "session.newWorktree.noMatchingBranches": "Não há branches coincidentes",
   "session.newWorktree.localBranches": "Branches locais",
   "session.newWorktree.remoteBranches": "Branches remotas",
-  "session.newWorktree.otherLocalBranches": "Outras branches locais",
-  "session.newWorktree.otherRemoteBranches": "Outras branches remotas",
   "session.newWorktree.branchName": "Nome da branch",
   "session.newWorktree.branchNamePlaceholder": "feature/my-awesome-feature",
   "session.newWorktree.actions.change": "Alterar",
@@ -2268,6 +2266,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.chatInput.toast.attachmentsTooLarge": "Os anexos são grandes demais para enviar. Tente reduzir a quantidade ou o tamanho das imagens.",
   "chat.chatInput.toast.sendAttachmentsFailed": "Não foi possível enviar os anexos. Tente com menos arquivos ou imagens menores.",
   "chat.chatInput.toast.messageSendFailed": "A mensagem não pôde ser enviada. Os anexos foram restaurados.",
+  "chat.chatInput.toast.noModelSelected": "Selecione um provedor e um modelo antes de enviar.",
   "chat.chatInput.toast.clipboardAttachFailed": "Não foi possível anexar a imagem da área de transferência",
   "chat.chatInput.toast.addedFileMentions": "Foram adicionadas {count} menção(es) de arquivo",
   "chat.chatInput.toast.attachFileFailed": "Não foi possível anexar o arquivo",
@@ -2317,6 +2316,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.toolPart.showRawJson": "Mostrar JSON bruto",
   "chat.toolPart.showFormattedJson": "Mostrar JSON formatado",
   "chat.toolPart.showNavigableJson": "Mostrar JSON navegável",
+  "chat.toolPart.openFile": "Abrir arquivo",
   "chat.toolPart.openFileAtFirstChange": "Abrir arquivo na primeira alteração",
   "chat.toolPart.openFileDiff": "Abrir diferenças do arquivo",
   "chat.toolPart.copyOutput": "Copiar saída",
@@ -2976,6 +2976,7 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.title": "Painel de depuração",
   "memoryDebugPanel.tabs.memory": "Memória",
   "memoryDebugPanel.tabs.streaming": "Transmissão",
+  "memoryDebugPanel.tabs.requests": "Solicitações",
   "memoryDebugPanel.section.sessionsInMemory": "Sessões em memória",
   "memoryDebugPanel.section.uiStreamingMetrics": "Métricas de streaming de UI",
   "memoryDebugPanel.section.vscodeBridgeMetrics": "Métricas da ponte do VS Code",
@@ -3013,6 +3014,16 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.streaming.copy.copied": "JSON de depuração em streaming copiado",
   "memoryDebugPanel.streaming.copy.failed": "Não foi possível copiar JSON",
   "memoryDebugPanel.streaming.copy.hint": "Copia exportações de métricas da UI e do VS Code em formato JSON",
+  "memoryDebugPanel.requests.inFlight": "Em curso",
+  "memoryDebugPanel.requests.peak": "Pico",
+  "memoryDebugPanel.requests.duration": "Duração",
+  "memoryDebugPanel.requests.totalRequests": "Solicitações totais",
+  "memoryDebugPanel.requests.tracking": "Rastreamento",
+  "memoryDebugPanel.requests.now": "agora",
+  "memoryDebugPanel.requests.noSamples": "Nenhuma solicitação registrada. Mantenha este painel aberto para registrar a atividade de fetch.",
+  "memoryDebugPanel.requests.chartLabel": "Solicitações fetch em curso ao longo do tempo, pico {peak}",
+  "memoryDebugPanel.requests.windowHint": "últimos {seconds}s",
+  "memoryDebugPanel.requests.percentileChartLabel": "Percentis de idade das solicitações em curso (p50, p90, p99, máx) ao longo do tempo",
   "memoryDebugPanel.common.idle": "inativo",
   "memoryDebugPanel.common.live": "ao vivo",
   "memoryDebugPanel.common.notAvailable": "n/a",
@@ -3111,7 +3122,7 @@ 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': 'Status do trabalho',
   'chat.workStatus.context.label': 'Contexto',
   'chat.workStatus.cost.breakdown': "Sessão {session} · Subagentes {subagents}",

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

@@ -384,7 +384,7 @@ export const dict: Record<I18nKey, string> = {
   "multirun.launcher.attachments.attach": "Прикріпити",
   "multirun.launcher.attachments.tooltip": "Ті самі файли буде надіслано в усі запуски",
   "multirun.launcher.models.label": "Моделі",
-  "multirun.launcher.models.info": "Вибрати моделі 2-{max}. Ту саму модель можна додавати кілька разів.",
+  "multirun.launcher.models.info": "Вибрати 2 або більше моделей. Ту саму модель можна додавати кілька разів.",
   "multirun.launcher.toast.fileTooLarge": "Файл \"{fileName}\" завеликий (макс. 10 МБ)",
   "multirun.launcher.toast.attachFailed": "Не вдалося вкласти \"{fileName}\"",
   "multirun.launcher.toast.attachedSingle": "Прикріплено файл: {count}",
@@ -1936,8 +1936,6 @@ export const dict: Record<I18nKey, string> = {
   "session.newWorktree.noMatchingBranches": "Немає відповідних гілок",
   "session.newWorktree.localBranches": "Локальні гілки",
   "session.newWorktree.remoteBranches": "Віддалені гілки",
-  "session.newWorktree.otherLocalBranches": "Інші локальні гілки",
-  "session.newWorktree.otherRemoteBranches": "Інші віддалені гілки",
   "session.newWorktree.branchName": "Назва гілки",
   "session.newWorktree.branchNamePlaceholder": "feature/my-awesome-feature",
   "session.newWorktree.actions.change": "Змінити",
@@ -2268,6 +2266,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.chatInput.toast.attachmentsTooLarge": "Вкладені файли завеликі для надсилання. Спробуйте зменшити кількість або розмір зображень.",
   "chat.chatInput.toast.sendAttachmentsFailed": "Не вдалося надіслати вкладення. Спробуйте зменшити кількість файлів або зображень.",
   "chat.chatInput.toast.messageSendFailed": "Не вдалося надіслати повідомлення. Вкладення відновлено.",
+  "chat.chatInput.toast.noModelSelected": "Виберіть постачальника та модель перед надсиланням.",
   "chat.chatInput.toast.clipboardAttachFailed": "Не вдалося вкласти зображення з буфера обміну",
   "chat.chatInput.toast.addedFileMentions": "Додано згадки файлів {count}",
   "chat.chatInput.toast.attachFileFailed": "Не вдалося прикріпити файл",
@@ -2317,6 +2316,7 @@ export const dict: Record<I18nKey, string> = {
   "chat.toolPart.showRawJson": "Показати сирий JSON",
   "chat.toolPart.showFormattedJson": "Показати форматований JSON",
   "chat.toolPart.showNavigableJson": "Показати навігаційний JSON",
+  "chat.toolPart.openFile": "Відкрити файл",
   "chat.toolPart.openFileAtFirstChange": "Відкрити файл на першій зміні",
   "chat.toolPart.openFileDiff": "Відкрити diff файлу",
   "chat.toolPart.copyOutput": "Скопіювати вивід",
@@ -2976,6 +2976,7 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.title": "Панель налагодження",
   "memoryDebugPanel.tabs.memory": "Пам'ять",
   "memoryDebugPanel.tabs.streaming": "Потокове передавання",
+  "memoryDebugPanel.tabs.requests": "Запити",
   "memoryDebugPanel.section.sessionsInMemory": "Сесії в пам'яті",
   "memoryDebugPanel.section.uiStreamingMetrics": "Потокові показники інтерфейсу користувача",
   "memoryDebugPanel.section.vscodeBridgeMetrics": "Метрики мосту VS Code",
@@ -3013,6 +3014,16 @@ export const dict: Record<I18nKey, string> = {
   "memoryDebugPanel.streaming.copy.copied": "Потокове налагодження JSON скопійовано",
   "memoryDebugPanel.streaming.copy.failed": "Не вдалося скопіювати JSON",
   "memoryDebugPanel.streaming.copy.hint": "Копіювання експортує метрики потокового інтерфейсу користувача та VS Code як JSON",
+  "memoryDebugPanel.requests.inFlight": "Виконуються",
+  "memoryDebugPanel.requests.peak": "Пік",
+  "memoryDebugPanel.requests.duration": "Тривалість",
+  "memoryDebugPanel.requests.totalRequests": "Усього запитів",
+  "memoryDebugPanel.requests.tracking": "Відстеження",
+  "memoryDebugPanel.requests.now": "зараз",
+  "memoryDebugPanel.requests.noSamples": "Запитів ще немає. Тримайте цю панель відкритою, щоб фіксувати активність fetch.",
+  "memoryDebugPanel.requests.chartLabel": "Запити fetch у виконанні з часом, пік {peak}",
+  "memoryDebugPanel.requests.windowHint": "останні {seconds}s",
+  "memoryDebugPanel.requests.percentileChartLabel": "Перцентилі віку запитів у виконанні (p50, p90, p99, max) з часом",
   "memoryDebugPanel.common.idle": "очікування",
   "memoryDebugPanel.common.live": "live",
   "memoryDebugPanel.common.notAvailable": "n/a",
@@ -3111,7 +3122,7 @@ 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": "Кредити ШІ",
   'chat.workStatus.ariaLabel': 'Стан роботи',
   'chat.workStatus.context.label': 'Контекст',
   'chat.workStatus.cost.breakdown': "Сеанс {session} · Субагенти {subagents}",

packages/ui/src/lib/i18n/messages/zh-CN.ts

@@ -384,7 +384,7 @@ export const dict: Record<I18nKey, string> = {
   'multirun.launcher.attachments.attach': '附加',
   'multirun.launcher.attachments.tooltip': '相同文件会发送到所有运行',
   'multirun.launcher.models.label': '模型',
-  'multirun.launcher.models.info': '选择 2-{max} 个模型。同一模型可重复添加。',
+  'multirun.launcher.models.info': '选择 2 个或更多模型。同一模型可重复添加。',
   'multirun.launcher.toast.fileTooLarge': '文件“{fileName}”过大（最大 10MB）',
   'multirun.launcher.toast.attachFailed': '附加“{fileName}”失败',
   'multirun.launcher.toast.attachedSingle': '已附加 {count} 个文件',
@@ -1924,8 +1924,6 @@ export const dict: Record<I18nKey, string> = {
   'session.newWorktree.noMatchingBranches': '没有匹配分支',
   'session.newWorktree.localBranches': '本地分支',
   'session.newWorktree.remoteBranches': '远程分支',
-  'session.newWorktree.otherLocalBranches': '其他本地分支',
-  'session.newWorktree.otherRemoteBranches': '其他远程分支',
   'session.newWorktree.branchName': '分支名',
   'session.newWorktree.branchNamePlaceholder': 'feature/my-awesome-feature',
   'session.newWorktree.actions.change': '更改',
@@ -2268,6 +2266,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.chatInput.toast.attachmentsTooLarge': '附件过大，无法发送。请减少图片数量或大小。',
   'chat.chatInput.toast.sendAttachmentsFailed': '发送附件失败。请尝试更少文件或更小图片。',
   'chat.chatInput.toast.messageSendFailed': '消息发送失败，附件已恢复。',
+  'chat.chatInput.toast.noModelSelected': '发送前请先选择提供商和模型。',
   'chat.chatInput.toast.clipboardAttachFailed': '从剪贴板附加图片失败',
   'chat.chatInput.toast.addedFileMentions': '已添加 {count} 个文件提及',
   'chat.chatInput.toast.attachFileFailed': '附加文件失败',
@@ -2317,6 +2316,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.toolPart.showRawJson': '显示原始 JSON',
   'chat.toolPart.showFormattedJson': '显示格式化 JSON',
   'chat.toolPart.showNavigableJson': '显示可导航 JSON',
+  'chat.toolPart.openFile': '打开文件',
   'chat.toolPart.openFileAtFirstChange': '在首次更改处打开文件',
   'chat.toolPart.openFileDiff': '打开文件差异',
   'chat.toolPart.copyOutput': '复制输出',
@@ -2976,6 +2976,7 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.title': '调试面板',
   'memoryDebugPanel.tabs.memory': '内存',
   'memoryDebugPanel.tabs.streaming': '流式',
+  'memoryDebugPanel.tabs.requests': '请求',
   'memoryDebugPanel.section.sessionsInMemory': '内存中的会话',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UI 流式指标',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Code 桥接指标',
@@ -3013,6 +3014,16 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.streaming.copy.copied': '流式调试 JSON 已复制',
   'memoryDebugPanel.streaming.copy.failed': '复制 JSON 失败',
   'memoryDebugPanel.streaming.copy.hint': '复制会导出 UI 与 VS Code 的流式指标 JSON',
+  'memoryDebugPanel.requests.inFlight': '进行中',
+  'memoryDebugPanel.requests.peak': '峰值',
+  'memoryDebugPanel.requests.duration': '时长',
+  'memoryDebugPanel.requests.totalRequests': '请求总数',
+  'memoryDebugPanel.requests.tracking': '跟踪',
+  'memoryDebugPanel.requests.now': '当前',
+  'memoryDebugPanel.requests.noSamples': '尚未记录请求。保持此面板打开以记录 fetch 活动。',
+  'memoryDebugPanel.requests.chartLabel': '随时间变化的进行中 fetch 请求，峰值 {peak}',
+  'memoryDebugPanel.requests.windowHint': '最近 {seconds}秒',
+  'memoryDebugPanel.requests.percentileChartLabel': '进行中请求年龄百分位（p50、p90、p99、最大值）随时间的变化',
   'memoryDebugPanel.common.idle': '空闲',
   'memoryDebugPanel.common.live': '实时',
   'memoryDebugPanel.common.notAvailable': '无',
@@ -3111,7 +3122,7 @@ 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': 'AI 点数',
   'chat.workStatus.ariaLabel': '工作状态',
   'chat.workStatus.context.label': '上下文',
   'chat.workStatus.cost.breakdown': '会话 {session} · 子智能体 {subagents}',

packages/ui/src/lib/i18n/messages/zh-TW.ts

@@ -397,7 +397,7 @@ export const dict: Record<I18nKey, string> = {
   'multirun.launcher.attachments.attach': '附加',
   'multirun.launcher.attachments.tooltip': '相同檔案會傳送到所有執行',
   'multirun.launcher.models.label': '模型',
-  'multirun.launcher.models.info': '選擇 2-{max} 個模型。同一模型可重複加入。',
+  'multirun.launcher.models.info': '選擇 2 個或更多模型。同一模型可重複加入。',
   'multirun.launcher.toast.fileTooLarge': '檔案「{fileName}」過大（最大 10MB）',
   'multirun.launcher.toast.attachFailed': '附加「{fileName}」失敗',
   'multirun.launcher.toast.attachedSingle': '已附加 {count} 個檔案',
@@ -1928,8 +1928,6 @@ export const dict: Record<I18nKey, string> = {
   'session.newWorktree.noMatchingBranches': '沒有符合分支',
   'session.newWorktree.localBranches': '本地分支',
   'session.newWorktree.remoteBranches': '遠端分支',
-  'session.newWorktree.otherLocalBranches': '其他本地分支',
-  'session.newWorktree.otherRemoteBranches': '其他遠端分支',
   'session.newWorktree.branchName': '分支名稱',
   'session.newWorktree.branchNamePlaceholder': 'feature/my-awesome-feature',
   'session.newWorktree.actions.change': '變更',
@@ -2272,6 +2270,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.chatInput.toast.attachmentsTooLarge': '附件過大，無法傳送。請減少圖片數量或大小。',
   'chat.chatInput.toast.sendAttachmentsFailed': '傳送附件失敗。請嘗試更少檔案或更小圖片。',
   'chat.chatInput.toast.messageSendFailed': '訊息傳送失敗，附件已恢復。',
+  'chat.chatInput.toast.noModelSelected': '傳送前請先選擇提供者與模型。',
   'chat.chatInput.toast.clipboardAttachFailed': '從剪貼簿附加圖片失敗',
   'chat.chatInput.toast.addedFileMentions': '已加入 {count} 個檔案提及',
   'chat.chatInput.toast.attachFileFailed': '附加檔案失敗',
@@ -2321,6 +2320,7 @@ export const dict: Record<I18nKey, string> = {
   'chat.toolPart.showRawJson': '顯示原始 JSON',
   'chat.toolPart.showFormattedJson': '顯示格式化 JSON',
   'chat.toolPart.showNavigableJson': '顯示可導覽 JSON',
+  'chat.toolPart.openFile': '開啟檔案',
   'chat.toolPart.openFileAtFirstChange': '在首次變更處開啟檔案',
   'chat.toolPart.openFileDiff': '開啟檔案差異',
   'chat.toolPart.copyOutput': '複製輸出',
@@ -2973,6 +2973,7 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.title': '偵錯面板',
   'memoryDebugPanel.tabs.memory': '記憶體',
   'memoryDebugPanel.tabs.streaming': '串流',
+  'memoryDebugPanel.tabs.requests': '請求',
   'memoryDebugPanel.section.sessionsInMemory': '記憶體中的會話',
   'memoryDebugPanel.section.uiStreamingMetrics': 'UI 串流指標',
   'memoryDebugPanel.section.vscodeBridgeMetrics': 'VS Code 橋接指標',
@@ -3010,6 +3011,16 @@ export const dict: Record<I18nKey, string> = {
   'memoryDebugPanel.streaming.copy.copied': '串流偵錯 JSON 已複製',
   'memoryDebugPanel.streaming.copy.failed': '複製 JSON 失敗',
   'memoryDebugPanel.streaming.copy.hint': '複製會匯出 UI 與 VS Code 的串流指標 JSON',
+  'memoryDebugPanel.requests.inFlight': '進行中',
+  'memoryDebugPanel.requests.peak': '峰值',
+  'memoryDebugPanel.requests.duration': '時長',
+  'memoryDebugPanel.requests.totalRequests': '請求總數',
+  'memoryDebugPanel.requests.tracking': '追蹤',
+  'memoryDebugPanel.requests.now': '目前',
+  'memoryDebugPanel.requests.noSamples': '尚未記錄請求。保持此面板開啟以記錄 fetch 活動。',
+  'memoryDebugPanel.requests.chartLabel': '隨時間變化的進行中 fetch 請求，峰值 {peak}',
+  'memoryDebugPanel.requests.windowHint': '最近 {seconds}秒',
+  'memoryDebugPanel.requests.percentileChartLabel': '進行中請求年齡百分位（p50、p90、p99、最大值）隨時間的變化',
   'memoryDebugPanel.common.idle': '閒置',
   'memoryDebugPanel.common.live': '即時',
   'memoryDebugPanel.common.notAvailable': '無',
@@ -3110,7 +3121,7 @@ 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': 'AI 點數',
   'chat.workStatus.ariaLabel': '工作狀態',
   'chat.workStatus.context.label': '上下文',
   'chat.workStatus.cost.breakdown': '工作階段 {session} · 子 Agent {subagents}',

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

@@ -0,0 +1,122 @@
+import { describe, expect, test } from 'bun:test';
+
+import type { Part } from '@opencode-ai/sdk/v2';
+import { flattenAssistantTextParts, flattenUserTextParts } from './messageText';
+
+// Regression tests for https://github.com/openchamber/openchamber/issues/2867
+//
+// `flattenAssistantTextParts` used to collapse every blank line into a single
+// `\n`. Markdown block structure (paragraphs, lists, fenced code blocks)
+// requires a blank line (`\n\n`); a single `\n` is a CommonMark soft break.
+// `ChatMessage.tsx`'s `handleCopyMessage` feeds the flattened string into
+// `copyMarkdownToClipboard`, which writes it to `text/plain`, `text/markdown`
+// and its markdown-rendered HTML into `text/html`.
+
+const basePart = (overrides: Record<string, unknown>): Part =>
+  ({
+    id: 'p1',
+    sessionID: 's',
+    messageID: 'm',
+    type: 'text',
+    text: '',
+    ...overrides,
+  }) as Part;
+
+const makeParts = (texts: string[]): Part[] =>
+  texts.map((text, index) => basePart({ id: `p${index}`, text }));
+
+const makeUserParts = (
+  entries: Array<{ text?: string; shellAction?: { output?: unknown; command?: unknown } }>,
+): Part[] =>
+  entries.map((entry, index) =>
+    basePart({ id: `u${index}`, text: entry.text ?? '', shellAction: entry.shellAction }),
+  );
+
+describe('flattenAssistantTextParts', () => {
+  const parts = makeParts([
+    '第一段',
+    '第二段',
+    '```js\nconsole.log(1)\n```',
+    '第三段',
+    '- item 1\n- item 2',
+  ]);
+
+  test('blank lines between paragraphs/code blocks/lists are preserved', () => {
+    expect(flattenAssistantTextParts(parts)).toBe(
+      '第一段\n\n第二段\n\n```js\nconsole.log(1)\n```\n\n第三段\n\n- item 1\n- item 2',
+    );
+  });
+
+  test('a code fence is not glued to the following paragraph', () => {
+    const flattened = flattenAssistantTextParts(parts);
+    expect(flattened).not.toContain('```\n第三段');
+    expect(flattened).toContain('```\n\n第三段');
+  });
+
+  test('list items keep single newlines inside their part', () => {
+    expect(flattenAssistantTextParts(parts)).toContain('\n\n- item 1\n- item 2');
+  });
+
+  test('internal blank-line runs are preserved', () => {
+    const text = 'a\n\n\n\nb\n \n \nd';
+    expect(flattenAssistantTextParts(makeParts([text]))).toBe(text);
+  });
+
+  test('multiple blank lines inside a fenced code block are preserved', () => {
+    const fenced = '```js\na\n\n\nb\n```';
+    expect(flattenAssistantTextParts(makeParts([fenced]))).toBe(fenced);
+  });
+
+  test('part boundaries produce block separators', () => {
+    expect(flattenAssistantTextParts(makeParts(['first', 'second']))).toBe('first\n\nsecond');
+  });
+
+  test('empty and whitespace-only parts are dropped', () => {
+    expect(flattenAssistantTextParts([])).toBe('');
+    expect(flattenAssistantTextParts(makeParts(['', '   ', '\n']))).toBe('');
+  });
+
+  test('single part without blank lines is returned unchanged', () => {
+    const single = 'only line\nsecond line';
+    expect(flattenAssistantTextParts(makeParts([single]))).toBe(single);
+  });
+
+  test('non-text parts are ignored', () => {
+    const partsWithTool: Part[] = [
+      ...makeParts(['before']),
+      { id: 't1', sessionID: 's', messageID: 'm', type: 'tool', tool: 'bash' } as Part,
+      ...makeParts(['after']),
+    ];
+    expect(flattenAssistantTextParts(partsWithTool)).toBe('before\n\nafter');
+  });
+});
+
+describe('flattenUserTextParts', () => {
+  test('plain text parts keep blank-line block separators', () => {
+    const parts = makeUserParts([{ text: '第一段\n\n\n第二段' }, { text: '下一段' }]);
+    expect(flattenUserTextParts(parts)).toBe('第一段\n\n\n第二段\n\n下一段');
+  });
+
+  test('shell outputs win over other content and are joined with blank lines', () => {
+    const parts = makeUserParts([
+      { text: 'note', shellAction: { command: 'ls -la' } },
+      { text: '', shellAction: { output: '  file-a\nfile-b  ' } },
+      { text: '', shellAction: { output: 'done' } },
+    ]);
+    expect(flattenUserTextParts(parts)).toBe('file-a\nfile-b\n\ndone');
+  });
+
+  test('shell commands fall back to a single-newline command list', () => {
+    const parts = makeUserParts([
+      { shellAction: { command: ' bun install ' } },
+      { shellAction: { command: 'bun test' } },
+      { text: 'ignored when commands exist' },
+    ]);
+    expect(flattenUserTextParts(parts)).toBe('bun install\nbun test');
+  });
+
+  test('returns empty string for parts without text', () => {
+    expect(flattenUserTextParts([])).toBe('');
+    expect(flattenUserTextParts(makeUserParts([{ text: '  ' }]))).toBe('');
+  });
+});

packages/ui/src/lib/messages/messageText.ts

@@ -1,6 +1,7 @@
 import type { Part } from '@opencode-ai/sdk/v2';
 
 type TextLikePart = Part & { text?: string; content?: string };
+type UserTextPart = Part & { text?: string; content?: string; shellAction?: { output?: unknown; command?: unknown } };
 
 export const flattenAssistantTextParts = (parts: Part[]): string => {
     const textParts = parts
@@ -8,8 +9,36 @@ export const flattenAssistantTextParts = (parts: Part[]): string => {
         .map((part) => (part.text || part.content || '').trim())
         .filter((text) => text.length > 0);
 
-    const combined = textParts.join('\n');
-    return combined.replace(/\n\s*\n+/g, '\n');
+    return textParts.join('\n\n');
+};
+
+export const flattenUserTextParts = (parts: Part[]): string => {
+    const textParts = parts.filter((part): part is UserTextPart => part?.type === 'text');
+
+    const shellOutputs = textParts
+        .map((part) => {
+            const output = part.shellAction?.output;
+            return typeof output === 'string' ? output.trim() : '';
+        })
+        .filter((output) => output.length > 0);
+    if (shellOutputs.length > 0) {
+        return shellOutputs.join('\n\n');
+    }
+
+    const shellCommands = textParts
+        .map((part) => {
+            const command = part.shellAction?.command;
+            return typeof command === 'string' ? command.trim() : '';
+        })
+        .filter((command) => command.length > 0);
+    if (shellCommands.length > 0) {
+        return shellCommands.join('\n');
+    }
+
+    const plainTexts = textParts
+        .map((part) => (part.text || part.content || '').trim())
+        .filter((text) => text.length > 0);
+    return plainTexts.join('\n\n');
 };
 
 export const suggestPlanTitleFromText = (text: string): string => {

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

@@ -0,0 +1,142 @@
+import { describe, expect, test } from 'bun:test';
+
+import { createPlanSaveQueue } from './planSaveQueue';
+
+type Deferred = { promise: Promise<void>; resolve: () => void; reject: () => void };
+
+const deferred = (): Deferred => {
+  let resolve!: () => void;
+  let reject!: () => void;
+  const promise = new Promise<void>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
+describe('planSaveQueue', () => {
+  test('runs writes for one document in schedule order even when they resolve out of order', async () => {
+    const queue = createPlanSaveQueue();
+    const order: string[] = [];
+    const first = deferred();
+    const second = deferred();
+
+    const firstDone = queue.schedule('doc', 1, async () => {
+      await first.promise;
+      order.push('first');
+    });
+    const secondDone = queue.schedule('doc', 2, async () => {
+      order.push('second');
+    });
+
+    // Second started only after first settles, regardless of timing.
+    first.resolve();
+    await firstDone;
+    second.resolve();
+    await secondDone;
+
+    expect(order).toEqual(['first', 'second']);
+  });
+
+  test('skips a revision at or below the last queued revision for the same document', async () => {
+    const queue = createPlanSaveQueue();
+    let writes = 0;
+
+    await queue.schedule('doc', 3, async () => {
+      writes += 1;
+    });
+    await queue.schedule('doc', 3, async () => {
+      writes += 1;
+    });
+    await queue.schedule('doc', 2, async () => {
+      writes += 1;
+    });
+
+    expect(writes).toBe(1);
+  });
+
+  test('never lets a write for one document block another document', async () => {
+    const queue = createPlanSaveQueue();
+    const blocked = deferred();
+
+    const blockedDone = queue.schedule('a', 1, async () => {
+      await blocked.promise;
+    });
+    let otherRan = false;
+    await queue.schedule('b', 1, async () => {
+      otherRan = true;
+    });
+
+    expect(otherRan).toBe(true);
+    blocked.resolve();
+    await blockedDone;
+  });
+
+  test('pendingFor waits for the outstanding chain of that document only', async () => {
+    const queue = createPlanSaveQueue();
+    const slow = deferred();
+    let slowSettled = false;
+
+    void queue.schedule('a', 1, async () => {
+      await slow.promise;
+      slowSettled = true;
+    });
+    await queue.schedule('b', 1, async () => {});
+
+    await queue.pendingFor('b');
+    expect(slowSettled).toBe(false);
+
+    slow.resolve();
+    await queue.pendingFor('a');
+    expect(slowSettled).toBe(true);
+  });
+
+  test('reset clears the revision watermark so a reloaded document can save again', async () => {
+    const queue = createPlanSaveQueue();
+    let writes = 0;
+
+    await queue.schedule('doc', 5, async () => {
+      writes += 1;
+    });
+    queue.reset('doc');
+    await queue.schedule('doc', 1, async () => {
+      writes += 1;
+    });
+
+    expect(writes).toBe(2);
+  });
+
+  test('a failed write does not poison the chain for later writes', async () => {
+    const queue = createPlanSaveQueue();
+
+    const failing = queue.schedule('doc', 1, async () => {
+      throw new Error('write failed');
+    });
+    let secondRan = false;
+    const second = queue.schedule('doc', 2, async () => {
+      secondRan = true;
+    });
+
+    await expect(failing).rejects.toThrow('write failed');
+    await second;
+    expect(secondRan).toBe(true);
+    await queue.pendingFor('doc');
+  });
+
+  test('allows the same revision to retry after its write fails', async () => {
+    const queue = createPlanSaveQueue();
+    let attempts = 0;
+
+    const failing = queue.schedule('doc', 1, async () => {
+      attempts += 1;
+      throw new Error('write failed');
+    });
+    await expect(failing).rejects.toThrow('write failed');
+
+    await queue.schedule('doc', 1, async () => {
+      attempts += 1;
+    });
+
+    expect(attempts).toBe(2);
+  });
+});

packages/ui/src/lib/planSaveQueue.ts

@@ -0,0 +1,61 @@
+/**
+ * Write queue for open plan documents.
+ *
+ * Debounced autosave and close-time flushes must reach the disk in edit order,
+ * and a document re-opened while its own write is still in flight must read
+ * the post-write state, not race it. The queue serializes writes per logical
+ * document key and deduplicates revisions so a flush of revision N can never
+ * run behind, or twice behind, a debounced save of the same revision.
+ */
+
+interface PlanSaveQueue {
+  /**
+   * Queue one write for `key`. Writes for the same key run in schedule order;
+   * writes for different keys never block each other. A revision at or below
+   * the last queued revision for that key is skipped — the queued write
+   * already carries newer content — and the returned promise tracks the
+   * outstanding chain so callers can still await it.
+   */
+  schedule: (key: string, revision: number, write: () => Promise<void>) => Promise<void>;
+  /** Resolves when every write queued for `key` has settled. */
+  pendingFor: (key: string) => Promise<void>;
+  /**
+   * Forgets the revision watermark for `key`. Call when a document is freshly
+   * loaded: its revision counter restarts, and stale watermarks from a
+   * previous open must not swallow the first real edit.
+   */
+  reset: (key: string) => void;
+}
+
+export const createPlanSaveQueue = (): PlanSaveQueue => {
+  const chains = new Map<string, Promise<void>>();
+  const lastRevision = new Map<string, number>();
+
+  return {
+    schedule: (key, revision, write) => {
+      if (revision <= (lastRevision.get(key) ?? Number.NEGATIVE_INFINITY)) {
+        return chains.get(key) ?? Promise.resolve();
+      }
+      lastRevision.set(key, revision);
+      const previous = chains.get(key) ?? Promise.resolve();
+      // A failed write must not poison the chain: the next write for this
+      // document is still safe to attempt, and error surfacing belongs to the
+      // caller that owns UI state.
+      const next = previous.then(write, write);
+      chains.set(key, next.catch(() => {
+        // Keep newer queued revisions deduplicated, but let the caller retry
+        // this exact revision after its write has failed.
+        if (lastRevision.get(key) === revision) {
+          lastRevision.delete(key);
+        }
+      }));
+      return next;
+    },
+    pendingFor: async (key) => {
+      await chains.get(key);
+    },
+    reset: (key) => {
+      lastRevision.delete(key);
+    },
+  };
+};

packages/ui/src/lib/projectContextApi.ts

@@ -57,6 +57,17 @@ export interface ProjectRef {
   path: string;
 }
 
+/**
+ * A saved project plan plus the project that owns it, carried as one value so
+ * a viewer can never end up with a plan id whose owner it has to guess.
+ * PlanView resolves no owner on its own: the panel (or the persisted tab,
+ * or the mobile surface) that opened the plan knows the owner exactly.
+ */
+export interface SavedProjectPlanTarget {
+  projectRef: ProjectRef;
+  planId: string;
+}
+
 export const PROJECT_NOTE_BODY_MAX_LENGTH = 3000;
 export const PROJECT_TODO_TEXT_MAX_LENGTH = 120;
 

packages/ui/src/lib/quota/utils.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 
-import { clampPercent, formatPercent } from './utils';
+import { clampPercent, formatPercent, formatWindowLabel } from './utils';
 
 describe('quota utils', () => {
   test('treats non-finite percentages as missing', () => {
@@ -10,4 +10,9 @@ describe('quota utils', () => {
     expect(formatPercent(Infinity)).toBe('-');
     expect(formatPercent(-Infinity)).toBe('-');
   });
+
+  test('labels Copilot usage as AI Credits without changing generic premium usage', () => {
+    expect(formatWindowLabel('premium')).toBe('Premium Interactions');
+    expect(formatWindowLabel('premium_interactions')).toBe('AI Credits');
+  });
 });

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

@@ -8,6 +8,7 @@ import {
   withBtwSessionLink,
   withBtwSessionMarker,
   withoutBtwSessionLink,
+  wasPromotedBtwSession,
   withoutBtwSessionMarker,
 } from './sessionBtwMetadata';
 
@@ -64,11 +65,20 @@ describe('fork marker', () => {
     expect(getBtwBoundaryMessageID(review)).toBeNull();
   });
 
-  test('withoutBtwSessionMarker strips the marker and keeps other keys', () => {
+  test('withoutBtwSessionMarker strips the marker, keeps other keys, and records the promotion', () => {
     const marked = { openchamber: { kind: 'btw', originalSessionID: 'parent-1', btwBoundaryMessageID: 'msg-9', btwSessionID: 'nested' } };
-    expect(withoutBtwSessionMarker(marked)).toEqual({ openchamber: { btwSessionID: 'nested' } });
-    expect(withoutBtwSessionMarker({ openchamber: { kind: 'btw', originalSessionID: 'parent-1' } })).toEqual({});
+    expect(withoutBtwSessionMarker(marked)).toEqual({ openchamber: { btwSessionID: 'nested', btwPromoted: true } });
+    expect(withoutBtwSessionMarker({ openchamber: { kind: 'btw', originalSessionID: 'parent-1' } })).toEqual({ openchamber: { btwPromoted: true } });
     const plain = { openchamber: { kind: 'review' } };
     expect(withoutBtwSessionMarker(plain)).toBe(plain);
   });
+
+  test('wasPromotedBtwSession only reports a session that went through promotion', () => {
+    expect(wasPromotedBtwSession(sessionWith({ openchamber: { btwPromoted: true } }))).toBe(true);
+    // Still a live btw fork: the boundary applies, the notice must not.
+    expect(wasPromotedBtwSession(sessionWith({ openchamber: { kind: 'btw', originalSessionID: 'p-1' } }))).toBe(false);
+    expect(wasPromotedBtwSession(sessionWith({ openchamber: {} }))).toBe(false);
+    expect(wasPromotedBtwSession(sessionWith(undefined))).toBe(false);
+    expect(wasPromotedBtwSession(null)).toBe(false);
+  });
 });

packages/ui/src/lib/sessionBtwMetadata.ts

@@ -21,6 +21,7 @@ type BtwMetadata = {
   originalSessionID?: string;
   btwSessionID?: string;
   btwBoundaryMessageID?: string;
+  btwPromoted?: boolean;
 };
 
 const getOpenChamberMetadata = (metadata: SessionMetadataRecord): BtwMetadata => {
@@ -39,6 +40,18 @@ const nonEmpty = (value: string | undefined): string | null =>
 export const getBtwSessionID = (session: Session | null | undefined): string | null =>
   nonEmpty(getOpenChamberMetadata(getSessionMetadata(session)).btwSessionID);
 
+/**
+ * The session was once a btw fork and was promoted to a normal session.
+ *
+ * Its transcript still contains the btw boundary instruction on every message
+ * sent while it was a side conversation, and there is no API to remove a
+ * message part after the fact. The flag lets the composer send a notice that
+ * those constraints have been lifted, so they cannot keep steering a session
+ * that is no longer a side conversation.
+ */
+export const wasPromotedBtwSession = (session: Session | null | undefined): boolean =>
+  getOpenChamberMetadata(getSessionMetadata(session)).btwPromoted === true;
+
 export const isBtwSession = (session: Session | null | undefined): boolean =>
   getOpenChamberMetadata(getSessionMetadata(session)).kind === 'btw'
   && Boolean(getBtwOriginalSessionID(session));
@@ -84,7 +97,13 @@ export const withBtwSessionMarker = (
   return { ...metadata, openchamber };
 };
 
-/** Remove the btw marker so a promoted fork becomes a plain session. */
+/**
+ * Remove the btw marker so a promoted fork becomes a plain session.
+ *
+ * `btwPromoted` replaces it rather than leaving nothing behind: the btw
+ * boundary instructions stay in the transcript forever, so the session has to
+ * remain distinguishable from one that was never a side conversation.
+ */
 export const withoutBtwSessionMarker = (metadata: SessionMetadataRecord): SessionMetadataRecord => {
   const openchamber = getOpenChamberMetadata(metadata);
   if (openchamber.kind !== 'btw') return metadata;
@@ -92,13 +111,8 @@ export const withoutBtwSessionMarker = (metadata: SessionMetadataRecord): Sessio
   delete rest.kind;
   delete rest.originalSessionID;
   delete rest.btwBoundaryMessageID;
-  const next: SessionMetadataRecord = { ...metadata };
-  if (Object.keys(rest).length > 0) {
-    next.openchamber = rest;
-  } else {
-    delete next.openchamber;
-  }
-  return next;
+  rest.btwPromoted = true;
+  return { ...metadata, openchamber: rest };
 };
 
 /** Unlink the parent, but only if it still points at this fork. */

packages/ui/src/lib/theme/themes/aura-dark.json

@@ -134,7 +134,7 @@
       "link": "#A277FF",
       "linkHover": "#F694FF",
       "inlineCode": "#61FFCA",
-      "inlineCodeBackground": "#1A1921",
+      "inlineCodeBackground": "#222128",
       "blockquote": "#6D6D6D",
       "blockquoteBorder": "#2D2B38",
       "listMarker": "#A277FF99"

packages/ui/src/lib/theme/themes/aura-light.json

@@ -133,8 +133,8 @@
       "heading4": "#2D2640",
       "link": "#A277FF",
       "linkHover": "#C17AC8",
-      "inlineCode": "#40BF7A",
-      "inlineCodeBackground": "#EFE8FC",
+      "inlineCode": "#00732E",
+      "inlineCodeBackground": "#E8E3F2",
       "blockquote": "#6D6D6D",
       "blockquoteBorder": "#E0D6F2",
       "listMarker": "#A277FF99"

packages/ui/src/lib/theme/themes/ayu-dark.json

@@ -134,7 +134,7 @@
       "link": "#66C6F1",
       "linkHover": "#3FB7E3",
       "inlineCode": "#B1C74A",
-      "inlineCodeBackground": "#161d23",
+      "inlineCodeBackground": "#1C2126",
       "blockquote": "#E4A75C",
       "blockquoteBorder": "#2B3440",
       "listMarker": "#3FB7E399"

packages/ui/src/lib/theme/themes/ayu-light.json

@@ -133,8 +133,8 @@
       "heading4": "#394049",
       "link": "#2F9BCE",
       "linkHover": "#4AA8C8",
-      "inlineCode": "#7FAD00",
-      "inlineCodeBackground": "#FCF9F3",
+      "inlineCode": "#497700",
+      "inlineCodeBackground": "#F0EDE7",
       "blockquote": "#ED982E",
       "blockquoteBorder": "#E6DDCF",
       "listMarker": "#4AA8C899"

packages/ui/src/lib/theme/themes/carbonfox-dark.json

@@ -134,7 +134,7 @@
       "link": "#33B1FF",
       "linkHover": "#78A9FF",
       "inlineCode": "#42BE65",
-      "inlineCodeBackground": "#1e1e1e",
+      "inlineCodeBackground": "#232323",
       "blockquote": "#8D8D8D",
       "blockquoteBorder": "#393939",
       "listMarker": "#33B1FF99"

packages/ui/src/lib/theme/themes/carbonfox-light.json

@@ -133,8 +133,8 @@
       "heading4": "#161616",
       "link": "#0072C3",
       "linkHover": "#0043CE",
-      "inlineCode": "#198038",
-      "inlineCodeBackground": "#F4F4F4",
+      "inlineCode": "#00661E",
+      "inlineCodeBackground": "#F2F2F2",
       "blockquote": "#525252",
       "blockquoteBorder": "#DCDCDC",
       "listMarker": "#0072C399"

packages/ui/src/lib/theme/themes/catppuccin-dark.json

@@ -134,7 +134,7 @@
       "link": "#89DCEB",
       "linkHover": "#B4BEFE",
       "inlineCode": "#A6E3A1",
-      "inlineCodeBackground": "#2d2a42",
+      "inlineCodeBackground": "#2B2B3B",
       "blockquote": "#F9E2AF",
       "blockquoteBorder": "#35324A",
       "listMarker": "#B4BEFE99"

packages/ui/src/lib/theme/themes/catppuccin-light.json

@@ -133,8 +133,8 @@
       "heading4": "#2e314a",
       "link": "#04A5E5",
       "linkHover": "#7287FD",
-      "inlineCode": "#40A02B",
-      "inlineCodeBackground": "#f6eeec",
+      "inlineCode": "#1A7A05",
+      "inlineCodeBackground": "#F2E9E7",
       "blockquote": "#DF8E1D",
       "blockquoteBorder": "#E0CFD3",
       "listMarker": "#7287FD99"

packages/ui/src/lib/theme/themes/dracula-dark.json

@@ -134,7 +134,7 @@
       "link": "#8BE9FD",
       "linkHover": "#BD93F9",
       "inlineCode": "#4aeb72",
-      "inlineCodeBackground": "#202132",
+      "inlineCodeBackground": "#21222C",
       "blockquote": "#FFB86C",
       "blockquoteBorder": "#2D2F3C",
       "listMarker": "#BD93F999"

packages/ui/src/lib/theme/themes/dracula-light.json

@@ -133,8 +133,8 @@
       "heading4": "#1F1F2F",
       "link": "#1D7FC5",
       "linkHover": "#7C6BF5",
-      "inlineCode": "#2FBF71",
-      "inlineCodeBackground": "#F1F2ED",
+      "inlineCode": "#007325",
+      "inlineCodeBackground": "#EBEBE5",
       "blockquote": "#F7A14D",
       "blockquoteBorder": "#E2E3DA",
       "listMarker": "#7C6BF599"

packages/ui/src/lib/theme/themes/fields-of-the-shire-dark.json

@@ -137,7 +137,7 @@
       "link": "#5a6d7a",
       "linkHover": "#93a56b",
       "inlineCode": "#93a56b",
-      "inlineCodeBackground": "#23201c",
+      "inlineCodeBackground": "#282522",
       "blockquote": "#a89888",
       "blockquoteBorder": "#f0e6d830",
       "listMarker": "#c47a3a99"

packages/ui/src/lib/theme/themes/fields-of-the-shire-light.json

@@ -136,8 +136,8 @@
       "heading4": "#1a1612",
       "link": "#3d4f5a",
       "linkHover": "#4a6030",
-      "inlineCode": "#4a6030",
-      "inlineCodeBackground": "#ece5d6",
+      "inlineCode": "#4A6030",
+      "inlineCodeBackground": "#ECE8DE",
       "blockquote": "#5a5048",
       "blockquoteBorder": "#1a161230",
       "listMarker": "#8c552099"

packages/ui/src/lib/theme/themes/flexoki-dark.json

@@ -136,7 +136,7 @@
       "link": "#4385BE",
       "linkHover": "#205EA6",
       "inlineCode": "#A0AF53",
-      "inlineCodeBackground": "#1C1B1A",
+      "inlineCodeBackground": "#242222",
       "blockquote": "#878580",
       "blockquoteBorder": "#343331",
       "listMarker": "#D0A21599"

packages/ui/src/lib/theme/themes/flexoki-light.json

@@ -135,8 +135,8 @@
       "heading4": "#100F0F",
       "link": "#205EA6",
       "linkHover": "#4385BE",
-      "inlineCode": "#24837B",
-      "inlineCodeBackground": "#f6f5ee",
+      "inlineCode": "#0A6961",
+      "inlineCodeBackground": "#F2F0E7",
       "blockquote": "#6F6E69",
       "blockquoteBorder": "#DAD8CE",
       "listMarker": "#AD830199"

packages/ui/src/lib/theme/themes/gruvbox-dark.json

@@ -134,7 +134,7 @@
       "link": "#8EC07C",
       "linkHover": "#83A598",
       "inlineCode": "#B8BB26",
-      "inlineCodeBackground": "#32302F",
+      "inlineCodeBackground": "#353535",
       "blockquote": "#928374",
       "blockquoteBorder": "#504945",
       "listMarker": "#83A59899"

packages/ui/src/lib/theme/themes/gruvbox-light.json

@@ -133,8 +133,8 @@
       "heading4": "#3C3836",
       "link": "#427B58",
       "linkHover": "#076678",
-      "inlineCode": "#79740E",
-      "inlineCodeBackground": "#F2E5BC",
+      "inlineCode": "#5F5A00",
+      "inlineCodeBackground": "#EBE4C8",
       "blockquote": "#928374",
       "blockquoteBorder": "#D5C4A1",
       "listMarker": "#07667899"

packages/ui/src/lib/theme/themes/jetbrains-dark.json

@@ -138,7 +138,7 @@
       "link": "#56A8F5",
       "linkHover": "#6796f5",
       "inlineCode": "#6AAB73",
-      "inlineCodeBackground": "#26282B",
+      "inlineCodeBackground": "#2B2C2F",
       "blockquote": "#7A7E85",
       "blockquoteBorder": "#393B41",
       "listMarker": "#B3AE6099"

packages/ui/src/lib/theme/themes/jetbrains-light.json

@@ -138,7 +138,7 @@
       "link": "#006DCC",
       "linkHover": "#3573F0",
       "inlineCode": "#067D17",
-      "inlineCodeBackground": "#F5F7F9",
+      "inlineCodeBackground": "#F2F2F2",
       "blockquote": "#8C8C8C",
       "blockquoteBorder": "#C9CCD6",
       "listMarker": "#9E880D99"