Add files using upload-large-folder tool

packages/cli/src/ui/__snapshots__/App.test.tsx.snap

@@ -0,0 +1,152 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`App > Snapshots > renders default layout correctly 1`] = `
+"
+ ▝▜▄      ▗█▀▀▜▙▝█▛▀▀▌▜██▖▟██▘▜█▘▜██▖▝█▛▝█▛
+   ▝▜▄    █▌     █▙▟  ▐█▝█▛▐█ ▐█ ▐█▝█▖█▌ █▌
+  ▗▟▀     ▜▙ ▝█▛ █▌▝ ▖▐█   ▐█ ▐█ ▐█ ▝██▌ █▌
+ ▝▀        ▀▀▀▀▘▝▀▀▀▀▘▀▀▘  ▀▀▘▀▀▘▀▀▘ ▝▀▀▝▀▀
+
+ Gemini CLI v1.2.3
+
+
+
+Tips for getting started:
+1. Create GEMINI.md files to customize your interactions
+2. /help for more information
+3. Ask coding questions, edit code or run commands
+4. Be specific for the best results
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Notifications
+
+Composer
+"
+`;
+
+exports[`App > Snapshots > renders screen reader layout correctly 1`] = `
+"Notifications
+Footer
+
+ ▝▜▄      ▗█▀▀▜▙▝█▛▀▀▌▜██▖▟██▘▜█▘▜██▖▝█▛▝█▛
+   ▝▜▄    █▌     █▙▟  ▐█▝█▛▐█ ▐█ ▐█▝█▖█▌ █▌
+  ▗▟▀     ▜▙ ▝█▛ █▌▝ ▖▐█   ▐█ ▐█ ▐█ ▝██▌ █▌
+ ▝▀        ▀▀▀▀▘▝▀▀▀▀▘▀▀▘  ▀▀▘▀▀▘▀▀▘ ▝▀▀▝▀▀
+
+ Gemini CLI v1.2.3
+
+
+
+Tips for getting started:
+1. Create GEMINI.md files to customize your interactions
+2. /help for more information
+3. Ask coding questions, edit code or run commands
+4. Be specific for the best results
+Composer
+"
+`;
+
+exports[`App > Snapshots > renders with dialogs visible 1`] = `
+"
+ ▝▜▄      ▗█▀▀▜▙▝█▛▀▀▌▜██▖▟██▘▜█▘▜██▖▝█▛▝█▛
+   ▝▜▄    █▌     █▙▟  ▐█▝█▛▐█ ▐█ ▐█▝█▖█▌ █▌
+  ▗▟▀     ▜▙ ▝█▛ █▌▝ ▖▐█   ▐█ ▐█ ▐█ ▝██▌ █▌
+ ▝▀        ▀▀▀▀▘▝▀▀▀▀▘▀▀▘  ▀▀▘▀▀▘▀▀▘ ▝▀▀▝▀▀
+
+ Gemini CLI v1.2.3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Notifications
+
+DialogManager
+"
+`;
+
+exports[`App > should render ToolConfirmationQueue along with Composer when tool is confirming and experiment is on 1`] = `
+"
+ ▝▜▄      ▗█▀▀▜▙▝█▛▀▀▌▜██▖▟██▘▜█▘▜██▖▝█▛▝█▛
+   ▝▜▄    █▌     █▙▟  ▐█▝█▛▐█ ▐█ ▐█▝█▖█▌ █▌
+  ▗▟▀     ▜▙ ▝█▛ █▌▝ ▖▐█   ▐█ ▐█ ▐█ ▝██▌ █▌
+ ▝▀        ▀▀▀▀▘▝▀▀▀▀▘▀▀▘  ▀▀▘▀▀▘▀▀▘ ▝▀▀▝▀▀
+
+ Gemini CLI v1.2.3
+
+
+
+Tips for getting started:
+1. Create GEMINI.md files to customize your interactions
+2. /help for more information
+3. Ask coding questions, edit code or run commands
+4. Be specific for the best results
+HistoryItemDisplay
+╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ Action Required                                                                                  │
+│                                                                                                  │
+│ ?  ls list directory                                                                             │
+│                                                                                                  │
+│ ╭──────────────────────────────────────────────────────────────────────────────────────────────╮ │
+│ │ ls                                                                                           │ │
+│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
+│ Allow execution of [ls]?                                                                         │
+│                                                                                                  │
+│ ● 1. Allow once                                                                                  │
+│   2. Allow for this session                                                                      │
+│   3. No, suggest changes (esc)                                                                   │
+╰──────────────────────────────���───────────────────────────────────────────────────────────────────╯
+
+
+
+
+
+
+Notifications
+
+Composer
+"
+`;

packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame.test.tsx.snap

@@ -0,0 +1,43 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Full Terminal Tool Confirmation Snapshot > renders tool confirmation box in the frame of the entire terminal 1`] = `
+" > Can you edit InputPrompt.tsx for me?                                                             
+▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
+
+╭─────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ ? Edit packages/.../InputPrompt.tsx:   return kittyProtocolSupporte... =>   return kittyProto…  │
+│ ╭─────────────────────────────────────────────────────────────────────────────────────────────╮ │
+│ │ ... first 42 lines hidden (Ctrl+O to show) ...                                              │ │
+│ │ 43   const line43 = true;                                                                   │ │
+│ │ 44   const line44 = true;                                                                   │ │
+│ │ 45   const line45 = true;                                                                   │ │
+│ │ 46   const line46 = true;                                                                   │ │
+│ │ 47   const line47 = true;                                                                   │ │▄
+│ │ 48   const line48 = true;                                                                   │ │█
+│ │ 49   const line49 = true;                                                                   │ │█
+│ │ 50   const line50 = true;                                                                   │ │█
+│ │ 51   const line51 = true;                                                                   │ │█
+│ │ 52   const line52 = true;                                                                   │ │█
+│ │ 53   const line53 = true;                                                                   │ │█
+│ │ 54   const line54 = true;                                                                   │ │█
+│ │ 55   const line55 = true;                                                                   │ │█
+│ │ 56   const line56 = true;                                                                   │ │█
+│ │ 57   const line57 = true;                                                                   │ │█
+│ │ 58   const line58 = true;                                                                   │ │█
+│ │ 59   const line59 = true;                                                                   │ │█
+│ │ 60   const line60 = true;                                                                   │ │█
+│ │ 61 -  return kittyProtocolSupporte...;                                                      │ │█
+│ │ 61 +  return kittyProtocolSupporte...;                                                      │ │█
+│ │ 62    buffer: TextBuffer;                                                                   │ │█
+│ │ 63    onSubmit: (value: string) => void;                                                    │ │█
+│ ╰─────────────────────────────────────────────────────────────────────────────────────────────╯ │█
+│ Apply this change?                                                                              │█
+│                                                                                                 │█
+│ ● 1. Allow once                                                                                 │█
+│   2. Allow for this session                                                                     │█
+│   3. Allow for this file in all future sessions ~/.gemini/policies/auto-saved.toml              │█
+│   4. Modify with external editor                                                                │█
+│   5. No, suggest changes (esc)                                                                  │█
+╰────────────────────────────────────────────────────────────��────────────────────────────────────╯█
+"
+`;

packages/cli/src/ui/auth/__snapshots__/ApiAuthDialog.test.tsx.snap

@@ -0,0 +1,19 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`ApiAuthDialog > renders correctly 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│                                                                                                  │
+│ Enter Gemini API Key                                                                             │
+│                                                                                                  │
+│ Please enter your Gemini API key. It will be securely stored in your system keychain.            │
+│ You can get an API key from https://aistudio.google.com/app/apikey                               │
+│                                                                                                  │
+│ ╭──────────────────────────────────────────────────────────────────────────────────────────────╮ │
+│ │ Paste your API key here                                                                      │ │
+│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │
+│                                                                                                  │
+│ (Press Enter to submit, Esc to cancel, Ctrl+C to clear stored key)                               │
+│                                                                                                  │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;

packages/cli/src/ui/auth/__snapshots__/AuthDialog.test.tsx.snap

@@ -0,0 +1,60 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`AuthDialog > Snapshots > renders correctly with auth error 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│                                                                                                  │
+│ ? Get started                                                                                    │
+│                                                                                                  │
+│   How would you like to authenticate for this project?                                           │
+│                                                                                                  │
+│   (selected) Sign in with Google(not selected) Use Gemini API Key(not selected) Vertex AI        │
+│                                                                                                  │
+│   Something went wrong                                                                           │
+│                                                                                                  │
+│   (Use Enter to select)                                                                          │
+│                                                                                                  │
+│   Terms of Services and Privacy Notice for Gemini CLI                                            │
+│                                                                                                  │
+│   https://geminicli.com/docs/resources/tos-privacy/                                              │
+│                                                                                                  │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;
+
+exports[`AuthDialog > Snapshots > renders correctly with default props 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│                                                                                                  │
+│ ? Get started                                                                                    │
+│                                                                                                  │
+│   How would you like to authenticate for this project?                                           │
+│                                                                                                  │
+│   (selected) Sign in with Google(not selected) Use Gemini API Key(not selected) Vertex AI        │
+│                                                                                                  │
+│   (Use Enter to select)                                                                          │
+│                                                                                                  │
+│   Terms of Services and Privacy Notice for Gemini CLI                                            │
+│                                                                                                  │
+│   https://geminicli.com/docs/resources/tos-privacy/                                              │
+│                                                                                                  │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;
+
+exports[`AuthDialog > Snapshots > renders correctly with enforced auth type 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│                                                                                                  │
+│ ? Get started                                                                                    │
+│                                                                                                  │
+│   How would you like to authenticate for this project?                                           │
+│                                                                                                  │
+│   (selected) Use Gemini API Key                                                                  │
+│                                                                                                  │
+│   (Use Enter to select)                                                                          │
+│                                                                                                  │
+│   Terms of Services and Privacy Notice for Gemini CLI                                            │
+│                                                                                                  │
+│   https://geminicli.com/docs/resources/tos-privacy/                                              │
+│                                                                                                  │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;

packages/cli/src/ui/auth/__snapshots__/BannedAccountDialog.test.tsx.snap

@@ -0,0 +1,17 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`BannedAccountDialog > renders snapshot correctly 1`] = `
+"
+ Error: Account Suspended
+
+ This service has been disabled in this account for violation of Terms of Service. Please submit an
+ appeal to continue using this product.
+
+ Appeal URL:
+ [https://example.com/appeal]
+
+ Appeal HereChange authenticationExit
+
+ Escape to exit
+"
+`;

packages/cli/src/ui/auth/__snapshots__/LoginRestartDialog.test.tsx.snap

@@ -0,0 +1,17 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`LoginRestartDialog > renders correctly with custom message 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ Authenticating to Vertex AI in Cloud Shell requires a restart to apply project settings.         │
+│ Press R to restart, or Esc to choose a different authentication method.                          │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;
+
+exports[`LoginRestartDialog > renders correctly with default message 1`] = `
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ You've successfully signed in with Google. Gemini CLI needs to be restarted.                     │
+│ Press R to restart, or Esc to choose a different authentication method.                          │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+"
+`;

packages/cli/src/ui/commands/__snapshots__/commandsCommand.test.ts.snap

@@ -0,0 +1,12 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`commandsCommand > list > should list .toml files from available sources 1`] = `
+"### User Commands (/mock/user/commands)
+- user1.toml
+### Project Commands (/mock/project/commands)
+- proj1.toml
+### Extension: ext1 Commands (/mock/ext1/commands)
+- ext1.toml
+
+_Note: MCP prompts are dynamically loaded from configured MCP servers._"
+`;

packages/cli/src/ui/commands/aboutCommand.test.ts

@@ -0,0 +1,181 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { aboutCommand } from './aboutCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import { IdeClient, getVersion } from '@google/gemini-cli-core';
+
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...actual,
+    IdeClient: {
+      getInstance: vi.fn().mockResolvedValue({
+        getDetectedIdeDisplayName: vi.fn().mockReturnValue('test-ide'),
+      }),
+    },
+    UserAccountManager: vi.fn().mockImplementation(() => ({
+      getCachedGoogleAccount: vi.fn().mockReturnValue('test-email@example.com'),
+    })),
+    getVersion: vi.fn(),
+  };
+});
+
+describe('aboutCommand', () => {
+  let mockContext: CommandContext;
+  const originalPlatform = process.platform;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getModel: vi.fn(),
+            getIdeMode: vi.fn().mockReturnValue(true),
+            getUserTierName: vi.fn().mockReturnValue(undefined),
+          },
+        },
+        settings: {
+          merged: {
+            security: {
+              auth: {
+                selectedType: 'test-auth',
+              },
+            },
+          },
+        },
+      },
+      ui: {
+        addItem: vi.fn(),
+      },
+    } as unknown as CommandContext);
+
+    vi.mocked(getVersion).mockResolvedValue('test-version');
+    vi.spyOn(
+      mockContext.services.agentContext!.config,
+      'getModel',
+    ).mockReturnValue('test-model');
+    process.env['GOOGLE_CLOUD_PROJECT'] = 'test-gcp-project';
+    Object.defineProperty(process, 'platform', {
+      value: 'test-os',
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    Object.defineProperty(process, 'platform', {
+      value: originalPlatform,
+    });
+    process.env = originalEnv;
+    vi.clearAllMocks();
+  });
+
+  it('should have the correct name and description', () => {
+    expect(aboutCommand.name).toBe('about');
+    expect(aboutCommand.description).toBe('Show version info');
+  });
+
+  it('should call addItem with all version info', async () => {
+    process.env['SANDBOX'] = '';
+    if (!aboutCommand.action) {
+      throw new Error('The about command must have an action.');
+    }
+
+    await aboutCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+      type: MessageType.ABOUT,
+      cliVersion: 'test-version',
+      osVersion: 'test-os',
+      sandboxEnv: 'no sandbox',
+      modelVersion: 'test-model',
+      selectedAuthType: 'test-auth',
+      gcpProject: 'test-gcp-project',
+      ideClient: 'test-ide',
+      userEmail: 'test-email@example.com',
+      tier: undefined,
+    });
+  });
+
+  it('should show the correct sandbox environment variable', async () => {
+    process.env['SANDBOX'] = 'gemini-sandbox';
+    if (!aboutCommand.action) {
+      throw new Error('The about command must have an action.');
+    }
+
+    await aboutCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sandboxEnv: 'gemini-sandbox',
+      }),
+    );
+  });
+
+  it('should show sandbox-exec profile when applicable', async () => {
+    process.env['SANDBOX'] = 'sandbox-exec';
+    process.env['SEATBELT_PROFILE'] = 'test-profile';
+    if (!aboutCommand.action) {
+      throw new Error('The about command must have an action.');
+    }
+
+    await aboutCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sandboxEnv: 'sandbox-exec (test-profile)',
+      }),
+    );
+  });
+
+  it('should not show ide client when it is not detected', async () => {
+    vi.mocked(IdeClient.getInstance).mockResolvedValue({
+      getDetectedIdeDisplayName: vi.fn().mockReturnValue(undefined),
+    } as unknown as IdeClient);
+
+    process.env['SANDBOX'] = '';
+    if (!aboutCommand.action) {
+      throw new Error('The about command must have an action.');
+    }
+
+    await aboutCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.ABOUT,
+        cliVersion: 'test-version',
+        osVersion: 'test-os',
+        sandboxEnv: 'no sandbox',
+        modelVersion: 'test-model',
+        selectedAuthType: 'test-auth',
+        gcpProject: 'test-gcp-project',
+        ideClient: '',
+      }),
+    );
+  });
+
+  it('should display the tier when getUserTierName returns a value', async () => {
+    vi.mocked(
+      mockContext.services.agentContext!.config.getUserTierName,
+    ).mockReturnValue('Enterprise Tier');
+    if (!aboutCommand.action) {
+      throw new Error('The about command must have an action.');
+    }
+
+    await aboutCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tier: 'Enterprise Tier',
+      }),
+    );
+  });
+});

packages/cli/src/ui/commands/aboutCommand.ts

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CommandKind,
+  type CommandContext,
+  type SlashCommand,
+} from './types.js';
+import process from 'node:process';
+import { MessageType, type HistoryItemAbout } from '../types.js';
+import {
+  IdeClient,
+  UserAccountManager,
+  debugLogger,
+  getVersion,
+} from '@google/gemini-cli-core';
+
+export const aboutCommand: SlashCommand = {
+  name: 'about',
+  description: 'Show version info',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  isSafeConcurrent: true,
+  action: async (context) => {
+    const osVersion = process.platform;
+    let sandboxEnv = 'no sandbox';
+    if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
+      sandboxEnv = process.env['SANDBOX'];
+    } else if (process.env['SANDBOX'] === 'sandbox-exec') {
+      sandboxEnv = `sandbox-exec (${
+        process.env['SEATBELT_PROFILE'] || 'unknown'
+      })`;
+    }
+    const modelVersion =
+      context.services.agentContext?.config.getModel() || 'Unknown';
+    const cliVersion = await getVersion();
+    const selectedAuthType =
+      context.services.settings.merged.security.auth.selectedType || '';
+    const gcpProject = process.env['GOOGLE_CLOUD_PROJECT'] || '';
+    const ideClient = await getIdeClientName(context);
+
+    const userAccountManager = new UserAccountManager();
+    const cachedAccount = userAccountManager.getCachedGoogleAccount();
+    debugLogger.log('AboutCommand: Retrieved cached Google account', {
+      cachedAccount,
+    });
+    const userEmail = cachedAccount ?? undefined;
+
+    const tier = context.services.agentContext?.config.getUserTierName();
+
+    const aboutItem: Omit<HistoryItemAbout, 'id'> = {
+      type: MessageType.ABOUT,
+      cliVersion,
+      osVersion,
+      sandboxEnv,
+      modelVersion,
+      selectedAuthType,
+      gcpProject,
+      ideClient,
+      userEmail,
+      tier,
+    };
+
+    context.ui.addItem(aboutItem);
+  },
+};
+
+async function getIdeClientName(context: CommandContext) {
+  if (!context.services.agentContext?.config.getIdeMode()) {
+    return '';
+  }
+  const ideClient = await IdeClient.getInstance();
+  return ideClient?.getDetectedIdeDisplayName() ?? '';
+}

packages/cli/src/ui/commands/agentsCommand.test.ts

@@ -0,0 +1,514 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { agentsCommand } from './agentsCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { Config } from '@google/gemini-cli-core';
+import type { LoadedSettings } from '../../config/settings.js';
+import { MessageType } from '../types.js';
+import { enableAgent, disableAgent } from '../../utils/agentSettings.js';
+import { renderAgentActionFeedback } from '../../utils/agentUtils.js';
+
+vi.mock('../../utils/agentSettings.js', () => ({
+  enableAgent: vi.fn(),
+  disableAgent: vi.fn(),
+}));
+
+vi.mock('../../utils/agentUtils.js', () => ({
+  renderAgentActionFeedback: vi.fn(),
+}));
+
+describe('agentsCommand', () => {
+  let mockContext: ReturnType<typeof createMockCommandContext>;
+  let mockConfig: {
+    getAgentRegistry: ReturnType<typeof vi.fn>;
+    config: Config;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockConfig = {
+      getAgentRegistry: vi.fn().mockReturnValue({
+        getAllDefinitions: vi.fn().mockReturnValue([]),
+        getAllAgentNames: vi.fn().mockReturnValue([]),
+        reload: vi.fn(),
+      }),
+      get config() {
+        return this as unknown as Config;
+      },
+    };
+
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: mockConfig as unknown as Config,
+        settings: {
+          workspace: { path: '/mock/path' },
+          merged: { agents: { overrides: {} } },
+        } as unknown as LoadedSettings,
+      },
+    });
+  });
+
+  it('should show an error if config is not available', async () => {
+    const contextWithoutConfig = createMockCommandContext({
+      services: {
+        agentContext: null,
+      },
+    });
+
+    const result = await agentsCommand.action!(contextWithoutConfig, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    });
+  });
+
+  it('should show an error if agent registry is not available', async () => {
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue(undefined);
+
+    const result = await agentsCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Agent registry not found.',
+    });
+  });
+
+  it('should call addItem with correct agents list', async () => {
+    const mockAgents = [
+      {
+        name: 'agent1',
+        displayName: 'Agent One',
+        description: 'desc1',
+        kind: 'local',
+      },
+      {
+        name: 'agent2',
+        displayName: undefined,
+        description: 'desc2',
+        kind: 'remote',
+      },
+    ];
+    mockConfig.getAgentRegistry().getAllDefinitions.mockReturnValue(mockAgents);
+
+    await agentsCommand.action!(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.AGENTS_LIST,
+        agents: mockAgents,
+      }),
+    );
+  });
+
+  it('should reload the agent registry when reload subcommand is called', async () => {
+    const reloadSpy = vi.fn().mockResolvedValue({
+      totalLoaded: 3,
+      localCount: 2,
+      remoteCount: 1,
+      newAgents: ['new-agent'],
+      updatedAgents: ['updated-agent'],
+      deletedAgents: ['deleted-agent'],
+      errors: [],
+    });
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+      reload: reloadSpy,
+    });
+
+    const reloadCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'reload',
+    );
+    expect(reloadCommand).toBeDefined();
+
+    const result = (await reloadCommand!.action!(mockContext, '')) as {
+      type: 'message';
+      content: string;
+    };
+
+    expect(reloadSpy).toHaveBeenCalled();
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.INFO,
+        text: 'Reloading agent registry...',
+      }),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: expect.stringContaining('Agents reloaded successfully:'),
+    });
+    expect(result.content).toContain('- Total: 3 (2 local, 1 remote)');
+    expect(result.content).toContain('- New: new-agent');
+    expect(result.content).toContain('- Updated: updated-agent');
+    expect(result.content).toContain('- Deleted: deleted-agent');
+    expect(result.content).toContain(
+      'Run /agents list to see all available agents.',
+    );
+  });
+
+  it('should show "reloaded with errors" if errors occurred during reload', async () => {
+    const reloadSpy = vi.fn().mockResolvedValue({
+      totalLoaded: 1,
+      localCount: 1,
+      remoteCount: 0,
+      newAgents: [],
+      updatedAgents: [],
+      deletedAgents: [],
+      errors: ['Some error'],
+    });
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+      reload: reloadSpy,
+    });
+
+    const reloadCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'reload',
+    );
+
+    const result = (await reloadCommand!.action!(mockContext, '')) as {
+      type: 'message';
+      content: string;
+    };
+
+    expect(result.content).toContain('Agents reloaded with errors:');
+    expect(result.content).toContain('- Errors: 1 encountered during reload');
+  });
+
+  it('should show an error if agent registry is not available during reload', async () => {
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue(undefined);
+
+    const reloadCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'reload',
+    );
+    const result = await reloadCommand!.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Agent registry not found.',
+    });
+  });
+
+  it('should enable an agent successfully', async () => {
+    const reloadSpy = vi.fn().mockResolvedValue(undefined);
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+      getAllAgentNames: vi.fn().mockReturnValue([]),
+      reload: reloadSpy,
+    });
+    // Add agent to disabled overrides so validation passes
+    mockContext.services.settings.merged.agents.overrides['test-agent'] = {
+      enabled: false,
+    };
+
+    vi.mocked(enableAgent).mockReturnValue({
+      status: 'success',
+      agentName: 'test-agent',
+      action: 'enable',
+      modifiedScopes: [],
+      alreadyInStateScopes: [],
+    });
+    vi.mocked(renderAgentActionFeedback).mockReturnValue('Enabled test-agent.');
+
+    const enableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'enable',
+    );
+    expect(enableCommand).toBeDefined();
+
+    const result = await enableCommand!.action!(mockContext, 'test-agent');
+
+    expect(enableAgent).toHaveBeenCalledWith(
+      mockContext.services.settings,
+      'test-agent',
+    );
+    expect(reloadSpy).toHaveBeenCalled();
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.INFO,
+        text: 'Enabling test-agent...',
+      }),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Enabled test-agent.',
+    });
+  });
+
+  it('should handle no-op when enabling an agent', async () => {
+    mockConfig
+      .getAgentRegistry()
+      .getAllAgentNames.mockReturnValue(['test-agent']);
+
+    const enableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'enable',
+    );
+    const result = await enableCommand!.action!(mockContext, 'test-agent');
+
+    expect(enableAgent).not.toHaveBeenCalled();
+    expect(mockContext.ui.addItem).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: "Agent 'test-agent' is already enabled.",
+    });
+  });
+
+  it('should show usage error if no agent name provided for enable', async () => {
+    const enableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'enable',
+    );
+    const result = await enableCommand!.action!(mockContext, '   ');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /agents enable <agent-name>',
+    });
+  });
+
+  it('should show an error if config is not available for enable', async () => {
+    const contextWithoutConfig = createMockCommandContext({
+      services: { agentContext: null },
+    });
+    const enableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'enable',
+    );
+    const result = await enableCommand!.action!(contextWithoutConfig, 'test');
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    });
+  });
+
+  it('should disable an agent successfully', async () => {
+    const reloadSpy = vi.fn().mockResolvedValue(undefined);
+    mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+      getAllAgentNames: vi.fn().mockReturnValue(['test-agent']),
+      reload: reloadSpy,
+    });
+    vi.mocked(disableAgent).mockReturnValue({
+      status: 'success',
+      agentName: 'test-agent',
+      action: 'disable',
+      modifiedScopes: [],
+      alreadyInStateScopes: [],
+    });
+    vi.mocked(renderAgentActionFeedback).mockReturnValue(
+      'Disabled test-agent.',
+    );
+
+    const disableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'disable',
+    );
+    expect(disableCommand).toBeDefined();
+
+    const result = await disableCommand!.action!(mockContext, 'test-agent');
+
+    expect(disableAgent).toHaveBeenCalledWith(
+      mockContext.services.settings,
+      'test-agent',
+      expect.anything(), // Scope is derived in the command
+    );
+    expect(reloadSpy).toHaveBeenCalled();
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.INFO,
+        text: 'Disabling test-agent...',
+      }),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Disabled test-agent.',
+    });
+  });
+
+  it('should show info message if agent is already disabled', async () => {
+    mockConfig.getAgentRegistry().getAllAgentNames.mockReturnValue([]);
+    mockContext.services.settings.merged.agents.overrides['test-agent'] = {
+      enabled: false,
+    };
+
+    const disableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'disable',
+    );
+    const result = await disableCommand!.action!(mockContext, 'test-agent');
+
+    expect(disableAgent).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: "Agent 'test-agent' is already disabled.",
+    });
+  });
+
+  it('should show error if agent is not found when disabling', async () => {
+    mockConfig.getAgentRegistry().getAllAgentNames.mockReturnValue([]);
+
+    const disableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'disable',
+    );
+    const result = await disableCommand!.action!(mockContext, 'test-agent');
+
+    expect(disableAgent).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: "Agent 'test-agent' not found.",
+    });
+  });
+
+  it('should show usage error if no agent name provided for disable', async () => {
+    const disableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'disable',
+    );
+    const result = await disableCommand!.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /agents disable <agent-name>',
+    });
+  });
+
+  it('should show an error if config is not available for disable', async () => {
+    const contextWithoutConfig = createMockCommandContext({
+      services: { agentContext: null },
+    });
+    const disableCommand = agentsCommand.subCommands?.find(
+      (cmd) => cmd.name === 'disable',
+    );
+    const result = await disableCommand!.action!(contextWithoutConfig, 'test');
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    });
+  });
+
+  describe('config sub-command', () => {
+    it('should return dialog action for a valid agent', async () => {
+      const mockDefinition = {
+        name: 'test-agent',
+        displayName: 'Test Agent',
+        description: 'test desc',
+        kind: 'local',
+      };
+      mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+        getDiscoveredDefinition: vi.fn().mockReturnValue(mockDefinition),
+      });
+
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      expect(configCommand).toBeDefined();
+
+      const result = await configCommand!.action!(mockContext, 'test-agent');
+
+      expect(result).toEqual({
+        type: 'dialog',
+        dialog: 'agentConfig',
+        props: {
+          name: 'test-agent',
+          displayName: 'Test Agent',
+          definition: mockDefinition,
+        },
+      });
+    });
+
+    it('should use name as displayName if displayName is missing', async () => {
+      const mockDefinition = {
+        name: 'test-agent',
+        description: 'test desc',
+        kind: 'local',
+      };
+      mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+        getDiscoveredDefinition: vi.fn().mockReturnValue(mockDefinition),
+      });
+
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      const result = await configCommand!.action!(mockContext, 'test-agent');
+
+      expect(result).toEqual({
+        type: 'dialog',
+        dialog: 'agentConfig',
+        props: {
+          name: 'test-agent',
+          displayName: 'test-agent', // Falls back to name
+          definition: mockDefinition,
+        },
+      });
+    });
+
+    it('should show error if agent is not found', async () => {
+      mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+        getDiscoveredDefinition: vi.fn().mockReturnValue(undefined),
+      });
+
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      const result = await configCommand!.action!(mockContext, 'non-existent');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: "Agent 'non-existent' not found.",
+      });
+    });
+
+    it('should show usage error if no agent name provided', async () => {
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      const result = await configCommand!.action!(mockContext, '  ');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Usage: /agents config <agent-name>',
+      });
+    });
+
+    it('should show an error if config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: { agentContext: null },
+      });
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      const result = await configCommand!.action!(contextWithoutConfig, 'test');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should provide completions for discovered agents', async () => {
+      mockConfig.getAgentRegistry = vi.fn().mockReturnValue({
+        getAllDiscoveredAgentNames: vi
+          .fn()
+          .mockReturnValue(['agent1', 'agent2', 'other']),
+      });
+
+      const configCommand = agentsCommand.subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      );
+      expect(configCommand?.completion).toBeDefined();
+
+      const completions = await configCommand!.completion!(mockContext, 'age');
+      expect(completions).toEqual(['agent1', 'agent2']);
+    });
+  });
+});

packages/cli/src/ui/commands/agentsCommand.ts

