fix

.gemini/skills/docs-writer/SKILL.md

@@ -45,10 +45,6 @@ Write precisely to ensure your instructions are unambiguous.
   specific verbs.
 - **Examples:** Use meaningful names in examples; avoid placeholders like
   "foo" or "bar."
-- **Quota and limit terminology:** For any content involving resource capacity
-  or using the word "quota" or "limit", strictly adhere to the guidelines in
-  the `quota-limit-style-guide.md` resource file. Generally, Use "quota" for the
-  administrative bucket and "limit" for the numerical ceiling.
 
 ### Formatting and syntax
 Apply consistent formatting to make documentation visually organized and

.gemini/skills/docs-writer/quota-limit-style-guide.md

@@ -1,61 +0,0 @@
-# Style Guide: Quota vs. Limit
-
-This guide defines the usage of "quota," "limit," and related terms in
-user-facing interfaces.
-
-## TL;DR
-
-- **`quota`**: The administrative "bucket." Use for settings, billing, and
-  requesting increases. (e.g., "Adjust your storage **quota**.")
-- **`limit`**: The real-time numerical "ceiling." Use for error messages when a
-  user is blocked. (e.g., "You've reached your request **limit**.")
-- **When blocked, combine them:** Explain the **limit** that was hit and the
-  **quota** that is the remedy. (e.g., "You've reached the request **limit** for
-  your developer **quota**.")
-- **Related terms:** Use `usage` for consumption tracking, `restriction` for
-  fixed rules, and `reset` for when a limit refreshes.
-
----
-
-## Detailed Guidelines
-
-### Definitions
-
-- **Quota is the "what":** It identifies the category of resource being managed
-  (e.g., storage quota, GPU quota, request/prompt quota).
-- **Limit is the "how much":** It defines the numerical boundary.
-
-Use **quota** when referring to the administrative concept or the request for
-more. Use **limit** when discussing the specific point of exhaustion.
-
-### When to use "quota"
-
-Use this term for **account management, billing, and settings.** It describes
-the entitlement the user has purchased or been assigned.
-
-**Examples:**
-
-- **Navigation label:** Quota and usage
-- **Contextual help:** Your **usage quota** is managed by your organization. To
-  request an increase, contact your administrator.
-
-### When to use "limit"
-
-Use this term for **real-time feedback, notifications, and error messages.** It
-identifies the specific wall the user just hit.
-
-**Examples:**
-
-- **Error message:** You’ve reached the 50-request-per-minute **limit**.
-- **Inline warning:** Input exceeds the 32k token **limit**.
-
-### How to use both together
-
-When a user is blocked, combine both terms to explain the **event** (limit) and
-the **remedy** (quota).
-
-**Example:**
-
-- **Heading:** Daily usage limit reached
-- **Body:** You've reached the maximum daily capacity for your developer quota.
-  To continue working today, upgrade your quota.

.github/workflows/ci.yml

@@ -124,9 +124,7 @@ jobs:
       - name: 'Link Checker'
         uses: 'lycheeverse/lychee-action@885c65f3dc543b57c898c8099f4e08c8afd178a2' # ratchet: lycheeverse/lychee-action@v2.6.1
         with:
-          # Exclude GEMINI.md because the absolute GitHub URL in CONTRIBUTING.md (which is symlinked)
-          # causes intermittent 429 Too Many Requests errors from GitHub API rate limits.
-          args: '--verbose --accept 200,503 --exclude "GEMINI\\.md" ./**/*.md'
+          args: '--verbose --accept 200,503 ./**/*.md'
           fail: true
   test_linux:
     name: 'Test (Linux) - ${{ matrix.node-version }}, ${{ matrix.shard }}'

.github/workflows/links.yml

@@ -22,6 +22,4 @@ jobs:
         id: 'lychee'
         uses: 'lycheeverse/lychee-action@885c65f3dc543b57c898c8099f4e08c8afd178a2' # ratchet: lycheeverse/lychee-action@v2.6.1
         with:
-          # Exclude GEMINI.md because the absolute GitHub URL in CONTRIBUTING.md (which is symlinked)
-          # causes intermittent 429 Too Many Requests errors from GitHub API rate limits.
-          args: '--verbose --no-progress --accept 200,503 --exclude "GEMINI\\.md" ./**/*.md'
+          args: '--verbose --no-progress --accept 200,503 ./**/*.md'

docs/cli/cli-reference.md

@@ -26,29 +26,29 @@ and parameters.
 
 ## CLI Options
 
-| Option                           | Alias | Type    | Default   | Description                                                                                                                                                            |
-| -------------------------------- | ----- | ------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--debug`                        | `-d`  | boolean | `false`   | Run in debug mode with verbose logging                                                                                                                                 |
-| `--version`                      | `-v`  | -       | -         | Show CLI version number and exit                                                                                                                                       |
-| `--help`                         | `-h`  | -       | -         | Show help information                                                                                                                                                  |
-| `--model`                        | `-m`  | string  | `auto`    | Model to use. See [Model Selection](#model-selection) for available values.                                                                                            |
-| `--prompt`                       | `-p`  | string  | -         | Prompt text. Appended to stdin input if provided. **Deprecated:** Use positional arguments instead.                                                                    |
-| `--prompt-interactive`           | `-i`  | string  | -         | Execute prompt and continue in interactive mode                                                                                                                        |
-| `--sandbox`                      | `-s`  | boolean | `false`   | Run in a sandboxed environment for safer execution                                                                                                                     |
-| `--approval-mode`                | -     | string  | `default` | Approval mode for tool execution. Choices: `default`, `auto_edit`, `yolo`                                                                                              |
-| `--yolo`                         | `-y`  | boolean | `false`   | **Deprecated.** Auto-approve all actions. Use `--approval-mode=yolo` instead.                                                                                          |
-| `--experimental-acp`             | -     | boolean | -         | Start in ACP (Agent Code Pilot) mode. **Experimental feature.**                                                                                                        |
-| `--experimental-zed-integration` | -     | boolean | -         | Run in Zed editor integration mode. **Experimental feature.**                                                                                                          |
-| `--allowed-mcp-server-names`     | -     | array   | -         | Allowed MCP server names (comma-separated or multiple flags)                                                                                                           |
-| `--allowed-tools`                | -     | array   | -         | **Deprecated.** Use the [Policy Engine](../reference/policy-engine.md) instead. Tools that are allowed to run without confirmation (comma-separated or multiple flags) |
-| `--extensions`                   | `-e`  | array   | -         | List of extensions to use. If not provided, all extensions are enabled (comma-separated or multiple flags)                                                             |
-| `--list-extensions`              | `-l`  | boolean | -         | List all available extensions and exit                                                                                                                                 |
-| `--resume`                       | `-r`  | string  | -         | Resume a previous session. Use `"latest"` for most recent or index number (e.g. `--resume 5`)                                                                          |
-| `--list-sessions`                | -     | boolean | -         | List available sessions for the current project and exit                                                                                                               |
-| `--delete-session`               | -     | string  | -         | Delete a session by index number (use `--list-sessions` to see available sessions)                                                                                     |
-| `--include-directories`          | -     | array   | -         | Additional directories to include in the workspace (comma-separated or multiple flags)                                                                                 |
-| `--screen-reader`                | -     | boolean | -         | Enable screen reader mode for accessibility                                                                                                                            |
-| `--output-format`                | `-o`  | string  | `text`    | The format of the CLI output. Choices: `text`, `json`, `stream-json`                                                                                                   |
+| Option                       | Alias | Type    | Default   | Description                                                                                                                                                            |
+| ---------------------------- | ----- | ------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--debug`                    | `-d`  | boolean | `false`   | Run in debug mode with verbose logging                                                                                                                                 |
+| `--version`                  | `-v`  | -       | -         | Show CLI version number and exit                                                                                                                                       |
+| `--help`                     | `-h`  | -       | -         | Show help information                                                                                                                                                  |
+| `--model`                    | `-m`  | string  | `auto`    | Model to use. See [Model Selection](#model-selection) for available values.                                                                                            |
+| `--prompt`                   | `-p`  | string  | -         | Prompt text. Appended to stdin input if provided. **Deprecated:** Use positional arguments instead.                                                                    |
+| `--prompt-interactive`       | `-i`  | string  | -         | Execute prompt and continue in interactive mode                                                                                                                        |
+| `--sandbox`                  | `-s`  | boolean | `false`   | Run in a sandboxed environment for safer execution                                                                                                                     |
+| `--approval-mode`            | -     | string  | `default` | Approval mode for tool execution. Choices: `default`, `auto_edit`, `yolo`                                                                                              |
+| `--yolo`                     | `-y`  | boolean | `false`   | **Deprecated.** Auto-approve all actions. Use `--approval-mode=yolo` instead.                                                                                          |
+| `--acp`                      | `-`   | boolean | -         | Start in ACP (Agent Client Protocol) mode.                                                                                                                             |
+| `--experimental-acp`         | -     | boolean | -         | **Deprecated.** Use `--acp` instead.                                                                                                                                   |
+| `--allowed-mcp-server-names` | -     | array   | -         | Allowed MCP server names (comma-separated or multiple flags)                                                                                                           |
+| `--allowed-tools`            | -     | array   | -         | **Deprecated.** Use the [Policy Engine](../reference/policy-engine.md) instead. Tools that are allowed to run without confirmation (comma-separated or multiple flags) |
+| `--extensions`               | `-e`  | array   | -         | List of extensions to use. If not provided, all extensions are enabled (comma-separated or multiple flags)                                                             |
+| `--list-extensions`          | `-l`  | boolean | -         | List all available extensions and exit                                                                                                                                 |
+| `--resume`                   | `-r`  | string  | -         | Resume a previous session. Use `"latest"` for most recent or index number (e.g. `--resume 5`)                                                                          |
+| `--list-sessions`            | -     | boolean | -         | List available sessions for the current project and exit                                                                                                               |
+| `--delete-session`           | -     | string  | -         | Delete a session by index number (use `--list-sessions` to see available sessions)                                                                                     |
+| `--include-directories`      | -     | array   | -         | Additional directories to include in the workspace (comma-separated or multiple flags)                                                                                 |
+| `--screen-reader`            | -     | boolean | -         | Enable screen reader mode for accessibility                                                                                                                            |
+| `--output-format`            | `-o`  | string  | `text`    | The format of the CLI output. Choices: `text`, `json`, `stream-json`                                                                                                   |
 
 ## Model selection
 

docs/cli/plan-mode.md

@@ -1,4 +1,4 @@
-# Plan Mode
+# Plan Mode (experimental)
 
 Plan Mode is a read-only environment for architecting robust solutions before
 implementation. It allows you to:
@@ -8,8 +8,64 @@ implementation. It allows you to:
 - **Design:** Understand problems, evaluate trade-offs, and choose a solution.
 - **Plan:** Align on an execution strategy before any code is modified.
 
-Plan Mode is enabled by default. You can manage this setting using the
-`/settings` command.
+> **Note:** This is a preview feature currently under active development. Your
+> feedback is invaluable as we refine this feature. If you have ideas,
+> suggestions, or encounter issues:
+>
+> - [Open an issue](https://github.com/google-gemini/gemini-cli/issues) on
+>   GitHub.
+> - Use the **/bug** command within Gemini CLI to file an issue.
+
+- [Enabling Plan Mode](#enabling-plan-mode)
+- [How to use Plan Mode](#how-to-use-plan-mode)
+  - [Entering Plan Mode](#entering-plan-mode)
+  - [Planning Workflow](#planning-workflow)
+  - [Exiting Plan Mode](#exiting-plan-mode)
+- [Tool Restrictions](#tool-restrictions)
+  - [Customizing Planning with Skills](#customizing-planning-with-skills)
+  - [Customizing Policies](#customizing-policies)
+    - [Example: Allow git commands in Plan Mode](#example-allow-git-commands-in-plan-mode)
+    - [Example: Enable custom subagents in Plan Mode](#example-enable-custom-subagents-in-plan-mode)
+  - [Custom Plan Directory and Policies](#custom-plan-directory-and-policies)
+- [Automatic Model Routing](#automatic-model-routing)
+- [Cleanup](#cleanup)
+
+## Enabling Plan Mode
+
+To use Plan Mode, enable it via **/settings** (search for **Plan**) or add the
+following to your `settings.json`:
+
+```json
+{
+  "experimental": {
+    "plan": true
+  }
+}
+```
+
+## How to use Plan Mode
+
+### Entering Plan Mode
+
+You can configure Gemini CLI to start in Plan Mode by default or enter it
+manually during a session.
+
+- **Configuration:** Configure Gemini CLI to start directly in Plan Mode by
+  default:
+  1.  Type `/settings` in the CLI.
+  2.  Search for **Default Approval Mode**.
+  3.  Set the value to **Plan**.
+
+  Alternatively, use the `gemini --approval-mode=plan` CLI flag or manually
+  update:
+
+  ```json
+  {
+    "general": {
+      "defaultApprovalMode": "plan"
+    }
+  }
+  ```
 
 - **Keyboard Shortcut:** Press `Shift+Tab` to cycle through approval modes
   (`Default` -> `Auto-Edit` -> `Plan`).
@@ -70,10 +126,6 @@ To exit Plan Mode, you can:
 - **Tool:** Gemini CLI calls the [`exit_plan_mode`] tool to present the
   finalized plan for your approval.
 
-### Commands
-
-- **`/plan copy`**: Copy the currently approved plan to your clipboard.
-
 ## Tool Restrictions
 
 Plan Mode enforces strict safety policies to prevent accidental changes.

docs/cli/settings.md

@@ -144,7 +144,7 @@ they appear in the UI.
 | Enable Tool Output Masking | `experimental.toolOutputMasking.enabled` | Enables tool output masking to save tokens.                                                                                                               | `true`  |
 | Use OSC 52 Paste           | `experimental.useOSC52Paste`             | Use OSC 52 for pasting. This may be more robust than the default system when using remote terminal sessions (if your terminal is configured to allow it). | `false` |
 | Use OSC 52 Copy            | `experimental.useOSC52Copy`              | Use OSC 52 for copying. This may be more robust than the default system when using remote terminal sessions (if your terminal is configured to allow it). | `false` |
-| Plan                       | `experimental.plan`                      | Enable Plan Mode.                                                                                                                                         | `true`  |
+| Plan                       | `experimental.plan`                      | Enable planning features (Plan Mode and tools).                                                                                                           | `false` |
 | Model Steering             | `experimental.modelSteering`             | Enable model steering (user hints) to guide the model during tool execution.                                                                              | `false` |
 | Direct Web Fetch           | `experimental.directWebFetch`            | Enable web fetch behavior that bypasses LLM summarization.                                                                                                | `false` |
 | Enable Gemma Model Router  | `experimental.gemmaModelRouter.enabled`  | Enable the Gemma Model Router. Requires a local endpoint serving Gemma via the Gemini API using LiteRT-LM shim.                                           | `false` |

docs/reference/commands.md

@@ -268,11 +268,8 @@ Slash commands provide meta-level control over the CLI itself.
 
 - **Description:** Switch to Plan Mode (read-only) and view the current plan if
   one has been generated.
-  - **Note:** This feature is enabled by default. It can be disabled via the
-    `experimental.plan` setting in your configuration.
-- **Sub-commands:**
-  - **`copy`**:
-    - **Description:** Copy the currently approved plan to your clipboard.
+  - **Note:** This feature requires the `experimental.plan` setting to be
+    enabled in your configuration.
 
 ### `/policies`
 

docs/reference/configuration.md

@@ -1010,8 +1010,8 @@ their corresponding top-level category object in your `settings.json` file.
   - **Default:** `false`
 
 - **`experimental.plan`** (boolean):
-  - **Description:** Enable Plan Mode.
-  - **Default:** `true`
+  - **Description:** Enable planning features (Plan Mode and tools).
+  - **Default:** `false`
   - **Requires restart:** Yes
 
 - **`experimental.modelSteering`** (boolean):
@@ -1583,8 +1583,10 @@ for that specific session.
     with screen readers.
 - **`--version`**:
   - Displays the version of the CLI.
-- **`--experimental-acp`**:
+- **`--acp`**:
   - Starts the agent in ACP mode.
+- **`--experimental-acp`**:
+  - **Deprecated.** Use `--acp` instead.
 - **`--allowed-mcp-server-names`**:
   - Allowed MCP server names.
 - **`--fake-responses`**:

docs/sidebar.json

@@ -94,14 +94,7 @@
           { "label": "Agent Skills", "slug": "docs/cli/skills" },
           { "label": "Checkpointing", "slug": "docs/cli/checkpointing" },
           { "label": "Headless mode", "slug": "docs/cli/headless" },
-          {
-            "label": "Hooks",
-            "collapsed": true,
-            "items": [
-              { "label": "Overview", "slug": "docs/hooks" },
-              { "label": "Reference", "slug": "docs/hooks/reference" }
-            ]
-          },
+          { "label": "Hooks", "slug": "docs/hooks" },
           { "label": "IDE integration", "slug": "docs/ide-integration" },
           { "label": "MCP servers", "slug": "docs/tools/mcp-server" },
           { "label": "Model routing", "slug": "docs/cli/model-routing" },

integration-tests/extensions-reload.test.ts

@@ -104,7 +104,7 @@ describe('extension reloading', () => {
           return (
             output.includes(
               'test-server (from test-extension) - Ready (1 tool)',
-            ) && output.includes('- mcp_test-server_hello')
+            ) && output.includes('- hello')
           );
         },
         30000, // 30s timeout
@@ -148,7 +148,7 @@ describe('extension reloading', () => {
           return (
             output.includes(
               'test-server (from test-extension) - Ready (1 tool)',
-            ) && output.includes('- mcp_test-server_goodbye')
+            ) && output.includes('- goodbye')
           );
         },
         30000,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.33.0",
+  "version": "0.33.0-nightly.20260228.1ca5c05d0",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -14,7 +14,7 @@
     "url": "git+https://github.com/google-gemini/gemini-cli.git"
   },
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.33.0"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.33.0-nightly.20260228.1ca5c05d0"
   },
   "scripts": {
     "start": "cross-env NODE_ENV=development node scripts/start.js",

packages/a2a-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-a2a-server",
-  "version": "0.33.0",
+  "version": "0.33.0-nightly.20260228.1ca5c05d0",
   "description": "Gemini CLI A2A Server",
   "repository": {
     "type": "git",
@@ -36,7 +36,7 @@
     "winston": "^3.17.0"
   },
   "devDependencies": {
-    "@google/genai": "1.30.0",
+    "@google/genai": "^1.30.0",
     "@types/express": "^5.0.3",
     "@types/fs-extra": "^11.0.4",
     "@types/supertest": "^6.0.3",

packages/a2a-server/src/agent/executor.test.ts

@@ -1,248 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
-import { CoderAgentExecutor } from './executor.js';
-import type {
-  ExecutionEventBus,
-  RequestContext,
-  TaskStore,
-} from '@a2a-js/sdk/server';
-import { EventEmitter } from 'node:events';
-import { requestStorage } from '../http/requestStorage.js';
-
-// Mocks for constructor dependencies
-vi.mock('../config/config.js', () => ({
-  loadConfig: vi.fn().mockReturnValue({
-    getSessionId: () => 'test-session',
-    getTargetDir: () => '/tmp',
-    getCheckpointingEnabled: () => false,
-  }),
-  loadEnvironment: vi.fn(),
-  setTargetDir: vi.fn().mockReturnValue('/tmp'),
-}));
-
-vi.mock('../config/settings.js', () => ({
-  loadSettings: vi.fn().mockReturnValue({}),
-}));
-
-vi.mock('../config/extension.js', () => ({
-  loadExtensions: vi.fn().mockReturnValue([]),
-}));
-
-vi.mock('../http/requestStorage.js', () => ({
-  requestStorage: {
-    getStore: vi.fn(),
-  },
-}));
-
-vi.mock('./task.js', () => {
-  const mockTaskInstance = (taskId: string, contextId: string) => ({
-    id: taskId,
-    contextId,
-    taskState: 'working',
-    acceptUserMessage: vi
-      .fn()
-      .mockImplementation(async function* (context, aborted) {
-        const isConfirmation = (
-          context.userMessage.parts as Array<{ kind: string }>
-        ).some((p) => p.kind === 'confirmation');
-        // Hang only for main user messages (text), allow confirmations to finish quickly
-        if (!isConfirmation && aborted) {
-          await new Promise((resolve) => {
-            aborted.addEventListener('abort', resolve, { once: true });
-          });
-        }
-        yield { type: 'content', value: 'hello' };
-      }),
-    acceptAgentMessage: vi.fn().mockResolvedValue(undefined),
-    scheduleToolCalls: vi.fn().mockResolvedValue(undefined),
-    waitForPendingTools: vi.fn().mockResolvedValue(undefined),
-    getAndClearCompletedTools: vi.fn().mockReturnValue([]),
-    addToolResponsesToHistory: vi.fn(),
-    sendCompletedToolsToLlm: vi.fn().mockImplementation(async function* () {}),
-    cancelPendingTools: vi.fn(),
-    setTaskStateAndPublishUpdate: vi.fn(),
-    dispose: vi.fn(),
-    getMetadata: vi.fn().mockResolvedValue({}),
-    geminiClient: {
-      initialize: vi.fn().mockResolvedValue(undefined),
-    },
-    toSDKTask: () => ({
-      id: taskId,
-      contextId,
-      kind: 'task',
-      status: { state: 'working', timestamp: new Date().toISOString() },
-      metadata: {},
-      history: [],
-      artifacts: [],
-    }),
-  });
-
-  const MockTask = vi.fn().mockImplementation(mockTaskInstance);
-  (MockTask as unknown as { create: Mock }).create = vi
-    .fn()
-    .mockImplementation(async (taskId: string, contextId: string) =>
-      mockTaskInstance(taskId, contextId),
-    );
-
-  return { Task: MockTask };
-});
-
-describe('CoderAgentExecutor', () => {
-  let executor: CoderAgentExecutor;
-  let mockTaskStore: TaskStore;
-  let mockEventBus: ExecutionEventBus;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockTaskStore = {
-      save: vi.fn().mockResolvedValue(undefined),
-      load: vi.fn().mockResolvedValue(undefined),
-      delete: vi.fn().mockResolvedValue(undefined),
-      list: vi.fn().mockResolvedValue([]),
-    } as unknown as TaskStore;
-
-    mockEventBus = new EventEmitter() as unknown as ExecutionEventBus;
-    mockEventBus.publish = vi.fn();
-    mockEventBus.finished = vi.fn();
-
-    executor = new CoderAgentExecutor(mockTaskStore);
-  });
-
-  it('should distinguish between primary and secondary execution', async () => {
-    const taskId = 'test-task';
-    const contextId = 'test-context';
-
-    const mockSocket = new EventEmitter();
-    const requestContext = {
-      userMessage: {
-        messageId: 'msg-1',
-        taskId,
-        contextId,
-        parts: [{ kind: 'text', text: 'hi' }],
-        metadata: {
-          coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
-        },
-      },
-    } as unknown as RequestContext;
-
-    // Mock requestStorage for primary
-    (requestStorage.getStore as Mock).mockReturnValue({
-      req: { socket: mockSocket },
-    });
-
-    // First execution (Primary)
-    const primaryPromise = executor.execute(requestContext, mockEventBus);
-
-    // Give it enough time to reach line 490 in executor.ts
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    expect(
-      (
-        executor as unknown as { executingTasks: Set<string> }
-      ).executingTasks.has(taskId),
-    ).toBe(true);
-    const wrapper = executor.getTask(taskId);
-    expect(wrapper).toBeDefined();
-
-    // Mock requestStorage for secondary
-    const secondarySocket = new EventEmitter();
-    (requestStorage.getStore as Mock).mockReturnValue({
-      req: { socket: secondarySocket },
-    });
-
-    const secondaryRequestContext = {
-      userMessage: {
-        messageId: 'msg-2',
-        taskId,
-        contextId,
-        parts: [{ kind: 'confirmation', callId: '1', outcome: 'proceed' }],
-        metadata: {
-          coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
-        },
-      },
-    } as unknown as RequestContext;
-
-    const secondaryPromise = executor.execute(
-      secondaryRequestContext,
-      mockEventBus,
-    );
-
-    // Secondary execution should NOT add to executingTasks (already there)
-    // and should return early after its loop
-    await secondaryPromise;
-
-    // Task should still be in executingTasks and NOT disposed
-    expect(
-      (
-        executor as unknown as { executingTasks: Set<string> }
-      ).executingTasks.has(taskId),
-    ).toBe(true);
-    expect(wrapper?.task.dispose).not.toHaveBeenCalled();
-
-    // Now simulate secondary socket closure - it should NOT affect primary
-    secondarySocket.emit('end');
-    expect(
-      (
-        executor as unknown as { executingTasks: Set<string> }
-      ).executingTasks.has(taskId),
-    ).toBe(true);
-    expect(wrapper?.task.dispose).not.toHaveBeenCalled();
-
-    // Set to terminal state to verify disposal on finish
-    wrapper!.task.taskState = 'completed';
-
-    // Now close primary socket
-    mockSocket.emit('end');
-
-    await primaryPromise;
-
-    expect(
-      (
-        executor as unknown as { executingTasks: Set<string> }
-      ).executingTasks.has(taskId),
-    ).toBe(false);
-    expect(wrapper?.task.dispose).toHaveBeenCalled();
-  });
-
-  it('should evict task from cache when it reaches terminal state', async () => {
-    const taskId = 'test-task-terminal';
-    const contextId = 'test-context';
-
-    const mockSocket = new EventEmitter();
-    (requestStorage.getStore as Mock).mockReturnValue({
-      req: { socket: mockSocket },
-    });
-
-    const requestContext = {
-      userMessage: {
-        messageId: 'msg-1',
-        taskId,
-        contextId,
-        parts: [{ kind: 'text', text: 'hi' }],
-        metadata: {
-          coderAgent: { kind: 'agent-settings', workspacePath: '/tmp' },
-        },
-      },
-    } as unknown as RequestContext;
-
-    const primaryPromise = executor.execute(requestContext, mockEventBus);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    const wrapper = executor.getTask(taskId)!;
-    expect(wrapper).toBeDefined();
-    // Simulate terminal state
-    wrapper.task.taskState = 'completed';
-
-    // Finish primary execution
-    mockSocket.emit('end');
-    await primaryPromise;
-
-    expect(executor.getTask(taskId)).toBeUndefined();
-    expect(wrapper.task.dispose).toHaveBeenCalled();
-  });
-});

packages/a2a-server/src/agent/executor.ts

@@ -252,10 +252,6 @@ export class CoderAgentExecutor implements AgentExecutor {
       );
       await this.taskStore?.save(wrapper.toSDKTask());
       logger.info(`[CoderAgentExecutor] Task ${taskId} state CANCELED saved.`);
-
-      // Cleanup listener subscriptions to avoid memory leaks.
-      wrapper.task.dispose();
-      this.tasks.delete(taskId);
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : 'Unknown error';
@@ -324,26 +320,23 @@ export class CoderAgentExecutor implements AgentExecutor {
     if (store) {
       // Grab the raw socket from the request object
       const socket = store.req.socket;
-      const onSocketEnd = () => {
+      const onClientEnd = () => {
         logger.info(
-          `[CoderAgentExecutor] Socket ended for message ${userMessage.messageId} (task ${taskId}). Aborting execution loop.`,
+          `[CoderAgentExecutor] Client socket closed for task ${taskId}. Cancelling execution.`,
         );
         if (!abortController.signal.aborted) {
           abortController.abort();
         }
         // Clean up the listener to prevent memory leaks
-        socket.removeListener('end', onSocketEnd);
+        socket.removeListener('close', onClientEnd);
       };
 
       // Listen on the socket's 'end' event (remote closed the connection)
-      socket.on('end', onSocketEnd);
-      socket.once('close', () => {
-        socket.removeListener('end', onSocketEnd);
-      });
+      socket.on('end', onClientEnd);
 
       // It's also good practice to remove the listener if the task completes successfully
       abortSignal.addEventListener('abort', () => {
-        socket.removeListener('end', onSocketEnd);
+        socket.removeListener('end', onClientEnd);
       });
       logger.info(
         `[CoderAgentExecutor] Socket close handler set up for task ${taskId}.`,
@@ -464,26 +457,6 @@ export class CoderAgentExecutor implements AgentExecutor {
       return;
     }
 
-    // Check if this is the primary/initial execution for this task
-    const isPrimaryExecution = !this.executingTasks.has(taskId);
-
-    if (!isPrimaryExecution) {
-      logger.info(
-        `[CoderAgentExecutor] Primary execution already active for task ${taskId}. Starting secondary loop for message ${userMessage.messageId}.`,
-      );
-      currentTask.eventBus = eventBus;
-      for await (const _ of currentTask.acceptUserMessage(
-        requestContext,
-        abortController.signal,
-      )) {
-        logger.info(
-          `[CoderAgentExecutor] Processing user message ${userMessage.messageId} in secondary execution loop for task ${taskId}.`,
-        );
-      }
-      // End this execution-- the original/source will be resumed.
-      return;
-    }
-
     logger.info(
       `[CoderAgentExecutor] Starting main execution for message ${userMessage.messageId} for task ${taskId}.`,
     );
@@ -625,30 +598,18 @@ export class CoderAgentExecutor implements AgentExecutor {
         }
       }
     } finally {
-      if (isPrimaryExecution) {
-        this.executingTasks.delete(taskId);
-        logger.info(
-          `[CoderAgentExecutor] Saving final state for task ${taskId}.`,
+      this.executingTasks.delete(taskId);
+      logger.info(
+        `[CoderAgentExecutor] Saving final state for task ${taskId}.`,
+      );
+      try {
+        await this.taskStore?.save(wrapper.toSDKTask());
+        logger.info(`[CoderAgentExecutor] Task ${taskId} state saved.`);
+      } catch (saveError) {
+        logger.error(
+          `[CoderAgentExecutor] Failed to save task ${taskId} state in finally block:`,
+          saveError,
         );
-        try {
-          await this.taskStore?.save(wrapper.toSDKTask());
-          logger.info(`[CoderAgentExecutor] Task ${taskId} state saved.`);
-        } catch (saveError) {
-          logger.error(
-            `[CoderAgentExecutor] Failed to save task ${taskId} state in finally block:`,
-            saveError,
-          );
-        }
-
-        if (
-          ['canceled', 'failed', 'completed'].includes(currentTask.taskState)
-        ) {
-          logger.info(
-            `[CoderAgentExecutor] Task ${taskId} reached terminal state ${currentTask.taskState}. Evicting and disposing.`,
-          );
-          wrapper.task.dispose();
-          this.tasks.delete(taskId);
-        }
       }
     }
   }

packages/a2a-server/src/agent/task-event-driven.test.ts

@@ -1,655 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
-import { Task } from './task.js';
-import {
-  type Config,
-  MessageBusType,
-  ToolConfirmationOutcome,
-  ApprovalMode,
-  Scheduler,
-  type MessageBus,
-} from '@google/gemini-cli-core';
-import { createMockConfig } from '../utils/testing_utils.js';
-import type { ExecutionEventBus } from '@a2a-js/sdk/server';
-
-describe('Task Event-Driven Scheduler', () => {
-  let mockConfig: Config;
-  let mockEventBus: ExecutionEventBus;
-  let messageBus: MessageBus;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockConfig = createMockConfig({
-      isEventDrivenSchedulerEnabled: () => true,
-    }) as Config;
-    messageBus = mockConfig.getMessageBus();
-    mockEventBus = {
-      publish: vi.fn(),
-      on: vi.fn(),
-      off: vi.fn(),
-      once: vi.fn(),
-      removeAllListeners: vi.fn(),
-      finished: vi.fn(),
-    };
-  });
-
-  it('should instantiate Scheduler when enabled', () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-    expect(task.scheduler).toBeInstanceOf(Scheduler);
-  });
-
-  it('should subscribe to TOOL_CALLS_UPDATE and map status changes', async () => {
-    // @ts-expect-error - Calling private constructor
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'executing',
-    };
-
-    // Simulate MessageBus event
-    // Simulate MessageBus event
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-
-    if (!handler) {
-      throw new Error('TOOL_CALLS_UPDATE handler not found');
-    }
-
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall],
-    });
-
-    expect(mockEventBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        status: expect.objectContaining({
-          state: 'submitted', // initial task state
-        }),
-        metadata: expect.objectContaining({
-          coderAgent: expect.objectContaining({
-            kind: 'tool-call-update',
-          }),
-        }),
-      }),
-    );
-  });
-
-  it('should handle tool confirmations by publishing to MessageBus', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-1',
-      confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
-    };
-
-    // Simulate MessageBus event to stash the correlationId
-    // Simulate MessageBus event
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-
-    if (!handler) {
-      throw new Error('TOOL_CALLS_UPDATE handler not found');
-    }
-
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall],
-    });
-
-    // Simulate A2A client confirmation
-    const part = {
-      kind: 'data',
-      data: {
-        callId: '1',
-        outcome: 'proceed_once',
-      },
-    };
-
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart(part);
-    expect(handled).toBe(true);
-
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-1',
-        confirmed: true,
-        outcome: ToolConfirmationOutcome.ProceedOnce,
-      }),
-    );
-  });
-
-  it('should handle Rejection (Cancel) and Modification (ModifyWithEditor)', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-1',
-      confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    // Simulate Rejection (Cancel)
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'cancel' },
-    });
-    expect(handled).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-1',
-        confirmed: false,
-      }),
-    );
-
-    const toolCall2 = {
-      request: { callId: '2', name: 'ls', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-2',
-      confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
-    };
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall2] });
-
-    // Simulate ModifyWithEditor
-    const handled2 = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '2', outcome: 'modify_with_editor' },
-    });
-    expect(handled2).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-2',
-        confirmed: false,
-        outcome: ToolConfirmationOutcome.ModifyWithEditor,
-        payload: undefined,
-      }),
-    );
-  });
-
-  it('should handle MCP Server tool operations correctly', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'call_mcp_tool', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-mcp-1',
-      confirmationDetails: {
-        type: 'mcp',
-        title: 'MCP Server Operation',
-        prompt: 'test_mcp',
-      },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    // Simulate ProceedOnce for MCP
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'proceed_once' },
-    });
-    expect(handled).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-mcp-1',
-        confirmed: true,
-        outcome: ToolConfirmationOutcome.ProceedOnce,
-      }),
-    );
-  });
-
-  it('should handle MCP Server tool ProceedAlwaysServer outcome', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'call_mcp_tool', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-mcp-2',
-      confirmationDetails: {
-        type: 'mcp',
-        title: 'MCP Server Operation',
-        prompt: 'test_mcp',
-      },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'proceed_always_server' },
-    });
-    expect(handled).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-mcp-2',
-        confirmed: true,
-        outcome: ToolConfirmationOutcome.ProceedAlwaysServer,
-      }),
-    );
-  });
-
-  it('should handle MCP Server tool ProceedAlwaysTool outcome', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'call_mcp_tool', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-mcp-3',
-      confirmationDetails: {
-        type: 'mcp',
-        title: 'MCP Server Operation',
-        prompt: 'test_mcp',
-      },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'proceed_always_tool' },
-    });
-    expect(handled).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-mcp-3',
-        confirmed: true,
-        outcome: ToolConfirmationOutcome.ProceedAlwaysTool,
-      }),
-    );
-  });
-
-  it('should handle MCP Server tool ProceedAlwaysAndSave outcome', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'call_mcp_tool', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-mcp-4',
-      confirmationDetails: {
-        type: 'mcp',
-        title: 'MCP Server Operation',
-        prompt: 'test_mcp',
-      },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'proceed_always_and_save' },
-    });
-    expect(handled).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-mcp-4',
-        confirmed: true,
-        outcome: ToolConfirmationOutcome.ProceedAlwaysAndSave,
-      }),
-    );
-  });
-
-  it('should execute without confirmation in YOLO mode and not transition to input-required', async () => {
-    // Enable YOLO mode
-    const yoloConfig = createMockConfig({
-      isEventDrivenSchedulerEnabled: () => true,
-      getApprovalMode: () => ApprovalMode.YOLO,
-    }) as Config;
-    const yoloMessageBus = yoloConfig.getMessageBus();
-
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', yoloConfig, mockEventBus);
-    task.setTaskStateAndPublishUpdate = vi.fn();
-
-    const toolCall = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-1',
-      confirmationDetails: { type: 'info', title: 'test', prompt: 'test' },
-    };
-
-    const handler = (yoloMessageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    // Should NOT auto-publish ProceedOnce anymore, because PolicyEngine handles it directly
-    expect(yoloMessageBus.publish).not.toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-      }),
-    );
-
-    // Should NOT transition to input-required since it was auto-approved
-    expect(task.setTaskStateAndPublishUpdate).not.toHaveBeenCalledWith(
-      'input-required',
-      expect.anything(),
-      undefined,
-      undefined,
-      true,
-    );
-  });
-
-  it('should handle output updates via the message bus', async () => {
-    // @ts-expect-error - Calling private constructor
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'executing',
-      liveOutput: 'chunk1',
-    };
-
-    // Simulate MessageBus event
-    // Simulate MessageBus event
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-
-    if (!handler) {
-      throw new Error('TOOL_CALLS_UPDATE handler not found');
-    }
-
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall],
-    });
-
-    // Should publish artifact update for output
-    expect(mockEventBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        kind: 'artifact-update',
-        artifact: expect.objectContaining({
-          artifactId: 'tool-1-output',
-          parts: [{ kind: 'text', text: 'chunk1' }],
-        }),
-      }),
-    );
-  });
-
-  it('should complete artifact creation without hanging', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCallId = 'create-file-123';
-    task['_registerToolCall'](toolCallId, 'executing');
-
-    const toolCall = {
-      request: {
-        callId: toolCallId,
-        name: 'writeFile',
-        args: { path: 'test.sh' },
-      },
-      status: 'success',
-      result: { ok: true },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-    handler({ type: MessageBusType.TOOL_CALLS_UPDATE, toolCalls: [toolCall] });
-
-    // The tool should be complete and registered appropriately, eventually
-    // triggering the toolCompletionPromise resolution when all clear.
-    const internalTask = task as unknown as {
-      completedToolCalls: unknown[];
-      pendingToolCalls: Map<string, string>;
-    };
-    expect(internalTask.completedToolCalls.length).toBe(1);
-    expect(internalTask.pendingToolCalls.size).toBe(0);
-  });
-
-  it('should preserve messageId across multiple text chunks to prevent UI duplication', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    // Initialize the ID for the first turn (happens internally upon LLM stream)
-    task.currentAgentMessageId = 'test-id-123';
-
-    // Simulate sending multiple text chunks
-    task._sendTextContent('chunk 1');
-    task._sendTextContent('chunk 2');
-
-    // Both text contents should have been published with the same messageId
-    const textCalls = (mockEventBus.publish as Mock).mock.calls.filter(
-      (call) => call[0].status?.message?.kind === 'message',
-    );
-    expect(textCalls.length).toBe(2);
-    expect(textCalls[0][0].status.message.messageId).toBe('test-id-123');
-    expect(textCalls[1][0].status.message.messageId).toBe('test-id-123');
-
-    // Simulate starting a new turn by calling getAndClearCompletedTools
-    // (which precedes sendCompletedToolsToLlm where a new ID is minted)
-    task.getAndClearCompletedTools();
-
-    // sendCompletedToolsToLlm internally rolls the ID forward.
-    // Simulate what sendCompletedToolsToLlm does:
-    const internalTask = task as unknown as {
-      setTaskStateAndPublishUpdate: (state: string, change: unknown) => void;
-    };
-    internalTask.setTaskStateAndPublishUpdate('working', {});
-
-    // Simulate what sendCompletedToolsToLlm does: generate a new UUID for the next turn
-    task.currentAgentMessageId = 'test-id-456';
-
-    task._sendTextContent('chunk 3');
-
-    const secondTurnCalls = (mockEventBus.publish as Mock).mock.calls.filter(
-      (call) => call[0].status?.message?.messageId === 'test-id-456',
-    );
-    expect(secondTurnCalls.length).toBe(1);
-    expect(secondTurnCalls[0][0].status.message.parts[0].text).toBe('chunk 3');
-  });
-
-  it('should handle parallel tool calls correctly', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const toolCall1 = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-1',
-      confirmationDetails: { type: 'info', title: 'test 1', prompt: 'test 1' },
-    };
-
-    const toolCall2 = {
-      request: { callId: '2', name: 'pwd', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-2',
-      confirmationDetails: { type: 'info', title: 'test 2', prompt: 'test 2' },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-
-    // Publish update for both tool calls simultaneously
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall1, toolCall2],
-    });
-
-    // Confirm first tool call
-    const handled1 = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '1', outcome: 'proceed_once' },
-    });
-    expect(handled1).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-1',
-        confirmed: true,
-      }),
-    );
-
-    // Confirm second tool call
-    const handled2 = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: '2', outcome: 'cancel' },
-    });
-    expect(handled2).toBe(true);
-    expect(messageBus.publish).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-        correlationId: 'corr-2',
-        confirmed: false,
-      }),
-    );
-  });
-
-  it('should wait for executing tools before transitioning to input-required state', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    task.setTaskStateAndPublishUpdate = vi.fn();
-
-    // Register tool 1 as executing
-    task['_registerToolCall']('1', 'executing');
-
-    const toolCall1 = {
-      request: { callId: '1', name: 'ls', args: {} },
-      status: 'executing',
-    };
-
-    const toolCall2 = {
-      request: { callId: '2', name: 'pwd', args: {} },
-      status: 'awaiting_approval',
-      correlationId: 'corr-2',
-      confirmationDetails: { type: 'info', title: 'test 2', prompt: 'test 2' },
-    };
-
-    const handler = (messageBus.subscribe as Mock).mock.calls.find(
-      (call: unknown[]) => call[0] === MessageBusType.TOOL_CALLS_UPDATE,
-    )?.[1];
-
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall1, toolCall2],
-    });
-
-    // Should NOT transition to input-required yet
-    expect(task.setTaskStateAndPublishUpdate).not.toHaveBeenCalledWith(
-      'input-required',
-      expect.anything(),
-      undefined,
-      undefined,
-      true,
-    );
-
-    // Complete tool 1
-    const toolCall1Complete = {
-      ...toolCall1,
-      status: 'success',
-      result: { ok: true },
-    };
-
-    handler({
-      type: MessageBusType.TOOL_CALLS_UPDATE,
-      toolCalls: [toolCall1Complete, toolCall2],
-    });
-
-    // Now it should transition
-    expect(task.setTaskStateAndPublishUpdate).toHaveBeenCalledWith(
-      'input-required',
-      expect.anything(),
-      undefined,
-      undefined,
-      true,
-    );
-  });
-
-  it('should ignore confirmations for unknown tool calls', async () => {
-    // @ts-expect-error - Calling private constructor
-    const task = new Task('task-id', 'context-id', mockConfig, mockEventBus);
-
-    const handled = await (
-      task as unknown as {
-        _handleToolConfirmationPart: (part: unknown) => Promise<boolean>;
-      }
-    )._handleToolConfirmationPart({
-      kind: 'data',
-      data: { callId: 'unknown-id', outcome: 'proceed_once' },
-    });
-
-    // Should return false for unhandled tool call
-    expect(handled).toBe(false);
-
-    // Should not publish anything to the message bus
-    expect(messageBus.publish).not.toHaveBeenCalled();
-  });
-});

