Add files using upload-large-folder tool

projects/ui/qwen-code/packages/cli/src/ui/components/OpenAIKeyPrompt.test.tsx

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { OpenAIKeyPrompt } from './OpenAIKeyPrompt.js';
+
+describe('OpenAIKeyPrompt', () => {
+  it('should render the prompt correctly', () => {
+    const onSubmit = vi.fn();
+    const onCancel = vi.fn();
+
+    const { lastFrame } = render(
+      <OpenAIKeyPrompt onSubmit={onSubmit} onCancel={onCancel} />,
+    );
+
+    expect(lastFrame()).toContain('OpenAI Configuration Required');
+    expect(lastFrame()).toContain('https://platform.openai.com/api-keys');
+    expect(lastFrame()).toContain(
+      'Press Enter to continue, Tab/↑↓ to navigate, Esc to cancel',
+    );
+  });
+
+  it('should show the component with proper styling', () => {
+    const onSubmit = vi.fn();
+    const onCancel = vi.fn();
+
+    const { lastFrame } = render(
+      <OpenAIKeyPrompt onSubmit={onSubmit} onCancel={onCancel} />,
+    );
+
+    const output = lastFrame();
+    expect(output).toContain('OpenAI Configuration Required');
+    expect(output).toContain('API Key:');
+    expect(output).toContain('Base URL:');
+    expect(output).toContain('Model:');
+    expect(output).toContain(
+      'Press Enter to continue, Tab/↑↓ to navigate, Esc to cancel',
+    );
+  });
+
+  it('should handle paste with control characters', async () => {
+    const onSubmit = vi.fn();
+    const onCancel = vi.fn();
+
+    const { stdin } = render(
+      <OpenAIKeyPrompt onSubmit={onSubmit} onCancel={onCancel} />,
+    );
+
+    // Simulate paste with control characters
+    const pasteWithControlChars = '\x1b[200~sk-test123\x1b[201~';
+    stdin.write(pasteWithControlChars);
+
+    // Wait a bit for processing
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // The component should have filtered out the control characters
+    // and only kept 'sk-test123'
+    expect(onSubmit).not.toHaveBeenCalled(); // Should not submit yet
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/OpenAIKeyPrompt.tsx

@@ -0,0 +1,197 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Colors } from '../colors.js';
+
+interface OpenAIKeyPromptProps {
+  onSubmit: (apiKey: string, baseUrl: string, model: string) => void;
+  onCancel: () => void;
+}
+
+export function OpenAIKeyPrompt({
+  onSubmit,
+  onCancel,
+}: OpenAIKeyPromptProps): React.JSX.Element {
+  const [apiKey, setApiKey] = useState('');
+  const [baseUrl, setBaseUrl] = useState('');
+  const [model, setModel] = useState('');
+  const [currentField, setCurrentField] = useState<
+    'apiKey' | 'baseUrl' | 'model'
+  >('apiKey');
+
+  useInput((input, key) => {
+    // 过滤粘贴相关的控制序列
+    let cleanInput = (input || '')
+      // 过滤 ESC 开头的控制序列（如 \u001b[200~、\u001b[201~ 等）
+      .replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '') // eslint-disable-line no-control-regex
+      // 过滤粘贴开始标记 [200~
+      .replace(/\[200~/g, '')
+      // 过滤粘贴结束标记 [201~
+      .replace(/\[201~/g, '')
+      // 过滤单独的 [ 和 ~ 字符（可能是粘贴标记的残留）
+      .replace(/^\[|~$/g, '');
+
+    // 再过滤所有不可见字符（ASCII < 32，除了回车换行）
+    cleanInput = cleanInput
+      .split('')
+      .filter((ch) => ch.charCodeAt(0) >= 32)
+      .join('');
+
+    if (cleanInput.length > 0) {
+      if (currentField === 'apiKey') {
+        setApiKey((prev) => prev + cleanInput);
+      } else if (currentField === 'baseUrl') {
+        setBaseUrl((prev) => prev + cleanInput);
+      } else if (currentField === 'model') {
+        setModel((prev) => prev + cleanInput);
+      }
+      return;
+    }
+
+    // 检查是否是 Enter 键（通过检查输入是否包含换行符）
+    if (input.includes('\n') || input.includes('\r')) {
+      if (currentField === 'apiKey') {
+        // 允许空 API key 跳转到下一个字段，让用户稍后可以返回修改
+        setCurrentField('baseUrl');
+        return;
+      } else if (currentField === 'baseUrl') {
+        setCurrentField('model');
+        return;
+      } else if (currentField === 'model') {
+        // 只有在提交时才检查 API key 是否为空
+        if (apiKey.trim()) {
+          onSubmit(apiKey.trim(), baseUrl.trim(), model.trim());
+        } else {
+          // 如果 API key 为空，回到 API key 字段
+          setCurrentField('apiKey');
+        }
+      }
+      return;
+    }
+
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+
+    // Handle Tab key for field navigation
+    if (key.tab) {
+      if (currentField === 'apiKey') {
+        setCurrentField('baseUrl');
+      } else if (currentField === 'baseUrl') {
+        setCurrentField('model');
+      } else if (currentField === 'model') {
+        setCurrentField('apiKey');
+      }
+      return;
+    }
+
+    // Handle arrow keys for field navigation
+    if (key.upArrow) {
+      if (currentField === 'baseUrl') {
+        setCurrentField('apiKey');
+      } else if (currentField === 'model') {
+        setCurrentField('baseUrl');
+      }
+      return;
+    }
+
+    if (key.downArrow) {
+      if (currentField === 'apiKey') {
+        setCurrentField('baseUrl');
+      } else if (currentField === 'baseUrl') {
+        setCurrentField('model');
+      }
+      return;
+    }
+
+    // Handle backspace - check both key.backspace and delete key
+    if (key.backspace || key.delete) {
+      if (currentField === 'apiKey') {
+        setApiKey((prev) => prev.slice(0, -1));
+      } else if (currentField === 'baseUrl') {
+        setBaseUrl((prev) => prev.slice(0, -1));
+      } else if (currentField === 'model') {
+        setModel((prev) => prev.slice(0, -1));
+      }
+      return;
+    }
+  });
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.AccentBlue}
+      flexDirection="column"
+      padding={1}
+      width="100%"
+    >
+      <Text bold color={Colors.AccentBlue}>
+        OpenAI Configuration Required
+      </Text>
+      <Box marginTop={1}>
+        <Text>
+          Please enter your OpenAI configuration. You can get an API key from{' '}
+          <Text color={Colors.AccentBlue}>
+            https://platform.openai.com/api-keys
+          </Text>
+        </Text>
+      </Box>
+      <Box marginTop={1} flexDirection="row">
+        <Box width={12}>
+          <Text
+            color={currentField === 'apiKey' ? Colors.AccentBlue : Colors.Gray}
+          >
+            API Key:
+          </Text>
+        </Box>
+        <Box flexGrow={1}>
+          <Text>
+            {currentField === 'apiKey' ? '> ' : '  '}
+            {apiKey || ' '}
+          </Text>
+        </Box>
+      </Box>
+      <Box marginTop={1} flexDirection="row">
+        <Box width={12}>
+          <Text
+            color={currentField === 'baseUrl' ? Colors.AccentBlue : Colors.Gray}
+          >
+            Base URL:
+          </Text>
+        </Box>
+        <Box flexGrow={1}>
+          <Text>
+            {currentField === 'baseUrl' ? '> ' : '  '}
+            {baseUrl}
+          </Text>
+        </Box>
+      </Box>
+      <Box marginTop={1} flexDirection="row">
+        <Box width={12}>
+          <Text
+            color={currentField === 'model' ? Colors.AccentBlue : Colors.Gray}
+          >
+            Model:
+          </Text>
+        </Box>
+        <Box flexGrow={1}>
+          <Text>
+            {currentField === 'model' ? '> ' : '  '}
+            {model}
+          </Text>
+        </Box>
+      </Box>
+      <Box marginTop={1}>
+        <Text color={Colors.Gray}>
+          Press Enter to continue, Tab/↑↓ to navigate, Esc to cancel
+        </Text>
+      </Box>
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/PrepareLabel.tsx

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Text } from 'ink';
+import { Colors } from '../colors.js';
+
+interface PrepareLabelProps {
+  label: string;
+  matchedIndex?: number;
+  userInput: string;
+  textColor: string;
+  highlightColor?: string;
+}
+
+export const PrepareLabel: React.FC<PrepareLabelProps> = ({
+  label,
+  matchedIndex,
+  userInput,
+  textColor,
+  highlightColor = Colors.AccentYellow,
+}) => {
+  if (
+    matchedIndex === undefined ||
+    matchedIndex < 0 ||
+    matchedIndex >= label.length ||
+    userInput.length === 0
+  ) {
+    return <Text color={textColor}>{label}</Text>;
+  }
+
+  const start = label.slice(0, matchedIndex);
+  const match = label.slice(matchedIndex, matchedIndex + userInput.length);
+  const end = label.slice(matchedIndex + userInput.length);
+
+  return (
+    <Text>
+      <Text color={textColor}>{start}</Text>
+      <Text color="black" bold backgroundColor={highlightColor}>
+        {match}
+      </Text>
+      <Text color={textColor}>{end}</Text>
+    </Text>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/QwenOAuthProgress.test.tsx

@@ -0,0 +1,546 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// React import not needed for test files
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { QwenOAuthProgress } from './QwenOAuthProgress.js';
+import { DeviceAuthorizationInfo } from '../hooks/useQwenAuth.js';
+
+// Mock qrcode-terminal module
+vi.mock('qrcode-terminal', () => ({
+  default: {
+    generate: vi.fn(),
+  },
+}));
+
+// Mock ink-spinner
+vi.mock('ink-spinner', () => ({
+  default: ({ type }: { type: string }) => `MockSpinner(${type})`,
+}));
+
+// Mock ink-link
+vi.mock('ink-link', () => ({
+  default: ({ children }: { children: React.ReactNode; url: string }) =>
+    children,
+}));
+
+describe('QwenOAuthProgress', () => {
+  const mockOnTimeout = vi.fn();
+  const mockOnCancel = vi.fn();
+
+  const createMockDeviceAuth = (
+    overrides: Partial<DeviceAuthorizationInfo> = {},
+  ): DeviceAuthorizationInfo => ({
+    verification_uri: 'https://example.com/device',
+    verification_uri_complete: 'https://example.com/device?user_code=ABC123',
+    user_code: 'ABC123',
+    expires_in: 300,
+    ...overrides,
+  });
+
+  const mockDeviceAuth = createMockDeviceAuth();
+
+  const renderComponent = (
+    props: Partial<{
+      deviceAuth: DeviceAuthorizationInfo;
+      authStatus:
+        | 'idle'
+        | 'polling'
+        | 'success'
+        | 'error'
+        | 'timeout'
+        | 'rate_limit';
+      authMessage: string | null;
+    }> = {},
+  ) =>
+    render(
+      <QwenOAuthProgress
+        onTimeout={mockOnTimeout}
+        onCancel={mockOnCancel}
+        {...props}
+      />,
+    );
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('Loading state (no deviceAuth)', () => {
+    it('should render loading state when deviceAuth is not provided', () => {
+      const { lastFrame } = renderComponent();
+
+      const output = lastFrame();
+      expect(output).toContain('MockSpinner(dots)');
+      expect(output).toContain('Waiting for Qwen OAuth authentication...');
+      expect(output).toContain('(Press ESC to cancel)');
+    });
+
+    it('should render loading state with gray border', () => {
+      const { lastFrame } = renderComponent();
+      const output = lastFrame();
+
+      // Should not contain auth flow elements
+      expect(output).not.toContain('Qwen OAuth Authentication');
+      expect(output).not.toContain('Please visit this URL to authorize:');
+      // Loading state still shows time remaining with default timeout
+      expect(output).toContain('Time remaining:');
+    });
+  });
+
+  describe('Authenticated state (with deviceAuth)', () => {
+    it('should render authentication flow when deviceAuth is provided', () => {
+      const { lastFrame } = renderComponent({ deviceAuth: mockDeviceAuth });
+
+      const output = lastFrame();
+      // Initially no QR code shown until it's generated, but the status area should be visible
+      expect(output).toContain('MockSpinner(dots)');
+      expect(output).toContain('Waiting for authorization');
+      expect(output).toContain('Time remaining: 5:00');
+      expect(output).toContain('(Press ESC to cancel)');
+    });
+
+    it('should display correct URL in Static component when QR code is generated', async () => {
+      const qrcode = await import('qrcode-terminal');
+      const mockGenerate = vi.mocked(qrcode.default.generate);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let qrCallback: any = null;
+      mockGenerate.mockImplementation((url, options, callback) => {
+        qrCallback = callback;
+      });
+
+      const customAuth = createMockDeviceAuth({
+        verification_uri_complete: 'https://custom.com/auth?code=XYZ789',
+      });
+
+      const { lastFrame, rerender } = renderComponent({
+        deviceAuth: customAuth,
+      });
+
+      // Manually trigger the QR code callback
+      if (qrCallback && typeof qrCallback === 'function') {
+        qrCallback('Mock QR Code Data');
+      }
+
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={customAuth}
+        />,
+      );
+
+      expect(lastFrame()).toContain('https://custom.com/auth?code=XYZ789');
+    });
+
+    it('should format time correctly', () => {
+      const deviceAuthWithCustomTime: DeviceAuthorizationInfo = {
+        ...mockDeviceAuth,
+        expires_in: 125, // 2 minutes and 5 seconds
+      };
+
+      const { lastFrame } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWithCustomTime}
+        />,
+      );
+
+      const output = lastFrame();
+      expect(output).toContain('Time remaining: 2:05');
+    });
+
+    it('should format single digit seconds with leading zero', () => {
+      const deviceAuthWithCustomTime: DeviceAuthorizationInfo = {
+        ...mockDeviceAuth,
+        expires_in: 67, // 1 minute and 7 seconds
+      };
+
+      const { lastFrame } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWithCustomTime}
+        />,
+      );
+
+      const output = lastFrame();
+      expect(output).toContain('Time remaining: 1:07');
+    });
+  });
+
+  describe('Timer functionality', () => {
+    it('should countdown and call onTimeout when timer expires', async () => {
+      const deviceAuthWithShortTime: DeviceAuthorizationInfo = {
+        ...mockDeviceAuth,
+        expires_in: 2, // 2 seconds
+      };
+
+      const { rerender } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWithShortTime}
+        />,
+      );
+
+      // Advance timer by 1 second
+      vi.advanceTimersByTime(1000);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWithShortTime}
+        />,
+      );
+
+      // Advance timer by another second to trigger timeout
+      vi.advanceTimersByTime(1000);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWithShortTime}
+        />,
+      );
+
+      expect(mockOnTimeout).toHaveBeenCalledTimes(1);
+    });
+
+    it('should update time remaining display', async () => {
+      const { lastFrame, rerender } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Initial time should be 5:00
+      expect(lastFrame()).toContain('Time remaining: 5:00');
+
+      // Advance by 1 second
+      vi.advanceTimersByTime(1000);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Should now show 4:59
+      expect(lastFrame()).toContain('Time remaining: 4:59');
+    });
+
+    it('should use default 300 second timeout when deviceAuth is null', () => {
+      const { lastFrame } = render(
+        <QwenOAuthProgress onTimeout={mockOnTimeout} onCancel={mockOnCancel} />,
+      );
+
+      // Should show default 5:00 (300 seconds) timeout
+      expect(lastFrame()).toContain('Time remaining: 5:00');
+
+      // The timer functionality is already tested in other tests,
+      // this test mainly verifies the default timeout value is used
+    });
+  });
+
+  describe('Animated dots', () => {
+    it('should cycle through animated dots', async () => {
+      const { lastFrame, rerender } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Initial state should have no dots
+      expect(lastFrame()).toContain('Waiting for authorization');
+
+      // Advance by 500ms to add first dot
+      vi.advanceTimersByTime(500);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+      expect(lastFrame()).toContain('Waiting for authorization.');
+
+      // Advance by another 500ms to add second dot
+      vi.advanceTimersByTime(500);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+      expect(lastFrame()).toContain('Waiting for authorization..');
+
+      // Advance by another 500ms to add third dot
+      vi.advanceTimersByTime(500);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+      expect(lastFrame()).toContain('Waiting for authorization...');
+
+      // Advance by another 500ms to reset dots
+      vi.advanceTimersByTime(500);
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+      expect(lastFrame()).toContain('Waiting for authorization');
+    });
+  });
+
+  describe('QR Code functionality', () => {
+    it('should generate QR code when deviceAuth is provided', async () => {
+      const qrcode = await import('qrcode-terminal');
+      const mockGenerate = vi.mocked(qrcode.default.generate);
+
+      mockGenerate.mockImplementation((url, options, callback) => {
+        callback!('Mock QR Code Data');
+      });
+
+      render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      expect(mockGenerate).toHaveBeenCalledWith(
+        mockDeviceAuth.verification_uri_complete,
+        { small: true },
+        expect.any(Function),
+      );
+    });
+
+    it('should display QR code in Static component when available', async () => {
+      const qrcode = await import('qrcode-terminal');
+      const mockGenerate = vi.mocked(qrcode.default.generate);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let qrCallback: any = null;
+      mockGenerate.mockImplementation((url, options, callback) => {
+        qrCallback = callback;
+      });
+
+      const { lastFrame, rerender } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Manually trigger the QR code callback
+      if (qrCallback && typeof qrCallback === 'function') {
+        qrCallback('Mock QR Code Data');
+      }
+
+      rerender(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      const output = lastFrame();
+      expect(output).toContain('Or scan the QR code below:');
+      expect(output).toContain('Mock QR Code Data');
+    });
+
+    it('should handle QR code generation errors gracefully', async () => {
+      const qrcode = await import('qrcode-terminal');
+      const mockGenerate = vi.mocked(qrcode.default.generate);
+      const consoleErrorSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      mockGenerate.mockImplementation(() => {
+        throw new Error('QR Code generation failed');
+      });
+
+      const { lastFrame } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Should not crash and should not show QR code section since QR generation failed
+      const output = lastFrame();
+      expect(output).not.toContain('Or scan the QR code below:');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Failed to generate QR code:',
+        expect.any(Error),
+      );
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should not generate QR code when deviceAuth is null', async () => {
+      const qrcode = await import('qrcode-terminal');
+      const mockGenerate = vi.mocked(qrcode.default.generate);
+
+      render(
+        <QwenOAuthProgress onTimeout={mockOnTimeout} onCancel={mockOnCancel} />,
+      );
+
+      expect(mockGenerate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('User interactions', () => {
+    it('should call onCancel when ESC key is pressed', () => {
+      const { stdin } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Simulate ESC key press
+      stdin.write('\u001b'); // ESC character
+
+      expect(mockOnCancel).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call onCancel when ESC is pressed in loading state', () => {
+      const { stdin } = render(
+        <QwenOAuthProgress onTimeout={mockOnTimeout} onCancel={mockOnCancel} />,
+      );
+
+      // Simulate ESC key press
+      stdin.write('\u001b'); // ESC character
+
+      expect(mockOnCancel).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not call onCancel for other key presses', () => {
+      const { stdin } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Simulate other key presses
+      stdin.write('a');
+      stdin.write('\r'); // Enter
+      stdin.write(' '); // Space
+
+      expect(mockOnCancel).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Props changes', () => {
+    it('should display initial timer value from deviceAuth', () => {
+      const deviceAuthWith10Min: DeviceAuthorizationInfo = {
+        ...mockDeviceAuth,
+        expires_in: 600, // 10 minutes
+      };
+
+      const { lastFrame } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={deviceAuthWith10Min}
+        />,
+      );
+
+      expect(lastFrame()).toContain('Time remaining: 10:00');
+    });
+
+    it('should reset to loading state when deviceAuth becomes null', () => {
+      const { rerender, lastFrame } = render(
+        <QwenOAuthProgress
+          onTimeout={mockOnTimeout}
+          onCancel={mockOnCancel}
+          deviceAuth={mockDeviceAuth}
+        />,
+      );
+
+      // Initially shows waiting for authorization
+      expect(lastFrame()).toContain('Waiting for authorization');
+
+      rerender(
+        <QwenOAuthProgress onTimeout={mockOnTimeout} onCancel={mockOnCancel} />,
+      );
+
+      expect(lastFrame()).toContain('Waiting for Qwen OAuth authentication...');
+      expect(lastFrame()).not.toContain('Waiting for authorization');
+    });
+  });
+
+  describe('Timeout state', () => {
+    it('should render timeout state when authStatus is timeout', () => {
+      const { lastFrame } = renderComponent({
+        authStatus: 'timeout',
+        authMessage: 'Custom timeout message',
+      });
+
+      const output = lastFrame();
+      expect(output).toContain('Qwen OAuth Authentication Timeout');
+      expect(output).toContain('Custom timeout message');
+      expect(output).toContain(
+        'Press any key to return to authentication type selection.',
+      );
+    });
+
+    it('should render default timeout message when no authMessage provided', () => {
+      const { lastFrame } = renderComponent({
+        authStatus: 'timeout',
+      });
+
+      const output = lastFrame();
+      expect(output).toContain('Qwen OAuth Authentication Timeout');
+      expect(output).toContain(
+        'OAuth token expired (over 300 seconds). Please select authentication method again.',
+      );
+    });
+
+    it('should call onCancel for any key press in timeout state', () => {
+      const { stdin } = renderComponent({
+        authStatus: 'timeout',
+      });
+
+      // Simulate any key press
+      stdin.write('a');
+      expect(mockOnCancel).toHaveBeenCalledTimes(1);
+
+      // Reset mock and try enter key
+      mockOnCancel.mockClear();
+      stdin.write('\r');
+      expect(mockOnCancel).toHaveBeenCalledTimes(1);
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/QwenOAuthProgress.tsx

@@ -0,0 +1,267 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useState, useEffect, useMemo } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import Link from 'ink-link';
+import qrcode from 'qrcode-terminal';
+import { Colors } from '../colors.js';
+import { DeviceAuthorizationInfo } from '../hooks/useQwenAuth.js';
+
+interface QwenOAuthProgressProps {
+  onTimeout: () => void;
+  onCancel: () => void;
+  deviceAuth?: DeviceAuthorizationInfo;
+  authStatus?:
+    | 'idle'
+    | 'polling'
+    | 'success'
+    | 'error'
+    | 'timeout'
+    | 'rate_limit';
+  authMessage?: string | null;
+}
+
+/**
+ * Static QR Code Display Component
+ * Renders the QR code and URL once and doesn't re-render unless the URL changes
+ */
+function QrCodeDisplay({
+  verificationUrl,
+  qrCodeData,
+}: {
+  verificationUrl: string;
+  qrCodeData: string | null;
+}): React.JSX.Element | null {
+  if (!qrCodeData) {
+    return null;
+  }
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.AccentBlue}
+      flexDirection="column"
+      padding={1}
+      width="100%"
+    >
+      <Text bold color={Colors.AccentBlue}>
+        Qwen OAuth Authentication
+      </Text>
+
+      <Box marginTop={1}>
+        <Text>Please visit this URL to authorize:</Text>
+      </Box>
+
+      <Link url={verificationUrl} fallback={false}>
+        <Text color={Colors.AccentGreen} bold>
+          {verificationUrl}
+        </Text>
+      </Link>
+
+      <Box marginTop={1}>
+        <Text>Or scan the QR code below:</Text>
+      </Box>
+
+      <Box marginTop={1}>
+        <Text>{qrCodeData}</Text>
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * Dynamic Status Display Component
+ * Shows the loading spinner, timer, and status messages
+ */
+function StatusDisplay({
+  timeRemaining,
+  dots,
+}: {
+  timeRemaining: number;
+  dots: string;
+}): React.JSX.Element {
+  const formatTime = (seconds: number): string => {
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+  };
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.AccentBlue}
+      flexDirection="column"
+      padding={1}
+      width="100%"
+    >
+      <Box marginTop={1}>
+        <Text>
+          <Spinner type="dots" /> Waiting for authorization{dots}
+        </Text>
+      </Box>
+
+      <Box marginTop={1} justifyContent="space-between">
+        <Text color={Colors.Gray}>
+          Time remaining: {formatTime(timeRemaining)}
+        </Text>
+        <Text color={Colors.AccentPurple}>(Press ESC to cancel)</Text>
+      </Box>
+    </Box>
+  );
+}
+
+export function QwenOAuthProgress({
+  onTimeout,
+  onCancel,
+  deviceAuth,
+  authStatus,
+  authMessage,
+}: QwenOAuthProgressProps): React.JSX.Element {
+  const defaultTimeout = deviceAuth?.expires_in || 300; // Default 5 minutes
+  const [timeRemaining, setTimeRemaining] = useState<number>(defaultTimeout);
+  const [dots, setDots] = useState<string>('');
+  const [qrCodeData, setQrCodeData] = useState<string | null>(null);
+
+  useInput((input, key) => {
+    if (authStatus === 'timeout') {
+      // Any key press in timeout state should trigger cancel to return to auth dialog
+      onCancel();
+    } else if (key.escape) {
+      onCancel();
+    }
+  });
+
+  // Generate QR code once when device auth is available
+  useEffect(() => {
+    if (!deviceAuth?.verification_uri_complete) {
+      return;
+    }
+
+    const generateQR = () => {
+      try {
+        qrcode.generate(
+          deviceAuth.verification_uri_complete,
+          { small: true },
+          (qrcode: string) => {
+            setQrCodeData(qrcode);
+          },
+        );
+      } catch (error) {
+        console.error('Failed to generate QR code:', error);
+        setQrCodeData(null);
+      }
+    };
+
+    generateQR();
+  }, [deviceAuth?.verification_uri_complete]);
+
+  // Countdown timer
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setTimeRemaining((prev) => {
+        if (prev <= 1) {
+          onTimeout();
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1000);
+
+    return () => clearInterval(timer);
+  }, [onTimeout]);
+
+  // Animated dots
+  useEffect(() => {
+    const dotsTimer = setInterval(() => {
+      setDots((prev) => {
+        if (prev.length >= 3) return '';
+        return prev + '.';
+      });
+    }, 500);
+
+    return () => clearInterval(dotsTimer);
+  }, []);
+
+  // Memoize the QR code display to prevent unnecessary re-renders
+  const qrCodeDisplay = useMemo(() => {
+    if (!deviceAuth?.verification_uri_complete) return null;
+
+    return (
+      <QrCodeDisplay
+        verificationUrl={deviceAuth.verification_uri_complete}
+        qrCodeData={qrCodeData}
+      />
+    );
+  }, [deviceAuth?.verification_uri_complete, qrCodeData]);
+
+  // Handle timeout state
+  if (authStatus === 'timeout') {
+    return (
+      <Box
+        borderStyle="round"
+        borderColor={Colors.AccentRed}
+        flexDirection="column"
+        padding={1}
+        width="100%"
+      >
+        <Text bold color={Colors.AccentRed}>
+          Qwen OAuth Authentication Timeout
+        </Text>
+
+        <Box marginTop={1}>
+          <Text>
+            {authMessage ||
+              `OAuth token expired (over ${defaultTimeout} seconds). Please select authentication method again.`}
+          </Text>
+        </Box>
+
+        <Box marginTop={1}>
+          <Text color={Colors.Gray}>
+            Press any key to return to authentication type selection.
+          </Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  // Show loading state when no device auth is available yet
+  if (!deviceAuth) {
+    return (
+      <Box
+        borderStyle="round"
+        borderColor={Colors.Gray}
+        flexDirection="column"
+        padding={1}
+        width="100%"
+      >
+        <Box>
+          <Text>
+            <Spinner type="dots" /> Waiting for Qwen OAuth authentication...
+          </Text>
+        </Box>
+        <Box marginTop={1} justifyContent="space-between">
+          <Text color={Colors.Gray}>
+            Time remaining: {Math.floor(timeRemaining / 60)}:
+            {(timeRemaining % 60).toString().padStart(2, '0')}
+          </Text>
+          <Text color={Colors.AccentPurple}>(Press ESC to cancel)</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" width="100%">
+      {/* Static QR Code Display */}
+      {qrCodeDisplay}
+
+      {/* Dynamic Status Display */}
+      <StatusDisplay timeRemaining={timeRemaining} dots={dots} />
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/SessionSummaryDisplay.test.tsx

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { SessionSummaryDisplay } from './SessionSummaryDisplay.js';
+import * as SessionContext from '../contexts/SessionContext.js';
+import { SessionMetrics } from '../contexts/SessionContext.js';
+
+vi.mock('../contexts/SessionContext.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof SessionContext>();
+  return {
+    ...actual,
+    useSessionStats: vi.fn(),
+  };
+});
+
+const useSessionStatsMock = vi.mocked(SessionContext.useSessionStats);
+
+const renderWithMockedStats = (metrics: SessionMetrics) => {
+  useSessionStatsMock.mockReturnValue({
+    stats: {
+      sessionStartTime: new Date(),
+      metrics,
+      lastPromptTokenCount: 0,
+      promptCount: 5,
+    },
+
+    getPromptCount: () => 5,
+    startNewPrompt: vi.fn(),
+  });
+
+  return render(<SessionSummaryDisplay duration="1h 23m 45s" />);
+};
+
+describe('<SessionSummaryDisplay />', () => {
+  it('renders the summary display with a title', () => {
+    const metrics: SessionMetrics = {
+      models: {
+        'gemini-2.5-pro': {
+          api: { totalRequests: 10, totalErrors: 1, totalLatencyMs: 50234 },
+          tokens: {
+            prompt: 1000,
+            candidates: 2000,
+            total: 3500,
+            cached: 500,
+            thoughts: 300,
+            tool: 200,
+          },
+        },
+      },
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 42,
+        totalLinesRemoved: 15,
+      },
+    };
+
+    const { lastFrame } = renderWithMockedStats(metrics);
+    const output = lastFrame();
+
+    expect(output).toContain('Agent powering down. Goodbye!');
+    expect(output).toMatchSnapshot();
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/SessionSummaryDisplay.tsx

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { StatsDisplay } from './StatsDisplay.js';
+
+interface SessionSummaryDisplayProps {
+  duration: string;
+}
+
+export const SessionSummaryDisplay: React.FC<SessionSummaryDisplayProps> = ({
+  duration,
+}) => (
+  <StatsDisplay title="Agent powering down. Goodbye!" duration={duration} />
+);

projects/ui/qwen-code/packages/cli/src/ui/components/SettingsDialog.test.tsx

@@ -0,0 +1,865 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ *
+ *
+ * This test suite covers:
+ * - Initial rendering and display state
+ * - Keyboard navigation (arrows, vim keys, Tab)
+ * - Settings toggling (Enter, Space)
+ * - Focus section switching between settings and scope selector
+ * - Scope selection and settings persistence across scopes
+ * - Restart-required vs immediate settings behavior
+ * - VimModeContext integration
+ * - Complex user interaction workflows
+ * - Error handling and edge cases
+ * - Display values for inherited and overridden settings
+ *
+ */
+
+import { render } from 'ink-testing-library';
+import { waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SettingsDialog } from './SettingsDialog.js';
+import { LoadedSettings } from '../../config/settings.js';
+import { VimModeProvider } from '../contexts/VimModeContext.js';
+
+// Mock the VimModeContext
+const mockToggleVimEnabled = vi.fn();
+const mockSetVimMode = vi.fn();
+
+vi.mock('../contexts/VimModeContext.js', async () => {
+  const actual = await vi.importActual('../contexts/VimModeContext.js');
+  return {
+    ...actual,
+    useVimMode: () => ({
+      vimEnabled: false,
+      vimMode: 'INSERT' as const,
+      toggleVimEnabled: mockToggleVimEnabled,
+      setVimMode: mockSetVimMode,
+    }),
+  };
+});
+
+vi.mock('../../utils/settingsUtils.js', async () => {
+  const actual = await vi.importActual('../../utils/settingsUtils.js');
+  return {
+    ...actual,
+    saveModifiedSettings: vi.fn(),
+  };
+});
+
+// Mock the useKeypress hook to avoid context issues
+interface Key {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  paste: boolean;
+  sequence: string;
+}
+
+// Variables for keypress simulation (not currently used)
+// let currentKeypressHandler: ((key: Key) => void) | null = null;
+// let isKeypressActive = false;
+
+vi.mock('../hooks/useKeypress.js', () => ({
+  useKeypress: vi.fn(
+    (_handler: (key: Key) => void, _options: { isActive: boolean }) => {
+      // Mock implementation - simplified for test stability
+    },
+  ),
+}));
+
+// Helper function to simulate key presses (commented out for now)
+// const simulateKeyPress = async (keyData: Partial<Key> & { name: string }) => {
+//   if (currentKeypressHandler) {
+//     const key: Key = {
+//       ctrl: false,
+//       meta: false,
+//       shift: false,
+//       paste: false,
+//       sequence: keyData.sequence || keyData.name,
+//       ...keyData,
+//     };
+//     currentKeypressHandler(key);
+//     // Allow React to process the state update
+//     await new Promise(resolve => setTimeout(resolve, 10));
+//   }
+// };
+
+// Mock console.log to avoid noise in tests
+// const originalConsoleLog = console.log;
+// const originalConsoleError = console.error;
+
+describe('SettingsDialog', () => {
+  const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset keypress mock state (variables are commented out)
+    // currentKeypressHandler = null;
+    // isKeypressActive = false;
+    // console.log = vi.fn();
+    // console.error = vi.fn();
+    mockToggleVimEnabled.mockResolvedValue(true);
+  });
+
+  afterEach(() => {
+    // Reset keypress mock state (variables are commented out)
+    // currentKeypressHandler = null;
+    // isKeypressActive = false;
+    // console.log = originalConsoleLog;
+    // console.error = originalConsoleError;
+  });
+
+  const createMockSettings = (
+    userSettings = {},
+    systemSettings = {},
+    workspaceSettings = {},
+  ) =>
+    new LoadedSettings(
+      {
+        settings: { customThemes: {}, mcpServers: {}, ...systemSettings },
+        path: '/system/settings.json',
+      },
+      {
+        settings: {
+          customThemes: {},
+          mcpServers: {},
+          ...userSettings,
+        },
+        path: '/user/settings.json',
+      },
+      {
+        settings: { customThemes: {}, mcpServers: {}, ...workspaceSettings },
+        path: '/workspace/settings.json',
+      },
+      [],
+    );
+
+  describe('Initial Rendering', () => {
+    it('should render the settings dialog with default state', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      expect(output).toContain('Settings');
+      expect(output).toContain('Apply To');
+      expect(output).toContain('Use Enter to select, Tab to change focus');
+    });
+
+    it('should show settings list with default values', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should show some default settings
+      expect(output).toContain('●'); // Active indicator
+    });
+
+    it('should highlight first setting by default', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // First item should be highlighted with green color and active indicator
+      expect(output).toContain('●');
+    });
+  });
+
+  describe('Settings Navigation', () => {
+    it('should navigate down with arrow key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press down arrow
+      stdin.write('\u001B[B'); // Down arrow
+      await wait();
+
+      // The active index should have changed (tested indirectly through behavior)
+      unmount();
+    });
+
+    it('should navigate up with arrow key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // First go down, then up
+      stdin.write('\u001B[B'); // Down arrow
+      await wait();
+      stdin.write('\u001B[A'); // Up arrow
+      await wait();
+
+      unmount();
+    });
+
+    it('should navigate with vim keys (j/k)', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate with vim keys
+      stdin.write('j'); // Down
+      await wait();
+      stdin.write('k'); // Up
+      await wait();
+
+      unmount();
+    });
+
+    it('should not navigate beyond bounds', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to go up from first item
+      stdin.write('\u001B[A'); // Up arrow
+      await wait();
+
+      // Should still be on first item
+      unmount();
+    });
+  });
+
+  describe('Settings Toggling', () => {
+    it('should toggle setting with Enter key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Enter to toggle current setting
+      stdin.write('\u000D'); // Enter key
+      await wait();
+
+      unmount();
+    });
+
+    it('should toggle setting with Space key', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Space to toggle current setting
+      stdin.write(' '); // Space key
+      await wait();
+
+      unmount();
+    });
+
+    it('should handle vim mode setting specially', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate to vim mode setting and toggle it
+      // This would require knowing the exact position, so we'll just test that the mock is called
+      stdin.write('\u000D'); // Enter key
+      await wait();
+
+      // The mock should potentially be called if vim mode was toggled
+      unmount();
+    });
+  });
+
+  describe('Scope Selection', () => {
+    it('should switch between scopes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Switch to scope focus
+      stdin.write('\t'); // Tab key
+      await wait();
+
+      // Select different scope (numbers 1-3 typically available)
+      stdin.write('2'); // Select second scope option
+      await wait();
+
+      unmount();
+    });
+
+    it('should reset to settings focus when scope is selected', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Wait for initial render
+      await waitFor(() => {
+        expect(lastFrame()).toContain('Hide Window Title');
+      });
+
+      // The UI should show the settings section is active and scope section is inactive
+      expect(lastFrame()).toContain('● Hide Window Title'); // Settings section active
+      expect(lastFrame()).toContain('  Apply To'); // Scope section inactive
+
+      // This test validates the initial state - scope selection behavior
+      // is complex due to keypress handling, so we focus on state validation
+
+      unmount();
+    });
+  });
+
+  describe('Restart Prompt', () => {
+    it('should show restart prompt for restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // This test would need to trigger a restart-required setting change
+      // The exact steps depend on which settings require restart
+      await wait();
+
+      unmount();
+    });
+
+    it('should handle restart request when r is pressed', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // Press 'r' key (this would only work if restart prompt is showing)
+      stdin.write('r');
+      await wait();
+
+      // If restart prompt was showing, onRestartRequest should be called
+      unmount();
+    });
+  });
+
+  describe('Escape Key Behavior', () => {
+    it('should call onSelect with undefined when Escape is pressed', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Wait for initial render
+      await waitFor(() => {
+        expect(lastFrame()).toContain('Hide Window Title');
+      });
+
+      // Verify the dialog is rendered properly
+      expect(lastFrame()).toContain('Settings');
+      expect(lastFrame()).toContain('Apply To');
+
+      // This test validates rendering - escape key behavior depends on complex
+      // keypress handling that's difficult to test reliably in this environment
+
+      unmount();
+    });
+  });
+
+  describe('Settings Persistence', () => {
+    it('should persist settings across scope changes', async () => {
+      const settings = createMockSettings({ vimMode: true });
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Switch to scope selector
+      stdin.write('\t'); // Tab
+      await wait();
+
+      // Change scope
+      stdin.write('2'); // Select workspace scope
+      await wait();
+
+      // Settings should be reloaded for new scope
+      unmount();
+    });
+
+    it('should show different values for different scopes', () => {
+      const settings = createMockSettings(
+        { vimMode: true }, // User settings
+        { vimMode: false }, // System settings
+        { autoUpdate: false }, // Workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Should show user scope values initially
+      const output = lastFrame();
+      expect(output).toContain('Settings');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle vim mode toggle errors gracefully', async () => {
+      mockToggleVimEnabled.mockRejectedValue(new Error('Toggle failed'));
+
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to toggle a setting (this might trigger vim mode toggle)
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Should not crash
+      unmount();
+    });
+  });
+
+  describe('Complex State Management', () => {
+    it('should track modified settings correctly', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle a setting
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Toggle another setting
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Should track multiple modified settings
+      unmount();
+    });
+
+    it('should handle scrolling when there are many settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Navigate down many times to test scrolling
+      for (let i = 0; i < 10; i++) {
+        stdin.write('\u001B[B'); // Down arrow
+        await wait(10);
+      }
+
+      unmount();
+    });
+  });
+
+  describe('VimMode Integration', () => {
+    it('should sync with VimModeContext when vim mode is toggled', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <VimModeProvider settings={settings}>
+          <SettingsDialog settings={settings} onSelect={onSelect} />
+        </VimModeProvider>,
+      );
+
+      // Navigate to and toggle vim mode setting
+      // This would require knowing the exact position of vim mode setting
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      unmount();
+    });
+  });
+
+  describe('Specific Settings Behavior', () => {
+    it('should show correct display values for settings with different states', () => {
+      const settings = createMockSettings(
+        { vimMode: true, hideTips: false }, // User settings
+        { hideWindowTitle: true }, // System settings
+        { ideMode: false }, // Workspace settings
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should contain settings labels
+      expect(output).toContain('Settings');
+    });
+
+    it('should handle immediate settings save for non-restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle a non-restart-required setting (like hideTips)
+      stdin.write('\u000D'); // Enter - toggle current setting
+      await wait();
+
+      // Should save immediately without showing restart prompt
+      unmount();
+    });
+
+    it('should show restart prompt for restart-required settings', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // This test would need to navigate to a specific restart-required setting
+      // Since we can't easily target specific settings, we test the general behavior
+      await wait();
+
+      // Should not show restart prompt initially
+      expect(lastFrame()).not.toContain(
+        'To see changes, Gemini CLI must be restarted',
+      );
+
+      unmount();
+    });
+
+    it('should clear restart prompt when switching scopes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Restart prompt should be cleared when switching scopes
+      unmount();
+    });
+  });
+
+  describe('Settings Display Values', () => {
+    it('should show correct values for inherited settings', () => {
+      const settings = createMockSettings(
+        {},
+        { vimMode: true, hideWindowTitle: false }, // System settings
+        {},
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Settings should show inherited values
+      expect(output).toContain('Settings');
+    });
+
+    it('should show override indicator for overridden settings', () => {
+      const settings = createMockSettings(
+        { vimMode: false }, // User overrides
+        { vimMode: true }, // System default
+        {},
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      const output = lastFrame();
+      // Should show settings with override indicators
+      expect(output).toContain('Settings');
+    });
+  });
+
+  describe('Keyboard Shortcuts Edge Cases', () => {
+    it('should handle rapid key presses gracefully', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Rapid navigation
+      for (let i = 0; i < 5; i++) {
+        stdin.write('\u001B[B'); // Down arrow
+        stdin.write('\u001B[A'); // Up arrow
+      }
+      await wait(100);
+
+      // Should not crash
+      unmount();
+    });
+
+    it('should handle Ctrl+C to reset current setting to default', async () => {
+      const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Ctrl+C to reset current setting to default
+      stdin.write('\u0003'); // Ctrl+C
+      await wait();
+
+      // Should reset the current setting to its default value
+      unmount();
+    });
+
+    it('should handle Ctrl+L to reset current setting to default', async () => {
+      const settings = createMockSettings({ vimMode: true }); // Start with vimMode enabled
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Press Ctrl+L to reset current setting to default
+      stdin.write('\u000C'); // Ctrl+L
+      await wait();
+
+      // Should reset the current setting to its default value
+      unmount();
+    });
+
+    it('should handle navigation when only one setting exists', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Try to navigate when potentially at bounds
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u001B[A'); // Up
+      await wait();
+
+      unmount();
+    });
+
+    it('should properly handle Tab navigation between sections', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Wait for initial render
+      await waitFor(() => {
+        expect(lastFrame()).toContain('Hide Window Title');
+      });
+
+      // Verify initial state: settings section active, scope section inactive
+      expect(lastFrame()).toContain('● Hide Window Title'); // Settings section active
+      expect(lastFrame()).toContain('  Apply To'); // Scope section inactive
+
+      // This test validates the rendered UI structure for tab navigation
+      // Actual tab behavior testing is complex due to keypress handling
+
+      unmount();
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should handle malformed settings gracefully', () => {
+      // Create settings with potentially problematic values
+      const settings = createMockSettings(
+        { vimMode: null as unknown as boolean }, // Invalid value
+        {},
+        {},
+      );
+      const onSelect = vi.fn();
+
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Should still render without crashing
+      expect(lastFrame()).toContain('Settings');
+    });
+
+    it('should handle missing setting definitions gracefully', () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      // Should not crash even if some settings are missing definitions
+      const { lastFrame } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      expect(lastFrame()).toContain('Settings');
+    });
+  });
+
+  describe('Complex User Interactions', () => {
+    it('should handle complete user workflow: navigate, toggle, change scope, exit', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { lastFrame, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Wait for initial render
+      await waitFor(() => {
+        expect(lastFrame()).toContain('Hide Window Title');
+      });
+
+      // Verify the complete UI is rendered with all necessary sections
+      expect(lastFrame()).toContain('Settings'); // Title
+      expect(lastFrame()).toContain('● Hide Window Title'); // Active setting
+      expect(lastFrame()).toContain('Apply To'); // Scope section
+      expect(lastFrame()).toContain('1. User Settings'); // Scope options
+      expect(lastFrame()).toContain(
+        '(Use Enter to select, Tab to change focus)',
+      ); // Help text
+
+      // This test validates the complete UI structure is available for user workflow
+      // Individual interactions are tested in focused unit tests
+
+      unmount();
+    });
+
+    it('should allow changing multiple settings without losing pending changes', async () => {
+      const settings = createMockSettings();
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Toggle first setting (should require restart)
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Navigate to next setting and toggle it (should not require restart - e.g., vimMode)
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // Navigate to another setting and toggle it (should also require restart)
+      stdin.write('\u001B[B'); // Down
+      await wait();
+      stdin.write('\u000D'); // Enter
+      await wait();
+
+      // The test verifies that all changes are preserved and the dialog still works
+      // This tests the fix for the bug where changing one setting would reset all pending changes
+      unmount();
+    });
+
+    it('should maintain state consistency during complex interactions', async () => {
+      const settings = createMockSettings({ vimMode: true });
+      const onSelect = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog settings={settings} onSelect={onSelect} />,
+      );
+
+      // Multiple scope changes
+      stdin.write('\t'); // Tab to scope
+      await wait();
+      stdin.write('2'); // Workspace
+      await wait();
+      stdin.write('\t'); // Tab to settings
+      await wait();
+      stdin.write('\t'); // Tab to scope
+      await wait();
+      stdin.write('1'); // User
+      await wait();
+
+      // Should maintain consistent state
+      unmount();
+    });
+
+    it('should handle restart workflow correctly', async () => {
+      const settings = createMockSettings();
+      const onRestartRequest = vi.fn();
+
+      const { stdin, unmount } = render(
+        <SettingsDialog
+          settings={settings}
+          onSelect={() => {}}
+          onRestartRequest={onRestartRequest}
+        />,
+      );
+
+      // This would test the restart workflow if we could trigger it
+      stdin.write('r'); // Try restart key
+      await wait();
+
+      // Without restart prompt showing, this should have no effect
+      expect(onRestartRequest).not.toHaveBeenCalled();
+
+      unmount();
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/SettingsDialog.tsx

@@ -0,0 +1,753 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+import {
+  LoadedSettings,
+  SettingScope,
+  Settings,
+} from '../../config/settings.js';
+import {
+  getScopeItems,
+  getScopeMessageForSetting,
+} from '../../utils/dialogScopeUtils.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import {
+  getDialogSettingKeys,
+  getSettingValue,
+  setPendingSettingValue,
+  getDisplayValue,
+  hasRestartRequiredSettings,
+  saveModifiedSettings,
+  getSettingDefinition,
+  isDefaultValue,
+  requiresRestart,
+  getRestartRequiredFromModified,
+  getDefaultValue,
+  setPendingSettingValueAny,
+  getNestedValue,
+} from '../../utils/settingsUtils.js';
+import { useVimMode } from '../contexts/VimModeContext.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import chalk from 'chalk';
+import { cpSlice, cpLen } from '../utils/textUtils.js';
+
+interface SettingsDialogProps {
+  settings: LoadedSettings;
+  onSelect: (settingName: string | undefined, scope: SettingScope) => void;
+  onRestartRequest?: () => void;
+}
+
+const maxItemsToShow = 8;
+
+export function SettingsDialog({
+  settings,
+  onSelect,
+  onRestartRequest,
+}: SettingsDialogProps): React.JSX.Element {
+  // Get vim mode context to sync vim mode changes
+  const { vimEnabled, toggleVimEnabled } = useVimMode();
+
+  // Focus state: 'settings' or 'scope'
+  const [focusSection, setFocusSection] = useState<'settings' | 'scope'>(
+    'settings',
+  );
+  // Scope selector state (User by default)
+  const [selectedScope, setSelectedScope] = useState<SettingScope>(
+    SettingScope.User,
+  );
+  // Active indices
+  const [activeSettingIndex, setActiveSettingIndex] = useState(0);
+  // Scroll offset for settings
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [showRestartPrompt, setShowRestartPrompt] = useState(false);
+
+  // Local pending settings state for the selected scope
+  const [pendingSettings, setPendingSettings] = useState<Settings>(() =>
+    // Deep clone to avoid mutation
+    structuredClone(settings.forScope(selectedScope).settings),
+  );
+
+  // Track which settings have been modified by the user
+  const [modifiedSettings, setModifiedSettings] = useState<Set<string>>(
+    new Set(),
+  );
+
+  // Preserve pending changes across scope switches (boolean and number values only)
+  type PendingValue = boolean | number;
+  const [globalPendingChanges, setGlobalPendingChanges] = useState<
+    Map<string, PendingValue>
+  >(new Map());
+
+  // Track restart-required settings across scope changes
+  const [_restartRequiredSettings, setRestartRequiredSettings] = useState<
+    Set<string>
+  >(new Set());
+
+  useEffect(() => {
+    // Base settings for selected scope
+    let updated = structuredClone(settings.forScope(selectedScope).settings);
+    // Overlay globally pending (unsaved) changes so user sees their modifications in any scope
+    const newModified = new Set<string>();
+    const newRestartRequired = new Set<string>();
+    for (const [key, value] of globalPendingChanges.entries()) {
+      const def = getSettingDefinition(key);
+      if (def?.type === 'boolean' && typeof value === 'boolean') {
+        updated = setPendingSettingValue(key, value, updated);
+      } else if (def?.type === 'number' && typeof value === 'number') {
+        updated = setPendingSettingValueAny(key, value, updated);
+      }
+      newModified.add(key);
+      if (requiresRestart(key)) newRestartRequired.add(key);
+    }
+    setPendingSettings(updated);
+    setModifiedSettings(newModified);
+    setRestartRequiredSettings(newRestartRequired);
+    setShowRestartPrompt(newRestartRequired.size > 0);
+  }, [selectedScope, settings, globalPendingChanges]);
+
+  const generateSettingsItems = () => {
+    const settingKeys = getDialogSettingKeys();
+
+    return settingKeys.map((key: string) => {
+      const definition = getSettingDefinition(key);
+
+      return {
+        label: definition?.label || key,
+        value: key,
+        type: definition?.type,
+        toggle: () => {
+          if (definition?.type !== 'boolean') {
+            // For non-boolean (e.g., number) items, toggle will be handled via edit mode.
+            return;
+          }
+          const currentValue = getSettingValue(key, pendingSettings, {});
+          const newValue = !currentValue;
+
+          setPendingSettings((prev) =>
+            setPendingSettingValue(key, newValue, prev),
+          );
+
+          if (!requiresRestart(key)) {
+            const immediateSettings = new Set([key]);
+            const immediateSettingsObject = setPendingSettingValueAny(
+              key,
+              newValue,
+              {} as Settings,
+            );
+
+            console.log(
+              `[DEBUG SettingsDialog] Saving ${key} immediately with value:`,
+              newValue,
+            );
+            saveModifiedSettings(
+              immediateSettings,
+              immediateSettingsObject,
+              settings,
+              selectedScope,
+            );
+
+            // Special handling for vim mode to sync with VimModeContext
+            if (key === 'vimMode' && newValue !== vimEnabled) {
+              // Call toggleVimEnabled to sync the VimModeContext local state
+              toggleVimEnabled().catch((error) => {
+                console.error('Failed to toggle vim mode:', error);
+              });
+            }
+
+            // Remove from modifiedSettings since it's now saved
+            setModifiedSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(key);
+              return updated;
+            });
+
+            // Also remove from restart-required settings if it was there
+            setRestartRequiredSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(key);
+              return updated;
+            });
+
+            // Remove from global pending changes if present
+            setGlobalPendingChanges((prev) => {
+              if (!prev.has(key)) return prev;
+              const next = new Map(prev);
+              next.delete(key);
+              return next;
+            });
+
+            // Refresh pending settings from the saved state
+            setPendingSettings(
+              structuredClone(settings.forScope(selectedScope).settings),
+            );
+          } else {
+            // For restart-required settings, track as modified
+            setModifiedSettings((prev) => {
+              const updated = new Set(prev).add(key);
+              const needsRestart = hasRestartRequiredSettings(updated);
+              console.log(
+                `[DEBUG SettingsDialog] Modified settings:`,
+                Array.from(updated),
+                'Needs restart:',
+                needsRestart,
+              );
+              if (needsRestart) {
+                setShowRestartPrompt(true);
+                setRestartRequiredSettings((prevRestart) =>
+                  new Set(prevRestart).add(key),
+                );
+              }
+              return updated;
+            });
+
+            // Add/update pending change globally so it persists across scopes
+            setGlobalPendingChanges((prev) => {
+              const next = new Map(prev);
+              next.set(key, newValue as PendingValue);
+              return next;
+            });
+          }
+        },
+      };
+    });
+  };
+
+  const items = generateSettingsItems();
+
+  // Number edit state
+  const [editingKey, setEditingKey] = useState<string | null>(null);
+  const [editBuffer, setEditBuffer] = useState<string>('');
+  const [editCursorPos, setEditCursorPos] = useState<number>(0); // Cursor position within edit buffer
+  const [cursorVisible, setCursorVisible] = useState<boolean>(true);
+
+  useEffect(() => {
+    if (!editingKey) {
+      setCursorVisible(true);
+      return;
+    }
+    const id = setInterval(() => setCursorVisible((v) => !v), 500);
+    return () => clearInterval(id);
+  }, [editingKey]);
+
+  const startEditingNumber = (key: string, initial?: string) => {
+    setEditingKey(key);
+    const initialValue = initial ?? '';
+    setEditBuffer(initialValue);
+    setEditCursorPos(cpLen(initialValue)); // Position cursor at end of initial value
+  };
+
+  const commitNumberEdit = (key: string) => {
+    if (editBuffer.trim() === '') {
+      // Nothing entered; cancel edit
+      setEditingKey(null);
+      setEditBuffer('');
+      setEditCursorPos(0);
+      return;
+    }
+    const parsed = Number(editBuffer.trim());
+    if (Number.isNaN(parsed)) {
+      // Invalid number; cancel edit
+      setEditingKey(null);
+      setEditBuffer('');
+      setEditCursorPos(0);
+      return;
+    }
+
+    // Update pending
+    setPendingSettings((prev) => setPendingSettingValueAny(key, parsed, prev));
+
+    if (!requiresRestart(key)) {
+      const immediateSettings = new Set([key]);
+      const immediateSettingsObject = setPendingSettingValueAny(
+        key,
+        parsed,
+        {} as Settings,
+      );
+      saveModifiedSettings(
+        immediateSettings,
+        immediateSettingsObject,
+        settings,
+        selectedScope,
+      );
+
+      // Remove from modified sets if present
+      setModifiedSettings((prev) => {
+        const updated = new Set(prev);
+        updated.delete(key);
+        return updated;
+      });
+      setRestartRequiredSettings((prev) => {
+        const updated = new Set(prev);
+        updated.delete(key);
+        return updated;
+      });
+
+      // Remove from global pending since it's immediately saved
+      setGlobalPendingChanges((prev) => {
+        if (!prev.has(key)) return prev;
+        const next = new Map(prev);
+        next.delete(key);
+        return next;
+      });
+    } else {
+      // Mark as modified and needing restart
+      setModifiedSettings((prev) => {
+        const updated = new Set(prev).add(key);
+        const needsRestart = hasRestartRequiredSettings(updated);
+        if (needsRestart) {
+          setShowRestartPrompt(true);
+          setRestartRequiredSettings((prevRestart) =>
+            new Set(prevRestart).add(key),
+          );
+        }
+        return updated;
+      });
+
+      // Record pending change globally for persistence across scopes
+      setGlobalPendingChanges((prev) => {
+        const next = new Map(prev);
+        next.set(key, parsed as PendingValue);
+        return next;
+      });
+    }
+
+    setEditingKey(null);
+    setEditBuffer('');
+    setEditCursorPos(0);
+  };
+
+  // Scope selector items
+  const scopeItems = getScopeItems();
+
+  const handleScopeHighlight = (scope: SettingScope) => {
+    setSelectedScope(scope);
+  };
+
+  const handleScopeSelect = (scope: SettingScope) => {
+    handleScopeHighlight(scope);
+    setFocusSection('settings');
+  };
+
+  // Scroll logic for settings
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxItemsToShow);
+  // Always show arrows for consistent UI and to indicate circular navigation
+  const showScrollUp = true;
+  const showScrollDown = true;
+
+  useKeypress(
+    (key) => {
+      const { name, ctrl } = key;
+      if (name === 'tab') {
+        setFocusSection((prev) => (prev === 'settings' ? 'scope' : 'settings'));
+      }
+      if (focusSection === 'settings') {
+        // If editing a number, capture numeric input and control keys
+        if (editingKey) {
+          if (key.paste && key.sequence) {
+            const pasted = key.sequence.replace(/[^0-9\-+.]/g, '');
+            if (pasted) {
+              setEditBuffer((b) => {
+                const before = cpSlice(b, 0, editCursorPos);
+                const after = cpSlice(b, editCursorPos);
+                return before + pasted + after;
+              });
+              setEditCursorPos((pos) => pos + cpLen(pasted));
+            }
+            return;
+          }
+          if (name === 'backspace' || name === 'delete') {
+            if (name === 'backspace' && editCursorPos > 0) {
+              setEditBuffer((b) => {
+                const before = cpSlice(b, 0, editCursorPos - 1);
+                const after = cpSlice(b, editCursorPos);
+                return before + after;
+              });
+              setEditCursorPos((pos) => pos - 1);
+            } else if (name === 'delete' && editCursorPos < cpLen(editBuffer)) {
+              setEditBuffer((b) => {
+                const before = cpSlice(b, 0, editCursorPos);
+                const after = cpSlice(b, editCursorPos + 1);
+                return before + after;
+              });
+              // Cursor position stays the same for delete
+            }
+            return;
+          }
+          if (name === 'escape') {
+            commitNumberEdit(editingKey);
+            return;
+          }
+          if (name === 'return') {
+            commitNumberEdit(editingKey);
+            return;
+          }
+          // Allow digits, minus, plus, and dot
+          const ch = key.sequence;
+          if (/[0-9\-+.]/.test(ch)) {
+            setEditBuffer((currentBuffer) => {
+              const beforeCursor = cpSlice(currentBuffer, 0, editCursorPos);
+              const afterCursor = cpSlice(currentBuffer, editCursorPos);
+              return beforeCursor + ch + afterCursor;
+            });
+            setEditCursorPos((pos) => pos + 1);
+            return;
+          }
+          // Arrow key navigation
+          if (name === 'left') {
+            setEditCursorPos((pos) => Math.max(0, pos - 1));
+            return;
+          }
+          if (name === 'right') {
+            setEditCursorPos((pos) => Math.min(cpLen(editBuffer), pos + 1));
+            return;
+          }
+          // Home and End keys
+          if (name === 'home') {
+            setEditCursorPos(0);
+            return;
+          }
+          if (name === 'end') {
+            setEditCursorPos(cpLen(editBuffer));
+            return;
+          }
+          // Block other keys while editing
+          return;
+        }
+        if (name === 'up' || name === 'k') {
+          // If editing, commit first
+          if (editingKey) {
+            commitNumberEdit(editingKey);
+          }
+          const newIndex =
+            activeSettingIndex > 0 ? activeSettingIndex - 1 : items.length - 1;
+          setActiveSettingIndex(newIndex);
+          // Adjust scroll offset for wrap-around
+          if (newIndex === items.length - 1) {
+            setScrollOffset(Math.max(0, items.length - maxItemsToShow));
+          } else if (newIndex < scrollOffset) {
+            setScrollOffset(newIndex);
+          }
+        } else if (name === 'down' || name === 'j') {
+          // If editing, commit first
+          if (editingKey) {
+            commitNumberEdit(editingKey);
+          }
+          const newIndex =
+            activeSettingIndex < items.length - 1 ? activeSettingIndex + 1 : 0;
+          setActiveSettingIndex(newIndex);
+          // Adjust scroll offset for wrap-around
+          if (newIndex === 0) {
+            setScrollOffset(0);
+          } else if (newIndex >= scrollOffset + maxItemsToShow) {
+            setScrollOffset(newIndex - maxItemsToShow + 1);
+          }
+        } else if (name === 'return' || name === 'space') {
+          const currentItem = items[activeSettingIndex];
+          if (currentItem?.type === 'number') {
+            startEditingNumber(currentItem.value);
+          } else {
+            currentItem?.toggle();
+          }
+        } else if (/^[0-9]$/.test(key.sequence || '') && !editingKey) {
+          const currentItem = items[activeSettingIndex];
+          if (currentItem?.type === 'number') {
+            startEditingNumber(currentItem.value, key.sequence);
+          }
+        } else if (ctrl && (name === 'c' || name === 'l')) {
+          // Ctrl+C or Ctrl+L: Clear current setting and reset to default
+          const currentSetting = items[activeSettingIndex];
+          if (currentSetting) {
+            const defaultValue = getDefaultValue(currentSetting.value);
+            const defType = currentSetting.type;
+            if (defType === 'boolean') {
+              const booleanDefaultValue =
+                typeof defaultValue === 'boolean' ? defaultValue : false;
+              setPendingSettings((prev) =>
+                setPendingSettingValue(
+                  currentSetting.value,
+                  booleanDefaultValue,
+                  prev,
+                ),
+              );
+            } else if (defType === 'number') {
+              if (typeof defaultValue === 'number') {
+                setPendingSettings((prev) =>
+                  setPendingSettingValueAny(
+                    currentSetting.value,
+                    defaultValue,
+                    prev,
+                  ),
+                );
+              }
+            }
+
+            // Remove from modified settings since it's now at default
+            setModifiedSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(currentSetting.value);
+              return updated;
+            });
+
+            // Remove from restart-required settings if it was there
+            setRestartRequiredSettings((prev) => {
+              const updated = new Set(prev);
+              updated.delete(currentSetting.value);
+              return updated;
+            });
+
+            // If this setting doesn't require restart, save it immediately
+            if (!requiresRestart(currentSetting.value)) {
+              const immediateSettings = new Set([currentSetting.value]);
+              const toSaveValue =
+                currentSetting.type === 'boolean'
+                  ? typeof defaultValue === 'boolean'
+                    ? defaultValue
+                    : false
+                  : typeof defaultValue === 'number'
+                    ? defaultValue
+                    : undefined;
+              const immediateSettingsObject =
+                toSaveValue !== undefined
+                  ? setPendingSettingValueAny(
+                      currentSetting.value,
+                      toSaveValue,
+                      {} as Settings,
+                    )
+                  : ({} as Settings);
+
+              saveModifiedSettings(
+                immediateSettings,
+                immediateSettingsObject,
+                settings,
+                selectedScope,
+              );
+
+              // Remove from global pending changes if present
+              setGlobalPendingChanges((prev) => {
+                if (!prev.has(currentSetting.value)) return prev;
+                const next = new Map(prev);
+                next.delete(currentSetting.value);
+                return next;
+              });
+            } else {
+              // Track default reset as a pending change if restart required
+              if (
+                (currentSetting.type === 'boolean' &&
+                  typeof defaultValue === 'boolean') ||
+                (currentSetting.type === 'number' &&
+                  typeof defaultValue === 'number')
+              ) {
+                setGlobalPendingChanges((prev) => {
+                  const next = new Map(prev);
+                  next.set(currentSetting.value, defaultValue as PendingValue);
+                  return next;
+                });
+              }
+            }
+          }
+        }
+      }
+      if (showRestartPrompt && name === 'r') {
+        // Only save settings that require restart (non-restart settings were already saved immediately)
+        const restartRequiredSettings =
+          getRestartRequiredFromModified(modifiedSettings);
+        const restartRequiredSet = new Set(restartRequiredSettings);
+
+        if (restartRequiredSet.size > 0) {
+          saveModifiedSettings(
+            restartRequiredSet,
+            pendingSettings,
+            settings,
+            selectedScope,
+          );
+
+          // Remove saved keys from global pending changes
+          setGlobalPendingChanges((prev) => {
+            if (prev.size === 0) return prev;
+            const next = new Map(prev);
+            for (const key of restartRequiredSet) {
+              next.delete(key);
+            }
+            return next;
+          });
+        }
+
+        setShowRestartPrompt(false);
+        setRestartRequiredSettings(new Set()); // Clear restart-required settings
+        if (onRestartRequest) onRestartRequest();
+      }
+      if (name === 'escape') {
+        if (editingKey) {
+          commitNumberEdit(editingKey);
+        } else {
+          onSelect(undefined, selectedScope);
+        }
+      }
+    },
+    { isActive: true },
+  );
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.Gray}
+      flexDirection="row"
+      padding={1}
+      width="100%"
+      height="100%"
+    >
+      <Box flexDirection="column" flexGrow={1}>
+        <Text bold color={Colors.AccentBlue}>
+          Settings
+        </Text>
+        <Box height={1} />
+        {showScrollUp && <Text color={Colors.Gray}>▲</Text>}
+        {visibleItems.map((item, idx) => {
+          const isActive =
+            focusSection === 'settings' &&
+            activeSettingIndex === idx + scrollOffset;
+
+          const scopeSettings = settings.forScope(selectedScope).settings;
+          const mergedSettings = settings.merged;
+
+          let displayValue: string;
+          if (editingKey === item.value) {
+            // Show edit buffer with advanced cursor highlighting
+            if (cursorVisible && editCursorPos < cpLen(editBuffer)) {
+              // Cursor is in the middle or at start of text
+              const beforeCursor = cpSlice(editBuffer, 0, editCursorPos);
+              const atCursor = cpSlice(
+                editBuffer,
+                editCursorPos,
+                editCursorPos + 1,
+              );
+              const afterCursor = cpSlice(editBuffer, editCursorPos + 1);
+              displayValue =
+                beforeCursor + chalk.inverse(atCursor) + afterCursor;
+            } else if (cursorVisible && editCursorPos >= cpLen(editBuffer)) {
+              // Cursor is at the end - show inverted space
+              displayValue = editBuffer + chalk.inverse(' ');
+            } else {
+              // Cursor not visible
+              displayValue = editBuffer;
+            }
+          } else if (item.type === 'number') {
+            // For numbers, get the actual current value from pending settings
+            const path = item.value.split('.');
+            const currentValue = getNestedValue(pendingSettings, path);
+
+            const defaultValue = getDefaultValue(item.value);
+
+            if (currentValue !== undefined && currentValue !== null) {
+              displayValue = String(currentValue);
+            } else {
+              displayValue =
+                defaultValue !== undefined && defaultValue !== null
+                  ? String(defaultValue)
+                  : '';
+            }
+
+            // Add * if value differs from default OR if currently being modified
+            const isModified = modifiedSettings.has(item.value);
+            const effectiveCurrentValue =
+              currentValue !== undefined && currentValue !== null
+                ? currentValue
+                : defaultValue;
+            const isDifferentFromDefault =
+              effectiveCurrentValue !== defaultValue;
+
+            if (isDifferentFromDefault || isModified) {
+              displayValue += '*';
+            }
+          } else {
+            // For booleans and other types, use existing logic
+            displayValue = getDisplayValue(
+              item.value,
+              scopeSettings,
+              mergedSettings,
+              modifiedSettings,
+              pendingSettings,
+            );
+          }
+          const shouldBeGreyedOut = isDefaultValue(item.value, scopeSettings);
+
+          // Generate scope message for this setting
+          const scopeMessage = getScopeMessageForSetting(
+            item.value,
+            selectedScope,
+            settings,
+          );
+
+          return (
+            <React.Fragment key={item.value}>
+              <Box flexDirection="row" alignItems="center">
+                <Box minWidth={2} flexShrink={0}>
+                  <Text color={isActive ? Colors.AccentGreen : Colors.Gray}>
+                    {isActive ? '●' : ''}
+                  </Text>
+                </Box>
+                <Box minWidth={50}>
+                  <Text
+                    color={isActive ? Colors.AccentGreen : Colors.Foreground}
+                  >
+                    {item.label}
+                    {scopeMessage && (
+                      <Text color={Colors.Gray}> {scopeMessage}</Text>
+                    )}
+                  </Text>
+                </Box>
+                <Box minWidth={3} />
+                <Text
+                  color={
+                    isActive
+                      ? Colors.AccentGreen
+                      : shouldBeGreyedOut
+                        ? Colors.Gray
+                        : Colors.Foreground
+                  }
+                >
+                  {displayValue}
+                </Text>
+              </Box>
+              <Box height={1} />
+            </React.Fragment>
+          );
+        })}
+        {showScrollDown && <Text color={Colors.Gray}>▼</Text>}
+
+        <Box height={1} />
+
+        <Box marginTop={1} flexDirection="column">
+          <Text bold={focusSection === 'scope'} wrap="truncate">
+            {focusSection === 'scope' ? '> ' : '  '}Apply To
+          </Text>
+          <RadioButtonSelect
+            items={scopeItems}
+            initialIndex={0}
+            onSelect={handleScopeSelect}
+            onHighlight={handleScopeHighlight}
+            isFocused={focusSection === 'scope'}
+            showNumbers={focusSection === 'scope'}
+          />
+        </Box>
+
+        <Box height={1} />
+        <Text color={Colors.Gray}>
+          (Use Enter to select, Tab to change focus)
+        </Text>
+        {showRestartPrompt && (
+          <Text color={Colors.AccentYellow}>
+            To see changes, Gemini CLI must be restarted. Press r to exit and
+            apply changes now.
+          </Text>
+        )}
+      </Box>
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/ShellConfirmationDialog.test.tsx

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { renderWithProviders } from '../../test-utils/render.js';
+import { describe, it, expect, vi } from 'vitest';
+import { ShellConfirmationDialog } from './ShellConfirmationDialog.js';
+
+describe('ShellConfirmationDialog', () => {
+  const onConfirm = vi.fn();
+
+  const request = {
+    commands: ['ls -la', 'echo "hello"'],
+    onConfirm,
+  };
+
+  it('renders correctly', () => {
+    const { lastFrame } = renderWithProviders(
+      <ShellConfirmationDialog request={request} />,
+    );
+    expect(lastFrame()).toMatchSnapshot();
+  });
+
+  it('calls onConfirm with ProceedOnce when "Yes, allow once" is selected', () => {
+    const { lastFrame } = renderWithProviders(
+      <ShellConfirmationDialog request={request} />,
+    );
+    const select = lastFrame()!.toString();
+    // Simulate selecting the first option
+    // This is a simplified way to test the selection
+    expect(select).toContain('Yes, allow once');
+  });
+
+  it('calls onConfirm with ProceedAlways when "Yes, allow always for this session" is selected', () => {
+    const { lastFrame } = renderWithProviders(
+      <ShellConfirmationDialog request={request} />,
+    );
+    const select = lastFrame()!.toString();
+    // Simulate selecting the second option
+    expect(select).toContain('Yes, allow always for this session');
+  });
+
+  it('calls onConfirm with Cancel when "No (esc)" is selected', () => {
+    const { lastFrame } = renderWithProviders(
+      <ShellConfirmationDialog request={request} />,
+    );
+    const select = lastFrame()!.toString();
+    // Simulate selecting the third option
+    expect(select).toContain('No (esc)');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/ShellConfirmationDialog.tsx

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ToolConfirmationOutcome } from '@qwen-code/qwen-code-core';
+import { Box, Text } from 'ink';
+import React from 'react';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { RenderInline } from '../utils/InlineMarkdownRenderer.js';
+import {
+  RadioButtonSelect,
+  RadioSelectItem,
+} from './shared/RadioButtonSelect.js';
+
+export interface ShellConfirmationRequest {
+  commands: string[];
+  onConfirm: (
+    outcome: ToolConfirmationOutcome,
+    approvedCommands?: string[],
+  ) => void;
+}
+
+export interface ShellConfirmationDialogProps {
+  request: ShellConfirmationRequest;
+}
+
+export const ShellConfirmationDialog: React.FC<
+  ShellConfirmationDialogProps
+> = ({ request }) => {
+  const { commands, onConfirm } = request;
+
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape') {
+        onConfirm(ToolConfirmationOutcome.Cancel);
+      }
+    },
+    { isActive: true },
+  );
+
+  const handleSelect = (item: ToolConfirmationOutcome) => {
+    if (item === ToolConfirmationOutcome.Cancel) {
+      onConfirm(item);
+    } else {
+      // For both ProceedOnce and ProceedAlways, we approve all the
+      // commands that were requested.
+      onConfirm(item, commands);
+    }
+  };
+
+  const options: Array<RadioSelectItem<ToolConfirmationOutcome>> = [
+    {
+      label: 'Yes, allow once',
+      value: ToolConfirmationOutcome.ProceedOnce,
+    },
+    {
+      label: 'Yes, allow always for this session',
+      value: ToolConfirmationOutcome.ProceedAlways,
+    },
+    {
+      label: 'No (esc)',
+      value: ToolConfirmationOutcome.Cancel,
+    },
+  ];
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor={Colors.AccentYellow}
+      padding={1}
+      width="100%"
+      marginLeft={1}
+    >
+      <Box flexDirection="column" marginBottom={1}>
+        <Text bold>Shell Command Execution</Text>
+        <Text>A custom command wants to run the following shell commands:</Text>
+        <Box
+          flexDirection="column"
+          borderStyle="round"
+          borderColor={Colors.Gray}
+          paddingX={1}
+          marginTop={1}
+        >
+          {commands.map((cmd) => (
+            <Text key={cmd} color={Colors.AccentCyan}>
+              <RenderInline text={cmd} />
+            </Text>
+          ))}
+        </Box>
+      </Box>
+
+      <Box marginBottom={1}>
+        <Text>Do you want to proceed?</Text>
+      </Box>
+
+      <RadioButtonSelect items={options} onSelect={handleSelect} isFocused />
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/ShellModeIndicator.tsx

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+
+export const ShellModeIndicator: React.FC = () => (
+  <Box>
+    <Text color={Colors.AccentYellow}>
+      shell mode enabled
+      <Text color={Colors.Gray}> (esc to disable)</Text>
+    </Text>
+  </Box>
+);

projects/ui/qwen-code/packages/cli/src/ui/components/ShowMoreLines.tsx

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text } from 'ink';
+import { useOverflowState } from '../contexts/OverflowContext.js';
+import { useStreamingContext } from '../contexts/StreamingContext.js';
+import { StreamingState } from '../types.js';
+import { Colors } from '../colors.js';
+
+interface ShowMoreLinesProps {
+  constrainHeight: boolean;
+}
+
+export const ShowMoreLines = ({ constrainHeight }: ShowMoreLinesProps) => {
+  const overflowState = useOverflowState();
+  const streamingState = useStreamingContext();
+
+  if (
+    overflowState === undefined ||
+    overflowState.overflowingIds.size === 0 ||
+    !constrainHeight ||
+    !(
+      streamingState === StreamingState.Idle ||
+      streamingState === StreamingState.WaitingForConfirmation
+    )
+  ) {
+    return null;
+  }
+
+  return (
+    <Box>
+      <Text color={Colors.Gray} wrap="truncate">
+        Press ctrl-s to show more lines
+      </Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/StatsDisplay.test.tsx

@@ -0,0 +1,401 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import { StatsDisplay } from './StatsDisplay.js';
+import * as SessionContext from '../contexts/SessionContext.js';
+import { SessionMetrics } from '../contexts/SessionContext.js';
+
+// Mock the context to provide controlled data for testing
+vi.mock('../contexts/SessionContext.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof SessionContext>();
+  return {
+    ...actual,
+    useSessionStats: vi.fn(),
+  };
+});
+
+const useSessionStatsMock = vi.mocked(SessionContext.useSessionStats);
+
+const renderWithMockedStats = (metrics: SessionMetrics) => {
+  useSessionStatsMock.mockReturnValue({
+    stats: {
+      sessionId: 'test-session-id',
+      sessionStartTime: new Date(),
+      metrics,
+      lastPromptTokenCount: 0,
+      promptCount: 5,
+    },
+
+    getPromptCount: () => 5,
+    startNewPrompt: vi.fn(),
+  });
+
+  return render(<StatsDisplay duration="1s" />);
+};
+
+describe('<StatsDisplay />', () => {
+  it('renders only the Performance section in its zero state', () => {
+    const zeroMetrics: SessionMetrics = {
+      models: {},
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+
+    const { lastFrame } = renderWithMockedStats(zeroMetrics);
+    const output = lastFrame();
+
+    expect(output).toContain('Performance');
+    expect(output).toContain('Interaction Summary');
+    expect(output).not.toContain('Efficiency & Optimizations');
+    expect(output).not.toContain('Model'); // The table header
+    expect(output).toMatchSnapshot();
+  });
+
+  it('renders a table with two models correctly', () => {
+    const metrics: SessionMetrics = {
+      models: {
+        'gemini-2.5-pro': {
+          api: { totalRequests: 3, totalErrors: 0, totalLatencyMs: 15000 },
+          tokens: {
+            prompt: 1000,
+            candidates: 2000,
+            total: 43234,
+            cached: 500,
+            thoughts: 100,
+            tool: 50,
+          },
+        },
+        'gemini-2.5-flash': {
+          api: { totalRequests: 5, totalErrors: 1, totalLatencyMs: 4500 },
+          tokens: {
+            prompt: 25000,
+            candidates: 15000,
+            total: 150000000,
+            cached: 10000,
+            thoughts: 2000,
+            tool: 1000,
+          },
+        },
+      },
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+
+    const { lastFrame } = renderWithMockedStats(metrics);
+    const output = lastFrame();
+
+    expect(output).toContain('gemini-2.5-pro');
+    expect(output).toContain('gemini-2.5-flash');
+    expect(output).toContain('1,000');
+    expect(output).toContain('25,000');
+    expect(output).toMatchSnapshot();
+  });
+
+  it('renders all sections when all data is present', () => {
+    const metrics: SessionMetrics = {
+      models: {
+        'gemini-2.5-pro': {
+          api: { totalRequests: 1, totalErrors: 0, totalLatencyMs: 100 },
+          tokens: {
+            prompt: 100,
+            candidates: 100,
+            total: 250,
+            cached: 50,
+            thoughts: 0,
+            tool: 0,
+          },
+        },
+      },
+      tools: {
+        totalCalls: 2,
+        totalSuccess: 1,
+        totalFail: 1,
+        totalDurationMs: 123,
+        totalDecisions: { accept: 1, reject: 0, modify: 0 },
+        byName: {
+          'test-tool': {
+            count: 2,
+            success: 1,
+            fail: 1,
+            durationMs: 123,
+            decisions: { accept: 1, reject: 0, modify: 0 },
+          },
+        },
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+
+    const { lastFrame } = renderWithMockedStats(metrics);
+    const output = lastFrame();
+
+    expect(output).toContain('Performance');
+    expect(output).toContain('Interaction Summary');
+    expect(output).toContain('User Agreement');
+    expect(output).toContain('Savings Highlight');
+    expect(output).toContain('gemini-2.5-pro');
+    expect(output).toMatchSnapshot();
+  });
+
+  describe('Conditional Rendering Tests', () => {
+    it('hides User Agreement when no decisions are made', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 2,
+          totalSuccess: 1,
+          totalFail: 1,
+          totalDurationMs: 123,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 }, // No decisions
+          byName: {
+            'test-tool': {
+              count: 2,
+              success: 1,
+              fail: 1,
+              durationMs: 123,
+              decisions: { accept: 0, reject: 0, modify: 0 },
+            },
+          },
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+
+      const { lastFrame } = renderWithMockedStats(metrics);
+      const output = lastFrame();
+
+      expect(output).toContain('Interaction Summary');
+      expect(output).toContain('Success Rate');
+      expect(output).not.toContain('User Agreement');
+      expect(output).toMatchSnapshot();
+    });
+
+    it('hides Efficiency section when cache is not used', () => {
+      const metrics: SessionMetrics = {
+        models: {
+          'gemini-2.5-pro': {
+            api: { totalRequests: 1, totalErrors: 0, totalLatencyMs: 100 },
+            tokens: {
+              prompt: 100,
+              candidates: 100,
+              total: 200,
+              cached: 0,
+              thoughts: 0,
+              tool: 0,
+            },
+          },
+        },
+        tools: {
+          totalCalls: 0,
+          totalSuccess: 0,
+          totalFail: 0,
+          totalDurationMs: 0,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+
+      const { lastFrame } = renderWithMockedStats(metrics);
+      const output = lastFrame();
+
+      expect(output).not.toContain('Efficiency & Optimizations');
+      expect(output).toMatchSnapshot();
+    });
+  });
+
+  describe('Conditional Color Tests', () => {
+    it('renders success rate in green for high values', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 10,
+          totalSuccess: 10,
+          totalFail: 0,
+          totalDurationMs: 0,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+      const { lastFrame } = renderWithMockedStats(metrics);
+      expect(lastFrame()).toMatchSnapshot();
+    });
+
+    it('renders success rate in yellow for medium values', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 10,
+          totalSuccess: 9,
+          totalFail: 1,
+          totalDurationMs: 0,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+      const { lastFrame } = renderWithMockedStats(metrics);
+      expect(lastFrame()).toMatchSnapshot();
+    });
+
+    it('renders success rate in red for low values', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 10,
+          totalSuccess: 5,
+          totalFail: 5,
+          totalDurationMs: 0,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+      const { lastFrame } = renderWithMockedStats(metrics);
+      expect(lastFrame()).toMatchSnapshot();
+    });
+  });
+
+  describe('Code Changes Display', () => {
+    it('displays Code Changes when line counts are present', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 1,
+          totalSuccess: 1,
+          totalFail: 0,
+          totalDurationMs: 100,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 42,
+          totalLinesRemoved: 18,
+        },
+      };
+
+      const { lastFrame } = renderWithMockedStats(metrics);
+      const output = lastFrame();
+
+      expect(output).toContain('Code Changes:');
+      expect(output).toContain('+42');
+      expect(output).toContain('-18');
+      expect(output).toMatchSnapshot();
+    });
+
+    it('hides Code Changes when no lines are added or removed', () => {
+      const metrics: SessionMetrics = {
+        models: {},
+        tools: {
+          totalCalls: 1,
+          totalSuccess: 1,
+          totalFail: 0,
+          totalDurationMs: 100,
+          totalDecisions: { accept: 0, reject: 0, modify: 0 },
+          byName: {},
+        },
+        files: {
+          totalLinesAdded: 0,
+          totalLinesRemoved: 0,
+        },
+      };
+
+      const { lastFrame } = renderWithMockedStats(metrics);
+      const output = lastFrame();
+
+      expect(output).not.toContain('Code Changes:');
+      expect(output).toMatchSnapshot();
+    });
+  });
+
+  describe('Title Rendering', () => {
+    const zeroMetrics: SessionMetrics = {
+      models: {},
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: { accept: 0, reject: 0, modify: 0 },
+        byName: {},
+      },
+      files: {
+        totalLinesAdded: 0,
+        totalLinesRemoved: 0,
+      },
+    };
+
+    it('renders the default title when no title prop is provided', () => {
+      const { lastFrame } = renderWithMockedStats(zeroMetrics);
+      const output = lastFrame();
+      expect(output).toContain('Session Stats');
+      expect(output).not.toContain('Agent powering down');
+      expect(output).toMatchSnapshot();
+    });
+
+    it('renders the custom title when a title prop is provided', () => {
+      useSessionStatsMock.mockReturnValue({
+        stats: {
+          sessionId: 'test-session-id',
+          sessionStartTime: new Date(),
+          metrics: zeroMetrics,
+          lastPromptTokenCount: 0,
+          promptCount: 5,
+        },
+
+        getPromptCount: () => 5,
+        startNewPrompt: vi.fn(),
+      });
+
+      const { lastFrame } = render(
+        <StatsDisplay duration="1s" title="Agent powering down. Goodbye!" />,
+      );
+      const output = lastFrame();
+      expect(output).toContain('Agent powering down. Goodbye!');
+      expect(output).not.toContain('Session Stats');
+      expect(output).toMatchSnapshot();
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/StatsDisplay.tsx

@@ -0,0 +1,273 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import Gradient from 'ink-gradient';
+import { theme } from '../semantic-colors.js';
+import { formatDuration } from '../utils/formatters.js';
+import { useSessionStats, ModelMetrics } from '../contexts/SessionContext.js';
+import {
+  getStatusColor,
+  TOOL_SUCCESS_RATE_HIGH,
+  TOOL_SUCCESS_RATE_MEDIUM,
+  USER_AGREEMENT_RATE_HIGH,
+  USER_AGREEMENT_RATE_MEDIUM,
+} from '../utils/displayUtils.js';
+import { computeSessionStats } from '../utils/computeStats.js';
+
+// A more flexible and powerful StatRow component
+interface StatRowProps {
+  title: string;
+  children: React.ReactNode; // Use children to allow for complex, colored values
+}
+
+const StatRow: React.FC<StatRowProps> = ({ title, children }) => (
+  <Box>
+    {/* Fixed width for the label creates a clean "gutter" for alignment */}
+    <Box width={28}>
+      <Text color={theme.text.link}>{title}</Text>
+    </Box>
+    {children}
+  </Box>
+);
+
+// A SubStatRow for indented, secondary information
+interface SubStatRowProps {
+  title: string;
+  children: React.ReactNode;
+}
+
+const SubStatRow: React.FC<SubStatRowProps> = ({ title, children }) => (
+  <Box paddingLeft={2}>
+    {/* Adjust width for the "» " prefix */}
+    <Box width={26}>
+      <Text>» {title}</Text>
+    </Box>
+    {children}
+  </Box>
+);
+
+// A Section component to group related stats
+interface SectionProps {
+  title: string;
+  children: React.ReactNode;
+}
+
+const Section: React.FC<SectionProps> = ({ title, children }) => (
+  <Box flexDirection="column" width="100%" marginBottom={1}>
+    <Text bold>{title}</Text>
+    {children}
+  </Box>
+);
+
+const ModelUsageTable: React.FC<{
+  models: Record<string, ModelMetrics>;
+  totalCachedTokens: number;
+  cacheEfficiency: number;
+}> = ({ models, totalCachedTokens, cacheEfficiency }) => {
+  const nameWidth = 25;
+  const requestsWidth = 8;
+  const inputTokensWidth = 15;
+  const outputTokensWidth = 15;
+
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      {/* Header */}
+      <Box>
+        <Box width={nameWidth}>
+          <Text bold>Model Usage</Text>
+        </Box>
+        <Box width={requestsWidth} justifyContent="flex-end">
+          <Text bold>Reqs</Text>
+        </Box>
+        <Box width={inputTokensWidth} justifyContent="flex-end">
+          <Text bold>Input Tokens</Text>
+        </Box>
+        <Box width={outputTokensWidth} justifyContent="flex-end">
+          <Text bold>Output Tokens</Text>
+        </Box>
+      </Box>
+      {/* Divider */}
+      <Box
+        borderStyle="round"
+        borderBottom={true}
+        borderTop={false}
+        borderLeft={false}
+        borderRight={false}
+        width={nameWidth + requestsWidth + inputTokensWidth + outputTokensWidth}
+      ></Box>
+
+      {/* Rows */}
+      {Object.entries(models).map(([name, modelMetrics]) => (
+        <Box key={name}>
+          <Box width={nameWidth}>
+            <Text>{name.replace('-001', '')}</Text>
+          </Box>
+          <Box width={requestsWidth} justifyContent="flex-end">
+            <Text>{modelMetrics.api.totalRequests}</Text>
+          </Box>
+          <Box width={inputTokensWidth} justifyContent="flex-end">
+            <Text color={theme.status.warning}>
+              {modelMetrics.tokens.prompt.toLocaleString()}
+            </Text>
+          </Box>
+          <Box width={outputTokensWidth} justifyContent="flex-end">
+            <Text color={theme.status.warning}>
+              {modelMetrics.tokens.candidates.toLocaleString()}
+            </Text>
+          </Box>
+        </Box>
+      ))}
+      {cacheEfficiency > 0 && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text>
+            <Text color={theme.status.success}>Savings Highlight:</Text>{' '}
+            {totalCachedTokens.toLocaleString()} ({cacheEfficiency.toFixed(1)}
+            %) of input tokens were served from the cache, reducing costs.
+          </Text>
+          <Box height={1} />
+          <Text color={theme.text.secondary}>
+            » Tip: For a full token breakdown, run `/stats model`.
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+};
+
+interface StatsDisplayProps {
+  duration: string;
+  title?: string;
+}
+
+export const StatsDisplay: React.FC<StatsDisplayProps> = ({
+  duration,
+  title,
+}) => {
+  const { stats } = useSessionStats();
+  const { metrics } = stats;
+  const { models, tools, files } = metrics;
+  const computed = computeSessionStats(metrics);
+
+  const successThresholds = {
+    green: TOOL_SUCCESS_RATE_HIGH,
+    yellow: TOOL_SUCCESS_RATE_MEDIUM,
+  };
+  const agreementThresholds = {
+    green: USER_AGREEMENT_RATE_HIGH,
+    yellow: USER_AGREEMENT_RATE_MEDIUM,
+  };
+  const successColor = getStatusColor(computed.successRate, successThresholds);
+  const agreementColor = getStatusColor(
+    computed.agreementRate,
+    agreementThresholds,
+  );
+
+  const renderTitle = () => {
+    if (title) {
+      return theme.ui.gradient && theme.ui.gradient.length > 0 ? (
+        <Gradient colors={theme.ui.gradient}>
+          <Text bold>{title}</Text>
+        </Gradient>
+      ) : (
+        <Text bold color={theme.text.accent}>
+          {title}
+        </Text>
+      );
+    }
+    return (
+      <Text bold color={theme.text.accent}>
+        Session Stats
+      </Text>
+    );
+  };
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={theme.border.default}
+      flexDirection="column"
+      paddingY={1}
+      paddingX={2}
+    >
+      {renderTitle()}
+      <Box height={1} />
+
+      <Section title="Interaction Summary">
+        <StatRow title="Session ID:">
+          <Text>{stats.sessionId}</Text>
+        </StatRow>
+        <StatRow title="Tool Calls:">
+          <Text>
+            {tools.totalCalls} ({' '}
+            <Text color={theme.status.success}>✔ {tools.totalSuccess}</Text>{' '}
+            <Text color={theme.status.error}>✖ {tools.totalFail}</Text> )
+          </Text>
+        </StatRow>
+        <StatRow title="Success Rate:">
+          <Text color={successColor}>{computed.successRate.toFixed(1)}%</Text>
+        </StatRow>
+        {computed.totalDecisions > 0 && (
+          <StatRow title="User Agreement:">
+            <Text color={agreementColor}>
+              {computed.agreementRate.toFixed(1)}%{' '}
+              <Text color={theme.text.secondary}>
+                ({computed.totalDecisions} reviewed)
+              </Text>
+            </Text>
+          </StatRow>
+        )}
+        {files &&
+          (files.totalLinesAdded > 0 || files.totalLinesRemoved > 0) && (
+            <StatRow title="Code Changes:">
+              <Text>
+                <Text color={theme.status.success}>
+                  +{files.totalLinesAdded}
+                </Text>{' '}
+                <Text color={theme.status.error}>
+                  -{files.totalLinesRemoved}
+                </Text>
+              </Text>
+            </StatRow>
+          )}
+      </Section>
+
+      <Section title="Performance">
+        <StatRow title="Wall Time:">
+          <Text>{duration}</Text>
+        </StatRow>
+        <StatRow title="Agent Active:">
+          <Text>{formatDuration(computed.agentActiveTime)}</Text>
+        </StatRow>
+        <SubStatRow title="API Time:">
+          <Text>
+            {formatDuration(computed.totalApiTime)}{' '}
+            <Text color={theme.text.secondary}>
+              ({computed.apiTimePercent.toFixed(1)}%)
+            </Text>
+          </Text>
+        </SubStatRow>
+        <SubStatRow title="Tool Time:">
+          <Text>
+            {formatDuration(computed.totalToolTime)}{' '}
+            <Text color={theme.text.secondary}>
+              ({computed.toolTimePercent.toFixed(1)}%)
+            </Text>
+          </Text>
+        </SubStatRow>
+      </Section>
+
+      {Object.keys(models).length > 0 && (
+        <ModelUsageTable
+          models={models}
+          totalCachedTokens={computed.totalCachedTokens}
+          cacheEfficiency={computed.cacheEfficiency}
+        />
+      )}
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/SuggestionsDisplay.tsx

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { PrepareLabel } from './PrepareLabel.js';
+export interface Suggestion {
+  label: string;
+  value: string;
+  description?: string;
+  matchedIndex?: number;
+}
+interface SuggestionsDisplayProps {
+  suggestions: Suggestion[];
+  activeIndex: number;
+  isLoading: boolean;
+  width: number;
+  scrollOffset: number;
+  userInput: string;
+}
+
+export const MAX_SUGGESTIONS_TO_SHOW = 8;
+
+export function SuggestionsDisplay({
+  suggestions,
+  activeIndex,
+  isLoading,
+  width,
+  scrollOffset,
+  userInput,
+}: SuggestionsDisplayProps) {
+  if (isLoading) {
+    return (
+      <Box paddingX={1} width={width}>
+        <Text color="gray">Loading suggestions...</Text>
+      </Box>
+    );
+  }
+
+  if (suggestions.length === 0) {
+    return null; // Don't render anything if there are no suggestions
+  }
+
+  // Calculate the visible slice based on scrollOffset
+  const startIndex = scrollOffset;
+  const endIndex = Math.min(
+    scrollOffset + MAX_SUGGESTIONS_TO_SHOW,
+    suggestions.length,
+  );
+  const visibleSuggestions = suggestions.slice(startIndex, endIndex);
+
+  return (
+    <Box flexDirection="column" paddingX={1} width={width}>
+      {scrollOffset > 0 && <Text color={Colors.Foreground}>▲</Text>}
+
+      {visibleSuggestions.map((suggestion, index) => {
+        const originalIndex = startIndex + index;
+        const isActive = originalIndex === activeIndex;
+        const textColor = isActive ? Colors.AccentPurple : Colors.Gray;
+        const labelElement = (
+          <PrepareLabel
+            label={suggestion.label}
+            matchedIndex={suggestion.matchedIndex}
+            userInput={userInput}
+            textColor={textColor}
+          />
+        );
+
+        return (
+          <Box key={`${suggestion.value}-${originalIndex}`} width={width}>
+            <Box flexDirection="row">
+              {userInput.startsWith('/') ? (
+                // only use box model for (/) command mode
+                <Box width={20} flexShrink={0}>
+                  {labelElement}
+                </Box>
+              ) : (
+                labelElement
+              )}
+              {suggestion.description ? (
+                <Box flexGrow={1}>
+                  <Text color={textColor} wrap="truncate">
+                    {suggestion.description}
+                  </Text>
+                </Box>
+              ) : null}
+            </Box>
+          </Box>
+        );
+      })}
+      {endIndex < suggestions.length && <Text color="gray">▼</Text>}
+      {suggestions.length > MAX_SUGGESTIONS_TO_SHOW && (
+        <Text color="gray">
+          ({activeIndex + 1}/{suggestions.length})
+        </Text>
+      )}
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/ThemeDialog.tsx

@@ -0,0 +1,310 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useCallback, useState } from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { themeManager, DEFAULT_THEME } from '../themes/theme-manager.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { DiffRenderer } from './messages/DiffRenderer.js';
+import { colorizeCode } from '../utils/CodeColorizer.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import {
+  getScopeItems,
+  getScopeMessageForSetting,
+} from '../../utils/dialogScopeUtils.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface ThemeDialogProps {
+  /** Callback function when a theme is selected */
+  onSelect: (themeName: string | undefined, scope: SettingScope) => void;
+
+  /** Callback function when a theme is highlighted */
+  onHighlight: (themeName: string | undefined) => void;
+  /** The settings object */
+  settings: LoadedSettings;
+  availableTerminalHeight?: number;
+  terminalWidth: number;
+}
+
+export function ThemeDialog({
+  onSelect,
+  onHighlight,
+  settings,
+  availableTerminalHeight,
+  terminalWidth,
+}: ThemeDialogProps): React.JSX.Element {
+  const [selectedScope, setSelectedScope] = useState<SettingScope>(
+    SettingScope.User,
+  );
+
+  // Track the currently highlighted theme name
+  const [highlightedThemeName, setHighlightedThemeName] = useState<
+    string | undefined
+  >(settings.merged.theme || DEFAULT_THEME.name);
+
+  // Generate theme items filtered by selected scope
+  const customThemes =
+    selectedScope === SettingScope.User
+      ? settings.user.settings.customThemes || {}
+      : settings.merged.customThemes || {};
+  const builtInThemes = themeManager
+    .getAvailableThemes()
+    .filter((theme) => theme.type !== 'custom');
+  const customThemeNames = Object.keys(customThemes);
+  const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+  // Generate theme items
+  const themeItems = [
+    ...builtInThemes.map((theme) => ({
+      label: theme.name,
+      value: theme.name,
+      themeNameDisplay: theme.name,
+      themeTypeDisplay: capitalize(theme.type),
+    })),
+    ...customThemeNames.map((name) => ({
+      label: name,
+      value: name,
+      themeNameDisplay: name,
+      themeTypeDisplay: 'Custom',
+    })),
+  ];
+  const [selectInputKey, setSelectInputKey] = useState(Date.now());
+
+  // Find the index of the selected theme, but only if it exists in the list
+  const selectedThemeName = settings.merged.theme || DEFAULT_THEME.name;
+  const initialThemeIndex = themeItems.findIndex(
+    (item) => item.value === selectedThemeName,
+  );
+  // If not found, fall back to the first theme
+  const safeInitialThemeIndex = initialThemeIndex >= 0 ? initialThemeIndex : 0;
+
+  const scopeItems = getScopeItems();
+
+  const handleThemeSelect = useCallback(
+    (themeName: string) => {
+      onSelect(themeName, selectedScope);
+    },
+    [onSelect, selectedScope],
+  );
+
+  const handleThemeHighlight = (themeName: string) => {
+    setHighlightedThemeName(themeName);
+    onHighlight(themeName);
+  };
+
+  const handleScopeHighlight = useCallback((scope: SettingScope) => {
+    setSelectedScope(scope);
+    setSelectInputKey(Date.now());
+  }, []);
+
+  const handleScopeSelect = useCallback(
+    (scope: SettingScope) => {
+      handleScopeHighlight(scope);
+      setFocusedSection('theme'); // Reset focus to theme section
+    },
+    [handleScopeHighlight],
+  );
+
+  const [focusedSection, setFocusedSection] = useState<'theme' | 'scope'>(
+    'theme',
+  );
+
+  useKeypress(
+    (key) => {
+      if (key.name === 'tab') {
+        setFocusedSection((prev) => (prev === 'theme' ? 'scope' : 'theme'));
+      }
+      if (key.name === 'escape') {
+        onSelect(undefined, selectedScope);
+      }
+    },
+    { isActive: true },
+  );
+
+  // Generate scope message for theme setting
+  const otherScopeModifiedMessage = getScopeMessageForSetting(
+    'theme',
+    selectedScope,
+    settings,
+  );
+
+  // Constants for calculating preview pane layout.
+  // These values are based on the JSX structure below.
+  const PREVIEW_PANE_WIDTH_PERCENTAGE = 0.55;
+  // A safety margin to prevent text from touching the border.
+  // This is a complete hack unrelated to the 0.9 used in App.tsx
+  const PREVIEW_PANE_WIDTH_SAFETY_MARGIN = 0.9;
+  // Combined horizontal padding from the dialog and preview pane.
+  const TOTAL_HORIZONTAL_PADDING = 4;
+  const colorizeCodeWidth = Math.max(
+    Math.floor(
+      (terminalWidth - TOTAL_HORIZONTAL_PADDING) *
+        PREVIEW_PANE_WIDTH_PERCENTAGE *
+        PREVIEW_PANE_WIDTH_SAFETY_MARGIN,
+    ),
+    1,
+  );
+
+  const DIALOG_PADDING = 2;
+  const selectThemeHeight = themeItems.length + 1;
+  const SCOPE_SELECTION_HEIGHT = 4; // Height for the scope selection section + margin.
+  const SPACE_BETWEEN_THEME_SELECTION_AND_APPLY_TO = 1;
+  const TAB_TO_SELECT_HEIGHT = 2;
+  availableTerminalHeight = availableTerminalHeight ?? Number.MAX_SAFE_INTEGER;
+  availableTerminalHeight -= 2; // Top and bottom borders.
+  availableTerminalHeight -= TAB_TO_SELECT_HEIGHT;
+
+  let totalLeftHandSideHeight =
+    DIALOG_PADDING +
+    selectThemeHeight +
+    SCOPE_SELECTION_HEIGHT +
+    SPACE_BETWEEN_THEME_SELECTION_AND_APPLY_TO;
+
+  let showScopeSelection = true;
+  let includePadding = true;
+
+  // Remove content from the LHS that can be omitted if it exceeds the available height.
+  if (totalLeftHandSideHeight > availableTerminalHeight) {
+    includePadding = false;
+    totalLeftHandSideHeight -= DIALOG_PADDING;
+  }
+
+  if (totalLeftHandSideHeight > availableTerminalHeight) {
+    // First, try hiding the scope selection
+    totalLeftHandSideHeight -= SCOPE_SELECTION_HEIGHT;
+    showScopeSelection = false;
+  }
+
+  // Don't focus the scope selection if it is hidden due to height constraints.
+  const currentFocusedSection = !showScopeSelection ? 'theme' : focusedSection;
+
+  // Vertical space taken by elements other than the two code blocks in the preview pane.
+  // Includes "Preview" title, borders, and margin between blocks.
+  const PREVIEW_PANE_FIXED_VERTICAL_SPACE = 8;
+
+  // The right column doesn't need to ever be shorter than the left column.
+  availableTerminalHeight = Math.max(
+    availableTerminalHeight,
+    totalLeftHandSideHeight,
+  );
+  const availableTerminalHeightCodeBlock =
+    availableTerminalHeight -
+    PREVIEW_PANE_FIXED_VERTICAL_SPACE -
+    (includePadding ? 2 : 0) * 2;
+
+  // Subtract margin between code blocks from available height.
+  const availableHeightForPanes = Math.max(
+    0,
+    availableTerminalHeightCodeBlock - 1,
+  );
+
+  // The code block is slightly longer than the diff, so give it more space.
+  const codeBlockHeight = Math.ceil(availableHeightForPanes * 0.6);
+  const diffHeight = Math.floor(availableHeightForPanes * 0.4);
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.Gray}
+      flexDirection="column"
+      paddingTop={includePadding ? 1 : 0}
+      paddingBottom={includePadding ? 1 : 0}
+      paddingLeft={1}
+      paddingRight={1}
+      width="100%"
+    >
+      <Box flexDirection="row">
+        {/* Left Column: Selection */}
+        <Box flexDirection="column" width="45%" paddingRight={2}>
+          <Text bold={currentFocusedSection === 'theme'} wrap="truncate">
+            {currentFocusedSection === 'theme' ? '> ' : '  '}Select Theme{' '}
+            <Text color={Colors.Gray}>{otherScopeModifiedMessage}</Text>
+          </Text>
+          <RadioButtonSelect
+            key={selectInputKey}
+            items={themeItems}
+            initialIndex={safeInitialThemeIndex}
+            onSelect={handleThemeSelect}
+            onHighlight={handleThemeHighlight}
+            isFocused={currentFocusedSection === 'theme'}
+            maxItemsToShow={8}
+            showScrollArrows={true}
+            showNumbers={currentFocusedSection === 'theme'}
+          />
+
+          {/* Scope Selection */}
+          {showScopeSelection && (
+            <Box marginTop={1} flexDirection="column">
+              <Text bold={currentFocusedSection === 'scope'} wrap="truncate">
+                {currentFocusedSection === 'scope' ? '> ' : '  '}Apply To
+              </Text>
+              <RadioButtonSelect
+                items={scopeItems}
+                initialIndex={0} // Default to User Settings
+                onSelect={handleScopeSelect}
+                onHighlight={handleScopeHighlight}
+                isFocused={currentFocusedSection === 'scope'}
+                showNumbers={currentFocusedSection === 'scope'}
+              />
+            </Box>
+          )}
+        </Box>
+
+        {/* Right Column: Preview */}
+        <Box flexDirection="column" width="55%" paddingLeft={2}>
+          <Text bold>Preview</Text>
+          {/* Get the Theme object for the highlighted theme, fall back to default if not found */}
+          {(() => {
+            const previewTheme =
+              themeManager.getTheme(
+                highlightedThemeName || DEFAULT_THEME.name,
+              ) || DEFAULT_THEME;
+            return (
+              <Box
+                borderStyle="single"
+                borderColor={Colors.Gray}
+                paddingTop={includePadding ? 1 : 0}
+                paddingBottom={includePadding ? 1 : 0}
+                paddingLeft={1}
+                paddingRight={1}
+                flexDirection="column"
+              >
+                {colorizeCode(
+                  `# function
+def fibonacci(n):
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a`,
+                  'python',
+                  codeBlockHeight,
+                  colorizeCodeWidth,
+                )}
+                <Box marginTop={1} />
+                <DiffRenderer
+                  diffContent={`--- a/util.py
++++ b/util.py
+@@ -1,2 +1,2 @@
+- print("Hello, " + name)
++ print(f"Hello, {name}!")
+`}
+                  availableTerminalHeight={diffHeight}
+                  terminalWidth={colorizeCodeWidth}
+                  theme={previewTheme}
+                />
+              </Box>
+            );
+          })()}
+        </Box>
+      </Box>
+      <Box marginTop={1}>
+        <Text color={Colors.Gray} wrap="truncate">
+          (Use Enter to select
+          {showScopeSelection ? ', Tab to change focus' : ''})
+        </Text>
+      </Box>
+    </Box>
+  );
+}

projects/ui/qwen-code/packages/cli/src/ui/components/Tips.tsx

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { type Config } from '@qwen-code/qwen-code-core';
+
+interface TipsProps {
+  config: Config;
+}
+
+export const Tips: React.FC<TipsProps> = ({ config }) => {
+  const geminiMdFileCount = config.getGeminiMdFileCount();
+  return (
+    <Box flexDirection="column">
+      <Text color={Colors.Foreground}>Tips for getting started:</Text>
+      <Text color={Colors.Foreground}>
+        1. Ask questions, edit files, or run commands.
+      </Text>
+      <Text color={Colors.Foreground}>
+        2. Be specific for the best results.
+      </Text>
+      {geminiMdFileCount === 0 && (
+        <Text color={Colors.Foreground}>
+          3. Create{' '}
+          <Text bold color={Colors.AccentPurple}>
+            QWEN.md
+          </Text>{' '}
+          files to customize your interactions with Qwen Code.
+        </Text>
+      )}
+      <Text color={Colors.Foreground}>
+        {geminiMdFileCount === 0 ? '4.' : '3.'}{' '}
+        <Text bold color={Colors.AccentPurple}>
+          /help
+        </Text>{' '}
+        for more information.
+      </Text>
+    </Box>
+  );
+};

projects/ui/qwen-code/packages/cli/src/ui/components/TodoDisplay.test.tsx

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import { TodoItem, TodoDisplay } from './TodoDisplay.js';
+
+describe('TodoDisplay', () => {
+  const mockTodos: TodoItem[] = [
+    {
+      id: '1',
+      content: 'Complete feature implementation',
+      status: 'completed',
+    },
+    {
+      id: '2',
+      content: 'Write unit tests',
+      status: 'in_progress',
+    },
+    {
+      id: '3',
+      content: 'Update documentation',
+      status: 'pending',
+    },
+  ];
+
+  it('should render todo list', () => {
+    const { lastFrame } = render(<TodoDisplay todos={mockTodos} />);
+
+    const output = lastFrame();
+
+    // Check all todo items are displayed
+    expect(output).toContain('Complete feature implementation');
+    expect(output).toContain('Write unit tests');
+    expect(output).toContain('Update documentation');
+  });
+
+  it('should display correct status icons', () => {
+    const { lastFrame } = render(<TodoDisplay todos={mockTodos} />);
+
+    const output = lastFrame();
+
+    // Check status icons are present
+    expect(output).toContain('●'); // completed
+    expect(output).toContain('◐'); // in_progress
+    expect(output).toContain('○'); // pending
+  });
+
+  it('should handle empty todo list', () => {
+    const { lastFrame } = render(<TodoDisplay todos={[]} />);
+
+    const output = lastFrame();
+
+    // Should render nothing for empty todos
+    expect(output).toBe('');
+  });
+
+  it('should handle undefined todos', () => {
+    const { lastFrame } = render(
+      <TodoDisplay todos={undefined as unknown as TodoItem[]} />,
+    );
+
+    const output = lastFrame();
+
+    // Should render nothing for undefined todos
+    expect(output).toBe('');
+  });
+
+  it('should render tasks with different statuses', () => {
+    const allCompleted: TodoItem[] = [
+      { id: '1', content: 'Task 1', status: 'completed' },
+      { id: '2', content: 'Task 2', status: 'completed' },
+    ];
+
+    const { lastFrame } = render(<TodoDisplay todos={allCompleted} />);
+
+    const output = lastFrame();
+    expect(output).toContain('Task 1');
+    expect(output).toContain('Task 2');
+  });
+
+  it('should render tasks with mixed statuses', () => {
+    const mixedTodos: TodoItem[] = [
+      { id: '1', content: 'Task 1', status: 'pending' },
+      { id: '2', content: 'Task 2', status: 'in_progress' },
+    ];
+
+    const { lastFrame } = render(<TodoDisplay todos={mixedTodos} />);
+
+    const output = lastFrame();
+    expect(output).toContain('Task 1');
+    expect(output).toContain('Task 2');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/components/TodoDisplay.tsx

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Colors } from '../colors.js';
+
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+interface TodoDisplayProps {
+  todos: TodoItem[];
+}
+
+const STATUS_ICONS = {
+  pending: '○',
+  in_progress: '◐',
+  completed: '●',
+} as const;
+
+export const TodoDisplay: React.FC<TodoDisplayProps> = ({ todos }) => {
+  if (!todos || todos.length === 0) {
+    return null;
+  }
+
+  return (
+    <Box flexDirection="column">
+      {todos.map((todo) => (
+        <TodoItemRow key={todo.id} todo={todo} />
+      ))}
+    </Box>
+  );
+};
+
+interface TodoItemRowProps {
+  todo: TodoItem;
+}
+
+const TodoItemRow: React.FC<TodoItemRowProps> = ({ todo }) => {
+  const statusIcon = STATUS_ICONS[todo.status];
+  const isCompleted = todo.status === 'completed';
+  const isInProgress = todo.status === 'in_progress';
+
+  // Use the same color for both status icon and text, like RadioButtonSelect
+  const itemColor = isCompleted
+    ? Colors.Foreground
+    : isInProgress
+      ? Colors.AccentGreen
+      : Colors.Foreground;
+
+  return (
+    <Box flexDirection="row" minHeight={1}>
+      {/* Status Icon */}
+      <Box width={3}>
+        <Text color={itemColor}>{statusIcon}</Text>
+      </Box>
+
+      {/* Content */}
+      <Box flexGrow={1}>
+        <Text color={itemColor} strikethrough={isCompleted} wrap="wrap">
+          {todo.content}
+        </Text>
+      </Box>
+    </Box>
+  );
+};