@@ -0,0 +1,394 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  SlashCommand,
+  CommandContext,
+  SlashCommandActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import { MessageType, type HistoryItemAgentsList } from '../types.js';
+import { SettingScope } from '../../config/settings.js';
+import { disableAgent, enableAgent } from '../../utils/agentSettings.js';
+import { renderAgentActionFeedback } from '../../utils/agentUtils.js';
+
+const agentsListCommand: SlashCommand = {
+  name: 'list',
+  description: 'List available local and remote agents',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context: CommandContext) => {
+    const config = context.services.agentContext?.config;
+    if (!config) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      };
+    }
+
+    const agentRegistry = config.getAgentRegistry();
+    if (!agentRegistry) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Agent registry not found.',
+      };
+    }
+
+    const agents = agentRegistry.getAllDefinitions().map((def) => ({
+      name: def.name,
+      displayName: def.displayName,
+      description: def.description,
+      kind: def.kind,
+    }));
+
+    const agentsListItem: HistoryItemAgentsList = {
+      type: MessageType.AGENTS_LIST,
+      agents,
+    };
+
+    context.ui.addItem(agentsListItem);
+
+    return;
+  },
+};
+
+async function enableAction(
+  context: CommandContext,
+  args: string,
+): Promise<SlashCommandActionReturn | void> {
+  const config = context.services.agentContext?.config;
+  const { settings } = context.services;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const agentName = args.trim();
+  if (!agentName) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /agents enable <agent-name>',
+    };
+  }
+
+  const agentRegistry = config.getAgentRegistry();
+  if (!agentRegistry) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Agent registry not found.',
+    };
+  }
+
+  const allAgents = agentRegistry.getAllAgentNames();
+  const overrides = settings.merged.agents.overrides;
+  const disabledAgents = Object.keys(overrides).filter(
+    (name) => overrides[name]?.enabled === false,
+  );
+
+  if (allAgents.includes(agentName) && !disabledAgents.includes(agentName)) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Agent '${agentName}' is already enabled.`,
+    };
+  }
+
+  if (!disabledAgents.includes(agentName) && !allAgents.includes(agentName)) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Agent '${agentName}' not found.`,
+    };
+  }
+
+  const result = enableAgent(settings, agentName);
+
+  if (result.status === 'no-op') {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: renderAgentActionFeedback(result, (l, p) => `${l} (${p})`),
+    };
+  }
+
+  context.ui.addItem({
+    type: MessageType.INFO,
+    text: `Enabling ${agentName}...`,
+  });
+  await agentRegistry.reload();
+
+  return {
+    type: 'message',
+    messageType: 'info',
+    content: renderAgentActionFeedback(result, (l, p) => `${l} (${p})`),
+  };
+}
+
+async function disableAction(
+  context: CommandContext,
+  args: string,
+): Promise<SlashCommandActionReturn | void> {
+  const config = context.services.agentContext?.config;
+  const { settings } = context.services;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const agentName = args.trim();
+  if (!agentName) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /agents disable <agent-name>',
+    };
+  }
+
+  const agentRegistry = config.getAgentRegistry();
+  if (!agentRegistry) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Agent registry not found.',
+    };
+  }
+
+  const allAgents = agentRegistry.getAllAgentNames();
+  const overrides = settings.merged.agents.overrides;
+  const disabledAgents = Object.keys(overrides).filter(
+    (name) => overrides[name]?.enabled === false,
+  );
+
+  if (disabledAgents.includes(agentName)) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Agent '${agentName}' is already disabled.`,
+    };
+  }
+
+  if (!allAgents.includes(agentName)) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Agent '${agentName}' not found.`,
+    };
+  }
+
+  const scope = context.services.settings.workspace.path
+    ? SettingScope.Workspace
+    : SettingScope.User;
+  const result = disableAgent(settings, agentName, scope);
+
+  if (result.status === 'no-op') {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: renderAgentActionFeedback(result, (l, p) => `${l} (${p})`),
+    };
+  }
+
+  context.ui.addItem({
+    type: MessageType.INFO,
+    text: `Disabling ${agentName}...`,
+  });
+  await agentRegistry.reload();
+
+  return {
+    type: 'message',
+    messageType: 'info',
+    content: renderAgentActionFeedback(result, (l, p) => `${l} (${p})`),
+  };
+}
+
+async function configAction(
+  context: CommandContext,
+  args: string,
+): Promise<SlashCommandActionReturn | void> {
+  const config = context.services.agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const agentName = args.trim();
+  if (!agentName) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /agents config <agent-name>',
+    };
+  }
+
+  const agentRegistry = config.getAgentRegistry();
+  if (!agentRegistry) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Agent registry not found.',
+    };
+  }
+
+  const definition = agentRegistry.getDiscoveredDefinition(agentName);
+  if (!definition) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Agent '${agentName}' not found.`,
+    };
+  }
+
+  const displayName = definition.displayName || agentName;
+
+  return {
+    type: 'dialog',
+    dialog: 'agentConfig',
+    props: {
+      name: agentName,
+      displayName,
+      definition,
+    },
+  };
+}
+
+function completeAgentsToEnable(context: CommandContext, partialArg: string) {
+  const config = context.services.agentContext?.config;
+  const { settings } = context.services;
+  if (!config) return [];
+
+  const overrides = settings.merged.agents.overrides;
+  const disabledAgents = Object.entries(overrides)
+    .filter(([_, override]) => override?.enabled === false)
+    .map(([name]) => name);
+
+  return disabledAgents.filter((name) => name.startsWith(partialArg));
+}
+
+function completeAgentsToDisable(context: CommandContext, partialArg: string) {
+  const config = context.services.agentContext?.config;
+  if (!config) return [];
+
+  const agentRegistry = config.getAgentRegistry();
+  const allAgents = agentRegistry ? agentRegistry.getAllAgentNames() : [];
+  return allAgents.filter((name: string) => name.startsWith(partialArg));
+}
+
+function completeAllAgents(context: CommandContext, partialArg: string) {
+  const config = context.services.agentContext?.config;
+  if (!config) return [];
+
+  const agentRegistry = config.getAgentRegistry();
+  const allAgents = agentRegistry?.getAllDiscoveredAgentNames() ?? [];
+  return allAgents.filter((name: string) => name.startsWith(partialArg));
+}
+
+const enableCommand: SlashCommand = {
+  name: 'enable',
+  description: 'Enable a disabled agent',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: enableAction,
+  completion: completeAgentsToEnable,
+};
+
+const disableCommand: SlashCommand = {
+  name: 'disable',
+  description: 'Disable an enabled agent',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: disableAction,
+  completion: completeAgentsToDisable,
+};
+
+const configCommand: SlashCommand = {
+  name: 'config',
+  description: 'Configure an agent',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: configAction,
+  completion: completeAllAgents,
+};
+
+const agentsReloadCommand: SlashCommand = {
+  name: 'reload',
+  altNames: ['refresh'],
+  description: 'Reload the agent registry',
+  kind: CommandKind.BUILT_IN,
+  action: async (context: CommandContext) => {
+    const config = context.services.agentContext?.config;
+    const agentRegistry = config?.getAgentRegistry();
+    if (!agentRegistry) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Agent registry not found.',
+      };
+    }
+
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: 'Reloading agent registry...',
+    });
+
+    const summary = await agentRegistry.reload();
+
+    let content =
+      summary.errors.length > 0
+        ? 'Agents reloaded with errors:'
+        : 'Agents reloaded successfully:';
+    content += `\n- Total: ${summary.totalLoaded} (${summary.localCount} local, ${summary.remoteCount} remote)`;
+
+    if (summary.newAgents.length > 0) {
+      content += `\n- New: ${summary.newAgents.join(', ')}`;
+    }
+    if (summary.updatedAgents.length > 0) {
+      content += `\n- Updated: ${summary.updatedAgents.join(', ')}`;
+    }
+    if (summary.deletedAgents.length > 0) {
+      content += `\n- Deleted: ${summary.deletedAgents.join(', ')}`;
+    }
+    if (summary.errors.length > 0) {
+      content += `\n- Errors: ${summary.errors.length} encountered during reload`;
+    }
+
+    content += '\n\nRun /agents list to see all available agents.';
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content,
+    };
+  },
+};
+
+export const agentsCommand: SlashCommand = {
+  name: 'agents',
+  description: 'Manage agents',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    agentsListCommand,
+    agentsReloadCommand,
+    enableCommand,
+    disableCommand,
+    configCommand,
+  ],
+  action: async (context: CommandContext, args) =>
+    // Default to list if no subcommand is provided
+    agentsListCommand.action!(context, args),
+};

packages/cli/src/ui/commands/authCommand.test.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { authCommand } from './authCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { SettingScope } from '../../config/settings.js';
+import type { GeminiClient } from '@google/gemini-cli-core';
+
+vi.mock('@google/gemini-cli-core', async () => {
+  const actual = await vi.importActual('@google/gemini-cli-core');
+  return {
+    ...actual,
+    clearCachedCredentialFile: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe('authCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          geminiClient: {
+            stripThoughtsFromHistory: vi.fn(),
+          },
+        },
+      },
+    });
+    // Add setValue mock to settings
+    mockContext.services.settings.setValue = vi.fn();
+    vi.clearAllMocks();
+  });
+
+  it('should have subcommands: signin and signout', () => {
+    expect(authCommand.subCommands).toBeDefined();
+    expect(authCommand.subCommands).toHaveLength(2);
+    expect(authCommand.subCommands?.[0]?.name).toBe('signin');
+    expect(authCommand.subCommands?.[0]?.altNames).toContain('login');
+    expect(authCommand.subCommands?.[1]?.name).toBe('signout');
+    expect(authCommand.subCommands?.[1]?.altNames).toContain('logout');
+  });
+
+  it('should return a dialog action to open the auth dialog when called with no args', () => {
+    if (!authCommand.action) {
+      throw new Error('The auth command must have an action.');
+    }
+
+    const result = authCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'auth',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(authCommand.name).toBe('auth');
+    expect(authCommand.description).toBe('Manage authentication');
+  });
+
+  describe('auth signin subcommand', () => {
+    it('should return auth dialog action', () => {
+      const loginCommand = authCommand.subCommands?.[0];
+      expect(loginCommand?.name).toBe('signin');
+      const result = loginCommand!.action!(mockContext, '');
+      expect(result).toEqual({ type: 'dialog', dialog: 'auth' });
+    });
+  });
+
+  describe('auth signout subcommand', () => {
+    it('should clear cached credentials', async () => {
+      const logoutCommand = authCommand.subCommands?.[1];
+      expect(logoutCommand?.name).toBe('signout');
+
+      const { clearCachedCredentialFile } = await import(
+        '@google/gemini-cli-core'
+      );
+
+      await logoutCommand!.action!(mockContext, '');
+
+      expect(clearCachedCredentialFile).toHaveBeenCalledOnce();
+    });
+
+    it('should clear selectedAuthType setting', async () => {
+      const logoutCommand = authCommand.subCommands?.[1];
+
+      await logoutCommand!.action!(mockContext, '');
+
+      expect(mockContext.services.settings.setValue).toHaveBeenCalledWith(
+        SettingScope.User,
+        'security.auth.selectedType',
+        undefined,
+      );
+    });
+
+    it('should strip thoughts from history', async () => {
+      const logoutCommand = authCommand.subCommands?.[1];
+      const mockStripThoughts = vi.fn();
+      const mockClient = {
+        stripThoughtsFromHistory: mockStripThoughts,
+      } as unknown as GeminiClient;
+      if (mockContext.services.agentContext?.config) {
+        mockContext.services.agentContext.config.getGeminiClient = vi.fn(
+          () => mockClient,
+        );
+      }
+
+      await logoutCommand!.action!(mockContext, '');
+
+      expect(
+        mockContext.services.agentContext?.geminiClient
+          .stripThoughtsFromHistory,
+      ).toHaveBeenCalled();
+    });
+
+    it('should return logout action to signal explicit state change', async () => {
+      const logoutCommand = authCommand.subCommands?.[1];
+      const result = await logoutCommand!.action!(mockContext, '');
+
+      expect(result).toEqual({ type: 'logout' });
+    });
+
+    it('should handle missing config gracefully', async () => {
+      const logoutCommand = authCommand.subCommands?.[1];
+      mockContext.services.agentContext = null;
+
+      const result = await logoutCommand!.action!(mockContext, '');
+
+      expect(result).toEqual({ type: 'logout' });
+    });
+  });
+});

packages/cli/src/ui/commands/authCommand.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  OpenDialogActionReturn,
+  SlashCommand,
+  LogoutActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import { clearCachedCredentialFile } from '@google/gemini-cli-core';
+import { SettingScope } from '../../config/settings.js';
+
+const authLoginCommand: SlashCommand = {
+  name: 'signin',
+  altNames: ['login'],
+  description: 'Sign in or change the authentication method',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: (_context, _args): OpenDialogActionReturn => ({
+    type: 'dialog',
+    dialog: 'auth',
+  }),
+};
+
+const authLogoutCommand: SlashCommand = {
+  name: 'signout',
+  altNames: ['logout'],
+  description: 'Sign out and clear all cached credentials',
+  kind: CommandKind.BUILT_IN,
+  action: async (context, _args): Promise<LogoutActionReturn> => {
+    await clearCachedCredentialFile();
+    // Clear the selected auth type so user sees the auth selection menu
+    context.services.settings.setValue(
+      SettingScope.User,
+      'security.auth.selectedType',
+      undefined,
+    );
+    // Strip thoughts from history instead of clearing completely
+    context.services.agentContext?.geminiClient.stripThoughtsFromHistory();
+    // Return logout action to signal explicit state change
+    return {
+      type: 'logout',
+    };
+  },
+};
+
+export const authCommand: SlashCommand = {
+  name: 'auth',
+  description: 'Manage authentication',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [authLoginCommand, authLogoutCommand],
+  action: (context, args) =>
+    // Default to login if no subcommand is provided
+    authLoginCommand.action!(context, args),
+};

packages/cli/src/ui/commands/bugCommand.test.ts

@@ -0,0 +1,344 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import open from 'open';
+import path from 'node:path';
+import { bugCommand } from './bugCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { getVersion, type Config } from '@google/gemini-cli-core';
+import { GIT_COMMIT_INFO } from '../../generated/git-commit.js';
+import { formatBytes } from '../utils/formatters.js';
+import { MessageType } from '../types.js';
+import { captureHeapSnapshot } from '../utils/memorySnapshot.js';
+
+const { memoryUsageMock } = vi.hoisted(() => ({
+  memoryUsageMock: vi.fn(() => ({
+    rss: 0,
+    heapTotal: 0,
+    heapUsed: 0,
+    external: 0,
+    arrayBuffers: 0,
+  })),
+}));
+
+// Mock dependencies
+vi.mock('open');
+vi.mock('../utils/formatters.js');
+vi.mock('../utils/memorySnapshot.js', () => ({
+  captureHeapSnapshot: vi.fn(),
+  MEMORY_SNAPSHOT_AUTO_THRESHOLD_BYTES: 2 * 1024 * 1024 * 1024,
+}));
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    stat: vi.fn().mockResolvedValue({ size: 4096 }),
+  };
+});
+vi.mock('../utils/historyExportUtils.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../utils/historyExportUtils.js')>();
+  return {
+    ...actual,
+    exportHistoryToFile: vi.fn(),
+  };
+});
+import { exportHistoryToFile } from '../utils/historyExportUtils.js';
+
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...actual,
+    IdeClient: {
+      getInstance: () => ({
+        getDetectedIdeDisplayName: vi.fn().mockReturnValue('VSCode'),
+      }),
+    },
+    sessionId: 'test-session-id',
+    getVersion: vi.fn(),
+    INITIAL_HISTORY_LENGTH: 1,
+    debugLogger: {
+      error: vi.fn(),
+      log: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+    },
+  };
+});
+vi.mock('node:process', () => ({
+  default: {
+    platform: 'test-platform',
+    version: 'v20.0.0',
+    // Keep other necessary process properties if needed by other parts of the code
+    env: process.env,
+    memoryUsage: memoryUsageMock,
+  },
+}));
+
+vi.mock('../utils/terminalCapabilityManager.js', () => ({
+  terminalCapabilityManager: {
+    getTerminalName: vi.fn().mockReturnValue('Test Terminal'),
+    getTerminalBackgroundColor: vi.fn().mockReturnValue('#000000'),
+    isKittyProtocolEnabled: vi.fn().mockReturnValue(true),
+  },
+}));
+
+describe('bugCommand', () => {
+  beforeEach(() => {
+    vi.mocked(getVersion).mockResolvedValue('0.1.0');
+    vi.mocked(formatBytes).mockReturnValue('100 MB');
+    memoryUsageMock.mockReturnValue({
+      rss: 0,
+      heapTotal: 0,
+      heapUsed: 0,
+      external: 0,
+      arrayBuffers: 0,
+    });
+    vi.stubEnv('SANDBOX', 'gemini-test');
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2024-01-01T00:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('should generate the default GitHub issue URL', async () => {
+    const mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getModel: () => 'gemini-pro',
+            getBugCommand: () => undefined,
+            getIdeMode: () => true,
+            getContentGeneratorConfig: () => ({ authType: 'oauth-personal' }),
+            getSessionId: vi.fn().mockReturnValue('test-session-id'),
+          } as unknown as Config,
+          geminiClient: {
+            getChat: () => ({
+              getHistory: () => [],
+            }),
+          },
+        },
+      },
+    });
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await bugCommand.action(mockContext, 'A test bug');
+
+    const expectedInfo = `
+* **CLI Version:** 0.1.0
+* **Git Commit:** ${GIT_COMMIT_INFO}
+* **Session ID:** test-session-id
+* **Operating System:** test-platform v20.0.0
+* **Sandbox Environment:** test
+* **Model Version:** gemini-pro
+* **Auth Type:** oauth-personal
+* **Memory Usage:** 100 MB
+* **Terminal Name:** Test Terminal
+* **Terminal Background:** #000000
+* **Kitty Keyboard Protocol:** Supported
+* **IDE Client:** VSCode
+`;
+    const expectedUrl = `https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml&title=A%20test%20bug&info=${encodeURIComponent(expectedInfo)}&problem=A%20test%20bug`;
+
+    expect(open).toHaveBeenCalledWith(expectedUrl);
+  });
+
+  it('should export chat history if available', async () => {
+    const history = [
+      { role: 'user', parts: [{ text: 'hello' }] },
+      { role: 'model', parts: [{ text: 'hi' }] },
+    ];
+    const mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getModel: () => 'gemini-pro',
+            getBugCommand: () => undefined,
+            getIdeMode: () => true,
+            getContentGeneratorConfig: () => ({ authType: 'vertex-ai' }),
+            storage: {
+              getProjectTempDir: () => '/tmp/gemini',
+            },
+            getSessionId: vi.fn().mockReturnValue('test-session-id'),
+          } as unknown as Config,
+          geminiClient: {
+            getChat: () => ({
+              getHistory: () => history,
+            }),
+          },
+        },
+      },
+    });
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await bugCommand.action(mockContext, 'Bug with history');
+
+    const expectedPath = path.join(
+      '/tmp/gemini',
+      'bug-report-history-1704067200000.json',
+    );
+    expect(exportHistoryToFile).toHaveBeenCalledWith({
+      history,
+      filePath: expectedPath,
+    });
+
+    const addItemCall = vi.mocked(mockContext.ui.addItem).mock.calls[0];
+    const messageText = addItemCall[0].text;
+    expect(messageText).toContain(expectedPath);
+    expect(messageText).toContain('📄 **Chat History Exported**');
+    expect(messageText).toContain('Privacy Disclaimer:');
+    expect(messageText).not.toContain('additional-context=');
+    expect(messageText).toContain('problem=');
+    const reminder =
+      '\n\n[ACTION REQUIRED] 📎 PLEASE ATTACH THE EXPORTED CHAT HISTORY JSON FILE TO THIS ISSUE IF YOU FEEL COMFORTABLE SHARING IT.';
+    expect(messageText).toContain(encodeURIComponent(reminder));
+  });
+
+  it('should use a custom URL template from config if provided', async () => {
+    const customTemplate =
+      'https://internal.bug-tracker.com/new?desc={title}&details={info}';
+    const mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getModel: () => 'gemini-pro',
+            getBugCommand: () => ({ urlTemplate: customTemplate }),
+            getIdeMode: () => true,
+            getContentGeneratorConfig: () => ({ authType: 'vertex-ai' }),
+            getSessionId: vi.fn().mockReturnValue('test-session-id'),
+          } as unknown as Config,
+          geminiClient: {
+            getChat: () => ({
+              getHistory: () => [],
+            }),
+          },
+        },
+      },
+    });
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await bugCommand.action(mockContext, 'A custom bug');
+
+    const expectedInfo = `
+* **CLI Version:** 0.1.0
+* **Git Commit:** ${GIT_COMMIT_INFO}
+* **Session ID:** test-session-id
+* **Operating System:** test-platform v20.0.0
+* **Sandbox Environment:** test
+* **Model Version:** gemini-pro
+* **Auth Type:** vertex-ai
+* **Memory Usage:** 100 MB
+* **Terminal Name:** Test Terminal
+* **Terminal Background:** #000000
+* **Kitty Keyboard Protocol:** Supported
+* **IDE Client:** VSCode
+`;
+    const expectedUrl = customTemplate
+      .replace('{title}', encodeURIComponent('A custom bug'))
+      .replace('{info}', encodeURIComponent(expectedInfo));
+
+    expect(open).toHaveBeenCalledWith(expectedUrl);
+  });
+
+  const buildHighMemoryContext = (tempDir: string | undefined) =>
+    createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getModel: () => 'gemini-pro',
+            getBugCommand: () => undefined,
+            getIdeMode: () => false,
+            getContentGeneratorConfig: () => ({ authType: 'oauth-personal' }),
+            storage: tempDir ? { getProjectTempDir: () => tempDir } : undefined,
+            getSessionId: vi.fn().mockReturnValue('test-session-id'),
+          } as unknown as Config,
+          geminiClient: { getChat: () => ({ getHistory: () => [] }) },
+        },
+      },
+    });
+
+  it('captures a heap snapshot AFTER opening the bug URL when RSS exceeds 2 GB', async () => {
+    memoryUsageMock.mockReturnValue({
+      rss: 3 * 1024 * 1024 * 1024,
+      heapTotal: 0,
+      heapUsed: 0,
+      external: 0,
+      arrayBuffers: 0,
+    });
+    vi.mocked(captureHeapSnapshot).mockResolvedValueOnce(undefined);
+
+    const tempDir = path.join('/tmp', 'gemini-test');
+    const context = buildHighMemoryContext(tempDir);
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await bugCommand.action(context, 'A memory bug');
+
+    const now = new Date('2024-01-01T00:00:00Z').getTime();
+    const expectedSnapshotPath = path.join(
+      tempDir,
+      `bug-memory-${now}.heapsnapshot`,
+    );
+    expect(captureHeapSnapshot).toHaveBeenCalledWith(expectedSnapshotPath);
+
+    const addItem = vi.mocked(context.ui.addItem);
+    const callOrder = addItem.mock.invocationCallOrder;
+    const openOrder = vi.mocked(open).mock.invocationCallOrder[0];
+    // The URL message must precede the "capturing" message so the user sees
+    // the URL before the 20+ second snapshot starts.
+    expect(callOrder[0]).toBeLessThan(openOrder);
+    expect(callOrder[1]).toBeGreaterThan(openOrder);
+    expect(addItem.mock.calls[1][0].text).toContain('High memory usage');
+    expect(addItem.mock.calls[2][0].text).toContain('Heap snapshot saved');
+    expect(addItem.mock.calls[2][0].text).toContain(expectedSnapshotPath);
+    expect(addItem.mock.calls[2][0].type).toBe(MessageType.INFO);
+  });
+
+  it('skips auto-capture when RSS is below the 2 GB threshold', async () => {
+    memoryUsageMock.mockReturnValue({
+      rss: 1 * 1024 * 1024 * 1024,
+      heapTotal: 0,
+      heapUsed: 0,
+      external: 0,
+      arrayBuffers: 0,
+    });
+    const context = buildHighMemoryContext('/tmp/gemini-test');
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await bugCommand.action(context, 'A light bug');
+
+    expect(captureHeapSnapshot).not.toHaveBeenCalled();
+  });
+
+  it('reports an error if the auto-capture fails but does not throw', async () => {
+    memoryUsageMock.mockReturnValue({
+      rss: 3 * 1024 * 1024 * 1024,
+      heapTotal: 0,
+      heapUsed: 0,
+      external: 0,
+      arrayBuffers: 0,
+    });
+    vi.mocked(captureHeapSnapshot).mockRejectedValueOnce(
+      new Error('inspector failure'),
+    );
+    const context = buildHighMemoryContext('/tmp/gemini-test');
+
+    if (!bugCommand.action) throw new Error('Action is not defined');
+    await expect(
+      bugCommand.action(context, 'A memory bug'),
+    ).resolves.toBeUndefined();
+
+    const addItem = vi.mocked(context.ui.addItem).mock.calls;
+    const lastCall = addItem[addItem.length - 1][0];
+    expect(lastCall.type).toBe(MessageType.ERROR);
+    expect(lastCall.text).toContain('inspector failure');
+  });
+});

packages/cli/src/ui/commands/bugCommand.ts

@@ -0,0 +1,194 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import open from 'open';
+import process from 'node:process';
+import {
+  type CommandContext,
+  type SlashCommand,
+  CommandKind,
+} from './types.js';
+import { MessageType } from '../types.js';
+import { GIT_COMMIT_INFO } from '../../generated/git-commit.js';
+import { formatBytes } from '../utils/formatters.js';
+import {
+  IdeClient,
+  getVersion,
+  INITIAL_HISTORY_LENGTH,
+  debugLogger,
+} from '@google/gemini-cli-core';
+import { terminalCapabilityManager } from '../utils/terminalCapabilityManager.js';
+import { exportHistoryToFile } from '../utils/historyExportUtils.js';
+import {
+  captureHeapSnapshot,
+  MEMORY_SNAPSHOT_AUTO_THRESHOLD_BYTES,
+} from '../utils/memorySnapshot.js';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+
+export const bugCommand: SlashCommand = {
+  name: 'bug',
+  description: 'Submit a bug report',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: async (context: CommandContext, args?: string): Promise<void> => {
+    const bugDescription = (args || '').trim();
+    const agentContext = context.services.agentContext;
+    const config = agentContext?.config;
+    const osVersion = `${process.platform} ${process.version}`;
+    let sandboxEnv = 'no sandbox';
+    if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
+      sandboxEnv = process.env['SANDBOX'].replace(/^gemini-(?:code-)?/, '');
+    } else if (process.env['SANDBOX'] === 'sandbox-exec') {
+      sandboxEnv = `sandbox-exec (${
+        process.env['SEATBELT_PROFILE'] || 'unknown'
+      })`;
+    }
+    const modelVersion = config?.getModel() || 'Unknown';
+    const cliVersion = await getVersion();
+    const memoryUsage = formatBytes(process.memoryUsage().rss);
+    const ideClient = await getIdeClientName(context);
+    const terminalName =
+      terminalCapabilityManager.getTerminalName() || 'Unknown';
+    const terminalBgColor =
+      terminalCapabilityManager.getTerminalBackgroundColor() || 'Unknown';
+    const kittyProtocol = terminalCapabilityManager.isKittyProtocolEnabled()
+      ? 'Supported'
+      : 'Unsupported';
+    const authType = config?.getContentGeneratorConfig()?.authType || 'Unknown';
+
+    let info = `
+* **CLI Version:** ${cliVersion}
+* **Git Commit:** ${GIT_COMMIT_INFO}
+* **Session ID:** ${config?.getSessionId() || 'Unknown'}
+* **Operating System:** ${osVersion}
+* **Sandbox Environment:** ${sandboxEnv}
+* **Model Version:** ${modelVersion}
+* **Auth Type:** ${authType}
+* **Memory Usage:** ${memoryUsage}
+* **Terminal Name:** ${terminalName}
+* **Terminal Background:** ${terminalBgColor}
+* **Kitty Keyboard Protocol:** ${kittyProtocol}
+`;
+    if (ideClient) {
+      info += `* **IDE Client:** ${ideClient}\n`;
+    }
+
+    const chat = agentContext?.geminiClient?.getChat();
+    const history = chat?.getHistory() || [];
+    let historyFileMessage = '';
+    let problemValue = bugDescription;
+
+    if (history.length > INITIAL_HISTORY_LENGTH) {
+      const tempDir = config?.storage?.getProjectTempDir();
+      if (tempDir) {
+        const historyFileName = `bug-report-history-${Date.now()}.json`;
+        const historyFilePath = path.join(tempDir, historyFileName);
+        try {
+          await exportHistoryToFile({ history, filePath: historyFilePath });
+          historyFileMessage = `\n\n--------------------------------------------------------------------------------\n\n📄 **Chat History Exported**\nTo help us debug, we've exported your current chat history to:\n${historyFilePath}\n\nPlease consider attaching this file to your GitHub issue if you feel comfortable doing so.\n\n**Privacy Disclaimer:** Please do not upload any logs containing sensitive or private information that you are not comfortable sharing publicly.`;
+          problemValue += `\n\n[ACTION REQUIRED] 📎 PLEASE ATTACH THE EXPORTED CHAT HISTORY JSON FILE TO THIS ISSUE IF YOU FEEL COMFORTABLE SHARING IT.`;
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          debugLogger.error(
+            `Failed to export chat history for bug report: ${errorMessage}`,
+          );
+        }
+      }
+    }
+
+    let bugReportUrl =
+      'https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml&title={title}&info={info}&problem={problem}';
+
+    const bugCommandSettings = config?.getBugCommand();
+    if (bugCommandSettings?.urlTemplate) {
+      bugReportUrl = bugCommandSettings.urlTemplate;
+    }
+
+    bugReportUrl = bugReportUrl
+      .replace('{title}', encodeURIComponent(bugDescription))
+      .replace('{info}', encodeURIComponent(info))
+      .replace('{problem}', encodeURIComponent(problemValue));
+
+    context.ui.addItem(
+      {
+        type: MessageType.INFO,
+        text: `To submit your bug report, please open the following URL in your browser:\n${bugReportUrl}${historyFileMessage}`,
+      },
+      Date.now(),
+    );
+
+    try {
+      await open(bugReportUrl);
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: `Could not open URL in browser: ${errorMessage}`,
+        },
+        Date.now(),
+      );
+    }
+
+    const rss = process.memoryUsage().rss;
+    const tempDir = config?.storage?.getProjectTempDir();
+    if (rss >= MEMORY_SNAPSHOT_AUTO_THRESHOLD_BYTES && tempDir) {
+      const snapshotPath = path.join(
+        tempDir,
+        `bug-memory-${Date.now()}.heapsnapshot`,
+      );
+      context.ui.addItem(
+        {
+          type: MessageType.INFO,
+          text: `High memory usage detected (${formatBytes(rss)}). Capturing V8 heap snapshot to ${snapshotPath}.\nThis can take 20+ seconds and the CLI may be temporarily unresponsive; please do not exit.`,
+        },
+        Date.now(),
+      );
+      try {
+        const startedAt = Date.now();
+        await captureHeapSnapshot(snapshotPath);
+        const durationMs = Date.now() - startedAt;
+        let sizeText = '';
+        try {
+          const { size } = await stat(snapshotPath);
+          sizeText = ` (${formatBytes(size)})`;
+        } catch {
+          // Size reporting is best-effort; the snapshot itself was captured successfully.
+        }
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: `Heap snapshot saved${sizeText} in ${durationMs}ms:\n${snapshotPath}\n\nConsider attaching it to your bug report only if it does not contain sensitive information.`,
+          },
+          Date.now(),
+        );
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        debugLogger.error(
+          `Failed to capture heap snapshot for bug report: ${errorMessage}`,
+        );
+        context.ui.addItem(
+          {
+            type: MessageType.ERROR,
+            text: `Failed to capture heap snapshot: ${errorMessage}`,
+          },
+          Date.now(),
+        );
+      }
+    }
+  },
+};
+
+async function getIdeClientName(context: CommandContext) {
+  if (!context.services.agentContext?.config.getIdeMode()) {
+    return '';
+  }
+  const ideClient = await IdeClient.getInstance();
+  return ideClient.getDetectedIdeDisplayName() ?? '';
+}

packages/cli/src/ui/commands/bugMemoryCommand.test.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import { bugMemoryCommand } from './bugMemoryCommand.js';
+import { captureHeapSnapshot } from '../utils/memorySnapshot.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import type { Config } from '@google/gemini-cli-core';
+
+vi.mock('../utils/memorySnapshot.js', () => ({
+  captureHeapSnapshot: vi.fn(),
+  MEMORY_SNAPSHOT_AUTO_THRESHOLD_BYTES: 2 * 1024 * 1024 * 1024,
+}));
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    stat: vi.fn().mockResolvedValue({ size: 1234 }),
+  };
+});
+
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...actual,
+    debugLogger: {
+      error: vi.fn(),
+      log: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+    },
+  };
+});
+
+function makeContextWithTempDir(tempDir: string | undefined) {
+  return createMockCommandContext({
+    services: {
+      agentContext: {
+        config: {
+          storage: tempDir ? { getProjectTempDir: () => tempDir } : undefined,
+        } as unknown as Config,
+      },
+    },
+  });
+}
+
+describe('bugMemoryCommand', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2024-01-01T00:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('declares itself as a non-auto-executing built-in command', () => {
+    expect(bugMemoryCommand.name).toBe('bug-memory');
+    expect(bugMemoryCommand.autoExecute).toBe(false);
+    expect(bugMemoryCommand.description).toBeTruthy();
+  });
+
+  it('captures a heap snapshot and reports the file path', async () => {
+    const tempDir = path.join('/tmp', 'gemini-test');
+    const context = makeContextWithTempDir(tempDir);
+    vi.mocked(captureHeapSnapshot).mockResolvedValueOnce(undefined);
+
+    if (!bugMemoryCommand.action) throw new Error('Action missing');
+    await bugMemoryCommand.action(context, '');
+
+    const expectedPath = path.join(
+      tempDir,
+      `bug-memory-${new Date('2024-01-01T00:00:00Z').getTime()}.heapsnapshot`,
+    );
+    expect(captureHeapSnapshot).toHaveBeenCalledWith(expectedPath);
+
+    const addItemCalls = vi.mocked(context.ui.addItem).mock.calls;
+    expect(addItemCalls).toHaveLength(2);
+    expect(addItemCalls[0][0]).toMatchObject({ type: MessageType.INFO });
+    expect(addItemCalls[0][0].text).toContain(expectedPath);
+    expect(addItemCalls[1][0]).toMatchObject({ type: MessageType.INFO });
+    expect(addItemCalls[1][0].text).toContain('Heap snapshot saved');
+    expect(addItemCalls[1][0].text).toContain(expectedPath);
+  });
+
+  it('surfaces an error if capture fails', async () => {
+    const context = makeContextWithTempDir('/tmp/gemini-test');
+    vi.mocked(captureHeapSnapshot).mockRejectedValueOnce(
+      new Error('inspector disconnected'),
+    );
+
+    if (!bugMemoryCommand.action) throw new Error('Action missing');
+    await bugMemoryCommand.action(context, '');
+
+    const addItemCalls = vi.mocked(context.ui.addItem).mock.calls;
+    const lastCall = addItemCalls[addItemCalls.length - 1][0];
+    expect(lastCall.type).toBe(MessageType.ERROR);
+    expect(lastCall.text).toContain('inspector disconnected');
+  });
+
+  it('emits an error when no project temp directory is available', async () => {
+    const context = makeContextWithTempDir(undefined);
+
+    if (!bugMemoryCommand.action) throw new Error('Action missing');
+    await bugMemoryCommand.action(context, '');
+
+    expect(captureHeapSnapshot).not.toHaveBeenCalled();
+    const addItemCalls = vi.mocked(context.ui.addItem).mock.calls;
+    expect(addItemCalls).toHaveLength(1);
+    expect(addItemCalls[0][0].type).toBe(MessageType.ERROR);
+    expect(addItemCalls[0][0].text).toContain('temp directory');
+  });
+});