packages/a2a-server/src/agent/task.test.ts

@@ -504,14 +504,13 @@ describe('Task', () => {
     });
 
     describe('auto-approval', () => {
-      it('should NOT publish ToolCallConfirmationEvent when autoExecute is true', () => {
+      it('should auto-approve tool calls when autoExecute is true', () => {
         task.autoExecute = true;
         const onConfirmSpy = vi.fn();
         const toolCalls = [
           {
             request: { callId: '1' },
             status: 'awaiting_approval',
-            correlationId: 'test-corr-id',
             confirmationDetails: {
               type: 'edit',
               onConfirm: onConfirmSpy,
@@ -525,17 +524,9 @@ describe('Task', () => {
         expect(onConfirmSpy).toHaveBeenCalledWith(
           ToolConfirmationOutcome.ProceedOnce,
         );
-        const calls = (mockEventBus.publish as Mock).mock.calls;
-        // Search if ToolCallConfirmationEvent was published
-        const confEvent = calls.find(
-          (call) =>
-            call[0].metadata?.coderAgent?.kind ===
-            CoderAgentEvent.ToolCallConfirmationEvent,
-        );
-        expect(confEvent).toBeUndefined();
       });
 
-      it('should NOT publish ToolCallConfirmationEvent when approval mode is YOLO', () => {
+      it('should auto-approve tool calls when approval mode is YOLO', () => {
         (mockConfig.getApprovalMode as Mock).mockReturnValue(ApprovalMode.YOLO);
         task.autoExecute = false;
         const onConfirmSpy = vi.fn();
@@ -543,7 +534,6 @@ describe('Task', () => {
           {
             request: { callId: '1' },
             status: 'awaiting_approval',
-            correlationId: 'test-corr-id',
             confirmationDetails: {
               type: 'edit',
               onConfirm: onConfirmSpy,
@@ -557,14 +547,6 @@ describe('Task', () => {
         expect(onConfirmSpy).toHaveBeenCalledWith(
           ToolConfirmationOutcome.ProceedOnce,
         );
-        const calls = (mockEventBus.publish as Mock).mock.calls;
-        // Search if ToolCallConfirmationEvent was published
-        const confEvent = calls.find(
-          (call) =>
-            call[0].metadata?.coderAgent?.kind ===
-            CoderAgentEvent.ToolCallConfirmationEvent,
-        );
-        expect(confEvent).toBeUndefined();
       });
 
       it('should NOT auto-approve when autoExecute is false and mode is not YOLO', () => {
@@ -585,14 +567,6 @@ describe('Task', () => {
         task._schedulerToolCallsUpdate(toolCalls);
 
         expect(onConfirmSpy).not.toHaveBeenCalled();
-        const calls = (mockEventBus.publish as Mock).mock.calls;
-        // Search if ToolCallConfirmationEvent was published
-        const confEvent = calls.find(
-          (call) =>
-            call[0].metadata?.coderAgent?.kind ===
-            CoderAgentEvent.ToolCallConfirmationEvent,
-        );
-        expect(confEvent).toBeDefined();
       });
     });
   });

packages/a2a-server/src/agent/task.ts

@@ -5,7 +5,6 @@
  */
 
 import {
-  Scheduler,
   CoreToolScheduler,
   type GeminiClient,
   GeminiEventType,
@@ -32,8 +31,6 @@ import {
   isSubagentProgress,
   EDIT_TOOL_NAMES,
   processRestorableToolCalls,
-  MessageBusType,
-  type ToolCallsUpdateMessage,
 } from '@google/gemini-cli-core';
 import {
   type ExecutionEventBus,
@@ -96,30 +93,21 @@ function isToolCallConfirmationDetails(
 export class Task {
   id: string;
   contextId: string;
-  scheduler: Scheduler | CoreToolScheduler;
+  scheduler: CoreToolScheduler;
   config: Config;
   geminiClient: GeminiClient;
   pendingToolConfirmationDetails: Map<string, ToolCallConfirmationDetails>;
-  pendingCorrelationIds: Map<string, string> = new Map();
   taskState: TaskState;
   eventBus?: ExecutionEventBus;
   completedToolCalls: CompletedToolCall[];
-  processedToolCallIds: Set<string> = new Set();
   skipFinalTrueAfterInlineEdit = false;
   modelInfo?: string;
   currentPromptId: string | undefined;
-  currentAgentMessageId = uuidv4();
   promptCount = 0;
   autoExecute: boolean;
-  private get isYoloMatch(): boolean {
-    return (
-      this.autoExecute || this.config.getApprovalMode() === ApprovalMode.YOLO
-    );
-  }
 
   // For tool waiting logic
   private pendingToolCalls: Map<string, string> = new Map(); //toolCallId --> status
-  private toolsAlreadyConfirmed: Set<string> = new Set();
   private toolCompletionPromise?: Promise<void>;
   private toolCompletionNotifier?: {
     resolve: () => void;
@@ -136,13 +124,7 @@ export class Task {
     this.id = id;
     this.contextId = contextId;
     this.config = config;
-
-    if (this.config.isEventDrivenSchedulerEnabled()) {
-      this.scheduler = this.setupEventDrivenScheduler();
-    } else {
-      this.scheduler = this.createLegacyScheduler();
-    }
-
+    this.scheduler = this.createScheduler();
     this.geminiClient = this.config.getGeminiClient();
     this.pendingToolConfirmationDetails = new Map();
     this.taskState = 'submitted';
@@ -242,7 +224,7 @@ export class Task {
     logger.info(
       `[Task] Waiting for ${this.pendingToolCalls.size} pending tool(s)...`,
     );
-    await this.toolCompletionPromise;
+    return this.toolCompletionPromise;
   }
 
   cancelPendingTools(reason: string): void {
@@ -255,13 +237,6 @@ export class Task {
       this.toolCompletionNotifier.reject(new Error(reason));
     }
     this.pendingToolCalls.clear();
-    this.pendingCorrelationIds.clear();
-
-    if (this.scheduler instanceof Scheduler) {
-      this.scheduler.cancelAll();
-    } else {
-      this.scheduler.cancelAll(new AbortController().signal);
-    }
     // Reset the promise for any future operations, ensuring it's in a clean state.
     this._resetToolCompletionPromise();
   }
@@ -274,7 +249,7 @@ export class Task {
       kind: 'message',
       role,
       parts: [{ kind: 'text', text }],
-      messageId: role === 'agent' ? this.currentAgentMessageId : uuidv4(),
+      messageId: uuidv4(),
       taskId: this.id,
       contextId: this.contextId,
     };
@@ -442,34 +417,26 @@ export class Task {
 
       // Only send an update if the status has actually changed.
       if (hasChanged) {
-        // Skip sending confirmation event if we are going to auto-approve it anyway
-        if (
-          tc.status === 'awaiting_approval' &&
-          tc.confirmationDetails &&
-          this.isYoloMatch
-        ) {
-          logger.info(
-            `[Task] Skipping ToolCallConfirmationEvent for ${tc.request.callId} due to YOLO mode.`,
-          );
-        } else {
-          const coderAgentMessage: CoderAgentMessage =
-            tc.status === 'awaiting_approval'
-              ? { kind: CoderAgentEvent.ToolCallConfirmationEvent }
-              : { kind: CoderAgentEvent.ToolCallUpdateEvent };
-          const message = this.toolStatusMessage(tc, this.id, this.contextId);
+        const coderAgentMessage: CoderAgentMessage =
+          tc.status === 'awaiting_approval'
+            ? { kind: CoderAgentEvent.ToolCallConfirmationEvent }
+            : { kind: CoderAgentEvent.ToolCallUpdateEvent };
+        const message = this.toolStatusMessage(tc, this.id, this.contextId);
 
-          const event = this._createStatusUpdateEvent(
-            this.taskState,
-            coderAgentMessage,
-            message,
-            false, // Always false for these continuous updates
-          );
-          this.eventBus?.publish(event);
-        }
+        const event = this._createStatusUpdateEvent(
+          this.taskState,
+          coderAgentMessage,
+          message,
+          false, // Always false for these continuous updates
+        );
+        this.eventBus?.publish(event);
       }
     });
 
-    if (this.isYoloMatch) {
+    if (
+      this.autoExecute ||
+      this.config.getApprovalMode() === ApprovalMode.YOLO
+    ) {
       logger.info(
         '[Task] ' +
           (this.autoExecute ? '' : 'YOLO mode enabled. ') +
@@ -517,7 +484,7 @@ export class Task {
     }
   }
 
-  private createLegacyScheduler(): CoreToolScheduler {
+  private createScheduler(): CoreToolScheduler {
     const scheduler = new CoreToolScheduler({
       outputUpdateHandler: this._schedulerOutputUpdate.bind(this),
       onAllToolCallsComplete: this._schedulerAllToolCallsComplete.bind(this),
@@ -528,171 +495,6 @@ export class Task {
     return scheduler;
   }
 
-  private messageBusListener?: (message: ToolCallsUpdateMessage) => void;
-
-  private setupEventDrivenScheduler(): Scheduler {
-    const messageBus = this.config.getMessageBus();
-    const scheduler = new Scheduler({
-      schedulerId: this.id,
-      config: this.config,
-      messageBus,
-      getPreferredEditor: () => DEFAULT_GUI_EDITOR,
-    });
-
-    this.messageBusListener = this.handleEventDrivenToolCallsUpdate.bind(this);
-    messageBus.subscribe<ToolCallsUpdateMessage>(
-      MessageBusType.TOOL_CALLS_UPDATE,
-      this.messageBusListener,
-    );
-
-    return scheduler;
-  }
-
-  dispose(): void {
-    if (this.messageBusListener) {
-      this.config
-        .getMessageBus()
-        .unsubscribe(MessageBusType.TOOL_CALLS_UPDATE, this.messageBusListener);
-      this.messageBusListener = undefined;
-    }
-
-    if (this.scheduler instanceof Scheduler) {
-      this.scheduler.dispose();
-    }
-  }
-
-  private handleEventDrivenToolCallsUpdate(
-    event: ToolCallsUpdateMessage,
-  ): void {
-    if (event.type !== MessageBusType.TOOL_CALLS_UPDATE) {
-      return;
-    }
-
-    const toolCalls = event.toolCalls;
-
-    toolCalls.forEach((tc) => {
-      this.handleEventDrivenToolCall(tc);
-    });
-
-    this.checkInputRequiredState();
-  }
-
-  private handleEventDrivenToolCall(tc: ToolCall): void {
-    const callId = tc.request.callId;
-
-    // Do not process events for tools that have already been finalized.
-    // This prevents duplicate completions if the state manager emits a snapshot containing
-    // already resolved tools whose IDs were removed from pendingToolCalls.
-    if (
-      this.processedToolCallIds.has(callId) ||
-      this.completedToolCalls.some((c) => c.request.callId === callId)
-    ) {
-      return;
-    }
-
-    const previousStatus = this.pendingToolCalls.get(callId);
-    const hasChanged = previousStatus !== tc.status;
-
-    // 1. Handle Output
-    if (tc.status === 'executing' && tc.liveOutput) {
-      this._schedulerOutputUpdate(callId, tc.liveOutput);
-    }
-
-    // 2. Handle terminal states
-    if (
-      tc.status === 'success' ||
-      tc.status === 'error' ||
-      tc.status === 'cancelled'
-    ) {
-      this.toolsAlreadyConfirmed.delete(callId);
-      if (hasChanged) {
-        logger.info(
-          `[Task] Tool call ${callId} completed with status: ${tc.status}`,
-        );
-        this.completedToolCalls.push(tc);
-        this._resolveToolCall(callId);
-      }
-    } else {
-      // Keep track of pending tools
-      this._registerToolCall(callId, tc.status);
-    }
-
-    // 3. Handle Confirmation Stash
-    if (tc.status === 'awaiting_approval' && tc.confirmationDetails) {
-      const details = tc.confirmationDetails;
-
-      if (tc.correlationId) {
-        this.pendingCorrelationIds.set(callId, tc.correlationId);
-      }
-
-      this.pendingToolConfirmationDetails.set(callId, {
-        ...details,
-        onConfirm: async () => {},
-      } as ToolCallConfirmationDetails);
-    }
-
-    // 4. Publish Status Updates to A2A event bus
-    if (hasChanged) {
-      const coderAgentMessage: CoderAgentMessage =
-        tc.status === 'awaiting_approval'
-          ? { kind: CoderAgentEvent.ToolCallConfirmationEvent }
-          : { kind: CoderAgentEvent.ToolCallUpdateEvent };
-
-      const message = this.toolStatusMessage(tc, this.id, this.contextId);
-      const statusUpdate = this._createStatusUpdateEvent(
-        this.taskState,
-        coderAgentMessage,
-        message,
-        false,
-      );
-      this.eventBus?.publish(statusUpdate);
-    }
-  }
-
-  private checkInputRequiredState(): void {
-    if (this.isYoloMatch) {
-      return;
-    }
-
-    // 6. Handle Input Required State
-    let isAwaitingApproval = false;
-    let isExecuting = false;
-
-    for (const [callId, status] of this.pendingToolCalls.entries()) {
-      if (status === 'executing' || status === 'scheduled') {
-        isExecuting = true;
-      } else if (
-        status === 'awaiting_approval' &&
-        !this.toolsAlreadyConfirmed.has(callId)
-      ) {
-        isAwaitingApproval = true;
-      }
-    }
-
-    if (
-      isAwaitingApproval &&
-      !isExecuting &&
-      !this.skipFinalTrueAfterInlineEdit
-    ) {
-      this.skipFinalTrueAfterInlineEdit = false;
-      const wasAlreadyInputRequired = this.taskState === 'input-required';
-
-      this.setTaskStateAndPublishUpdate(
-        'input-required',
-        { kind: CoderAgentEvent.StateChangeEvent },
-        undefined,
-        undefined,
-        /*final*/ true,
-      );
-
-      // Unblock waitForPendingTools to correctly end the executor loop and release the HTTP response stream.
-      // The IDE client will open a new stream with the confirmation reply.
-      if (!wasAlreadyInputRequired && this.toolCompletionNotifier) {
-        this.toolCompletionNotifier.resolve();
-      }
-    }
-  }
-
   private _pickFields<
     T extends ToolCall | AnyDeclarativeTool,
     K extends UnionKeys<T>,
@@ -903,16 +705,7 @@ export class Task {
     };
     this.setTaskStateAndPublishUpdate('working', stateChange);
 
-    // Pre-register tools to ensure waitForPendingTools sees them as pending
-    // before the async scheduler enqueues them and fires the event bus update.
-    for (const req of updatedRequests) {
-      if (!this.pendingToolCalls.has(req.callId)) {
-        this._registerToolCall(req.callId, 'scheduled');
-      }
-    }
-
-    // Fire and forget so we don't block the executor loop before waitForPendingTools can be called
-    void this.scheduler.schedule(updatedRequests, abortSignal);
+    await this.scheduler.schedule(updatedRequests, abortSignal);
   }
 
   async acceptAgentMessage(event: ServerGeminiStreamEvent): Promise<void> {
@@ -1036,15 +829,9 @@ export class Task {
     ) {
       return false;
     }
-    if (!part.data['outcome']) {
-      return false;
-    }
 
     const callId = part.data['callId'];
     const outcomeString = part.data['outcome'];
-
-    this.toolsAlreadyConfirmed.add(callId);
-
     let confirmationOutcome: ToolConfirmationOutcome | undefined;
 
     if (outcomeString === 'proceed_once') {
@@ -1057,8 +844,6 @@ export class Task {
       confirmationOutcome = ToolConfirmationOutcome.ProceedAlwaysServer;
     } else if (outcomeString === 'proceed_always_tool') {
       confirmationOutcome = ToolConfirmationOutcome.ProceedAlwaysTool;
-    } else if (outcomeString === 'proceed_always_and_save') {
-      confirmationOutcome = ToolConfirmationOutcome.ProceedAlwaysAndSave;
     } else if (outcomeString === 'modify_with_editor') {
       confirmationOutcome = ToolConfirmationOutcome.ModifyWithEditor;
     } else {
@@ -1069,9 +854,8 @@ export class Task {
     }
 
     const confirmationDetails = this.pendingToolConfirmationDetails.get(callId);
-    const correlationId = this.pendingCorrelationIds.get(callId);
 
-    if (!confirmationDetails && !correlationId) {
+    if (!confirmationDetails) {
       logger.warn(
         `[Task] Received tool confirmation for unknown or already processed callId: ${callId}`,
       );
@@ -1093,35 +877,24 @@ export class Task {
         // This will trigger the scheduler to continue or cancel the specific tool.
         // The scheduler's onToolCallsUpdate will then reflect the new state (e.g., executing or cancelled).
 
-        // If `edit` tool call, pass updated payload if present
-        const newContent = part.data['newContent'];
-        const payload =
-          confirmationDetails?.type === 'edit' && typeof newContent === 'string'
-            ? ({ newContent } as ToolConfirmationPayload)
-            : undefined;
-        this.skipFinalTrueAfterInlineEdit = !!payload;
-
-        try {
-          if (correlationId) {
-            await this.config.getMessageBus().publish({
-              type: MessageBusType.TOOL_CONFIRMATION_RESPONSE,
-              correlationId,
-              confirmed:
-                confirmationOutcome !== ToolConfirmationOutcome.Cancel &&
-                confirmationOutcome !==
-                  ToolConfirmationOutcome.ModifyWithEditor,
-              outcome: confirmationOutcome,
-              payload,
-            });
-          } else if (confirmationDetails?.onConfirm) {
-            // Fallback for legacy callback-based confirmation
+        // If `edit` tool call, pass updated payload if presesent
+        if (confirmationDetails.type === 'edit') {
+          const newContent = part.data['newContent'];
+          const payload =
+            typeof newContent === 'string'
+              ? ({ newContent } as ToolConfirmationPayload)
+              : undefined;
+          this.skipFinalTrueAfterInlineEdit = !!payload;
+          try {
             await confirmationDetails.onConfirm(confirmationOutcome, payload);
+          } finally {
+            // Once confirmationDetails.onConfirm finishes (or fails) with a payload,
+            // reset skipFinalTrueAfterInlineEdit so that external callers receive
+            // their call has been completed.
+            this.skipFinalTrueAfterInlineEdit = false;
           }
-        } finally {
-          // Once confirmation payload is sent or callback finishes,
-          // reset skipFinalTrueAfterInlineEdit so that external callers receive
-          // their call has been completed.
-          this.skipFinalTrueAfterInlineEdit = false;
+        } else {
+          await confirmationDetails.onConfirm(confirmationOutcome);
         }
       } finally {
         if (gcpProject) {
@@ -1137,7 +910,6 @@ export class Task {
       // Note !== ToolConfirmationOutcome.ModifyWithEditor does not work!
       if (confirmationOutcome !== 'modify_with_editor') {
         this.pendingToolConfirmationDetails.delete(callId);
-        this.pendingCorrelationIds.delete(callId);
       }
 
       // If outcome is Cancel, scheduler should update status to 'cancelled', which then resolves the tool.
@@ -1171,9 +943,6 @@ export class Task {
 
   getAndClearCompletedTools(): CompletedToolCall[] {
     const tools = [...this.completedToolCalls];
-    for (const tool of tools) {
-      this.processedToolCallIds.add(tool.request.callId);
-    }
     this.completedToolCalls = [];
     return tools;
   }
@@ -1234,7 +1003,6 @@ export class Task {
     };
     // Set task state to working as we are about to call LLM
     this.setTaskStateAndPublishUpdate('working', stateChange);
-    this.currentAgentMessageId = uuidv4();
     yield* this.geminiClient.sendMessageStream(
       llmParts,
       aborted,
@@ -1256,10 +1024,6 @@ export class Task {
       if (confirmationHandled) {
         anyConfirmationHandled = true;
         // If a confirmation was handled, the scheduler will now run the tool (or cancel it).
-        // We resolve the toolCompletionPromise manually in checkInputRequiredState
-        // to break the original execution loop, so we must reset it here so the
-        // new loop correctly awaits the tool's final execution.
-        this._resetToolCompletionPromise();
         // We don't send anything to the LLM for this part.
         // The subsequent tool execution will eventually lead to resolveToolCall.
         continue;
@@ -1274,7 +1038,6 @@ export class Task {
     if (hasContentForLlm) {
       this.currentPromptId =
         this.config.getSessionId() + '########' + this.promptCount++;
-      this.currentAgentMessageId = uuidv4();
       logger.info('[Task] Sending new parts to LLM.');
       const stateChange: StateChange = {
         kind: CoderAgentEvent.StateChangeEvent,
@@ -1320,6 +1083,7 @@ export class Task {
     if (content === '') {
       return;
     }
+    logger.info('[Task] Sending text content to event bus.');
     const message = this._createTextMessage(content);
     const textContent: TextContent = {
       kind: CoderAgentEvent.TextContentEvent,
@@ -1351,7 +1115,7 @@ export class Task {
           data: content,
         } as Part,
       ],
-      messageId: this.currentAgentMessageId,
+      messageId: uuidv4(),
       taskId: this.id,
       contextId: this.contextId,
     };

packages/a2a-server/src/config/config.ts

@@ -105,8 +105,6 @@ export async function loadConfig(
     checkpointing,
     interactive: true,
     enableInteractiveShell: true,
-    enableEventDrivenScheduler:
-      settings.experimental?.enableEventDrivenScheduler ?? true,
     ptyInfo: 'auto',
   };
 

packages/a2a-server/src/config/settings.ts

@@ -37,12 +37,6 @@ export interface Settings {
   showMemoryUsage?: boolean;
   checkpointing?: CheckpointingSettings;
   folderTrust?: boolean;
-  general?: {
-    previewFeatures?: boolean;
-  };
-  experimental?: {
-    enableEventDrivenScheduler?: boolean;
-  };
 
   // Git-aware file filtering settings
   fileFiltering?: {

packages/a2a-server/src/utils/testing_utils.ts

@@ -64,7 +64,6 @@ export function createMockConfig(
     getEmbeddingModel: vi.fn().mockReturnValue('text-embedding-004'),
     getSessionId: vi.fn().mockReturnValue('test-session-id'),
     getUserTier: vi.fn(),
-    isEventDrivenSchedulerEnabled: vi.fn().mockReturnValue(false),
     getMessageBus: vi.fn(),
     getPolicyEngine: vi.fn(),
     getEnableExtensionReloading: vi.fn().mockReturnValue(false),

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.33.0",
+  "version": "0.33.0-nightly.20260228.1ca5c05d0",
   "description": "Gemini CLI",
   "license": "Apache-2.0",
   "repository": {
@@ -26,19 +26,19 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.33.0"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.33.0-nightly.20260228.1ca5c05d0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.12.0",
     "@google/gemini-cli-core": "file:../core",
-    "@google/genai": "1.30.0",
+    "@google/genai": "1.41.0",
     "@iarna/toml": "^2.2.5",
     "@modelcontextprotocol/sdk": "^1.23.0",
     "ansi-escapes": "^7.3.0",
     "ansi-regex": "^6.2.2",
     "chalk": "^4.1.2",
     "cli-spinners": "^2.9.2",
-    "clipboardy": "~5.2.0",
+    "clipboardy": "^5.0.0",
     "color-convert": "^2.0.1",
     "command-exists": "^1.2.9",
     "comment-json": "^4.2.5",

packages/cli/src/acp/acpClient.test.ts

@@ -15,7 +15,6 @@ import {
   type Mocked,
 } from 'vitest';
 import { GeminiAgent, Session } from './acpClient.js';
-import type { CommandHandler } from './commandHandler.js';
 import * as acp from '@agentclientprotocol/sdk';
 import {
   AuthType,
@@ -27,7 +26,6 @@ import {
   type Config,
   type MessageBus,
   LlmRole,
-  type GitService,
 } from '@google/gemini-cli-core';
 import {
   SettingScope,
@@ -64,33 +62,7 @@ vi.mock('node:path', async (importOriginal) => {
   };
 });
 
-vi.mock('../ui/commands/memoryCommand.js', () => ({
-  memoryCommand: {
-    name: 'memory',
-    action: vi.fn(),
-  },
-}));
-
-vi.mock('../ui/commands/extensionsCommand.js', () => ({
-  extensionsCommand: vi.fn().mockReturnValue({
-    name: 'extensions',
-    action: vi.fn(),
-  }),
-}));
-
-vi.mock('../ui/commands/restoreCommand.js', () => ({
-  restoreCommand: vi.fn().mockReturnValue({
-    name: 'restore',
-    action: vi.fn(),
-  }),
-}));
-
-vi.mock('../ui/commands/initCommand.js', () => ({
-  initCommand: {
-    name: 'init',
-    action: vi.fn(),
-  },
-}));
+// Mock ReadManyFilesTool
 vi.mock(
   '@google/gemini-cli-core',
   async (
@@ -172,10 +144,7 @@ describe('GeminiAgent', () => {
         unsubscribe: vi.fn(),
       }),
       getApprovalMode: vi.fn().mockReturnValue('default'),
-      isPlanEnabled: vi.fn().mockReturnValue(true),
-      getGemini31LaunchedSync: vi.fn().mockReturnValue(false),
-      getHasAccessToPreviewModel: vi.fn().mockReturnValue(false),
-      getCheckpointingEnabled: vi.fn().mockReturnValue(false),
+      isPlanEnabled: vi.fn().mockReturnValue(false),
     } as unknown as Mocked<Awaited<ReturnType<typeof loadCliConfig>>>;
     mockSettings = {
       merged: {
@@ -208,16 +177,7 @@ describe('GeminiAgent', () => {
     });
 
     expect(response.protocolVersion).toBe(acp.PROTOCOL_VERSION);
-    expect(response.authMethods).toHaveLength(4);
-    const gatewayAuth = response.authMethods?.find(
-      (m) => m.id === AuthType.GATEWAY,
-    );
-    expect(gatewayAuth?._meta).toEqual({
-      gateway: {
-        protocol: 'google',
-        restartRequired: 'false',
-      },
-    });
+    expect(response.authMethods).toHaveLength(3);
     const geminiAuth = response.authMethods?.find(
       (m) => m.id === AuthType.USE_GEMINI,
     );
@@ -237,8 +197,6 @@ describe('GeminiAgent', () => {
     expect(mockConfig.refreshAuth).toHaveBeenCalledWith(
       AuthType.LOGIN_WITH_GOOGLE,
       undefined,
-      undefined,
-      undefined,
     );
     expect(mockSettings.setValue).toHaveBeenCalledWith(
       SettingScope.User,
@@ -258,8 +216,6 @@ describe('GeminiAgent', () => {
     expect(mockConfig.refreshAuth).toHaveBeenCalledWith(
       AuthType.USE_GEMINI,
       'test-api-key',
-      undefined,
-      undefined,
     );
     expect(mockSettings.setValue).toHaveBeenCalledWith(
       SettingScope.User,
@@ -268,47 +224,7 @@ describe('GeminiAgent', () => {
     );
   });
 
-  it('should authenticate correctly with gateway method', async () => {
-    await agent.authenticate({
-      methodId: AuthType.GATEWAY,
-      _meta: {
-        gateway: {
-          baseUrl: 'https://example.com',
-          headers: { Authorization: 'Bearer token' },
-        },
-      },
-    } as unknown as acp.AuthenticateRequest);
-
-    expect(mockConfig.refreshAuth).toHaveBeenCalledWith(
-      AuthType.GATEWAY,
-      undefined,
-      'https://example.com',
-      { Authorization: 'Bearer token' },
-    );
-    expect(mockSettings.setValue).toHaveBeenCalledWith(
-      SettingScope.User,
-      'security.auth.selectedType',
-      AuthType.GATEWAY,
-    );
-  });
-
-  it('should throw acp.RequestError when gateway payload is malformed', async () => {
-    await expect(
-      agent.authenticate({
-        methodId: AuthType.GATEWAY,
-        _meta: {
-          gateway: {
-            // Invalid baseUrl
-            baseUrl: 123,
-            headers: { Authorization: 'Bearer token' },
-          },
-        },
-      } as unknown as acp.AuthenticateRequest),
-    ).rejects.toThrow(/Malformed gateway payload/);
-  });
-
   it('should create a new session', async () => {
-    vi.useFakeTimers();
     mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
       apiKey: 'test-key',
     });
@@ -321,17 +237,6 @@ describe('GeminiAgent', () => {
     expect(loadCliConfig).toHaveBeenCalled();
     expect(mockConfig.initialize).toHaveBeenCalled();
     expect(mockConfig.getGeminiClient).toHaveBeenCalled();
-
-    // Verify deferred call
-    await vi.runAllTimersAsync();
-    expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(
-      expect.objectContaining({
-        update: expect.objectContaining({
-          sessionUpdate: 'available_commands_update',
-        }),
-      }),
-    );
-    vi.useRealTimers();
   });
 
   it('should return modes without plan mode when plan is disabled', async () => {
@@ -358,38 +263,6 @@ describe('GeminiAgent', () => {
       ],
       currentModeId: 'default',
     });
-    expect(response.models).toEqual({
-      availableModels: expect.arrayContaining([
-        expect.objectContaining({
-          modelId: 'auto-gemini-2.5',
-          name: 'Auto (Gemini 2.5)',
-        }),
-      ]),
-      currentModelId: 'gemini-pro',
-    });
-  });
-
-  it('should include preview models when user has access', async () => {
-    mockConfig.getHasAccessToPreviewModel = vi.fn().mockReturnValue(true);
-    mockConfig.getGemini31LaunchedSync = vi.fn().mockReturnValue(true);
-
-    const response = await agent.newSession({
-      cwd: '/tmp',
-      mcpServers: [],
-    });
-
-    expect(response.models?.availableModels).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          modelId: 'auto-gemini-3',
-          name: expect.stringContaining('Auto'),
-        }),
-        expect.objectContaining({
-          modelId: 'gemini-3.1-pro-preview',
-          name: 'gemini-3.1-pro-preview',
-        }),
-      ]),
-    );
   });
 
   it('should return modes with plan mode when plan is enabled', async () => {
@@ -417,15 +290,6 @@ describe('GeminiAgent', () => {
       ],
       currentModeId: 'plan',
     });
-    expect(response.models).toEqual({
-      availableModels: expect.arrayContaining([
-        expect.objectContaining({
-          modelId: 'auto-gemini-2.5',
-          name: 'Auto (Gemini 2.5)',
-        }),
-      ]),
-      currentModelId: 'gemini-pro',
-    });
   });
 
   it('should fail session creation if Gemini API key is missing', async () => {
@@ -575,32 +439,6 @@ describe('GeminiAgent', () => {
       }),
     ).rejects.toThrow('Session not found: unknown');
   });
-
-  it('should delegate setModel to session (unstable)', async () => {
-    await agent.newSession({ cwd: '/tmp', mcpServers: [] });
-    const session = (
-      agent as unknown as { sessions: Map<string, Session> }
-    ).sessions.get('test-session-id');
-    if (!session) throw new Error('Session not found');
-    session.setModel = vi.fn().mockReturnValue({});
-
-    const result = await agent.unstable_setSessionModel({
-      sessionId: 'test-session-id',
-      modelId: 'gemini-2.0-pro-exp',
-    });
-
-    expect(session.setModel).toHaveBeenCalledWith('gemini-2.0-pro-exp');
-    expect(result).toEqual({});
-  });
-
-  it('should throw error when setting model on non-existent session (unstable)', async () => {
-    await expect(
-      agent.unstable_setSessionModel({
-        sessionId: 'unknown',
-        modelId: 'gemini-2.0-pro-exp',
-      }),
-    ).rejects.toThrow('Session not found: unknown');
-  });
 });
 
 describe('Session', () => {
@@ -639,7 +477,6 @@ describe('Session', () => {
       getModel: vi.fn().mockReturnValue('gemini-pro'),
       getActiveModel: vi.fn().mockReturnValue('gemini-pro'),
       getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
-      getMcpServers: vi.fn(),
       getFileService: vi.fn().mockReturnValue({
         shouldIgnoreFile: vi.fn().mockReturnValue(false),
       }),
@@ -649,10 +486,7 @@ describe('Session', () => {
       getDebugMode: vi.fn().mockReturnValue(false),
       getMessageBus: vi.fn().mockReturnValue(mockMessageBus),
       setApprovalMode: vi.fn(),
-      setModel: vi.fn(),
-      isPlanEnabled: vi.fn().mockReturnValue(true),
-      getCheckpointingEnabled: vi.fn().mockReturnValue(false),
-      getGitService: vi.fn().mockResolvedValue({} as GitService),
+      isPlanEnabled: vi.fn().mockReturnValue(false),
       waitForMcpInit: vi.fn(),
     } as unknown as Mocked<Config>;
     mockConnection = {
@@ -661,38 +495,13 @@ describe('Session', () => {
       sendNotification: vi.fn(),
     } as unknown as Mocked<acp.AgentSideConnection>;
 
-    session = new Session('session-1', mockChat, mockConfig, mockConnection, {
-      system: { settings: {} },
-      systemDefaults: { settings: {} },
-      user: { settings: {} },
-      workspace: { settings: {} },
-      merged: { settings: {} },
-      errors: [],
-    } as unknown as LoadedSettings);
+    session = new Session('session-1', mockChat, mockConfig, mockConnection);
   });
 
   afterEach(() => {
     vi.clearAllMocks();
   });
 
-  it('should send available commands', async () => {
-    await session.sendAvailableCommands();
-
-    expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(
-      expect.objectContaining({
-        update: expect.objectContaining({
-          sessionUpdate: 'available_commands_update',
-          availableCommands: expect.arrayContaining([
-            expect.objectContaining({ name: 'memory' }),
-            expect.objectContaining({ name: 'extensions' }),
-            expect.objectContaining({ name: 'restore' }),
-            expect.objectContaining({ name: 'init' }),
-          ]),
-        }),
-      }),
-    );
-  });
-
   it('should await MCP initialization before processing a prompt', async () => {
     const stream = createMockStream([
       {
@@ -742,113 +551,6 @@ describe('Session', () => {
     expect(result).toEqual({ stopReason: 'end_turn' });
   });
 
-  it('should handle /memory command', async () => {
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    const result = await session.prompt({
-      sessionId: 'session-1',
-      prompt: [{ type: 'text', text: '/memory view' }],
-    });
-
-    expect(result).toEqual({ stopReason: 'end_turn' });
-    expect(handleCommandSpy).toHaveBeenCalledWith(
-      '/memory view',
-      expect.any(Object),
-    );
-    expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-  });
-
-  it('should handle /extensions command', async () => {
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    const result = await session.prompt({
-      sessionId: 'session-1',
-      prompt: [{ type: 'text', text: '/extensions list' }],
-    });
-
-    expect(result).toEqual({ stopReason: 'end_turn' });
-    expect(handleCommandSpy).toHaveBeenCalledWith(
-      '/extensions list',
-      expect.any(Object),
-    );
-    expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-  });
-
-  it('should handle /extensions explore command', async () => {
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    const result = await session.prompt({
-      sessionId: 'session-1',
-      prompt: [{ type: 'text', text: '/extensions explore' }],
-    });
-
-    expect(result).toEqual({ stopReason: 'end_turn' });
-    expect(handleCommandSpy).toHaveBeenCalledWith(
-      '/extensions explore',
-      expect.any(Object),
-    );
-    expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-  });
-
-  it('should handle /restore command', async () => {
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    const result = await session.prompt({
-      sessionId: 'session-1',
-      prompt: [{ type: 'text', text: '/restore' }],
-    });
-
-    expect(result).toEqual({ stopReason: 'end_turn' });
-    expect(handleCommandSpy).toHaveBeenCalledWith(
-      '/restore',
-      expect.any(Object),
-    );
-    expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-  });
-
-  it('should handle /init command', async () => {
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    const result = await session.prompt({
-      sessionId: 'session-1',
-      prompt: [{ type: 'text', text: '/init' }],
-    });
-
-    expect(result).toEqual({ stopReason: 'end_turn' });
-    expect(handleCommandSpy).toHaveBeenCalledWith('/init', expect.any(Object));
-    expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-  });
-
   it('should handle tool calls', async () => {
     const stream1 = createMockStream([
       {
@@ -1505,30 +1207,4 @@ describe('Session', () => {
       'Invalid or unavailable mode: invalid-mode',
     );
   });
-
-  it('should set model on config', () => {
-    session.setModel('gemini-2.0-flash-exp');
-    expect(mockConfig.setModel).toHaveBeenCalledWith('gemini-2.0-flash-exp');
-  });
-
-  it('should handle unquoted commands from autocomplete (with empty leading parts)', async () => {
-    // Mock handleCommand to verify it gets called
-    const handleCommandSpy = vi
-      .spyOn(
-        (session as unknown as { commandHandler: CommandHandler })
-          .commandHandler,
-        'handleCommand',
-      )
-      .mockResolvedValue(true);
-
-    await session.prompt({
-      sessionId: 'session-1',
-      prompt: [
-        { type: 'text', text: '' },
-        { type: 'text', text: '/memory' },
-      ],
-    });
-
-    expect(handleCommandSpy).toHaveBeenCalledWith('/memory', expect.anything());
-  });
 });

packages/cli/src/acp/acpClient.ts

@@ -4,13 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {
+  Config,
+  GeminiChat,
+  ToolResult,
+  ToolCallConfirmationDetails,
+  FilterFilesOptions,
+  ConversationRecord,
+} from '@google/gemini-cli-core';
 import {
-  type Config,
-  type GeminiChat,
-  type ToolResult,
-  type ToolCallConfirmationDetails,
-  type FilterFilesOptions,
-  type ConversationRecord,
   CoreToolCallStatus,
   AuthType,
   logToolCall,
@@ -37,16 +39,6 @@ import {
   ApprovalMode,
   getVersion,
   convertSessionToClientHistory,
-  DEFAULT_GEMINI_MODEL,
-  DEFAULT_GEMINI_FLASH_MODEL,
-  DEFAULT_GEMINI_FLASH_LITE_MODEL,
-  PREVIEW_GEMINI_MODEL,
-  PREVIEW_GEMINI_3_1_MODEL,
-  PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,
-  PREVIEW_GEMINI_FLASH_MODEL,
-  DEFAULT_GEMINI_MODEL_AUTO,
-  PREVIEW_GEMINI_MODEL_AUTO,
-  getDisplayString,
 } from '@google/gemini-cli-core';
 import * as acp from '@agentclientprotocol/sdk';
 import { AcpFileSystemService } from './fileSystemService.js';
@@ -69,14 +61,11 @@ import { loadCliConfig } from '../config/config.js';
 import { runExitCleanup } from '../utils/cleanup.js';
 import { SessionSelector } from '../utils/sessionUtils.js';
 
-import { CommandHandler } from './commandHandler.js';
 export async function runAcpClient(
   config: Config,
   settings: LoadedSettings,
   argv: CliArgs,
 ) {
-  // ... (skip unchanged lines) ...
-
   const { stdout: workingStdout } = createWorkingStdio();
   const stdout = Writable.toWeb(workingStdout) as WritableStream;
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
@@ -98,8 +87,6 @@ export class GeminiAgent {
   private sessions: Map<string, Session> = new Map();
   private clientCapabilities: acp.ClientCapabilities | undefined;
   private apiKey: string | undefined;
-  private baseUrl: string | undefined;
-  private customHeaders: Record<string, string> | undefined;
 
   constructor(
     private config: Config,
@@ -133,17 +120,6 @@ export class GeminiAgent {
         name: 'Vertex AI',
         description: 'Use an API key with Vertex AI GenAI API',
       },
-      {
-        id: AuthType.GATEWAY,
-        name: 'AI API Gateway',
-        description: 'Use a custom AI API Gateway',
-        _meta: {
-          gateway: {
-            protocol: 'google',
-            restartRequired: 'false',
-          },
-        },
-      },
     ];
 
     await this.config.initialize();
@@ -192,38 +168,7 @@ export class GeminiAgent {
       if (apiKey) {
         this.apiKey = apiKey;
       }
-
-      // Extract gateway details if present
-      const gatewaySchema = z.object({
-        baseUrl: z.string().optional(),
-        headers: z.record(z.string()).optional(),
-      });
-
-      let baseUrl: string | undefined;
-      let headers: Record<string, string> | undefined;
-
-      if (meta?.['gateway']) {
-        const result = gatewaySchema.safeParse(meta['gateway']);
-        if (result.success) {
-          baseUrl = result.data.baseUrl;
-          headers = result.data.headers;
-        } else {
-          throw new acp.RequestError(
-            -32602,
-            `Malformed gateway payload: ${result.error.message}`,
-          );
-        }
-      }
-
-      this.baseUrl = baseUrl;
-      this.customHeaders = headers;
-
-      await this.config.refreshAuth(
-        method,
-        apiKey ?? this.apiKey,
-        baseUrl,
-        headers,
-      );
+      await this.config.refreshAuth(method, apiKey ?? this.apiKey);
     } catch (e) {
       throw new acp.RequestError(-32000, getAcpErrorMessage(e));
     }
@@ -253,12 +198,7 @@ export class GeminiAgent {
     let isAuthenticated = false;
     let authErrorMessage = '';
     try {
-      await config.refreshAuth(
-        authType,
-        this.apiKey,
-        this.baseUrl,
-        this.customHeaders,
-      );
+      await config.refreshAuth(authType, this.apiKey);
       isAuthenticated = true;
 
       // Extra validation for Gemini API key
@@ -300,37 +240,16 @@ export class GeminiAgent {
 
     const geminiClient = config.getGeminiClient();
     const chat = await geminiClient.startChat();
-    const session = new Session(
-      sessionId,
-      chat,
-      config,
-      this.connection,
-      this.settings,
-    );
+    const session = new Session(sessionId, chat, config, this.connection);
     this.sessions.set(sessionId, session);
 
-    setTimeout(() => {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      session.sendAvailableCommands();
-    }, 0);
-
-    const { availableModels, currentModelId } = buildAvailableModels(
-      config,
-      loadedSettings,
-    );
-
-    const response = {
+    return {
       sessionId,
       modes: {
         availableModes: buildAvailableModes(config.isPlanEnabled()),
         currentModeId: config.getApprovalMode(),
       },
-      models: {
-        availableModels,
-        currentModelId,
-      },
     };
-    return response;
   }
 
   async loadSession({
@@ -372,7 +291,6 @@ export class GeminiAgent {
       geminiClient.getChat(),
       config,
       this.connection,
-      this.settings,
     );
     this.sessions.set(sessionId, session);
 
@@ -380,27 +298,12 @@ export class GeminiAgent {
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
     session.streamHistory(sessionData.messages);
 
-    setTimeout(() => {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      session.sendAvailableCommands();
-    }, 0);
-
-    const { availableModels, currentModelId } = buildAvailableModels(
-      config,
-      this.settings,
-    );
-
-    const response = {
+    return {
       modes: {
         availableModes: buildAvailableModes(config.isPlanEnabled()),
         currentModeId: config.getApprovalMode(),
       },
-      models: {
-        availableModels,
-        currentModelId,
-      },
     };
-    return response;
   }
 
   private async initializeSessionConfig(
@@ -420,12 +323,7 @@ export class GeminiAgent {
     // This satisfies the security requirement to verify the user before executing
     // potentially unsafe server definitions.
     try {
-      await config.refreshAuth(
-        selectedAuthType,
-        this.apiKey,
-        this.baseUrl,
-        this.customHeaders,
-      );
+      await config.refreshAuth(selectedAuthType, this.apiKey);
     } catch (e) {
       debugLogger.error(`Authentication failed: ${e}`);
       throw acp.RequestError.authRequired();
@@ -516,28 +414,16 @@ export class GeminiAgent {
     }
     return session.setMode(params.modeId);
   }
-
-  async unstable_setSessionModel(
-    params: acp.SetSessionModelRequest,
-  ): Promise<acp.SetSessionModelResponse> {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    return session.setModel(params.modelId);
-  }
 }
 
 export class Session {
   private pendingPrompt: AbortController | null = null;
-  private commandHandler = new CommandHandler();
 
   constructor(
     private readonly id: string,
     private readonly chat: GeminiChat,
     private readonly config: Config,
     private readonly connection: acp.AgentSideConnection,
-    private readonly settings: LoadedSettings,
   ) {}
 
   async cancelPendingPrompt(): Promise<void> {
@@ -560,27 +446,6 @@ export class Session {
     return {};
   }
 
-  private getAvailableCommands() {
-    return this.commandHandler.getAvailableCommands();
-  }
-
-  async sendAvailableCommands(): Promise<void> {
-    const availableCommands = this.getAvailableCommands().map((command) => ({
-      name: command.name,
-      description: command.description,
-    }));
-
-    await this.sendUpdate({
-      sessionUpdate: 'available_commands_update',
-      availableCommands,
-    });
-  }
-
-  setModel(modelId: acp.ModelId): acp.SetSessionModelResponse {
-    this.config.setModel(modelId);
-    return {};
-  }
-
   async streamHistory(messages: ConversationRecord['messages']): Promise<void> {
     for (const msg of messages) {
       const contentString = partListUnionToString(msg.content);
@@ -663,41 +528,6 @@ export class Session {
 
     const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
 
-    // Command interception
-    let commandText = '';
-
-    for (const part of parts) {
-      if (typeof part === 'object' && part !== null) {
-        if ('text' in part) {
-          // It is a text part
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-type-assertion
-          const text = (part as any).text;
-          if (typeof text === 'string') {
-            commandText += text;
-          }
-        } else {
-          // Non-text part (image, embedded resource)
-          // Stop looking for command
-          break;
-        }
-      }
-    }
-
-    commandText = commandText.trim();
-
-    if (
-      commandText &&
-      (commandText.startsWith('/') || commandText.startsWith('$'))
-    ) {
-      // If we found a command, pass it to handleCommand
-      // Note: handleCommand currently expects `commandText` to be the command string
-      // It uses `parts` argument but effectively ignores it in current implementation
-      const handled = await this.handleCommand(commandText, parts);
-      if (handled) {
-        return { stopReason: 'end_turn' };
-      }
-    }
-
     let nextMessage: Content | null = { role: 'user', parts };
 
     while (nextMessage !== null) {
@@ -797,28 +627,9 @@ export class Session {
     return { stopReason: 'end_turn' };
   }
 
-  private async handleCommand(
-    commandText: string,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    parts: Part[],
-  ): Promise<boolean> {
-    const gitService = await this.config.getGitService();
-    const commandContext = {
-      config: this.config,
-      settings: this.settings,
-      git: gitService,
-      sendMessage: async (text: string) => {
-        await this.sendUpdate({
-          sessionUpdate: 'agent_message_chunk',
-          content: { type: 'text', text },
-        });
-      },
-    };
-
-    return this.commandHandler.handleCommand(commandText, commandContext);
-  }
-
-  private async sendUpdate(update: acp.SessionUpdate): Promise<void> {
+  private async sendUpdate(
+    update: acp.SessionNotification['update'],
+  ): Promise<void> {
     const params: acp.SessionNotification = {
       sessionId: this.id,
       update,
@@ -1566,94 +1377,3 @@ function buildAvailableModes(isPlanEnabled: boolean): acp.SessionMode[] {
 
   return modes;
 }
-
-function buildAvailableModels(
-  config: Config,
-  settings: LoadedSettings,
-): {
-  availableModels: Array<{
-    modelId: string;
-    name: string;
-    description?: string;
-  }>;
-  currentModelId: string;
-} {
-  const preferredModel = config.getModel() || DEFAULT_GEMINI_MODEL_AUTO;
-  const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
-  const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
-  const selectedAuthType = settings.merged.security.auth.selectedType;
-  const useCustomToolModel =
-    useGemini31 && selectedAuthType === AuthType.USE_GEMINI;
-
-  const mainOptions = [
-    {
-      value: DEFAULT_GEMINI_MODEL_AUTO,
-      title: getDisplayString(DEFAULT_GEMINI_MODEL_AUTO),
-      description:
-        'Let Gemini CLI decide the best model for the task: gemini-2.5-pro, gemini-2.5-flash',
-    },
-  ];
-
-  if (shouldShowPreviewModels) {
-    mainOptions.unshift({
-      value: PREVIEW_GEMINI_MODEL_AUTO,
-      title: getDisplayString(PREVIEW_GEMINI_MODEL_AUTO),
-      description: useGemini31
-        ? 'Let Gemini CLI decide the best model for the task: gemini-3.1-pro, gemini-3-flash'
-        : 'Let Gemini CLI decide the best model for the task: gemini-3-pro, gemini-3-flash',
-    });
-  }
-
-  const manualOptions = [
-    {
-      value: DEFAULT_GEMINI_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_MODEL),
-    },
-    {
-      value: DEFAULT_GEMINI_FLASH_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_FLASH_MODEL),
-    },
-    {
-      value: DEFAULT_GEMINI_FLASH_LITE_MODEL,
-      title: getDisplayString(DEFAULT_GEMINI_FLASH_LITE_MODEL),
-    },
-  ];
-
-  if (shouldShowPreviewModels) {
-    const previewProModel = useGemini31
-      ? PREVIEW_GEMINI_3_1_MODEL
-      : PREVIEW_GEMINI_MODEL;
-
-    const previewProValue = useCustomToolModel
-      ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL
-      : previewProModel;
-
-    manualOptions.unshift(
-      {
-        value: previewProValue,
-        title: getDisplayString(previewProModel),
-      },
-      {
-        value: PREVIEW_GEMINI_FLASH_MODEL,
-        title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL),
-      },
-    );
-  }
-
-  const scaleOptions = (
-    options: Array<{ value: string; title: string; description?: string }>,
-  ) =>
-    options.map((o) => ({
-      modelId: o.value,
-      name: o.title,
-      description: o.description,
-    }));
-
-  return {
-    availableModels: [
-      ...scaleOptions(mainOptions),
-      ...scaleOptions(manualOptions),
-    ],
-    currentModelId: preferredModel,
-  };
-}

packages/cli/src/acp/acpResume.test.ts

@@ -92,11 +92,7 @@ describe('GeminiAgent Session Resume', () => {
         getProjectTempDir: vi.fn().mockReturnValue('/tmp/project'),
       },
       getApprovalMode: vi.fn().mockReturnValue('default'),
-      isPlanEnabled: vi.fn().mockReturnValue(true),
-      getModel: vi.fn().mockReturnValue('gemini-pro'),
-      getHasAccessToPreviewModel: vi.fn().mockReturnValue(false),
-      getGemini31LaunchedSync: vi.fn().mockReturnValue(false),
-      getCheckpointingEnabled: vi.fn().mockReturnValue(false),
+      isPlanEnabled: vi.fn().mockReturnValue(false),
     } as unknown as Mocked<Config>;
     mockSettings = {
       merged: {
@@ -204,18 +200,9 @@ describe('GeminiAgent Session Resume', () => {
             name: 'YOLO',
             description: 'Auto-approves all tools',
           },
-          {
-            id: ApprovalMode.PLAN,
-            name: 'Plan',
-            description: 'Read-only mode',
-          },
         ],
         currentModeId: ApprovalMode.DEFAULT,
       },
-      models: {
-        availableModels: expect.any(Array) as unknown,
-        currentModelId: 'gemini-pro',
-      },
     });
 
     // Verify resumeChat received the correct arguments

packages/cli/src/acp/commandHandler.test.ts

@@ -1,30 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { CommandHandler } from './commandHandler.js';
-import { describe, it, expect } from 'vitest';
-
-describe('CommandHandler', () => {
-  it('parses commands correctly', () => {
-    const handler = new CommandHandler();
-    // @ts-expect-error - testing private method
-    const parse = (query: string) => handler.parseSlashCommand(query);
-
-    const memShow = parse('/memory show');
-    expect(memShow.commandToExecute?.name).toBe('memory show');
-    expect(memShow.args).toBe('');
-
-    const memAdd = parse('/memory add hello world');
-    expect(memAdd.commandToExecute?.name).toBe('memory add');
-    expect(memAdd.args).toBe('hello world');
-
-    const extList = parse('/extensions list');
-    expect(extList.commandToExecute?.name).toBe('extensions list');
-
-    const init = parse('/init');
-    expect(init.commandToExecute?.name).toBe('init');
-  });
-});

packages/cli/src/acp/commandHandler.ts

@@ -1,134 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Command, CommandContext } from './commands/types.js';
-import { CommandRegistry } from './commands/commandRegistry.js';
-import { MemoryCommand } from './commands/memory.js';
-import { ExtensionsCommand } from './commands/extensions.js';
-import { InitCommand } from './commands/init.js';
-import { RestoreCommand } from './commands/restore.js';
-
-export class CommandHandler {
-  private registry: CommandRegistry;
-
-  constructor() {
-    this.registry = CommandHandler.createRegistry();
-  }
-
-  private static createRegistry(): CommandRegistry {
-    const registry = new CommandRegistry();
-    registry.register(new MemoryCommand());
-    registry.register(new ExtensionsCommand());
-    registry.register(new InitCommand());
-    registry.register(new RestoreCommand());
-    return registry;
-  }
-
-  getAvailableCommands(): Array<{ name: string; description: string }> {
-    return this.registry.getAllCommands().map((cmd) => ({
-      name: cmd.name,
-      description: cmd.description,
-    }));
-  }
-
-  /**
-   * Parses and executes a command string if it matches a registered command.
-   * Returns true if a command was handled, false otherwise.
-   */
-  async handleCommand(
-    commandText: string,
-    context: CommandContext,
-  ): Promise<boolean> {
-    const { commandToExecute, args } = this.parseSlashCommand(commandText);
-
-    if (commandToExecute) {
-      await this.runCommand(commandToExecute, args, context);
-      return true;
-    }
-
-    return false;
-  }
-
-  private async runCommand(
-    commandToExecute: Command,
-    args: string,
-    context: CommandContext,
-  ): Promise<void> {
-    try {
-      const result = await commandToExecute.execute(
-        context,
-        args ? args.split(/\s+/) : [],
-      );
-
-      let messageContent = '';
-      if (typeof result.data === 'string') {
-        messageContent = result.data;
-      } else if (
-        typeof result.data === 'object' &&
-        result.data !== null &&
-        'content' in result.data
-      ) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any
-        messageContent = (result.data as Record<string, any>)[
-          'content'
-        ] as string;
-      } else {
-        messageContent = JSON.stringify(result.data, null, 2);
-      }
-
-      await context.sendMessage(messageContent);
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      await context.sendMessage(`Error: ${errorMessage}`);
-    }
-  }
-
-  /**
-   * Parses a raw slash command string into its matching headless command and arguments.
-   * Mirrors `packages/cli/src/utils/commands.ts` logic.
-   */
-  private parseSlashCommand(query: string): {
-    commandToExecute: Command | undefined;
-    args: string;
-  } {
-    const trimmed = query.trim();
-    const parts = trimmed.substring(1).trim().split(/\s+/);
-    const commandPath = parts.filter((p) => p);
-
-    let currentCommands = this.registry.getAllCommands();
-    let commandToExecute: Command | undefined;
-    let pathIndex = 0;
-
-    for (const part of commandPath) {
-      const foundCommand = currentCommands.find((cmd) => {
-        const expectedName = commandPath.slice(0, pathIndex + 1).join(' ');
-        return (
-          cmd.name === part ||
-          cmd.name === expectedName ||
-          cmd.aliases?.includes(part) ||
-          cmd.aliases?.includes(expectedName)
-        );
-      });
-
-      if (foundCommand) {
-        commandToExecute = foundCommand;
-        pathIndex++;
-        if (foundCommand.subCommands) {
-          currentCommands = foundCommand.subCommands;
-        } else {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-
-    const args = parts.slice(pathIndex).join(' ');
-
-    return { commandToExecute, args };
-  }
-}

packages/cli/src/acp/commands/commandRegistry.ts

@@ -1,33 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { debugLogger } from '@google/gemini-cli-core';
-import type { Command } from './types.js';
-
-export class CommandRegistry {
-  private readonly commands = new Map<string, Command>();
-
-  register(command: Command) {
-    if (this.commands.has(command.name)) {
-      debugLogger.warn(`Command ${command.name} already registered. Skipping.`);
-      return;
-    }
-
-    this.commands.set(command.name, command);
-
-    for (const subCommand of command.subCommands ?? []) {
-      this.register(subCommand);
-    }
-  }
-
-  get(commandName: string): Command | undefined {
-    return this.commands.get(commandName);
-  }
-
-  getAllCommands(): Command[] {
-    return [...this.commands.values()];
-  }
-}

packages/cli/src/acp/commands/extensions.ts

@@ -1,428 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { listExtensions } from '@google/gemini-cli-core';
-import { SettingScope } from '../../config/settings.js';
-import {
-  ExtensionManager,
-  inferInstallMetadata,
-} from '../../config/extension-manager.js';
-import { getErrorMessage } from '../../utils/errors.js';
-import { McpServerEnablementManager } from '../../config/mcp/mcpServerEnablement.js';
-import { stat } from 'node:fs/promises';
-import type {
-  Command,
-  CommandContext,
-  CommandExecutionResponse,
-} from './types.js';
-import type { Config } from '@google/gemini-cli-core';
-
-export class ExtensionsCommand implements Command {
-  readonly name = 'extensions';
-  readonly description = 'Manage extensions.';
-  readonly subCommands = [
-    new ListExtensionsCommand(),
-    new ExploreExtensionsCommand(),
-    new EnableExtensionCommand(),
-    new DisableExtensionCommand(),
-    new InstallExtensionCommand(),
-    new LinkExtensionCommand(),
-    new UninstallExtensionCommand(),
-    new RestartExtensionCommand(),
-    new UpdateExtensionCommand(),
-  ];
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    return new ListExtensionsCommand().execute(context, _);
-  }
-}
-
-export class ListExtensionsCommand implements Command {
-  readonly name = 'extensions list';
-  readonly description = 'Lists all installed extensions.';
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensions = listExtensions(context.config);
-    const data = extensions.length ? extensions : 'No extensions installed.';
-
-    return { name: this.name, data };
-  }
-}
-
-export class ExploreExtensionsCommand implements Command {
-  readonly name = 'extensions explore';
-  readonly description = 'Explore available extensions.';
-
-  async execute(
-    _context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionsUrl = 'https://geminicli.com/extensions/';
-    return {
-      name: this.name,
-      data: `View or install available extensions at ${extensionsUrl}`,
-    };
-  }
-}
-
-function getEnableDisableContext(
-  config: Config,
-  args: string[],
-  invocationName: string,
-) {
-  const extensionManager = config.getExtensionLoader();
-  if (!(extensionManager instanceof ExtensionManager)) {
-    return {
-      error: `Cannot ${invocationName} extensions in this environment.`,
-    };
-  }
-
-  if (args.length === 0) {
-    return {
-      error: `Usage: /extensions ${invocationName} <extension> [--scope=<user|workspace|session>]`,
-    };
-  }
-
-  let scope = SettingScope.User;
-  if (args.includes('--scope=workspace') || args.includes('workspace')) {
-    scope = SettingScope.Workspace;
-  } else if (args.includes('--scope=session') || args.includes('session')) {
-    scope = SettingScope.Session;
-  }
-
-  const name = args.filter(
-    (a) =>
-      !a.startsWith('--scope') && !['user', 'workspace', 'session'].includes(a),
-  )[0];
-
-  let names: string[] = [];
-  if (name === '--all') {
-    let extensions = extensionManager.getExtensions();
-    if (invocationName === 'enable') {
-      extensions = extensions.filter((ext) => !ext.isActive);
-    }
-    if (invocationName === 'disable') {
-      extensions = extensions.filter((ext) => ext.isActive);
-    }
-    names = extensions.map((ext) => ext.name);
-  } else if (name) {
-    names = [name];
-  } else {
-    return { error: 'No extension name provided.' };
-  }
-
-  return { extensionManager, names, scope };
-}
-
-export class EnableExtensionCommand implements Command {
-  readonly name = 'extensions enable';
-  readonly description = 'Enable an extension.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const enableContext = getEnableDisableContext(
-      context.config,
-      args,
-      'enable',
-    );
-    if ('error' in enableContext) {
-      return { name: this.name, data: enableContext.error };
-    }
-
-    const { names, scope, extensionManager } = enableContext;
-    const output: string[] = [];
-
-    for (const name of names) {
-      try {
-        await extensionManager.enableExtension(name, scope);
-        output.push(`Extension "${name}" enabled for scope "${scope}".`);
-
-        const extension = extensionManager
-          .getExtensions()
-          .find((e) => e.name === name);
-
-        if (extension?.mcpServers) {
-          const mcpEnablementManager = McpServerEnablementManager.getInstance();
-          const mcpClientManager = context.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) => {
-                output.push(
-                  `Failed to restart MCP server '${serverName}': ${getErrorMessage(error)}`,
-                );
-              }),
-            );
-            await Promise.all(restartPromises);
-            output.push(`Re-enabled MCP servers: ${enabledServers.join(', ')}`);
-          }
-        }
-      } catch (e) {
-        output.push(`Failed to enable "${name}": ${getErrorMessage(e)}`);
-      }
-    }
-
-    return { name: this.name, data: output.join('\n') || 'No action taken.' };
-  }
-}
-
-export class DisableExtensionCommand implements Command {
-  readonly name = 'extensions disable';
-  readonly description = 'Disable an extension.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const enableContext = getEnableDisableContext(
-      context.config,
-      args,
-      'disable',
-    );
-    if ('error' in enableContext) {
-      return { name: this.name, data: enableContext.error };
-    }
-
-    const { names, scope, extensionManager } = enableContext;
-    const output: string[] = [];
-
-    for (const name of names) {
-      try {
-        await extensionManager.disableExtension(name, scope);
-        output.push(`Extension "${name}" disabled for scope "${scope}".`);
-      } catch (e) {
-        output.push(`Failed to disable "${name}": ${getErrorMessage(e)}`);
-      }
-    }
-
-    return { name: this.name, data: output.join('\n') || 'No action taken.' };
-  }
-}
-
-export class InstallExtensionCommand implements Command {
-  readonly name = 'extensions install';
-  readonly description = 'Install an extension from a git repo or local path.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionLoader = context.config.getExtensionLoader();
-    if (!(extensionLoader instanceof ExtensionManager)) {
-      return {
-        name: this.name,
-        data: 'Cannot install extensions in this environment.',
-      };
-    }
-
-    const source = args.join(' ').trim();
-    if (!source) {
-      return { name: this.name, data: `Usage: /extensions install <source>` };
-    }
-
-    if (/[;&|`'"]/.test(source)) {
-      return {
-        name: this.name,
-        data: `Invalid source: contains disallowed characters.`,
-      };
-    }
-
-    try {
-      const installMetadata = await inferInstallMetadata(source);
-      const extension =
-        await extensionLoader.installOrUpdateExtension(installMetadata);
-      return {
-        name: this.name,
-        data: `Extension "${extension.name}" installed successfully.`,
-      };
-    } catch (error) {
-      return {
-        name: this.name,
-        data: `Failed to install extension from "${source}": ${getErrorMessage(error)}`,
-      };
-    }
-  }
-}
-
-export class LinkExtensionCommand implements Command {
-  readonly name = 'extensions link';
-  readonly description = 'Link an extension from a local path.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionLoader = context.config.getExtensionLoader();
-    if (!(extensionLoader instanceof ExtensionManager)) {
-      return {
-        name: this.name,
-        data: 'Cannot link extensions in this environment.',
-      };
-    }
-
-    const sourceFilepath = args.join(' ').trim();
-    if (!sourceFilepath) {
-      return { name: this.name, data: `Usage: /extensions link <source>` };
-    }
-
-    try {
-      await stat(sourceFilepath);
-    } catch (_error) {
-      return { name: this.name, data: `Invalid source: ${sourceFilepath}` };
-    }
-
-    try {
-      const extension = await extensionLoader.installOrUpdateExtension({
-        source: sourceFilepath,
-        type: 'link',
-      });
-      return {
-        name: this.name,
-        data: `Extension "${extension.name}" linked successfully.`,
-      };
-    } catch (error) {
-      return {
-        name: this.name,
-        data: `Failed to link extension: ${getErrorMessage(error)}`,
-      };
-    }
-  }
-}
-
-export class UninstallExtensionCommand implements Command {
-  readonly name = 'extensions uninstall';
-  readonly description = 'Uninstall an extension.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionLoader = context.config.getExtensionLoader();
-    if (!(extensionLoader instanceof ExtensionManager)) {
-      return {
-        name: this.name,
-        data: 'Cannot uninstall extensions in this environment.',
-      };
-    }
-
-    const name = args.join(' ').trim();
-    if (!name) {
-      return {
-        name: this.name,
-        data: `Usage: /extensions uninstall <extension-name>`,
-      };
-    }
-
-    try {
-      await extensionLoader.uninstallExtension(name, false);
-      return {
-        name: this.name,
-        data: `Extension "${name}" uninstalled successfully.`,
-      };
-    } catch (error) {
-      return {
-        name: this.name,
-        data: `Failed to uninstall extension "${name}": ${getErrorMessage(error)}`,
-      };
-    }
-  }
-}
-
-export class RestartExtensionCommand implements Command {
-  readonly name = 'extensions restart';
-  readonly description = 'Restart an extension.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionLoader = context.config.getExtensionLoader();
-    if (!(extensionLoader instanceof ExtensionManager)) {
-      return { name: this.name, data: 'Cannot restart extensions.' };
-    }
-
-    const all = args.includes('--all');
-    const names = all ? null : args.filter((a) => !!a);
-
-    if (!all && names?.length === 0) {
-      return {
-        name: this.name,
-        data: 'Usage: /extensions restart <extension-names>|--all',
-      };
-    }
-
-    let extensionsToRestart = extensionLoader
-      .getExtensions()
-      .filter((e) => e.isActive);
-    if (names) {
-      extensionsToRestart = extensionsToRestart.filter((e) =>
-        names.includes(e.name),
-      );
-    }
-
-    if (extensionsToRestart.length === 0) {
-      return {
-        name: this.name,
-        data: 'No active extensions matched the request.',
-      };
-    }
-
-    const output: string[] = [];
-    for (const extension of extensionsToRestart) {
-      try {
-        await extensionLoader.restartExtension(extension);
-        output.push(`Restarted "${extension.name}".`);
-      } catch (e) {
-        output.push(
-          `Failed to restart "${extension.name}": ${getErrorMessage(e)}`,
-        );
-      }
-    }
-
-    return { name: this.name, data: output.join('\n') };
-  }
-}
-
-export class UpdateExtensionCommand implements Command {
-  readonly name = 'extensions update';
-  readonly description = 'Update an extension.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const extensionLoader = context.config.getExtensionLoader();
-    if (!(extensionLoader instanceof ExtensionManager)) {
-      return { name: this.name, data: 'Cannot update extensions.' };
-    }
-
-    const all = args.includes('--all');
-    const names = all ? null : args.filter((a) => !!a);
-
-    if (!all && names?.length === 0) {
-      return {
-        name: this.name,
-        data: 'Usage: /extensions update <extension-names>|--all',
-      };
-    }
-
-    return {
-      name: this.name,
-      data: 'Headless extension updating requires internal UI dispatches. Please use `gemini extensions update` directly in the terminal.',
-    };
-  }
-}

packages/cli/src/acp/commands/init.ts

@@ -1,62 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { performInit } from '@google/gemini-cli-core';
-import type {
-  Command,
-  CommandContext,
-  CommandExecutionResponse,
-} from './types.js';
-
-export class InitCommand implements Command {
-  name = 'init';
-  description = 'Analyzes the project and creates a tailored GEMINI.md file';
-  requiresWorkspace = true;
-
-  async execute(
-    context: CommandContext,
-    _args: string[] = [],
-  ): Promise<CommandExecutionResponse> {
-    const targetDir = context.config.getTargetDir();
-    if (!targetDir) {
-      throw new Error('Command requires a workspace.');
-    }
-
-    const geminiMdPath = path.join(targetDir, 'GEMINI.md');
-    const result = performInit(fs.existsSync(geminiMdPath));
-
-    switch (result.type) {
-      case 'message':
-        return {
-          name: this.name,
-          data: result,
-        };
-      case 'submit_prompt':
-        fs.writeFileSync(geminiMdPath, '', 'utf8');
-
-        if (typeof result.content !== 'string') {
-          throw new Error('Init command content must be a string.');
-        }
-
-        // Inform the user since we can't trigger the UI-based interactive agent loop here directly.
-        // We output the prompt text they can use to re-trigger the generation manually,
-        // or just seed the GEMINI.md file as we've done above.
-        return {
-          name: this.name,
-          data: {
-            type: 'message',
-            messageType: 'info',
-            content: `A template GEMINI.md has been created at ${geminiMdPath}.\n\nTo populate it with project context, you can run the following prompt in a new chat:\n\n${result.content}`,
-          },
-        };
-
-      default:
-        throw new Error('Unknown result type from performInit');
-    }
-  }
-}

packages/cli/src/acp/commands/memory.ts

@@ -1,121 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  addMemory,
-  listMemoryFiles,
-  refreshMemory,
-  showMemory,
-} from '@google/gemini-cli-core';
-import type {
-  Command,
-  CommandContext,
-  CommandExecutionResponse,
-} from './types.js';
-
-const DEFAULT_SANITIZATION_CONFIG = {
-  allowedEnvironmentVariables: [],
-  blockedEnvironmentVariables: [],
-  enableEnvironmentVariableRedaction: false,
-};
-
-export class MemoryCommand implements Command {
-  readonly name = 'memory';
-  readonly description = 'Manage memory.';
-  readonly subCommands = [
-    new ShowMemoryCommand(),
-    new RefreshMemoryCommand(),
-    new ListMemoryCommand(),
-    new AddMemoryCommand(),
-  ];
-  readonly requiresWorkspace = true;
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    return new ShowMemoryCommand().execute(context, _);
-  }
-}
-
-export class ShowMemoryCommand implements Command {
-  readonly name = 'memory show';
-  readonly description = 'Shows the current memory contents.';
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    const result = showMemory(context.config);
-    return { name: this.name, data: result.content };
-  }
-}
-
-export class RefreshMemoryCommand implements Command {
-  readonly name = 'memory refresh';
-  readonly aliases = ['memory reload'];
-  readonly description = 'Refreshes the memory from the source.';
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    const result = await refreshMemory(context.config);
-    return { name: this.name, data: result.content };
-  }
-}
-
-export class ListMemoryCommand implements Command {
-  readonly name = 'memory list';
-  readonly description = 'Lists the paths of the GEMINI.md files in use.';
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    const result = listMemoryFiles(context.config);
-    return { name: this.name, data: result.content };
-  }
-}
-
-export class AddMemoryCommand implements Command {
-  readonly name = 'memory add';
-  readonly description = 'Add content to the memory.';
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const textToAdd = args.join(' ').trim();
-    const result = addMemory(textToAdd);
-    if (result.type === 'message') {
-      return { name: this.name, data: result.content };
-    }
-
-    const toolRegistry = context.config.getToolRegistry();
-    const tool = toolRegistry.getTool(result.toolName);
-    if (tool) {
-      const abortController = new AbortController();
-      const signal = abortController.signal;
-
-      await context.sendMessage(`Saving memory via ${result.toolName}...`);
-
-      await tool.buildAndExecute(result.toolArgs, signal, undefined, {
-        sanitizationConfig: DEFAULT_SANITIZATION_CONFIG,
-      });
-      await refreshMemory(context.config);
-      return {
-        name: this.name,
-        data: `Added memory: "${textToAdd}"`,
-      };
-    } else {
-      return {
-        name: this.name,
-        data: `Error: Tool ${result.toolName} not found.`,
-      };
-    }
-  }
-}

packages/cli/src/acp/commands/restore.ts

@@ -1,178 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  getCheckpointInfoList,
-  getToolCallDataSchema,
-  isNodeError,
-  performRestore,
-} from '@google/gemini-cli-core';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import type {
-  Command,
-  CommandContext,
-  CommandExecutionResponse,
-} from './types.js';
-
-export class RestoreCommand implements Command {
-  readonly name = 'restore';
-  readonly description =
-    'Restore to a previous checkpoint, or list available checkpoints to restore. This will reset the conversation and file history to the state it was in when the checkpoint was created';
-  readonly requiresWorkspace = true;
-  readonly subCommands = [new ListCheckpointsCommand()];
-
-  async execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse> {
-    const { config, git: gitService } = context;
-    const argsStr = args.join(' ');
-
-    try {
-      if (!argsStr) {
-        return await new ListCheckpointsCommand().execute(context);
-      }
-
-      if (!config.getCheckpointingEnabled()) {
-        return {
-          name: this.name,
-          data: 'Checkpointing is not enabled. Please enable it in your settings (`general.checkpointing.enabled: true`) to use /restore.',
-        };
-      }
-
-      const selectedFile = argsStr.endsWith('.json')
-        ? argsStr
-        : `${argsStr}.json`;
-
-      const checkpointDir = config.storage.getProjectTempCheckpointsDir();
-      const filePath = path.join(checkpointDir, selectedFile);
-
-      let data: string;
-      try {
-        data = await fs.readFile(filePath, 'utf-8');
-      } catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-          return {
-            name: this.name,
-            data: `File not found: ${selectedFile}`,
-          };
-        }
-        throw error;
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const toolCallData = JSON.parse(data);
-      const ToolCallDataSchema = getToolCallDataSchema();
-      const parseResult = ToolCallDataSchema.safeParse(toolCallData);
-
-      if (!parseResult.success) {
-        return {
-          name: this.name,
-          data: 'Checkpoint file is invalid or corrupted.',
-        };
-      }
-
-      const restoreResultGenerator = performRestore(
-        parseResult.data,
-        gitService,
-      );
-
-      const restoreResult = [];
-      for await (const result of restoreResultGenerator) {
-        restoreResult.push(result);
-      }
-
-      // Format the result nicely since Zed just dumps data
-      const formattedResult = restoreResult
-        .map((r) => {
-          if (r.type === 'message') {
-            return `[${r.messageType.toUpperCase()}] ${r.content}`;
-          } else if (r.type === 'load_history') {
-            return `Loaded history with ${r.clientHistory.length} messages.`;
-          }
-          return `Restored: ${JSON.stringify(r)}`;
-        })
-        .join('\n');
-
-      return {
-        name: this.name,
-        data: formattedResult,
-      };
-    } catch (error) {
-      return {
-        name: this.name,
-        data: `An unexpected error occurred during restore: ${error}`,
-      };
-    }
-  }
-}
-
-export class ListCheckpointsCommand implements Command {
-  readonly name = 'restore list';
-  readonly description = 'Lists all available checkpoints.';
-
-  async execute(context: CommandContext): Promise<CommandExecutionResponse> {
-    const { config } = context;
-
-    try {
-      if (!config.getCheckpointingEnabled()) {
-        return {
-          name: this.name,
-          data: 'Checkpointing is not enabled. Please enable it in your settings (`general.checkpointing.enabled: true`) to use /restore.',
-        };
-      }
-
-      const checkpointDir = config.storage.getProjectTempCheckpointsDir();
-      try {
-        await fs.mkdir(checkpointDir, { recursive: true });
-      } catch (_e) {
-        // Ignore
-      }
-
-      const files = await fs.readdir(checkpointDir);
-      const jsonFiles = files.filter((file) => file.endsWith('.json'));
-
-      if (jsonFiles.length === 0) {
-        return { name: this.name, data: 'No checkpoints found.' };
-      }
-
-      const checkpointFiles = new Map<string, string>();
-      for (const file of jsonFiles) {
-        const filePath = path.join(checkpointDir, file);
-        const data = await fs.readFile(filePath, 'utf-8');
-        checkpointFiles.set(file, data);
-      }
-
-      const checkpointInfoList = getCheckpointInfoList(checkpointFiles);
-
-      const formatted = checkpointInfoList
-        .map((info) => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const i = info as Record<string, any>;
-          const fileName = String(i['fileName'] || 'Unknown');
-          const toolName = String(i['toolName'] || 'Unknown');
-          const status = String(i['status'] || 'Unknown');
-          const timestamp = new Date(
-            Number(i['timestamp']) || 0,
-          ).toLocaleString();
-
-          return `- **${fileName}**: ${toolName} (Status: ${status}) [${timestamp}]`;
-        })
-        .join('\n');
-
-      return {
-        name: this.name,
-        data: `Available Checkpoints:\n${formatted}`,
-      };
-    } catch (_error) {
-      return {
-        name: this.name,
-        data: 'An unexpected error occurred while listing checkpoints.',
-      };
-    }
-  }
-}

packages/cli/src/acp/commands/types.ts

@@ -1,40 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Config, GitService } from '@google/gemini-cli-core';
-import type { LoadedSettings } from '../../config/settings.js';
-
-export interface CommandContext {
-  config: Config;
-  settings: LoadedSettings;
-  git?: GitService;
-  sendMessage: (text: string) => Promise<void>;
-}
-
-export interface CommandArgument {
-  readonly name: string;
-  readonly description: string;
-  readonly isRequired?: boolean;
-}
-
-export interface Command {
-  readonly name: string;
-  readonly aliases?: string[];
-  readonly description: string;
-  readonly arguments?: CommandArgument[];
-  readonly subCommands?: Command[];
-  readonly requiresWorkspace?: boolean;
-
-  execute(
-    context: CommandContext,
-    args: string[],
-  ): Promise<CommandExecutionResponse>;
-}
-
-export interface CommandExecutionResponse {
-  readonly name: string;
-  readonly data: unknown;
-}

packages/cli/src/config/config.test.ts

@@ -2630,13 +2630,13 @@ describe('loadCliConfig approval mode', () => {
     expect(config.getApprovalMode()).toBe(ApprovalMode.DEFAULT);
   });
 
-  it('should allow plan approval mode by default when --approval-mode=plan is used', async () => {
+  it('should throw error when --approval-mode=plan is used but experimental.plan setting is missing', async () => {
     process.argv = ['node', 'script.js', '--approval-mode', 'plan'];
     const argv = await parseArguments(createTestMergedSettings());
     const settings = createTestMergedSettings({});
 
     const config = await loadCliConfig(settings, 'test-session', argv);
-    expect(config.getApprovalMode()).toBe(ApprovalMode.PLAN);
+    expect(config.getApprovalMode()).toBe(ApprovalMode.DEFAULT);
   });
 
   it('should pass planSettings.directory from settings to config', async () => {

packages/cli/src/config/config.ts

@@ -81,8 +81,9 @@ export interface CliArgs {
   policy: string[] | undefined;
   allowedMcpServerNames: string[] | undefined;
   allowedTools: string[] | undefined;
-  acp?: boolean;
-  experimentalAcp?: boolean;
+  acp: boolean | undefined;
+  /** @deprecated Use acp instead */
+  experimentalAcp: boolean | undefined;
   extensions: string[] | undefined;
   listExtensions: boolean | undefined;
   resume: string | typeof RESUME_LATEST | undefined;
@@ -179,14 +180,10 @@ export async function parseArguments(
             ),
         })
         .option('acp', {
+          alias: 'experimental-acp',
           type: 'boolean',
           description: 'Starts the agent in ACP mode',
         })
-        .option('experimental-acp', {
-          type: 'boolean',
-          description:
-            'Starts the agent in ACP mode (deprecated, use --acp instead)',
-        })
         .option('allowed-mcp-server-names', {
           type: 'array',
           string: true,
@@ -765,7 +762,6 @@ export async function loadCliConfig(
   }
 
   return new Config({
-    acpMode: !!argv.acp || !!argv.experimentalAcp,
     sessionId,
     clientVersion: await getVersion(),
     embeddingModel: DEFAULT_GEMINI_EMBEDDING_MODEL,
@@ -829,7 +825,7 @@ export async function loadCliConfig(
     bugCommand: settings.advanced?.bugCommand,
     model: resolvedModel,
     maxSessionTurns: settings.model?.maxSessionTurns,
-
+    acpMode: argv.acp || argv.experimentalAcp || false,
     listExtensions: argv.listExtensions || false,
     listSessions: argv.listSessions || false,
     deleteSession: argv.deleteSession,
@@ -875,7 +871,6 @@ export async function loadCliConfig(
     fakeResponses: argv.fakeResponses,
     recordResponses: argv.recordResponses,
     retryFetchErrors: settings.general?.retryFetchErrors,
-    billing: settings.billing,
     maxAttempts: settings.general?.maxAttempts,
     ptyInfo: ptyInfo?.name,
     disableLLMCorrection: settings.tools?.disableLLMCorrection,

packages/cli/src/config/policy-engine.integration.test.ts

@@ -89,13 +89,13 @@ describe('Policy Engine Integration Tests', () => {
       // Tools from allowed server should be allowed
       // Tools from allowed server should be allowed
       expect(
-        (await engine.check({ name: 'mcp_allowed-server_tool1' }, undefined))
+        (await engine.check({ name: 'allowed-server__tool1' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
         (
           await engine.check(
-            { name: 'mcp_allowed-server_another_tool' },
+            { name: 'allowed-server__another_tool' },
             undefined,
           )
         ).decision,
@@ -103,13 +103,13 @@ describe('Policy Engine Integration Tests', () => {
 
       // Tools from trusted server should be allowed
       expect(
-        (await engine.check({ name: 'mcp_trusted-server_tool1' }, undefined))
+        (await engine.check({ name: 'trusted-server__tool1' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
         (
           await engine.check(
-            { name: 'mcp_trusted-server_special_tool' },
+            { name: 'trusted-server__special_tool' },
             undefined,
           )
         ).decision,
@@ -117,17 +117,17 @@ describe('Policy Engine Integration Tests', () => {
 
       // Tools from blocked server should be denied
       expect(
-        (await engine.check({ name: 'mcp_blocked-server_tool1' }, undefined))
+        (await engine.check({ name: 'blocked-server__tool1' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
       expect(
-        (await engine.check({ name: 'mcp_blocked-server_any_tool' }, undefined))
+        (await engine.check({ name: 'blocked-server__any_tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
 
       // Tools from unknown servers should use default
       expect(
-        (await engine.check({ name: 'mcp_unknown-server_tool' }, undefined))
+        (await engine.check({ name: 'unknown-server__tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ASK_USER);
     });
@@ -147,16 +147,12 @@ describe('Policy Engine Integration Tests', () => {
 
       // ANY tool with a server name should be allowed
       expect(
-        (await engine.check({ name: 'mcp_mcp-server_tool' }, 'mcp-server'))
+        (await engine.check({ name: 'mcp-server__tool' }, 'mcp-server'))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (
-          await engine.check(
-            { name: 'mcp_another-server_tool' },
-            'another-server',
-          )
-        ).decision,
+        (await engine.check({ name: 'another-server__tool' }, 'another-server'))
+          .decision,
       ).toBe(PolicyDecision.ALLOW);
 
       // Built-in tools should NOT be allowed by the MCP wildcard
@@ -171,7 +167,7 @@ describe('Policy Engine Integration Tests', () => {
           allowed: ['my-server'],
         },
         tools: {
-          exclude: ['mcp_my-server_dangerous-tool'],
+          exclude: ['my-server__dangerous-tool'],
         },
       };
 
@@ -184,24 +180,20 @@ describe('Policy Engine Integration Tests', () => {
       // MCP server allowed (priority 4.1) provides general allow for server
       // MCP server allowed (priority 4.1) provides general allow for server
       expect(
-        (await engine.check({ name: 'mcp_my-server_safe-tool' }, undefined))
+        (await engine.check({ name: 'my-server__safe-tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       // But specific tool exclude (priority 4.4) wins over server allow
       expect(
-        (
-          await engine.check(
-            { name: 'mcp_my-server_dangerous-tool' },
-            undefined,
-          )
-        ).decision,
+        (await engine.check({ name: 'my-server__dangerous-tool' }, undefined))
+          .decision,
       ).toBe(PolicyDecision.DENY);
     });
 
     it('should handle complex mixed configurations', async () => {
       const settings: Settings = {
         tools: {
-          allowed: ['custom-tool', 'mcp_my-server_special-tool'],
+          allowed: ['custom-tool', 'my-server__special-tool'],
           exclude: ['glob', 'dangerous-tool'],
         },
         mcp: {
@@ -246,21 +238,21 @@ describe('Policy Engine Integration Tests', () => {
         (await engine.check({ name: 'custom-tool' }, undefined)).decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_my-server_special-tool' }, undefined))
+        (await engine.check({ name: 'my-server__special-tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
 
       // MCP server tools
       expect(
-        (await engine.check({ name: 'mcp_allowed-server_tool' }, undefined))
+        (await engine.check({ name: 'allowed-server__tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_trusted-server_tool' }, undefined))
+        (await engine.check({ name: 'trusted-server__tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_blocked-server_tool' }, undefined))
+        (await engine.check({ name: 'blocked-server__tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
 
@@ -487,7 +479,7 @@ describe('Policy Engine Integration Tests', () => {
       expect(blockedToolRule?.priority).toBe(4.4); // Command line exclude
 
       const blockedServerRule = rules.find(
-        (r) => r.toolName === 'mcp_blocked-server_*',
+        (r) => r.toolName === 'blocked-server__*',
       );
       expect(blockedServerRule?.priority).toBe(4.9); // MCP server exclude
 
@@ -497,13 +489,11 @@ describe('Policy Engine Integration Tests', () => {
       expect(specificToolRule?.priority).toBe(4.3); // Command line allow
 
       const trustedServerRule = rules.find(
-        (r) => r.toolName === 'mcp_trusted-server_*',
+        (r) => r.toolName === 'trusted-server__*',
       );
       expect(trustedServerRule?.priority).toBe(4.2); // MCP trusted server
 
-      const mcpServerRule = rules.find(
-        (r) => r.toolName === 'mcp_mcp-server_*',
-      );
+      const mcpServerRule = rules.find((r) => r.toolName === 'mcp-server__*');
       expect(mcpServerRule?.priority).toBe(4.1); // MCP allowed server
 
       const readOnlyToolRule = rules.find((r) => r.toolName === 'glob');
@@ -515,19 +505,18 @@ describe('Policy Engine Integration Tests', () => {
         (await engine.check({ name: 'blocked-tool' }, undefined)).decision,
       ).toBe(PolicyDecision.DENY);
       expect(
-        (await engine.check({ name: 'mcp_blocked-server_any' }, undefined))
+        (await engine.check({ name: 'blocked-server__any' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
       expect(
         (await engine.check({ name: 'specific-tool' }, undefined)).decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_trusted-server_any' }, undefined))
+        (await engine.check({ name: 'trusted-server__any' }, undefined))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_mcp-server_any' }, undefined))
-          .decision,
+        (await engine.check({ name: 'mcp-server__any' }, undefined)).decision,
       ).toBe(PolicyDecision.ALLOW);
       expect((await engine.check({ name: 'glob' }, undefined)).decision).toBe(
         PolicyDecision.ALLOW,
@@ -556,7 +545,7 @@ describe('Policy Engine Integration Tests', () => {
 
       // Exclusion (195) should win over trust (90)
       expect(
-        (await engine.check({ name: 'mcp_conflicted-server_tool' }, undefined))
+        (await engine.check({ name: 'conflicted-server__tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
     });
@@ -567,7 +556,7 @@ describe('Policy Engine Integration Tests', () => {
           excluded: ['my-server'], // Priority 195 - DENY
         },
         tools: {
-          allowed: ['mcp_my-server_special-tool'], // Priority 100 - ALLOW
+          allowed: ['my-server__special-tool'], // Priority 100 - ALLOW
         },
       };
 
@@ -580,11 +569,11 @@ describe('Policy Engine Integration Tests', () => {
       // Server exclusion (195) wins over specific tool allow (100)
       // This might be counterintuitive but follows the priority system
       expect(
-        (await engine.check({ name: 'mcp_my-server_special-tool' }, undefined))
+        (await engine.check({ name: 'my-server__special-tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
       expect(
-        (await engine.check({ name: 'mcp_my-server_other-tool' }, undefined))
+        (await engine.check({ name: 'my-server__other-tool' }, undefined))
           .decision,
       ).toBe(PolicyDecision.DENY);
     });
@@ -654,13 +643,13 @@ describe('Policy Engine Integration Tests', () => {
       const tool3Rule = rules.find((r) => r.toolName === 'tool3');
       expect(tool3Rule?.priority).toBe(4.4); // Excluded tools (user tier)
 
-      const server2Rule = rules.find((r) => r.toolName === 'mcp_server2_*');
+      const server2Rule = rules.find((r) => r.toolName === 'server2__*');
       expect(server2Rule?.priority).toBe(4.9); // Excluded servers (user tier)
 
       const tool1Rule = rules.find((r) => r.toolName === 'tool1');
       expect(tool1Rule?.priority).toBe(4.3); // Allowed tools (user tier)
 
-      const server1Rule = rules.find((r) => r.toolName === 'mcp_server1_*');
+      const server1Rule = rules.find((r) => r.toolName === 'server1__*');
       expect(server1Rule?.priority).toBe(4.1); // Allowed servers (user tier)
 
       const globRule = rules.find((r) => r.toolName === 'glob');

packages/cli/src/config/settingsSchema.test.ts

@@ -424,10 +424,12 @@ describe('SettingsSchema', () => {
       expect(setting).toBeDefined();
       expect(setting.type).toBe('boolean');
       expect(setting.category).toBe('Experimental');
-      expect(setting.default).toBe(true);
+      expect(setting.default).toBe(false);
       expect(setting.requiresRestart).toBe(true);
       expect(setting.showInDialog).toBe(true);
-      expect(setting.description).toBe('Enable Plan Mode.');
+      expect(setting.description).toBe(
+        'Enable planning features (Plan Mode and tools).',
+      );
     });
 
     it('should have hooksConfig.notifications setting in schema', () => {

packages/cli/src/config/settingsSchema.ts

@@ -1802,8 +1802,8 @@ const SETTINGS_SCHEMA = {
         label: 'Plan',
         category: 'Experimental',
         requiresRestart: true,
-        default: true,
-        description: 'Enable Plan Mode.',
+        default: false,
+        description: 'Enable planning features (Plan Mode and tools).',
         showInDialog: true,
       },
       modelSteering: {

packages/cli/src/gemini.test.tsx

@@ -483,6 +483,7 @@ describe('gemini.tsx main function kitty protocol', () => {
       policy: undefined,
       allowedMcpServerNames: undefined,
       allowedTools: undefined,
+      acp: undefined,
       experimentalAcp: undefined,
       extensions: undefined,
       listExtensions: undefined,
@@ -544,6 +545,7 @@ describe('gemini.tsx main function kitty protocol', () => {
       getQuestion: () => '',
       getSandbox: () => undefined,
       getListExtensions: () => flag === 'listExtensions',
+      getAcpMode: () => false,
       getListSessions: () => flag === 'listSessions',
       getDeleteSession: () => (flag === 'deleteSession' ? value : undefined),
       getExtensions: () => [
@@ -618,6 +620,7 @@ describe('gemini.tsx main function kitty protocol', () => {
     const mockConfig = createMockConfig({
       isInteractive: () => false,
       getQuestion: () => '',
+      getAcpMode: () => false,
       getSandbox: () => ({ command: 'docker', image: 'test-image' }),
     });
 
@@ -728,6 +731,7 @@ describe('gemini.tsx main function kitty protocol', () => {
       createMockConfig({
         isInteractive: () => true,
         getQuestion: () => '',
+        getAcpMode: () => false,
         getSandbox: () => undefined,
       }),
     );
@@ -779,6 +783,7 @@ describe('gemini.tsx main function kitty protocol', () => {
       createMockConfig({
         isInteractive: () => false,
         getQuestion: () => 'test',
+        getAcpMode: () => false,
         getSandbox: () => undefined,
       }),
     );

packages/cli/src/gemini_cleanup.test.tsx

@@ -69,6 +69,7 @@ vi.mock('./config/config.js', () => ({
     getSandbox: vi.fn(() => false),
     getQuestion: vi.fn(() => ''),
     isInteractive: () => false,
+    getAcpMode: vi.fn(() => false),
     storage: { initialize: vi.fn().mockResolvedValue(undefined) },
   } as unknown as Config),
   parseArguments: vi.fn().mockResolvedValue({}),
@@ -141,8 +142,8 @@ vi.mock('./utils/cleanup.js', async (importOriginal) => {
   };
 });
 
-vi.mock('./zed-integration/zedIntegration.js', () => ({
-  runZedIntegration: vi.fn().mockResolvedValue(undefined),
+vi.mock('./acp/acpClient.js', () => ({
+  runAcpClient: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock('./utils/readStdin.js', () => ({
@@ -179,7 +180,7 @@ describe('gemini.tsx main function cleanup', () => {
     vi.restoreAllMocks();
   });
 
-  it.skip('should log error when cleanupExpiredSessions fails', async () => {
+  it('should log error when cleanupExpiredSessions fails', async () => {
     const { loadCliConfig, parseArguments } = await import(
       './config/config.js'
     );
@@ -216,7 +217,7 @@ describe('gemini.tsx main function cleanup', () => {
       getMcpServers: () => ({}),
       getMcpClientManager: vi.fn(),
       getIdeMode: vi.fn(() => false),
-      getAcpMode: vi.fn(() => true),
+      getExperimentalZedIntegration: vi.fn(() => true),
       getScreenReader: vi.fn(() => false),
       getGeminiMdFileCount: vi.fn(() => 0),
       getProjectRoot: vi.fn(() => '/'),

packages/cli/src/services/BuiltinCommandLoader.test.ts

@@ -129,7 +129,7 @@ describe('BuiltinCommandLoader', () => {
     vi.clearAllMocks();
     mockConfig = {
       getFolderTrust: vi.fn().mockReturnValue(true),
-      isPlanEnabled: vi.fn().mockReturnValue(true),
+      isPlanEnabled: vi.fn().mockReturnValue(false),
       getEnableExtensionReloading: () => false,
       getEnableHooks: () => false,
       getEnableHooksUI: () => false,
@@ -287,7 +287,7 @@ describe('BuiltinCommandLoader profile', () => {
     vi.resetModules();
     mockConfig = {
       getFolderTrust: vi.fn().mockReturnValue(false),
-      isPlanEnabled: vi.fn().mockReturnValue(true),
+      isPlanEnabled: vi.fn().mockReturnValue(false),
       getCheckpointingEnabled: () => false,
       getEnableExtensionReloading: () => false,
       getEnableHooks: () => false,

packages/cli/src/test-utils/mockConfig.ts

@@ -42,9 +42,10 @@ export const createMockConfig = (overrides: Partial<Config> = {}): Config =>
     setSessionId: vi.fn(),
     getSessionId: vi.fn().mockReturnValue('mock-session-id'),
     getContentGeneratorConfig: vi.fn(() => ({ authType: 'google' })),
-    getAcpMode: vi.fn(() => false),
+    getExperimentalZedIntegration: vi.fn(() => false),
     isBrowserLaunchSuppressed: vi.fn(() => false),
     setRemoteAdminSettings: vi.fn(),
+    getAcpMode: vi.fn(() => false),
     isYoloModeDisabled: vi.fn(() => false),
     isPlanEnabled: vi.fn(() => false),
     getPlanModeRoutingEnabled: vi.fn().mockResolvedValue(true),

packages/cli/src/ui/AppContainer.test.tsx

@@ -2544,6 +2544,136 @@ describe('AppContainer State Management', () => {
     });
   });
 
+  describe('Expansion Persistence', () => {
+    let rerender: () => void;
+    let unmount: () => void;
+    let stdin: ReturnType<typeof render>['stdin'];
+
+    const setupExpansionPersistenceTest = async (
+      HighPriorityChild?: React.FC,
+    ) => {
+      const getTree = () => (
+        <SettingsContext.Provider value={mockSettings}>
+          <KeypressProvider config={mockConfig}>
+            <OverflowProvider>
+              <AppContainer
+                config={mockConfig}
+                version="1.0.0"
+                initializationResult={mockInitResult}
+              />
+              {HighPriorityChild && <HighPriorityChild />}
+            </OverflowProvider>
+          </KeypressProvider>
+        </SettingsContext.Provider>
+      );
+
+      const renderResult = render(getTree());
+      stdin = renderResult.stdin;
+      await act(async () => {
+        vi.advanceTimersByTime(100);
+      });
+      rerender = () => renderResult.rerender(getTree());
+      unmount = () => renderResult.unmount();
+    };
+
+    const writeStdin = async (sequence: string) => {
+      await act(async () => {
+        stdin.write(sequence);
+        // Advance timers to allow escape sequence parsing and broadcasting
+        vi.advanceTimersByTime(100);
+      });
+      rerender();
+    };
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      vi.restoreAllMocks();
+    });
+
+    it('should reset expansion when a key is NOT handled by anyone', async () => {
+      await setupExpansionPersistenceTest();
+
+      // Expand first
+      act(() => capturedUIActions.setConstrainHeight(false));
+      rerender();
+      expect(capturedUIState.constrainHeight).toBe(false);
+
+      // Press a random key that no one handles (hits Low priority fallback)
+      await writeStdin('x');
+
+      // Should be reset to true (collapsed)
+      expect(capturedUIState.constrainHeight).toBe(true);
+
+      unmount();
+    });
+
+    it('should toggle expansion when Ctrl+O is pressed', async () => {
+      await setupExpansionPersistenceTest();
+
+      // Initial state is collapsed
+      expect(capturedUIState.constrainHeight).toBe(true);
+
+      // Press Ctrl+O to expand (Ctrl+O is sequence \x0f)
+      await writeStdin('\x0f');
+      expect(capturedUIState.constrainHeight).toBe(false);
+
+      // Press Ctrl+O again to collapse
+      await writeStdin('\x0f');
+      expect(capturedUIState.constrainHeight).toBe(true);
+
+      unmount();
+    });
+
+    it('should NOT collapse when a high-priority component handles the key (e.g., up/down arrows)', async () => {
+      const NavigationHandler = () => {
+        // use real useKeypress
+        useKeypress(
+          (key: Key) => {
+            if (key.name === 'up' || key.name === 'down') {
+              return true; // Handle navigation
+            }
+            return false;
+          },
+          { isActive: true, priority: true }, // High priority
+        );
+        return null;
+      };
+
+      await setupExpansionPersistenceTest(NavigationHandler);
+
+      // Expand first
+      act(() => capturedUIActions.setConstrainHeight(false));
+      rerender();
+      expect(capturedUIState.constrainHeight).toBe(false);
+
+      // 1. Simulate Up arrow (handled by high priority child)
+      // CSI A is Up arrow
+      await writeStdin('\u001b[A');
+
+      // Should STILL be expanded
+      expect(capturedUIState.constrainHeight).toBe(false);
+
+      // 2. Simulate Down arrow (handled by high priority child)
+      // CSI B is Down arrow
+      await writeStdin('\u001b[B');
+
+      // Should STILL be expanded
+      expect(capturedUIState.constrainHeight).toBe(false);
+
+      // 3. Sanity check: press an unhandled key
+      await writeStdin('x');
+
+      // Should finally collapse
+      expect(capturedUIState.constrainHeight).toBe(true);
+
+      unmount();
+    });
+  });
+
   describe('Shortcuts Help Visibility', () => {
     let handleGlobalKeypress: (key: Key) => boolean;
     let mockedUseKeypress: Mock;

packages/cli/src/ui/AppContainer.tsx

@@ -1382,7 +1382,11 @@ Logging in with Google... Restarting Gemini CLI to continue.
   // Compute available terminal height based on controls measurement
   const availableTerminalHeight = Math.max(
     0,
-    terminalHeight - controlsHeight - backgroundShellHeight - 1,
+    terminalHeight -
+      controlsHeight -
+      staticExtraHeight -
+      2 -
+      backgroundShellHeight,
   );
 
   config.setShellExecutionConfig({
@@ -1869,7 +1873,10 @@ Logging in with Google... Restarting Gemini CLI to continue.
     ],
   );
 
-  useKeypress(handleGlobalKeypress, { isActive: true, priority: true });
+  useKeypress(handleGlobalKeypress, {
+    isActive: true,
+    priority: KeypressPriority.Low,
+  });
 
   useKeypress(
     () => {

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

@@ -14,9 +14,7 @@ import {
   coreEvents,
   processSingleFileContent,
   type ProcessedFileReadResult,
-  readFileWithEncoding,
 } from '@google/gemini-cli-core';
-import { copyToClipboard } from '../utils/commandUtils.js';
 
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
   const actual =
@@ -27,7 +25,6 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
       emitFeedback: vi.fn(),
     },
     processSingleFileContent: vi.fn(),
-    readFileWithEncoding: vi.fn(),
     partToString: vi.fn((val) => val),
   };
 });
@@ -38,14 +35,9 @@ vi.mock('node:path', async (importOriginal) => {
     ...actual,
     default: { ...actual },
     join: vi.fn((...args) => args.join('/')),
-    basename: vi.fn((p) => p.split('/').pop()),
   };
 });
 
-vi.mock('../utils/commandUtils.js', () => ({
-  copyToClipboard: vi.fn(),
-}));
-
 describe('planCommand', () => {
   let mockContext: CommandContext;
 
@@ -123,46 +115,4 @@ describe('planCommand', () => {
       text: '# Approved Plan Content',
     });
   });
-
-  describe('copy subcommand', () => {
-    it('should copy the approved plan to clipboard', async () => {
-      const mockPlanPath = '/mock/plans/dir/approved-plan.md';
-      vi.mocked(
-        mockContext.services.config!.getApprovedPlanPath,
-      ).mockReturnValue(mockPlanPath);
-      vi.mocked(readFileWithEncoding).mockResolvedValue('# Plan Content');
-
-      const copySubCommand = planCommand.subCommands?.find(
-        (sc) => sc.name === 'copy',
-      );
-      if (!copySubCommand?.action) throw new Error('Copy action missing');
-
-      await copySubCommand.action(mockContext, '');
-
-      expect(readFileWithEncoding).toHaveBeenCalledWith(mockPlanPath);
-      expect(copyToClipboard).toHaveBeenCalledWith('# Plan Content');
-      expect(coreEvents.emitFeedback).toHaveBeenCalledWith(
-        'info',
-        'Plan copied to clipboard (approved-plan.md).',
-      );
-    });
-
-    it('should warn if no approved plan is found', async () => {
-      vi.mocked(
-        mockContext.services.config!.getApprovedPlanPath,
-      ).mockReturnValue(undefined);
-
-      const copySubCommand = planCommand.subCommands?.find(
-        (sc) => sc.name === 'copy',
-      );
-      if (!copySubCommand?.action) throw new Error('Copy action missing');
-
-      await copySubCommand.action(mockContext, '');
-
-      expect(coreEvents.emitFeedback).toHaveBeenCalledWith(
-        'warning',
-        'No approved plan found to copy.',
-      );
-    });
-  });
 });

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

@@ -4,54 +4,22 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {
-  type CommandContext,
-  CommandKind,
-  type SlashCommand,
-} from './types.js';
+import { CommandKind, type SlashCommand } from './types.js';
 import {
   ApprovalMode,
   coreEvents,
   debugLogger,
   processSingleFileContent,
   partToString,
-  readFileWithEncoding,
 } from '@google/gemini-cli-core';
 import { MessageType } from '../types.js';
 import * as path from 'node:path';
-import { copyToClipboard } from '../utils/commandUtils.js';
-
-async function copyAction(context: CommandContext) {
-  const config = context.services.config;
-  if (!config) {
-    debugLogger.debug('Plan copy command: config is not available in context');
-    return;
-  }
-
-  const planPath = config.getApprovedPlanPath();
-
-  if (!planPath) {
-    coreEvents.emitFeedback('warning', 'No approved plan found to copy.');
-    return;
-  }
-
-  try {
-    const content = await readFileWithEncoding(planPath);
-    await copyToClipboard(content);
-    coreEvents.emitFeedback(
-      'info',
-      `Plan copied to clipboard (${path.basename(planPath)}).`,
-    );
-  } catch (error) {
-    coreEvents.emitFeedback('error', `Failed to copy plan: ${error}`, error);
-  }
-}
 
 export const planCommand: SlashCommand = {
   name: 'plan',
   description: 'Switch to Plan Mode and view current plan',
   kind: CommandKind.BUILT_IN,
-  autoExecute: false,
+  autoExecute: true,
   action: async (context) => {
     const config = context.services.config;
     if (!config) {
@@ -94,13 +62,4 @@ export const planCommand: SlashCommand = {
       );
     }
   },
-  subCommands: [
-    {
-      name: 'copy',
-      description: 'Copy the currently approved plan to your clipboard',
-      kind: CommandKind.BUILT_IN,
-      autoExecute: true,
-      action: copyAction,
-    },
-  ],
 };

packages/cli/src/ui/components/AskUserDialog.tsx

@@ -786,21 +786,16 @@ const ChoiceQuestionView: React.FC<ChoiceQuestionViewProps> = ({
   const TITLE_MARGIN = 1;
   const FOOTER_HEIGHT = 2; // DialogFooter + margin
   const overhead = HEADER_HEIGHT + TITLE_MARGIN + FOOTER_HEIGHT;
-
   const listHeight = availableHeight
     ? Math.max(1, availableHeight - overhead)
     : undefined;
-
-  const questionHeightLimit =
+  const questionHeight =
     listHeight && !isAlternateBuffer
-      ? question.unconstrainedHeight
-        ? Math.max(1, listHeight - selectionItems.length * 2)
-        : Math.min(15, Math.max(1, listHeight - DIALOG_PADDING))
+      ? Math.min(15, Math.max(1, listHeight - DIALOG_PADDING))
       : undefined;
-
   const maxItemsToShow =
-    listHeight && questionHeightLimit
-      ? Math.max(1, Math.floor((listHeight - questionHeightLimit) / 2))
+    listHeight && questionHeight
+      ? Math.max(1, Math.floor((listHeight - questionHeight) / 2))
       : selectionItems.length;
 
   return (
@@ -808,7 +803,7 @@ const ChoiceQuestionView: React.FC<ChoiceQuestionViewProps> = ({
       {progressHeader}
       <Box marginBottom={TITLE_MARGIN}>
         <MaxSizedBox
-          maxHeight={questionHeightLimit}
+          maxHeight={questionHeight}
           maxWidth={availableWidth}
           overflowDirection="bottom"
         >

packages/cli/src/ui/components/Composer.test.tsx

@@ -231,7 +231,7 @@ const createMockConfig = (overrides = {}): Config =>
     getDebugMode: vi.fn(() => false),
     getAccessibility: vi.fn(() => ({})),
     getMcpServers: vi.fn(() => ({})),
-    isPlanEnabled: vi.fn(() => true),
+    isPlanEnabled: vi.fn(() => false),
     getToolRegistry: () => ({
       getTool: vi.fn(),
     }),

packages/cli/src/ui/components/ExitPlanModeDialog.tsx

@@ -247,7 +247,6 @@ export const ExitPlanModeDialog: React.FC<ExitPlanModeDialogProps> = ({
             ],
             placeholder: 'Type your feedback...',
             multiSelect: false,
-            unconstrainedHeight: false,
           },
         ]}
         onSubmit={(answers) => {

packages/cli/src/ui/components/ToolConfirmationQueue.test.tsx

@@ -282,10 +282,7 @@ describe('ToolConfirmationQueue', () => {
     // hideToolIdentity is true for ask_user -> subtracts 4 instead of 6
     // availableContentHeight = 19 - 4 = 15
     // ToolConfirmationMessage handlesOwnUI=true -> returns full 15
-    // AskUserDialog allocates questionHeight = availableHeight - overhead - DIALOG_PADDING.
-    // listHeight = 15 - overhead (Header:0, Margin:1, Footer:2) = 12.
-    // maxQuestionHeight = listHeight - 4 = 8.
-    // 8 lines is enough for the 6-line question.
+    // AskUserDialog uses 15 lines to render its multi-line question and options.
     await waitFor(() => {
       expect(lastFrame()).toContain('Line 6');
       expect(lastFrame()).not.toContain('lines hidden');

packages/cli/src/ui/components/UserIdentity.test.tsx

@@ -47,7 +47,6 @@ describe('<UserIdentity />', () => {
     const output = lastFrame();
     expect(output).toContain('test@example.com');
     expect(output).toContain('/auth');
-    expect(output).not.toContain('/upgrade');
     unmount();
   });
 
@@ -75,7 +74,6 @@ describe('<UserIdentity />', () => {
     const output = lastFrame();
     expect(output).toContain('Logged in with Google');
     expect(output).toContain('/auth');
-    expect(output).not.toContain('/upgrade');
     unmount();
   });
 
@@ -132,26 +130,6 @@ describe('<UserIdentity />', () => {
     const output = lastFrame();
     expect(output).toContain(`Authenticated with ${AuthType.USE_GEMINI}`);
     expect(output).toContain('/auth');
-    expect(output).not.toContain('/upgrade');
-    unmount();
-  });
-
-  it('should render specific tier name when provided', async () => {
-    const mockConfig = makeFakeConfig();
-    vi.spyOn(mockConfig, 'getContentGeneratorConfig').mockReturnValue({
-      authType: AuthType.LOGIN_WITH_GOOGLE,
-      model: 'gemini-pro',
-    } as unknown as ContentGeneratorConfig);
-    vi.spyOn(mockConfig, 'getUserTierName').mockReturnValue('Enterprise Tier');
-
-    const { lastFrame, waitUntilReady, unmount } = renderWithProviders(
-      <UserIdentity config={mockConfig} />,
-    );
-    await waitUntilReady();
-
-    const output = lastFrame();
-    expect(output).toContain('Enterprise Tier');
-    expect(output).toContain('/upgrade');
     unmount();
   });
 });

packages/cli/src/ui/components/UserIdentity.tsx

@@ -53,14 +53,12 @@ export const UserIdentity: React.FC<UserIdentityProps> = ({ config }) => {
       </Box>
 
       {/* Tier Name /upgrade */}
-      {tierName && (
-        <Box>
-          <Text color={theme.text.primary} wrap="truncate-end">
-            {tierName}
-          </Text>
-          <Text color={theme.text.secondary}> /upgrade</Text>
-        </Box>
-      )}
+      <Box>
+        <Text color={theme.text.primary} wrap="truncate-end">
+          {tierName ?? 'Gemini Code Assist for individuals'}
+        </Text>
+        <Text color={theme.text.secondary}> /upgrade</Text>
+      </Box>
     </Box>
   );
 };

packages/cli/src/ui/hooks/creditsFlowHandler.ts

@@ -110,6 +110,7 @@ async function handleOverageMenu(
     isDialogPending,
     setOverageMenuRequest,
     setModelSwitchedFromQuotaError,
+    historyManager,
   } = args;
 
   logBillingEvent(
@@ -154,6 +155,13 @@ async function handleOverageMenu(
       setModelSwitchedFromQuotaError(false);
       config.setQuotaErrorOccurred(false);
       config.setOverageStrategy('always');
+      historyManager.addItem(
+        {
+          type: MessageType.INFO,
+          text: `Using AI Credits for this request.`,
+        },
+        Date.now(),
+      );
       return 'retry_with_credits';
 
     case 'use_fallback':

packages/cli/src/ui/hooks/useApprovalModeIndicator.test.ts

@@ -86,7 +86,7 @@ describe('useApprovalModeIndicator', () => {
           (value: ApprovalMode) => void
         >,
         isYoloModeDisabled: vi.fn().mockReturnValue(false),
-        isPlanEnabled: vi.fn().mockReturnValue(true),
+        isPlanEnabled: vi.fn().mockReturnValue(false),
         isTrustedFolder: vi.fn().mockReturnValue(true) as Mock<() => boolean>,
         getCoreTools: vi.fn().mockReturnValue([]) as Mock<() => string[]>,
         getToolDiscoveryCommand: vi.fn().mockReturnValue(undefined) as Mock<

packages/cli/src/ui/hooks/useGeminiStream.test.tsx

@@ -271,7 +271,6 @@ describe('useGeminiStream', () => {
     addHistory: vi.fn(),
     getSessionId: vi.fn(() => 'test-session-id'),
     setQuotaErrorOccurred: vi.fn(),
-    resetBillingTurnState: vi.fn(),
     getQuotaErrorOccurred: vi.fn(() => false),
     getModel: vi.fn(() => 'gemini-2.5-pro'),
     getContentGeneratorConfig: vi.fn(() => ({

packages/cli/src/ui/hooks/useGeminiStream.ts

@@ -1036,6 +1036,10 @@ export const useGeminiStream = (
           'Response stopped due to prohibited image content.',
         [FinishReason.NO_IMAGE]:
           'Response stopped because no image was generated.',
+        [FinishReason.IMAGE_RECITATION]:
+          'Response stopped due to image recitation policy.',
+        [FinishReason.IMAGE_OTHER]:
+          'Response stopped due to other image-related reasons.',
       };
 
       const message = finishReasonMessages[finishReason];
@@ -1370,9 +1374,6 @@ export const useGeminiStream = (
           if (!options?.isContinuation) {
             setModelSwitchedFromQuotaError(false);
             config.setQuotaErrorOccurred(false);
-            config.resetBillingTurnState(
-              settings.merged.billing?.overageStrategy,
-            );
             suppressedToolErrorCountRef.current = 0;
             suppressedToolErrorNoteShownRef.current = false;
             lowVerbosityFailureNoteShownRef.current = false;
@@ -1533,7 +1534,6 @@ export const useGeminiStream = (
       setThought,
       maybeAddSuppressedToolErrorNote,
       maybeAddLowVerbosityFailureNote,
-      settings.merged.billing?.overageStrategy,
     ],
   );
 

packages/cli/src/ui/hooks/useQuotaAndFallback.ts

@@ -67,6 +67,14 @@ export function useQuotaAndFallback({
   const isDialogPending = useRef(false);
   const isValidationPending = useRef(false);
 
+  // Initial overage strategy from settings; runtime value read from config at call time.
+  const initialOverageStrategy =
+    (settings.merged.billing?.overageStrategy as
+      | 'ask'
+      | 'always'
+      | 'never'
+      | undefined) ?? 'ask';
+
   // Set up Flash fallback handler
   useEffect(() => {
     const fallbackHandler: FallbackModelHandler = async (
@@ -101,7 +109,9 @@ export function useQuotaAndFallback({
             ? getResetTimeMessage(error.retryDelayMs)
             : undefined;
 
-          const overageStrategy = config.getBillingSettings().overageStrategy;
+          const overageStrategy =
+            config.getBillingSettings().overageStrategy ??
+            initialOverageStrategy;
 
           const creditsResult = await handleCreditsFlow({
             config,
@@ -199,6 +209,7 @@ export function useQuotaAndFallback({
     userTier,
     paidTier,
     settings,
+    initialOverageStrategy,
     setModelSwitchedFromQuotaError,
     onShowAuthSelection,
     errorVerbosity,

packages/cli/src/ui/utils/textUtils.ts

@@ -126,10 +126,9 @@ export function stripUnsafeCharacters(str: string): string {
   // C1: 0x80-0x9F
   // BiDi: U+200E (LRM), U+200F (RLM), U+202A-U+202E, U+2066-U+2069
   // Zero-width: U+200B (ZWSP), U+FEFF (BOM)
-  // U+0602: ARABIC FOOTNOTE MARKER (can crash string-width)
   return strippedVT.replace(
     // eslint-disable-next-line no-control-regex
-    /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\x9F\u200E\u200F\u202A-\u202E\u2066-\u2069\u200B\uFEFF\u0602]/g,
+    /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\x9F\u200E\u200F\u202A-\u202E\u2066-\u2069\u200B\uFEFF]/g,
     '',
   );
 }
@@ -188,7 +187,7 @@ export const getCachedStringWidth = (str: string): number => {
   } catch {
     // Fallback for characters that cause string-width to crash (e.g. U+0602)
     // See: https://github.com/google-gemini/gemini-cli/issues/16418
-    width = toCodePoints(stripUnsafeCharacters(str)).length;
+    width = toCodePoints(stripAnsi(str)).length;
   }
 
   stringWidthCache.set(str, width);

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-core",
-  "version": "0.33.0",
+  "version": "0.33.0-nightly.20260228.1ca5c05d0",
   "description": "Gemini CLI Core",
   "license": "Apache-2.0",
   "repository": {
@@ -25,8 +25,7 @@
     "@google-cloud/logging": "^11.2.1",
     "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",
     "@google-cloud/opentelemetry-cloud-trace-exporter": "^3.0.0",
-    "@google/genai": "1.30.0",
-    "@grpc/grpc-js": "^1.14.3",
+    "@google/genai": "1.41.0",
     "@iarna/toml": "^2.2.5",
     "@joshua.litt/get-ripgrep": "^0.0.3",
     "@modelcontextprotocol/sdk": "^1.23.0",
@@ -60,7 +59,7 @@
     "fdir": "^6.4.6",
     "fzf": "^0.5.2",
     "glob": "^12.0.0",
-    "google-auth-library": "^9.11.0",
+    "google-auth-library": "^10.5.0",
     "html-to-text": "^9.0.5",
     "https-proxy-agent": "^7.0.6",
     "ignore": "^7.0.0",

packages/core/src/agents/local-executor.test.ts

@@ -17,7 +17,10 @@ import { debugLogger } from '../utils/debugLogger.js';
 import { LocalAgentExecutor, type ActivityCallback } from './local-executor.js';
 import { makeFakeConfig } from '../test-utils/config.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
-import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
+import {
+  DiscoveredMCPTool,
+  MCP_QUALIFIED_NAME_SEPARATOR,
+} from '../tools/mcp-tool.js';
 import { LSTool } from '../tools/ls.js';
 import { LS_TOOL_NAME, READ_FILE_TOOL_NAME } from '../tools/tool-names.js';
 import {
@@ -501,7 +504,7 @@ describe('LocalAgentExecutor', () => {
     it('should automatically qualify MCP tools in agent definitions', async () => {
       const serverName = 'mcp-server';
       const toolName = 'mcp-tool';
-      const qualifiedName = `mcp_${serverName}_${toolName}`;
+      const qualifiedName = `${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${toolName}`;
 
       const mockMcpTool = {
         tool: vi.fn(),

packages/core/src/availability/policyHelpers.test.ts

@@ -20,21 +20,14 @@ import {
 } from '../config/models.js';
 import { AuthType } from '../core/contentGenerator.js';
 
-const createMockConfig = (overrides: Partial<Config> = {}): Config => {
-  const config = {
+const createMockConfig = (overrides: Partial<Config> = {}): Config =>
+  ({
     getUserTier: () => undefined,
     getModel: () => 'gemini-2.5-pro',
     getGemini31LaunchedSync: () => false,
-    getUseCustomToolModelSync: () => {
-      const useGemini31 = config.getGemini31LaunchedSync();
-      const authType = config.getContentGeneratorConfig().authType;
-      return useGemini31 && authType === AuthType.USE_GEMINI;
-    },
     getContentGeneratorConfig: () => ({ authType: undefined }),
     ...overrides,
-  } as unknown as Config;
-  return config;
-};
+  }) as unknown as Config;
 
 describe('policyHelpers', () => {
   describe('resolvePolicyChain', () => {

packages/core/src/availability/policyHelpers.ts

@@ -6,6 +6,7 @@
 
 import type { GenerateContentConfig } from '@google/genai';
 import type { Config } from '../config/config.js';
+import { AuthType } from '../core/contentGenerator.js';
 import type {
   FailureKind,
   FallbackAction,
@@ -45,7 +46,9 @@ export function resolvePolicyChain(
 
   let chain;
   const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
-  const useCustomToolModel = config.getUseCustomToolModelSync?.() ?? false;
+  const useCustomToolModel =
+    useGemini31 &&
+    config.getContentGeneratorConfig?.()?.authType === AuthType.USE_GEMINI;
 
   const resolvedModel = resolveModel(
     modelFromConfig,

packages/core/src/billing/billing.test.ts

@@ -229,14 +229,14 @@ describe('billing', () => {
       expect(isOverageEligibleModel('gemini-3.1-pro-preview')).toBe(true);
     });
 
-    it('should return false for gemini-3.1-pro-preview-customtools', () => {
+    it('should return true for gemini-3.1-pro-preview-customtools', () => {
       expect(isOverageEligibleModel('gemini-3.1-pro-preview-customtools')).toBe(
         false,
       );
     });
 
-    it('should return true for gemini-3-flash-preview', () => {
-      expect(isOverageEligibleModel('gemini-3-flash-preview')).toBe(true);
+    it('should return false for gemini-3-flash-preview', () => {
+      expect(isOverageEligibleModel('gemini-3-flash-preview')).toBe(false);
     });
 
     it('should return false for gemini-2.5-pro', () => {

packages/core/src/billing/billing.ts

@@ -12,7 +12,6 @@ import type {
 import {
   PREVIEW_GEMINI_MODEL,
   PREVIEW_GEMINI_3_1_MODEL,
-  PREVIEW_GEMINI_FLASH_MODEL,
 } from '../config/models.js';
 
 /**
@@ -33,7 +32,6 @@ export const G1_CREDIT_TYPE: CreditType = 'GOOGLE_ONE_AI';
 export const OVERAGE_ELIGIBLE_MODELS = new Set([
   PREVIEW_GEMINI_MODEL,
   PREVIEW_GEMINI_3_1_MODEL,
-  PREVIEW_GEMINI_FLASH_MODEL,
 ]);
 
 /**

packages/core/src/code_assist/oauth2.test.ts

@@ -95,8 +95,7 @@ const mockConfig = {
   getNoBrowser: () => false,
   getProxy: () => 'http://test.proxy.com:8080',
   isBrowserLaunchSuppressed: () => false,
-  getAcpMode: () => false,
-  isInteractive: () => true,
+  getExperimentalZedIntegration: () => false,
 } as unknown as Config;
 
 // Mock fetch globally

packages/core/src/code_assist/server.ts

@@ -47,9 +47,7 @@ import {
   isOverageEligibleModel,
   shouldAutoUseCredits,
 } from '../billing/billing.js';
-
 import { logBillingEvent } from '../telemetry/loggers.js';
-import { coreEvents } from '../utils/events.js';
 import { CreditsUsedEvent } from '../telemetry/billingEvents.js';
 import type {
   CaCountTokenResponse,
@@ -104,11 +102,6 @@ export class CodeAssistServer implements ContentGenerator {
     const modelIsEligible = isOverageEligibleModel(req.model);
     const shouldEnableCredits = modelIsEligible && autoUse;
 
-    if (shouldEnableCredits && !this.config?.getCreditsNotificationShown()) {
-      this.config?.setCreditsNotificationShown(true);
-      coreEvents.emitFeedback('info', 'Using AI Credits for this request.');
-    }
-
     const enabledCreditTypes = shouldEnableCredits
       ? ([G1_CREDIT_TYPE] as string[])
       : undefined;

packages/core/src/config/config.test.ts

@@ -500,8 +500,6 @@ describe('Server Config (config.ts)', () => {
         config,
         authType,
         undefined,
-        undefined,
-        undefined,
       );
       // Verify that contentGeneratorConfig is updated
       expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
@@ -2397,65 +2395,6 @@ describe('Availability Service Integration', () => {
     config.resetTurn();
     expect(spy).toHaveBeenCalled();
   });
-
-  it('resetTurn does NOT reset billing state', () => {
-    const config = new Config({
-      ...baseParams,
-      billing: { overageStrategy: 'ask' },
-    });
-
-    // Simulate accepting credits mid-turn
-    config.setOverageStrategy('always');
-    config.setCreditsNotificationShown(true);
-
-    // resetTurn should leave billing state intact
-    config.resetTurn();
-    expect(config.getBillingSettings().overageStrategy).toBe('always');
-    expect(config.getCreditsNotificationShown()).toBe(true);
-  });
-
-  it('resetBillingTurnState resets overageStrategy to configured value', () => {
-    const config = new Config({
-      ...baseParams,
-      billing: { overageStrategy: 'ask' },
-    });
-
-    config.setOverageStrategy('always');
-    expect(config.getBillingSettings().overageStrategy).toBe('always');
-
-    config.resetBillingTurnState('ask');
-    expect(config.getBillingSettings().overageStrategy).toBe('ask');
-  });
-
-  it('resetBillingTurnState preserves overageStrategy when configured as always', () => {
-    const config = new Config({
-      ...baseParams,
-      billing: { overageStrategy: 'always' },
-    });
-
-    config.resetBillingTurnState('always');
-    expect(config.getBillingSettings().overageStrategy).toBe('always');
-  });
-
-  it('resetBillingTurnState defaults to ask when no strategy provided', () => {
-    const config = new Config({
-      ...baseParams,
-      billing: { overageStrategy: 'always' },
-    });
-
-    config.resetBillingTurnState();
-    expect(config.getBillingSettings().overageStrategy).toBe('ask');
-  });
-
-  it('resetBillingTurnState resets creditsNotificationShown', () => {
-    const config = new Config(baseParams);
-
-    config.setCreditsNotificationShown(true);
-    expect(config.getCreditsNotificationShown()).toBe(true);
-
-    config.resetBillingTurnState();
-    expect(config.getCreditsNotificationShown()).toBe(false);
-  });
 });
 
 describe('Hooks configuration', () => {
@@ -2759,9 +2698,9 @@ describe('Config Quota & Preview Model Access', () => {
   });
 
   describe('isPlanEnabled', () => {
-    it('should return true by default', () => {
+    it('should return false by default', () => {
       const config = new Config(baseParams);
-      expect(config.isPlanEnabled()).toBe(true);
+      expect(config.isPlanEnabled()).toBe(false);
     });
 
     it('should return true when plan is enabled', () => {

packages/core/src/config/config.ts

@@ -6,6 +6,7 @@
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { inspect } from 'node:util';
 import process from 'node:process';
 import type {
@@ -134,7 +135,7 @@ import { SkillManager, type SkillDefinition } from '../skills/skillManager.js';
 import { startupProfiler } from '../telemetry/startupProfiler.js';
 import type { AgentDefinition } from '../agents/types.js';
 import { fetchAdminControls } from '../code_assist/admin/admin_controls.js';
-import { isSubpath, resolveToRealPath } from '../utils/paths.js';
+import { isSubpath } from '../utils/paths.js';
 import { UserHintService } from './userHintService.js';
 import { WORKSPACE_POLICY_TIER } from '../policy/config.js';
 import { loadPoliciesFromToml } from '../policy/toml-loader.js';
@@ -670,7 +671,6 @@ export class Config implements McpContext {
   fallbackModelHandler?: FallbackModelHandler;
   validationHandler?: ValidationHandler;
   private quotaErrorOccurred: boolean = false;
-  private creditsNotificationShown: boolean = false;
   private modelQuotas: Map<
     string,
     { remaining: number; limit: number; resetTime?: string }
@@ -869,7 +869,7 @@ export class Config implements McpContext {
     this.enableAgents = params.enableAgents ?? false;
     this.agents = params.agents ?? {};
     this.disableLLMCorrection = params.disableLLMCorrection ?? true;
-    this.planEnabled = params.plan ?? true;
+    this.planEnabled = params.plan ?? false;
     this.planModeRoutingEnabled = params.planSettings?.modelRouting ?? true;
     this.enableEventDrivenScheduler = params.enableEventDrivenScheduler ?? true;
     this.skillsSupport = params.skillsSupport ?? true;
@@ -1190,12 +1190,7 @@ export class Config implements McpContext {
     return this.contentGenerator;
   }
 
-  async refreshAuth(
-    authMethod: AuthType,
-    apiKey?: string,
-    baseUrl?: string,
-    customHeaders?: Record<string, string>,
-  ) {
+  async refreshAuth(authMethod: AuthType, apiKey?: string) {
     // Reset availability service when switching auth
     this.modelAvailabilityService.reset();
 
@@ -1222,8 +1217,6 @@ export class Config implements McpContext {
       this,
       authMethod,
       apiKey,
-      baseUrl,
-      customHeaders,
     );
     this.contentGenerator = await createContentGenerator(
       newContentGeneratorConfig,
@@ -1438,12 +1431,6 @@ export class Config implements McpContext {
     this.modelAvailabilityService.resetTurn();
   }
 
-  /** Resets billing state (overageStrategy, creditsNotificationShown) once per user prompt. */
-  resetBillingTurnState(overageStrategy?: OverageStrategy): void {
-    this.creditsNotificationShown = false;
-    this.billing.overageStrategy = overageStrategy ?? 'ask';
-  }
-
   getMaxSessionTurns(): number {
     return this.maxSessionTurns;
   }
@@ -1456,14 +1443,6 @@ export class Config implements McpContext {
     return this.quotaErrorOccurred;
   }
 
-  setCreditsNotificationShown(value: boolean): void {
-    this.creditsNotificationShown = value;
-  }
-
-  getCreditsNotificationShown(): boolean {
-    return this.creditsNotificationShown;
-  }
-
   setQuota(
     remaining: number | undefined,
     limit: number | undefined,
@@ -2359,7 +2338,17 @@ export class Config implements McpContext {
    * @returns true if the path is allowed, false otherwise.
    */
   isPathAllowed(absolutePath: string): boolean {
-    const resolvedPath = resolveToRealPath(absolutePath);
+    const realpath = (p: string) => {
+      let resolved: string;
+      try {
+        resolved = fs.realpathSync(p);
+      } catch {
+        resolved = path.resolve(p);
+      }
+      return os.platform() === 'win32' ? resolved.toLowerCase() : resolved;
+    };
+
+    const resolvedPath = realpath(absolutePath);
 
     const workspaceContext = this.getWorkspaceContext();
     if (workspaceContext.isPathWithinWorkspace(resolvedPath)) {
@@ -2367,7 +2356,7 @@ export class Config implements McpContext {
     }
 
     const projectTempDir = this.storage.getProjectTempDir();
-    const resolvedTempDir = resolveToRealPath(projectTempDir);
+    const resolvedTempDir = realpath(projectTempDir);
 
     return isSubpath(resolvedTempDir, resolvedPath);
   }
@@ -2476,26 +2465,6 @@ export class Config implements McpContext {
     return this.getGemini31LaunchedSync();
   }
 
-  /**
-   * Returns whether the custom tool model should be used.
-   */
-  async getUseCustomToolModel(): Promise<boolean> {
-    const useGemini3_1 = await this.getGemini31Launched();
-    const authType = this.contentGeneratorConfig?.authType;
-    return useGemini3_1 && authType === AuthType.USE_GEMINI;
-  }
-
-  /**
-   * Returns whether the custom tool model should be used.
-   *
-   * Note: This method should only be called after startup, once experiments have been loaded.
-   */
-  getUseCustomToolModelSync(): boolean {
-    const useGemini3_1 = this.getGemini31LaunchedSync();
-    const authType = this.contentGeneratorConfig?.authType;
-    return useGemini3_1 && authType === AuthType.USE_GEMINI;
-  }
-
   /**
    * Returns whether Gemini 3.1 has been launched.
    *

packages/core/src/config/models.ts

@@ -136,8 +136,7 @@ export function isPreviewModel(model: string): boolean {
     model === PREVIEW_GEMINI_3_1_MODEL ||
     model === PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL ||
     model === PREVIEW_GEMINI_FLASH_MODEL ||
-    model === PREVIEW_GEMINI_MODEL_AUTO ||
-    model === GEMINI_MODEL_ALIAS_AUTO
+    model === PREVIEW_GEMINI_MODEL_AUTO
   );
 }
 

packages/core/src/config/storage.test.ts

@@ -24,7 +24,7 @@ vi.mock('fs', async (importOriginal) => {
 });
 
 import { Storage } from './storage.js';
-import { GEMINI_DIR, homedir, resolveToRealPath } from '../utils/paths.js';
+import { GEMINI_DIR, homedir } from '../utils/paths.js';
 import { ProjectRegistry } from './projectRegistry.js';
 import { StorageMigration } from './storageMigration.js';
 
@@ -279,7 +279,8 @@ describe('Storage – additional helpers', () => {
         name: 'custom absolute path outside throws',
         customDir: '/absolute/path/to/plans',
         expected: '',
-        expectedError: `Custom plans directory '/absolute/path/to/plans' resolves to '/absolute/path/to/plans', which is outside the project root '${resolveToRealPath(projectRoot)}'.`,
+        expectedError:
+          "Custom plans directory '/absolute/path/to/plans' resolves to '/absolute/path/to/plans', which is outside the project root '/tmp/project'.",
       },
       {
         name: 'absolute path that happens to be inside project root',
@@ -305,7 +306,8 @@ describe('Storage – additional helpers', () => {
         name: 'escaping relative path throws',
         customDir: '../escaped-plans',
         expected: '',
-        expectedError: `Custom plans directory '../escaped-plans' resolves to '${resolveToRealPath(path.resolve(projectRoot, '../escaped-plans'))}', which is outside the project root '${resolveToRealPath(projectRoot)}'.`,
+        expectedError:
+          "Custom plans directory '../escaped-plans' resolves to '/tmp/escaped-plans', which is outside the project root '/tmp/project'.",
       },
       {
         name: 'hidden directory starting with ..',

packages/core/src/confirmation-bus/types.ts

@@ -162,8 +162,6 @@ export interface Question {
   multiSelect?: boolean;
   /** Placeholder hint text. For type='text', shown in the input field. For type='choice', shown in the "Other" custom input. */
   placeholder?: string;
-  /** Allow the question to consume more vertical space instead of being strictly capped. */
-  unconstrainedHeight?: boolean;
 }
 
 export interface AskUserRequest {

packages/core/src/core/__snapshots__/prompts.test.ts.snap

@@ -103,7 +103,7 @@ The following tools are available in Plan Mode:
   <tool>\`exit_plan_mode\`</tool>
   <tool>\`write_file\`</tool>
   <tool>\`replace\`</tool>
-  <tool>\`mcp_readonly-server_read_data\` (readonly-server)</tool>
+  <tool>\`read_data\` (readonly-server)</tool>
 </available_tools>
 
 ## Rules
@@ -271,7 +271,7 @@ The following tools are available in Plan Mode:
   <tool>\`exit_plan_mode\`</tool>
   <tool>\`write_file\`</tool>
   <tool>\`replace\`</tool>
-  <tool>\`mcp_readonly-server_read_data\` (readonly-server)</tool>
+  <tool>\`read_data\` (readonly-server)</tool>
 </available_tools>
 
 ## Rules
@@ -558,7 +558,7 @@ The following tools are available in Plan Mode:
   <tool>\`exit_plan_mode\`</tool>
   <tool>\`write_file\`</tool>
   <tool>\`replace\`</tool>
-  <tool>\`mcp_readonly-server_read_data\` (readonly-server)</tool>
+  <tool>\`read_data\` (readonly-server)</tool>
 </available_tools>
 
 ## Rules

packages/core/src/core/contentGenerator.ts

@@ -59,7 +59,6 @@ export enum AuthType {
   USE_VERTEX_AI = 'vertex-ai',
   LEGACY_CLOUD_SHELL = 'cloud-shell',
   COMPUTE_ADC = 'compute-default-credentials',
-  GATEWAY = 'gateway',
 }
 
 /**
@@ -94,16 +93,12 @@ export type ContentGeneratorConfig = {
   vertexai?: boolean;
   authType?: AuthType;
   proxy?: string;
-  baseUrl?: string;
-  customHeaders?: Record<string, string>;
 };
 
 export async function createContentGeneratorConfig(
   config: Config,
   authType: AuthType | undefined,
   apiKey?: string,
-  baseUrl?: string,
-  customHeaders?: Record<string, string>,
 ): Promise<ContentGeneratorConfig> {
   const geminiApiKey =
     apiKey ||
@@ -120,8 +115,6 @@ export async function createContentGeneratorConfig(
   const contentGeneratorConfig: ContentGeneratorConfig = {
     authType,
     proxy: config?.getProxy(),
-    baseUrl,
-    customHeaders,
   };
 
   // If we are using Google auth or we are in Cloud Shell, there is nothing else to validate for now
@@ -210,13 +203,9 @@ export async function createContentGenerator(
 
     if (
       config.authType === AuthType.USE_GEMINI ||
-      config.authType === AuthType.USE_VERTEX_AI ||
-      config.authType === AuthType.GATEWAY
+      config.authType === AuthType.USE_VERTEX_AI
     ) {
       let headers: Record<string, string> = { ...baseHeaders };
-      if (config.customHeaders) {
-        headers = { ...headers, ...config.customHeaders };
-      }
       if (gcConfig?.getUsageStatisticsEnabled()) {
         const installationManager = new InstallationManager();
         const installationId = installationManager.getInstallationId();
@@ -225,14 +214,7 @@ export async function createContentGenerator(
           'x-gemini-api-privileged-user-id': `${installationId}`,
         };
       }
-      const httpOptions: {
-        baseUrl?: string;
-        headers: Record<string, string>;
-      } = { headers };
-
-      if (config.baseUrl) {
-        httpOptions.baseUrl = config.baseUrl;
-      }
+      const httpOptions = { headers };
 
       const googleGenAI = new GoogleGenAI({
         apiKey: config.apiKey === '' ? undefined : config.apiKey,

packages/core/src/core/coreToolScheduler.ts

@@ -20,10 +20,7 @@ import { ToolErrorType } from '../tools/tool-error.js';
 import { ToolCallEvent } from '../telemetry/types.js';
 import { runInDevTraceSpan } from '../telemetry/trace.js';
 import { ToolModificationHandler } from '../scheduler/tool-modifier.js';
-import {
-  getToolSuggestion,
-  isToolCallResponseInfo,
-} from '../utils/tool-utils.js';
+import { getToolSuggestion } from '../utils/tool-utils.js';
 import type { ToolConfirmationRequest } from '../confirmation-bus/types.js';
 import { MessageBusType } from '../confirmation-bus/types.js';
 import type { MessageBus } from '../confirmation-bus/message-bus.js';
@@ -228,36 +225,32 @@ export class CoreToolScheduler {
           const durationMs = existingStartTime
             ? Date.now() - existingStartTime
             : undefined;
-          if (isToolCallResponseInfo(auxiliaryData)) {
-            return {
-              request: currentCall.request,
-              tool: toolInstance,
-              invocation,
-              status: CoreToolCallStatus.Success,
-              response: auxiliaryData,
-              durationMs,
-              outcome,
-              approvalMode,
-            } as SuccessfulToolCall;
-          }
-          throw new Error('Invalid response data for tool success');
+          return {
+            request: currentCall.request,
+            tool: toolInstance,
+            invocation,
+            status: CoreToolCallStatus.Success,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            response: auxiliaryData as ToolCallResponseInfo,
+            durationMs,
+            outcome,
+            approvalMode,
+          } as SuccessfulToolCall;
         }
         case CoreToolCallStatus.Error: {
           const durationMs = existingStartTime
             ? Date.now() - existingStartTime
             : undefined;
-          if (isToolCallResponseInfo(auxiliaryData)) {
-            return {
-              request: currentCall.request,
-              status: CoreToolCallStatus.Error,
-              tool: toolInstance,
-              response: auxiliaryData,
-              durationMs,
-              outcome,
-              approvalMode,
-            } as ErroredToolCall;
-          }
-          throw new Error('Invalid response data for tool error');
+          return {
+            request: currentCall.request,
+            status: CoreToolCallStatus.Error,
+            tool: toolInstance,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            response: auxiliaryData as ToolCallResponseInfo,
+            durationMs,
+            outcome,
+            approvalMode,
+          } as ErroredToolCall;
         }
         case CoreToolCallStatus.AwaitingApproval:
           return {
@@ -287,19 +280,6 @@ export class CoreToolScheduler {
             ? Date.now() - existingStartTime
             : undefined;
 
-          if (isToolCallResponseInfo(auxiliaryData)) {
-            return {
-              request: currentCall.request,
-              tool: toolInstance,
-              invocation,
-              status: CoreToolCallStatus.Cancelled,
-              response: auxiliaryData,
-              durationMs,
-              outcome,
-              approvalMode,
-            } as CancelledToolCall;
-          }
-
           // Preserve diff for cancelled edit operations
           let resultDisplay: ToolResultDisplay | undefined = undefined;
           if (currentCall.status === CoreToolCallStatus.AwaitingApproval) {

packages/core/src/core/loggingContentGenerator.test.ts

@@ -709,7 +709,7 @@ describe('estimateContextBreakdown', () => {
         {
           functionDeclarations: [
             {
-              name: 'mcp_myserver_search',
+              name: 'myserver__search',
               description: 'Search via MCP',
               parameters: {},
             },
@@ -747,7 +747,8 @@ describe('estimateContextBreakdown', () => {
     expect(builtinOnly.mcp_servers).toBe(0);
   });
 
-  it('should not classify tools without mcp_ prefix as MCP', () => {
+  it('should not classify tools with __ in the middle of a segment as MCP', () => {
+    // "__" at start or end (not a valid server__tool pattern) should not be MCP
     const config = {
       tools: [
         {
@@ -841,7 +842,7 @@ describe('estimateContextBreakdown', () => {
           functionDeclarations: [
             { name: 'read_file', description: 'Read', parameters: {} },
             {
-              name: 'mcp_myserver_search',
+              name: 'myserver__search',
               description: 'MCP search',
               parameters: {},
             },
@@ -857,7 +858,7 @@ describe('estimateContextBreakdown', () => {
     expect(result.history).toBeGreaterThan(0);
     // tool_calls should only contain non-MCP tools
     expect(result.tool_calls['read_file']).toBeGreaterThan(0);
-    expect(result.tool_calls['mcp_myserver_search']).toBeUndefined();
+    expect(result.tool_calls['myserver__search']).toBeUndefined();
     // MCP tokens are only in mcp_servers
     expect(result.mcp_servers).toBeGreaterThan(0);
   });
@@ -869,7 +870,7 @@ describe('estimateContextBreakdown', () => {
         parts: [
           {
             functionCall: {
-              name: 'mcp_myserver_search',
+              name: 'myserver__search',
               args: { query: 'test' },
             },
           },
@@ -880,7 +881,7 @@ describe('estimateContextBreakdown', () => {
         parts: [
           {
             functionResponse: {
-              name: 'mcp_myserver_search',
+              name: 'myserver__search',
               response: { results: [] },
             },
           },
@@ -889,7 +890,7 @@ describe('estimateContextBreakdown', () => {
     ];
     const result = estimateContextBreakdown(contents);
     // MCP tool calls should NOT appear in tool_calls
-    expect(result.tool_calls['mcp_myserver_search']).toBeUndefined();
+    expect(result.tool_calls['myserver__search']).toBeUndefined();
     // MCP call tokens should only be counted in mcp_servers
     expect(result.mcp_servers).toBeGreaterThan(0);
   });
@@ -907,7 +908,7 @@ describe('estimateContextBreakdown', () => {
           },
           {
             functionCall: {
-              name: 'mcp_myserver_search',
+              name: 'myserver__search',
               args: { q: 'hello' },
             },
           },
@@ -918,7 +919,7 @@ describe('estimateContextBreakdown', () => {
     // Non-MCP tools should be in tool_calls
     expect(result.tool_calls['read_file']).toBeGreaterThan(0);
     // MCP tools should NOT be in tool_calls
-    expect(result.tool_calls['mcp_myserver_search']).toBeUndefined();
+    expect(result.tool_calls['myserver__search']).toBeUndefined();
     // MCP tool calls should only be in mcp_servers
     expect(result.mcp_servers).toBeGreaterThan(0);
   });

packages/core/src/core/prompts.test.ts

@@ -465,13 +465,9 @@ describe('Core System Prompt (prompts.ts)', () => {
       const prompt = getCoreSystemPrompt(mockConfig);
       expect(prompt).toContain('# Active Approval Mode: Plan');
       // Read-only MCP tool should appear with server name
-      expect(prompt).toContain(
-        '`mcp_readonly-server_read_data` (readonly-server)',
-      );
+      expect(prompt).toContain('`read_data` (readonly-server)');
       // Non-read-only MCP tool should not appear (excluded by policy)
-      expect(prompt).not.toContain(
-        '`mcp_nonreadonly-server_write_data` (nonreadonly-server)',
-      );
+      expect(prompt).not.toContain('`write_data` (nonreadonly-server)');
       expect(prompt).toMatchSnapshot();
     });
 
@@ -489,12 +485,8 @@ describe('Core System Prompt (prompts.ts)', () => {
 
       const prompt = getCoreSystemPrompt(mockConfig);
 
-      expect(prompt).toContain(
-        '`mcp_readonly-server_read_data` (readonly-server)',
-      );
-      expect(prompt).not.toContain(
-        '`mcp_nonreadonly-server_write_data` (nonreadonly-server)',
-      );
+      expect(prompt).toContain('`read_data` (readonly-server)');
+      expect(prompt).not.toContain('`write_data` (nonreadonly-server)');
     });
 
     it('should only list available tools in PLAN mode', () => {

packages/core/src/policy/config.test.ts

@@ -202,7 +202,8 @@ describe('createPolicyEngineConfig', () => {
       '/tmp/mock/default/policies',
     );
     const rule = config.rules?.find(
-      (r) => r.mcpName === 'my-server' && r.decision === PolicyDecision.ALLOW,
+      (r) =>
+        r.toolName === 'my-server__*' && r.decision === PolicyDecision.ALLOW,
     );
     expect(rule).toBeDefined();
     expect(rule?.priority).toBe(4.1); // MCP allowed server
@@ -219,7 +220,8 @@ describe('createPolicyEngineConfig', () => {
       '/tmp/mock/default/policies',
     );
     const rule = config.rules?.find(
-      (r) => r.mcpName === 'my-server' && r.decision === PolicyDecision.DENY,
+      (r) =>
+        r.toolName === 'my-server__*' && r.decision === PolicyDecision.DENY,
     );
     expect(rule).toBeDefined();
     expect(rule?.priority).toBe(4.9); // MCP excluded server
@@ -245,7 +247,8 @@ describe('createPolicyEngineConfig', () => {
 
     const trustedRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'trusted-server' && r.decision === PolicyDecision.ALLOW,
+        r.toolName === 'trusted-server__*' &&
+        r.decision === PolicyDecision.ALLOW,
     );
     expect(trustedRule).toBeDefined();
     expect(trustedRule?.priority).toBe(4.2); // MCP trusted server
@@ -253,7 +256,8 @@ describe('createPolicyEngineConfig', () => {
     // Untrusted server should not have an allow rule
     const untrustedRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'untrusted-server' && r.decision === PolicyDecision.ALLOW,
+        r.toolName === 'untrusted-server__*' &&
+        r.decision === PolicyDecision.ALLOW,
     );
     expect(untrustedRule).toBeUndefined();
   });
@@ -280,7 +284,8 @@ describe('createPolicyEngineConfig', () => {
     // Check allowed server
     const allowedRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'allowed-server' && r.decision === PolicyDecision.ALLOW,
+        r.toolName === 'allowed-server__*' &&
+        r.decision === PolicyDecision.ALLOW,
     );
     expect(allowedRule).toBeDefined();
     expect(allowedRule?.priority).toBe(4.1); // MCP allowed server
@@ -288,7 +293,8 @@ describe('createPolicyEngineConfig', () => {
     // Check trusted server
     const trustedRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'trusted-server' && r.decision === PolicyDecision.ALLOW,
+        r.toolName === 'trusted-server__*' &&
+        r.decision === PolicyDecision.ALLOW,
     );
     expect(trustedRule).toBeDefined();
     expect(trustedRule?.priority).toBe(4.2); // MCP trusted server
@@ -296,7 +302,8 @@ describe('createPolicyEngineConfig', () => {
     // Check excluded server
     const excludedRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'excluded-server' && r.decision === PolicyDecision.DENY,
+        r.toolName === 'excluded-server__*' &&
+        r.decision === PolicyDecision.DENY,
     );
     expect(excludedRule).toBeDefined();
     expect(excludedRule?.priority).toBe(4.9); // MCP excluded server
@@ -361,7 +368,7 @@ describe('createPolicyEngineConfig', () => {
     const { createPolicyEngineConfig } = await import('./config.js');
     const settings: PolicySettings = {
       mcp: { excluded: ['my-server'] },
-      tools: { allowed: ['mcp_my-server_specific-tool'] },
+      tools: { allowed: ['my-server__specific-tool'] },
     };
     const config = await createPolicyEngineConfig(
       settings,
@@ -370,11 +377,12 @@ describe('createPolicyEngineConfig', () => {
     );
 
     const serverDenyRule = config.rules?.find(
-      (r) => r.mcpName === 'my-server' && r.decision === PolicyDecision.DENY,
+      (r) =>
+        r.toolName === 'my-server__*' && r.decision === PolicyDecision.DENY,
     );
     const toolAllowRule = config.rules?.find(
       (r) =>
-        r.toolName === 'mcp_my-server_specific-tool' &&
+        r.toolName === 'my-server__specific-tool' &&
         r.decision === PolicyDecision.ALLOW,
     );
 
@@ -396,7 +404,7 @@ describe('createPolicyEngineConfig', () => {
           trust: true,
         },
       },
-      tools: { exclude: ['mcp_my-server_dangerous-tool'] },
+      tools: { exclude: ['my-server__dangerous-tool'] },
     };
     const config = await createPolicyEngineConfig(
       settings,
@@ -405,11 +413,12 @@ describe('createPolicyEngineConfig', () => {
     );
 
     const serverAllowRule = config.rules?.find(
-      (r) => r.mcpName === 'my-server' && r.decision === PolicyDecision.ALLOW,
+      (r) =>
+        r.toolName === 'my-server__*' && r.decision === PolicyDecision.ALLOW,
     );
     const toolDenyRule = config.rules?.find(
       (r) =>
-        r.toolName === 'mcp_my-server_dangerous-tool' &&
+        r.toolName === 'my-server__dangerous-tool' &&
         r.decision === PolicyDecision.DENY,
     );
 
@@ -423,8 +432,8 @@ describe('createPolicyEngineConfig', () => {
   it('should handle complex priority scenarios correctly', async () => {
     const settings: PolicySettings = {
       tools: {
-        allowed: ['mcp_trusted-server_tool1', 'other-tool'], // Priority 4.3
-        exclude: ['mcp_trusted-server_tool2', 'glob'], // Priority 4.4
+        allowed: ['my-server__tool1', 'other-tool'], // Priority 4.3
+        exclude: ['my-server__tool2', 'glob'], // Priority 4.4
       },
       mcp: {
         allowed: ['allowed-server'], // Priority 4.1
@@ -555,12 +564,13 @@ describe('createPolicyEngineConfig', () => {
     // Neither server should have an allow rule
     const noTrustRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'no-trust-property' &&
+        r.toolName === 'no-trust-property__*' &&
         r.decision === PolicyDecision.ALLOW,
     );
     const explicitFalseRule = config.rules?.find(
       (r) =>
-        r.mcpName === 'explicit-false' && r.decision === PolicyDecision.ALLOW,
+        r.toolName === 'explicit-false__*' &&
+        r.decision === PolicyDecision.ALLOW,
     );
 
     expect(noTrustRule).toBeUndefined();

packages/core/src/policy/config.ts

@@ -31,7 +31,6 @@ import { debugLogger } from '../utils/debugLogger.js';
 import { SHELL_TOOL_NAMES } from '../utils/shell-utils.js';
 import { SHELL_TOOL_NAME } from '../tools/tool-names.js';
 import { isNodeError } from '../utils/errors.js';
-import { MCP_TOOL_PREFIX } from '../tools/mcp-tool.js';
 
 import { isDirectorySecure } from '../utils/security.js';
 
@@ -343,11 +342,7 @@ export async function createPolicyEngineConfig(
   if (settings.mcp?.excluded) {
     for (const serverName of settings.mcp.excluded) {
       rules.push({
-        toolName:
-          serverName === '*'
-            ? `${MCP_TOOL_PREFIX}*`
-            : `${MCP_TOOL_PREFIX}${serverName}_*`,
-        mcpName: serverName,
+        toolName: `${serverName}__*`,
         decision: PolicyDecision.DENY,
         priority: MCP_EXCLUDED_PRIORITY,
         source: 'Settings (MCP Excluded)',
@@ -428,10 +423,9 @@ export async function createPolicyEngineConfig(
     )) {
       if (serverConfig.trust) {
         // Trust all tools from this MCP server
-        // Using explicit mcpName metadata and FQN mcp_{serverName}_*
+        // Using pattern matching for MCP tool names which are formatted as "serverName__toolName"
         rules.push({
-          toolName: `${MCP_TOOL_PREFIX}${serverName}_*`,
-          mcpName: serverName,
+          toolName: `${serverName}__*`,
           decision: PolicyDecision.ALLOW,
           priority: TRUSTED_MCP_SERVER_PRIORITY,
           source: 'Settings (MCP Trusted)',
@@ -445,11 +439,7 @@ export async function createPolicyEngineConfig(
   if (settings.mcp?.allowed) {
     for (const serverName of settings.mcp.allowed) {
       rules.push({
-        toolName:
-          serverName === '*'
-            ? `${MCP_TOOL_PREFIX}*`
-            : `${MCP_TOOL_PREFIX}${serverName}_*`,
-        mcpName: serverName,
+        toolName: `${serverName}__*`,
         decision: PolicyDecision.ALLOW,
         priority: ALLOWED_MCP_SERVER_PRIORITY,
         source: 'Settings (MCP Allowed)',

packages/core/src/policy/policies/read-only.toml

@@ -51,8 +51,3 @@ priority = 50
 toolName = "google_web_search"
 decision = "allow"
 priority = 50
-
-[[rule]]
-toolName = ["codebase_investigator", "cli_help"]
-decision = "allow"
-priority = 50

packages/core/src/policy/policy-engine.test.ts

@@ -150,8 +150,7 @@ describe('PolicyEngine', () => {
     it('should match unqualified tool names with qualified rules when serverName is provided', async () => {
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_my-server_tool',
-          mcpName: 'my-server',
+          toolName: 'my-server__tool',
           decision: PolicyDecision.ALLOW,
         },
       ];
@@ -160,9 +159,23 @@ describe('PolicyEngine', () => {
 
       // Match with qualified name (standard)
       expect(
-        (await engine.check({ name: 'mcp_my-server_tool' }, 'my-server'))
-          .decision,
+        (await engine.check({ name: 'my-server__tool' }, 'my-server')).decision,
       ).toBe(PolicyDecision.ALLOW);
+
+      // Match with unqualified name + serverName (the fix)
+      expect((await engine.check({ name: 'tool' }, 'my-server')).decision).toBe(
+        PolicyDecision.ALLOW,
+      );
+
+      // Should NOT match with unqualified name but NO serverName
+      expect((await engine.check({ name: 'tool' }, undefined)).decision).toBe(
+        PolicyDecision.ASK_USER,
+      );
+
+      // Should NOT match with unqualified name but WRONG serverName
+      expect(
+        (await engine.check({ name: 'tool' }, 'wrong-server')).decision,
+      ).toBe(PolicyDecision.ASK_USER);
     });
 
     it('should match by args pattern', async () => {
@@ -333,48 +346,6 @@ describe('PolicyEngine', () => {
         PolicyDecision.ASK_USER,
       );
     });
-
-    it('should return ALLOW by default in YOLO mode when no rules match', async () => {
-      engine = new PolicyEngine({ approvalMode: ApprovalMode.YOLO });
-
-      // No rules defined, should return ALLOW in YOLO mode
-      const { decision } = await engine.check({ name: 'any-tool' }, undefined);
-      expect(decision).toBe(PolicyDecision.ALLOW);
-    });
-
-    it('should NOT override explicit DENY rules in YOLO mode', async () => {
-      const rules: PolicyRule[] = [
-        { toolName: 'dangerous-tool', decision: PolicyDecision.DENY },
-      ];
-      engine = new PolicyEngine({ rules, approvalMode: ApprovalMode.YOLO });
-
-      const { decision } = await engine.check(
-        { name: 'dangerous-tool' },
-        undefined,
-      );
-      expect(decision).toBe(PolicyDecision.DENY);
-
-      // But other tools still allowed
-      expect(
-        (await engine.check({ name: 'safe-tool' }, undefined)).decision,
-      ).toBe(PolicyDecision.ALLOW);
-    });
-
-    it('should respect rule priority in YOLO mode when a match exists', async () => {
-      const rules: PolicyRule[] = [
-        {
-          toolName: 'test-tool',
-          decision: PolicyDecision.ASK_USER,
-          priority: 10,
-        },
-        { toolName: 'test-tool', decision: PolicyDecision.DENY, priority: 20 },
-      ];
-      engine = new PolicyEngine({ rules, approvalMode: ApprovalMode.YOLO });
-
-      // Priority 20 (DENY) should win over priority 10 (ASK_USER)
-      const { decision } = await engine.check({ name: 'test-tool' }, undefined);
-      expect(decision).toBe(PolicyDecision.DENY);
-    });
   });
 
   describe('addRule', () => {
@@ -505,41 +476,61 @@ describe('PolicyEngine', () => {
         (await engine.check({ name: 'read_file' }, undefined)).decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (await engine.check({ name: 'mcp_my-server_tool' }, 'my-server'))
-          .decision,
+        (await engine.check({ name: 'my-server__tool' }, 'my-server')).decision,
       ).toBe(PolicyDecision.ALLOW);
     });
 
-    it('should match any MCP tool when toolName is mcp_*', async () => {
+    it('should match any MCP tool when toolName is *__*', async () => {
       engine = new PolicyEngine({
         rules: [
-          { toolName: 'mcp_*', decision: PolicyDecision.ALLOW, priority: 10 },
+          { toolName: '*__*', decision: PolicyDecision.ALLOW, priority: 10 },
         ],
         defaultDecision: PolicyDecision.DENY,
       });
 
+      expect((await engine.check({ name: 'mcp__tool' }, 'mcp')).decision).toBe(
+        PolicyDecision.ALLOW,
+      );
       expect(
-        (await engine.check({ name: 'mcp_mcp_tool' }, 'mcp')).decision,
-      ).toBe(PolicyDecision.ALLOW);
-      expect(
-        (await engine.check({ name: 'mcp_other_tool' }, 'other')).decision,
+        (await engine.check({ name: 'other__tool' }, 'other')).decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
         (await engine.check({ name: 'read_file' }, undefined)).decision,
       ).toBe(PolicyDecision.DENY);
     });
 
+    it('should match specific tool across all servers when using *__tool', async () => {
+      engine = new PolicyEngine({
+        rules: [
+          {
+            toolName: '*__search',
+            decision: PolicyDecision.ALLOW,
+            priority: 10,
+          },
+        ],
+        defaultDecision: PolicyDecision.DENY,
+      });
+
+      expect((await engine.check({ name: 'ws__search' }, 'ws')).decision).toBe(
+        PolicyDecision.ALLOW,
+      );
+      expect((await engine.check({ name: 'gh__search' }, 'gh')).decision).toBe(
+        PolicyDecision.ALLOW,
+      );
+      expect((await engine.check({ name: 'gh__list' }, 'gh')).decision).toBe(
+        PolicyDecision.DENY,
+      );
+    });
+
     it('should match MCP server wildcard patterns', async () => {
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_my-server_*',
-          mcpName: 'my-server',
+          toolName: 'my-server__*',
           decision: PolicyDecision.ALLOW,
           priority: 10,
         },
         {
-          toolName: 'mcp_blocked-server_*',
-          mcpName: 'blocked-server',
+          toolName: 'blocked-server__*',
           decision: PolicyDecision.DENY,
           priority: 20,
         },
@@ -549,23 +540,19 @@ describe('PolicyEngine', () => {
 
       // Should match my-server tools
       expect(
-        (await engine.check({ name: 'mcp_my-server_tool1' }, 'my-server'))
+        (await engine.check({ name: 'my-server__tool1' }, 'my-server'))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
       expect(
-        (
-          await engine.check(
-            { name: 'mcp_my-server_another_tool' },
-            'my-server',
-          )
-        ).decision,
+        (await engine.check({ name: 'my-server__another_tool' }, 'my-server'))
+          .decision,
       ).toBe(PolicyDecision.ALLOW);
 
       // Should match blocked-server tools
       expect(
         (
           await engine.check(
-            { name: 'mcp_blocked-server_tool1' },
+            { name: 'blocked-server__tool1' },
             'blocked-server',
           )
         ).decision,
@@ -573,7 +560,7 @@ describe('PolicyEngine', () => {
       expect(
         (
           await engine.check(
-            { name: 'mcp_blocked-server_dangerous' },
+            { name: 'blocked-server__dangerous' },
             'blocked-server',
           )
         ).decision,
@@ -581,7 +568,7 @@ describe('PolicyEngine', () => {
 
       // Should not match other patterns
       expect(
-        (await engine.check({ name: 'mcp_other-server_tool' }, 'other-server'))
+        (await engine.check({ name: 'other-server__tool' }, 'other-server'))
           .decision,
       ).toBe(PolicyDecision.ASK_USER);
       expect(
@@ -595,14 +582,12 @@ describe('PolicyEngine', () => {
     it('should prioritize specific tool rules over server wildcards', async () => {
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_my-server_*',
-          mcpName: 'my-server',
+          toolName: 'my-server__*',
           decision: PolicyDecision.ALLOW,
           priority: 10,
         },
         {
-          toolName: 'mcp_my-server_dangerous-tool',
-          mcpName: 'my-server',
+          toolName: 'my-server__dangerous-tool',
           decision: PolicyDecision.DENY,
           priority: 20,
         },
@@ -612,38 +597,33 @@ describe('PolicyEngine', () => {
 
       // Specific tool deny should override server allow
       expect(
-        (
-          await engine.check(
-            { name: 'mcp_my-server_dangerous-tool' },
-            'my-server',
-          )
-        ).decision,
+        (await engine.check({ name: 'my-server__dangerous-tool' }, 'my-server'))
+          .decision,
       ).toBe(PolicyDecision.DENY);
       expect(
-        (await engine.check({ name: 'mcp_my-server_safe-tool' }, 'my-server'))
+        (await engine.check({ name: 'my-server__safe-tool' }, 'my-server'))
           .decision,
       ).toBe(PolicyDecision.ALLOW);
     });
 
     it('should NOT match spoofed server names when using wildcards', async () => {
-      // Vulnerability: A rule for 'mcp_prefix_*' matches 'mcp_prefix__suffix_tool'
-      // effectively allowing a server named 'mcp_prefix_suffix' to spoof 'prefix'.
+      // Vulnerability: A rule for 'prefix__*' matches 'prefix__suffix__tool'
+      // effectively allowing a server named 'prefix__suffix' to spoof 'prefix'.
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_safe_server_*',
-          mcpName: 'safe_server',
+          toolName: 'safe_server__*',
           decision: PolicyDecision.ALLOW,
         },
       ];
       engine = new PolicyEngine({ rules });
 
-      // A tool from a different server 'mcp_safe_server_malicious'
-      const spoofedToolCall = { name: 'mcp_mcp_safe_server_malicious_tool' };
+      // A tool from a different server 'safe_server__malicious'
+      const spoofedToolCall = { name: 'safe_server__malicious__tool' };
 
       // CURRENT BEHAVIOR (FIXED): Matches because it starts with 'safe_server__' BUT serverName doesn't match 'safe_server'
       // We expect this to FAIL matching the ALLOW rule, thus falling back to default (ASK_USER)
       expect(
-        (await engine.check(spoofedToolCall, 'mcp_safe_server_malicious'))
+        (await engine.check(spoofedToolCall, 'safe_server__malicious'))
           .decision,
       ).toBe(PolicyDecision.ASK_USER);
     });
@@ -651,15 +631,14 @@ describe('PolicyEngine', () => {
     it('should verify tool name prefix even if serverName matches', async () => {
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_safe_server_*',
-          mcpName: 'safe_server',
+          toolName: 'safe_server__*',
           decision: PolicyDecision.ALLOW,
         },
       ];
       engine = new PolicyEngine({ rules });
 
       // serverName matches, but tool name does not start with prefix
-      const invalidToolCall = { name: 'mcp_other_server_tool' };
+      const invalidToolCall = { name: 'other_server__tool' };
       expect(
         (await engine.check(invalidToolCall, 'safe_server')).decision,
       ).toBe(PolicyDecision.ASK_USER);
@@ -668,14 +647,13 @@ describe('PolicyEngine', () => {
     it('should allow when both serverName and tool name prefix match', async () => {
       const rules: PolicyRule[] = [
         {
-          toolName: 'mcp_safe_server_*',
-          mcpName: 'safe_server',
+          toolName: 'safe_server__*',
           decision: PolicyDecision.ALLOW,
         },
       ];
       engine = new PolicyEngine({ rules });
 
-      const validToolCall = { name: 'mcp_safe_server_tool' };
+      const validToolCall = { name: 'safe_server__tool' };
       expect((await engine.check(validToolCall, 'safe_server')).decision).toBe(
         PolicyDecision.ALLOW,
       );
@@ -2029,16 +2007,11 @@ describe('PolicyEngine', () => {
 
     it('should support wildcard patterns for checkers', async () => {
       const rules: PolicyRule[] = [
-        {
-          toolName: 'mcp_server_tool',
-          mcpName: 'server',
-          decision: PolicyDecision.ALLOW,
-        },
+        { toolName: 'server__tool', decision: PolicyDecision.ALLOW },
       ];
       const wildcardChecker: SafetyCheckerRule = {
         checker: { type: 'external', name: 'wildcard' },
-        toolName: 'mcp_server_*',
-        mcpName: 'server',
+        toolName: 'server__*',
       };
 
       engine = new PolicyEngine(
@@ -2050,7 +2023,7 @@ describe('PolicyEngine', () => {
         decision: SafetyCheckDecision.ALLOW,
       });
 
-      await engine.check({ name: 'mcp_server_tool' }, 'server');
+      await engine.check({ name: 'server__tool' }, 'server');
 
       expect(mockCheckerRunner.runChecker).toHaveBeenCalledWith(
         expect.anything(),
@@ -2164,8 +2137,6 @@ describe('PolicyEngine', () => {
       rules: PolicyRule[];
       approvalMode?: ApprovalMode;
       nonInteractive?: boolean;
-      allToolNames?: string[];
-      metadata?: Map<string, Record<string, unknown>>;
       expected: string[];
     }
 
@@ -2173,13 +2144,11 @@ describe('PolicyEngine', () => {
       {
         name: 'should return empty set when no rules provided',
         rules: [],
-        allToolNames: ['tool1'],
         expected: [],
       },
       {
         name: 'should apply rules without explicit modes to all modes',
         rules: [{ toolName: 'tool1', decision: PolicyDecision.DENY }],
-        allToolNames: ['tool1', 'tool2'],
         expected: ['tool1'],
       },
       {
@@ -2199,7 +2168,6 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['tool1'],
         expected: [],
       },
       {
@@ -2216,7 +2184,6 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['tool1', 'tool2', 'tool3'],
         expected: ['tool1'],
       },
       {
@@ -2235,7 +2202,6 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['tool1'],
         expected: ['tool1'],
       },
       {
@@ -2254,7 +2220,6 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['tool1'],
         expected: [],
       },
       {
@@ -2267,8 +2232,7 @@ describe('PolicyEngine', () => {
           },
         ],
         nonInteractive: true,
-        allToolNames: ['tool1'],
-        expected: ['tool1'],
+        expected: [],
       },
       {
         name: 'should ignore rules with argsPattern',
@@ -2280,7 +2244,6 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['tool1'],
         expected: [],
       },
       {
@@ -2293,7 +2256,6 @@ describe('PolicyEngine', () => {
           },
         ],
         approvalMode: ApprovalMode.PLAN,
-        allToolNames: ['tool1'],
         expected: ['tool1'],
       },
       {
@@ -2306,7 +2268,6 @@ describe('PolicyEngine', () => {
           },
         ],
         approvalMode: ApprovalMode.DEFAULT,
-        allToolNames: ['tool1'],
         expected: [],
       },
       {
@@ -2325,55 +2286,36 @@ describe('PolicyEngine', () => {
           },
         ],
         approvalMode: ApprovalMode.YOLO,
-        allToolNames: ['dangerous-tool', 'safe-tool'],
         expected: [],
       },
       {
         name: 'should respect server wildcard DENY',
         rules: [
           {
-            toolName: 'mcp_server_*',
-            mcpName: 'server',
+            toolName: 'server__*',
             decision: PolicyDecision.DENY,
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: [
-          'mcp_server_tool1',
-          'mcp_server_tool2',
-          'mcp_other_tool',
-        ],
-        metadata: new Map([
-          ['mcp_server_tool1', { _serverName: 'server' }],
-          ['mcp_server_tool2', { _serverName: 'server' }],
-          ['mcp_other_tool', { _serverName: 'other' }],
-        ]),
-        expected: ['mcp_server_tool1', 'mcp_server_tool2'],
+        expected: ['server__*'],
       },
       {
         name: 'should expand server wildcard for specific tools if already processed',
         rules: [
           {
-            toolName: 'mcp_server_*',
-            mcpName: 'server',
+            toolName: 'server__*',
             decision: PolicyDecision.DENY,
             priority: 100,
             modes: [ApprovalMode.DEFAULT],
           },
           {
-            toolName: 'mcp_server_tool1',
-            mcpName: 'server',
-            decision: PolicyDecision.DENY, // redundant but tests ordering
+            toolName: 'server__tool1',
+            decision: PolicyDecision.DENY,
             priority: 10,
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['mcp_server_tool1', 'mcp_server_tool2'],
-        metadata: new Map([
-          ['mcp_server_tool1', { _serverName: 'server' }],
-          ['mcp_server_tool2', { _serverName: 'server' }],
-        ]),
-        expected: ['mcp_server_tool1', 'mcp_server_tool2'],
+        expected: ['server__*', 'server__tool1'],
       },
       {
         name: 'should exclude run_shell_command but NOT write_file in simulated Plan Mode',
@@ -2400,29 +2342,24 @@ describe('PolicyEngine', () => {
             priority: 10,
           },
         ],
-        allToolNames: ['write_file', 'run_shell_command', 'read_file'],
-        expected: ['run_shell_command', 'read_file'],
+        expected: ['run_shell_command'],
       },
       {
         name: 'should NOT exclude tool if covered by a higher priority wildcard ALLOW',
         rules: [
           {
-            toolName: 'mcp_server_*',
-            mcpName: 'server',
+            toolName: 'server__*',
             decision: PolicyDecision.ALLOW,
             priority: 100,
             modes: [ApprovalMode.DEFAULT],
           },
           {
-            toolName: 'mcp_server_tool1',
-            mcpName: 'server',
+            toolName: 'server__tool1',
             decision: PolicyDecision.DENY,
             priority: 10,
             modes: [ApprovalMode.DEFAULT],
           },
         ],
-        allToolNames: ['mcp_server_tool1'],
-        metadata: new Map([['mcp_server_tool1', { _serverName: 'server' }]]),
         expected: [],
       },
       {
@@ -2434,63 +2371,41 @@ describe('PolicyEngine', () => {
             priority: 10,
           },
         ],
-        allToolNames: ['toolA', 'toolB', 'mcp_server_toolC'],
-        expected: ['toolA', 'toolB', 'mcp_server_toolC'], // all tools denied by *
+        expected: ['*'],
       },
       {
         name: 'should handle MCP category wildcard *__* in getExcludedTools',
         rules: [
           {
-            toolName: 'mcp_*',
+            toolName: '*__*',
             decision: PolicyDecision.DENY,
             priority: 10,
           },
         ],
-        allToolNames: ['localTool', 'mcp_myserver_mytool'],
-        metadata: new Map([
-          ['mcp_myserver_mytool', { _serverName: 'myserver' }],
-        ]),
-        expected: ['mcp_myserver_mytool'],
+        expected: ['*__*'],
       },
       {
-        name: 'should handle tool wildcard mcp_server_* in getExcludedTools',
+        name: 'should handle tool wildcard *__search in getExcludedTools',
         rules: [
           {
-            toolName: 'mcp_server_*',
+            toolName: '*__search',
             decision: PolicyDecision.DENY,
             priority: 10,
           },
         ],
-        allToolNames: [
-          'localTool',
-          'mcp_server_search',
-          'mcp_otherserver_read',
-        ],
-        metadata: new Map([
-          ['mcp_server_search', { _serverName: 'server' }],
-          ['mcp_otherserver_read', { _serverName: 'otherserver' }],
-        ]),
-        expected: ['mcp_server_search'],
+        expected: ['*__search'],
       },
     ];
 
     it.each(testCases)(
       '$name',
-      ({
-        rules,
-        approvalMode,
-        nonInteractive,
-        allToolNames,
-        metadata,
-        expected,
-      }) => {
+      ({ rules, approvalMode, nonInteractive, expected }) => {
         engine = new PolicyEngine({
           rules,
           approvalMode: approvalMode ?? ApprovalMode.DEFAULT,
           nonInteractive: nonInteractive ?? false,
         });
-        const toolsSet = allToolNames ? new Set(allToolNames) : undefined;
-        const excluded = engine.getExcludedTools(metadata, toolsSet);
+        const excluded = engine.getExcludedTools();
         expect(Array.from(excluded).sort()).toEqual(expected.sort());
       },
     );
@@ -2505,10 +2420,7 @@ describe('PolicyEngine', () => {
           },
         ],
       });
-      const excluded = engine.getExcludedTools(
-        undefined,
-        new Set(['dangerous_tool']),
-      );
+      const excluded = engine.getExcludedTools();
       expect(Array.from(excluded)).toEqual([]);
     });
 
@@ -2526,10 +2438,7 @@ describe('PolicyEngine', () => {
         ['dangerous_tool', { destructiveHint: true }],
         ['safe_tool', { readOnlyHint: true }],
       ]);
-      const excluded = engine.getExcludedTools(
-        metadata,
-        new Set(['dangerous_tool', 'safe_tool']),
-      );
+      const excluded = engine.getExcludedTools(metadata);
       expect(Array.from(excluded)).toEqual(['dangerous_tool']);
     });
 
@@ -2546,10 +2455,7 @@ describe('PolicyEngine', () => {
       const metadata = new Map<string, Record<string, unknown>>([
         ['safe_tool', { readOnlyHint: true }],
       ]);
-      const excluded = engine.getExcludedTools(
-        metadata,
-        new Set(['safe_tool']),
-      );
+      const excluded = engine.getExcludedTools(metadata);
       expect(Array.from(excluded)).toEqual([]);
     });
 
@@ -2557,8 +2463,7 @@ describe('PolicyEngine', () => {
       engine = new PolicyEngine({
         rules: [
           {
-            toolName: 'mcp_server_*',
-            mcpName: 'server',
+            toolName: 'server__*',
             toolAnnotations: { destructiveHint: true },
             decision: PolicyDecision.DENY,
             priority: 10,
@@ -2566,25 +2471,12 @@ describe('PolicyEngine', () => {
         ],
       });
       const metadata = new Map<string, Record<string, unknown>>([
-        [
-          'mcp_server_dangerous_tool',
-          { destructiveHint: true, _serverName: 'server' },
-        ],
-        [
-          'mcp_other_dangerous_tool',
-          { destructiveHint: true, _serverName: 'other' },
-        ],
-        ['mcp_server_safe_tool', { readOnlyHint: true, _serverName: 'server' }],
+        ['server__dangerous_tool', { destructiveHint: true }],
+        ['other__dangerous_tool', { destructiveHint: true }],
+        ['server__safe_tool', { readOnlyHint: true }],
       ]);
-      const excluded = engine.getExcludedTools(
-        metadata,
-        new Set([
-          'mcp_server_dangerous_tool',
-          'mcp_other_dangerous_tool',
-          'mcp_server_safe_tool',
-        ]),
-      );
-      expect(Array.from(excluded)).toEqual(['mcp_server_dangerous_tool']);
+      const excluded = engine.getExcludedTools(metadata);
+      expect(Array.from(excluded)).toEqual(['server__dangerous_tool']);
     });
 
     it('should exclude unprocessed tools from allToolNames when global DENY is active', () => {
@@ -2601,8 +2493,8 @@ describe('PolicyEngine', () => {
             priority: 70,
           },
           {
-            // Simulates plan.toml: mcpName="*" → toolName="mcp_*"
-            toolName: 'mcp_*',
+            // Simulates plan.toml: mcpName="*" → toolName="*__*"
+            toolName: '*__*',
             toolAnnotations: { readOnlyHint: true },
             decision: PolicyDecision.ASK_USER,
             priority: 70,
@@ -2613,42 +2505,36 @@ describe('PolicyEngine', () => {
           },
         ],
       });
-      // MCP tools are registered with qualified names in ToolRegistry
+      // MCP tools are registered with unqualified names in ToolRegistry
       const allToolNames = new Set([
         'glob',
         'read_file',
         'shell',
         'web_fetch',
-        'mcp_my-server_read_mcp_tool',
-        'mcp_my-server_write_mcp_tool',
+        'read_mcp_tool',
+        'write_mcp_tool',
       ]);
       // buildToolMetadata() includes _serverName for MCP tools
       const toolMetadata = new Map<string, Record<string, unknown>>([
-        [
-          'mcp_my-server_read_mcp_tool',
-          { readOnlyHint: true, _serverName: 'my-server' },
-        ],
-        [
-          'mcp_my-server_write_mcp_tool',
-          { readOnlyHint: false, _serverName: 'my-server' },
-        ],
+        ['read_mcp_tool', { readOnlyHint: true, _serverName: 'my-server' }],
+        ['write_mcp_tool', { readOnlyHint: false, _serverName: 'my-server' }],
       ]);
       const excluded = engine.getExcludedTools(toolMetadata, allToolNames);
       expect(excluded.has('shell')).toBe(true);
       expect(excluded.has('web_fetch')).toBe(true);
       // Non-read-only MCP tool excluded by catch-all DENY
-      expect(excluded.has('mcp_my-server_write_mcp_tool')).toBe(true);
+      expect(excluded.has('write_mcp_tool')).toBe(true);
       expect(excluded.has('glob')).toBe(false);
       expect(excluded.has('read_file')).toBe(false);
       // Read-only MCP tool allowed by annotation rule
-      expect(excluded.has('mcp_my-server_read_mcp_tool')).toBe(false);
+      expect(excluded.has('read_mcp_tool')).toBe(false);
     });
 
-    it('should match MCP wildcard rules when explicitly mapped with _serverName', () => {
+    it('should match already-qualified MCP tool names without _serverName', () => {
       engine = new PolicyEngine({
         rules: [
           {
-            toolName: 'mcp_*',
+            toolName: '*__*',
             toolAnnotations: { readOnlyHint: true },
             decision: PolicyDecision.ASK_USER,
             priority: 70,
@@ -2661,23 +2547,17 @@ describe('PolicyEngine', () => {
       });
       // Tool registered with qualified name (collision case)
       const allToolNames = new Set([
-        'mcp_myserver_read_tool',
-        'mcp_myserver_write_tool',
+        'myserver__read_tool',
+        'myserver__write_tool',
       ]);
       const toolMetadata = new Map<string, Record<string, unknown>>([
-        [
-          'mcp_myserver_read_tool',
-          { readOnlyHint: true, _serverName: 'myserver' },
-        ],
-        [
-          'mcp_myserver_write_tool',
-          { readOnlyHint: false, _serverName: 'myserver' },
-        ],
+        ['myserver__read_tool', { readOnlyHint: true }],
+        ['myserver__write_tool', { readOnlyHint: false }],
       ]);
       const excluded = engine.getExcludedTools(toolMetadata, allToolNames);
-      // Qualified name matched using explicit _serverName
-      expect(excluded.has('mcp_myserver_read_tool')).toBe(false);
-      expect(excluded.has('mcp_myserver_write_tool')).toBe(true);
+      // Qualified name already contains __, matched directly without _serverName
+      expect(excluded.has('myserver__read_tool')).toBe(false);
+      expect(excluded.has('myserver__write_tool')).toBe(true);
     });
 
     it('should not exclude unprocessed tools when allToolNames is not provided (backward compat)', () => {
@@ -2768,7 +2648,7 @@ describe('PolicyEngine', () => {
             modes: [ApprovalMode.PLAN],
           },
           {
-            toolName: 'mcp_*',
+            toolName: '*__*',
             toolAnnotations: { readOnlyHint: true },
             decision: PolicyDecision.ASK_USER,
             priority: 70,
@@ -2799,19 +2679,13 @@ describe('PolicyEngine', () => {
         'write_todos',
         'memory',
         'save_memory',
-        'mcp_mcp-server_read_tool',
-        'mcp_mcp-server_write_tool',
+        'read_tool',
+        'write_tool',
       ]);
       // buildToolMetadata() includes _serverName for MCP tools
       const toolMetadata = new Map<string, Record<string, unknown>>([
-        [
-          'mcp_mcp-server_read_tool',
-          { readOnlyHint: true, _serverName: 'mcp-server' },
-        ],
-        [
-          'mcp_mcp-server_write_tool',
-          { readOnlyHint: false, _serverName: 'mcp-server' },
-        ],
+        ['read_tool', { readOnlyHint: true, _serverName: 'mcp-server' }],
+        ['write_tool', { readOnlyHint: false, _serverName: 'mcp-server' }],
       ]);
       const excluded = engine.getExcludedTools(toolMetadata, allToolNames);
       // These should be excluded (caught by catch-all DENY)
@@ -2824,7 +2698,7 @@ describe('PolicyEngine', () => {
       expect(excluded.has('write_file')).toBe(true);
       expect(excluded.has('replace')).toBe(true);
       // Non-read-only MCP tool excluded by catch-all DENY
-      expect(excluded.has('mcp_mcp-server_write_tool')).toBe(true);
+      expect(excluded.has('write_tool')).toBe(true);
       // These should NOT be excluded (explicitly allowed)
       expect(excluded.has('glob')).toBe(false);
       expect(excluded.has('grep_search')).toBe(false);
@@ -2836,7 +2710,7 @@ describe('PolicyEngine', () => {
       expect(excluded.has('exit_plan_mode')).toBe(false);
       expect(excluded.has('save_memory')).toBe(false);
       // Read-only MCP tool allowed by annotation rule (matched via _serverName)
-      expect(excluded.has('mcp_mcp-server_read_tool')).toBe(false);
+      expect(excluded.has('read_tool')).toBe(false);
     });
   });
 
@@ -3184,13 +3058,13 @@ describe('PolicyEngine', () => {
       engine = new PolicyEngine({
         rules: [
           {
-            toolName: 'mcp_*',
+            toolName: '*__*',
             toolAnnotations: { experimental: true },
             decision: PolicyDecision.DENY,
             priority: 20,
           },
           {
-            toolName: 'mcp_*',
+            toolName: '*__*',
             decision: PolicyDecision.ALLOW,
             priority: 10,
           },
@@ -3199,14 +3073,14 @@ describe('PolicyEngine', () => {
 
       expect(
         (
-          await engine.check({ name: 'mcp_mcp_test' }, 'mcp', {
+          await engine.check({ name: 'mcp__test' }, 'mcp', {
             experimental: true,
           })
         ).decision,
       ).toBe(PolicyDecision.DENY);
       expect(
         (
-          await engine.check({ name: 'mcp_mcp_stable' }, 'mcp', {
+          await engine.check({ name: 'mcp__stable' }, 'mcp', {
             experimental: false,
           })
         ).decision,

packages/core/src/policy/policy-engine.ts

@@ -25,11 +25,6 @@ import {
   hasRedirection,
 } from '../utils/shell-utils.js';
 import { getToolAliases } from '../tools/tool-names.js';
-import {
-  MCP_TOOL_PREFIX,
-  isMcpToolAnnotation,
-  parseMcpToolName,
-} from '../tools/mcp-tool.js';
 
 function isWildcardPattern(name: string): boolean {
   return name === '*' || name.includes('*');
@@ -37,7 +32,7 @@ function isWildcardPattern(name: string): boolean {
 
 /**
  * Checks if a tool call matches a wildcard pattern.
- * Supports global (*) and the explicit MCP (*mcp_serverName_**) format.
+ * Supports global (*) and composite (server__*, *__tool, *__*) patterns.
  */
 function matchesWildcard(
   pattern: string,
@@ -48,25 +43,59 @@ function matchesWildcard(
     return true;
   }
 
-  if (pattern === `${MCP_TOOL_PREFIX}*`) {
-    return serverName !== undefined;
+  if (pattern.includes('__')) {
+    return matchesCompositePattern(pattern, toolName, serverName);
   }
 
-  if (pattern.startsWith(MCP_TOOL_PREFIX) && pattern.endsWith('_*')) {
-    const expectedServerName = pattern.slice(MCP_TOOL_PREFIX.length, -2);
-    // 1. Must be an MCP tool call (has serverName)
-    // 2. Server name must match
-    // 3. Tool name must be properly qualified by that server
-    if (serverName === undefined || serverName !== expectedServerName) {
-      return false;
-    }
-    return toolName.startsWith(`${MCP_TOOL_PREFIX}${expectedServerName}_`);
-  }
-
-  // Not a recognized wildcard pattern, fallback to exact match just in case
   return toolName === pattern;
 }
 
+/**
+ * Matches composite patterns like "server__*", "*__tool", or "*__*".
+ */
+function matchesCompositePattern(
+  pattern: string,
+  toolName: string,
+  serverName: string | undefined,
+): boolean {
+  const parts = pattern.split('__');
+  if (parts.length !== 2) return false;
+  const [patternServer, patternTool] = parts;
+
+  // 1. Identify the tool's components
+  const { actualServer, actualTool } = getToolMetadata(toolName, serverName);
+
+  // 2. Composite patterns require a server context
+  if (actualServer === undefined) {
+    return false;
+  }
+
+  // 3. Robustness: if serverName is provided, toolName MUST be qualified by it.
+  // This prevents "malicious-server" from spoofing "trusted-server" by naming itself "trusted-server__malicious".
+  if (serverName !== undefined && !toolName.startsWith(serverName + '__')) {
+    return false;
+  }
+
+  // 4. Match components
+  const serverMatch = patternServer === '*' || patternServer === actualServer;
+  const toolMatch = patternTool === '*' || patternTool === actualTool;
+
+  return serverMatch && toolMatch;
+}
+
+/**
+ * Extracts the server and unqualified tool name from a tool call context.
+ */
+function getToolMetadata(toolName: string, serverName: string | undefined) {
+  const sepIndex = toolName.indexOf('__');
+  const isQualified = sepIndex !== -1;
+  return {
+    actualServer:
+      serverName ?? (isQualified ? toolName.substring(0, sepIndex) : undefined),
+    actualTool: isQualified ? toolName.substring(sepIndex + 2) : toolName,
+  };
+}
+
 function ruleMatches(
   rule: PolicyRule | SafetyCheckerRule,
   toolCall: FunctionCall,
@@ -82,20 +111,9 @@ function ruleMatches(
     }
   }
 
-  // Strictly enforce mcpName identity if the rule dictates it
-  if (rule.mcpName) {
-    if (rule.mcpName === '*') {
-      // Rule requires it to be ANY MCP tool
-      if (serverName === undefined) return false;
-    } else {
-      // Rule requires it to be a specific MCP server
-      if (serverName !== rule.mcpName) return false;
-    }
-  }
-
   // Check tool name if specified
   if (rule.toolName) {
-    // Support wildcard patterns: "mcp_serverName_*" matches "mcp_serverName_anyTool"
+    // Support wildcard patterns: "serverName__*" matches "serverName__anyTool"
     if (rule.toolName === '*') {
       // Match all tools
     } else if (isWildcardPattern(rule.toolName)) {
@@ -353,22 +371,6 @@ export class PolicyEngine {
     serverName: string | undefined,
     toolAnnotations?: Record<string, unknown>,
   ): Promise<CheckResult> {
-    // Case 1: Metadata injection is the primary and safest way to identify an MCP server.
-    // If we have explicit `_serverName` metadata (usually injected by tool-registry for active tools), use it.
-    if (!serverName && isMcpToolAnnotation(toolAnnotations)) {
-      serverName = toolAnnotations._serverName;
-    }
-
-    // Case 2: Fallback for static FQN strings (e.g. from TOML policies or allowed/excluded settings strings).
-    // These strings don't have active metadata objects associated with them during policy generation,
-    // so we must extract the server name from the qualified `mcp_{server}_{tool}` format.
-    if (!serverName && toolCall.name) {
-      const parsed = parseMcpToolName(toolCall.name);
-      if (parsed.serverName) {
-        serverName = parsed.serverName;
-      }
-    }
-
     let stringifiedArgs: string | undefined;
     // Compute stringified args once before the loop
     if (
@@ -402,12 +404,20 @@ export class PolicyEngine {
     let matchedRule: PolicyRule | undefined;
     let decision: PolicyDecision | undefined;
 
+    // For tools with a server name, we want to try matching both the
+    // original name and the fully qualified name (server__tool).
     // We also want to check legacy aliases for the tool name.
     const toolNamesToTry = toolCall.name ? getToolAliases(toolCall.name) : [];
 
     const toolCallsToTry: FunctionCall[] = [];
     for (const name of toolNamesToTry) {
       toolCallsToTry.push({ ...toolCall, name });
+      if (serverName && !name.includes('__')) {
+        toolCallsToTry.push({
+          ...toolCall,
+          name: `${serverName}__${name}`,
+        });
+      }
     }
 
     for (const rule of this.rules) {
@@ -453,15 +463,6 @@ export class PolicyEngine {
 
     // Default if no rule matched
     if (decision === undefined) {
-      if (this.approvalMode === ApprovalMode.YOLO) {
-        debugLogger.debug(
-          `[PolicyEngine.check] NO MATCH in YOLO mode - using ALLOW`,
-        );
-        return {
-          decision: PolicyDecision.ALLOW,
-        };
-      }
-
       debugLogger.debug(
         `[PolicyEngine.check] NO MATCH - using default decision: ${this.defaultDecision}`,
       );
@@ -653,71 +654,147 @@ export class PolicyEngine {
     allToolNames?: Set<string>,
   ): Set<string> {
     const excludedTools = new Set<string>();
+    const processedTools = new Set<string>();
+    let globalVerdict: PolicyDecision | undefined;
 
-    if (!allToolNames) {
-      return excludedTools;
-    }
+    for (const rule of this.rules) {
+      if (rule.argsPattern) {
+        if (rule.toolName && rule.decision !== PolicyDecision.DENY) {
+          processedTools.add(rule.toolName);
+        }
+        continue;
+      }
 
-    for (const toolName of allToolNames) {
-      const annotations = toolMetadata?.get(toolName);
-      const serverName = isMcpToolAnnotation(annotations)
-        ? annotations._serverName
-        : undefined;
+      // Check if rule applies to current approval mode
+      if (rule.modes && rule.modes.length > 0) {
+        if (!rule.modes.includes(this.approvalMode)) {
+          continue;
+        }
+      }
 
-      let staticallyExcluded = false;
-      let matchFound = false;
-
-      // Evaluate rules in priority order (they are already sorted in constructor)
-      for (const rule of this.rules) {
-        // Create a copy of the rule without argsPattern to see if it targets the tool
-        // regardless of the runtime arguments it might receive.
-        const ruleWithoutArgs: PolicyRule = { ...rule, argsPattern: undefined };
-        const toolCall: FunctionCall = { name: toolName, args: {} };
-
-        const appliesToTool = ruleMatches(
-          ruleWithoutArgs,
-          toolCall,
-          undefined, // stringifiedArgs
-          serverName,
-          this.approvalMode,
-          annotations,
-        );
-
-        if (appliesToTool) {
-          if (rule.argsPattern) {
-            // Exclusions only apply statically before arguments are known.
-            if (rule.decision !== PolicyDecision.DENY) {
-              // Conditionally allowed/asked based on args. Therefore NOT statically excluded.
-              staticallyExcluded = false;
-              matchFound = true;
+      // Handle annotation-based rules
+      if (rule.toolAnnotations) {
+        if (!toolMetadata) {
+          // Without metadata, we can't evaluate annotation rules — skip (conservative fallback)
+          continue;
+        }
+        // Iterate over all known tools and check if their annotations match this rule
+        for (const [toolName, annotations] of toolMetadata) {
+          if (processedTools.has(toolName)) {
+            continue;
+          }
+          // Check if annotations match the rule's toolAnnotations (partial match)
+          let annotationsMatch = true;
+          for (const [key, value] of Object.entries(rule.toolAnnotations)) {
+            if (annotations[key] !== value) {
+              annotationsMatch = false;
               break;
             }
-            // If it's conditionally DENIED based on args, it means it's not unconditionally denied.
-            // We must keep evaluating lower priority rules to see the default/unconditional state.
+          }
+          if (!annotationsMatch) {
             continue;
+          }
+          // Check if the tool name matches the rule's toolName pattern (if any)
+          if (rule.toolName) {
+            if (isWildcardPattern(rule.toolName)) {
+              // For composite patterns (e.g. "*__*"), construct a qualified
+              // name from metadata so matchesWildcard can resolve it.
+              const rawServerName = annotations['_serverName'];
+              const serverName =
+                typeof rawServerName === 'string' ? rawServerName : undefined;
+              const qualifiedName =
+                serverName && !toolName.includes('__')
+                  ? `${serverName}__${toolName}`
+                  : toolName;
+              if (!matchesWildcard(rule.toolName, qualifiedName, undefined)) {
+                continue;
+              }
+            } else if (toolName !== rule.toolName) {
+              continue;
+            }
+          }
+          // Determine decision considering global verdict
+          let decision: PolicyDecision;
+          if (globalVerdict !== undefined) {
+            decision = globalVerdict;
           } else {
-            // Unconditional rule for this tool
-            const decision = this.applyNonInteractiveMode(rule.decision);
-            staticallyExcluded = decision === PolicyDecision.DENY;
-            matchFound = true;
+            decision = rule.decision;
+          }
+          if (decision === PolicyDecision.DENY) {
+            excludedTools.add(toolName);
+          }
+          processedTools.add(toolName);
+        }
+        continue;
+      }
+
+      // Handle Global Rules
+      if (!rule.toolName) {
+        if (globalVerdict === undefined) {
+          globalVerdict = rule.decision;
+          if (globalVerdict !== PolicyDecision.DENY) {
+            // Global ALLOW/ASK found.
+            // Since rules are sorted by priority, this overrides any lower-priority rules.
+            // We can stop processing because nothing else will be excluded.
             break;
           }
+          // If Global DENY, we continue to find specific tools to add to excluded set
         }
+        continue;
       }
 
-      if (!matchFound) {
-        // Fallback to default decision if no rule matches
-        const defaultDec = this.applyNonInteractiveMode(this.defaultDecision);
-        if (defaultDec === PolicyDecision.DENY) {
-          staticallyExcluded = true;
-        }
+      const toolName = rule.toolName;
+
+      // Check if already processed (exact match)
+      if (processedTools.has(toolName)) {
+        continue;
       }
 
-      if (staticallyExcluded) {
+      // Check if covered by a processed wildcard
+      let coveredByWildcard = false;
+      for (const processed of processedTools) {
+        if (
+          isWildcardPattern(processed) &&
+          matchesWildcard(processed, toolName, undefined)
+        ) {
+          // It's covered by a higher-priority wildcard rule.
+          // If that wildcard rule resulted in exclusion, this tool should also be excluded.
+          if (excludedTools.has(processed)) {
+            excludedTools.add(toolName);
+          }
+          coveredByWildcard = true;
+          break;
+        }
+      }
+      if (coveredByWildcard) {
+        continue;
+      }
+
+      processedTools.add(toolName);
+
+      // Determine decision
+      let decision: PolicyDecision;
+      if (globalVerdict !== undefined) {
+        decision = globalVerdict;
+      } else {
+        decision = rule.decision;
+      }
+
+      if (decision === PolicyDecision.DENY) {
         excludedTools.add(toolName);
       }
     }
 
+    // If there's a global DENY and we know all tool names, exclude any tool
+    // that wasn't explicitly allowed by a higher-priority rule.
+    if (globalVerdict === PolicyDecision.DENY && allToolNames) {
+      for (const name of allToolNames) {
+        if (!processedTools.has(name)) {
+          excludedTools.add(name);
+        }
+      }
+    }
+
     return excludedTools;
   }
 

packages/core/src/policy/toml-loader.test.ts

@@ -129,7 +129,7 @@ priority = 10
 `);
 
       expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].toolName).toBe('mcp_*');
+      expect(result.rules[0].toolName).toBe('*__*');
       expect(result.rules[0].decision).toBe(PolicyDecision.ASK_USER);
       expect(result.errors).toHaveLength(0);
     });
@@ -144,7 +144,7 @@ priority = 10
 `);
 
       expect(result.rules).toHaveLength(1);
-      expect(result.rules[0].toolName).toBe('mcp_*_search');
+      expect(result.rules[0].toolName).toBe('*__search');
       expect(result.errors).toHaveLength(0);
     });
 
@@ -215,12 +215,8 @@ priority = 100
 `);
 
       expect(result.rules).toHaveLength(2);
-      expect(result.rules[0].toolName).toBe(
-        'mcp_google-workspace_calendar.list',
-      );
-      expect(result.rules[1].toolName).toBe(
-        'mcp_google-workspace_calendar.get',
-      );
+      expect(result.rules[0].toolName).toBe('google-workspace__calendar.list');
+      expect(result.rules[1].toolName).toBe('google-workspace__calendar.get');
       expect(result.errors).toHaveLength(0);
     });
 
@@ -682,12 +678,12 @@ priority = 100
     it('should not warn for MCP format tool names', async () => {
       const result = await runLoadPoliciesFromToml(`
 [[rule]]
-toolName = "mcp_my-server_my-tool"
+toolName = "my-server__my-tool"
 decision = "allow"
 priority = 100
 
 [[rule]]
-toolName = "mcp_my-server_*"
+toolName = "my-server__*"
 decision = "allow"
 priority = 100
 `);
@@ -826,7 +822,7 @@ priority = 100
           annotationRule,
           'Should have loaded a rule with toolAnnotations',
         ).toBeDefined();
-        expect(annotationRule!.toolName).toBe('mcp_*');
+        expect(annotationRule!.toolName).toBe('*__*');
         expect(annotationRule!.toolAnnotations).toEqual({
           readOnlyHint: true,
         });
@@ -867,7 +863,7 @@ priority = 100
 
         // 4. MCP tool WITHOUT annotations should be DENIED
         const denyResult = await engine.check(
-          { name: 'mcp_github_create_issue' },
+          { name: 'github__create_issue' },
           'github',
           undefined,
         );
@@ -878,7 +874,7 @@ priority = 100
 
         // 5. MCP tool with readOnlyHint=false should also be DENIED
         const denyResult2 = await engine.check(
-          { name: 'mcp_github_delete_issue' },
+          { name: 'github__delete_issue' },
           'github',
           { readOnlyHint: false },
         );
@@ -887,9 +883,9 @@ priority = 100
           'MCP tool with readOnlyHint=false should be DENIED in Plan Mode',
         ).toBe(PolicyDecision.DENY);
 
-        // 6. Test with qualified tool name format (mcp_server_tool) but no separate serverName
+        // 6. Test with qualified tool name format (server__tool) but no separate serverName
         const qualifiedResult = await engine.check(
-          { name: 'mcp_github_list_repos' },
+          { name: 'github__list_repos' },
           undefined,
           { readOnlyHint: true },
         );
@@ -994,8 +990,7 @@ priority = 100
         ['people.getMe', 'calendar.list', 'calendar.get'],
         [
           {
-            toolName: 'mcp_google-workspace_people.getxMe',
-            mcpName: 'google-workspace',
+            toolName: 'google-workspace__people.getxMe',
             source: 'User: workspace.toml',
           },
         ],
@@ -1012,14 +1007,8 @@ priority = 100
         'google-workspace',
         ['people.getMe', 'calendar.list'],
         [
-          {
-            toolName: 'mcp_google-workspace_people.getMe',
-            mcpName: 'google-workspace',
-          },
-          {
-            toolName: 'mcp_google-workspace_calendar.list',
-            mcpName: 'google-workspace',
-          },
+          { toolName: 'google-workspace__people.getMe' },
+          { toolName: 'google-workspace__calendar.list' },
         ],
       );
 
@@ -1030,7 +1019,7 @@ priority = 100
       const warnings = validateMcpPolicyToolNames(
         'my-server',
         ['tool1', 'tool2'],
-        [{ toolName: 'mcp_my-server_*', mcpName: 'my-server' }],
+        [{ toolName: 'my-server__*' }],
       );
 
       expect(warnings).toHaveLength(0);
@@ -1040,7 +1029,7 @@ priority = 100
       const warnings = validateMcpPolicyToolNames(
         'server-a',
         ['tool1'],
-        [{ toolName: 'mcp_server-b_toolx', mcpName: 'server-b' }],
+        [{ toolName: 'server-b__toolx' }],
       );
 
       expect(warnings).toHaveLength(0);
@@ -1050,12 +1039,7 @@ priority = 100
       const warnings = validateMcpPolicyToolNames(
         'my-server',
         ['tool1', 'tool2'],
-        [
-          {
-            toolName: 'mcp_my-server_completely_different_name',
-            mcpName: 'my-server',
-          },
-        ],
+        [{ toolName: 'my-server__completely_different_name' }],
       );
 
       expect(warnings).toHaveLength(0);
@@ -1075,13 +1059,7 @@ priority = 100
       const warnings = validateMcpPolicyToolNames(
         'my-server',
         ['tool1'],
-        [
-          {
-            toolName: 'mcp_my-server_tol1',
-            mcpName: 'my-server',
-            source: 'User: custom.toml',
-          },
-        ],
+        [{ toolName: 'my-server__tol1', source: 'User: custom.toml' }],
       );
 
       expect(warnings).toHaveLength(1);

packages/core/src/policy/toml-loader.ts

@@ -24,7 +24,6 @@ import path from 'node:path';
 import toml from '@iarna/toml';
 import { z, type ZodError } from 'zod';
 import { isNodeError } from '../utils/errors.js';
-import { MCP_TOOL_PREFIX, formatMcpToolName } from '../tools/mcp-tool.js';
 
 /**
  * Maximum Levenshtein distance to consider a name a likely typo of a built-in tool.
@@ -263,15 +262,11 @@ function validateShellCommandSyntax(
  * tool name, or null if valid or not close to any built-in name.
  */
 function validateToolName(name: string, ruleIndex: number): string | null {
-  if (name.includes('__')) {
-    return `Rule #${ruleIndex + 1}: The "__" syntax for MCP tools is strictly deprecated. Please use the 'mcpName = "..."' property or the 'mcp_server_tool' format instead.`;
-  }
-
   // A name that looks like an MCP tool (e.g., "re__ad") could be a typo of a
   // built-in tool ("read_file"). We should let such names fall through to the
   // Levenshtein distance check below. Non-MCP-like names that are valid can
   // be safely skipped.
-  if (isValidToolName(name, { allowWildcards: true })) {
+  if (isValidToolName(name, { allowWildcards: true }) && !name.includes('__')) {
     return null;
   }
 
@@ -407,8 +402,8 @@ export async function loadPoliciesFromToml(
         // Validate tool names in rules
         for (let i = 0; i < tomlRules.length; i++) {
           const rule = tomlRules[i];
-          // We no longer skip MCP-scoped rules because we need to specifically
-          // warn users if they use deprecated "__" syntax for MCP tool names
+          // Skip MCP-scoped rules — MCP tool names are server-defined and dynamic
+          if (rule.mcpName) continue;
 
           const toolNames: string[] = rule.toolName
             ? Array.isArray(rule.toolName)
@@ -452,19 +447,18 @@ export async function loadPoliciesFromToml(
 
               // Create a policy rule for each tool name
               return toolNames.map((toolName) => {
-                let effectiveToolName: string | undefined = toolName;
-                const mcpName = rule.mcpName;
-
-                if (mcpName) {
-                  effectiveToolName = formatMcpToolName(
-                    mcpName,
-                    effectiveToolName,
-                  );
+                // Transform mcpName field to composite toolName format
+                let effectiveToolName: string | undefined;
+                if (rule.mcpName && toolName) {
+                  effectiveToolName = `${rule.mcpName}__${toolName}`;
+                } else if (rule.mcpName) {
+                  effectiveToolName = `${rule.mcpName}__*`;
+                } else {
+                  effectiveToolName = toolName;
                 }
 
                 const policyRule: PolicyRule = {
                   toolName: effectiveToolName,
-                  mcpName: rule.mcpName,
                   decision: rule.decision,
                   priority: transformPriority(rule.priority, tier),
                   modes: rule.modes,
@@ -569,16 +563,15 @@ export async function loadPoliciesFromToml(
               return toolNames.map((toolName) => {
                 let effectiveToolName: string | undefined;
                 if (checker.mcpName && toolName) {
-                  effectiveToolName = `${MCP_TOOL_PREFIX}${checker.mcpName}_${toolName}`;
+                  effectiveToolName = `${checker.mcpName}__${toolName}`;
                 } else if (checker.mcpName) {
-                  effectiveToolName = `${MCP_TOOL_PREFIX}${checker.mcpName}_*`;
+                  effectiveToolName = `${checker.mcpName}__*`;
                 } else {
                   effectiveToolName = toolName;
                 }
 
                 const safetyCheckerRule: SafetyCheckerRule = {
                   toolName: effectiveToolName,
-                  mcpName: checker.mcpName,
                   priority: transformPriority(checker.priority, tier),
                   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                   checker: checker.checker as SafetyCheckerConfig,
@@ -662,28 +655,16 @@ export async function loadPoliciesFromToml(
 export function validateMcpPolicyToolNames(
   serverName: string,
   discoveredToolNames: string[],
-  policyRules: ReadonlyArray<{
-    toolName?: string;
-    mcpName?: string;
-    source?: string;
-  }>,
+  policyRules: ReadonlyArray<{ toolName?: string; source?: string }>,
 ): string[] {
-  const prefix = `${MCP_TOOL_PREFIX}${serverName}_`;
+  const prefix = `${serverName}__`;
   const warnings: string[] = [];
 
   for (const rule of policyRules) {
     if (!rule.toolName) continue;
+    if (!rule.toolName.startsWith(prefix)) continue;
 
-    let toolPart: string | undefined;
-
-    // The toolName is typically transformed into an FQN if mcpName was used.
-    if (rule.mcpName === serverName && rule.toolName.startsWith(prefix)) {
-      toolPart = rule.toolName.slice(prefix.length);
-    } else if (rule.toolName.startsWith(prefix)) {
-      toolPart = rule.toolName.slice(prefix.length);
-    } else {
-      continue;
-    }
+    const toolPart = rule.toolName.slice(prefix.length);
 
     // Skip wildcards
     if (toolPart === '*') continue;

packages/core/src/policy/types.ts

@@ -110,13 +110,6 @@ export interface PolicyRule {
    */
   toolName?: string;
 
-  /**
-   * Identifies the MCP server this rule applies to.
-   * Enables precise rule matching against `serverName` metadata instead
-   * of parsing composite string names.
-   */
-  mcpName?: string;
-
   /**
    * Pattern to match against tool arguments.
    * Can be used for more fine-grained control.
@@ -173,11 +166,6 @@ export interface SafetyCheckerRule {
    */
   toolName?: string;
 
-  /**
-   * Identifies the MCP server this rule applies to.
-   */
-  mcpName?: string;
-
   /**
    * Pattern to match against tool arguments.
    * Can be used for more fine-grained control.

packages/core/src/prompts/promptProvider.test.ts

@@ -153,7 +153,7 @@ describe('PromptProvider', () => {
       const provider = new PromptProvider();
       const prompt = provider.getCoreSystemPrompt(mockConfig);
 
-      expect(prompt).toContain('`mcp_my-mcp-server_mcp_read` (my-mcp-server)');
+      expect(prompt).toContain('`mcp_read` (my-mcp-server)');
     });
 
     it('should include write constraint message in plan mode prompt', () => {

packages/core/src/routing/strategies/approvalModeStrategy.test.ts

@@ -15,9 +15,7 @@ import {
   PREVIEW_GEMINI_FLASH_MODEL,
   DEFAULT_GEMINI_MODEL_AUTO,
   PREVIEW_GEMINI_MODEL_AUTO,
-  GEMINI_MODEL_ALIAS_AUTO,
 } from '../../config/models.js';
-import { AuthType } from '../../core/contentGenerator.js';
 import { ApprovalMode } from '../../policy/types.js';
 import type { BaseLlmClient } from '../../core/baseLlmClient.js';
 
@@ -42,15 +40,6 @@ describe('ApprovalModeStrategy', () => {
       getApprovalMode: vi.fn().mockReturnValue(ApprovalMode.DEFAULT),
       getApprovedPlanPath: vi.fn().mockReturnValue(undefined),
       getPlanModeRoutingEnabled: vi.fn().mockResolvedValue(true),
-      getGemini31Launched: vi.fn().mockResolvedValue(false),
-      getUseCustomToolModel: vi.fn().mockImplementation(async () => {
-        const launched = await mockConfig.getGemini31Launched();
-        const authType = mockConfig.getContentGeneratorConfig?.()?.authType;
-        return launched && authType === AuthType.USE_GEMINI;
-      }),
-      getContentGeneratorConfig: vi.fn().mockReturnValue({
-        authType: AuthType.LOGIN_WITH_GOOGLE,
-      }),
     } as unknown as Config;
 
     mockBaseLlmClient = {} as BaseLlmClient;
@@ -195,50 +184,4 @@ describe('ApprovalModeStrategy', () => {
 
     expect(decision?.model).toBe(PREVIEW_GEMINI_MODEL);
   });
-
-  it('should route to Preview models when using "auto" alias', async () => {
-    vi.mocked(mockConfig.getModel).mockReturnValue(GEMINI_MODEL_ALIAS_AUTO);
-    vi.mocked(mockConfig.getApprovalMode).mockReturnValue(ApprovalMode.PLAN);
-
-    const decision = await strategy.route(
-      mockContext,
-      mockConfig,
-      mockBaseLlmClient,
-    );
-
-    expect(decision?.model).toBe(PREVIEW_GEMINI_MODEL);
-
-    vi.mocked(mockConfig.getApprovalMode).mockReturnValue(ApprovalMode.DEFAULT);
-    vi.mocked(mockConfig.getApprovedPlanPath).mockReturnValue(
-      '/path/to/plan.md',
-    );
-
-    const implementationDecision = await strategy.route(
-      mockContext,
-      mockConfig,
-      mockBaseLlmClient,
-    );
-
-    expect(implementationDecision?.model).toBe(PREVIEW_GEMINI_FLASH_MODEL);
-  });
-
-  it('should route to Preview Flash model when an approved plan exists and Gemini 3.1 is launched', async () => {
-    vi.mocked(mockConfig.getModel).mockReturnValue(GEMINI_MODEL_ALIAS_AUTO);
-    vi.mocked(mockConfig.getGemini31Launched).mockResolvedValue(true);
-
-    // Exit plan mode with approved plan
-    vi.mocked(mockConfig.getApprovalMode).mockReturnValue(ApprovalMode.DEFAULT);
-    vi.mocked(mockConfig.getApprovedPlanPath).mockReturnValue(
-      '/path/to/plan.md',
-    );
-
-    const decision = await strategy.route(
-      mockContext,
-      mockConfig,
-      mockBaseLlmClient,
-    );
-
-    // Should resolve to Preview Flash (3.0) because resolveClassifierModel uses preview variants for Gemini 3
-    expect(decision?.model).toBe(PREVIEW_GEMINI_FLASH_MODEL);
-  });
 });

packages/core/src/routing/strategies/approvalModeStrategy.ts

@@ -6,10 +6,12 @@
 
 import type { Config } from '../../config/config.js';
 import {
+  DEFAULT_GEMINI_MODEL,
+  DEFAULT_GEMINI_FLASH_MODEL,
+  PREVIEW_GEMINI_MODEL,
+  PREVIEW_GEMINI_FLASH_MODEL,
   isAutoModel,
-  resolveClassifierModel,
-  GEMINI_MODEL_ALIAS_FLASH,
-  GEMINI_MODEL_ALIAS_PRO,
+  isPreviewModel,
 } from '../../config/models.js';
 import type { BaseLlmClient } from '../../core/baseLlmClient.js';
 import { ApprovalMode } from '../../policy/types.js';
@@ -48,19 +50,11 @@ export class ApprovalModeStrategy implements RoutingStrategy {
     const approvalMode = config.getApprovalMode();
     const approvedPlanPath = config.getApprovedPlanPath();
 
-    const [useGemini3_1, useCustomToolModel] = await Promise.all([
-      config.getGemini31Launched(),
-      config.getUseCustomToolModel(),
-    ]);
+    const isPreview = isPreviewModel(model);
 
     // 1. Planning Phase: If ApprovalMode === PLAN, explicitly route to the Pro model.
     if (approvalMode === ApprovalMode.PLAN) {
-      const proModel = resolveClassifierModel(
-        model,
-        GEMINI_MODEL_ALIAS_PRO,
-        useGemini3_1,
-        useCustomToolModel,
-      );
+      const proModel = isPreview ? PREVIEW_GEMINI_MODEL : DEFAULT_GEMINI_MODEL;
       return {
         model: proModel,
         metadata: {
@@ -71,12 +65,9 @@ export class ApprovalModeStrategy implements RoutingStrategy {
       };
     } else if (approvedPlanPath) {
       // 2. Implementation Phase: If ApprovalMode !== PLAN AND an approved plan path is set, prefer the Flash model.
-      const flashModel = resolveClassifierModel(
-        model,
-        GEMINI_MODEL_ALIAS_FLASH,
-        useGemini3_1,
-        useCustomToolModel,
-      );
+      const flashModel = isPreview
+        ? PREVIEW_GEMINI_FLASH_MODEL
+        : DEFAULT_GEMINI_FLASH_MODEL;
       return {
         model: flashModel,
         metadata: {

packages/core/src/routing/strategies/classifierStrategy.test.ts

@@ -59,11 +59,6 @@ describe('ClassifierStrategy', () => {
       getModel: vi.fn().mockReturnValue(DEFAULT_GEMINI_MODEL_AUTO),
       getNumericalRoutingEnabled: vi.fn().mockResolvedValue(false),
       getGemini31Launched: vi.fn().mockResolvedValue(false),
-      getUseCustomToolModel: vi.fn().mockImplementation(async () => {
-        const launched = await mockConfig.getGemini31Launched();
-        const authType = mockConfig.getContentGeneratorConfig().authType;
-        return launched && authType === AuthType.USE_GEMINI;
-      }),
       getContentGeneratorConfig: vi.fn().mockReturnValue({
         authType: AuthType.LOGIN_WITH_GOOGLE,
       }),

packages/core/src/routing/strategies/classifierStrategy.ts

@@ -22,6 +22,7 @@ import {
 import { debugLogger } from '../../utils/debugLogger.js';
 import type { LocalLiteRtLmClient } from '../../core/localLiteRtLmClient.js';
 import { LlmRole } from '../../telemetry/types.js';
+import { AuthType } from '../../core/contentGenerator.js';
 
 // The number of recent history turns to provide to the router for context.
 const HISTORY_TURNS_FOR_CONTEXT = 4;
@@ -171,10 +172,10 @@ export class ClassifierStrategy implements RoutingStrategy {
 
       const reasoning = routerResponse.reasoning;
       const latencyMs = Date.now() - startTime;
-      const [useGemini3_1, useCustomToolModel] = await Promise.all([
-        config.getGemini31Launched(),
-        config.getUseCustomToolModel(),
-      ]);
+      const useGemini3_1 = (await config.getGemini31Launched?.()) ?? false;
+      const useCustomToolModel =
+        useGemini3_1 &&
+        config.getContentGeneratorConfig().authType === AuthType.USE_GEMINI;
       const selectedModel = resolveClassifierModel(
         model,
         routerResponse.model_choice,

packages/core/src/routing/strategies/numericalClassifierStrategy.test.ts

@@ -58,11 +58,6 @@ describe('NumericalClassifierStrategy', () => {
       getNumericalRoutingEnabled: vi.fn().mockResolvedValue(true),
       getClassifierThreshold: vi.fn().mockResolvedValue(undefined),
       getGemini31Launched: vi.fn().mockResolvedValue(false),
-      getUseCustomToolModel: vi.fn().mockImplementation(async () => {
-        const launched = await mockConfig.getGemini31Launched();
-        const authType = mockConfig.getContentGeneratorConfig().authType;
-        return launched && authType === AuthType.USE_GEMINI;
-      }),
       getContentGeneratorConfig: vi.fn().mockReturnValue({
         authType: AuthType.LOGIN_WITH_GOOGLE,
       }),

packages/core/src/routing/strategies/numericalClassifierStrategy.ts

@@ -18,6 +18,7 @@ import type { Config } from '../../config/config.js';
 import { debugLogger } from '../../utils/debugLogger.js';
 import type { LocalLiteRtLmClient } from '../../core/localLiteRtLmClient.js';
 import { LlmRole } from '../../telemetry/types.js';
+import { AuthType } from '../../core/contentGenerator.js';
 
 // The number of recent history turns to provide to the router for context.
 const HISTORY_TURNS_FOR_CONTEXT = 8;
@@ -184,10 +185,10 @@ export class NumericalClassifierStrategy implements RoutingStrategy {
           config,
           config.getSessionId() || 'unknown-session',
         );
-      const [useGemini3_1, useCustomToolModel] = await Promise.all([
-        config.getGemini31Launched(),
-        config.getUseCustomToolModel(),
-      ]);
+      const useGemini3_1 = (await config.getGemini31Launched?.()) ?? false;
+      const useCustomToolModel =
+        useGemini3_1 &&
+        config.getContentGeneratorConfig().authType === AuthType.USE_GEMINI;
       const selectedModel = resolveClassifierModel(
         model,
         modelAlias,

packages/core/src/scheduler/scheduler.test.ts

@@ -946,7 +946,7 @@ describe('Scheduler (Orchestrator)', () => {
       expect(mockStateManager.updateStatus).toHaveBeenCalledWith(
         'call-1',
         CoreToolCallStatus.Cancelled,
-        { callId: 'call-1', responseParts: [] },
+        'Operation cancelled',
       );
     });
 

packages/core/src/scheduler/scheduler.ts

@@ -741,7 +741,7 @@ export class Scheduler {
       this.state.updateStatus(
         callId,
         CoreToolCallStatus.Cancelled,
-        result.response,
+        'Operation cancelled',
       );
     } else {
       this.state.updateStatus(

packages/core/src/scheduler/state-manager.ts

@@ -30,7 +30,6 @@ import {
   MessageBusType,
   type SerializableConfirmationDetails,
 } from '../confirmation-bus/types.js';
-import { isToolCallResponseInfo } from '../utils/tool-utils.js';
 
 /**
  * Handler for terminal tool calls.
@@ -128,7 +127,7 @@ export class SchedulerStateManager {
   updateStatus(
     callId: string,
     status: CoreToolCallStatus.Cancelled,
-    data: string | ToolCallResponseInfo,
+    data: string,
   ): void;
   updateStatus(
     callId: string,
@@ -265,7 +264,7 @@ export class SchedulerStateManager {
   ): ToolCall {
     switch (newStatus) {
       case CoreToolCallStatus.Success: {
-        if (!isToolCallResponseInfo(auxiliaryData)) {
+        if (!this.isToolCallResponseInfo(auxiliaryData)) {
           throw new Error(
             `Invalid data for 'success' transition (callId: ${call.request.callId})`,
           );
@@ -273,7 +272,7 @@ export class SchedulerStateManager {
         return this.toSuccess(call, auxiliaryData);
       }
       case CoreToolCallStatus.Error: {
-        if (!isToolCallResponseInfo(auxiliaryData)) {
+        if (!this.isToolCallResponseInfo(auxiliaryData)) {
           throw new Error(
             `Invalid data for 'error' transition (callId: ${call.request.callId})`,
           );
@@ -291,12 +290,9 @@ export class SchedulerStateManager {
       case CoreToolCallStatus.Scheduled:
         return this.toScheduled(call);
       case CoreToolCallStatus.Cancelled: {
-        if (
-          typeof auxiliaryData !== 'string' &&
-          !isToolCallResponseInfo(auxiliaryData)
-        ) {
+        if (typeof auxiliaryData !== 'string') {
           throw new Error(
-            `Invalid reason (string) or response for 'cancelled' transition (callId: ${call.request.callId})`,
+            `Invalid reason (string) for 'cancelled' transition (callId: ${call.request.callId})`,
           );
         }
         return this.toCancelled(call, auxiliaryData);
@@ -321,6 +317,15 @@ export class SchedulerStateManager {
     }
   }
 
+  private isToolCallResponseInfo(data: unknown): data is ToolCallResponseInfo {
+    return (
+      typeof data === 'object' &&
+      data !== null &&
+      'callId' in data &&
+      'responseParts' in data
+    );
+  }
+
   private isExecutingToolCallPatch(
     data: unknown,
   ): data is Partial<ExecutingToolCall> {
@@ -446,10 +451,7 @@ export class SchedulerStateManager {
     };
   }
 
-  private toCancelled(
-    call: ToolCall,
-    reason: string | ToolCallResponseInfo,
-  ): CancelledToolCall {
+  private toCancelled(call: ToolCall, reason: string): CancelledToolCall {
     this.validateHasToolAndInvocation(call, CoreToolCallStatus.Cancelled);
     const startTime = 'startTime' in call ? call.startTime : undefined;
 
@@ -476,20 +478,6 @@ export class SchedulerStateManager {
       }
     }
 
-    if (isToolCallResponseInfo(reason)) {
-      return {
-        request: call.request,
-        tool: call.tool,
-        invocation: call.invocation,
-        status: CoreToolCallStatus.Cancelled,
-        response: reason,
-        durationMs: startTime ? Date.now() - startTime : undefined,
-        outcome: call.outcome,
-        schedulerId: call.schedulerId,
-        approvalMode: call.approvalMode,
-      };
-    }
-
     const errorMessage = `[Operation Cancelled] Reason: ${reason}`;
     return {
       request: call.request,

packages/core/src/scheduler/tool-executor.test.ts

@@ -534,113 +534,4 @@ describe('ToolExecutor', () => {
       }),
     );
   });
-
-  it('should return cancelled result with partial output when signal is aborted', async () => {
-    const mockTool = new MockTool({
-      name: 'slowTool',
-    });
-    const invocation = mockTool.build({});
-
-    const partialOutput = 'Some partial output before cancellation';
-    vi.mocked(coreToolHookTriggers.executeToolWithHooks).mockImplementation(
-      async () => ({
-        llmContent: partialOutput,
-        returnDisplay: `[Cancelled] ${partialOutput}`,
-      }),
-    );
-
-    const scheduledCall: ScheduledToolCall = {
-      status: CoreToolCallStatus.Scheduled,
-      request: {
-        callId: 'call-cancel-partial',
-        name: 'slowTool',
-        args: {},
-        isClientInitiated: false,
-        prompt_id: 'prompt-cancel',
-      },
-      tool: mockTool,
-      invocation: invocation as unknown as AnyToolInvocation,
-      startTime: Date.now(),
-    };
-
-    const controller = new AbortController();
-    controller.abort();
-
-    const result = await executor.execute({
-      call: scheduledCall,
-      signal: controller.signal,
-      onUpdateToolCall: vi.fn(),
-    });
-
-    expect(result.status).toBe(CoreToolCallStatus.Cancelled);
-    if (result.status === CoreToolCallStatus.Cancelled) {
-      const response = result.response.responseParts[0]?.functionResponse
-        ?.response as Record<string, unknown>;
-      expect(response).toEqual({
-        error: '[Operation Cancelled] User cancelled tool execution.',
-        output: partialOutput,
-      });
-      expect(result.response.resultDisplay).toBe(
-        `[Cancelled] ${partialOutput}`,
-      );
-    }
-  });
-
-  it('should truncate large shell output even on cancellation', async () => {
-    // 1. Setup Config for Truncation
-    vi.spyOn(config, 'getTruncateToolOutputThreshold').mockReturnValue(10);
-    vi.spyOn(config.storage, 'getProjectTempDir').mockReturnValue('/tmp');
-
-    const mockTool = new MockTool({ name: SHELL_TOOL_NAME });
-    const invocation = mockTool.build({});
-    const longOutput = 'This is a very long output that should be truncated.';
-
-    // 2. Mock execution returning long content
-    vi.mocked(coreToolHookTriggers.executeToolWithHooks).mockResolvedValue({
-      llmContent: longOutput,
-      returnDisplay: longOutput,
-    });
-
-    const scheduledCall: ScheduledToolCall = {
-      status: CoreToolCallStatus.Scheduled,
-      request: {
-        callId: 'call-trunc-cancel',
-        name: SHELL_TOOL_NAME,
-        args: { command: 'echo long' },
-        isClientInitiated: false,
-        prompt_id: 'prompt-trunc-cancel',
-      },
-      tool: mockTool,
-      invocation: invocation as unknown as AnyToolInvocation,
-      startTime: Date.now(),
-    };
-
-    // 3. Abort immediately
-    const controller = new AbortController();
-    controller.abort();
-
-    // 4. Execute
-    const result = await executor.execute({
-      call: scheduledCall,
-      signal: controller.signal,
-      onUpdateToolCall: vi.fn(),
-    });
-
-    // 5. Verify Truncation Logic was applied in cancelled path
-    expect(fileUtils.saveTruncatedToolOutput).toHaveBeenCalledWith(
-      longOutput,
-      SHELL_TOOL_NAME,
-      'call-trunc-cancel',
-      expect.any(String),
-      'test-session-id',
-    );
-
-    expect(result.status).toBe(CoreToolCallStatus.Cancelled);
-    if (result.status === CoreToolCallStatus.Cancelled) {
-      const response = result.response.responseParts[0]?.functionResponse
-        ?.response as Record<string, unknown>;
-      expect(response['output']).toBe('TruncatedContent...');
-      expect(result.response.outputFile).toBe('/tmp/truncated_output.txt');
-    }
-  });
 });

packages/core/src/scheduler/tool-executor.ts

@@ -9,6 +9,7 @@ import type {
   ToolCallResponseInfo,
   ToolResult,
   Config,
+  ToolResultDisplay,
   ToolLiveOutput,
 } from '../index.js';
 import {
@@ -18,8 +19,8 @@ import {
   runInDevTraceSpan,
 } from '../index.js';
 import { SHELL_TOOL_NAME } from '../tools/tool-names.js';
-import { ShellToolInvocation } from '../tools/shell.js';
 import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
+import { ShellToolInvocation } from '../tools/shell.js';
 import { executeToolWithHooks } from '../core/coreToolHookTriggers.js';
 import {
   saveTruncatedToolOutput,
@@ -35,7 +36,6 @@ import type {
   CancelledToolCall,
 } from './types.js';
 import { CoreToolCallStatus } from './types.js';
-import type { PartListUnion, Part } from '@google/genai';
 import {
   GeminiCliOperation,
   GEN_AI_TOOL_CALL_ID,
@@ -132,10 +132,10 @@ export class ToolExecutor {
           const toolResult: ToolResult = await promise;
 
           if (signal.aborted) {
-            completedToolCall = await this.createCancelledResult(
+            completedToolCall = this.createCancelledResult(
               call,
               'User cancelled tool execution.',
-              toolResult,
+              toolResult.returnDisplay,
             );
           } else if (toolResult.error === undefined) {
             completedToolCall = await this.createSuccessResult(
@@ -163,7 +163,7 @@ export class ToolExecutor {
               executionError.message.includes('Operation cancelled by user'));
 
           if (signal.aborted || isAbortError) {
-            completedToolCall = await this.createCancelledResult(
+            completedToolCall = this.createCancelledResult(
               call,
               'User cancelled tool execution.',
             );
@@ -186,13 +186,56 @@ export class ToolExecutor {
     );
   }
 
-  private async truncateOutputIfNeeded(
+  private createCancelledResult(
     call: ToolCall,
-    content: PartListUnion,
-  ): Promise<{ truncatedContent: PartListUnion; outputFile?: string }> {
-    const toolName = call.request.name;
-    const callId = call.request.callId;
+    reason: string,
+    resultDisplay?: ToolResultDisplay,
+  ): CancelledToolCall {
+    const errorMessage = `[Operation Cancelled] ${reason}`;
+    const startTime = 'startTime' in call ? call.startTime : undefined;
+
+    if (!('tool' in call) || !('invocation' in call)) {
+      // This should effectively never happen in execution phase, but we handle
+      // it safely
+      throw new Error('Cancelled tool call missing tool/invocation references');
+    }
+
+    return {
+      status: CoreToolCallStatus.Cancelled,
+      request: call.request,
+      response: {
+        callId: call.request.callId,
+        responseParts: [
+          {
+            functionResponse: {
+              id: call.request.callId,
+              name: call.request.name,
+              response: { error: errorMessage },
+            },
+          },
+        ],
+        resultDisplay,
+        error: undefined,
+        errorType: undefined,
+        contentLength: errorMessage.length,
+      },
+      tool: call.tool,
+      invocation: call.invocation,
+      durationMs: startTime ? Date.now() - startTime : undefined,
+      startTime,
+      endTime: Date.now(),
+      outcome: call.outcome,
+    };
+  }
+
+  private async createSuccessResult(
+    call: ToolCall,
+    toolResult: ToolResult,
+  ): Promise<SuccessfulToolCall> {
+    let content = toolResult.llmContent;
     let outputFile: string | undefined;
+    const toolName = call.request.originalRequestName || call.request.name;
+    const callId = call.request.callId;
 
     if (typeof content === 'string' && toolName === SHELL_TOOL_NAME) {
       const threshold = this.config.getTruncateToolOutputThreshold();
@@ -207,23 +250,17 @@ export class ToolExecutor {
           this.config.getSessionId(),
         );
         outputFile = savedPath;
-        const truncatedContent = formatTruncatedToolOutput(
-          content,
-          outputFile,
-          threshold,
-        );
+        content = formatTruncatedToolOutput(content, outputFile, threshold);
 
         logToolOutputTruncated(
           this.config,
           new ToolOutputTruncatedEvent(call.request.prompt_id, {
             toolName,
             originalContentLength,
-            truncatedContentLength: truncatedContent.length,
+            truncatedContentLength: content.length,
             threshold,
           }),
         );
-
-        return { truncatedContent, outputFile };
       }
     } else if (
       Array.isArray(content) &&
@@ -251,12 +288,7 @@ export class ToolExecutor {
             outputFile,
             threshold,
           );
-
-          // We need to return a NEW array to avoid mutating the original toolResult if it matters,
-          // though here we are creating the response so it's probably fine to mutate or return new.
-          const truncatedContent: Part[] = [
-            { ...firstPart, text: truncatedText },
-          ];
+          content[0] = { ...firstPart, text: truncatedText };
 
           logToolOutputTruncated(
             this.config,
@@ -267,95 +299,10 @@ export class ToolExecutor {
               threshold,
             }),
           );
-
-          return { truncatedContent, outputFile };
         }
       }
     }
 
-    return { truncatedContent: content, outputFile };
-  }
-
-  private async createCancelledResult(
-    call: ToolCall,
-    reason: string,
-    toolResult?: ToolResult,
-  ): Promise<CancelledToolCall> {
-    const errorMessage = `[Operation Cancelled] ${reason}`;
-    const startTime = 'startTime' in call ? call.startTime : undefined;
-
-    if (!('tool' in call) || !('invocation' in call)) {
-      // This should effectively never happen in execution phase, but we handle
-      // it safely
-      throw new Error('Cancelled tool call missing tool/invocation references');
-    }
-
-    let responseParts: Part[] = [];
-    let outputFile: string | undefined;
-
-    if (toolResult?.llmContent) {
-      // Attempt to truncate and save output if we have content, even in cancellation case
-      // This is to handle cases where the tool may have produced output before cancellation
-      const { truncatedContent: output, outputFile: truncatedOutputFile } =
-        await this.truncateOutputIfNeeded(call, toolResult?.llmContent);
-
-      outputFile = truncatedOutputFile;
-      responseParts = convertToFunctionResponse(
-        call.request.name,
-        call.request.callId,
-        output,
-        this.config.getActiveModel(),
-      );
-
-      // Inject the cancellation error into the response object
-      const mainPart = responseParts[0];
-      if (mainPart?.functionResponse?.response) {
-        const respObj = mainPart.functionResponse.response;
-        respObj['error'] = errorMessage;
-      }
-    } else {
-      responseParts = [
-        {
-          functionResponse: {
-            id: call.request.callId,
-            name: call.request.name,
-            response: { error: errorMessage },
-          },
-        },
-      ];
-    }
-
-    return {
-      status: CoreToolCallStatus.Cancelled,
-      request: call.request,
-      response: {
-        callId: call.request.callId,
-        responseParts,
-        resultDisplay: toolResult?.returnDisplay,
-        error: undefined,
-        errorType: undefined,
-        outputFile,
-        contentLength: JSON.stringify(responseParts).length,
-      },
-      tool: call.tool,
-      invocation: call.invocation,
-      durationMs: startTime ? Date.now() - startTime : undefined,
-      startTime,
-      endTime: Date.now(),
-      outcome: call.outcome,
-    };
-  }
-
-  private async createSuccessResult(
-    call: ToolCall,
-    toolResult: ToolResult,
-  ): Promise<SuccessfulToolCall> {
-    const { truncatedContent: content, outputFile } =
-      await this.truncateOutputIfNeeded(call, toolResult.llmContent);
-
-    const toolName = call.request.originalRequestName || call.request.name;
-    const callId = call.request.callId;
-
     const response = convertToFunctionResponse(
       toolName,
       callId,

packages/core/src/tools/mcp-tool.test.ts

@@ -8,12 +8,9 @@
 import type { Mocked } from 'vitest';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { safeJsonStringify } from '../utils/safeJsonStringify.js';
-import {
-  DiscoveredMCPTool,
-  generateValidName,
-  formatMcpToolName,
-} from './mcp-tool.js'; // Added getStringifiedResultForDisplay
-import { ToolConfirmationOutcome, type ToolResult } from './tools.js';
+import { DiscoveredMCPTool, generateValidName } from './mcp-tool.js'; // Added getStringifiedResultForDisplay
+import type { ToolResult } from './tools.js';
+import { ToolConfirmationOutcome } from './tools.js'; // Added ToolConfirmationOutcome
 import type { CallableTool, Part } from '@google/genai';
 import { ToolErrorType } from './tool-error.js';
 import {
@@ -46,23 +43,23 @@ const createSdkResponse = (
 
 describe('generateValidName', () => {
   it('should return a valid name for a simple function', () => {
-    expect(generateValidName('myFunction')).toBe('mcp_myFunction');
+    expect(generateValidName('myFunction')).toBe('myFunction');
   });
 
   it('should replace invalid characters with underscores', () => {
     expect(generateValidName('invalid-name with spaces')).toBe(
-      'mcp_invalid-name_with_spaces',
+      'invalid-name_with_spaces',
     );
   });
 
   it('should truncate long names', () => {
     expect(generateValidName('x'.repeat(80))).toBe(
-      'mcp_xxxxxxxxxxxxxxxxxxxxxxxxxx...xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
+      'xxxxxxxxxxxxxxxxxxxxxxxxxxxx___xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
     );
   });
 
   it('should handle names with only invalid characters', () => {
-    expect(generateValidName('!@#$%^&*()')).toBe('mcp___________');
+    expect(generateValidName('!@#$%^&*()')).toBe('__________');
   });
 
   it.each([
@@ -77,30 +74,6 @@ describe('generateValidName', () => {
   );
 });
 
-describe('formatMcpToolName', () => {
-  it('should format a fully qualified name', () => {
-    expect(formatMcpToolName('github', 'list_repos')).toBe(
-      'mcp_github_list_repos',
-    );
-  });
-
-  it('should handle global wildcards', () => {
-    expect(formatMcpToolName('*')).toBe('mcp_*');
-  });
-
-  it('should handle tool-level wildcards', () => {
-    expect(formatMcpToolName('github', '*')).toBe('mcp_github_*');
-  });
-
-  it('should handle undefined toolName as a tool-level wildcard', () => {
-    expect(formatMcpToolName('github')).toBe('mcp_github_*');
-  });
-
-  it('should format explicitly global wildcard with specific tool', () => {
-    expect(formatMcpToolName('*', 'list_repos')).toBe('mcp_*_list_repos');
-  });
-});
-
 describe('DiscoveredMCPTool', () => {
   const serverName = 'mock-mcp-server';
   const serverToolName = 'actual-server-tool-name';
@@ -137,10 +110,8 @@ describe('DiscoveredMCPTool', () => {
 
   describe('constructor', () => {
     it('should set properties correctly', () => {
-      expect(tool.name).toBe('mcp_mock-mcp-server_actual-server-tool-name');
-      expect(tool.schema.name).toBe(
-        'mcp_mock-mcp-server_actual-server-tool-name',
-      );
+      expect(tool.name).toBe(serverToolName);
+      expect(tool.schema.name).toBe(serverToolName);
       expect(tool.schema.description).toBe(baseDescription);
       expect(tool.schema.parameters).toBeUndefined();
       expect(tool.schema.parametersJsonSchema).toEqual(inputSchema);
@@ -962,86 +933,3 @@ describe('DiscoveredMCPTool', () => {
     });
   });
 });
-
-describe('MCP Tool Naming Regression Fixes', () => {
-  describe('generateValidName', () => {
-    it('should replace spaces with underscores', () => {
-      expect(generateValidName('My Tool')).toBe('mcp_My_Tool');
-    });
-
-    it('should allow colons', () => {
-      expect(generateValidName('namespace:tool')).toBe('mcp_namespace:tool');
-    });
-
-    it('should ensure name starts with a letter or underscore', () => {
-      expect(generateValidName('valid_tool_name')).toBe('mcp_valid_tool_name');
-      expect(generateValidName('alsoValid-123.name')).toBe(
-        'mcp_alsoValid-123.name',
-      );
-      expect(generateValidName('another:valid:name')).toBe(
-        'mcp_another:valid:name',
-      );
-    });
-
-    it('should handle very long names by truncating in the middle', () => {
-      const longName = 'a'.repeat(40) + '__' + 'b'.repeat(40);
-      const result = generateValidName(longName);
-      expect(result.length).toBeLessThanOrEqual(63);
-      expect(result).toMatch(/^mcp_a{26}\.\.\.b{30}$/);
-    });
-
-    it('should handle very long names starting with a digit', () => {
-      const longName = '1' + 'a'.repeat(80);
-      const result = generateValidName(longName);
-      expect(result.length).toBeLessThanOrEqual(63);
-      expect(result.startsWith('mcp_1')).toBe(true);
-    });
-  });
-
-  describe('DiscoveredMCPTool qualified names', () => {
-    it('should generate a valid qualified name even with spaces in server name', () => {
-      const tool = new DiscoveredMCPTool(
-        {} as any,
-        'My Server',
-        'my-tool',
-        'desc',
-        {},
-        {} as any,
-      );
-
-      const qn = tool.getFullyQualifiedName();
-      expect(qn).toBe('mcp_My_Server_my-tool');
-    });
-
-    it('should handle long server and tool names in qualified name', () => {
-      const serverName = 'a'.repeat(40);
-      const toolName = 'b'.repeat(40);
-      const tool = new DiscoveredMCPTool(
-        {} as any,
-        serverName,
-        toolName,
-        'desc',
-        {},
-        {} as any,
-      );
-
-      const qn = tool.getFullyQualifiedName();
-      expect(qn.length).toBeLessThanOrEqual(63);
-      expect(qn).toContain('...');
-    });
-
-    it('should handle server names starting with digits', () => {
-      const tool = new DiscoveredMCPTool(
-        {} as any,
-        '123-server',
-        'tool',
-        'desc',
-        {},
-        {} as any,
-      );
-
-      const qn = tool.getFullyQualifiedName();
-      expect(qn).toBe('mcp_123-server_tool');
-    });
-  });
-});

packages/core/src/tools/mcp-tool.ts

@@ -5,7 +5,6 @@
  */
 
 import { safeJsonStringify } from '../utils/safeJsonStringify.js';
-import { debugLogger } from '../utils/debugLogger.js';
 import type {
   ToolCallConfirmationDetails,
   ToolInvocation,
@@ -26,92 +25,18 @@ import type { McpContext } from './mcp-client.js';
 
 /**
  * The separator used to qualify MCP tool names with their server prefix.
- * e.g. "mcp_server_name_tool_name"
+ * e.g. "server_name__tool_name"
  */
-export const MCP_QUALIFIED_NAME_SEPARATOR = '_';
+export const MCP_QUALIFIED_NAME_SEPARATOR = '__';
 
 /**
- * The strict prefix that all MCP tools must start with.
- */
-export const MCP_TOOL_PREFIX = 'mcp_';
-
-/**
- * Returns true if `name` matches the MCP qualified name format: "mcp_server_tool",
- * i.e. starts with the "mcp_" prefix.
+ * Returns true if `name` matches the MCP qualified name format: "server__tool",
+ * i.e. exactly two non-empty parts separated by the MCP_QUALIFIED_NAME_SEPARATOR.
  */
 export function isMcpToolName(name: string): boolean {
-  return name.startsWith(MCP_TOOL_PREFIX);
-}
-
-/**
- * Extracts the server name and tool name from a fully qualified MCP tool name.
- * Expected format: `mcp_{server_name}_{tool_name}`
- * @param name The fully qualified tool name.
- * @returns An object containing the extracted `serverName` and `toolName`, or
- *          `undefined` properties if the name doesn't match the expected format.
- */
-export function parseMcpToolName(name: string): {
-  serverName?: string;
-  toolName?: string;
-} {
-  if (!isMcpToolName(name)) {
-    return {};
-  }
-  // Remove the prefix
-  const withoutPrefix = name.slice(MCP_TOOL_PREFIX.length);
-  // The first segment is the server name, the rest is the tool name
-  const match = withoutPrefix.match(/^([^_]+)_(.+)$/);
-  if (match) {
-    return {
-      serverName: match[1],
-      toolName: match[2],
-    };
-  }
-  return {};
-}
-
-/**
- * Assembles a fully qualified MCP tool name (or wildcard pattern) from its server and tool components.
- *
- * @param serverName The backend MCP server name (can be '*' for global wildcards).
- * @param toolName The name of the tool (can be undefined or '*' for tool-level wildcards).
- * @returns The fully qualified name (e.g., `mcp_server_tool`, `mcp_*`, `mcp_server_*`).
- */
-export function formatMcpToolName(
-  serverName: string,
-  toolName?: string,
-): string {
-  if (serverName === '*' && !toolName) {
-    return `${MCP_TOOL_PREFIX}*`;
-  } else if (serverName === '*') {
-    return `${MCP_TOOL_PREFIX}*_${toolName}`;
-  } else if (!toolName) {
-    return `${MCP_TOOL_PREFIX}${serverName}_*`;
-  } else {
-    return `${MCP_TOOL_PREFIX}${serverName}_${toolName}`;
-  }
-}
-
-/**
- * Interface representing metadata annotations specific to an MCP tool.
- * Ensures strongly-typed access to server-level properties.
- */
-export interface McpToolAnnotation extends Record<string, unknown> {
-  _serverName: string;
-}
-
-/**
- * Type guard to check if tool annotations implement McpToolAnnotation.
- */
-export function isMcpToolAnnotation(
-  annotation: unknown,
-): annotation is McpToolAnnotation {
-  return (
-    typeof annotation === 'object' &&
-    annotation !== null &&
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    typeof (annotation as Record<string, unknown>)['_serverName'] === 'string'
-  );
+  if (!name.includes(MCP_QUALIFIED_NAME_SEPARATOR)) return false;
+  const parts = name.split(MCP_QUALIFIED_NAME_SEPARATOR);
+  return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
 }
 
 type ToolParams = Record<string, unknown>;
@@ -171,17 +96,14 @@ export class DiscoveredMCPToolInvocation extends BaseToolInvocation<
   ) {
     // Use composite format for policy checks: serverName__toolName
     // This enables server wildcards (e.g., "google-workspace__*")
-    // while still allowing specific tool rules.
-    // We use the same sanitized names as the registry to ensure policy matches.
+    // while still allowing specific tool rules
 
     super(
       params,
       messageBus,
-      generateValidName(
-        `${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`,
-      ),
+      `${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`,
       displayName,
-      generateValidName(serverName),
+      serverName,
       toolAnnotationsData,
     );
   }
@@ -351,10 +273,7 @@ export class DiscoveredMCPTool extends BaseDeclarativeTool<
     private readonly _toolAnnotations?: Record<string, unknown>,
   ) {
     super(
-      nameOverride ??
-        generateValidName(
-          `${serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${serverToolName}`,
-        ),
+      nameOverride ?? generateValidName(serverToolName),
       `${serverToolName} (${serverName} MCP Server)`,
       description,
       Kind.Other,
@@ -382,15 +301,11 @@ export class DiscoveredMCPTool extends BaseDeclarativeTool<
   }
 
   getFullyQualifiedPrefix(): string {
-    return generateValidName(
-      `${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}`,
-    );
+    return `${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}`;
   }
 
   getFullyQualifiedName(): string {
-    return generateValidName(
-      `${this.serverName}${MCP_QUALIFIED_NAME_SEPARATOR}${this.serverToolName}`,
-    );
+    return `${this.getFullyQualifiedPrefix()}${generateValidName(this.serverToolName)}`;
   }
 
   asFullyQualifiedTool(): DiscoveredMCPTool {
@@ -567,36 +482,16 @@ function getStringifiedResultForDisplay(rawResponse: Part[]): string {
   return displayParts.join('\n');
 }
 
-/**
- * Maximum length for a function name in the Gemini API.
- * @see https://docs.cloud.google.com/vertex-ai/generative-ai/docs/model-reference/function-calling#functiondeclaration
- */
-const MAX_FUNCTION_NAME_LENGTH = 64;
-
 /** Visible for testing */
 export function generateValidName(name: string) {
-  // Enforce the mcp_ prefix for all generated MCP tool names
-  let validToolname = name.startsWith('mcp_') ? name : `mcp_${name}`;
+  // Replace invalid characters (based on 400 error message from Gemini API) with underscores
+  let validToolname = name.replace(/[^a-zA-Z0-9_.-]/g, '_');
 
-  // Replace invalid characters with underscores to conform to Gemini API:
-  // ^[a-zA-Z_][a-zA-Z0-9_\-.:]{0,63}$
-  validToolname = validToolname.replace(/[^a-zA-Z0-9_\-.:]/g, '_');
-
-  // Ensure it starts with a letter or underscore
-  if (/^[^a-zA-Z_]/.test(validToolname)) {
-    validToolname = `_${validToolname}`;
-  }
-
-  // If longer than the API limit, replace middle with '...'
-  // Note: We use 63 instead of 64 to be safe, as some environments have off-by-one behaviors.
-  const safeLimit = MAX_FUNCTION_NAME_LENGTH - 1;
-  if (validToolname.length > safeLimit) {
-    debugLogger.warn(
-      `Truncating MCP tool name "${validToolname}" to fit within the 64 character limit. This tool may require user approval.`,
-    );
+  // If longer than 63 characters, replace middle with '___'
+  // (Gemini API says max length 64, but actual limit seems to be 63)
+  if (validToolname.length > 63) {
     validToolname =
-      validToolname.slice(0, 30) + '...' + validToolname.slice(-30);
+      validToolname.slice(0, 28) + '___' + validToolname.slice(-32);
   }
-
   return validToolname;
 }

packages/core/src/tools/shell.ts

@@ -388,17 +388,16 @@ export class ShellToolInvocation extends BaseToolInvocation<
       } else {
         if (this.params.is_background || result.backgrounded) {
           returnDisplayMessage = `Command moved to background (PID: ${result.pid}). Output hidden. Press Ctrl+B to view.`;
-        } else if (result.aborted) {
-          const cancelMsg = timeoutMessage || 'Command cancelled by user.';
-          if (result.output.trim()) {
-            returnDisplayMessage = `${cancelMsg}\n\nOutput before cancellation:\n${result.output}`;
-          } else {
-            returnDisplayMessage = cancelMsg;
-          }
         } else if (result.output.trim()) {
           returnDisplayMessage = result.output;
         } else {
-          if (result.signal) {
+          if (result.aborted) {
+            if (timeoutMessage) {
+              returnDisplayMessage = timeoutMessage;
+            } else {
+              returnDisplayMessage = 'Command cancelled by user.';
+            }
+          } else if (result.signal) {
             returnDisplayMessage = `Command terminated by signal: ${result.signal}`;
           } else if (result.error) {
             returnDisplayMessage = `Command failed: ${getErrorMessage(