packages/cli/src/ui/commands/bugMemoryCommand.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { debugLogger } from '@google/gemini-cli-core';
+import {
+  type CommandContext,
+  type SlashCommand,
+  CommandKind,
+} from './types.js';
+import { MessageType } from '../types.js';
+import { formatBytes } from '../utils/formatters.js';
+import { captureHeapSnapshot } from '../utils/memorySnapshot.js';
+
+export const bugMemoryCommand: SlashCommand = {
+  name: 'bug-memory',
+  description: 'Capture a V8 heap snapshot to disk to attach to a bug report',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: async (context: CommandContext): Promise<void> => {
+    const tempDir =
+      context.services.agentContext?.config?.storage?.getProjectTempDir();
+    if (!tempDir) {
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: 'Cannot capture heap snapshot: project temp directory is unavailable.',
+        },
+        Date.now(),
+      );
+      return;
+    }
+
+    const filePath = path.join(
+      tempDir,
+      `bug-memory-${Date.now()}.heapsnapshot`,
+    );
+    const rss = process.memoryUsage().rss;
+
+    context.ui.addItem(
+      {
+        type: MessageType.INFO,
+        text: `Capturing V8 heap snapshot (current RSS: ${formatBytes(rss)}).\nThis can take 20+ seconds and the CLI may be temporarily unresponsive — please do not exit.\nDestination: ${filePath}`,
+      },
+      Date.now(),
+    );
+
+    const startedAt = Date.now();
+    try {
+      await captureHeapSnapshot(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      debugLogger.error(`Failed to capture heap snapshot: ${message}`);
+      context.ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: `Failed to capture heap snapshot: ${message}`,
+        },
+        Date.now(),
+      );
+      return;
+    }
+
+    const durationMs = Date.now() - startedAt;
+    let sizeText = '';
+    try {
+      const { size } = await stat(filePath);
+      sizeText = ` (${formatBytes(size)})`;
+    } catch {
+      // Size reporting is best-effort; the snapshot itself was captured successfully.
+    }
+
+    context.ui.addItem(
+      {
+        type: MessageType.INFO,
+        text: `Heap snapshot saved${sizeText} in ${durationMs}ms:\n${filePath}\n\nLoad it in Chrome DevTools → Memory → "Load" to analyze. Attach it to your bug report only if it does not contain sensitive information.`,
+      },
+      Date.now(),
+    );
+  },
+};

packages/cli/src/ui/commands/chatCommand.test.ts

@@ -0,0 +1,763 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+import type { SlashCommand, CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { Content } from '@google/genai';
+import { AuthType, type GeminiClient } from '@google/gemini-cli-core';
+
+import * as fsPromises from 'node:fs/promises';
+import { chatCommand, debugCommand } from './chatCommand.js';
+import {
+  serializeHistoryToMarkdown,
+  exportHistoryToFile,
+} from '../utils/historyExportUtils.js';
+import type { Stats } from 'node:fs';
+import type { HistoryItemWithoutId } from '../types.js';
+import path from 'node:path';
+
+vi.mock('fs/promises', () => ({
+  stat: vi.fn(),
+  readdir: vi.fn().mockResolvedValue(['file1.txt', 'file2.txt'] as string[]),
+  writeFile: vi.fn(),
+}));
+
+vi.mock('../utils/historyExportUtils.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../utils/historyExportUtils.js')>();
+  return {
+    ...actual,
+    exportHistoryToFile: vi.fn(),
+  };
+});
+
+describe('chatCommand', () => {
+  const mockFs = vi.mocked(fsPromises);
+  const mockExport = vi.mocked(exportHistoryToFile);
+
+  let mockContext: CommandContext;
+  let mockGetChat: ReturnType<typeof vi.fn>;
+  let mockSaveCheckpoint: ReturnType<typeof vi.fn>;
+  let mockLoadCheckpoint: ReturnType<typeof vi.fn>;
+  let mockDeleteCheckpoint: ReturnType<typeof vi.fn>;
+  let mockGetHistory: ReturnType<typeof vi.fn>;
+
+  const getSubCommand = (
+    name: 'list' | 'save' | 'resume' | 'delete' | 'share',
+  ): SlashCommand => {
+    const subCommand = chatCommand.subCommands?.find(
+      (cmd) => cmd.name === name,
+    );
+    if (!subCommand) {
+      throw new Error(`/chat ${name} command not found.`);
+    }
+    return subCommand;
+  };
+
+  beforeEach(() => {
+    mockGetHistory = vi.fn().mockReturnValue([]);
+    mockGetChat = vi.fn().mockReturnValue({
+      getHistory: mockGetHistory,
+    });
+    mockSaveCheckpoint = vi.fn().mockResolvedValue(undefined);
+    mockLoadCheckpoint = vi.fn().mockResolvedValue({ history: [] });
+    mockDeleteCheckpoint = vi.fn().mockResolvedValue(true);
+
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getProjectRoot: () => '/project/root',
+            getContentGeneratorConfig: () => ({
+              authType: AuthType.LOGIN_WITH_GOOGLE,
+            }),
+            storage: {
+              getProjectTempDir: () => '/project/root/.gemini/tmp/mockhash',
+            },
+          },
+          geminiClient: {
+            getChat: mockGetChat,
+          } as unknown as GeminiClient,
+        },
+        logger: {
+          saveCheckpoint: mockSaveCheckpoint,
+          loadCheckpoint: mockLoadCheckpoint,
+          deleteCheckpoint: mockDeleteCheckpoint,
+          initialize: vi.fn().mockResolvedValue(undefined),
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should have the correct main command definition', () => {
+    expect(chatCommand.name).toBe('chat');
+    expect(chatCommand.description).toBe(
+      'Browse auto-saved conversations and manage chat checkpoints',
+    );
+    expect(chatCommand.autoExecute).toBe(true);
+    expect(chatCommand.subCommands).toHaveLength(6);
+  });
+
+  describe('list subcommand', () => {
+    let listCommand: SlashCommand;
+
+    beforeEach(() => {
+      listCommand = getSubCommand('list');
+    });
+
+    it('should add a chat_list item to the UI', async () => {
+      const fakeFiles = ['checkpoint-test1.json', 'checkpoint-test2.json'];
+      const date1 = new Date();
+      const date2 = new Date(date1.getTime() + 1000);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      mockFs.readdir.mockResolvedValue(fakeFiles as any);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      mockFs.stat.mockImplementation(async (path: any): Promise<Stats> => {
+        if (path.endsWith('test1.json')) {
+          return { mtime: date1 } as Stats;
+        }
+        return { mtime: date2 } as Stats;
+      });
+
+      await listCommand?.action?.(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: 'chat_list',
+        chats: [
+          {
+            name: 'test1',
+            mtime: date1.toISOString(),
+          },
+          {
+            name: 'test2',
+            mtime: date2.toISOString(),
+          },
+        ],
+      });
+    });
+  });
+  describe('save subcommand', () => {
+    let saveCommand: SlashCommand;
+    const tag = 'my-tag';
+    let mockCheckpointExists: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      saveCommand = getSubCommand('save');
+      mockCheckpointExists = vi.fn().mockResolvedValue(false);
+      mockContext.services.logger.checkpointExists = mockCheckpointExists;
+    });
+
+    it('should return an error if tag is missing', async () => {
+      const result = await saveCommand?.action?.(mockContext, '  ');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume save <tag>',
+      });
+    });
+
+    it('should inform if conversation history is empty or only contains system context', async () => {
+      mockGetHistory.mockReturnValue([]);
+      let result = await saveCommand?.action?.(mockContext, tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No conversation found to save.',
+      });
+
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: 'context for our chat' }] },
+      ]);
+      result = await saveCommand?.action?.(mockContext, tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No conversation found to save.',
+      });
+
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: 'context for our chat' }] },
+        { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
+        { role: 'user', parts: [{ text: 'Hello, how are you?' }] },
+      ]);
+      result = await saveCommand?.action?.(mockContext, tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint saved with tag: ${tag}.`,
+      });
+    });
+
+    it('should return confirm_action if checkpoint already exists', async () => {
+      mockCheckpointExists.mockResolvedValue(true);
+      mockContext.invocation = {
+        raw: `/chat save ${tag}`,
+        name: 'save',
+        args: tag,
+      };
+
+      const result = await saveCommand?.action?.(mockContext, tag);
+
+      expect(mockCheckpointExists).toHaveBeenCalledWith(tag);
+      expect(mockSaveCheckpoint).not.toHaveBeenCalled();
+      expect(result).toMatchObject({
+        type: 'confirm_action',
+        originalInvocation: { raw: `/chat save ${tag}` },
+      });
+      // Check that prompt is a React element
+      expect(result).toHaveProperty('prompt');
+    });
+
+    it('should save the conversation if overwrite is confirmed', async () => {
+      const history: Content[] = [
+        { role: 'user', parts: [{ text: 'context for our chat' }] },
+        { role: 'user', parts: [{ text: 'hello' }] },
+      ];
+      mockGetHistory.mockReturnValue(history);
+      mockContext.overwriteConfirmed = true;
+
+      const result = await saveCommand?.action?.(mockContext, tag);
+
+      expect(mockCheckpointExists).not.toHaveBeenCalled(); // Should skip existence check
+      expect(mockSaveCheckpoint).toHaveBeenCalledWith(
+        { history, authType: AuthType.LOGIN_WITH_GOOGLE },
+        tag,
+      );
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint saved with tag: ${tag}.`,
+      });
+    });
+  });
+
+  describe('resume subcommand', () => {
+    const goodTag = 'good-tag';
+    const badTag = 'bad-tag';
+
+    let resumeCommand: SlashCommand;
+    beforeEach(() => {
+      resumeCommand = getSubCommand('resume');
+    });
+
+    it('should return an error if tag is missing', async () => {
+      const result = await resumeCommand?.action?.(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume resume <tag>',
+      });
+    });
+
+    it('should inform if checkpoint is not found', async () => {
+      mockLoadCheckpoint.mockResolvedValue({ history: [] });
+
+      const result = await resumeCommand?.action?.(mockContext, badTag);
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `No saved checkpoint found with tag: ${badTag}.`,
+      });
+    });
+
+    it('should resume a conversation with matching authType', async () => {
+      const conversation: Content[] = [
+        { role: 'user', parts: [{ text: 'system setup' }] },
+        { role: 'user', parts: [{ text: 'hello gemini' }] },
+        { role: 'model', parts: [{ text: 'hello world' }] },
+      ];
+      mockLoadCheckpoint.mockResolvedValue({
+        history: conversation,
+        authType: AuthType.LOGIN_WITH_GOOGLE,
+      });
+
+      const result = await resumeCommand?.action?.(mockContext, goodTag);
+
+      expect(result).toEqual({
+        type: 'load_history',
+        history: [
+          { type: 'user', text: 'hello gemini' },
+          { type: 'gemini', text: 'hello world' },
+        ] as HistoryItemWithoutId[],
+        clientHistory: conversation,
+      });
+    });
+
+    it('should block resuming a conversation with mismatched authType', async () => {
+      const conversation: Content[] = [
+        { role: 'user', parts: [{ text: 'system setup' }] },
+        { role: 'user', parts: [{ text: 'hello gemini' }] },
+        { role: 'model', parts: [{ text: 'hello world' }] },
+      ];
+      mockLoadCheckpoint.mockResolvedValue({
+        history: conversation,
+        authType: AuthType.USE_GEMINI,
+      });
+
+      const result = await resumeCommand?.action?.(mockContext, goodTag);
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `Cannot resume chat. It was saved with a different authentication method (${AuthType.USE_GEMINI}) than the current one (${AuthType.LOGIN_WITH_GOOGLE}).`,
+      });
+    });
+
+    it('should resume a legacy conversation without authType', async () => {
+      const conversation: Content[] = [
+        { role: 'user', parts: [{ text: 'system setup' }] },
+        { role: 'user', parts: [{ text: 'hello gemini' }] },
+        { role: 'model', parts: [{ text: 'hello world' }] },
+      ];
+      mockLoadCheckpoint.mockResolvedValue({ history: conversation });
+
+      const result = await resumeCommand?.action?.(mockContext, goodTag);
+
+      expect(result).toEqual({
+        type: 'load_history',
+        history: [
+          { type: 'user', text: 'hello gemini' },
+          { type: 'gemini', text: 'hello world' },
+        ] as HistoryItemWithoutId[],
+        clientHistory: conversation,
+      });
+    });
+
+    describe('completion', () => {
+      it('should provide completion suggestions', async () => {
+        const fakeFiles = ['checkpoint-alpha.json', 'checkpoint-beta.json'];
+        mockFs.readdir.mockImplementation(
+          (async (_: string): Promise<string[]> =>
+            fakeFiles) as unknown as typeof fsPromises.readdir,
+        );
+
+        mockFs.stat.mockImplementation(
+          (async (_: string): Promise<Stats> =>
+            ({
+              mtime: new Date(),
+            }) as Stats) as unknown as typeof fsPromises.stat,
+        );
+
+        const result = await resumeCommand?.completion?.(mockContext, 'a');
+
+        expect(result).toEqual(['alpha']);
+      });
+
+      it('should suggest filenames sorted by modified time (newest first)', async () => {
+        const fakeFiles = ['checkpoint-test1.json', 'checkpoint-test2.json'];
+        const date = new Date();
+        mockFs.readdir.mockImplementation(
+          (async (_: string): Promise<string[]> =>
+            fakeFiles) as unknown as typeof fsPromises.readdir,
+        );
+        mockFs.stat.mockImplementation((async (
+          path: string,
+        ): Promise<Stats> => {
+          if (path.endsWith('test1.json')) {
+            return { mtime: date } as Stats;
+          }
+          return { mtime: new Date(date.getTime() + 1000) } as Stats;
+        }) as unknown as typeof fsPromises.stat);
+
+        const result = await resumeCommand?.completion?.(mockContext, '');
+        // Sort items by last modified time (newest first)
+        expect(result).toEqual(['test2', 'test1']);
+      });
+    });
+  });
+
+  describe('delete subcommand', () => {
+    let deleteCommand: SlashCommand;
+    const tag = 'my-tag';
+    beforeEach(() => {
+      deleteCommand = getSubCommand('delete');
+    });
+
+    it('should return an error if tag is missing', async () => {
+      const result = await deleteCommand?.action?.(mockContext, '  ');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume delete <tag>',
+      });
+    });
+
+    it('should return an error if checkpoint is not found', async () => {
+      mockDeleteCheckpoint.mockResolvedValue(false);
+      const result = await deleteCommand?.action?.(mockContext, tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `Error: No checkpoint found with tag '${tag}'.`,
+      });
+    });
+
+    it('should delete the conversation', async () => {
+      const result = await deleteCommand?.action?.(mockContext, tag);
+
+      expect(mockDeleteCheckpoint).toHaveBeenCalledWith(tag);
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint '${tag}' has been deleted.`,
+      });
+    });
+
+    describe('completion', () => {
+      it('should provide completion suggestions', async () => {
+        const fakeFiles = ['checkpoint-alpha.json', 'checkpoint-beta.json'];
+        mockFs.readdir.mockImplementation(
+          (async (_: string): Promise<string[]> =>
+            fakeFiles) as unknown as typeof fsPromises.readdir,
+        );
+
+        mockFs.stat.mockImplementation(
+          (async (_: string): Promise<Stats> =>
+            ({
+              mtime: new Date(),
+            }) as Stats) as unknown as typeof fsPromises.stat,
+        );
+
+        const result = await deleteCommand?.completion?.(mockContext, 'a');
+
+        expect(result).toEqual(['alpha']);
+      });
+    });
+  });
+
+  describe('share subcommand', () => {
+    let shareCommand: SlashCommand;
+    const mockHistory = [
+      { role: 'user', parts: [{ text: 'context' }] },
+      { role: 'model', parts: [{ text: 'context response' }] },
+      { role: 'user', parts: [{ text: 'Hello' }] },
+      { role: 'model', parts: [{ text: 'Hi there!' }] },
+    ];
+
+    beforeEach(() => {
+      shareCommand = getSubCommand('share');
+      vi.spyOn(process, 'cwd').mockReturnValue(
+        path.resolve('/usr/local/google/home/myuser/gemini-cli'),
+      );
+      vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+      mockGetHistory.mockReturnValue(mockHistory);
+      mockFs.writeFile.mockClear();
+    });
+
+    it('should default to a json file if no path is provided', async () => {
+      const result = await shareCommand?.action?.(mockContext, '');
+      const expectedPath = path.join(
+        process.cwd(),
+        'gemini-conversation-1234567890.json',
+      );
+      expect(mockExport).toHaveBeenCalledWith({
+        history: mockHistory,
+        filePath: expectedPath,
+      });
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation shared to ${expectedPath}`,
+      });
+    });
+
+    it('should share the conversation to a JSON file', async () => {
+      const filePath = 'my-chat.json';
+      const result = await shareCommand?.action?.(mockContext, filePath);
+      const expectedPath = path.join(process.cwd(), 'my-chat.json');
+      expect(mockExport).toHaveBeenCalledWith({
+        history: mockHistory,
+        filePath: expectedPath,
+      });
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation shared to ${expectedPath}`,
+      });
+    });
+
+    it('should share the conversation to a Markdown file', async () => {
+      const filePath = 'my-chat.md';
+      const result = await shareCommand?.action?.(mockContext, filePath);
+      const expectedPath = path.join(process.cwd(), 'my-chat.md');
+      expect(mockExport).toHaveBeenCalledWith({
+        history: mockHistory,
+        filePath: expectedPath,
+      });
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation shared to ${expectedPath}`,
+      });
+    });
+
+    it('should return an error for unsupported file extensions', async () => {
+      const filePath = 'my-chat.txt';
+      const result = await shareCommand?.action?.(mockContext, filePath);
+      expect(mockExport).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Invalid file format. Only .md and .json are supported.',
+      });
+    });
+
+    it('should inform if there is no conversation to share', async () => {
+      mockGetHistory.mockReturnValue([
+        { role: 'user', parts: [{ text: 'context' }] },
+      ]);
+      const result = await shareCommand?.action?.(mockContext, 'my-chat.json');
+      expect(mockExport).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No conversation found to share.',
+      });
+    });
+
+    it('should handle errors during file writing', async () => {
+      const error = new Error('Permission denied');
+      mockExport.mockRejectedValue(error);
+      const result = await shareCommand?.action?.(mockContext, 'my-chat.json');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `Error sharing conversation: ${error.message}`,
+      });
+    });
+
+    it('should output valid JSON schema', async () => {
+      const filePath = 'my-chat.json';
+      await shareCommand?.action?.(mockContext, filePath);
+      const expectedPath = path.join(process.cwd(), 'my-chat.json');
+      expect(mockExport).toHaveBeenCalledWith({
+        history: mockHistory,
+        filePath: expectedPath,
+      });
+    });
+
+    it('should output correct markdown format', async () => {
+      const filePath = 'my-chat.md';
+      await shareCommand?.action?.(mockContext, filePath);
+      const expectedPath = path.join(process.cwd(), 'my-chat.md');
+      expect(mockExport).toHaveBeenCalledWith({
+        history: mockHistory,
+        filePath: expectedPath,
+      });
+    });
+  });
+
+  describe('serializeHistoryToMarkdown', () => {
+    it('should correctly serialize chat history to Markdown with icons', () => {
+      const history: Content[] = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+        { role: 'model', parts: [{ text: 'Hi there!' }] },
+        { role: 'user', parts: [{ text: 'How are you?' }] },
+      ];
+
+      const expectedMarkdown =
+        '## USER 🧑‍💻\n\nHello\n\n---\n\n' +
+        '## MODEL ✨\n\nHi there!\n\n---\n\n' +
+        '## USER 🧑‍💻\n\nHow are you?';
+
+      const result = serializeHistoryToMarkdown(history);
+      expect(result).toBe(expectedMarkdown);
+    });
+
+    it('should handle empty history', () => {
+      const history: Content[] = [];
+      const result = serializeHistoryToMarkdown(history);
+      expect(result).toBe('');
+    });
+
+    it('should handle items with no text parts', () => {
+      const history: Content[] = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+        { role: 'model', parts: [] },
+        { role: 'user', parts: [{ text: 'How are you?' }] },
+      ];
+
+      const expectedMarkdown = `## USER 🧑‍💻
+
+Hello
+
+---
+
+## MODEL ✨
+
+
+
+---
+
+## USER 🧑‍💻
+
+How are you?`;
+
+      const result = serializeHistoryToMarkdown(history);
+      expect(result).toBe(expectedMarkdown);
+    });
+
+    it('should correctly serialize function calls and responses', () => {
+      const history: Content[] = [
+        {
+          role: 'user',
+          parts: [{ text: 'Please call a function.' }],
+        },
+        {
+          role: 'model',
+          parts: [
+            {
+              functionCall: {
+                name: 'my-function',
+                args: { arg1: 'value1' },
+              },
+            },
+          ],
+        },
+        {
+          role: 'user',
+          parts: [
+            {
+              functionResponse: {
+                name: 'my-function',
+                response: { result: 'success' },
+              },
+            },
+          ],
+        },
+      ];
+
+      const expectedMarkdown = `## USER 🧑‍💻
+
+Please call a function.
+
+---
+
+## MODEL ✨
+
+**Tool Command**:
+\`\`\`json
+{
+  "name": "my-function",
+  "args": {
+    "arg1": "value1"
+  }
+}
+\`\`\`
+
+---
+
+## USER 🧑‍💻
+
+**Tool Response**:
+\`\`\`json
+{
+  "name": "my-function",
+  "response": {
+    "result": "success"
+  }
+}
+\`\`\``;
+
+      const result = serializeHistoryToMarkdown(history);
+      expect(result).toBe(expectedMarkdown);
+    });
+
+    it('should handle items with undefined role', () => {
+      const history: Array<Partial<Content>> = [
+        { role: 'user', parts: [{ text: 'Hello' }] },
+        { parts: [{ text: 'Hi there!' }] },
+      ];
+
+      const expectedMarkdown = `## USER 🧑‍💻
+
+Hello
+
+---
+
+## MODEL ✨
+
+Hi there!`;
+
+      const result = serializeHistoryToMarkdown(history as Content[]);
+      expect(result).toBe(expectedMarkdown);
+    });
+    describe('debug subcommand', () => {
+      let mockGetLatestApiRequest: ReturnType<typeof vi.fn>;
+
+      beforeEach(() => {
+        mockGetLatestApiRequest = vi.fn();
+        if (!mockContext.services.agentContext!.config) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (mockContext.services.agentContext!.config as any) = {};
+        }
+        mockContext.services.agentContext!.config.getLatestApiRequest =
+          mockGetLatestApiRequest;
+        vi.spyOn(process, 'cwd').mockReturnValue('/project/root');
+        vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+        mockFs.writeFile.mockClear();
+      });
+
+      it('should return an error if no API request is found', async () => {
+        mockGetLatestApiRequest.mockReturnValue(undefined);
+
+        const result = await debugCommand.action?.(mockContext, '');
+
+        expect(result).toEqual({
+          type: 'message',
+          messageType: 'error',
+          content: 'No recent API request found to export.',
+        });
+        expect(mockFs.writeFile).not.toHaveBeenCalled();
+      });
+
+      it('should convert and write the API request to a json file', async () => {
+        const mockRequest = {
+          contents: [{ role: 'user', parts: [{ text: 'test' }] }],
+        };
+        mockGetLatestApiRequest.mockReturnValue(mockRequest);
+
+        const result = await debugCommand.action?.(mockContext, '');
+
+        const expectedFilename = 'gcli-request-1234567890.json';
+        const expectedPath = path.join('/project/root', expectedFilename);
+
+        expect(mockFs.writeFile).toHaveBeenCalledWith(
+          expectedPath,
+          expect.stringContaining('"role": "user"'),
+        );
+        expect(result).toEqual({
+          type: 'message',
+          messageType: 'info',
+          content: `Debug API request saved to ${expectedFilename}`,
+        });
+      });
+
+      it('should handle errors during file write', async () => {
+        const mockRequest = { contents: [] };
+        mockGetLatestApiRequest.mockReturnValue(mockRequest);
+        mockFs.writeFile.mockRejectedValue(new Error('Write failed'));
+
+        const result = await debugCommand.action?.(mockContext, '');
+
+        expect(result).toEqual({
+          type: 'message',
+          messageType: 'error',
+          content: 'Error saving debug request: Write failed',
+        });
+      });
+    });
+  });
+});

packages/cli/src/ui/commands/chatCommand.ts

@@ -0,0 +1,430 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fsPromises from 'node:fs/promises';
+import React from 'react';
+import { Text } from 'ink';
+import { theme } from '../semantic-colors.js';
+import type {
+  CommandContext,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import {
+  decodeTagName,
+  type MessageActionReturn,
+  INITIAL_HISTORY_LENGTH,
+} from '@google/gemini-cli-core';
+import path from 'node:path';
+import type {
+  HistoryItemWithoutId,
+  HistoryItemChatList,
+  ChatDetail,
+} from '../types.js';
+import { MessageType } from '../types.js';
+import { exportHistoryToFile } from '../utils/historyExportUtils.js';
+import { convertToRestPayload } from '@google/gemini-cli-core';
+
+const CHECKPOINT_MENU_GROUP = 'checkpoints';
+
+const getSavedChatTags = async (
+  context: CommandContext,
+  mtSortDesc: boolean,
+): Promise<ChatDetail[]> => {
+  const cfg = context.services.agentContext?.config;
+  const geminiDir = cfg?.storage?.getProjectTempDir();
+  if (!geminiDir) {
+    return [];
+  }
+  try {
+    const file_head = 'checkpoint-';
+    const file_tail = '.json';
+    const files = await fsPromises.readdir(geminiDir);
+    const chatDetails: ChatDetail[] = [];
+
+    for (const file of files) {
+      if (file.startsWith(file_head) && file.endsWith(file_tail)) {
+        const filePath = path.join(geminiDir, file);
+        const stats = await fsPromises.stat(filePath);
+        const tagName = file.slice(file_head.length, -file_tail.length);
+        chatDetails.push({
+          name: decodeTagName(tagName),
+          mtime: stats.mtime.toISOString(),
+        });
+      }
+    }
+
+    chatDetails.sort((a, b) =>
+      mtSortDesc
+        ? b.mtime.localeCompare(a.mtime)
+        : a.mtime.localeCompare(b.mtime),
+    );
+
+    return chatDetails;
+  } catch {
+    return [];
+  }
+};
+
+const listCommand: SlashCommand = {
+  name: 'list',
+  description: 'List saved manual conversation checkpoints',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  takesArgs: false,
+  action: async (context): Promise<void> => {
+    const chatDetails = await getSavedChatTags(context, false);
+
+    const item: HistoryItemChatList = {
+      type: MessageType.CHAT_LIST,
+      chats: chatDetails,
+    };
+
+    context.ui.addItem(item);
+  },
+};
+
+const saveCommand: SlashCommand = {
+  name: 'save',
+  description:
+    'Save the current conversation as a checkpoint. Usage: /resume save <tag>',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: async (context, args): Promise<SlashCommandActionReturn | void> => {
+    const tag = args.trim();
+    if (!tag) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume save <tag>',
+      };
+    }
+
+    const { logger } = context.services;
+    const config = context.services.agentContext?.config;
+    await logger.initialize();
+
+    if (!context.overwriteConfirmed) {
+      const exists = await logger.checkpointExists(tag);
+      if (exists) {
+        return {
+          type: 'confirm_action',
+          prompt: React.createElement(
+            Text,
+            null,
+            'A checkpoint with the tag ',
+            React.createElement(Text, { color: theme.text.accent }, tag),
+            ' already exists. Do you want to overwrite it?',
+          ),
+          originalInvocation: {
+            raw: context.invocation?.raw || `/resume save ${tag}`,
+          },
+        };
+      }
+    }
+
+    const chat = context.services.agentContext?.geminiClient?.getChat();
+    if (!chat) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No chat client available to save conversation.',
+      };
+    }
+
+    const history = chat.getHistory();
+    if (history.length > INITIAL_HISTORY_LENGTH) {
+      const authType = config?.getContentGeneratorConfig()?.authType;
+      await logger.saveCheckpoint({ history, authType }, tag);
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint saved with tag: ${decodeTagName(
+          tag,
+        )}.`,
+      };
+    } else {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: 'No conversation found to save.',
+      };
+    }
+  },
+};
+
+const resumeCheckpointCommand: SlashCommand = {
+  name: 'resume',
+  altNames: ['load'],
+  description:
+    'Resume a conversation from a checkpoint. Usage: /resume resume <tag>',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context, args) => {
+    const tag = args.trim();
+    if (!tag) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume resume <tag>',
+      };
+    }
+
+    const { logger } = context.services;
+    const config = context.services.agentContext?.config;
+    await logger.initialize();
+    const checkpoint = await logger.loadCheckpoint(tag);
+    const conversation = checkpoint.history;
+
+    if (conversation.length === 0) {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `No saved checkpoint found with tag: ${decodeTagName(tag)}.`,
+      };
+    }
+
+    const currentAuthType = config?.getContentGeneratorConfig()?.authType;
+    if (
+      checkpoint.authType &&
+      currentAuthType &&
+      checkpoint.authType !== currentAuthType
+    ) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Cannot resume chat. It was saved with a different authentication method (${checkpoint.authType}) than the current one (${currentAuthType}).`,
+      };
+    }
+
+    const rolemap: { [key: string]: MessageType } = {
+      user: MessageType.USER,
+      model: MessageType.GEMINI,
+    };
+
+    const uiHistory: HistoryItemWithoutId[] = [];
+
+    for (const item of conversation.slice(INITIAL_HISTORY_LENGTH)) {
+      const text =
+        item.parts
+          ?.filter((m) => !!m.text)
+          .map((m) => m.text)
+          .join('') || '';
+      if (!text) {
+        continue;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      uiHistory.push({
+        type: (item.role && rolemap[item.role]) || MessageType.GEMINI,
+        text,
+      } as HistoryItemWithoutId);
+    }
+    return {
+      type: 'load_history',
+      history: uiHistory,
+      clientHistory: conversation,
+    };
+  },
+  completion: async (context, partialArg) => {
+    const chatDetails = await getSavedChatTags(context, true);
+    return chatDetails
+      .map((chat) => chat.name)
+      .filter((name) => name.startsWith(partialArg));
+  },
+};
+
+const deleteCommand: SlashCommand = {
+  name: 'delete',
+  description: 'Delete a conversation checkpoint. Usage: /resume delete <tag>',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context, args): Promise<MessageActionReturn> => {
+    const tag = args.trim();
+    if (!tag) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Missing tag. Usage: /resume delete <tag>',
+      };
+    }
+
+    const { logger } = context.services;
+    await logger.initialize();
+    const deleted = await logger.deleteCheckpoint(tag);
+
+    if (deleted) {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation checkpoint '${decodeTagName(tag)}' has been deleted.`,
+      };
+    } else {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Error: No checkpoint found with tag '${decodeTagName(tag)}'.`,
+      };
+    }
+  },
+  completion: async (context, partialArg) => {
+    const chatDetails = await getSavedChatTags(context, true);
+    return chatDetails
+      .map((chat) => chat.name)
+      .filter((name) => name.startsWith(partialArg));
+  },
+};
+
+const shareCommand: SlashCommand = {
+  name: 'share',
+  description:
+    'Share the current conversation to a markdown or json file. Usage: /resume share <file>',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: async (context, args): Promise<MessageActionReturn> => {
+    let filePathArg = args.trim();
+    if (!filePathArg) {
+      filePathArg = `gemini-conversation-${Date.now()}.json`;
+    }
+
+    const filePath = path.resolve(filePathArg);
+    const extension = path.extname(filePath);
+    if (extension !== '.md' && extension !== '.json') {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Invalid file format. Only .md and .json are supported.',
+      };
+    }
+
+    const chat = context.services.agentContext?.geminiClient?.getChat();
+    if (!chat) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No chat client available to share conversation.',
+      };
+    }
+
+    const history = chat.getHistory();
+
+    // An empty conversation has a hidden message that sets up the context for
+    // the chat. Thus, to check whether a conversation has been started, we
+    // can't check for length 0.
+    if (history.length <= INITIAL_HISTORY_LENGTH) {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: 'No conversation found to share.',
+      };
+    }
+
+    try {
+      await exportHistoryToFile({ history, filePath });
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Conversation shared to ${filePath}`,
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Error sharing conversation: ${errorMessage}`,
+      };
+    }
+  },
+};
+
+export const debugCommand: SlashCommand = {
+  name: 'debug',
+  description: 'Export the most recent API request as a JSON payload',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context): Promise<MessageActionReturn> => {
+    const req = context.services.agentContext?.config.getLatestApiRequest();
+    if (!req) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No recent API request found to export.',
+      };
+    }
+
+    const restPayload = convertToRestPayload(req);
+    const filename = `gcli-request-${Date.now()}.json`;
+    const filePath = path.join(process.cwd(), filename);
+
+    try {
+      await fsPromises.writeFile(
+        filePath,
+        JSON.stringify(restPayload, null, 2),
+      );
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Debug API request saved to ${filename}`,
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Error saving debug request: ${errorMessage}`,
+      };
+    }
+  },
+};
+
+export const checkpointSubCommands: SlashCommand[] = [
+  listCommand,
+  saveCommand,
+  resumeCheckpointCommand,
+  deleteCommand,
+  shareCommand,
+];
+
+const checkpointCompatibilityCommand: SlashCommand = {
+  name: 'checkpoints',
+  altNames: ['checkpoint'],
+  description: 'Compatibility command for nested checkpoint operations',
+  kind: CommandKind.BUILT_IN,
+  hidden: true,
+  autoExecute: false,
+  subCommands: checkpointSubCommands,
+};
+
+export const chatResumeSubCommands: SlashCommand[] = [
+  ...checkpointSubCommands.map((subCommand) => ({
+    ...subCommand,
+    suggestionGroup: CHECKPOINT_MENU_GROUP,
+  })),
+  checkpointCompatibilityCommand,
+];
+
+import { parseSlashCommand } from '../../utils/commands.js';
+
+export const chatCommand: SlashCommand = {
+  name: 'chat',
+  description: 'Browse auto-saved conversations and manage chat checkpoints',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context, args) => {
+    if (args) {
+      const parsed = parseSlashCommand(`/${args}`, chatResumeSubCommands);
+      if (parsed.commandToExecute?.action) {
+        return parsed.commandToExecute.action(context, parsed.args);
+      }
+    }
+    return {
+      type: 'dialog',
+      dialog: 'sessionBrowser',
+    };
+  },
+  subCommands: chatResumeSubCommands,
+};

packages/cli/src/ui/commands/clearCommand.test.ts

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
+import { clearCommand } from './clearCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+// Mock the telemetry service
+vi.mock('@google/gemini-cli-core', async () => {
+  const actual = await vi.importActual('@google/gemini-cli-core');
+  return {
+    ...actual,
+    uiTelemetryService: {
+      setLastPromptTokenCount: vi.fn(),
+      clear: vi.fn(),
+    },
+  };
+});
+
+import { uiTelemetryService, type GeminiClient } from '@google/gemini-cli-core';
+
+describe('clearCommand', () => {
+  let mockContext: CommandContext;
+  let mockResetChat: ReturnType<typeof vi.fn>;
+  let mockHintClear: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockResetChat = vi.fn().mockResolvedValue(undefined);
+    mockHintClear = vi.fn();
+    const mockGetChatRecordingService = vi.fn();
+    vi.clearAllMocks();
+
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getEnableHooks: vi.fn().mockReturnValue(false),
+            resetNewSessionState: vi.fn(),
+            getMessageBus: vi.fn().mockReturnValue(undefined),
+            getHookSystem: vi.fn().mockReturnValue({
+              fireSessionEndEvent: vi.fn().mockResolvedValue(undefined),
+              fireSessionStartEvent: vi.fn().mockResolvedValue(undefined),
+            }),
+            injectionService: {
+              clear: mockHintClear,
+            },
+          },
+          geminiClient: {
+            resetChat: mockResetChat,
+            getChat: () => ({
+              getChatRecordingService: mockGetChatRecordingService,
+            }),
+          } as unknown as GeminiClient,
+        },
+      },
+    });
+  });
+
+  it('should set debug message, reset chat, reset telemetry, clear hints, and clear UI when config is available', async () => {
+    if (!clearCommand.action) {
+      throw new Error('clearCommand must have an action.');
+    }
+
+    await clearCommand.action(mockContext, '');
+
+    expect(mockContext.ui.setDebugMessage).toHaveBeenCalledWith(
+      'Clearing terminal and resetting chat.',
+    );
+    expect(mockContext.ui.setDebugMessage).toHaveBeenCalledTimes(1);
+
+    expect(mockResetChat).toHaveBeenCalledTimes(1);
+    expect(mockHintClear).toHaveBeenCalledTimes(1);
+    expect(
+      mockContext.services.agentContext?.config.resetNewSessionState,
+    ).toHaveBeenCalledTimes(1);
+    expect(uiTelemetryService.clear).toHaveBeenCalled();
+    expect(uiTelemetryService.clear).toHaveBeenCalledTimes(1);
+    expect(mockContext.ui.clear).toHaveBeenCalledTimes(1);
+
+    // Check the order of operations.
+    const setDebugMessageOrder = (mockContext.ui.setDebugMessage as Mock).mock
+      .invocationCallOrder[0];
+    const resetChatOrder = mockResetChat.mock.invocationCallOrder[0];
+    const resetTelemetryOrder = (uiTelemetryService.clear as Mock).mock
+      .invocationCallOrder[0];
+    const clearOrder = (mockContext.ui.clear as Mock).mock
+      .invocationCallOrder[0];
+
+    expect(setDebugMessageOrder).toBeLessThan(resetChatOrder);
+    expect(resetChatOrder).toBeLessThan(resetTelemetryOrder);
+    expect(resetTelemetryOrder).toBeLessThan(clearOrder);
+  });
+
+  it('should not attempt to reset chat if config service is not available', async () => {
+    if (!clearCommand.action) {
+      throw new Error('clearCommand must have an action.');
+    }
+
+    const nullConfigContext = createMockCommandContext({
+      services: {
+        agentContext: null,
+      },
+    });
+
+    await clearCommand.action(nullConfigContext, '');
+
+    expect(nullConfigContext.ui.setDebugMessage).toHaveBeenCalledWith(
+      'Clearing terminal.',
+    );
+    expect(mockResetChat).not.toHaveBeenCalled();
+    expect(uiTelemetryService.clear).toHaveBeenCalled();
+    expect(uiTelemetryService.clear).toHaveBeenCalledTimes(1);
+    expect(nullConfigContext.ui.clear).toHaveBeenCalledTimes(1);
+  });
+});

packages/cli/src/ui/commands/clearCommand.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  uiTelemetryService,
+  SessionEndReason,
+  SessionStartSource,
+  flushTelemetry,
+  resetBrowserSession,
+} from '@google/gemini-cli-core';
+import { CommandKind, type SlashCommand } from './types.js';
+import { MessageType } from '../types.js';
+import { randomUUID } from 'node:crypto';
+
+export const clearCommand: SlashCommand = {
+  name: 'clear',
+  altNames: ['new'],
+  description: 'Clear the screen and start a new session',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context, _args) => {
+    const geminiClient = context.services.agentContext?.geminiClient;
+    const config = context.services.agentContext?.config;
+
+    // Fire SessionEnd hook before clearing
+    const hookSystem = config?.getHookSystem();
+    if (hookSystem) {
+      await hookSystem.fireSessionEndEvent(SessionEndReason.Clear);
+    }
+
+    // Reset user steering hints
+    config?.injectionService.clear();
+
+    // Start a new conversation recording with a new session ID
+    // We MUST do this before calling resetChat() so the new ChatRecordingService
+    // initialized by GeminiChat picks up the new session ID.
+    let newSessionId: string | undefined;
+    if (config) {
+      newSessionId = randomUUID();
+      config.resetNewSessionState(newSessionId);
+    }
+
+    if (geminiClient) {
+      context.ui.setDebugMessage('Clearing terminal and resetting chat.');
+
+      // Close persistent browser sessions before resetting chat
+      await resetBrowserSession();
+
+      // If resetChat fails, the exception will propagate and halt the command,
+      // which is the correct behavior to signal a failure to the user.
+      await geminiClient.resetChat();
+    } else {
+      context.ui.setDebugMessage('Clearing terminal.');
+    }
+
+    // Fire SessionStart hook after clearing
+    let result;
+    if (hookSystem) {
+      result = await hookSystem.fireSessionStartEvent(SessionStartSource.Clear);
+    }
+
+    // Give the event loop a chance to process any pending telemetry operations
+    // This ensures logger.emit() calls have fully propagated to the BatchLogRecordProcessor
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Flush telemetry to ensure hooks are written to disk immediately
+    // This is critical for tests and environments with I/O latency
+    if (config) {
+      await flushTelemetry(config);
+    }
+
+    uiTelemetryService.clear(newSessionId);
+    context.ui.clear();
+
+    if (result?.systemMessage) {
+      context.ui.addItem(
+        {
+          type: MessageType.INFO,
+          text: result.systemMessage,
+        },
+        Date.now(),
+      );
+    }
+  },
+};

packages/cli/src/ui/commands/commandsCommand.test.ts

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Storage, type Config } from '@google/gemini-cli-core';
+import { commandsCommand } from './commandsCommand.js';
+import { MessageType } from '../types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { CommandContext } from './types.js';
+import { FileCommandLoader } from '../../services/FileCommandLoader.js';
+
+vi.mock('../../services/FileCommandLoader.js');
+
+vi.mock('@google/gemini-cli-core', async () => {
+  const actual = await vi.importActual<
+    typeof import('@google/gemini-cli-core')
+  >('@google/gemini-cli-core');
+  return {
+    ...actual,
+    Storage: class extends actual.Storage {
+      static override getUserCommandsDir() {
+        return '/mock/user/commands';
+      }
+      override getProjectCommandsDir() {
+        return '/mock/project/commands';
+      }
+    },
+  };
+});
+
+describe('commandsCommand', () => {
+  let context: CommandContext;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    context = createMockCommandContext({
+      ui: {
+        reloadCommands: vi.fn(),
+        addItem: vi.fn(),
+      },
+      services: {
+        agentContext: {
+          getProjectRoot: vi.fn().mockReturnValue('/mock/project'),
+          getFolderTrust: vi.fn().mockReturnValue(false),
+          isTrustedFolder: vi.fn().mockReturnValue(false),
+          getExtensions: vi.fn().mockReturnValue([
+            { name: 'ext1', path: '/mock/ext1', isActive: true },
+            { name: 'ext2', path: '/mock/ext2', isActive: false },
+          ]),
+          storage: new Storage('/mock/project'),
+        } as unknown as Config,
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('default action', () => {
+    it('should return an info message prompting subcommand usage', async () => {
+      const result = await commandsCommand.action!(context, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content:
+          'Use "/commands list" to view available .toml files, or "/commands reload" to reload custom command definitions.',
+      });
+    });
+  });
+
+  describe('list', () => {
+    it('should list .toml files from available sources', async () => {
+      vi.mocked(
+        FileCommandLoader.prototype.listAvailableFiles,
+      ).mockResolvedValue([
+        {
+          displayName: 'User',
+          path: '/mock/user/commands',
+          files: ['user1.toml'],
+        },
+        {
+          displayName: 'Project',
+          path: '/mock/project/commands',
+          files: ['proj1.toml'],
+        },
+        {
+          displayName: 'Extension: ext1',
+          path: '/mock/ext1/commands',
+          files: ['ext1.toml'],
+        },
+      ]);
+
+      const listCmd = commandsCommand.subCommands!.find(
+        (s) => s.name === 'list',
+      )!;
+
+      await listCmd.action!(context, '');
+
+      expect(context.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: expect.any(String),
+        }),
+        expect.any(Number),
+      );
+
+      // Snapshot the text content
+      const addItemCall = vi.mocked(context.ui.addItem).mock.calls[0][0];
+
+      expect((addItemCall as { text: string }).text).toMatchSnapshot();
+    });
+
+    it('should show "No custom command files found" message if no .toml files exist', async () => {
+      vi.mocked(
+        FileCommandLoader.prototype.listAvailableFiles,
+      ).mockResolvedValue([]);
+
+      const listCmd = commandsCommand.subCommands!.find(
+        (s) => s.name === 'list',
+      )!;
+
+      const result = await listCmd.action!(context, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining(
+          'No custom command files (.toml) found.',
+        ),
+      });
+    });
+  });
+
+  describe('reload', () => {
+    it('should call reloadCommands and show a success message', async () => {
+      const reloadCmd = commandsCommand.subCommands!.find(
+        (s) => s.name === 'reload',
+      )!;
+
+      await reloadCmd.action!(context, '');
+
+      expect(context.ui.reloadCommands).toHaveBeenCalledTimes(1);
+      expect(context.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: 'Custom commands reloaded successfully.',
+        }),
+        expect.any(Number),
+      );
+    });
+  });
+});

packages/cli/src/ui/commands/commandsCommand.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { FileCommandLoader } from '../../services/FileCommandLoader.js';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import {
+  MessageType,
+  type HistoryItemError,
+  type HistoryItemInfo,
+} from '../types.js';
+
+/**
+ * Action for the default `/commands` invocation.
+ * Displays a message prompting the user to use a subcommand.
+ */
+async function defaultAction(
+  _context: CommandContext,
+  _args: string,
+): Promise<void | SlashCommandActionReturn> {
+  return {
+    type: 'message',
+    messageType: 'info',
+    content:
+      'Use "/commands list" to view available .toml files, or "/commands reload" to reload custom command definitions.',
+  };
+}
+
+/**
+ * Action for `/commands list`.
+ * Lists available .toml command files from user, project, and extension directories.
+ */
+async function listSubcommandAction(
+  context: CommandContext,
+): Promise<void | SlashCommandActionReturn> {
+  try {
+    const config = context.services.agentContext?.config ?? null;
+    const loader = new FileCommandLoader(config);
+    const groups = await loader.listAvailableFiles();
+
+    const results: string[] = [];
+    for (const group of groups) {
+      results.push(`### ${group.displayName} Commands (${group.path})`);
+      if (group.error) {
+        results.push(`- (Error reading directory: ${group.error})`);
+      } else {
+        group.files.forEach((file) => results.push(`- ${file}`));
+      }
+    }
+
+    results.push(
+      '\n_Note: MCP prompts are dynamically loaded from configured MCP servers._',
+    );
+
+    if (results.length === 1) {
+      // Only the note is present
+      return {
+        type: 'message',
+        messageType: 'info',
+        content:
+          'No custom command files (.toml) found.\n\n_Note: MCP prompts are dynamically loaded from configured MCP servers._',
+      };
+    }
+
+    context.ui.addItem(
+      {
+        type: MessageType.INFO,
+        text: results.join('\n'),
+      } as HistoryItemInfo,
+      Date.now(),
+    );
+  } catch (error) {
+    context.ui.addItem(
+      {
+        type: MessageType.ERROR,
+        text: `Failed to list commands: ${error instanceof Error ? error.message : String(error)}`,
+      } as HistoryItemError,
+      Date.now(),
+    );
+  }
+}
+
+/**
+ * Action for `/commands reload`.
+ * Triggers a full re-discovery and reload of all slash commands, including
+ * user/project-level .toml files, MCP prompts, and extension commands.
+ */
+async function reloadAction(
+  context: CommandContext,
+): Promise<void | SlashCommandActionReturn> {
+  try {
+    context.ui.reloadCommands();
+
+    context.ui.addItem(
+      {
+        type: MessageType.INFO,
+        text: 'Custom commands reloaded successfully.',
+      } as HistoryItemInfo,
+      Date.now(),
+    );
+  } catch (error) {
+    context.ui.addItem(
+      {
+        type: MessageType.ERROR,
+        text: `Failed to reload commands: ${error instanceof Error ? error.message : String(error)}`,
+      } as HistoryItemError,
+      Date.now(),
+    );
+  }
+}
+
+export const commandsCommand: SlashCommand = {
+  name: 'commands',
+  description: 'Manage custom slash commands. Usage: /commands [list|reload]',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  subCommands: [
+    {
+      name: 'list',
+      description:
+        'List available custom command .toml files. Usage: /commands list',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: true,
+      action: listSubcommandAction,
+    },
+    {
+      name: 'reload',
+      altNames: ['refresh'],
+      description:
+        'Reload custom command definitions from .toml files. Usage: /commands reload',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: true,
+      action: reloadAction,
+    },
+  ],
+  action: defaultAction,
+};

packages/cli/src/ui/commands/compressCommand.test.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CompressionStatus,
+  type ChatCompressionInfo,
+  type GeminiClient,
+} from '@google/gemini-cli-core';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { compressCommand } from './compressCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+
+describe('compressCommand', () => {
+  let context: ReturnType<typeof createMockCommandContext>;
+  let mockTryCompressChat: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockTryCompressChat = vi.fn();
+    context = createMockCommandContext({
+      services: {
+        agentContext: {
+          geminiClient: {
+            tryCompressChat: mockTryCompressChat,
+          } as unknown as GeminiClient,
+        },
+      },
+    });
+  });
+
+  it('should do nothing if a compression is already pending', async () => {
+    context.ui.pendingItem = {
+      type: MessageType.COMPRESSION,
+      compression: {
+        isPending: true,
+        originalTokenCount: null,
+        newTokenCount: null,
+        compressionStatus: null,
+      },
+    };
+    await compressCommand.action!(context, '');
+    await new Promise((r) => setTimeout(r, 0));
+    expect(context.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.ERROR,
+        text: 'Already compressing, wait for previous request to complete',
+      }),
+      expect.any(Number),
+    );
+    expect(context.ui.setPendingItem).not.toHaveBeenCalled();
+    expect(mockTryCompressChat).not.toHaveBeenCalled();
+  });
+
+  it('should set pending item, call tryCompressChat, and add result on success', async () => {
+    const compressedResult: ChatCompressionInfo = {
+      originalTokenCount: 200,
+      compressionStatus: CompressionStatus.COMPRESSED,
+      newTokenCount: 100,
+    };
+    mockTryCompressChat.mockResolvedValue(compressedResult);
+
+    await compressCommand.action!(context, '');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(context.ui.setPendingItem).toHaveBeenNthCalledWith(1, {
+      type: MessageType.COMPRESSION,
+      compression: {
+        isPending: true,
+        compressionStatus: null,
+        originalTokenCount: null,
+        newTokenCount: null,
+      },
+    });
+
+    expect(mockTryCompressChat).toHaveBeenCalledWith(
+      expect.stringMatching(/^compress-\d+$/),
+      true,
+    );
+
+    expect(context.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.COMPRESSION,
+        compression: {
+          isPending: false,
+          compressionStatus: CompressionStatus.COMPRESSED,
+          originalTokenCount: 200,
+          newTokenCount: 100,
+        },
+      },
+      expect.any(Number),
+    );
+
+    expect(context.ui.setPendingItem).toHaveBeenNthCalledWith(2, null);
+  });
+
+  it('should add an error message if tryCompressChat returns falsy', async () => {
+    mockTryCompressChat.mockResolvedValue(null);
+
+    await compressCommand.action!(context, '');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(context.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.ERROR,
+        text: 'Failed to compress chat history.',
+      }),
+      expect.any(Number),
+    );
+    expect(context.ui.setPendingItem).toHaveBeenCalledWith(null);
+  });
+
+  it('should add an error message if tryCompressChat throws', async () => {
+    const error = new Error('Compression failed');
+    mockTryCompressChat.mockRejectedValue(error);
+
+    await compressCommand.action!(context, '');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(context.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.ERROR,
+        text: `Failed to compress chat history: ${error.message}`,
+      }),
+      expect.any(Number),
+    );
+    expect(context.ui.setPendingItem).toHaveBeenCalledWith(null);
+  });
+
+  it('should clear the pending item in a finally block', async () => {
+    mockTryCompressChat.mockRejectedValue(new Error('some error'));
+    await compressCommand.action!(context, '');
+    await new Promise((r) => setTimeout(r, 0));
+    expect(context.ui.setPendingItem).toHaveBeenCalledWith(null);
+  });
+
+  describe('metadata', () => {
+    it('should have the correct name and aliases', () => {
+      expect(compressCommand.name).toBe('compress');
+      expect(compressCommand.altNames).toContain('summarize');
+      expect(compressCommand.altNames).toContain('compact');
+    });
+  });
+});

packages/cli/src/ui/commands/compressCommand.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MessageType, type HistoryItemCompression } from '../types.js';
+import { CommandKind, type SlashCommand } from './types.js';
+
+export const compressCommand: SlashCommand = {
+  name: 'compress',
+  altNames: ['summarize', 'compact'],
+  description: 'Compresses the context by replacing it with a summary',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context) => {
+    const { ui } = context;
+    if (ui.pendingItem) {
+      ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: 'Already compressing, wait for previous request to complete',
+        },
+        Date.now(),
+      );
+      return;
+    }
+
+    const pendingMessage: HistoryItemCompression = {
+      type: MessageType.COMPRESSION,
+      compression: {
+        isPending: true,
+        originalTokenCount: null,
+        newTokenCount: null,
+        compressionStatus: null,
+      },
+    };
+
+    ui.setPendingItem(pendingMessage);
+
+    void (async () => {
+      try {
+        const promptId = `compress-${Date.now()}`;
+        const compressed =
+          await context.services.agentContext?.geminiClient?.tryCompressChat(
+            promptId,
+            true,
+          );
+        if (compressed) {
+          ui.addItem(
+            {
+              type: MessageType.COMPRESSION,
+              compression: {
+                isPending: false,
+                originalTokenCount: compressed.originalTokenCount,
+                newTokenCount: compressed.newTokenCount,
+                compressionStatus: compressed.compressionStatus,
+              },
+            } as HistoryItemCompression,
+            Date.now(),
+          );
+        } else {
+          ui.addItem(
+            {
+              type: MessageType.ERROR,
+              text: 'Failed to compress chat history.',
+            },
+            Date.now(),
+          );
+        }
+      } catch (e) {
+        ui.addItem(
+          {
+            type: MessageType.ERROR,
+            text: `Failed to compress chat history: ${
+              e instanceof Error ? e.message : String(e)
+            }`,
+          },
+          Date.now(),
+        );
+      } finally {
+        ui.setPendingItem(null);
+      }
+    })();
+  },
+};

packages/cli/src/ui/commands/copyCommand.test.ts

@@ -0,0 +1,317 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
+import { copyCommand } from './copyCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { copyToClipboard } from '../utils/commandUtils.js';
+
+vi.mock('../utils/commandUtils.js', () => ({
+  copyToClipboard: vi.fn(),
+}));
+
+describe('copyCommand', () => {
+  let mockContext: CommandContext;
+  let mockCopyToClipboard: Mock;
+  let mockGetChat: Mock;
+  let mockGetHistory: Mock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockCopyToClipboard = vi.mocked(copyToClipboard);
+    mockGetChat = vi.fn();
+    mockGetHistory = vi.fn();
+
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          geminiClient: {
+            getChat: mockGetChat,
+          },
+        },
+      },
+    });
+
+    mockGetChat.mockReturnValue({
+      getHistory: mockGetHistory,
+    });
+  });
+
+  it('should return info message when no history is available', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    mockGetChat.mockReturnValue(undefined);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'No output in history',
+    });
+
+    expect(mockCopyToClipboard).not.toHaveBeenCalled();
+  });
+
+  it('should return info message when history is empty', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    mockGetHistory.mockReturnValue([]);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'No output in history',
+    });
+
+    expect(mockCopyToClipboard).not.toHaveBeenCalled();
+  });
+
+  it('should return info message when no AI messages are found in history', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithUserOnly = [
+      {
+        role: 'user',
+        parts: [{ text: 'Hello' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithUserOnly);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'No output in history',
+    });
+
+    expect(mockCopyToClipboard).not.toHaveBeenCalled();
+  });
+
+  it('should copy last AI message to clipboard successfully', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithAiMessage = [
+      {
+        role: 'user',
+        parts: [{ text: 'Hello' }],
+      },
+      {
+        role: 'model',
+        parts: [{ text: 'Hi there! How can I help you?' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithAiMessage);
+    mockCopyToClipboard.mockResolvedValue(undefined);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Last output copied to the clipboard',
+    });
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'Hi there! How can I help you?',
+      expect.anything(),
+    );
+  });
+
+  it('should handle multiple text parts in AI message', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithMultipleParts = [
+      {
+        role: 'model',
+        parts: [{ text: 'Part 1: ' }, { text: 'Part 2: ' }, { text: 'Part 3' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithMultipleParts);
+    mockCopyToClipboard.mockResolvedValue(undefined);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'Part 1: Part 2: Part 3',
+      expect.anything(),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Last output copied to the clipboard',
+    });
+  });
+
+  it('should filter out non-text parts', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithMixedParts = [
+      {
+        role: 'model',
+        parts: [
+          { text: 'Text part' },
+          { image: 'base64data' }, // Non-text part
+          { text: ' more text' },
+        ],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithMixedParts);
+    mockCopyToClipboard.mockResolvedValue(undefined);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'Text part more text',
+      expect.anything(),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Last output copied to the clipboard',
+    });
+  });
+
+  it('should get the last AI message when multiple AI messages exist', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithMultipleAiMessages = [
+      {
+        role: 'model',
+        parts: [{ text: 'First AI response' }],
+      },
+      {
+        role: 'user',
+        parts: [{ text: 'User message' }],
+      },
+      {
+        role: 'model',
+        parts: [{ text: 'Second AI response' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithMultipleAiMessages);
+    mockCopyToClipboard.mockResolvedValue(undefined);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'Second AI response',
+      expect.anything(),
+    );
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Last output copied to the clipboard',
+    });
+  });
+
+  it('should handle clipboard copy error', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithAiMessage = [
+      {
+        role: 'model',
+        parts: [{ text: 'AI response' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithAiMessage);
+    const clipboardError = new Error('Clipboard access denied');
+    mockCopyToClipboard.mockRejectedValue(clipboardError);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to copy to the clipboard. ${clipboardError.message}`,
+    });
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'AI response',
+      expect.anything(),
+    );
+  });
+
+  it('should handle non-Error clipboard errors', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithAiMessage = [
+      {
+        role: 'model',
+        parts: [{ text: 'AI response' }],
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithAiMessage);
+    const rejectedValue = 'String error';
+    mockCopyToClipboard.mockRejectedValue(rejectedValue);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to copy to the clipboard. ${rejectedValue}`,
+    });
+
+    expect(mockCopyToClipboard).toHaveBeenCalledWith(
+      'AI response',
+      expect.anything(),
+    );
+  });
+
+  it('should return info message when no text parts found in AI message', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const historyWithEmptyParts = [
+      {
+        role: 'model',
+        parts: [{ image: 'base64data' }], // No text parts
+      },
+    ];
+
+    mockGetHistory.mockReturnValue(historyWithEmptyParts);
+
+    const result = await copyCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'Last AI output contains no text to copy.',
+    });
+
+    expect(mockCopyToClipboard).not.toHaveBeenCalled();
+  });
+
+  it('should handle unavailable config service', async () => {
+    if (!copyCommand.action) throw new Error('Command has no action');
+
+    const nullConfigContext = createMockCommandContext({
+      services: { agentContext: null },
+    });
+
+    const result = await copyCommand.action(nullConfigContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: 'No output in history',
+    });
+
+    expect(mockCopyToClipboard).not.toHaveBeenCalled();
+  });
+});

packages/cli/src/ui/commands/copyCommand.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { debugLogger } from '@google/gemini-cli-core';
+import { copyToClipboard } from '../utils/commandUtils.js';
+import {
+  CommandKind,
+  type SlashCommand,
+  type SlashCommandActionReturn,
+} from './types.js';
+
+export const copyCommand: SlashCommand = {
+  name: 'copy',
+  description: 'Copy the last result or code snippet to clipboard',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context, _args): Promise<SlashCommandActionReturn | void> => {
+    const chat = context.services.agentContext?.geminiClient?.getChat();
+    const history = chat?.getHistory();
+
+    // Get the last message from the AI (model role)
+    const lastAiMessage = history
+      ? history.filter((item) => item.role === 'model').pop()
+      : undefined;
+
+    if (!lastAiMessage) {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: 'No output in history',
+      };
+    }
+    // Extract text from the parts
+    const lastAiOutput = lastAiMessage.parts
+      ?.filter((part) => part.text)
+      .map((part) => part.text)
+      .join('');
+
+    if (lastAiOutput) {
+      try {
+        const settings = context.services.settings.merged;
+        await copyToClipboard(lastAiOutput, settings);
+
+        return {
+          type: 'message',
+          messageType: 'info',
+          content: 'Last output copied to the clipboard',
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        debugLogger.debug(message);
+
+        return {
+          type: 'message',
+          messageType: 'error',
+          content: `Failed to copy to the clipboard. ${message}`,
+        };
+      }
+    } else {
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: 'Last AI output contains no text to copy.',
+      };
+    }
+  },
+};

packages/cli/src/ui/commands/corgiCommand.test.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { corgiCommand } from './corgiCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('corgiCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext();
+    vi.spyOn(mockContext.ui, 'toggleCorgiMode');
+  });
+
+  it('should call the toggleCorgiMode function on the UI context', async () => {
+    if (!corgiCommand.action) {
+      throw new Error('The corgi command must have an action.');
+    }
+
+    await corgiCommand.action(mockContext, '');
+
+    expect(mockContext.ui.toggleCorgiMode).toHaveBeenCalledTimes(1);
+  });
+
+  it('should have the correct name and description', () => {
+    expect(corgiCommand.name).toBe('corgi');
+    expect(corgiCommand.description).toBe('Toggles corgi mode');
+  });
+});

packages/cli/src/ui/commands/corgiCommand.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, type SlashCommand } from './types.js';
+
+export const corgiCommand: SlashCommand = {
+  name: 'corgi',
+  description: 'Toggles corgi mode',
+  hidden: true,
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: (context, _args) => {
+    context.ui.toggleCorgiMode();
+  },
+};

packages/cli/src/ui/commands/directoryCommand.test.tsx

@@ -0,0 +1,461 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  type Mock,
+} from 'vitest';
+import { directoryCommand } from './directoryCommand.js';
+import {
+  expandHomeDir,
+  getDirectorySuggestions,
+} from '../utils/directoryUtils.js';
+import type { Config, WorkspaceContext } from '@google/gemini-cli-core';
+import type { MultiFolderTrustDialogProps } from '../components/MultiFolderTrustDialog.js';
+import type { CommandContext, OpenCustomDialogActionReturn } from './types.js';
+import { MessageType } from '../types.js';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as trustedFolders from '../../config/trustedFolders.js';
+import type { LoadedTrustedFolders } from '../../config/trustedFolders.js';
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    realpathSync: vi.fn((p) => p),
+  };
+});
+
+vi.mock('../utils/directoryUtils.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../utils/directoryUtils.js')>();
+  return {
+    ...actual,
+    getDirectorySuggestions: vi.fn(),
+  };
+});
+
+describe('directoryCommand', () => {
+  let mockContext: CommandContext;
+  let mockConfig: Config;
+  let mockWorkspaceContext: WorkspaceContext;
+  const addCommand = directoryCommand.subCommands?.find(
+    (c) => c.name === 'add',
+  );
+  const showCommand = directoryCommand.subCommands?.find(
+    (c) => c.name === 'show',
+  );
+
+  beforeEach(() => {
+    mockWorkspaceContext = {
+      targetDir: path.resolve('/test/dir'),
+      addDirectory: vi.fn(),
+      addDirectories: vi.fn().mockReturnValue({ added: [], failed: [] }),
+      getDirectories: vi
+        .fn()
+        .mockReturnValue([
+          path.resolve('/home/user/project1'),
+          path.resolve('/home/user/project2'),
+        ]),
+    } as unknown as WorkspaceContext;
+
+    mockConfig = {
+      getWorkspaceContext: () => mockWorkspaceContext,
+      isRestrictiveSandbox: vi.fn().mockReturnValue(false),
+      getGeminiClient: vi.fn().mockReturnValue({
+        addDirectoryContext: vi.fn(),
+        getChatRecordingService: vi.fn().mockReturnValue({
+          recordDirectories: vi.fn(),
+        }),
+      }),
+      getWorkingDir: () => path.resolve('/test/dir'),
+      shouldLoadMemoryFromIncludeDirectories: () => false,
+      getMemoryContextManager: vi.fn(),
+      getDebugMode: () => false,
+      getFileService: () => ({}),
+      getFileFilteringOptions: () => ({ ignore: [], include: [] }),
+      setUserMemory: vi.fn(),
+      setGeminiMdFileCount: vi.fn(),
+      get config() {
+        return this;
+      },
+    } as unknown as Config;
+
+    mockContext = {
+      services: {
+        agentContext: mockConfig,
+        settings: {
+          merged: {
+            memoryDiscoveryMaxDirs: 1000,
+            security: {
+              folderTrust: {
+                enabled: false,
+              },
+            },
+          },
+        },
+      },
+      ui: {
+        addItem: vi.fn(),
+      },
+    } as unknown as CommandContext;
+  });
+
+  describe('show', () => {
+    it('should display the list of directories', () => {
+      if (!showCommand?.action) throw new Error('No action');
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      showCommand.action(mockContext, '');
+      expect(mockWorkspaceContext.getDirectories).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `Current workspace directories:\n- ${path.resolve(
+            '/home/user/project1',
+          )}\n- ${path.resolve('/home/user/project2')}`,
+        }),
+      );
+    });
+  });
+
+  describe('add', () => {
+    it('should show an error in a restrictive sandbox', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      vi.mocked(mockConfig.isRestrictiveSandbox).mockReturnValue(true);
+      const result = await addCommand.action(mockContext, '/some/path');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content:
+          'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.',
+      });
+    });
+
+    it('should show an error if no path is provided', () => {
+      if (!addCommand?.action) throw new Error('No action');
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      addCommand.action(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: 'Please provide at least one path to add.',
+        }),
+      );
+    });
+
+    it('should call addDirectory and show a success message for a single path', async () => {
+      const newPath = path.resolve('/home/user/new-project');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [newPath],
+        failed: [],
+      });
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, newPath);
+      expect(mockWorkspaceContext.addDirectories).toHaveBeenCalledWith([
+        newPath,
+      ]);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `Successfully added directories:\n- ${newPath}`,
+        }),
+      );
+    });
+
+    it('should call addDirectory for each path and show a success message for multiple paths', async () => {
+      const newPath1 = path.resolve('/home/user/new-project1');
+      const newPath2 = path.resolve('/home/user/new-project2');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [newPath1, newPath2],
+        failed: [],
+      });
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, `${newPath1},${newPath2}`);
+      expect(mockWorkspaceContext.addDirectories).toHaveBeenCalledWith([
+        newPath1,
+        newPath2,
+      ]);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `Successfully added directories:\n- ${newPath1}\n- ${newPath2}`,
+        }),
+      );
+    });
+
+    it('should show an error if addDirectory throws an exception', async () => {
+      const error = new Error('Directory does not exist');
+      const newPath = path.resolve('/home/user/invalid-project');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [],
+        failed: [{ path: newPath, error }],
+      });
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, newPath);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: `Error adding '${newPath}': ${error.message}`,
+        }),
+      );
+    });
+
+    it('should add directory directly when folder trust is disabled', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      vi.spyOn(trustedFolders, 'isFolderTrustEnabled').mockReturnValue(false);
+      const newPath = path.resolve('/home/user/new-project');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [newPath],
+        failed: [],
+      });
+
+      await addCommand.action(mockContext, newPath);
+
+      expect(mockWorkspaceContext.addDirectories).toHaveBeenCalledWith([
+        newPath,
+      ]);
+    });
+
+    it('should show an info message for an already added directory', async () => {
+      const existingPath = path.resolve('/home/user/project1');
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, existingPath);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `The following directories are already in the workspace:\n- ${existingPath}`,
+        }),
+      );
+      expect(mockWorkspaceContext.addDirectory).not.toHaveBeenCalledWith(
+        existingPath,
+      );
+    });
+
+    it('should show an info message for an already added directory specified as a relative path', async () => {
+      const existingPath = path.resolve('/home/user/project1');
+      const relativePath = './project1';
+      const absoluteRelativePath = path.resolve(
+        path.resolve('/test/dir'),
+        relativePath,
+      );
+
+      vi.mocked(fs.realpathSync).mockImplementation((p) => {
+        if (p === absoluteRelativePath) return existingPath;
+        return p as string;
+      });
+
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, relativePath);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `The following directories are already in the workspace:\n- ${relativePath}`,
+        }),
+      );
+    });
+
+    it('should handle a mix of successful and failed additions', async () => {
+      const validPath = path.resolve('/home/user/valid-project');
+      const invalidPath = path.resolve('/home/user/invalid-project');
+      const error = new Error('Directory does not exist');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [validPath],
+        failed: [{ path: invalidPath, error }],
+      });
+
+      if (!addCommand?.action) throw new Error('No action');
+      await addCommand.action(mockContext, `${validPath},${invalidPath}`);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `Successfully added directories:\n- ${validPath}`,
+        }),
+      );
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: `Error adding '${invalidPath}': ${error.message}`,
+        }),
+      );
+    });
+
+    describe('completion', () => {
+      const completion = addCommand!.completion!;
+
+      it('should return empty suggestions for an empty path', async () => {
+        const results = await completion(mockContext, '');
+        expect(results).toEqual([]);
+      });
+
+      it('should return empty suggestions for whitespace only path', async () => {
+        const results = await completion(mockContext, '  ');
+        expect(results).toEqual([]);
+      });
+
+      it('should return suggestions for a single path', async () => {
+        vi.mocked(getDirectorySuggestions).mockResolvedValue(['docs/', 'src/']);
+
+        const results = await completion(mockContext, 'd');
+
+        expect(getDirectorySuggestions).toHaveBeenCalledWith('d');
+        expect(results).toEqual(['docs/', 'src/']);
+      });
+
+      it('should return suggestions for multiple paths', async () => {
+        vi.mocked(getDirectorySuggestions).mockResolvedValue(['src/']);
+
+        const results = await completion(mockContext, 'docs/,s');
+
+        expect(getDirectorySuggestions).toHaveBeenCalledWith('s');
+        expect(results).toEqual(['docs/,src/']);
+      });
+
+      it('should handle leading whitespace in suggestions', async () => {
+        vi.mocked(getDirectorySuggestions).mockResolvedValue(['src/']);
+
+        const results = await completion(mockContext, 'docs/, s');
+
+        expect(getDirectorySuggestions).toHaveBeenCalledWith('s');
+        expect(results).toEqual(['docs/, src/']);
+      });
+
+      it('should filter out existing directories from suggestions', async () => {
+        const existingPath = path.resolve(process.cwd(), 'existing');
+        vi.mocked(mockWorkspaceContext.getDirectories).mockReturnValue([
+          existingPath,
+        ]);
+        vi.mocked(getDirectorySuggestions).mockResolvedValue([
+          'existing/',
+          'new/',
+        ]);
+
+        const results = await completion(mockContext, 'ex');
+
+        expect(results).toEqual(['new/']);
+      });
+    });
+  });
+
+  describe('add with folder trust enabled', () => {
+    let mockIsPathTrusted: Mock;
+
+    beforeEach(() => {
+      vi.spyOn(trustedFolders, 'isFolderTrustEnabled').mockReturnValue(true);
+      // isWorkspaceTrusted is no longer checked, so we don't need to mock it returning true
+      mockIsPathTrusted = vi.fn();
+      const mockLoadedFolders = {
+        isPathTrusted: mockIsPathTrusted,
+      } as unknown as LoadedTrustedFolders;
+      vi.spyOn(trustedFolders, 'loadTrustedFolders').mockReturnValue(
+        mockLoadedFolders,
+      );
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should add a trusted directory', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      mockIsPathTrusted.mockReturnValue(true);
+      const newPath = path.resolve('/home/user/trusted-project');
+      vi.mocked(mockWorkspaceContext.addDirectories).mockReturnValue({
+        added: [newPath],
+        failed: [],
+      });
+
+      await addCommand.action(mockContext, newPath);
+
+      expect(mockWorkspaceContext.addDirectories).toHaveBeenCalledWith([
+        newPath,
+      ]);
+    });
+
+    it('should return a custom dialog for an explicitly untrusted directory (upgrade flow)', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      mockIsPathTrusted.mockReturnValue(false); // DO_NOT_TRUST
+      const newPath = path.resolve('/home/user/untrusted-project');
+
+      const result = await addCommand.action(mockContext, newPath);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          type: 'custom_dialog',
+          component: expect.objectContaining({
+            type: expect.any(Function), // React component for MultiFolderTrustDialog
+          }),
+        }),
+      );
+      if (!result) {
+        throw new Error('Command did not return a result');
+      }
+      const component = (result as OpenCustomDialogActionReturn)
+        .component as React.ReactElement<MultiFolderTrustDialogProps>;
+      expect(component.props.folders.includes(newPath)).toBeTruthy();
+    });
+
+    it('should return a custom dialog for a directory with undefined trust', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      mockIsPathTrusted.mockReturnValue(undefined);
+      const newPath = path.resolve('/home/user/undefined-trust-project');
+
+      const result = await addCommand.action(mockContext, newPath);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          type: 'custom_dialog',
+          component: expect.objectContaining({
+            type: expect.any(Function), // React component for MultiFolderTrustDialog
+          }),
+        }),
+      );
+      if (!result) {
+        throw new Error('Command did not return a result');
+      }
+      const component = (result as OpenCustomDialogActionReturn)
+        .component as React.ReactElement<MultiFolderTrustDialogProps>;
+      expect(component.props.folders.includes(newPath)).toBeTruthy();
+    });
+
+    it('should prompt for directory even if workspace is untrusted', async () => {
+      if (!addCommand?.action) throw new Error('No action');
+      // Even if workspace is untrusted, we should still check directory trust
+      vi.spyOn(trustedFolders, 'isWorkspaceTrusted').mockReturnValue({
+        isTrusted: false,
+        source: 'file',
+      });
+      mockIsPathTrusted.mockReturnValue(undefined);
+      const newPath = path.resolve('/home/user/new-project');
+
+      const result = await addCommand.action(mockContext, newPath);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          type: 'custom_dialog',
+        }),
+      );
+    });
+  });
+
+  it('should correctly expand a Windows-style home directory path', () => {
+    const windowsPath = '%userprofile%\\Documents';
+    const expectedPath = path.win32.join(os.homedir(), 'Documents');
+    const result = expandHomeDir(windowsPath);
+    expect(path.win32.normalize(result)).toBe(
+      path.win32.normalize(expectedPath),
+    );
+  });
+});

packages/cli/src/ui/commands/directoryCommand.tsx

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  isFolderTrustEnabled,
+  loadTrustedFolders,
+} from '../../config/trustedFolders.js';
+import { MultiFolderTrustDialog } from '../components/MultiFolderTrustDialog.js';
+import {
+  CommandKind,
+  type SlashCommand,
+  type CommandContext,
+} from './types.js';
+import { MessageType, type HistoryItem } from '../types.js';
+import { type Config } from '@google/gemini-cli-core';
+import {
+  expandHomeDir,
+  getDirectorySuggestions,
+  batchAddDirectories,
+} from '../utils/directoryUtils.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+async function finishAddingDirectories(
+  config: Config,
+  addItem: (
+    itemData: Omit<HistoryItem, 'id'>,
+    baseTimestamp?: number,
+  ) => number,
+  added: string[],
+  errors: string[],
+) {
+  if (!config) {
+    addItem({
+      type: MessageType.ERROR,
+      text: 'Configuration is not available.',
+    });
+    return;
+  }
+
+  if (added.length > 0) {
+    try {
+      if (config.shouldLoadMemoryFromIncludeDirectories()) {
+        await config.getMemoryContextManager()?.refresh();
+      }
+      addItem({
+        type: MessageType.INFO,
+        text: `Successfully added GEMINI.md files from the following directories if there are:\n- ${added.join('\n- ')}`,
+      });
+    } catch (error) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      errors.push(`Error refreshing memory: ${(error as Error).message}`);
+    }
+  }
+
+  if (added.length > 0) {
+    const gemini = config.geminiClient;
+    if (gemini) {
+      await gemini.addDirectoryContext();
+
+      // Persist directories to session file for resume support
+      const chatRecordingService = gemini.getChatRecordingService();
+      const workspaceContext = config.getWorkspaceContext();
+      chatRecordingService?.recordDirectories(
+        workspaceContext.getDirectories(),
+      );
+    }
+    addItem({
+      type: MessageType.INFO,
+      text: `Successfully added directories:\n- ${added.join('\n- ')}`,
+    });
+  }
+
+  if (errors.length > 0) {
+    addItem({ type: MessageType.ERROR, text: errors.join('\n') });
+  }
+}
+
+export const directoryCommand: SlashCommand = {
+  name: 'directory',
+  altNames: ['dir'],
+  description: 'Manage workspace directories',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    {
+      name: 'add',
+      description:
+        'Add directories to the workspace. Use comma to separate multiple paths',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: false,
+      showCompletionLoading: false,
+      completion: async (context: CommandContext, partialArg: string) => {
+        // Support multiple paths separated by commas
+        const parts = partialArg.split(',');
+        const lastPart = parts[parts.length - 1];
+        const leadingWhitespace = lastPart.match(/^\s*/)?.[0] ?? '';
+        const trimmedLastPart = lastPart.trimStart();
+
+        if (trimmedLastPart === '') {
+          return [];
+        }
+
+        const suggestions = await getDirectorySuggestions(trimmedLastPart);
+
+        // Filter out existing directories
+        let filteredSuggestions = suggestions;
+        if (context.services.agentContext?.config) {
+          const workspaceContext =
+            context.services.agentContext.config.getWorkspaceContext();
+          const existingDirs = new Set(
+            workspaceContext.getDirectories().map((dir) => path.resolve(dir)),
+          );
+
+          filteredSuggestions = suggestions.filter((s) => {
+            const expanded = expandHomeDir(s);
+            const absolute = path.resolve(expanded);
+
+            if (existingDirs.has(absolute)) {
+              return false;
+            }
+            if (
+              absolute.endsWith(path.sep) &&
+              existingDirs.has(absolute.slice(0, -1))
+            ) {
+              return false;
+            }
+            return true;
+          });
+        }
+
+        if (parts.length > 1) {
+          const prefix = parts.slice(0, -1).join(',') + ',';
+          return filteredSuggestions.map((s) => prefix + leadingWhitespace + s);
+        }
+
+        return filteredSuggestions.map((s) => leadingWhitespace + s);
+      },
+      action: async (context: CommandContext, args: string) => {
+        const {
+          ui: { addItem },
+          services: { agentContext, settings },
+        } = context;
+        const [...rest] = args.split(' ');
+
+        if (!agentContext) {
+          addItem({
+            type: MessageType.ERROR,
+            text: 'Configuration is not available.',
+          });
+          return;
+        }
+
+        if (agentContext.config.isRestrictiveSandbox()) {
+          return {
+            type: 'message' as const,
+            messageType: 'error' as const,
+            content:
+              'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.',
+          };
+        }
+
+        const pathsToAdd = rest
+          .join(' ')
+          .split(',')
+          .filter((p) => p);
+        if (pathsToAdd.length === 0) {
+          addItem({
+            type: MessageType.ERROR,
+            text: 'Please provide at least one path to add.',
+          });
+          return;
+        }
+
+        const added: string[] = [];
+        const errors: string[] = [];
+        const alreadyAdded: string[] = [];
+
+        const workspaceContext = agentContext.config.getWorkspaceContext();
+        const currentWorkspaceDirs = workspaceContext.getDirectories();
+        const pathsToProcess: string[] = [];
+
+        for (const pathToAdd of pathsToAdd) {
+          const trimmedPath = pathToAdd.trim();
+          const expandedPath = expandHomeDir(trimmedPath);
+          try {
+            const absolutePath = path.resolve(
+              workspaceContext.targetDir,
+              expandedPath,
+            );
+            const resolvedPath = fs.realpathSync(absolutePath);
+            if (currentWorkspaceDirs.includes(resolvedPath)) {
+              alreadyAdded.push(trimmedPath);
+              continue;
+            }
+          } catch {
+            // Path might not exist or be inaccessible.
+            // We'll let batchAddDirectories handle it later.
+          }
+          pathsToProcess.push(trimmedPath);
+        }
+
+        if (alreadyAdded.length > 0) {
+          addItem({
+            type: MessageType.INFO,
+            text: `The following directories are already in the workspace:\n- ${alreadyAdded.join(
+              '\n- ',
+            )}`,
+          });
+        }
+
+        if (pathsToProcess.length === 0) {
+          return;
+        }
+
+        if (isFolderTrustEnabled(settings.merged)) {
+          const trustedFolders = loadTrustedFolders();
+          const dirsToConfirm: string[] = [];
+          const trustedDirs: string[] = [];
+
+          for (const pathToAdd of pathsToProcess) {
+            const expandedPath = path.resolve(expandHomeDir(pathToAdd.trim()));
+            const isTrusted = trustedFolders.isPathTrusted(expandedPath);
+            // If explicitly trusted, add immediately.
+            // If undefined or explicitly untrusted (DO_NOT_TRUST), prompt for confirmation.
+            // This allows users to "upgrade" a DO_NOT_TRUST folder to trusted via the dialog.
+            if (isTrusted === true) {
+              trustedDirs.push(pathToAdd.trim());
+            } else {
+              dirsToConfirm.push(pathToAdd.trim());
+            }
+          }
+
+          if (trustedDirs.length > 0) {
+            const result = batchAddDirectories(workspaceContext, trustedDirs);
+            added.push(...result.added);
+            errors.push(...result.errors);
+          }
+
+          if (dirsToConfirm.length > 0) {
+            return {
+              type: 'custom_dialog',
+              component: (
+                <MultiFolderTrustDialog
+                  folders={dirsToConfirm}
+                  onComplete={context.ui.removeComponent}
+                  trustedDirs={added}
+                  errors={errors}
+                  finishAddingDirectories={finishAddingDirectories}
+                  config={agentContext.config}
+                  addItem={addItem}
+                />
+              ),
+            };
+          }
+        } else {
+          const result = batchAddDirectories(workspaceContext, pathsToProcess);
+          added.push(...result.added);
+          errors.push(...result.errors);
+        }
+
+        await finishAddingDirectories(
+          agentContext.config,
+          addItem,
+          added,
+          errors,
+        );
+        return;
+      },
+    },
+    {
+      name: 'show',
+      description: 'Show all directories in the workspace',
+      kind: CommandKind.BUILT_IN,
+      action: async (context: CommandContext) => {
+        const {
+          ui: { addItem },
+          services: { agentContext },
+        } = context;
+        if (!agentContext) {
+          addItem({
+            type: MessageType.ERROR,
+            text: 'Configuration is not available.',
+          });
+          return;
+        }
+        const workspaceContext = agentContext.config.getWorkspaceContext();
+        const directories = workspaceContext.getDirectories();
+        const directoryList = directories.map((dir) => `- ${dir}`).join('\n');
+        addItem({
+          type: MessageType.INFO,
+          text: `Current workspace directories:\n${directoryList}`,
+        });
+      },
+    },
+  ],
+};

packages/cli/src/ui/commands/docsCommand.test.ts

@@ -0,0 +1,99 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import open from 'open';
+import { docsCommand } from './docsCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+
+// Mock the 'open' library
+vi.mock('open', () => ({
+  default: vi.fn(),
+}));
+
+describe('docsCommand', () => {
+  let mockContext: CommandContext;
+  beforeEach(() => {
+    // Create a fresh mock context before each test
+    mockContext = createMockCommandContext();
+    // Reset the `open` mock
+    vi.mocked(open).mockClear();
+  });
+
+  afterEach(() => {
+    // Restore any stubbed environment variables
+    vi.unstubAllEnvs();
+  });
+
+  it("should add an info message and call 'open' in a non-sandbox environment", async () => {
+    if (!docsCommand.action) {
+      throw new Error('docsCommand must have an action.');
+    }
+
+    const docsUrl = 'https://goo.gle/gemini-cli-docs';
+
+    await docsCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.INFO,
+        text: `Opening documentation in your browser: ${docsUrl}`,
+      },
+      expect.any(Number),
+    );
+
+    expect(open).toHaveBeenCalledWith(docsUrl);
+  });
+
+  it('should only add an info message in a sandbox environment', async () => {
+    if (!docsCommand.action) {
+      throw new Error('docsCommand must have an action.');
+    }
+
+    // Simulate a sandbox environment
+    vi.stubEnv('SANDBOX', 'gemini-sandbox');
+    const docsUrl = 'https://goo.gle/gemini-cli-docs';
+
+    await docsCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.INFO,
+        text: `Please open the following URL in your browser to view the documentation:\n${docsUrl}`,
+      },
+      expect.any(Number),
+    );
+
+    // Ensure 'open' was not called in the sandbox
+    expect(open).not.toHaveBeenCalled();
+  });
+
+  it("should not open browser for 'sandbox-exec'", async () => {
+    if (!docsCommand.action) {
+      throw new Error('docsCommand must have an action.');
+    }
+
+    // Simulate the specific 'sandbox-exec' environment
+    vi.stubEnv('SANDBOX', 'sandbox-exec');
+    const docsUrl = 'https://goo.gle/gemini-cli-docs';
+
+    await docsCommand.action(mockContext, '');
+
+    // The logic should fall through to the 'else' block
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.INFO,
+        text: `Opening documentation in your browser: ${docsUrl}`,
+      },
+      expect.any(Number),
+    );
+
+    // 'open' should be called in this specific sandbox case
+    expect(open).toHaveBeenCalledWith(docsUrl);
+  });
+});

packages/cli/src/ui/commands/docsCommand.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import open from 'open';
+import process from 'node:process';
+import {
+  type CommandContext,
+  type SlashCommand,
+  CommandKind,
+} from './types.js';
+import { MessageType } from '../types.js';
+
+export const docsCommand: SlashCommand = {
+  name: 'docs',
+  description: 'Open full Gemini CLI documentation in your browser',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (context: CommandContext): Promise<void> => {
+    const docsUrl = 'https://goo.gle/gemini-cli-docs';
+
+    if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
+      context.ui.addItem(
+        {
+          type: MessageType.INFO,
+          text: `Please open the following URL in your browser to view the documentation:\n${docsUrl}`,
+        },
+        Date.now(),
+      );
+    } else {
+      context.ui.addItem(
+        {
+          type: MessageType.INFO,
+          text: `Opening documentation in your browser: ${docsUrl}`,
+        },
+        Date.now(),
+      );
+      await open(docsUrl);
+    }
+  },
+};

packages/cli/src/ui/commands/editorCommand.test.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { editorCommand } from './editorCommand.js';
+// 1. Import the mock context utility
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('editorCommand', () => {
+  it('should return a dialog action to open the editor dialog', () => {
+    if (!editorCommand.action) {
+      throw new Error('The editor command must have an action.');
+    }
+    const mockContext = createMockCommandContext();
+    const result = editorCommand.action(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'editor',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(editorCommand.name).toBe('editor');
+    expect(editorCommand.description).toBe('Set external editor preference');
+  });
+});

packages/cli/src/ui/commands/editorCommand.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  CommandKind,
+  type OpenDialogActionReturn,
+  type SlashCommand,
+} from './types.js';
+
+export const editorCommand: SlashCommand = {
+  name: 'editor',
+  description: 'Set external editor preference',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: (): OpenDialogActionReturn => ({
+    type: 'dialog',
+    dialog: 'editor',
+  }),
+};

packages/cli/src/ui/commands/exportSessionCommand.test.ts

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { exportSessionCommand } from './exportSessionCommand.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { SessionSelector } from '../../utils/sessionUtils.js';
+import type { CommandContext } from './types.js';
+import { Storage, type ConversationRecord } from '@google/gemini-cli-core';
+
+vi.mock('node:fs/promises');
+vi.mock('../../utils/sessionUtils.js');
+
+describe('exportSessionCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.spyOn(Storage.prototype, 'initialize').mockResolvedValue(undefined);
+    vi.spyOn(Storage.prototype, 'getProjectTempDir').mockReturnValue(
+      path.join(path.sep, 'tmp', 'mock-dir'),
+    );
+    mockContext = {
+      services: {
+        agentContext: {
+          config: {
+            sessionId: 'test-session-id',
+            getSessionId: () => 'test-session-id',
+            storage: new Storage(process.cwd()),
+          },
+        },
+      },
+      invocation: {
+        args: '  export.json  ',
+        name: 'export-session',
+        raw: '/export-session export.json',
+      },
+      ui: {
+        addItem: vi.fn(),
+        setPendingItem: vi.fn(),
+        pendingItem: null,
+      },
+    } as unknown as CommandContext;
+  });
+
+  it('should return error if no path is provided', async () => {
+    mockContext.invocation!.args = '   ';
+    const result = await exportSessionCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: expect.stringContaining('Please provide a file path'),
+    });
+  });
+
+  it('should return error if sessionId is missing', async () => {
+    mockContext.services.agentContext!.config.getSessionId = () =>
+      undefined as unknown as string;
+    const result = await exportSessionCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'No active session found to export.',
+    });
+  });
+
+  it('should export the session successfully', async () => {
+    const mockSessionData: ConversationRecord = {
+      sessionId: 'test-session-id',
+      messages: [],
+      projectHash: 'hash',
+      startTime: 'time',
+      lastUpdated: 'time',
+    };
+    vi.mocked(SessionSelector.prototype.resolveSession).mockResolvedValue({
+      sessionData: mockSessionData,
+      sessionPath: path.join(
+        path.sep,
+        'tmp',
+        'mock-dir',
+        'chats',
+        'session.jsonl',
+      ),
+      displayInfo: 'test',
+    });
+
+    vi.mocked(fs.access).mockRejectedValue(new Error('Not found'));
+
+    const result = await exportSessionCommand.action!(mockContext, '');
+
+    expect(result).toBeUndefined();
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve(process.cwd(), 'export.json'),
+      JSON.stringify(mockSessionData, null, 2),
+      'utf-8',
+    );
+    expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'export_session',
+        exportSession: { isPending: true },
+      }),
+    );
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'export_session',
+        exportSession: {
+          isPending: false,
+          targetPath: expect.stringContaining('export.json'),
+        },
+      }),
+      expect.any(Number),
+    );
+    expect(mockContext.ui.setPendingItem).toHaveBeenLastCalledWith(null);
+  });
+
+  it('should return error if resolveSession fails', async () => {
+    vi.mocked(SessionSelector.prototype.resolveSession).mockRejectedValue(
+      new Error('Session not found'),
+    );
+
+    const result = await exportSessionCommand.action!(mockContext, '');
+
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Failed to export session: Session not found',
+    });
+  });
+});

packages/cli/src/ui/commands/exportSessionCommand.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import { MessageType, type HistoryItemExportSession } from '../types.js';
+import { SessionSelector } from '../../utils/sessionUtils.js';
+
+export const exportSessionCommand: SlashCommand = {
+  name: 'export-session',
+  description: 'Export the current session to a JSON file',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (
+    context: CommandContext,
+  ): Promise<SlashCommandActionReturn | void> => {
+    const { ui } = context;
+    const args = context.invocation?.args.trim();
+    if (!args) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content:
+          'Please provide a file path to export the session to. Example: /export-session ./my-session.json',
+      };
+    }
+
+    const sessionId = context.services.agentContext?.config.getSessionId();
+    if (!sessionId) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'No active session found to export.',
+      };
+    }
+
+    if (ui.pendingItem) {
+      ui.addItem(
+        {
+          type: MessageType.ERROR,
+          text: 'Operation already in progress, please wait.',
+        },
+        Date.now(),
+      );
+      return;
+    }
+
+    const pendingMessage: HistoryItemExportSession = {
+      type: MessageType.EXPORT_SESSION,
+      exportSession: {
+        isPending: true,
+      },
+    };
+
+    try {
+      ui.setPendingItem(pendingMessage);
+      const storage = context.services.agentContext!.config.storage;
+      const sessionSelector = new SessionSelector(storage);
+      const { sessionData } = await sessionSelector.resolveSession(sessionId);
+
+      const targetPath = path.resolve(process.cwd(), args);
+
+      await fs.writeFile(
+        targetPath,
+        JSON.stringify(sessionData, null, 2),
+        'utf-8',
+      );
+
+      ui.addItem(
+        {
+          type: MessageType.EXPORT_SESSION,
+          exportSession: {
+            isPending: false,
+            targetPath,
+          },
+        } as HistoryItemExportSession,
+        Date.now(),
+      );
+    } catch (error) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Failed to export session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      };
+    } finally {
+      ui.setPendingItem(null);
+    }
+  },
+};

packages/cli/src/ui/commands/extensionsCommand.test.ts

@@ -0,0 +1,1227 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type ReactElement } from 'react';
+
+import type {
+  ExtensionLoader,
+  GeminiCLIExtension,
+} from '@google/gemini-cli-core';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import {
+  completeExtensions,
+  completeExtensionsAndScopes,
+  extensionsCommand,
+} from './extensionsCommand.js';
+import {
+  ConfigExtensionDialog,
+  type ConfigExtensionDialogProps,
+} from '../components/ConfigExtensionDialog.js';
+import {
+  ExtensionRegistryView,
+  type ExtensionRegistryViewProps,
+} from '../components/views/ExtensionRegistryView.js';
+import { type CommandContext, type SlashCommand } from './types.js';
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  afterEach,
+  type MockedFunction,
+} from 'vitest';
+import { type ExtensionUpdateAction } from '../state/extensions.js';
+import {
+  ExtensionManager,
+  inferInstallMetadata,
+} from '../../config/extension-manager.js';
+import { SettingScope } from '../../config/settings.js';
+import { stat } from 'node:fs/promises';
+import { type RegistryExtension } from '../../config/extensionRegistryClient.js';
+import { waitFor } from '../../test-utils/async.js';
+
+vi.mock('../../config/extension-manager.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../../config/extension-manager.js')>();
+  return {
+    ...actual,
+    inferInstallMetadata: vi.fn(),
+  };
+});
+
+import open from 'open';
+import type { Stats } from 'node:fs';
+
+vi.mock('open', () => ({
+  default: vi.fn(),
+}));
+
+vi.mock('node:fs/promises', () => ({
+  stat: vi.fn(),
+}));
+
+vi.mock('../../config/extensions/extensionSettings.js', () => ({
+  ExtensionSettingScope: {
+    USER: 'user',
+    WORKSPACE: 'workspace',
+  },
+  getScopedEnvContents: vi.fn().mockResolvedValue({}),
+  promptForSetting: vi.fn(),
+  updateSetting: vi.fn(),
+}));
+
+vi.mock('prompts', () => ({
+  default: vi.fn(),
+}));
+
+vi.mock('../../config/extensions/update.js', () => ({
+  updateExtension: vi.fn(),
+  checkForAllExtensionUpdates: vi.fn(),
+}));
+
+const mockDisableExtension = vi.fn();
+const mockEnableExtension = vi.fn();
+const mockInstallExtension = vi.fn();
+const mockUninstallExtension = vi.fn();
+const mockGetExtensions = vi.fn();
+
+const inactiveExt: GeminiCLIExtension = {
+  name: 'ext-one',
+  id: 'ext-one-id',
+  version: '1.0.0',
+  isActive: false, // should suggest disabled extensions
+  path: '/test/dir/ext-one',
+  contextFiles: [],
+  installMetadata: {
+    type: 'git',
+    autoUpdate: false,
+    source: 'https://github.com/some/extension.git',
+  },
+};
+const activeExt: GeminiCLIExtension = {
+  name: 'ext-two',
+  id: 'ext-two-id',
+  version: '1.0.0',
+  isActive: true, // should not suggest enabled extensions
+  path: '/test/dir/ext-two',
+  contextFiles: [],
+  installMetadata: {
+    type: 'git',
+    autoUpdate: false,
+    source: 'https://github.com/some/extension.git',
+  },
+};
+const allExt: GeminiCLIExtension = {
+  name: 'all-ext',
+  id: 'all-ext-id',
+  version: '1.0.0',
+  isActive: true,
+  path: '/test/dir/all-ext',
+  contextFiles: [],
+  installMetadata: {
+    type: 'git',
+    autoUpdate: false,
+    source: 'https://github.com/some/extension.git',
+  },
+};
+
+describe('extensionsCommand', () => {
+  let mockContext: CommandContext;
+  const mockDispatchExtensionState = vi.fn();
+  let mockExtensionLoader: unknown;
+  let mockReloadSkills: MockedFunction<() => Promise<void>>;
+  let mockReloadAgents: MockedFunction<() => Promise<void>>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockExtensionLoader = Object.create(ExtensionManager.prototype);
+    Object.assign(mockExtensionLoader as object, {
+      enableExtension: mockEnableExtension,
+      disableExtension: mockDisableExtension,
+      installOrUpdateExtension: mockInstallExtension,
+      uninstallExtension: mockUninstallExtension,
+      getExtensions: mockGetExtensions,
+      loadExtensionConfig: vi.fn().mockResolvedValue({
+        name: 'test-ext',
+        settings: [{ name: 'setting1', envVar: 'SETTING1' }],
+      }),
+    });
+
+    mockGetExtensions.mockReturnValue([inactiveExt, activeExt, allExt]);
+    vi.mocked(open).mockClear();
+    mockReloadAgents = vi.fn().mockResolvedValue(undefined);
+    mockReloadSkills = vi.fn().mockResolvedValue(undefined);
+
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getExtensions: mockGetExtensions,
+            getExtensionLoader: vi.fn().mockReturnValue(mockExtensionLoader),
+            getWorkingDir: () => '/test/dir',
+            reloadSkills: mockReloadSkills,
+            getAgentRegistry: vi.fn().mockReturnValue({
+              reload: mockReloadAgents,
+            }),
+          },
+        },
+      },
+      ui: {
+        dispatchExtensionStateUpdate: mockDispatchExtensionState,
+        removeComponent: vi.fn(),
+      },
+    });
+  });
+
+  afterEach(() => {
+    // Restore any stubbed environment variables, similar to docsCommand.test.ts
+    vi.unstubAllEnvs();
+  });
+
+  describe('list', () => {
+    it('should add an EXTENSIONS_LIST item to the UI', async () => {
+      const command = extensionsCommand();
+      if (!command.action) throw new Error('Action not defined');
+      await command.action(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+    });
+
+    it('should show a message if no extensions are installed', async () => {
+      mockGetExtensions.mockReturnValue([]);
+      const command = extensionsCommand();
+      if (!command.action) throw new Error('Action not defined');
+      await command.action(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: 'No extensions installed. Run `/extensions explore` to check out the gallery.',
+      });
+    });
+  });
+
+  describe('completeExtensions', () => {
+    it.each([
+      {
+        description: 'should return matching extension names',
+        partialArg: 'ext',
+        expected: ['ext-one', 'ext-two'],
+      },
+      {
+        description: 'should return --all when partialArg matches',
+        partialArg: '--al',
+        expected: ['--all'],
+      },
+      {
+        description:
+          'should return both extension names and --all when both match',
+        partialArg: 'all',
+        expected: ['--all', 'all-ext'],
+      },
+      {
+        description: 'should return an empty array if no matches',
+        partialArg: 'nomatch',
+        expected: [],
+      },
+      {
+        description:
+          'should suggest only disabled extension names for the enable command',
+        partialArg: 'ext',
+        expected: ['ext-one'],
+        command: 'enable',
+      },
+      {
+        description:
+          'should suggest only enabled extension names for the disable command',
+        partialArg: 'ext',
+        expected: ['ext-two'],
+        command: 'disable',
+      },
+    ])('$description', async ({ partialArg, expected, command }) => {
+      if (command) {
+        mockContext.invocation!.name = command;
+      }
+      const suggestions = completeExtensions(mockContext, partialArg);
+      expect(suggestions).toEqual(expected);
+    });
+  });
+
+  describe('completeExtensionsAndScopes', () => {
+    it('expands the list of suggestions with --scope args', () => {
+      const suggestions = completeExtensionsAndScopes(mockContext, 'ext');
+      expect(suggestions).toEqual([
+        'ext-one --scope user',
+        'ext-one --scope workspace',
+        'ext-one --scope session',
+        'ext-two --scope user',
+        'ext-two --scope workspace',
+        'ext-two --scope session',
+      ]);
+    });
+  });
+
+  describe('update', () => {
+    const updateAction = extensionsCommand().subCommands?.find(
+      (cmd) => cmd.name === 'update',
+    )?.action;
+
+    if (!updateAction) {
+      throw new Error('Update action not found');
+    }
+
+    it('should show usage if no args are provided', async () => {
+      await updateAction(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions update <extension-names>|--all',
+      });
+    });
+
+    it('should show a message if no extensions are installed', async () => {
+      mockGetExtensions.mockReturnValue([]);
+      await updateAction(mockContext, 'ext-one');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: 'No extensions installed. Run `/extensions explore` to check out the gallery.',
+      });
+    });
+
+    it('should inform user if there are no extensions to update with --all', async () => {
+      mockDispatchExtensionState.mockImplementationOnce(
+        async (action: ExtensionUpdateAction) => {
+          if (action.type === 'SCHEDULE_UPDATE') {
+            action.payload.onComplete([]);
+          }
+        },
+      );
+
+      await updateAction(mockContext, '--all');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: 'No extensions to update.',
+      });
+    });
+
+    it('should call setPendingItem and addItem in a finally block on success', async () => {
+      mockDispatchExtensionState.mockImplementationOnce(
+        async (action: ExtensionUpdateAction) => {
+          if (action.type === 'SCHEDULE_UPDATE') {
+            action.payload.onComplete([
+              {
+                name: 'ext-one',
+                originalVersion: '1.0.0',
+                updatedVersion: '1.0.1',
+              },
+              {
+                name: 'ext-two',
+                originalVersion: '2.0.0',
+                updatedVersion: '2.0.1',
+              },
+            ]);
+          }
+        },
+      );
+      await updateAction(mockContext, '--all');
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+    });
+
+    it('should call setPendingItem and addItem in a finally block on failure', async () => {
+      mockDispatchExtensionState.mockImplementationOnce((_) => {
+        throw new Error('Something went wrong');
+      });
+      await updateAction(mockContext, '--all');
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Something went wrong',
+      });
+    });
+
+    it('should update a single extension by name', async () => {
+      mockDispatchExtensionState.mockImplementationOnce(
+        async (action: ExtensionUpdateAction) => {
+          if (action.type === 'SCHEDULE_UPDATE') {
+            action.payload.onComplete([
+              {
+                name: 'ext-one',
+                originalVersion: '1.0.0',
+                updatedVersion: '1.0.1',
+              },
+            ]);
+          }
+        },
+      );
+      await updateAction(mockContext, 'ext-one');
+      expect(mockDispatchExtensionState).toHaveBeenCalledWith({
+        type: 'SCHEDULE_UPDATE',
+        payload: {
+          all: false,
+          names: ['ext-one'],
+          onComplete: expect.any(Function),
+        },
+      });
+    });
+
+    it('should update multiple extensions by name', async () => {
+      mockDispatchExtensionState.mockImplementationOnce(
+        async (action: ExtensionUpdateAction) => {
+          if (action.type === 'SCHEDULE_UPDATE') {
+            action.payload.onComplete([
+              {
+                name: 'ext-one',
+                originalVersion: '1.0.0',
+                updatedVersion: '1.0.1',
+              },
+              {
+                name: 'ext-two',
+                originalVersion: '1.0.0',
+                updatedVersion: '1.0.1',
+              },
+            ]);
+          }
+        },
+      );
+      await updateAction(mockContext, 'ext-one ext-two');
+      expect(mockDispatchExtensionState).toHaveBeenCalledWith({
+        type: 'SCHEDULE_UPDATE',
+        payload: {
+          all: false,
+          names: ['ext-one', 'ext-two'],
+          onComplete: expect.any(Function),
+        },
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+      expect(mockContext.ui.setPendingItem).toHaveBeenCalledWith(null);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.EXTENSIONS_LIST,
+        extensions: expect.any(Array),
+      });
+    });
+  });
+
+  describe('explore', () => {
+    const exploreAction = extensionsCommand().subCommands?.find(
+      (cmd) => cmd.name === 'explore',
+    )?.action;
+
+    if (!exploreAction) {
+      throw new Error('Explore action not found');
+    }
+
+    it('should return ExtensionRegistryView custom dialog when experimental.extensionRegistry is true', async () => {
+      mockContext.services.settings.merged.experimental.extensionRegistry =
+        true;
+
+      const result = await exploreAction(mockContext, '');
+
+      expect(result).toBeDefined();
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+
+      const component =
+        result.component as ReactElement<ExtensionRegistryViewProps>;
+      expect(component.type).toBe(ExtensionRegistryView);
+      expect(component.props.extensionManager).toBe(mockExtensionLoader);
+    });
+
+    it('should handle onSelect and onClose in ExtensionRegistryView', async () => {
+      mockContext.services.settings.merged.experimental.extensionRegistry =
+        true;
+
+      const result = await exploreAction(mockContext, '');
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+
+      const component =
+        result.component as ReactElement<ExtensionRegistryViewProps>;
+
+      const extension = {
+        extensionName: 'test-ext',
+        url: 'https://github.com/test/ext.git',
+      } as RegistryExtension;
+
+      vi.mocked(inferInstallMetadata).mockResolvedValue({
+        source: extension.url,
+        type: 'git',
+      });
+      mockInstallExtension.mockResolvedValue({ name: extension.url });
+
+      // Call onSelect
+      await component.props.onSelect?.(extension);
+
+      await waitFor(() => {
+        expect(inferInstallMetadata).toHaveBeenCalledWith(extension.url);
+        expect(mockInstallExtension).toHaveBeenCalledWith(
+          {
+            source: extension.url,
+            type: 'git',
+          },
+          undefined,
+          undefined,
+        );
+      });
+      expect(mockContext.ui.removeComponent).toHaveBeenCalledTimes(1);
+
+      // Call onClose
+      component.props.onClose?.();
+      expect(mockContext.ui.removeComponent).toHaveBeenCalledTimes(2);
+    });
+
+    it("should add an info message and call 'open' in a non-sandbox environment", async () => {
+      // Ensure no special environment variables that would affect behavior
+      vi.stubEnv('NODE_ENV', '');
+      vi.stubEnv('SANDBOX', '');
+
+      await exploreAction(mockContext, '');
+
+      const extensionsUrl = 'https://geminicli.com/extensions/';
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Opening extensions page in your browser: ${extensionsUrl}`,
+      });
+
+      expect(open).toHaveBeenCalledWith(extensionsUrl);
+    });
+
+    it('should only add an info message in a sandbox environment', async () => {
+      // Simulate a sandbox environment
+      vi.stubEnv('NODE_ENV', '');
+      vi.stubEnv('SANDBOX', 'gemini-sandbox');
+      const extensionsUrl = 'https://geminicli.com/extensions/';
+
+      await exploreAction(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `View available extensions at ${extensionsUrl}`,
+      });
+
+      // Ensure 'open' was not called in the sandbox
+      expect(open).not.toHaveBeenCalled();
+    });
+
+    it('should add an info message and not call open in NODE_ENV test environment', async () => {
+      vi.stubEnv('NODE_ENV', 'test');
+      vi.stubEnv('SANDBOX', '');
+      const extensionsUrl = 'https://geminicli.com/extensions/';
+
+      await exploreAction(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Would open extensions page in your browser: ${extensionsUrl} (skipped in test environment)`,
+      });
+
+      // Ensure 'open' was not called in test environment
+      expect(open).not.toHaveBeenCalled();
+    });
+
+    it('should handle errors when opening the browser', async () => {
+      vi.stubEnv('NODE_ENV', '');
+      const extensionsUrl = 'https://geminicli.com/extensions/';
+      const errorMessage = 'Failed to open browser';
+      vi.mocked(open).mockRejectedValue(new Error(errorMessage));
+
+      await exploreAction(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: `Failed to open browser. Check out the extensions gallery at ${extensionsUrl}`,
+      });
+    });
+  });
+
+  describe('when enableExtensionReloading is true', () => {
+    it('should include enable, disable, install, link, and uninstall subcommands', () => {
+      const command = extensionsCommand(true);
+      const subCommandNames = command.subCommands?.map((cmd) => cmd.name);
+      expect(subCommandNames).toContain('enable');
+      expect(subCommandNames).toContain('disable');
+      expect(subCommandNames).toContain('install');
+      expect(subCommandNames).toContain('link');
+      expect(subCommandNames).toContain('uninstall');
+    });
+  });
+
+  describe('when enableExtensionReloading is false', () => {
+    it('should not include enable, disable, install, link, and uninstall subcommands', () => {
+      const command = extensionsCommand(false);
+      const subCommandNames = command.subCommands?.map((cmd) => cmd.name);
+      expect(subCommandNames).not.toContain('enable');
+      expect(subCommandNames).not.toContain('disable');
+      expect(subCommandNames).not.toContain('install');
+      expect(subCommandNames).not.toContain('link');
+      expect(subCommandNames).not.toContain('uninstall');
+    });
+  });
+
+  describe('when enableExtensionReloading is not provided', () => {
+    it('should not include enable, disable, install, link, and uninstall subcommands by default', () => {
+      const command = extensionsCommand();
+      const subCommandNames = command.subCommands?.map((cmd) => cmd.name);
+      expect(subCommandNames).not.toContain('enable');
+      expect(subCommandNames).not.toContain('disable');
+      expect(subCommandNames).not.toContain('install');
+      expect(subCommandNames).not.toContain('link');
+      expect(subCommandNames).not.toContain('uninstall');
+    });
+  });
+
+  describe('install', () => {
+    let installAction: SlashCommand['action'];
+
+    beforeEach(() => {
+      installAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'install',
+      )?.action;
+
+      expect(installAction).not.toBeNull();
+
+      mockContext.invocation!.name = 'install';
+    });
+
+    it('should show usage if no extension name is provided', async () => {
+      await installAction!(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions install <source>',
+      });
+      expect(mockInstallExtension).not.toHaveBeenCalled();
+    });
+
+    it('should call installExtension and show success message', async () => {
+      const packageName = 'test-extension-package';
+      vi.mocked(inferInstallMetadata).mockResolvedValue({
+        source: packageName,
+        type: 'git',
+      });
+      mockInstallExtension.mockResolvedValue({ name: packageName });
+      await installAction!(mockContext, packageName);
+      expect(inferInstallMetadata).toHaveBeenCalledWith(packageName);
+      expect(mockInstallExtension).toHaveBeenCalledWith(
+        {
+          source: packageName,
+          type: 'git',
+        },
+        undefined,
+        undefined,
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Installing extension from "${packageName}"...`,
+      });
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Extension "${packageName}" installed successfully.`,
+      });
+    });
+
+    it('should show error message on installation failure', async () => {
+      const packageName = 'failed-extension';
+      const errorMessage = 'install failed';
+      vi.mocked(inferInstallMetadata).mockResolvedValue({
+        source: packageName,
+        type: 'git',
+      });
+      mockInstallExtension.mockRejectedValue(new Error(errorMessage));
+
+      await installAction!(mockContext, packageName);
+      expect(inferInstallMetadata).toHaveBeenCalledWith(packageName);
+      expect(mockInstallExtension).toHaveBeenCalledWith(
+        {
+          source: packageName,
+          type: 'git',
+        },
+        undefined,
+        undefined,
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: `Failed to install extension from "${packageName}": ${errorMessage}`,
+      });
+    });
+
+    it('should show error message for invalid source', async () => {
+      const invalidSource = 'a;b';
+      await installAction!(mockContext, invalidSource);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: `Invalid source: ${invalidSource}`,
+      });
+      expect(mockInstallExtension).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('link', () => {
+    let linkAction: SlashCommand['action'];
+
+    beforeEach(() => {
+      linkAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'link',
+      )?.action;
+
+      expect(linkAction).not.toBeNull();
+      mockContext.invocation!.name = 'link';
+    });
+
+    it('should show usage if no extension is provided', async () => {
+      await linkAction!(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions link <source>',
+      });
+      expect(mockInstallExtension).not.toHaveBeenCalled();
+    });
+
+    it('should call installExtension and show success message', async () => {
+      const packageName = 'test-extension-package';
+      mockInstallExtension.mockResolvedValue({ name: packageName });
+      vi.mocked(stat).mockResolvedValue({
+        size: 100,
+      } as Stats);
+      await linkAction!(mockContext, packageName);
+      expect(mockInstallExtension).toHaveBeenCalledWith(
+        {
+          source: packageName,
+          type: 'link',
+        },
+        undefined,
+        undefined,
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Linking extension from "${packageName}"...`,
+      });
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Extension "${packageName}" linked successfully.`,
+      });
+    });
+
+    it('should show error message on linking failure', async () => {
+      const packageName = 'test-extension-package';
+      const errorMessage = 'link failed';
+      mockInstallExtension.mockRejectedValue(new Error(errorMessage));
+      vi.mocked(stat).mockResolvedValue({
+        size: 100,
+      } as Stats);
+
+      await linkAction!(mockContext, packageName);
+      expect(mockInstallExtension).toHaveBeenCalledWith(
+        {
+          source: packageName,
+          type: 'link',
+        },
+        undefined,
+        undefined,
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: `Failed to link extension from "${packageName}": ${errorMessage}`,
+      });
+    });
+
+    it('should show error message for invalid source', async () => {
+      const packageName = 'test-extension-package';
+      const errorMessage = 'invalid path';
+      vi.mocked(stat).mockRejectedValue(new Error(errorMessage));
+      await linkAction!(mockContext, packageName);
+      expect(mockInstallExtension).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('uninstall', () => {
+    let uninstallAction: SlashCommand['action'];
+
+    beforeEach(() => {
+      uninstallAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'uninstall',
+      )?.action;
+
+      expect(uninstallAction).not.toBeNull();
+
+      mockContext.invocation!.name = 'uninstall';
+    });
+
+    it('should show usage if no extension name is provided', async () => {
+      await uninstallAction!(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions uninstall <extension-names...>|--all',
+      });
+      expect(mockUninstallExtension).not.toHaveBeenCalled();
+    });
+
+    it('should expose "delete" as an alias', () => {
+      const uninstallCmd = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'uninstall',
+      );
+      expect(uninstallCmd?.altNames).toContain('delete');
+    });
+
+    it('should call uninstallExtension and show success message', async () => {
+      const extensionName = 'test-extension';
+      await uninstallAction!(mockContext, extensionName);
+      expect(mockUninstallExtension).toHaveBeenCalledWith(extensionName, false);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Uninstalling extension "${extensionName}"...`,
+      });
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: `Extension "${extensionName}" uninstalled successfully.`,
+      });
+    });
+
+    it('should show error message on uninstallation failure', async () => {
+      const extensionName = 'failed-extension';
+      const errorMessage = 'uninstall failed';
+      mockUninstallExtension.mockRejectedValue(new Error(errorMessage));
+
+      await uninstallAction!(mockContext, extensionName);
+      expect(mockUninstallExtension).toHaveBeenCalledWith(extensionName, false);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: `Failed to uninstall extension "${extensionName}": ${errorMessage}`,
+      });
+    });
+  });
+
+  describe('enable', () => {
+    let enableAction: SlashCommand['action'];
+
+    beforeEach(() => {
+      enableAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'enable',
+      )?.action;
+
+      expect(enableAction).not.toBeNull();
+
+      mockContext.invocation!.name = 'enable';
+    });
+
+    it('should show usage if no extension name is provided', async () => {
+      await enableAction!(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions enable <extension> [--scope=<user|workspace|session>]',
+      });
+    });
+
+    it('should call enableExtension with the provided scope', async () => {
+      await enableAction!(mockContext, `${inactiveExt.name} --scope=user`);
+      expect(mockEnableExtension).toHaveBeenCalledWith(
+        inactiveExt.name,
+        SettingScope.User,
+      );
+
+      await enableAction!(mockContext, `${inactiveExt.name} --scope workspace`);
+      expect(mockEnableExtension).toHaveBeenCalledWith(
+        inactiveExt.name,
+        SettingScope.Workspace,
+      );
+    });
+
+    it('should support --all', async () => {
+      mockGetExtensions.mockReturnValue([
+        inactiveExt,
+        { ...inactiveExt, name: 'another-inactive-ext' },
+      ]);
+      await enableAction!(mockContext, '--all --scope session');
+      expect(mockEnableExtension).toHaveBeenCalledWith(
+        inactiveExt.name,
+        SettingScope.Session,
+      );
+      expect(mockEnableExtension).toHaveBeenCalledWith(
+        'another-inactive-ext',
+        SettingScope.Session,
+      );
+    });
+  });
+
+  describe('disable', () => {
+    let disableAction: SlashCommand['action'];
+
+    beforeEach(() => {
+      disableAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'disable',
+      )?.action;
+
+      expect(disableAction).not.toBeNull();
+
+      mockContext.invocation!.name = 'disable';
+    });
+
+    it('should show usage if no extension name is provided', async () => {
+      await disableAction!(mockContext, '');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Usage: /extensions disable <extension> [--scope=<user|workspace|session>]',
+      });
+    });
+
+    it('should call disableExtension with the provided scope', async () => {
+      await disableAction!(mockContext, `${activeExt.name} --scope=user`);
+      expect(mockDisableExtension).toHaveBeenCalledWith(
+        activeExt.name,
+        SettingScope.User,
+      );
+
+      await disableAction!(mockContext, `${activeExt.name} --scope workspace`);
+      expect(mockDisableExtension).toHaveBeenCalledWith(
+        activeExt.name,
+        SettingScope.Workspace,
+      );
+    });
+
+    it('should support --all', async () => {
+      mockGetExtensions.mockReturnValue([
+        activeExt,
+        { ...activeExt, name: 'another-active-ext' },
+      ]);
+      await disableAction!(mockContext, '--all --scope session');
+      expect(mockDisableExtension).toHaveBeenCalledWith(
+        activeExt.name,
+        SettingScope.Session,
+      );
+      expect(mockDisableExtension).toHaveBeenCalledWith(
+        'another-active-ext',
+        SettingScope.Session,
+      );
+    });
+  });
+
+  describe('reload', () => {
+    let restartAction: SlashCommand['action'];
+    let mockRestartExtension: MockedFunction<
+      typeof ExtensionLoader.prototype.restartExtension
+    >;
+
+    beforeEach(() => {
+      restartAction = extensionsCommand().subCommands?.find(
+        (c) => c.name === 'reload',
+      )?.action;
+      expect(restartAction).not.toBeNull();
+
+      mockRestartExtension = vi.fn();
+      mockContext.services.agentContext!.config.getExtensionLoader = vi
+        .fn()
+        .mockImplementation(() => ({
+          getExtensions: mockGetExtensions,
+          restartExtension: mockRestartExtension,
+        }));
+      mockContext.invocation!.name = 'reload';
+    });
+
+    it('should show a message if no extensions are installed', async () => {
+      mockContext.services.agentContext!.config.getExtensionLoader = vi
+        .fn()
+        .mockImplementation(() => ({
+          getExtensions: () => [],
+          restartExtension: mockRestartExtension,
+        }));
+
+      await restartAction!(mockContext, '--all');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.INFO,
+        text: 'No extensions installed. Run `/extensions explore` to check out the gallery.',
+      });
+    });
+
+    it('reloads all active extensions when --all is provided', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+        { name: 'ext2', isActive: true },
+        { name: 'ext3', isActive: false },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+
+      await restartAction!(mockContext, '--all');
+
+      expect(mockRestartExtension).toHaveBeenCalledTimes(2);
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[0]);
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[1]);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: 'Reloading 2 extensions...',
+        }),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: '2 extensions reloaded successfully',
+        }),
+      );
+      expect(mockContext.ui.dispatchExtensionStateUpdate).toHaveBeenCalledWith({
+        type: 'RESTARTED',
+        payload: { name: 'ext1' },
+      });
+      expect(mockContext.ui.dispatchExtensionStateUpdate).toHaveBeenCalledWith({
+        type: 'RESTARTED',
+        payload: { name: 'ext2' },
+      });
+      expect(mockReloadSkills).toHaveBeenCalled();
+      expect(mockReloadAgents).toHaveBeenCalled();
+    });
+
+    it('handles errors during skill or agent reload', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+      mockReloadSkills.mockRejectedValue(new Error('Failed to reload skills'));
+
+      await restartAction!(mockContext, '--all');
+
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[0]);
+      expect(mockReloadSkills).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: 'Failed to reload skills or agents: Failed to reload skills',
+        }),
+      );
+    });
+
+    it('reloads only specified active extensions', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: false },
+        { name: 'ext2', isActive: true },
+        { name: 'ext3', isActive: true },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+
+      await restartAction!(mockContext, 'ext1 ext3');
+
+      expect(mockRestartExtension).toHaveBeenCalledTimes(1);
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[2]);
+      expect(mockContext.ui.dispatchExtensionStateUpdate).toHaveBeenCalledWith({
+        type: 'RESTARTED',
+        payload: { name: 'ext3' },
+      });
+    });
+
+    it('shows an error if no extension loader is available', async () => {
+      mockContext.services.agentContext!.config.getExtensionLoader = vi.fn();
+
+      await restartAction!(mockContext, '--all');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: "Extensions are not yet loaded, can't restart yet",
+        }),
+      );
+      expect(mockRestartExtension).not.toHaveBeenCalled();
+    });
+
+    it('shows usage error for no arguments', async () => {
+      await restartAction!(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: 'Usage: /extensions reload <extension-names>|--all',
+        }),
+      );
+      expect(mockRestartExtension).not.toHaveBeenCalled();
+    });
+
+    it('handles errors during extension reload', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+      mockRestartExtension.mockRejectedValue(new Error('Failed to restart'));
+
+      await restartAction!(mockContext, '--all');
+
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[0]);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.ERROR,
+          text: 'Failed to reload some extensions:\n  ext1: Failed to restart',
+        }),
+      );
+    });
+
+    it('shows a warning if an extension is not found', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+
+      await restartAction!(mockContext, 'ext1 ext2');
+
+      expect(mockRestartExtension).toHaveBeenCalledTimes(1);
+      expect(mockRestartExtension).toHaveBeenCalledWith(mockExtensions[0]);
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.WARNING,
+          text: 'Extension(s) not found or not active: ext2',
+        }),
+      );
+    });
+
+    it('does not reload any extensions if none are found', async () => {
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+
+      await restartAction!(mockContext, 'ext2 ext3');
+
+      expect(mockRestartExtension).not.toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.WARNING,
+          text: 'Extension(s) not found or not active: ext2, ext3',
+        }),
+      );
+    });
+
+    it('should suggest only enabled extension names for the reload command', async () => {
+      mockContext.invocation!.name = 'reload';
+      const mockExtensions = [
+        { name: 'ext1', isActive: true },
+        { name: 'ext2', isActive: false },
+      ] as GeminiCLIExtension[];
+      mockGetExtensions.mockReturnValue(mockExtensions);
+
+      const suggestions = completeExtensions(mockContext, 'ext');
+      expect(suggestions).toEqual(['ext1']);
+    });
+  });
+
+  describe('config', () => {
+    let configAction: SlashCommand['action'];
+
+    beforeEach(async () => {
+      configAction = extensionsCommand(true).subCommands?.find(
+        (cmd) => cmd.name === 'config',
+      )?.action;
+
+      expect(configAction).not.toBeNull();
+      mockContext.invocation!.name = 'config';
+
+      const prompts = (await import('prompts')).default;
+      vi.mocked(prompts).mockResolvedValue({ overwrite: true });
+
+      const { getScopedEnvContents } = await import(
+        '../../config/extensions/extensionSettings.js'
+      );
+      vi.mocked(getScopedEnvContents).mockResolvedValue({});
+    });
+
+    it('should return dialog to configure all extensions if no args provided', async () => {
+      const result = await configAction!(mockContext, '');
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+      const dialogResult = result;
+      const component =
+        dialogResult.component as ReactElement<ConfigExtensionDialogProps>;
+      expect(component.type).toBe(ConfigExtensionDialog);
+      expect(component.props.configureAll).toBe(true);
+      expect(component.props.extensionManager).toBeDefined();
+    });
+
+    it('should return dialog to configure specific extension', async () => {
+      const result = await configAction!(mockContext, 'ext-one');
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+      const dialogResult = result;
+      const component =
+        dialogResult.component as ReactElement<ConfigExtensionDialogProps>;
+      expect(component.type).toBe(ConfigExtensionDialog);
+      expect(component.props.extensionName).toBe('ext-one');
+      expect(component.props.settingKey).toBeUndefined();
+      expect(component.props.configureAll).toBe(false);
+    });
+
+    it('should return dialog to configure specific setting for an extension', async () => {
+      const result = await configAction!(mockContext, 'ext-one SETTING1');
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+      const dialogResult = result;
+      const component =
+        dialogResult.component as ReactElement<ConfigExtensionDialogProps>;
+      expect(component.type).toBe(ConfigExtensionDialog);
+      expect(component.props.extensionName).toBe('ext-one');
+      expect(component.props.settingKey).toBe('SETTING1');
+      expect(component.props.scope).toBe('user'); // Default scope
+    });
+
+    it('should respect scope argument passed to dialog', async () => {
+      const result = await configAction!(
+        mockContext,
+        'ext-one SETTING1 --scope=workspace',
+      );
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+      const dialogResult = result;
+      const component =
+        dialogResult.component as ReactElement<ConfigExtensionDialogProps>;
+      expect(component.props.scope).toBe('workspace');
+    });
+
+    it('should show error for invalid extension name', async () => {
+      await configAction!(mockContext, '../invalid');
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith({
+        type: MessageType.ERROR,
+        text: 'Invalid extension name. Names cannot contain path separators or "..".',
+      });
+    });
+
+    // "should inform if extension has no settings" - This check is now inside ConfigExtensionDialog logic.
+    // We can test that we still return a dialog, and the dialog will handle logical checks via utils.ts
+    // For unit testing extensionsCommand, we just ensure delegation.
+    it('should return dialog even if extension has no settings (dialog handles logic)', async () => {
+      const result = await configAction!(mockContext, 'ext-one');
+      if (result?.type !== 'custom_dialog') {
+        throw new Error('Expected custom_dialog');
+      }
+      const dialogResult = result;
+      const component =
+        dialogResult.component as ReactElement<ConfigExtensionDialogProps>;
+      expect(component.type).toBe(ConfigExtensionDialog);
+    });
+  });
+});

packages/cli/src/ui/commands/extensionsCommand.ts

@@ -0,0 +1,916 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  debugLogger,
+  listExtensions,
+  getErrorMessage,
+  type ExtensionInstallMetadata,
+} from '@google/gemini-cli-core';
+import type { ExtensionUpdateInfo } from '../../config/extension.js';
+import {
+  emptyIcon,
+  MessageType,
+  type HistoryItemExtensionsList,
+  type HistoryItemInfo,
+} from '../types.js';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import open from 'open';
+import process from 'node:process';
+import {
+  ExtensionManager,
+  inferInstallMetadata,
+} from '../../config/extension-manager.js';
+import { SettingScope } from '../../config/settings.js';
+import { McpServerEnablementManager } from '../../config/mcp/mcpServerEnablement.js';
+import { theme } from '../semantic-colors.js';
+import { stat } from 'node:fs/promises';
+import { ExtensionSettingScope } from '../../config/extensions/extensionSettings.js';
+import { type ConfigLogger } from '../../commands/extensions/utils.js';
+import { ConfigExtensionDialog } from '../components/ConfigExtensionDialog.js';
+import { ExtensionRegistryView } from '../components/views/ExtensionRegistryView.js';
+import React from 'react';
+
+function showMessageIfNoExtensions(
+  context: CommandContext,
+  extensions: unknown[],
+): boolean {
+  if (extensions.length === 0) {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: 'No extensions installed. Run `/extensions explore` to check out the gallery.',
+    });
+    return true;
+  }
+  return false;
+}
+
+async function listAction(context: CommandContext) {
+  const extensions = context.services.agentContext?.config
+    ? listExtensions(context.services.agentContext.config)
+    : [];
+
+  if (showMessageIfNoExtensions(context, extensions)) {
+    return;
+  }
+
+  const historyItem: HistoryItemExtensionsList = {
+    type: MessageType.EXTENSIONS_LIST,
+    extensions,
+  };
+
+  context.ui.addItem(historyItem);
+}
+
+function updateAction(context: CommandContext, args: string): Promise<void> {
+  const updateArgs = args.split(' ').filter((value) => value.length > 0);
+  const all = updateArgs.length === 1 && updateArgs[0] === '--all';
+  const names = all ? null : updateArgs;
+
+  if (!all && names?.length === 0) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: 'Usage: /extensions update <extension-names>|--all',
+    });
+    return Promise.resolve();
+  }
+
+  let resolveUpdateComplete: (updateInfo: ExtensionUpdateInfo[]) => void;
+  const updateComplete = new Promise<ExtensionUpdateInfo[]>(
+    (resolve) => (resolveUpdateComplete = resolve),
+  );
+
+  const extensions = context.services.agentContext?.config
+    ? listExtensions(context.services.agentContext.config)
+    : [];
+
+  if (showMessageIfNoExtensions(context, extensions)) {
+    return Promise.resolve();
+  }
+
+  const historyItem: HistoryItemExtensionsList = {
+    type: MessageType.EXTENSIONS_LIST,
+    extensions,
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  updateComplete.then((updateInfos) => {
+    if (updateInfos.length === 0) {
+      context.ui.addItem({
+        type: MessageType.INFO,
+        text: 'No extensions to update.',
+      });
+    }
+
+    context.ui.addItem(historyItem);
+    context.ui.setPendingItem(null);
+  });
+
+  try {
+    context.ui.setPendingItem(historyItem);
+
+    context.ui.dispatchExtensionStateUpdate({
+      type: 'SCHEDULE_UPDATE',
+      payload: {
+        all,
+        names,
+        onComplete: (updateInfos) => {
+          resolveUpdateComplete(updateInfos);
+        },
+      },
+    });
+    if (names?.length) {
+      const extensions = listExtensions(context.services.agentContext!.config);
+      for (const name of names) {
+        const extension = extensions.find(
+          (extension) => extension.name === name,
+        );
+        if (!extension) {
+          context.ui.addItem({
+            type: MessageType.ERROR,
+            text: `Extension ${name} not found.`,
+          });
+          continue;
+        }
+      }
+    }
+  } catch (error) {
+    resolveUpdateComplete!([]);
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: getErrorMessage(error),
+    });
+  }
+  return updateComplete.then((_) => {});
+}
+
+async function restartAction(
+  context: CommandContext,
+  args: string,
+): Promise<void> {
+  const extensionLoader =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!extensionLoader) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: "Extensions are not yet loaded, can't restart yet",
+    });
+    return;
+  }
+
+  const extensions = extensionLoader.getExtensions();
+  if (showMessageIfNoExtensions(context, extensions)) {
+    return;
+  }
+
+  const restartArgs = args.split(' ').filter((value) => value.length > 0);
+  const all = restartArgs.length === 1 && restartArgs[0] === '--all';
+  const names = all ? null : restartArgs;
+  if (!all && names?.length === 0) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: 'Usage: /extensions reload <extension-names>|--all',
+    });
+    return Promise.resolve();
+  }
+
+  let extensionsToRestart = extensionLoader
+    .getExtensions()
+    .filter((extension) => extension.isActive);
+  if (names) {
+    extensionsToRestart = extensionsToRestart.filter((extension) =>
+      names.includes(extension.name),
+    );
+    if (names.length !== extensionsToRestart.length) {
+      const notFound = names.filter(
+        (name) =>
+          !extensionsToRestart.some((extension) => extension.name === name),
+      );
+      if (notFound.length > 0) {
+        context.ui.addItem({
+          type: MessageType.WARNING,
+          text: `Extension(s) not found or not active: ${notFound.join(', ')}`,
+        });
+      }
+    }
+  }
+  if (extensionsToRestart.length === 0) {
+    // We will have logged a different message above already.
+    return;
+  }
+
+  const s = extensionsToRestart.length > 1 ? 's' : '';
+
+  const reloadingMessage = {
+    type: MessageType.INFO,
+    text: `Reloading ${extensionsToRestart.length} extension${s}...`,
+    color: theme.text.primary,
+  };
+  context.ui.addItem(reloadingMessage);
+
+  const results = await Promise.allSettled(
+    extensionsToRestart.map(async (extension) => {
+      if (extension.isActive) {
+        await extensionLoader.restartExtension(extension);
+        context.ui.dispatchExtensionStateUpdate({
+          type: 'RESTARTED',
+          payload: {
+            name: extension.name,
+          },
+        });
+      }
+    }),
+  );
+
+  const failures = results.filter(
+    (result): result is PromiseRejectedResult => result.status === 'rejected',
+  );
+
+  if (failures.length < extensionsToRestart.length) {
+    try {
+      await context.services.agentContext?.config.reloadSkills();
+      await context.services.agentContext?.config.getAgentRegistry()?.reload();
+    } catch (error) {
+      context.ui.addItem({
+        type: MessageType.ERROR,
+        text: `Failed to reload skills or agents: ${getErrorMessage(error)}`,
+      });
+    }
+  }
+
+  if (failures.length > 0) {
+    const errorMessages = failures
+      .map((failure, index) => {
+        const extensionName = extensionsToRestart[index].name;
+        return `${extensionName}: ${getErrorMessage(failure.reason)}`;
+      })
+      .join('\n  ');
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Failed to reload some extensions:\n  ${errorMessages}`,
+    });
+  } else {
+    const infoItem: HistoryItemInfo = {
+      type: MessageType.INFO,
+      text: `${extensionsToRestart.length} extension${s} reloaded successfully`,
+      icon: emptyIcon,
+      color: theme.text.primary,
+    };
+    context.ui.addItem(infoItem);
+  }
+}
+
+async function exploreAction(
+  context: CommandContext,
+): Promise<SlashCommandActionReturn | void> {
+  const settings = context.services.settings.merged;
+  const useRegistryUI = settings.experimental?.extensionRegistry;
+
+  if (useRegistryUI) {
+    const extensionManager =
+      context.services.agentContext?.config.getExtensionLoader();
+    if (extensionManager instanceof ExtensionManager) {
+      return {
+        type: 'custom_dialog' as const,
+        component: React.createElement(ExtensionRegistryView, {
+          onSelect: async (extension, requestConsentOverride) => {
+            debugLogger.log(`Selected extension: ${extension.extensionName}`);
+            await installAction(context, extension.url, requestConsentOverride);
+            context.ui.removeComponent();
+          },
+          onLink: async (extension, requestConsentOverride) => {
+            debugLogger.log(`Linking extension: ${extension.extensionName}`);
+            await linkAction(context, extension.url, requestConsentOverride);
+            context.ui.removeComponent();
+          },
+          onClose: () => context.ui.removeComponent(),
+          extensionManager,
+        }),
+      };
+    }
+  }
+
+  const extensionsUrl = 'https://geminicli.com/extensions/';
+
+  // Only check for NODE_ENV for explicit test mode, not for unit test framework
+  if (process.env['NODE_ENV'] === 'test') {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Would open extensions page in your browser: ${extensionsUrl} (skipped in test environment)`,
+    });
+  } else if (
+    process.env['SANDBOX'] &&
+    process.env['SANDBOX'] !== 'sandbox-exec'
+  ) {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `View available extensions at ${extensionsUrl}`,
+    });
+  } else {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Opening extensions page in your browser: ${extensionsUrl}`,
+    });
+    try {
+      await open(extensionsUrl);
+    } catch {
+      context.ui.addItem({
+        type: MessageType.ERROR,
+        text: `Failed to open browser. Check out the extensions gallery at ${extensionsUrl}`,
+      });
+    }
+  }
+}
+
+function getEnableDisableContext(
+  context: CommandContext,
+  argumentsString: string,
+): {
+  extensionManager: ExtensionManager;
+  names: string[];
+  scope: SettingScope;
+} | null {
+  const extensionLoader =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!(extensionLoader instanceof ExtensionManager)) {
+    debugLogger.error(
+      `Cannot ${context.invocation?.name} extensions in this environment`,
+    );
+    return null;
+  }
+  const parts = argumentsString.split(' ');
+  const name = parts[0];
+  if (
+    name === '' ||
+    !(
+      (parts.length === 2 && parts[1].startsWith('--scope=')) || // --scope=<scope>
+      (parts.length === 3 && parts[1] === '--scope') // --scope <scope>
+    )
+  ) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Usage: /extensions ${context.invocation?.name} <extension> [--scope=<user|workspace|session>]`,
+    });
+    return null;
+  }
+  let scope: SettingScope;
+  // Transform `--scope=<scope>` to `--scope <scope>`.
+  if (parts.length === 2) {
+    parts.push(...parts[1].split('='));
+    parts.splice(1, 1);
+  }
+  switch (parts[2].toLowerCase()) {
+    case 'workspace':
+      scope = SettingScope.Workspace;
+      break;
+    case 'user':
+      scope = SettingScope.User;
+      break;
+    case 'session':
+      scope = SettingScope.Session;
+      break;
+    default:
+      context.ui.addItem({
+        type: MessageType.ERROR,
+        text: `Unsupported scope ${parts[2]}, should be one of "user", "workspace", or "session"`,
+      });
+      debugLogger.error();
+      return null;
+  }
+  let names: string[] = [];
+  if (name === '--all') {
+    let extensions = extensionLoader.getExtensions();
+    if (context.invocation?.name === 'enable') {
+      extensions = extensions.filter((ext) => !ext.isActive);
+    }
+    if (context.invocation?.name === 'disable') {
+      extensions = extensions.filter((ext) => ext.isActive);
+    }
+    names = extensions.map((ext) => ext.name);
+  } else {
+    names = [name];
+  }
+
+  return {
+    extensionManager: extensionLoader,
+    names,
+    scope,
+  };
+}
+
+async function disableAction(context: CommandContext, args: string) {
+  const enableContext = getEnableDisableContext(context, args);
+  if (!enableContext) return;
+
+  const { names, scope, extensionManager } = enableContext;
+  for (const name of names) {
+    await extensionManager.disableExtension(name, scope);
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Extension "${name}" disabled for the scope "${scope}"`,
+    });
+  }
+}
+
+async function enableAction(context: CommandContext, args: string) {
+  const enableContext = getEnableDisableContext(context, args);
+  if (!enableContext) return;
+
+  const { names, scope, extensionManager } = enableContext;
+  for (const name of names) {
+    await extensionManager.enableExtension(name, scope);
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Extension "${name}" enabled for the scope "${scope}"`,
+    });
+
+    // Auto-enable any disabled MCP servers for this extension
+    const extension = extensionManager
+      .getExtensions()
+      .find((e) => e.name === name);
+
+    if (extension?.mcpServers) {
+      const mcpEnablementManager = McpServerEnablementManager.getInstance();
+      const mcpClientManager =
+        context.services.agentContext?.config.getMcpClientManager();
+      const enabledServers = await mcpEnablementManager.autoEnableServers(
+        Object.keys(extension.mcpServers ?? {}),
+      );
+
+      if (mcpClientManager && enabledServers.length > 0) {
+        const restartPromises = enabledServers.map((serverName) =>
+          mcpClientManager.restartServer(serverName).catch((error) => {
+            context.ui.addItem({
+              type: MessageType.WARNING,
+              text: `Failed to restart MCP server '${serverName}': ${getErrorMessage(error)}`,
+            });
+          }),
+        );
+        await Promise.all(restartPromises);
+      }
+
+      if (enabledServers.length > 0) {
+        context.ui.addItem({
+          type: MessageType.INFO,
+          text: `Re-enabled MCP servers: ${enabledServers.join(', ')}`,
+        });
+      }
+    }
+  }
+}
+
+async function installAction(
+  context: CommandContext,
+  args: string,
+  requestConsentOverride?: (consent: string) => Promise<boolean>,
+) {
+  const extensionLoader =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!(extensionLoader instanceof ExtensionManager)) {
+    debugLogger.error(
+      `Cannot ${context.invocation?.name} extensions in this environment`,
+    );
+    return;
+  }
+
+  const source = args.trim();
+  if (!source) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Usage: /extensions install <source>`,
+    });
+    return;
+  }
+
+  // Validate that the source is either a valid URL or a valid file path.
+  let isValid = false;
+  try {
+    // Check if it's a valid URL.
+    new URL(source);
+    isValid = true;
+  } catch {
+    // If not a URL, check for characters that are disallowed in file paths
+    // and could be used for command injection.
+    if (!/[;&|`'"]/.test(source)) {
+      isValid = true;
+    }
+  }
+
+  if (!isValid) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Invalid source: ${source}`,
+    });
+    return;
+  }
+
+  context.ui.addItem({
+    type: MessageType.INFO,
+    text: `Installing extension from "${source}"...`,
+  });
+
+  try {
+    const installMetadata = await inferInstallMetadata(source);
+    const extension = await extensionLoader.installOrUpdateExtension(
+      installMetadata,
+      undefined,
+      requestConsentOverride,
+    );
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Extension "${extension.name}" installed successfully.`,
+    });
+  } catch (error) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Failed to install extension from "${source}": ${getErrorMessage(
+        error,
+      )}`,
+    });
+  }
+}
+
+async function linkAction(
+  context: CommandContext,
+  args: string,
+  requestConsentOverride?: (consent: string) => Promise<boolean>,
+) {
+  const extensionLoader =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!(extensionLoader instanceof ExtensionManager)) {
+    debugLogger.error(
+      `Cannot ${context.invocation?.name} extensions in this environment`,
+    );
+    return;
+  }
+
+  const sourceFilepath = args.trim();
+  if (!sourceFilepath) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Usage: /extensions link <source>`,
+    });
+    return;
+  }
+  if (/[;&|`'"]/.test(sourceFilepath)) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Source file path contains disallowed characters: ${sourceFilepath}`,
+    });
+    return;
+  }
+
+  try {
+    await stat(sourceFilepath);
+  } catch (error) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Invalid source: ${sourceFilepath}`,
+    });
+    debugLogger.error(
+      `Failed to stat path "${sourceFilepath}": ${getErrorMessage(error)}`,
+    );
+    return;
+  }
+
+  context.ui.addItem({
+    type: MessageType.INFO,
+    text: `Linking extension from "${sourceFilepath}"...`,
+  });
+
+  try {
+    const installMetadata: ExtensionInstallMetadata = {
+      source: sourceFilepath,
+      type: 'link',
+    };
+    const extension = await extensionLoader.installOrUpdateExtension(
+      installMetadata,
+      undefined,
+      requestConsentOverride,
+    );
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Extension "${extension.name}" linked successfully.`,
+    });
+  } catch (error) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Failed to link extension from "${sourceFilepath}": ${getErrorMessage(
+        error,
+      )}`,
+    });
+  }
+}
+
+async function uninstallAction(context: CommandContext, args: string) {
+  const extensionLoader =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!(extensionLoader instanceof ExtensionManager)) {
+    debugLogger.error(
+      `Cannot ${context.invocation?.name} extensions in this environment`,
+    );
+    return;
+  }
+
+  const uninstallArgs = args.split(' ').filter((value) => value.length > 0);
+  const all = uninstallArgs.includes('--all');
+  const names = uninstallArgs.filter((a) => !a.startsWith('--'));
+
+  if (!all && names.length === 0) {
+    context.ui.addItem({
+      type: MessageType.ERROR,
+      text: `Usage: /extensions uninstall <extension-names...>|--all`,
+    });
+    return;
+  }
+
+  let namesToUninstall: string[] = [];
+  if (all) {
+    namesToUninstall = extensionLoader.getExtensions().map((ext) => ext.name);
+  } else {
+    namesToUninstall = names;
+  }
+
+  if (namesToUninstall.length === 0) {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: all ? 'No extensions installed.' : 'No extension name provided.',
+    });
+    return;
+  }
+
+  for (const extensionName of namesToUninstall) {
+    context.ui.addItem({
+      type: MessageType.INFO,
+      text: `Uninstalling extension "${extensionName}"...`,
+    });
+
+    try {
+      await extensionLoader.uninstallExtension(extensionName, false);
+      context.ui.addItem({
+        type: MessageType.INFO,
+        text: `Extension "${extensionName}" uninstalled successfully.`,
+      });
+    } catch (error) {
+      context.ui.addItem({
+        type: MessageType.ERROR,
+        text: `Failed to uninstall extension "${extensionName}": ${getErrorMessage(
+          error,
+        )}`,
+      });
+    }
+  }
+}
+
+async function configAction(context: CommandContext, args: string) {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  let scope = ExtensionSettingScope.USER;
+
+  const scopeEqIndex = parts.findIndex((p) => p.startsWith('--scope='));
+  if (scopeEqIndex > -1) {
+    const scopeVal = parts[scopeEqIndex].split('=')[1];
+    if (scopeVal === 'workspace') {
+      scope = ExtensionSettingScope.WORKSPACE;
+    } else if (scopeVal === 'user') {
+      scope = ExtensionSettingScope.USER;
+    }
+    parts.splice(scopeEqIndex, 1);
+  } else {
+    const scopeIndex = parts.indexOf('--scope');
+    if (scopeIndex > -1) {
+      const scopeVal = parts[scopeIndex + 1];
+      if (scopeVal === 'workspace' || scopeVal === 'user') {
+        scope =
+          scopeVal === 'workspace'
+            ? ExtensionSettingScope.WORKSPACE
+            : ExtensionSettingScope.USER;
+        parts.splice(scopeIndex, 2);
+      }
+    }
+  }
+
+  const otherArgs = parts;
+  const name = otherArgs[0];
+  const setting = otherArgs[1];
+
+  if (name) {
+    if (name.includes('/') || name.includes('\\') || name.includes('..')) {
+      context.ui.addItem({
+        type: MessageType.ERROR,
+        text: 'Invalid extension name. Names cannot contain path separators or "..".',
+      });
+      return;
+    }
+  }
+
+  const extensionManager =
+    context.services.agentContext?.config.getExtensionLoader();
+  if (!(extensionManager instanceof ExtensionManager)) {
+    debugLogger.error(
+      `Cannot ${context.invocation?.name} extensions in this environment`,
+    );
+    return;
+  }
+
+  const logger: ConfigLogger = {
+    log: (message: string) => {
+      context.ui.addItem({ type: MessageType.INFO, text: message.trim() });
+    },
+    error: (message: string) =>
+      context.ui.addItem({ type: MessageType.ERROR, text: message }),
+  };
+
+  return {
+    type: 'custom_dialog' as const,
+    component: React.createElement(ConfigExtensionDialog, {
+      extensionManager,
+      onClose: () => context.ui.removeComponent(),
+      extensionName: name,
+      settingKey: setting,
+      scope,
+      configureAll: !name && !setting,
+      loggerAdapter: logger,
+    }),
+  };
+}
+
+/**
+ * Exported for testing.
+ */
+export function completeExtensions(
+  context: CommandContext,
+  partialArg: string,
+) {
+  let extensions = context.services.agentContext?.config.getExtensions() ?? [];
+
+  if (context.invocation?.name === 'enable') {
+    extensions = extensions.filter((ext) => !ext.isActive);
+  }
+  if (
+    context.invocation?.name === 'disable' ||
+    context.invocation?.name === 'restart' ||
+    context.invocation?.name === 'reload'
+  ) {
+    extensions = extensions.filter((ext) => ext.isActive);
+  }
+  const extensionNames = extensions.map((ext) => ext.name);
+  const suggestions = extensionNames.filter((name) =>
+    name.startsWith(partialArg),
+  );
+
+  if ('--all'.startsWith(partialArg) || 'all'.startsWith(partialArg)) {
+    suggestions.unshift('--all');
+  }
+
+  return suggestions;
+}
+
+export function completeExtensionsAndScopes(
+  context: CommandContext,
+  partialArg: string,
+) {
+  return completeExtensions(context, partialArg).flatMap((s) => [
+    `${s} --scope user`,
+    `${s} --scope workspace`,
+    `${s} --scope session`,
+  ]);
+}
+
+const listExtensionsCommand: SlashCommand = {
+  name: 'list',
+  description: 'List active extensions',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  takesArgs: false,
+  action: listAction,
+};
+
+const updateExtensionsCommand: SlashCommand = {
+  name: 'update',
+  description: 'Update extensions. Usage: update <extension-names>|--all',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: updateAction,
+  completion: completeExtensions,
+};
+
+const disableCommand: SlashCommand = {
+  name: 'disable',
+  description: 'Disable an extension',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: disableAction,
+  completion: completeExtensionsAndScopes,
+};
+
+const enableCommand: SlashCommand = {
+  name: 'enable',
+  description: 'Enable an extension',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: enableAction,
+  completion: completeExtensionsAndScopes,
+};
+
+const installCommand: SlashCommand = {
+  name: 'install',
+  description: 'Install an extension from a git repo or local path',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: installAction,
+};
+
+const linkCommand: SlashCommand = {
+  name: 'link',
+  description: 'Link an extension from a local path',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: linkAction,
+};
+
+const uninstallCommand: SlashCommand = {
+  name: 'uninstall',
+  altNames: ['delete'],
+  description: 'Uninstall an extension',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: uninstallAction,
+  completion: completeExtensions,
+};
+
+const exploreExtensionsCommand: SlashCommand = {
+  name: 'explore',
+  description: 'Open extensions page in your browser',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  takesArgs: false,
+  action: exploreAction,
+};
+
+const reloadCommand: SlashCommand = {
+  name: 'reload',
+  altNames: ['restart'],
+  description: 'Reload all extensions',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: restartAction,
+  completion: completeExtensions,
+};
+
+const configCommand: SlashCommand = {
+  name: 'config',
+  description: 'Configure extension settings',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: false,
+  action: configAction,
+};
+
+import { parseSlashCommand } from '../../utils/commands.js';
+
+export function extensionsCommand(
+  enableExtensionReloading?: boolean,
+): SlashCommand {
+  const conditionalCommands = enableExtensionReloading
+    ? [
+        disableCommand,
+        enableCommand,
+        installCommand,
+        uninstallCommand,
+        linkCommand,
+        configCommand,
+      ]
+    : [];
+  const subCommands = [
+    listExtensionsCommand,
+    updateExtensionsCommand,
+    exploreExtensionsCommand,
+    reloadCommand,
+    ...conditionalCommands,
+  ];
+
+  return {
+    name: 'extensions',
+    description: 'Manage extensions',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands,
+    action: async (context, args) => {
+      if (args) {
+        const parsed = parseSlashCommand(`/${args}`, subCommands);
+        if (parsed.commandToExecute?.action) {
+          return parsed.commandToExecute.action(context, parsed.args);
+        }
+      }
+      // Default to list if no subcommand is provided
+      return listExtensionsCommand.action!(context, args);
+    },
+  };
+}

packages/cli/src/ui/commands/footerCommand.tsx

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  type SlashCommand,
+  type CommandContext,
+  type OpenCustomDialogActionReturn,
+  CommandKind,
+} from './types.js';
+import { FooterConfigDialog } from '../components/FooterConfigDialog.js';
+
+export const footerCommand: SlashCommand = {
+  name: 'footer',
+  altNames: ['statusline'],
+  description: 'Configure which items appear in the footer (statusline)',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: (context: CommandContext): OpenCustomDialogActionReturn => ({
+    type: 'custom_dialog',
+    component: <FooterConfigDialog onClose={context.ui.removeComponent} />,
+  }),
+};

packages/cli/src/ui/commands/gemmaStatusCommand.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, type SlashCommand } from './types.js';
+import { MessageType, type HistoryItemGemmaStatus } from '../types.js';
+import { checkGemmaStatus } from '../../commands/gemma/status.js';
+import { GEMMA_MODEL_NAME } from '../../commands/gemma/constants.js';
+
+export const gemmaStatusCommand: SlashCommand = {
+  name: 'gemma',
+  description: 'Check local Gemma model routing status',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  isSafeConcurrent: true,
+  action: async (context) => {
+    const port =
+      parseInt(
+        context.services.settings.merged.experimental?.gemmaModelRouter?.classifier?.host?.match(
+          /:(\d+)/,
+        )?.[1] ?? '',
+        10,
+      ) || undefined;
+    const status = await checkGemmaStatus(port);
+    const item: Omit<HistoryItemGemmaStatus, 'id'> = {
+      type: MessageType.GEMMA_STATUS,
+      binaryInstalled: status.binaryInstalled,
+      binaryPath: status.binaryPath,
+      modelName: GEMMA_MODEL_NAME,
+      modelDownloaded: status.modelDownloaded,
+      serverRunning: status.serverRunning,
+      serverPid: status.serverPid,
+      serverPort: status.port,
+      settingsEnabled: status.settingsEnabled,
+      allPassing: status.allPassing,
+    };
+    context.ui.addItem(item);
+  },
+};

packages/cli/src/ui/commands/helpCommand.test.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { helpCommand } from './helpCommand.js';
+import { CommandKind, type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+
+describe('helpCommand', () => {
+  let mockContext: CommandContext;
+  const originalPlatform = process.platform;
+  const action = helpCommand.action;
+
+  if (!action) {
+    throw new Error('Help command has no action');
+  }
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext({
+      ui: {
+        addItem: vi.fn(),
+      },
+    } as unknown as CommandContext);
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+    vi.unstubAllEnvs();
+    vi.clearAllMocks();
+  });
+
+  it('should add a help message to the UI history by default', async () => {
+    await action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.HELP,
+        timestamp: expect.any(Date),
+      }),
+    );
+  });
+
+  it('should have the correct command properties', () => {
+    expect(helpCommand.name).toBe('help');
+    expect(helpCommand.kind).toBe(CommandKind.BUILT_IN);
+    expect(helpCommand.description).toBe('For help on gemini-cli');
+  });
+
+  describe('Antigravity installer commands help', () => {
+    it('should output macOS installation command on darwin platform', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      await action(mockContext, 'install antigravity cli');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `To install the Antigravity CLI on macOS, run the following command:\n\n'curl -fsSL https://antigravity.google/cli/install.sh | bash'`,
+        }),
+      );
+    });
+
+    it('should output Linux installation command on linux platform', async () => {
+      Object.defineProperty(process, 'platform', { value: 'linux' });
+
+      await action(mockContext, 'how do I install antigravity CLI');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `To install the Antigravity CLI on Linux, run the following command:\n\n'curl -fsSL https://antigravity.google/cli/install.sh | bash'`,
+        }),
+      );
+    });
+
+    it('should output Windows PowerShell installation command on win32 when PSModulePath is set', async () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      vi.stubEnv('PSModulePath', 'C:\\some\\path');
+
+      await action(mockContext, 'how do I migrate to antigravity CLI');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `To install the Antigravity CLI on Windows (PowerShell), run the following command:\n\n'irm https://antigravity.google/cli/install.ps1 | iex'`,
+        }),
+      );
+    });
+
+    it('should output Windows CMD installation command on win32 when PSModulePath is not set', async () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      vi.stubEnv('PSModulePath', '');
+
+      await action(mockContext, 'install antigravity cli');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: `To install the Antigravity CLI on Windows (Command Prompt), run the following command:\n\n'curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd'`,
+        }),
+      );
+    });
+
+    it('should learn more message on unsupported platform', async () => {
+      Object.defineProperty(process, 'platform', { value: 'freebsd' });
+
+      await action(mockContext, 'install antigravity cli');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.INFO,
+          text: 'Learn more about Antigravity CLI at https://antigravity.google/docs/cli-getting-started',
+        }),
+      );
+    });
+
+    it('should fall back to default help if query does not contain install or migrate', async () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+
+      await action(mockContext, 'antigravity cli');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: MessageType.HELP,
+        }),
+      );
+    });
+  });
+});

packages/cli/src/ui/commands/helpCommand.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, type SlashCommand } from './types.js';
+import { MessageType, type HistoryItemHelp } from '../types.js';
+import { getAntigravityInstallInfo } from '../utils/antigravityUtils.js';
+
+export const helpCommand: SlashCommand = {
+  name: 'help',
+  kind: CommandKind.BUILT_IN,
+  description: 'For help on gemini-cli',
+  autoExecute: true,
+  action: async (context, args) => {
+    const lowerArgs = args?.toLowerCase() || '';
+    const hasAntigravity = lowerArgs.includes('antigravity');
+    const hasInstallOrMigrate =
+      lowerArgs.includes('install') || lowerArgs.includes('migrate');
+
+    if (hasAntigravity && hasInstallOrMigrate) {
+      const info = getAntigravityInstallInfo();
+
+      if (info) {
+        context.ui.addItem({
+          type: MessageType.INFO,
+          text: `To install the Antigravity CLI on ${info.platformName}, run the following command:\n\n'${info.installCmd}'`,
+        });
+      } else {
+        context.ui.addItem({
+          type: MessageType.INFO,
+          text: `Learn more about Antigravity CLI at https://antigravity.google/docs/cli-getting-started`,
+        });
+      }
+      return;
+    }
+
+    const helpItem: Omit<HistoryItemHelp, 'id'> = {
+      type: MessageType.HELP,
+      timestamp: new Date(),
+    };
+
+    context.ui.addItem(helpItem);
+  },
+};

packages/cli/src/ui/commands/hooksCommand.test.ts

@@ -0,0 +1,835 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { hooksCommand } from './hooksCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import {
+  HookType,
+  HookEventName,
+  ConfigSource,
+  type HookRegistryEntry,
+} from '@google/gemini-cli-core';
+import type { CommandContext } from './types.js';
+import { SettingScope } from '../../config/settings.js';
+
+describe('hooksCommand', () => {
+  let mockContext: CommandContext;
+  let mockHookSystem: {
+    getAllHooks: ReturnType<typeof vi.fn>;
+    setHookEnabled: ReturnType<typeof vi.fn>;
+    getRegistry: ReturnType<typeof vi.fn>;
+  };
+  let mockConfig: {
+    getHookSystem: ReturnType<typeof vi.fn>;
+    getEnableHooks: ReturnType<typeof vi.fn>;
+    updateDisabledHooks: ReturnType<typeof vi.fn>;
+  };
+  let mockSettings: {
+    merged: {
+      hooksConfig?: {
+        disabled?: string[];
+      };
+    };
+    setValue: ReturnType<typeof vi.fn>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    workspace: { path: string; settings: any };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    user: { path: string; settings: any };
+    forScope: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create mock hook system
+    mockHookSystem = {
+      getAllHooks: vi.fn().mockReturnValue([]),
+      setHookEnabled: vi.fn(),
+      getRegistry: vi.fn().mockReturnValue({
+        initialize: vi.fn().mockResolvedValue(undefined),
+      }),
+    };
+
+    // Create mock config
+    mockConfig = {
+      getHookSystem: vi.fn().mockReturnValue(mockHookSystem),
+      getEnableHooks: vi.fn().mockReturnValue(true),
+      updateDisabledHooks: vi.fn(),
+    };
+
+    // Create mock settings
+    const mockUser = {
+      path: '/mock/user.json',
+      settings: { hooksConfig: { disabled: [] } },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+    const mockWorkspace = {
+      path: '/mock/workspace.json',
+      settings: { hooksConfig: { disabled: [] } },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+
+    mockSettings = {
+      merged: {
+        hooksConfig: {
+          disabled: [],
+        },
+      },
+      setValue: vi.fn(),
+      workspace: mockWorkspace,
+      user: mockUser,
+      forScope: vi.fn((scope) => {
+        if (scope === SettingScope.User) return mockUser;
+        if (scope === SettingScope.Workspace) return mockWorkspace;
+        return mockUser;
+      }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+
+    // Create mock context with config and settings
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: { config: mockConfig },
+        settings: mockSettings,
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('root command', () => {
+    it('should have the correct name and description', () => {
+      expect(hooksCommand.name).toBe('hooks');
+      expect(hooksCommand.description).toBe('Manage hooks');
+    });
+
+    it('should have all expected subcommands', () => {
+      expect(hooksCommand.subCommands).toBeDefined();
+      expect(hooksCommand.subCommands).toHaveLength(5);
+
+      const subCommandNames = hooksCommand.subCommands!.map((cmd) => cmd.name);
+      expect(subCommandNames).toContain('panel');
+      expect(subCommandNames).toContain('enable');
+      expect(subCommandNames).toContain('disable');
+      expect(subCommandNames).toContain('enable-all');
+      expect(subCommandNames).toContain('disable-all');
+    });
+
+    it('should delegate to panel action when invoked without subcommand', async () => {
+      if (!hooksCommand.action) {
+        throw new Error('hooks command must have an action');
+      }
+
+      mockHookSystem.getAllHooks.mockReturnValue([
+        createMockHook('test-hook', HookEventName.BeforeTool, true),
+      ]);
+
+      const result = await hooksCommand.action(mockContext, '');
+
+      expect(result).toHaveProperty('type', 'custom_dialog');
+      expect(result).toHaveProperty('component');
+    });
+  });
+
+  describe('panel subcommand', () => {
+    it('should return error when config is not loaded', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const panelCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'panel',
+      );
+      if (!panelCmd?.action) {
+        throw new Error('panel command must have an action');
+      }
+
+      const result = await panelCmd.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should return custom_dialog even when hook system is not enabled', async () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const panelCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'panel',
+      );
+      if (!panelCmd?.action) {
+        throw new Error('panel command must have an action');
+      }
+
+      const result = await panelCmd.action(mockContext, '');
+
+      expect(result).toHaveProperty('type', 'custom_dialog');
+      expect(result).toHaveProperty('component');
+    });
+
+    it('should return custom_dialog when no hooks are configured', async () => {
+      mockHookSystem.getAllHooks.mockReturnValue([]);
+      (mockContext.services.settings.merged as Record<string, unknown>)[
+        'hooksConfig'
+      ] = { enabled: true };
+
+      const panelCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'panel',
+      );
+      if (!panelCmd?.action) {
+        throw new Error('panel command must have an action');
+      }
+
+      const result = await panelCmd.action(mockContext, '');
+
+      expect(result).toHaveProperty('type', 'custom_dialog');
+      expect(result).toHaveProperty('component');
+    });
+
+    it('should return custom_dialog when hooks are configured', async () => {
+      const mockHooks: HookRegistryEntry[] = [
+        createMockHook('echo-test', HookEventName.BeforeTool, true),
+        createMockHook('notify', HookEventName.AfterAgent, false),
+      ];
+
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+      (mockContext.services.settings.merged as Record<string, unknown>)[
+        'hooksConfig'
+      ] = { enabled: true };
+
+      const panelCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'panel',
+      );
+      if (!panelCmd?.action) {
+        throw new Error('panel command must have an action');
+      }
+
+      const result = await panelCmd.action(mockContext, '');
+
+      expect(result).toHaveProperty('type', 'custom_dialog');
+      expect(result).toHaveProperty('component');
+    });
+  });
+
+  describe('enable subcommand', () => {
+    it('should return error when config is not loaded', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.action) {
+        throw new Error('enable command must have an action');
+      }
+
+      const result = await enableCmd.action(contextWithoutConfig, 'test-hook');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should return error when hook system is not enabled', async () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.action) {
+        throw new Error('enable command must have an action');
+      }
+
+      const result = await enableCmd.action(mockContext, 'test-hook');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Hook system is not enabled.',
+      });
+    });
+
+    it('should return error when hook name is not provided', async () => {
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.action) {
+        throw new Error('enable command must have an action');
+      }
+
+      const result = await enableCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Usage: /hooks enable <hook-name>',
+      });
+    });
+
+    it('should enable a hook and update settings', async () => {
+      // Update the user settings with disabled hooks
+      mockSettings.user.settings.hooksConfig.disabled = [
+        'test-hook',
+        'other-hook',
+      ];
+      mockSettings.workspace.settings.hooksConfig.disabled = [];
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.action) {
+        throw new Error('enable command must have an action');
+      }
+
+      const result = await enableCmd.action(mockContext, 'test-hook');
+
+      expect(mockContext.services.settings.setValue).toHaveBeenCalledWith(
+        SettingScope.User,
+        'hooksConfig.disabled',
+        ['other-hook'],
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'test-hook',
+        true,
+      );
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content:
+          'Hook "test-hook" enabled by removing it from the disabled list in user (/mock/user.json) and workspace (/mock/workspace.json) settings.',
+      });
+    });
+
+    it('should complete hook names using friendly names', () => {
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      )!;
+
+      const hookEntry = createMockHook(
+        './hooks/test.sh',
+        HookEventName.BeforeTool,
+        false, // Must be disabled for enable completion
+      );
+      hookEntry.config.name = 'friendly-name';
+
+      mockHookSystem.getAllHooks.mockReturnValue([hookEntry]);
+
+      const completions = enableCmd.completion!(mockContext, 'frie');
+      expect(completions).toContain('friendly-name');
+    });
+  });
+
+  describe('disable subcommand', () => {
+    it('should return error when config is not loaded', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      );
+      if (!disableCmd?.action) {
+        throw new Error('disable command must have an action');
+      }
+
+      const result = await disableCmd.action(contextWithoutConfig, 'test-hook');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should return error when hook system is not enabled', async () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      );
+      if (!disableCmd?.action) {
+        throw new Error('disable command must have an action');
+      }
+
+      const result = await disableCmd.action(mockContext, 'test-hook');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Hook system is not enabled.',
+      });
+    });
+
+    it('should return error when hook name is not provided', async () => {
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      );
+      if (!disableCmd?.action) {
+        throw new Error('disable command must have an action');
+      }
+
+      const result = await disableCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Usage: /hooks disable <hook-name>',
+      });
+    });
+
+    it('should disable a hook and update settings', async () => {
+      // Ensure not disabled anywhere
+      mockSettings.workspace.settings.hooksConfig.disabled = [];
+      mockSettings.user.settings.hooksConfig.disabled = [];
+
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      );
+      if (!disableCmd?.action) {
+        throw new Error('disable command must have an action');
+      }
+
+      const result = await disableCmd.action(mockContext, 'test-hook');
+
+      // Should default to workspace if present
+      expect(mockContext.services.settings.setValue).toHaveBeenCalledWith(
+        SettingScope.Workspace,
+        'hooksConfig.disabled',
+        ['test-hook'],
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'test-hook',
+        false,
+      );
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content:
+          'Hook "test-hook" disabled by adding it to the disabled list in workspace (/mock/workspace.json) settings.',
+      });
+    });
+
+    it('should return info when hook is already disabled', async () => {
+      // Update the context's settings with the hook already disabled in Workspace
+      mockSettings.workspace.settings.hooksConfig.disabled = ['test-hook'];
+
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      );
+      if (!disableCmd?.action) {
+        throw new Error('disable command must have an action');
+      }
+
+      const result = await disableCmd.action(mockContext, 'test-hook');
+
+      expect(mockContext.services.settings.setValue).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'Hook "test-hook" is already disabled.',
+      });
+    });
+
+    it('should complete hook names using friendly names', () => {
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      )!;
+
+      const hookEntry = createMockHook(
+        './hooks/test.sh',
+        HookEventName.BeforeTool,
+        true, // Must be enabled for disable completion
+      );
+      hookEntry.config.name = 'friendly-name';
+
+      mockHookSystem.getAllHooks.mockReturnValue([hookEntry]);
+
+      const completions = disableCmd.completion!(mockContext, 'frie');
+      expect(completions).toContain('friendly-name');
+    });
+  });
+
+  describe('completion', () => {
+    it('should return empty array when config is not available', () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.completion) {
+        throw new Error('enable command must have completion');
+      }
+
+      const result = enableCmd.completion(contextWithoutConfig, 'test');
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array when hook system is not enabled', () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.completion) {
+        throw new Error('enable command must have completion');
+      }
+
+      const result = enableCmd.completion(mockContext, 'test');
+      expect(result).toEqual([]);
+    });
+
+    it('should return matching hook names based on status', () => {
+      const mockHooks: HookRegistryEntry[] = [
+        createMockHook('test-hook-enabled', HookEventName.BeforeTool, true),
+        createMockHook('test-hook-disabled', HookEventName.AfterTool, false),
+      ];
+
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      )!;
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      )!;
+
+      const enableResult = enableCmd.completion!(mockContext, 'test');
+      expect(enableResult).toEqual(['test-hook-disabled']);
+
+      const disableResult = disableCmd.completion!(mockContext, 'test');
+      expect(disableResult).toEqual(['test-hook-enabled']);
+    });
+
+    it('should return all relevant hook names when partial is empty', () => {
+      const mockHooks: HookRegistryEntry[] = [
+        createMockHook('hook-enabled', HookEventName.BeforeTool, true),
+        createMockHook('hook-disabled', HookEventName.AfterTool, false),
+      ];
+
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      )!;
+      const disableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable',
+      )!;
+
+      expect(enableCmd.completion!(mockContext, '')).toEqual(['hook-disabled']);
+      expect(disableCmd.completion!(mockContext, '')).toEqual(['hook-enabled']);
+    });
+
+    it('should handle hooks without command name gracefully', () => {
+      const mockHooks: HookRegistryEntry[] = [
+        createMockHook('test-hook', HookEventName.BeforeTool, false),
+        {
+          ...createMockHook('', HookEventName.AfterTool, false),
+          config: { command: '', type: HookType.Command, timeout: 30 },
+        },
+      ];
+
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const enableCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable',
+      );
+      if (!enableCmd?.completion) {
+        throw new Error('enable command must have completion');
+      }
+
+      const result = enableCmd.completion(mockContext, 'test');
+      expect(result).toEqual(['test-hook']);
+    });
+  });
+
+  describe('enable-all subcommand', () => {
+    it('should return error when config is not loaded', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const enableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable-all',
+      );
+      if (!enableAllCmd?.action) {
+        throw new Error('enable-all command must have an action');
+      }
+
+      const result = await enableAllCmd.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should return error when hook system is not enabled', async () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const enableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable-all',
+      );
+      if (!enableAllCmd?.action) {
+        throw new Error('enable-all command must have an action');
+      }
+
+      const result = await enableAllCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Hook system is not enabled.',
+      });
+    });
+
+    it('should enable all disabled hooks', async () => {
+      const mockHooks = [
+        createMockHook('hook-1', HookEventName.BeforeTool, false),
+        createMockHook('hook-2', HookEventName.AfterTool, false),
+        createMockHook('hook-3', HookEventName.BeforeAgent, true), // already enabled
+      ];
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const enableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable-all',
+      );
+      if (!enableAllCmd?.action) {
+        throw new Error('enable-all command must have an action');
+      }
+
+      const result = await enableAllCmd.action(mockContext, '');
+
+      expect(mockContext.services.settings.setValue).toHaveBeenCalledWith(
+        expect.any(String), // enableAll uses legacy logic so it might return 'Workspace' or 'User' depending on ternary
+        'hooksConfig.disabled',
+        [],
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'hook-1',
+        true,
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'hook-2',
+        true,
+      );
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'Enabled 2 hook(s) successfully.',
+      });
+    });
+
+    it('should return info when no hooks are configured', async () => {
+      mockHookSystem.getAllHooks.mockReturnValue([]);
+
+      const enableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable-all',
+      );
+      if (!enableAllCmd?.action) {
+        throw new Error('enable-all command must have an action');
+      }
+
+      const result = await enableAllCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No hooks configured.',
+      });
+    });
+
+    it('should return info when all hooks are already enabled', async () => {
+      const mockHooks = [
+        createMockHook('hook-1', HookEventName.BeforeTool, true),
+        createMockHook('hook-2', HookEventName.AfterTool, true),
+      ];
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const enableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'enable-all',
+      );
+      if (!enableAllCmd?.action) {
+        throw new Error('enable-all command must have an action');
+      }
+
+      const result = await enableAllCmd.action(mockContext, '');
+
+      expect(mockContext.services.settings.setValue).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'All hooks are already enabled.',
+      });
+    });
+  });
+
+  describe('disable-all subcommand', () => {
+    it('should return error when config is not loaded', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          agentContext: null,
+        },
+      });
+
+      const disableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable-all',
+      );
+      if (!disableAllCmd?.action) {
+        throw new Error('disable-all command must have an action');
+      }
+
+      const result = await disableAllCmd.action(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should return error when hook system is not enabled', async () => {
+      mockConfig.getHookSystem.mockReturnValue(null);
+
+      const disableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable-all',
+      );
+      if (!disableAllCmd?.action) {
+        throw new Error('disable-all command must have an action');
+      }
+
+      const result = await disableAllCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Hook system is not enabled.',
+      });
+    });
+
+    it('should disable all enabled hooks', async () => {
+      const mockHooks = [
+        createMockHook('hook-1', HookEventName.BeforeTool, true),
+        createMockHook('hook-2', HookEventName.AfterTool, true),
+        createMockHook('hook-3', HookEventName.BeforeAgent, false), // already disabled
+      ];
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const disableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable-all',
+      );
+      if (!disableAllCmd?.action) {
+        throw new Error('disable-all command must have an action');
+      }
+
+      const result = await disableAllCmd.action(mockContext, '');
+
+      expect(mockContext.services.settings.setValue).toHaveBeenCalledWith(
+        expect.any(String),
+        'hooksConfig.disabled',
+        ['hook-1', 'hook-2', 'hook-3'],
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'hook-1',
+        false,
+      );
+      expect(mockHookSystem.setHookEnabled).toHaveBeenCalledWith(
+        'hook-2',
+        false,
+      );
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'Disabled 2 hook(s) successfully.',
+      });
+    });
+
+    it('should return info when no hooks are configured', async () => {
+      mockHookSystem.getAllHooks.mockReturnValue([]);
+
+      const disableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable-all',
+      );
+      if (!disableAllCmd?.action) {
+        throw new Error('disable-all command must have an action');
+      }
+
+      const result = await disableAllCmd.action(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No hooks configured.',
+      });
+    });
+
+    it('should return info when all hooks are already disabled', async () => {
+      const mockHooks = [
+        createMockHook('hook-1', HookEventName.BeforeTool, false),
+        createMockHook('hook-2', HookEventName.AfterTool, false),
+      ];
+      mockHookSystem.getAllHooks.mockReturnValue(mockHooks);
+
+      const disableAllCmd = hooksCommand.subCommands!.find(
+        (cmd) => cmd.name === 'disable-all',
+      );
+      if (!disableAllCmd?.action) {
+        throw new Error('disable-all command must have an action');
+      }
+
+      const result = await disableAllCmd.action(mockContext, '');
+
+      expect(mockContext.services.settings.setValue).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'All hooks are already disabled.',
+      });
+    });
+  });
+});
+
+/**
+ * Helper function to create a mock HookRegistryEntry
+ */
+function createMockHook(
+  command: string,
+  eventName: HookEventName,
+  enabled: boolean,
+): HookRegistryEntry {
+  return {
+    config: {
+      command,
+      type: HookType.Command,
+      timeout: 30,
+    },
+    source: ConfigSource.Project,
+    eventName,
+    matcher: undefined,
+    sequential: false,
+    enabled,
+  };
+}

packages/cli/src/ui/commands/hooksCommand.ts

@@ -0,0 +1,411 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { createElement } from 'react';
+import type {
+  SlashCommand,
+  CommandContext,
+  OpenCustomDialogActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import type {
+  HookRegistryEntry,
+  MessageActionReturn,
+} from '@google/gemini-cli-core';
+import { getErrorMessage } from '@google/gemini-cli-core';
+import { SettingScope, isLoadableSettingScope } from '../../config/settings.js';
+import { enableHook, disableHook } from '../../utils/hookSettings.js';
+import { renderHookActionFeedback } from '../../utils/hookUtils.js';
+import { HooksDialog } from '../components/HooksDialog.js';
+
+/**
+ * Display a formatted list of hooks with their status in a dialog
+ */
+function panelAction(
+  context: CommandContext,
+): MessageActionReturn | OpenCustomDialogActionReturn {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const hookSystem = config.getHookSystem();
+  const allHooks = hookSystem?.getAllHooks() || [];
+
+  return {
+    type: 'custom_dialog',
+    component: createElement(HooksDialog, {
+      hooks: allHooks,
+      onClose: () => context.ui.removeComponent(),
+    }),
+  };
+}
+
+/**
+ * Enable a hook by name
+ */
+async function enableAction(
+  context: CommandContext,
+  args: string,
+): Promise<void | MessageActionReturn> {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Hook system is not enabled.',
+    };
+  }
+
+  const hookName = args.trim();
+  if (!hookName) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /hooks enable <hook-name>',
+    };
+  }
+
+  const settings = context.services.settings;
+  const result = enableHook(settings, hookName);
+
+  if (result.status === 'success') {
+    hookSystem.setHookEnabled(hookName, true);
+  }
+
+  const feedback = renderHookActionFeedback(
+    result,
+    (label, path) => `${label} (${path})`,
+  );
+
+  return {
+    type: 'message',
+    messageType: result.status === 'error' ? 'error' : 'info',
+    content: feedback,
+  };
+}
+
+/**
+ * Disable a hook by name
+ */
+async function disableAction(
+  context: CommandContext,
+  args: string,
+): Promise<void | MessageActionReturn> {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Hook system is not enabled.',
+    };
+  }
+
+  const hookName = args.trim();
+  if (!hookName) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Usage: /hooks disable <hook-name>',
+    };
+  }
+
+  const settings = context.services.settings;
+  const scope = settings.workspace ? SettingScope.Workspace : SettingScope.User;
+
+  const result = disableHook(settings, hookName, scope);
+
+  if (result.status === 'success') {
+    hookSystem.setHookEnabled(hookName, false);
+  }
+
+  const feedback = renderHookActionFeedback(
+    result,
+    (label, path) => `${label} (${path})`,
+  );
+
+  return {
+    type: 'message',
+    messageType: result.status === 'error' ? 'error' : 'info',
+    content: feedback,
+  };
+}
+
+/**
+ * Completion function for enabled hook names (to be disabled)
+ */
+function completeEnabledHookNames(
+  context: CommandContext,
+  partialArg: string,
+): string[] {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) return [];
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) return [];
+
+  const allHooks = hookSystem.getAllHooks();
+  return allHooks
+    .filter((hook) => hook.enabled)
+    .map((hook) => getHookDisplayName(hook))
+    .filter((name) => name.startsWith(partialArg));
+}
+
+/**
+ * Completion function for disabled hook names (to be enabled)
+ */
+function completeDisabledHookNames(
+  context: CommandContext,
+  partialArg: string,
+): string[] {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) return [];
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) return [];
+
+  const allHooks = hookSystem.getAllHooks();
+  return allHooks
+    .filter((hook) => !hook.enabled)
+    .map((hook) => getHookDisplayName(hook))
+    .filter((name) => name.startsWith(partialArg));
+}
+
+/**
+ * Get a display name for a hook
+ */
+function getHookDisplayName(hook: HookRegistryEntry): string {
+  return hook.config.name || hook.config.command || 'unknown-hook';
+}
+
+/**
+ * Enable all hooks by clearing the disabled list
+ */
+async function enableAllAction(
+  context: CommandContext,
+): Promise<void | MessageActionReturn> {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Hook system is not enabled.',
+    };
+  }
+
+  const settings = context.services.settings;
+  const allHooks = hookSystem.getAllHooks();
+
+  if (allHooks.length === 0) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: 'No hooks configured.',
+    };
+  }
+
+  const disabledHooks = allHooks.filter((hook) => !hook.enabled);
+  if (disabledHooks.length === 0) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: 'All hooks are already enabled.',
+    };
+  }
+
+  try {
+    const scopes = [SettingScope.Workspace, SettingScope.User];
+    for (const scope of scopes) {
+      if (isLoadableSettingScope(scope)) {
+        settings.setValue(scope, 'hooksConfig.disabled', []);
+      }
+    }
+
+    for (const hook of disabledHooks) {
+      const hookName = getHookDisplayName(hook);
+      hookSystem.setHookEnabled(hookName, true);
+    }
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Enabled ${disabledHooks.length} hook(s) successfully.`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to enable hooks: ${getErrorMessage(error)}`,
+    };
+  }
+}
+
+/**
+ * Disable all hooks by adding all hooks to the disabled list
+ */
+async function disableAllAction(
+  context: CommandContext,
+): Promise<void | MessageActionReturn> {
+  const agentContext = context.services.agentContext;
+  const config = agentContext?.config;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const hookSystem = config.getHookSystem();
+  if (!hookSystem) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Hook system is not enabled.',
+    };
+  }
+
+  const settings = context.services.settings;
+  const allHooks = hookSystem.getAllHooks();
+
+  if (allHooks.length === 0) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: 'No hooks configured.',
+    };
+  }
+
+  const enabledHooks = allHooks.filter((hook) => hook.enabled);
+  if (enabledHooks.length === 0) {
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: 'All hooks are already disabled.',
+    };
+  }
+
+  try {
+    const allHookNames = allHooks.map((hook) => getHookDisplayName(hook));
+    const scope = settings.workspace
+      ? SettingScope.Workspace
+      : SettingScope.User;
+    settings.setValue(scope, 'hooksConfig.disabled', allHookNames);
+
+    for (const hook of enabledHooks) {
+      const hookName = getHookDisplayName(hook);
+      hookSystem.setHookEnabled(hookName, false);
+    }
+
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `Disabled ${enabledHooks.length} hook(s) successfully.`,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Failed to disable hooks: ${getErrorMessage(error)}`,
+    };
+  }
+}
+
+const panelCommand: SlashCommand = {
+  name: 'panel',
+  altNames: ['list', 'show'],
+  description: 'Display all registered hooks with their status',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: panelAction,
+};
+
+const enableCommand: SlashCommand = {
+  name: 'enable',
+  description: 'Enable a hook by name',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: enableAction,
+  completion: completeDisabledHookNames,
+};
+
+const disableCommand: SlashCommand = {
+  name: 'disable',
+  description: 'Disable a hook by name',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: disableAction,
+  completion: completeEnabledHookNames,
+};
+
+const enableAllCommand: SlashCommand = {
+  name: 'enable-all',
+  altNames: ['enableall'],
+  description: 'Enable all disabled hooks',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: enableAllAction,
+};
+
+const disableAllCommand: SlashCommand = {
+  name: 'disable-all',
+  altNames: ['disableall'],
+  description: 'Disable all enabled hooks',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: disableAllAction,
+};
+
+export const hooksCommand: SlashCommand = {
+  name: 'hooks',
+  description: 'Manage hooks',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    panelCommand,
+    enableCommand,
+    disableCommand,
+    enableAllCommand,
+    disableAllCommand,
+  ],
+  action: (context: CommandContext) => panelCommand.action!(context, ''),
+};

packages/cli/src/ui/commands/ideCommand.test.ts

@@ -0,0 +1,274 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  type MockInstance,
+} from 'vitest';
+import { ideCommand } from './ideCommand.js';
+import { type CommandContext } from './types.js';
+import { IDE_DEFINITIONS } from '@google/gemini-cli-core';
+import * as core from '@google/gemini-cli-core';
+
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const original = await importOriginal<typeof core>();
+  return {
+    ...original,
+    getOauthClient: vi.fn(original.getOauthClient),
+    getIdeInstaller: vi.fn(original.getIdeInstaller),
+    IdeClient: {
+      getInstance: vi.fn(),
+    },
+  };
+});
+
+describe('ideCommand', () => {
+  let mockContext: CommandContext;
+  let mockIdeClient: core.IdeClient;
+  let platformSpy: MockInstance;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockIdeClient = {
+      reconnect: vi.fn(),
+      disconnect: vi.fn(),
+      connect: vi.fn(),
+      getCurrentIde: vi.fn(),
+      getConnectionStatus: vi.fn(),
+      getDetectedIdeDisplayName: vi.fn(),
+    } as unknown as core.IdeClient;
+
+    vi.mocked(core.IdeClient.getInstance).mockResolvedValue(mockIdeClient);
+    vi.mocked(mockIdeClient.getDetectedIdeDisplayName).mockReturnValue(
+      'VS Code',
+    );
+
+    mockContext = {
+      ui: {
+        addItem: vi.fn(),
+      },
+      services: {
+        settings: {
+          setValue: vi.fn(),
+        },
+        agentContext: {
+          config: {
+            getIdeMode: vi.fn(),
+            setIdeMode: vi.fn(),
+            getUsageStatisticsEnabled: vi.fn().mockReturnValue(false),
+          },
+        },
+      },
+    } as unknown as CommandContext;
+
+    platformSpy = vi.spyOn(process, 'platform', 'get');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return the ide command', async () => {
+    vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+      IDE_DEFINITIONS.vscode,
+    );
+    vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+      status: core.IDEConnectionStatus.Disconnected,
+    });
+    const command = await ideCommand();
+    expect(command).not.toBeNull();
+    expect(command.name).toBe('ide');
+    expect(command.subCommands).toHaveLength(3);
+    expect(command.subCommands?.[0].name).toBe('enable');
+    expect(command.subCommands?.[1].name).toBe('status');
+    expect(command.subCommands?.[2].name).toBe('install');
+  });
+
+  it('should show disable command when connected', async () => {
+    vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+      IDE_DEFINITIONS.vscode,
+    );
+    vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+      status: core.IDEConnectionStatus.Connected,
+    });
+    const command = await ideCommand();
+    expect(command).not.toBeNull();
+    const subCommandNames = command.subCommands?.map((cmd) => cmd.name);
+    expect(subCommandNames).toContain('disable');
+    expect(subCommandNames).not.toContain('enable');
+  });
+
+  describe('status subcommand', () => {
+    beforeEach(() => {
+      vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+        IDE_DEFINITIONS.vscode,
+      );
+    });
+
+    it('should show connected status', async () => {
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Connected,
+      });
+      const command = await ideCommand();
+      const result = await command.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: '🟢 Connected to VS Code',
+      });
+    });
+
+    it('should show connecting status', async () => {
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Connecting,
+      });
+      const command = await ideCommand();
+      const result = await command.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      });
+    });
+    it('should show disconnected status', async () => {
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+      });
+      const command = await ideCommand();
+      const result = await command.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `🔴 Disconnected`,
+      });
+    });
+
+    it('should show disconnected status with details', async () => {
+      const details = 'Something went wrong';
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+        details,
+      });
+      const command = await ideCommand();
+      const result = await command.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `🔴 Disconnected: ${details}`,
+      });
+    });
+  });
+
+  describe('install subcommand', () => {
+    const mockInstall = vi.fn();
+    beforeEach(() => {
+      vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+        IDE_DEFINITIONS.vscode,
+      );
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+      });
+      vi.mocked(core.getIdeInstaller).mockReturnValue({
+        install: mockInstall,
+      });
+      platformSpy.mockReturnValue('linux');
+    });
+
+    it('should install the extension', async () => {
+      vi.useFakeTimers();
+      mockInstall.mockResolvedValue({
+        success: true,
+        message: 'Successfully installed.',
+      });
+
+      const command = await ideCommand();
+
+      // For the polling loop inside the action.
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Connected,
+      });
+
+      const actionPromise = command.subCommands!.find(
+        (c) => c.name === 'install',
+      )!.action!(mockContext, '');
+      await vi.runAllTimersAsync();
+      await actionPromise;
+
+      expect(core.getIdeInstaller).toHaveBeenCalledWith(IDE_DEFINITIONS.vscode);
+      expect(mockInstall).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: `Installing IDE companion...`,
+        }),
+        expect.any(Number),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: 'Successfully installed.',
+        }),
+        expect.any(Number),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: '🟢 Connected to VS Code',
+        }),
+        expect.any(Number),
+      );
+      vi.useRealTimers();
+    }, 10000);
+
+    it('should show an error if installation fails', async () => {
+      mockInstall.mockResolvedValue({
+        success: false,
+        message: 'Installation failed.',
+      });
+
+      const command = await ideCommand();
+      await command.subCommands!.find((c) => c.name === 'install')!.action!(
+        mockContext,
+        '',
+      );
+
+      expect(core.getIdeInstaller).toHaveBeenCalledWith(IDE_DEFINITIONS.vscode);
+      expect(mockInstall).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: `Installing IDE companion...`,
+        }),
+        expect.any(Number),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          text: 'Installation failed.',
+        }),
+        expect.any(Number),
+      );
+    });
+  });
+});

packages/cli/src/ui/commands/ideCommand.ts

@@ -0,0 +1,324 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  type Config,
+  IdeClient,
+  type File,
+  logIdeConnection,
+  IdeConnectionEvent,
+  IdeConnectionType,
+} from '@google/gemini-cli-core';
+import {
+  getIdeInstaller,
+  IDEConnectionStatus,
+  ideContextStore,
+  GEMINI_CLI_COMPANION_EXTENSION_NAME,
+} from '@google/gemini-cli-core';
+import path from 'node:path';
+import type {
+  CommandContext,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import { SettingScope } from '../../config/settings.js';
+
+function getIdeStatusMessage(ideClient: IdeClient): {
+  messageType: 'info' | 'error';
+  content: string;
+} {
+  const connection = ideClient.getConnectionStatus();
+  switch (connection.status) {
+    case IDEConnectionStatus.Connected:
+      return {
+        messageType: 'info',
+        content: `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`,
+      };
+    case IDEConnectionStatus.Connecting:
+      return {
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      };
+    default: {
+      let content = `🔴 Disconnected`;
+      if (connection?.details) {
+        content += `: ${connection.details}`;
+      }
+      return {
+        messageType: 'error',
+        content,
+      };
+    }
+  }
+}
+
+function formatFileList(openFiles: File[]): string {
+  const basenameCounts = new Map<string, number>();
+  for (const file of openFiles) {
+    const basename = path.basename(file.path);
+    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
+  }
+
+  const fileList = openFiles
+    .map((file: File) => {
+      const basename = path.basename(file.path);
+      const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
+      const parentDir = path.basename(path.dirname(file.path));
+      const displayName = isDuplicate
+        ? `${basename} (/${parentDir})`
+        : basename;
+
+      return `  - ${displayName}${file.isActive ? ' (active)' : ''}`;
+    })
+    .join('\n');
+
+  const infoMessage = `
+(Note: The file list is limited to a number of recently accessed files within your workspace and only includes local files on disk)`;
+
+  return `\n\nOpen files:\n${fileList}\n${infoMessage}`;
+}
+
+async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
+  messageType: 'info' | 'error';
+  content: string;
+}> {
+  const connection = ideClient.getConnectionStatus();
+  switch (connection.status) {
+    case IDEConnectionStatus.Connected: {
+      let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
+      const context = ideContextStore.get();
+      const openFiles = context?.workspaceState?.openFiles;
+      if (openFiles && openFiles.length > 0) {
+        content += formatFileList(openFiles);
+      }
+      return {
+        messageType: 'info',
+        content,
+      };
+    }
+    case IDEConnectionStatus.Connecting:
+      return {
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      };
+    default: {
+      let content = `🔴 Disconnected`;
+      if (connection?.details) {
+        content += `: ${connection.details}`;
+      }
+      return {
+        messageType: 'error',
+        content,
+      };
+    }
+  }
+}
+
+async function setIdeModeAndSyncConnection(
+  config: Config,
+  value: boolean,
+  options: { logToConsole?: boolean } = {},
+): Promise<void> {
+  config.setIdeMode(value);
+  const ideClient = await IdeClient.getInstance();
+  if (value) {
+    await ideClient.connect(options);
+    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.SESSION));
+  } else {
+    await ideClient.disconnect();
+  }
+}
+
+export const ideCommand = async (): Promise<SlashCommand> => {
+  const ideClient = await IdeClient.getInstance();
+  const currentIDE = ideClient.getCurrentIde();
+  if (!currentIDE) {
+    return {
+      name: 'ide',
+      description: 'Manage IDE integration',
+      kind: CommandKind.BUILT_IN,
+      autoExecute: false,
+      action: (): SlashCommandActionReturn =>
+        ({
+          type: 'message',
+          messageType: 'error',
+          content: `IDE integration is not supported in your current environment. To use this feature, run Gemini CLI in one of these supported IDEs: Antigravity, VS Code, or VS Code forks.`,
+        }) as const,
+    };
+  }
+
+  const ideSlashCommand: SlashCommand = {
+    name: 'ide',
+    description: 'Manage IDE integration',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: false,
+    subCommands: [],
+  };
+
+  const statusCommand: SlashCommand = {
+    name: 'status',
+    description: 'Check status of IDE integration',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (): Promise<SlashCommandActionReturn> => {
+      const { messageType, content } =
+        await getIdeStatusMessageWithFiles(ideClient);
+      return {
+        type: 'message',
+        messageType,
+        content,
+      } as const;
+    },
+  };
+
+  const installCommand: SlashCommand = {
+    name: 'install',
+    description: `Install required IDE companion for ${ideClient.getDetectedIdeDisplayName()}`,
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context) => {
+      const installer = getIdeInstaller(currentIDE);
+      if (!installer) {
+        context.ui.addItem(
+          {
+            type: 'error',
+            text: `No installer is available for ${ideClient.getDetectedIdeDisplayName()}. Please install the '${GEMINI_CLI_COMPANION_EXTENSION_NAME}' extension manually from the marketplace.`,
+          },
+          Date.now(),
+        );
+        return;
+      }
+
+      context.ui.addItem(
+        {
+          type: 'info',
+          text: `Installing IDE companion...`,
+        },
+        Date.now(),
+      );
+
+      const result = await installer.install();
+      context.ui.addItem(
+        {
+          type: result.success ? 'info' : 'error',
+          text: result.message,
+        },
+        Date.now(),
+      );
+      if (result.success) {
+        context.services.settings.setValue(
+          SettingScope.User,
+          'ide.enabled',
+          true,
+        );
+        // Poll for up to 5 seconds for the extension to activate.
+        for (let i = 0; i < 10; i++) {
+          await setIdeModeAndSyncConnection(
+            context.services.agentContext!.config,
+            true,
+            {
+              logToConsole: false,
+            },
+          );
+          if (
+            ideClient.getConnectionStatus().status ===
+            IDEConnectionStatus.Connected
+          ) {
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+
+        const { messageType, content } = getIdeStatusMessage(ideClient);
+        if (messageType === 'error') {
+          context.ui.addItem(
+            {
+              type: messageType,
+              text: `Failed to automatically enable IDE integration. To fix this, run the CLI in a new terminal window.`,
+            },
+            Date.now(),
+          );
+        } else {
+          context.ui.addItem(
+            {
+              type: messageType,
+              text: content,
+            },
+            Date.now(),
+          );
+        }
+      }
+    },
+  };
+
+  const enableCommand: SlashCommand = {
+    name: 'enable',
+    description: 'Enable IDE integration',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context: CommandContext) => {
+      context.services.settings.setValue(
+        SettingScope.User,
+        'ide.enabled',
+        true,
+      );
+      await setIdeModeAndSyncConnection(
+        context.services.agentContext!.config,
+        true,
+      );
+      const { messageType, content } = getIdeStatusMessage(ideClient);
+      context.ui.addItem(
+        {
+          type: messageType,
+          text: content,
+        },
+        Date.now(),
+      );
+    },
+  };
+
+  const disableCommand: SlashCommand = {
+    name: 'disable',
+    description: 'Disable IDE integration',
+    kind: CommandKind.BUILT_IN,
+    autoExecute: true,
+    action: async (context: CommandContext) => {
+      context.services.settings.setValue(
+        SettingScope.User,
+        'ide.enabled',
+        false,
+      );
+      await setIdeModeAndSyncConnection(
+        context.services.agentContext!.config,
+        false,
+      );
+      const { messageType, content } = getIdeStatusMessage(ideClient);
+      context.ui.addItem(
+        {
+          type: messageType,
+          text: content,
+        },
+        Date.now(),
+      );
+    },
+  };
+
+  const { status } = ideClient.getConnectionStatus();
+  const isConnected = status === IDEConnectionStatus.Connected;
+
+  if (isConnected) {
+    ideSlashCommand.subCommands = [statusCommand, disableCommand];
+  } else {
+    ideSlashCommand.subCommands = [
+      enableCommand,
+      statusCommand,
+      installCommand,
+    ];
+  }
+
+  return ideSlashCommand;
+};

packages/cli/src/ui/commands/initCommand.test.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { initCommand } from './initCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import type { CommandContext } from './types.js';
+import type { SubmitPromptActionReturn } from '@google/gemini-cli-core';
+
+// Mock the 'fs' module
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    existsSync: vi.fn(),
+    writeFileSync: vi.fn(),
+  };
+});
+
+describe('initCommand', () => {
+  let mockContext: CommandContext;
+  const targetDir = '/test/dir';
+  const geminiMdPath = path.join(targetDir, 'GEMINI.md');
+
+  beforeEach(() => {
+    // Create a fresh mock context for each test
+    mockContext = createMockCommandContext({
+      services: {
+        agentContext: {
+          config: {
+            getTargetDir: () => targetDir,
+          },
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    // Clear all mocks after each test
+    vi.clearAllMocks();
+  });
+
+  it('should inform the user if GEMINI.md already exists', async () => {
+    // Arrange: Simulate that the file exists
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    // Act: Run the command's action
+    const result = await initCommand.action!(mockContext, '');
+
+    // Assert: Check for the correct informational message
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content:
+        'A GEMINI.md file already exists in this directory. No changes were made.',
+    });
+    // Assert: Ensure no file was written
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  it('should create GEMINI.md and submit a prompt if it does not exist', async () => {
+    // Arrange: Simulate that the file does not exist
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    // Act: Run the command's action
+    const result = (await initCommand.action!(
+      mockContext,
+      '',
+    )) as SubmitPromptActionReturn;
+
+    // Assert: Check that writeFileSync was called correctly
+    expect(fs.writeFileSync).toHaveBeenCalledWith(geminiMdPath, '', 'utf8');
+
+    // Assert: Check that an informational message was added to the UI
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: 'info',
+        text: 'Empty GEMINI.md created. Now analyzing the project to populate it.',
+      },
+      expect.any(Number),
+    );
+
+    // Assert: Check that the correct prompt is submitted
+    expect(result.type).toBe('submit_prompt');
+    expect(result.content).toContain(
+      'You are an AI agent that brings the power of Gemini',
+    );
+  });
+
+  it('should return an error if config is not available', async () => {
+    // Arrange: Create a context without config
+    const noConfigContext = createMockCommandContext();
+    if (noConfigContext.services) {
+      noConfigContext.services.agentContext = null;
+    }
+
+    // Act: Run the command's action
+    const result = await initCommand.action!(noConfigContext, '');
+
+    // Assert: Check for the correct error message
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    });
+  });
+});

packages/cli/src/ui/commands/initCommand.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type {
+  CommandContext,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+import { CommandKind } from './types.js';
+import { performInit } from '@google/gemini-cli-core';
+
+export const initCommand: SlashCommand = {
+  name: 'init',
+  description: 'Analyzes the project and creates a tailored GEMINI.md file',
+  kind: CommandKind.BUILT_IN,
+  autoExecute: true,
+  action: async (
+    context: CommandContext,
+    _args: string,
+  ): Promise<SlashCommandActionReturn> => {
+    if (!context.services.agentContext?.config) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      };
+    }
+    const targetDir = context.services.agentContext.config.getTargetDir();
+    const geminiMdPath = path.join(targetDir, 'GEMINI.md');
+
+    const result = performInit(fs.existsSync(geminiMdPath));
+
+    if (result.type === 'submit_prompt') {
+      // Create an empty GEMINI.md file
+      fs.writeFileSync(geminiMdPath, '', 'utf8');
+
+      context.ui.addItem(
+        {
+          type: 'info',
+          text: 'Empty GEMINI.md created. Now analyzing the project to populate it.',
+        },
+        Date.now(),
+      );
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return result as SlashCommandActionReturn;
+  },
+};