Merge branch 'main' of github.com:QwenLM/qwen-code into mingholy/fix/acp-slashcommands

fix: basic slash command support
2025-12-23 18:19:15 +00:00 · 2025-11-18 13:23:12 +08:00 · 2025-11-13 10:32:28 +08:00
362 changed files with 7955 additions and 51271 deletions
--- a/.github/workflows/release-sdk.yml
+++ b/.github/workflows/release-sdk.yml
@@ -1,237 +0,0 @@
-name: 'Release SDK'
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'The version to release (e.g., v0.1.11). Required for manual patch releases.'
-        required: false
-        type: 'string'
-      ref:
-        description: 'The branch or ref (full git sha) to release from.'
-        required: true
-        type: 'string'
-        default: 'main'
-      dry_run:
-        description: 'Run a dry-run of the release process; no branches, npm packages or GitHub releases will be created.'
-        required: true
-        type: 'boolean'
-        default: true
-      create_nightly_release:
-        description: 'Auto apply the nightly release tag, input version is ignored.'
-        required: false
-        type: 'boolean'
-        default: false
-      create_preview_release:
-        description: 'Auto apply the preview release tag, input version is ignored.'
-        required: false
-        type: 'boolean'
-        default: false
-      force_skip_tests:
-        description: 'Select to skip the "Run Tests" step in testing. Prod releases should run tests'
-        required: false
-        type: 'boolean'
-        default: false
-
-jobs:
-  release-sdk:
-    runs-on: 'ubuntu-latest'
-    environment:
-      name: 'production-release'
-      url: '${{ github.server_url }}/${{ github.repository }}/releases/tag/sdk-typescript-${{ steps.version.outputs.RELEASE_TAG }}'
-    if: |-
-      ${{ github.repository == 'QwenLM/qwen-code' }}
-    permissions:
-      contents: 'write'
-      packages: 'write'
-      id-token: 'write'
-      issues: 'write'
-    outputs:
-      RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
-
-    steps:
-      - name: 'Checkout'
-        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
-        with:
-          ref: '${{ github.event.inputs.ref || github.sha }}'
-          fetch-depth: 0
-
-      - name: 'Set booleans for simplified logic'
-        env:
-          CREATE_NIGHTLY_RELEASE: '${{ github.event.inputs.create_nightly_release }}'
-          CREATE_PREVIEW_RELEASE: '${{ github.event.inputs.create_preview_release }}'
-          DRY_RUN_INPUT: '${{ github.event.inputs.dry_run }}'
-        id: 'vars'
-        run: |-
-          is_nightly="false"
-          if [[ "${CREATE_NIGHTLY_RELEASE}" == "true" ]]; then
-            is_nightly="true"
-          fi
-          echo "is_nightly=${is_nightly}" >> "${GITHUB_OUTPUT}"
-
-          is_preview="false"
-          if [[ "${CREATE_PREVIEW_RELEASE}" == "true" ]]; then
-            is_preview="true"
-          fi
-          echo "is_preview=${is_preview}" >> "${GITHUB_OUTPUT}"
-
-          is_dry_run="false"
-          if [[ "${DRY_RUN_INPUT}" == "true" ]]; then
-            is_dry_run="true"
-          fi
-          echo "is_dry_run=${is_dry_run}" >> "${GITHUB_OUTPUT}"
-
-      - name: 'Setup Node.js'
-        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          cache: 'npm'
-
-      - name: 'Install Dependencies'
-        run: |-
-          npm ci
-
-      - name: 'Get the version'
-        id: 'version'
-        run: |
-          VERSION_ARGS=()
-          if [[ "${IS_NIGHTLY}" == "true" ]]; then
-            VERSION_ARGS+=(--type=nightly)
-          elif [[ "${IS_PREVIEW}" == "true" ]]; then
-            VERSION_ARGS+=(--type=preview)
-            if [[ -n "${MANUAL_VERSION}" ]]; then
-              VERSION_ARGS+=("--preview_version_override=${MANUAL_VERSION}")
-            fi
-          else
-            VERSION_ARGS+=(--type=stable)
-            if [[ -n "${MANUAL_VERSION}" ]]; then
-              VERSION_ARGS+=("--stable_version_override=${MANUAL_VERSION}")
-            fi
-          fi
-
-          VERSION_JSON=$(node packages/sdk-typescript/scripts/get-release-version.js "${VERSION_ARGS[@]}")
-          echo "RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .releaseTag)" >> "$GITHUB_OUTPUT"
-          echo "RELEASE_VERSION=$(echo "$VERSION_JSON" | jq -r .releaseVersion)" >> "$GITHUB_OUTPUT"
-          echo "NPM_TAG=$(echo "$VERSION_JSON" | jq -r .npmTag)" >> "$GITHUB_OUTPUT"
-
-          echo "PREVIOUS_RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .previousReleaseTag)" >> "$GITHUB_OUTPUT"
-        env:
-          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
-          IS_NIGHTLY: '${{ steps.vars.outputs.is_nightly }}'
-          IS_PREVIEW: '${{ steps.vars.outputs.is_preview }}'
-          MANUAL_VERSION: '${{ inputs.version }}'
-
-      - name: 'Run Tests'
-        if: |-
-          ${{ github.event.inputs.force_skip_tests != 'true' }}
-        working-directory: 'packages/sdk-typescript'
-        run: |
-          npm run test:ci
-        env:
-          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
-          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
-          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
-
-      - name: 'Build CLI for Integration Tests'
-        if: |-
-          ${{ github.event.inputs.force_skip_tests != 'true' }}
-        run: |
-          npm run build
-          npm run bundle
-
-      - name: 'Run SDK Integration Tests'
-        if: |-
-          ${{ github.event.inputs.force_skip_tests != 'true' }}
-        run: |
-          npm run test:integration:sdk:sandbox:none
-          npm run test:integration:sdk:sandbox:docker
-        env:
-          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
-          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
-          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
-
-      - name: 'Configure Git User'
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: 'Create and switch to a release branch'
-        id: 'release_branch'
-        env:
-          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
-        run: |-
-          BRANCH_NAME="release/sdk-typescript/${RELEASE_TAG}"
-          git switch -c "${BRANCH_NAME}"
-          echo "BRANCH_NAME=${BRANCH_NAME}" >> "${GITHUB_OUTPUT}"
-
-      - name: 'Update package version'
-        working-directory: 'packages/sdk-typescript'
-        env:
-          RELEASE_VERSION: '${{ steps.version.outputs.RELEASE_VERSION }}'
-        run: |-
-          npm version "${RELEASE_VERSION}" --no-git-tag-version --allow-same-version
-
-      - name: 'Commit and Conditionally Push package version'
-        env:
-          BRANCH_NAME: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
-          IS_DRY_RUN: '${{ steps.vars.outputs.is_dry_run }}'
-          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
-        run: |-
-          git add packages/sdk-typescript/package.json
-          if git diff --staged --quiet; then
-            echo "No version changes to commit"
-          else
-            git commit -m "chore(release): sdk-typescript ${RELEASE_TAG}"
-          fi
-          if [[ "${IS_DRY_RUN}" == "false" ]]; then
-            echo "Pushing release branch to remote..."
-            git push --set-upstream origin "${BRANCH_NAME}" --follow-tags
-          else
-            echo "Dry run enabled. Skipping push."
-          fi
-
-      - name: 'Build SDK'
-        working-directory: 'packages/sdk-typescript'
-        run: |-
-          npm run build
-
-      - name: 'Configure npm for publishing'
-        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          registry-url: 'https://registry.npmjs.org'
-          scope: '@qwen-code'
-
-      - name: 'Publish @qwen-code/sdk'
-        working-directory: 'packages/sdk-typescript'
-        run: |-
-          npm publish --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}
-        env:
-          NODE_AUTH_TOKEN: '${{ secrets.NPM_TOKEN }}'
-
-      - name: 'Create GitHub Release and Tag'
-        if: |-
-          ${{ steps.vars.outputs.is_dry_run == 'false' }}
-        env:
-          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
-          RELEASE_BRANCH: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
-          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
-          PREVIOUS_RELEASE_TAG: '${{ steps.version.outputs.PREVIOUS_RELEASE_TAG }}'
-        run: |-
-          gh release create "sdk-typescript-${RELEASE_TAG}" \
-            --target "$RELEASE_BRANCH" \
-            --title "SDK TypeScript Release ${RELEASE_TAG}" \
-            --notes-start-tag "sdk-typescript-${PREVIOUS_RELEASE_TAG}" \
-            --generate-notes
-
-      - name: 'Create Issue on Failure'
-        if: |-
-          ${{ failure() }}
-        env:
-          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
-          RELEASE_TAG: "${{ steps.version.outputs.RELEASE_TAG || 'N/A' }}"
-          DETAILS_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
-        run: |-
-          gh issue create \
-            --title "SDK Release Failed for ${RELEASE_TAG} on $(date +'%Y-%m-%d')" \
-            --body "The SDK release workflow failed. See the full run for details: ${DETAILS_URL}"
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -224,4 +224,5 @@ jobs:
        run: |-
          gh issue create \
            --title "Release Failed for ${RELEASE_TAG} on $(date +'%Y-%m-%d')" \
-            --body "The release workflow failed. See the full run for details: ${DETAILS_URL}"
+            --body "The release workflow failed. See the full run for details: ${DETAILS_URL}" \
+            --label "kind/bug,release-failure"
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -73,15 +73,7 @@
      "request": "launch",
      "name": "Launch CLI Non-Interactive",
      "runtimeExecutable": "npm",
-      "runtimeArgs": [
-        "run",
-        "start",
-        "--",
-        "-p",
-        "${input:prompt}",
-        "--output-format",
-        "stream-json"
-      ],
+      "runtimeArgs": ["run", "start", "--", "-p", "${input:prompt}", "-y"],
      "skipFiles": ["<node_internals>/**"],
      "cwd": "${workspaceFolder}",
      "console": "integratedTerminal",
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@
  
 </div>

-Qwen Code is a powerful command-line AI workflow tool adapted from [**Gemini CLI**](https://github.com/google-gemini/gemini-cli), specifically optimized for [Qwen3-Coder](https://github.com/QwenLM/Qwen3-Coder) models. It enhances your development workflow with advanced code understanding, automated tasks, and intelligent assistance.
+Qwen Code is a powerful command-line AI workflow tool adapted from [**Gemini CLI**](https://github.com/google-gemini/gemini-cli) ([details](./README.gemini.md)), specifically optimized for [Qwen3-Coder](https://github.com/QwenLM/Qwen3-Coder) models. It enhances your development workflow with advanced code understanding, automated tasks, and intelligent assistance.

 ## 💡 Free Options Available

--- a/docs/cli/commands.md
+++ b/docs/cli/commands.md
@@ -11,8 +11,31 @@ Slash commands provide meta-level control over the CLI itself.
 - **`/bug`**
  - **Description:** File an issue about Qwen Code. By default, the issue is filed within the GitHub repository for Qwen Code. The string you enter after `/bug` will become the headline for the bug being filed. The default `/bug` behavior can be modified using the `advanced.bugCommand` setting in your `.qwen/settings.json` files.

- **`/clear`** (aliases: `reset`, `new`)
-  - **Description:** Clear conversation history and free up context by starting a fresh session. Also clears the terminal output and scrollback within the CLI.
+- **`/chat`**
+  - **Description:** Save and resume conversation history for branching conversation state interactively, or resuming a previous state from a later session.
+  - **Sub-commands:**
+    - **`save`**
+      - **Description:** Saves the current conversation history. You must add a `<tag>` for identifying the conversation state.
+      - **Usage:** `/chat save <tag>`
+      - **Details on Checkpoint Location:** The default locations for saved chat checkpoints are:
+        - Linux/macOS: `~/.qwen/tmp/<project_hash>/`
+        - Windows: `C:\Users\<YourUsername>\.qwen\tmp\<project_hash>\`
+        - When you run `/chat list`, the CLI only scans these specific directories to find available checkpoints.
+        - **Note:** These checkpoints are for manually saving and resuming conversation states. For automatic checkpoints created before file modifications, see the [Checkpointing documentation](../checkpointing.md).
+    - **`resume`**
+      - **Description:** Resumes a conversation from a previous save.
+      - **Usage:** `/chat resume <tag>`
+    - **`list`**
+      - **Description:** Lists available tags for chat state resumption.
+    - **`delete`**
+      - **Description:** Deletes a saved conversation checkpoint.
+      - **Usage:** `/chat delete <tag>`
+    - **`share`**
+      - **Description** Writes the current conversation to a provided Markdown or JSON file.
+      - **Usage** `/chat share file.md` or `/chat share file.json`. If no filename is provided, then the CLI will generate one.
+
+- **`/clear`**
+  - **Description:** Clear the terminal screen, including the visible session history and scrollback within the CLI. The underlying session data (for history recall) might be preserved depending on the exact implementation, but the visual display is cleared.
  - **Keyboard shortcut:** Press **Ctrl+L** at any time to perform a clear action.

 - **`/summary`**
@@ -145,6 +168,16 @@ Slash commands provide meta-level control over the CLI itself.
    - **`nodesc`** or **`nodescriptions`**:
      - **Description:** Hide tool descriptions, showing only the tool names.

+- **`/quit-confirm`**
+  - **Description:** Show a confirmation dialog before exiting Qwen Code, allowing you to choose how to handle your current session.
+  - **Usage:** `/quit-confirm`
+  - **Features:**
+    - **Quit immediately:** Exit without saving anything (equivalent to `/quit`)
+    - **Generate summary and quit:** Create a project summary using `/summary` before exiting
+    - **Save conversation and quit:** Save the current conversation with an auto-generated tag before exiting
+  - **Keyboard shortcut:** Press **Ctrl+C** twice to trigger the quit confirmation dialog
+  - **Note:** This command is automatically triggered when you press Ctrl+C once, providing a safety mechanism to prevent accidental exits.
+
 - **`/quit`** (or **`/exit`**)
  - **Description:** Exit Qwen Code immediately without any confirmation dialog.

@@ -162,16 +195,6 @@ Slash commands provide meta-level control over the CLI itself.
 - **`/init`**
  - **Description:** Analyzes the current directory and creates a `QWEN.md` context file by default (or the filename specified by `contextFileName`). If a non-empty file already exists, no changes are made. The command seeds an empty file and prompts the model to populate it with project-specific instructions.

- [**`/language`**](./language.md)
-  - **Description:** View or change the language setting for both UI and LLM output.
-  - **Sub-commands:**
-    - **`ui`**: Set the UI language (zh-CN or en-US)
-    - **`output`**: Set the LLM output language
-  - **Usage:** `/language [ui|output] [language]`
-  - **Examples:**
-    - `/language ui zh-CN` (set UI language to Simplified Chinese)
-    - `/language output English` (set LLM output language to English)
-
 ### Custom Commands

 For a quick start, see the [example](#example-a-pure-function-refactoring-command) below.
--- a/docs/cli/configuration-v1.md
+++ b/docs/cli/configuration-v1.md
@@ -671,4 +671,4 @@ Note: When usage statistics are enabled, events are sent to an Alibaba Cloud RUM
  - **Category:** UI
  - **Requires Restart:** No
  - **Example:** `"enableWelcomeBack": false`
-  - **Details:** When enabled, Qwen Code will automatically detect if you're returning to a project with a previously generated project summary (`.qwen/PROJECT_SUMMARY.md`) and show a dialog allowing you to continue your previous conversation or start fresh. This feature integrates with the `/summary` command. See the [Welcome Back documentation](./welcome-back.md) for more details.
+  - **Details:** When enabled, Qwen Code will automatically detect if you're returning to a project with a previously generated project summary (`.qwen/PROJECT_SUMMARY.md`) and show a dialog allowing you to continue your previous conversation or start fresh. This feature integrates with the `/chat summary` command and quit confirmation dialog. See the [Welcome Back documentation](./welcome-back.md) for more details.
--- a/docs/cli/configuration.md
+++ b/docs/cli/configuration.md
@@ -548,31 +548,12 @@ Arguments passed directly when running the CLI can override other configurations
  - The prompt is processed within the interactive session, not before it.
  - Cannot be used when piping input from stdin.
  - Example: `qwen -i "explain this code"`
- **`--continue`**:
-  - Resume the most recent session for the current project (current working directory).
-  - Works in interactive and headless modes (e.g., `qwen --continue -p "Keep going"`).
- **`--resume [sessionId]`**:
-  - Resume a specific session for the current project. When called without an ID, an interactive picker lists only this project's sessions with prompt preview, timestamps, message count, and optional git branch.
-  - If an ID is provided and not found for this project, the CLI exits with an error.
- **`--output-format <format>`** (**`-o <format>`**):
+- **`--output-format <format>`**:
  - **Description:** Specifies the format of the CLI output for non-interactive mode.
  - **Values:**
    - `text`: (Default) The standard human-readable output.
-    - `json`: A machine-readable JSON output emitted at the end of execution.
-    - `stream-json`: Streaming JSON messages emitted as they occur during execution.
-  - **Note:** For structured output and scripting, use the `--output-format json` or `--output-format stream-json` flag. See [Headless Mode](../features/headless.md) for detailed information.
- **`--input-format <format>`**:
-  - **Description:** Specifies the format consumed from standard input.
-  - **Values:**
-    - `text`: (Default) Standard text input from stdin or command-line arguments.
-    - `stream-json`: JSON message protocol via stdin for bidirectional communication.
-  - **Requirement:** `--input-format stream-json` requires `--output-format stream-json` to be set.
-  - **Note:** When using `stream-json`, stdin is reserved for protocol messages. See [Headless Mode](../features/headless.md) for detailed information.
- **`--include-partial-messages`**:
-  - **Description:** Include partial assistant messages when using `stream-json` output format. When enabled, emits stream events (message_start, content_block_delta, etc.) as they occur during streaming.
-  - **Default:** `false`
-  - **Requirement:** Requires `--output-format stream-json` to be set.
-  - **Note:** See [Headless Mode](../features/headless.md) for detailed information about stream events.
+    - `json`: A machine-readable JSON output.
+  - **Note:** For structured output and scripting, use the `--output-format json` flag.
 - **`--sandbox`** (**`-s`**):
  - Enables sandbox mode for this session.
 - **`--sandbox-image`**:
--- a/docs/cli/language.md
+++ b/docs/cli/language.md
@@ -1,71 +0,0 @@
-# Language Command
-
-The `/language` command allows you to customize the language settings for both the Qwen Code user interface (UI) and the language model's output. This command supports two distinct functionalities:
-
-1. Setting the UI language for the Qwen Code interface
-2. Setting the output language for the language model (LLM)
-
-## UI Language Settings
-
-To change the UI language of Qwen Code, use the `ui` subcommand:
-
-```
-/language ui [zh-CN|en-US]
-```
-
-### Available UI Languages
-
- **zh-CN**: Simplified Chinese (简体中文)
- **en-US**: English
-
-### Examples
-
-```
-/language ui zh-CN    # Set UI language to Simplified Chinese
-/language ui en-US    # Set UI language to English
-```
-
-### UI Language Subcommands
-
-You can also use direct subcommands for convenience:
-
- `/language ui zh-CN` or `/language ui zh` or `/language ui 中文`
- `/language ui en-US` or `/language ui en` or `/language ui english`
-
-## LLM Output Language Settings
-
-To set the language for the language model's responses, use the `output` subcommand:
-
-```
-/language output <language>
-```
-
-This command generates a language rule file that instructs the LLM to respond in the specified language. The rule file is saved to `~/.qwen/output-language.md`.
-
-### Examples
-
-```
-/language output 中文      # Set LLM output language to Chinese
-/language output English   # Set LLM output language to English
-/language output 日本語    # Set LLM output language to Japanese
-```
-
-## Viewing Current Settings
-
-When used without arguments, the `/language` command displays the current language settings:
-
-```
-/language
-```
-
-This will show:
-
- Current UI language
- Current LLM output language (if set)
- Available subcommands
-
-## Notes
-
- UI language changes take effect immediately and reload all command descriptions
- LLM output language settings are persisted in a rule file that is automatically included in the model's context
- To request additional UI language packs, please open an issue on GitHub
--- a/docs/features/headless.md
+++ b/docs/features/headless.md
@@ -13,9 +13,8 @@ scripting, automation, CI/CD pipelines, and building AI-powered tools.
  - [Output Formats](#output-formats)
    - [Text Output (Default)](#text-output-default)
    - [JSON Output](#json-output)
+      - [Response Schema](#response-schema)
      - [Example Usage](#example-usage)
-    - [Stream-JSON Output](#stream-json-output)
-    - [Input Format](#input-format)
    - [File Redirection](#file-redirection)
  - [Configuration Options](#configuration-options)
  - [Examples](#examples)
@@ -23,7 +22,7 @@ scripting, automation, CI/CD pipelines, and building AI-powered tools.
    - [Generate commit messages](#generate-commit-messages)
    - [API documentation](#api-documentation)
    - [Batch code analysis](#batch-code-analysis)
-    - [PR code review](#pr-code-review)
+    - [Code review](#code-review-1)
    - [Log analysis](#log-analysis)
    - [Release notes generation](#release-notes-generation)
    - [Model and tool usage tracking](#model-and-tool-usage-tracking)
@@ -38,7 +37,6 @@ The headless mode provides a headless interface to Qwen Code that:
 - Supports file redirection and piping
 - Enables automation and scripting workflows
 - Provides consistent exit codes for error handling
- Can resume previous sessions scoped to the current project for multi-step automation

 ## Basic Usage

@@ -66,27 +64,8 @@ Read from files and process with Qwen Code:
 cat README.md | qwen --prompt "Summarize this documentation"
 ```

-### Resume Previous Sessions (Headless)
-
-Reuse conversation context from the current project in headless scripts:
-
-```bash
-# Continue the most recent session for this project and run a new prompt
-qwen --continue -p "Run the tests again and summarize failures"
-
-# Resume a specific session ID directly (no UI)
-qwen --resume 123e4567-e89b-12d3-a456-426614174000 -p "Apply the follow-up refactor"
-```
-
-Notes:
-
- Session data is project-scoped JSONL under `~/.qwen/projects/<sanitized-cwd>/chats`.
- Restores conversation history, tool outputs, and chat-compression checkpoints before sending the new prompt.
-
 ## Output Formats

-Qwen Code supports multiple output formats for different use cases:
-
 ### Text Output (Default)

 Standard human-readable output:
@@ -103,9 +82,56 @@ The capital of France is Paris.

 ### JSON Output

-Returns structured data as a JSON array. All messages are buffered and output together when the session completes. This format is ideal for programmatic processing and automation scripts.
+Returns structured data including response, statistics, and metadata. This
+format is ideal for programmatic processing and automation scripts.

-The JSON output is an array of message objects. The output includes multiple message types: system messages (session initialization), assistant messages (AI responses), and result messages (execution summary).
+#### Response Schema
+
+The JSON output follows this high-level structure:
+
+```json
+{
+  "response": "string", // The main AI-generated content answering your prompt
+  "stats": {
+    // Usage metrics and performance data
+    "models": {
+      // Per-model API and token usage statistics
+      "[model-name]": {
+        "api": {
+          /* request counts, errors, latency */
+        },
+        "tokens": {
+          /* prompt, response, cached, total counts */
+        }
+      }
+    },
+    "tools": {
+      // Tool execution statistics
+      "totalCalls": "number",
+      "totalSuccess": "number",
+      "totalFail": "number",
+      "totalDurationMs": "number",
+      "totalDecisions": {
+        /* accept, reject, modify, auto_accept counts */
+      },
+      "byName": {
+        /* per-tool detailed stats */
+      }
+    },
+    "files": {
+      // File modification statistics
+      "totalLinesAdded": "number",
+      "totalLinesRemoved": "number"
+    }
+  },
+  "error": {
+    // Present only when an error occurred
+    "type": "string", // Error type (e.g., "ApiError", "AuthError")
+    "message": "string", // Human-readable error description
+    "code": "number" // Optional error code
+  }
+}
+```

 #### Example Usage

@@ -113,81 +139,63 @@ The JSON output is an array of message objects. The output includes multiple mes
 qwen -p "What is the capital of France?" --output-format json
 ```

-Output (at end of execution):
+Response:

 ```json
-[
-  {
-    "type": "system",
-    "subtype": "session_start",
-    "uuid": "...",
-    "session_id": "...",
-    "model": "qwen3-coder-plus",
-    ...
-  },
-  {
-    "type": "assistant",
-    "uuid": "...",
-    "session_id": "...",
-    "message": {
-      "id": "...",
-      "type": "message",
-      "role": "assistant",
-      "model": "qwen3-coder-plus",
-      "content": [
-        {
-          "type": "text",
-          "text": "The capital of France is Paris."
+{
+  "response": "The capital of France is Paris.",
+  "stats": {
+    "models": {
+      "qwen3-coder-plus": {
+        "api": {
+          "totalRequests": 2,
+          "totalErrors": 0,
+          "totalLatencyMs": 5053
+        },
+        "tokens": {
+          "prompt": 24939,
+          "candidates": 20,
+          "total": 25113,
+          "cached": 21263,
+          "thoughts": 154,
+          "tool": 0
        }
-      ],
-      "usage": {...}
+      }
    },
-    "parent_tool_use_id": null
-  },
-  {
-    "type": "result",
-    "subtype": "success",
-    "uuid": "...",
-    "session_id": "...",
-    "is_error": false,
-    "duration_ms": 1234,
-    "result": "The capital of France is Paris.",
-    "usage": {...}
+    "tools": {
+      "totalCalls": 1,
+      "totalSuccess": 1,
+      "totalFail": 0,
+      "totalDurationMs": 1881,
+      "totalDecisions": {
+        "accept": 0,
+        "reject": 0,
+        "modify": 0,
+        "auto_accept": 1
+      },
+      "byName": {
+        "google_web_search": {
+          "count": 1,
+          "success": 1,
+          "fail": 0,
+          "durationMs": 1881,
+          "decisions": {
+            "accept": 0,
+            "reject": 0,
+            "modify": 0,
+            "auto_accept": 1
+          }
+        }
+      }
+    },
+    "files": {
+      "totalLinesAdded": 0,
+      "totalLinesRemoved": 0
+    }
  }
-]
+}
 ```

-### Stream-JSON Output
-
-Stream-JSON format emits JSON messages immediately as they occur during execution, enabling real-time monitoring. This format uses line-delimited JSON where each message is a complete JSON object on a single line.
-
-```bash
-qwen -p "Explain TypeScript" --output-format stream-json
-```
-
-Output (streaming as events occur):
-
-```json
-{"type":"system","subtype":"session_start","uuid":"...","session_id":"..."}
-{"type":"assistant","uuid":"...","session_id":"...","message":{...}}
-{"type":"result","subtype":"success","uuid":"...","session_id":"..."}
-```
-
-When combined with `--include-partial-messages`, additional stream events are emitted in real-time (message_start, content_block_delta, etc.) for real-time UI updates.
-
-```bash
-qwen -p "Write a Python script" --output-format stream-json --include-partial-messages
-```
-
-### Input Format
-
-The `--input-format` parameter controls how Qwen Code consumes input from standard input:
-
- **`text`** (default): Standard text input from stdin or command-line arguments
- **`stream-json`**: JSON message protocol via stdin for bidirectional communication
-
-> **Note:** Stream-json input mode is currently under construction and is intended for SDK integration. It requires `--output-format stream-json` to be set.
-
 ### File Redirection

 Save output to files or pipe to other commands:
@@ -204,55 +212,48 @@ qwen -p "Add more details" >> docker-explanation.txt
 qwen -p "What is Kubernetes?" --output-format json | jq '.response'
 qwen -p "Explain microservices" | wc -w
 qwen -p "List programming languages" | grep -i "python"
-
-# Stream-JSON output for real-time processing
-qwen -p "Explain Docker" --output-format stream-json | jq '.type'
-qwen -p "Write code" --output-format stream-json --include-partial-messages | jq '.event.type'
 ```

 ## Configuration Options

 Key command-line options for headless usage:

-| Option                       | Description                                         | Example                                                                  |
-| ---------------------------- | --------------------------------------------------- | ------------------------------------------------------------------------ |
-| `--prompt`, `-p`             | Run in headless mode                                | `qwen -p "query"`                                                        |
-| `--output-format`, `-o`      | Specify output format (text, json, stream-json)     | `qwen -p "query" --output-format json`                                   |
-| `--input-format`             | Specify input format (text, stream-json)            | `qwen --input-format text --output-format stream-json`                   |
-| `--include-partial-messages` | Include partial messages in stream-json output      | `qwen -p "query" --output-format stream-json --include-partial-messages` |
-| `--debug`, `-d`              | Enable debug mode                                   | `qwen -p "query" --debug`                                                |
-| `--all-files`, `-a`          | Include all files in context                        | `qwen -p "query" --all-files`                                            |
-| `--include-directories`      | Include additional directories                      | `qwen -p "query" --include-directories src,docs`                         |
-| `--yolo`, `-y`               | Auto-approve all actions                            | `qwen -p "query" --yolo`                                                 |
-| `--approval-mode`            | Set approval mode                                   | `qwen -p "query" --approval-mode auto_edit`                              |
-| `--continue`                 | Resume the most recent session for this project     | `qwen --continue -p "Pick up where we left off"`                         |
-| `--resume [sessionId]`       | Resume a specific session (or choose interactively) | `qwen --resume 123e... -p "Finish the refactor"`                         |
+| Option                  | Description                        | Example                                          |
+| ----------------------- | ---------------------------------- | ------------------------------------------------ |
+| `--prompt`, `-p`        | Run in headless mode               | `qwen -p "query"`                                |
+| `--output-format`       | Specify output format (text, json) | `qwen -p "query" --output-format json`           |
+| `--model`, `-m`         | Specify the Qwen model             | `qwen -p "query" -m qwen3-coder-plus`            |
+| `--debug`, `-d`         | Enable debug mode                  | `qwen -p "query" --debug`                        |
+| `--all-files`, `-a`     | Include all files in context       | `qwen -p "query" --all-files`                    |
+| `--include-directories` | Include additional directories     | `qwen -p "query" --include-directories src,docs` |
+| `--yolo`, `-y`          | Auto-approve all actions           | `qwen -p "query" --yolo`                         |
+| `--approval-mode`       | Set approval mode                  | `qwen -p "query" --approval-mode auto_edit`      |

 For complete details on all available configuration options, settings files, and environment variables, see the [Configuration Guide](./cli/configuration.md).

 ## Examples

-### Code review
+#### Code review

 ```bash
 cat src/auth.py | qwen -p "Review this authentication code for security issues" > security-review.txt
 ```

-### Generate commit messages
+#### Generate commit messages

 ```bash
 result=$(git diff --cached | qwen -p "Write a concise commit message for these changes" --output-format json)
 echo "$result" | jq -r '.response'
 ```

-### API documentation
+#### API documentation

 ```bash
 result=$(cat api/routes.js | qwen -p "Generate OpenAPI spec for these routes" --output-format json)
 echo "$result" | jq -r '.response' > openapi.json
 ```

-### Batch code analysis
+#### Batch code analysis

 ```bash
 for file in src/*.py; do
@@ -263,20 +264,20 @@ for file in src/*.py; do
 done
 ```

-### PR code review
+#### Code review

 ```bash
 result=$(git diff origin/main...HEAD | qwen -p "Review these changes for bugs, security issues, and code quality" --output-format json)
 echo "$result" | jq -r '.response' > pr-review.json
 ```

-### Log analysis
+#### Log analysis

 ```bash
 grep "ERROR" /var/log/app.log | tail -20 | qwen -p "Analyze these errors and suggest root cause and fixes" > error-analysis.txt
 ```

-### Release notes generation
+#### Release notes generation

 ```bash
 result=$(git log --oneline v1.0.0..HEAD | qwen -p "Generate release notes from these commits" --output-format json)
@@ -285,7 +286,7 @@ echo "$response"
 echo "$response" >> CHANGELOG.md
 ```

-### Model and tool usage tracking
+#### Model and tool usage tracking

 ```bash
 result=$(qwen -p "Explain this database schema" --include-directories db --output-format json)
--- a/docs/features/subagents.md
+++ b/docs/features/subagents.md
@@ -106,7 +106,7 @@ Subagents are configured using Markdown files with YAML frontmatter. This format
 ---
 name: agent-name
 description: Brief description of when and how to use this agent
-tools:
+tools: 
  - tool1
  - tool2
  - tool3 # Optional
@@ -170,7 +170,7 @@ Perfect for comprehensive test creation and test-driven development.
 ---
 name: testing-expert
 description: Writes comprehensive unit tests, integration tests, and handles test automation with best practices
-tools:
+tools: 
  - read_file
  - write_file
  - read_many_files
@@ -214,7 +214,7 @@ Specialized in creating clear, comprehensive documentation.
 ---
 name: documentation-writer
 description: Creates comprehensive documentation, README files, API docs, and user guides
-tools:
+tools: 
  - read_file
  - write_file
  - read_many_files
@@ -267,7 +267,7 @@ Focused on code quality, security, and best practices.
 ---
 name: code-reviewer
 description: Reviews code for best practices, security issues, performance, and maintainability
-tools:
+tools: 
  - read_file
  - read_many_files
 ---
@@ -311,7 +311,7 @@ Optimized for React development, hooks, and component patterns.
 ---
 name: react-specialist
 description: Expert in React development, hooks, component patterns, and modern React best practices
-tools:
+tools: 
  - read_file
  - write_file
  - read_many_files
--- a/docs/features/welcome-back.md
+++ b/docs/features/welcome-back.md
@@ -75,12 +75,20 @@ Add to your `.qwen/settings.json`:

 ### Project Summary Generation

-The Welcome Back feature works seamlessly with the `/summary` command:
+The Welcome Back feature works seamlessly with the `/chat summary` command:

-1. **Generate Summary:** Use `/summary` to create a project summary
+1. **Generate Summary:** Use `/chat summary` to create a project summary
 2. **Automatic Detection:** Next time you start Qwen Code in this project, Welcome Back will detect the summary
 3. **Resume Work:** Choose to continue and the summary will be loaded as context

+### Quit Confirmation
+
+When exiting with `/quit-confirm` and choosing "Generate summary and quit":
+
+1. A project summary is automatically created
+2. Next session will trigger the Welcome Back dialog
+3. You can seamlessly continue your work
+
 ## File Structure

 The Welcome Back feature creates and uses:
--- a/docs/index.md
+++ b/docs/index.md
@@ -72,7 +72,7 @@ Create or edit `.qwen/settings.json` in your home directory:
 #### Session Commands

 - **`/compress`** - Compress conversation history to continue within token limits
- **`/clear`** (aliases: `/reset`, `/new`) - Clear conversation history, start a fresh session, and free up context
+- **`/clear`** - Clear all conversation history and start fresh
 - **`/stats`** - Check current token usage and limits

 > 📝 **Note**: Session token limit applies to a single conversation, not cumulative API calls.
@@ -332,7 +332,7 @@ qwen
 ### Session Commands

 - `/help` - Display available commands
- `/clear` (aliases: `/reset`, `/new`) - Clear conversation history and start a fresh session
+- `/clear` - Clear conversation history
 - `/compress` - Compress history to save tokens
 - `/stats` - Show current session information
 - `/exit` or `/quit` - Exit Qwen Code
--- a/docs/support/troubleshooting.md
+++ b/docs/support/troubleshooting.md
@@ -14,13 +14,6 @@ This guide provides solutions to common issues and debugging tips, including top
  - **Solution:** Set the `NODE_EXTRA_CA_CERTS` environment variable to the absolute path of your corporate root CA certificate file.
    - Example: `export NODE_EXTRA_CA_CERTS=/path/to/your/corporate-ca.crt`

- **Issue: Unable to display UI after authentication failure**
-  - **Cause:** If authentication fails after selecting an authentication type, the `security.auth.selectedType` setting may be persisted in `settings.json`. On restart, the CLI may get stuck trying to authenticate with the failed auth type and fail to display the UI.
-  - **Solution:** Clear the `security.auth.selectedType` configuration item in your `settings.json` file:
-    - Open `~/.qwen/settings.json` (or `./.qwen/settings.json` for project-specific settings)
-    - Remove the `security.auth.selectedType` field
-    - Restart the CLI to allow it to prompt for authentication again
-
 ## Frequently asked questions (FAQs)

 - **Q: How do I update Qwen Code to the latest version?**
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -22,7 +22,6 @@ export default tseslint.config(
      'bundle/**',
      'package/bundle/**',
      '.integration-tests/**',
-      'packages/**/.integration-test/**',
      'dist/**',
    ],
  },
@@ -151,7 +150,7 @@ export default tseslint.config(
    },
  },
  {
-    files: ['packages/*/src/**/*.test.{ts,tsx}', 'packages/**/test/**/*.test.{ts,tsx}'],
+    files: ['packages/*/src/**/*.test.{ts,tsx}'],
    plugins: {
      vitest,
    },
@@ -159,19 +158,11 @@ export default tseslint.config(
      ...vitest.configs.recommended.rules,
      'vitest/expect-expect': 'off',
      'vitest/no-commented-out-tests': 'off',
-      '@typescript-eslint/no-unused-vars': [
-        'error',
-        {
-          argsIgnorePattern: '^_',
-          varsIgnorePattern: '^_',
-          caughtErrorsIgnorePattern: '^_',
-        },
-      ],
    },
  },
  // extra settings for scripts that we run directly with node
  {
-    files: ['./scripts/**/*.js', 'esbuild.config.js', 'packages/*/scripts/**/*.js'],
+    files: ['./scripts/**/*.js', 'esbuild.config.js'],
    languageOptions: {
      globals: {
        ...globals.node,
@@ -238,7 +229,7 @@ export default tseslint.config(
  prettierConfig,
  // extra settings for scripts that we run directly with node
  {
-    files: ['./integration-tests/**/*.{js,ts,tsx}'],
+    files: ['./integration-tests/**/*.js'],
    languageOptions: {
      globals: {
        ...globals.node,
--- a/integration-tests/acp-integration.test.ts
+++ b/integration-tests/acp-integration.test.ts
@@ -1,590 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import { setTimeout as delay } from 'node:timers/promises';
-import { describe, expect, it } from 'vitest';
-import { TestRig } from './test-helper.js';
-
-const REQUEST_TIMEOUT_MS = 60_000;
-const INITIAL_PROMPT = 'Create a quick note (smoke test).';
-const RESUME_PROMPT = 'Continue the note after reload.';
-const LIST_SIZE = 5;
-const IS_SANDBOX =
-  process.env['GEMINI_SANDBOX'] &&
-  process.env['GEMINI_SANDBOX']!.toLowerCase() !== 'false';
-
-type PendingRequest = {
-  resolve: (value: unknown) => void;
-  reject: (reason: Error) => void;
-  timeout: NodeJS.Timeout;
-};
-
-type SessionUpdateNotification = {
-  sessionId?: string;
-  update?: {
-    sessionUpdate?: string;
-    availableCommands?: Array<{
-      name: string;
-      description: string;
-      input?: { hint: string } | null;
-    }>;
-    content?: {
-      type: string;
-      text?: string;
-    };
-    modeId?: string;
-  };
-};
-
-type PermissionRequest = {
-  id: number;
-  sessionId?: string;
-  toolCall?: {
-    toolCallId: string;
-    title: string;
-    kind: string;
-    status: string;
-    content?: Array<{
-      type: string;
-      text?: string;
-      path?: string;
-      oldText?: string;
-      newText?: string;
-    }>;
-  };
-  options?: Array<{
-    optionId: string;
-    name: string;
-    kind: string;
-  }>;
-};
-
-type PermissionHandler = (
-  request: PermissionRequest,
-) => { optionId: string } | { outcome: 'cancelled' };
-
-/**
- * Sets up an ACP test environment with all necessary utilities.
- */
-function setupAcpTest(
-  rig: TestRig,
-  options?: { permissionHandler?: PermissionHandler },
-) {
-  const pending = new Map<number, PendingRequest>();
-  let nextRequestId = 1;
-  const sessionUpdates: SessionUpdateNotification[] = [];
-  const permissionRequests: PermissionRequest[] = [];
-  const stderr: string[] = [];
-
-  // Default permission handler: auto-approve all
-  const permissionHandler =
-    options?.permissionHandler ?? (() => ({ optionId: 'proceed_once' }));
-
-  const agent = spawn('node', [rig.bundlePath, '--experimental-acp'], {
-    cwd: rig.testDir!,
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-
-  agent.stderr?.on('data', (chunk) => {
-    stderr.push(chunk.toString());
-  });
-
-  const rl = createInterface({ input: agent.stdout });
-
-  const send = (json: unknown) => {
-    agent.stdin.write(`${JSON.stringify(json)}\n`);
-  };
-
-  const sendResponse = (id: number, result: unknown) => {
-    send({ jsonrpc: '2.0', id, result });
-  };
-
-  const sendRequest = (method: string, params?: unknown) =>
-    new Promise<unknown>((resolve, reject) => {
-      const id = nextRequestId++;
-      const timeout = setTimeout(() => {
-        pending.delete(id);
-        reject(new Error(`Request ${id} (${method}) timed out`));
-      }, REQUEST_TIMEOUT_MS);
-      pending.set(id, { resolve, reject, timeout });
-      send({ jsonrpc: '2.0', id, method, params });
-    });
-
-  const handleResponse = (msg: {
-    id: number;
-    result?: unknown;
-    error?: { message?: string };
-  }) => {
-    const waiter = pending.get(msg.id);
-    if (!waiter) {
-      return;
-    }
-    clearTimeout(waiter.timeout);
-    pending.delete(msg.id);
-    if (msg.error) {
-      waiter.reject(new Error(msg.error.message ?? 'Unknown error'));
-    } else {
-      waiter.resolve(msg.result);
-    }
-  };
-
-  const handleMessage = (msg: {
-    id?: number;
-    method?: string;
-    params?: SessionUpdateNotification & {
-      path?: string;
-      content?: string;
-      sessionId?: string;
-      toolCall?: PermissionRequest['toolCall'];
-      options?: PermissionRequest['options'];
-    };
-    result?: unknown;
-    error?: { message?: string };
-  }) => {
-    if (typeof msg.id !== 'undefined' && ('result' in msg || 'error' in msg)) {
-      handleResponse(
-        msg as {
-          id: number;
-          result?: unknown;
-          error?: { message?: string };
-        },
-      );
-      return;
-    }
-
-    if (msg.method === 'session/update') {
-      sessionUpdates.push({
-        sessionId: msg.params?.sessionId,
-        update: msg.params?.update,
-      });
-      return;
-    }
-
-    if (
-      msg.method === 'session/request_permission' &&
-      typeof msg.id === 'number'
-    ) {
-      // Track permission request
-      const permRequest: PermissionRequest = {
-        id: msg.id,
-        sessionId: msg.params?.sessionId,
-        toolCall: msg.params?.toolCall,
-        options: msg.params?.options,
-      };
-      permissionRequests.push(permRequest);
-
-      // Use custom handler or default
-      const response = permissionHandler(permRequest);
-      if ('outcome' in response) {
-        sendResponse(msg.id, { outcome: response });
-      } else {
-        sendResponse(msg.id, {
-          outcome: { optionId: response.optionId, outcome: 'selected' },
-        });
-      }
-      return;
-    }
-
-    if (msg.method === 'fs/read_text_file' && typeof msg.id === 'number') {
-      try {
-        const content = readFileSync(msg.params?.path ?? '', 'utf8');
-        sendResponse(msg.id, { content });
-      } catch (e) {
-        sendResponse(msg.id, { content: `ERROR: ${(e as Error).message}` });
-      }
-      return;
-    }
-
-    if (msg.method === 'fs/write_text_file' && typeof msg.id === 'number') {
-      try {
-        writeFileSync(
-          msg.params?.path ?? '',
-          msg.params?.content ?? '',
-          'utf8',
-        );
-        sendResponse(msg.id, null);
-      } catch (e) {
-        sendResponse(msg.id, { message: (e as Error).message });
-      }
-    }
-  };
-
-  rl.on('line', (line) => {
-    if (!line.trim()) return;
-    try {
-      const msg = JSON.parse(line);
-      handleMessage(msg);
-    } catch {
-      // Ignore non-JSON output from the agent.
-    }
-  });
-
-  const waitForExit = () =>
-    new Promise<void>((resolve) => {
-      if (agent.exitCode !== null || agent.signalCode) {
-        resolve();
-        return;
-      }
-      agent.once('exit', () => resolve());
-    });
-
-  const cleanup = async () => {
-    rl.close();
-    agent.kill();
-    pending.forEach(({ timeout }) => clearTimeout(timeout));
-    pending.clear();
-    await waitForExit();
-  };
-
-  return {
-    sendRequest,
-    sendResponse,
-    cleanup,
-    stderr,
-    sessionUpdates,
-    permissionRequests,
-  };
-}
-
-(IS_SANDBOX ? describe.skip : describe)('acp integration', () => {
-  it('creates, lists, loads, and resumes a session', async () => {
-    const rig = new TestRig();
-    rig.setup('acp load session');
-
-    const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
-
-    try {
-      const initResult = await sendRequest('initialize', {
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: { readTextFile: true, writeTextFile: true },
-        },
-      });
-      expect(initResult).toBeDefined();
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((initResult as any).agentInfo.version).toBeDefined();
-
-      await sendRequest('authenticate', { methodId: 'openai' });
-
-      const newSession = (await sendRequest('session/new', {
-        cwd: rig.testDir!,
-        mcpServers: [],
-      })) as { sessionId: string };
-      expect(newSession.sessionId).toBeTruthy();
-
-      const promptResult = await sendRequest('session/prompt', {
-        sessionId: newSession.sessionId,
-        prompt: [{ type: 'text', text: INITIAL_PROMPT }],
-      });
-      expect(promptResult).toBeDefined();
-
-      await delay(500);
-
-      const listResult = (await sendRequest('session/list', {
-        cwd: rig.testDir!,
-        size: LIST_SIZE,
-      })) as { items?: Array<{ sessionId: string }> };
-
-      expect(Array.isArray(listResult.items)).toBe(true);
-      expect(listResult.items?.length ?? 0).toBeGreaterThan(0);
-
-      const sessionToLoad = listResult.items![0].sessionId;
-      await sendRequest('session/load', {
-        cwd: rig.testDir!,
-        sessionId: sessionToLoad,
-        mcpServers: [],
-      });
-
-      const resumeResult = await sendRequest('session/prompt', {
-        sessionId: sessionToLoad,
-        prompt: [{ type: 'text', text: RESUME_PROMPT }],
-      });
-      expect(resumeResult).toBeDefined();
-
-      const sessionsWithUpdates = sessionUpdates
-        .map((update) => update.sessionId)
-        .filter(Boolean);
-      expect(sessionsWithUpdates).toContain(sessionToLoad);
-    } catch (e) {
-      if (stderr.length) {
-        console.error('Agent stderr:', stderr.join(''));
-      }
-      throw e;
-    } finally {
-      await cleanup();
-    }
-  });
-
-  it('returns modes on initialize and allows setting approval mode', async () => {
-    const rig = new TestRig();
-    rig.setup('acp approval mode');
-
-    const { sendRequest, cleanup, stderr } = setupAcpTest(rig);
-
-    try {
-      // Test 1: Initialize and verify modes are returned
-      const initResult = (await sendRequest('initialize', {
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: { readTextFile: true, writeTextFile: true },
-        },
-      })) as {
-        protocolVersion: number;
-        modes: {
-          currentModeId: string;
-          availableModes: Array<{
-            id: string;
-            name: string;
-            description: string;
-          }>;
-        };
-      };
-
-      expect(initResult).toBeDefined();
-      expect(initResult.protocolVersion).toBe(1);
-
-      // Verify modes data is present
-      expect(initResult.modes).toBeDefined();
-      expect(initResult.modes.currentModeId).toBeDefined();
-      expect(Array.isArray(initResult.modes.availableModes)).toBe(true);
-      expect(initResult.modes.availableModes.length).toBeGreaterThan(0);
-
-      // Verify available modes have expected structure
-      const modeIds = initResult.modes.availableModes.map((m) => m.id);
-      expect(modeIds).toContain('default');
-      expect(modeIds).toContain('yolo');
-      expect(modeIds).toContain('auto-edit');
-      expect(modeIds).toContain('plan');
-
-      // Verify each mode has required fields
-      for (const mode of initResult.modes.availableModes) {
-        expect(mode.id).toBeTruthy();
-        expect(mode.name).toBeTruthy();
-        expect(mode.description).toBeTruthy();
-      }
-
-      // Test 2: Authenticate
-      await sendRequest('authenticate', { methodId: 'openai' });
-
-      // Test 3: Create a new session
-      const newSession = (await sendRequest('session/new', {
-        cwd: rig.testDir!,
-        mcpServers: [],
-      })) as { sessionId: string };
-      expect(newSession.sessionId).toBeTruthy();
-
-      // Test 4: Set approval mode to 'yolo'
-      const setModeResult = (await sendRequest('session/set_mode', {
-        sessionId: newSession.sessionId,
-        modeId: 'yolo',
-      })) as { modeId: string };
-      expect(setModeResult).toBeDefined();
-      expect(setModeResult.modeId).toBe('yolo');
-
-      // Test 5: Set approval mode to 'auto-edit'
-      const setModeResult2 = (await sendRequest('session/set_mode', {
-        sessionId: newSession.sessionId,
-        modeId: 'auto-edit',
-      })) as { modeId: string };
-      expect(setModeResult2).toBeDefined();
-      expect(setModeResult2.modeId).toBe('auto-edit');
-
-      // Test 6: Set approval mode back to 'default'
-      const setModeResult3 = (await sendRequest('session/set_mode', {
-        sessionId: newSession.sessionId,
-        modeId: 'default',
-      })) as { modeId: string };
-      expect(setModeResult3).toBeDefined();
-      expect(setModeResult3.modeId).toBe('default');
-    } catch (e) {
-      if (stderr.length) {
-        console.error('Agent stderr:', stderr.join(''));
-      }
-      throw e;
-    } finally {
-      await cleanup();
-    }
-  });
-
-  it('receives available_commands_update with slash commands after session creation', async () => {
-    const rig = new TestRig();
-    rig.setup('acp slash commands');
-
-    const { sendRequest, cleanup, stderr, sessionUpdates } = setupAcpTest(rig);
-
-    try {
-      // Initialize
-      await sendRequest('initialize', {
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: { readTextFile: true, writeTextFile: true },
-        },
-      });
-
-      await sendRequest('authenticate', { methodId: 'openai' });
-
-      // Create a new session
-      const newSession = (await sendRequest('session/new', {
-        cwd: rig.testDir!,
-        mcpServers: [],
-      })) as { sessionId: string };
-      expect(newSession.sessionId).toBeTruthy();
-
-      // Wait for available_commands_update to be received
-      await delay(1000);
-
-      // Verify available_commands_update is received
-      const commandsUpdate = sessionUpdates.find(
-        (update) =>
-          update.update?.sessionUpdate === 'available_commands_update',
-      );
-
-      expect(commandsUpdate).toBeDefined();
-      expect(commandsUpdate?.update?.availableCommands).toBeDefined();
-      expect(Array.isArray(commandsUpdate?.update?.availableCommands)).toBe(
-        true,
-      );
-
-      // Verify that the 'init' command is present (the only allowed built-in command for ACP)
-      const initCommand = commandsUpdate?.update?.availableCommands?.find(
-        (cmd) => cmd.name === 'init',
-      );
-      expect(initCommand).toBeDefined();
-      expect(initCommand?.description).toBeTruthy();
-
-      // Note: We don't test /init execution here because it triggers a complex
-      // multi-step process (listing files, reading up to 10 files, generating QWEN.md)
-      // that can take 30-60+ seconds, exceeding the request timeout.
-      // The slash command execution path is tested via simpler prompts in other tests.
-    } catch (e) {
-      if (stderr.length) {
-        console.error('Agent stderr:', stderr.join(''));
-      }
-      throw e;
-    } finally {
-      await cleanup();
-    }
-  });
-
-  it('handles exit plan mode with permission request and mode update notification', async () => {
-    const rig = new TestRig();
-    rig.setup('acp exit plan mode');
-
-    // Track which permission requests we've seen
-    const planModeRequests: PermissionRequest[] = [];
-
-    const { sendRequest, cleanup, stderr, sessionUpdates, permissionRequests } =
-      setupAcpTest(rig, {
-        permissionHandler: (request) => {
-          // Track all permission requests for later verification
-          // Auto-approve exit plan mode requests with "proceed_always" to trigger auto-edit mode
-          if (request.toolCall?.kind === 'switch_mode') {
-            planModeRequests.push(request);
-            // Return proceed_always to switch to auto-edit mode
-            return { optionId: 'proceed_always' };
-          }
-          // Auto-approve all other requests
-          return { optionId: 'proceed_once' };
-        },
-      });
-
-    try {
-      // Initialize
-      await sendRequest('initialize', {
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: { readTextFile: true, writeTextFile: true },
-        },
-      });
-
-      await sendRequest('authenticate', { methodId: 'openai' });
-
-      // Create a new session
-      const newSession = (await sendRequest('session/new', {
-        cwd: rig.testDir!,
-        mcpServers: [],
-      })) as { sessionId: string };
-      expect(newSession.sessionId).toBeTruthy();
-
-      // Set mode to 'plan' to enable plan mode
-      const setModeResult = (await sendRequest('session/set_mode', {
-        sessionId: newSession.sessionId,
-        modeId: 'plan',
-      })) as { modeId: string };
-      expect(setModeResult.modeId).toBe('plan');
-
-      // Send a prompt that should trigger the LLM to call exit_plan_mode
-      // The prompt is designed to trigger planning behavior
-      const promptResult = await sendRequest('session/prompt', {
-        sessionId: newSession.sessionId,
-        prompt: [
-          {
-            type: 'text',
-            text: 'Create a simple hello world function in Python. Make a brief plan and when ready, use the exit_plan_mode tool to present it for approval.',
-          },
-        ],
-      });
-      expect(promptResult).toBeDefined();
-
-      // Give time for all notifications to be processed
-      await delay(1000);
-
-      // Verify: If exit_plan_mode was called, we should have received:
-      // 1. A permission request with kind: "switch_mode"
-      // 2. A current_mode_update notification after approval
-
-      // Check for switch_mode permission requests
-      const switchModeRequests = permissionRequests.filter(
-        (req) => req.toolCall?.kind === 'switch_mode',
-      );
-
-      // Check for current_mode_update notifications
-      const modeUpdateNotifications = sessionUpdates.filter(
-        (update) => update.update?.sessionUpdate === 'current_mode_update',
-      );
-
-      // If the LLM called exit_plan_mode, verify the flow
-      if (switchModeRequests.length > 0) {
-        // Verify permission request structure
-        const permReq = switchModeRequests[0];
-        expect(permReq.toolCall).toBeDefined();
-        expect(permReq.toolCall?.kind).toBe('switch_mode');
-        expect(permReq.toolCall?.status).toBe('pending');
-        expect(permReq.options).toBeDefined();
-        expect(Array.isArray(permReq.options)).toBe(true);
-
-        // Verify options include appropriate choices
-        const optionKinds = permReq.options?.map((opt) => opt.kind) ?? [];
-        expect(optionKinds).toContain('allow_once');
-        expect(optionKinds).toContain('allow_always');
-
-        // After approval, should have received current_mode_update
-        expect(modeUpdateNotifications.length).toBeGreaterThan(0);
-
-        // Verify mode update structure
-        const modeUpdate = modeUpdateNotifications[0];
-        expect(modeUpdate.sessionId).toBe(newSession.sessionId);
-        expect(modeUpdate.update?.modeId).toBeDefined();
-        // Mode should be auto-edit since we approved with proceed_always
-        expect(modeUpdate.update?.modeId).toBe('auto-edit');
-      }
-
-      // Note: If the LLM didn't call exit_plan_mode, that's acceptable
-      // since LLM behavior is non-deterministic. The test setup and structure
-      // is verified regardless.
-    } catch (e) {
-      if (stderr.length) {
-        console.error('Agent stderr:', stderr.join(''));
-      }
-      throw e;
-    } finally {
-      await cleanup();
-    }
-  });
-});
--- a/integration-tests/context-compress-interactive.test.ts
+++ b/integration-tests/context-compress-interactive.test.ts
@@ -21,21 +21,23 @@ describe('Interactive Mode', () => {
  it.skipIf(process.platform === 'win32')(
    'should trigger chat compression with /compress command',
    async () => {
-      await rig.setup('interactive-compress-test', {
-        settings: {
-          security: {
-            auth: {
-              selectedType: 'openai',
-            },
-          },
-        },
-      });
+      await rig.setup('interactive-compress-test');

      const { ptyProcess } = rig.runInteractive();

      let fullOutput = '';
      ptyProcess.onData((data) => (fullOutput += data));

+      const authDialogAppeared = await rig.waitForText(
+        'How would you like to authenticate',
+        5000,
+      );
+
+      // select the second option if auth dialog come's up
+      if (authDialogAppeared) {
+        ptyProcess.write('2');
+      }
+
      // Wait for the app to be ready
      const isReady = await rig.waitForText('Type your message', 15000);
      expect(
@@ -66,43 +68,49 @@ describe('Interactive Mode', () => {
    },
  );

-  it.skip('should handle compression failure on token inflation', async () => {
-    await rig.setup('interactive-compress-test', {
-      settings: {
-        security: {
-          auth: {
-            selectedType: 'openai',
-          },
-        },
-      },
-    });
+  it.skipIf(process.platform === 'win32')(
+    'should handle compression failure on token inflation',
+    async () => {
+      await rig.setup('interactive-compress-test');

-    const { ptyProcess } = rig.runInteractive();
+      const { ptyProcess } = rig.runInteractive();

-    let fullOutput = '';
-    ptyProcess.onData((data) => (fullOutput += data));
+      let fullOutput = '';
+      ptyProcess.onData((data) => (fullOutput += data));

-    // Wait for the app to be ready
-    const isReady = await rig.waitForText('Type your message', 25000);
-    expect(isReady, 'CLI did not start up in interactive mode correctly').toBe(
-      true,
-    );
+      const authDialogAppeared = await rig.waitForText(
+        'How would you like to authenticate',
+        5000,
+      );

-    await type(ptyProcess, '/compress');
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    await type(ptyProcess, '\r');
+      // select the second option if auth dialog come's up
+      if (authDialogAppeared) {
+        ptyProcess.write('2');
+      }

-    const foundEvent = await rig.waitForTelemetryEvent(
-      'chat_compression',
-      90000,
-    );
-    expect(foundEvent).toBe(true);
+      // Wait for the app to be ready
+      const isReady = await rig.waitForText('Type your message', 25000);
+      expect(
+        isReady,
+        'CLI did not start up in interactive mode correctly',
+      ).toBe(true);

-    const compressionFailed = await rig.waitForText(
-      'Nothing to compress.',
-      25000,
-    );
+      await type(ptyProcess, '/compress');
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await type(ptyProcess, '\r');

-    expect(compressionFailed).toBe(true);
-  });
+      const foundEvent = await rig.waitForTelemetryEvent(
+        'chat_compression',
+        90000,
+      );
+      expect(foundEvent).toBe(true);
+
+      const compressionFailed = await rig.waitForText(
+        'compression was not beneficial',
+        25000,
+      );
+
+      expect(compressionFailed).toBe(true);
+    },
+  );
 });
--- a/integration-tests/ctrl-c-exit.test.ts
+++ b/integration-tests/ctrl-c-exit.test.ts
@@ -6,71 +6,124 @@

 import { describe, it, expect } from 'vitest';
 import { TestRig } from './test-helper.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';

 describe('Ctrl+C exit', () => {
  // (#9782) Temporarily disabling on windows because it is failing on main and every
  // PR, which is potentially hiding other failures
-  it.skip('should exit gracefully on second Ctrl+C', async () => {
-    const rig = new TestRig();
-    await rig.setup('should exit gracefully on second Ctrl+C');
+  it.skipIf(process.platform === 'win32')(
+    'should exit gracefully on second Ctrl+C',
+    async () => {
+      const rig = new TestRig();
+      await rig.setup('should exit gracefully on second Ctrl+C');

-    const { ptyProcess, promise } = rig.runInteractive();
+      const { ptyProcess, promise } = rig.runInteractive();

-    let output = '';
-    ptyProcess.onData((data) => {
-      output += data;
-    });
+      let output = '';
+      ptyProcess.onData((data) => {
+        output += data;
+      });

-    const isReady = await rig.waitForText('Type your message', 15000);
-    expect(isReady, 'CLI did not start up in interactive mode correctly').toBe(
-      true,
-    );
+      // Wait for the app to be ready by looking for the initial prompt indicator
+      await rig.poll(() => output.includes('▶'), 5000, 100);

-    // Send first Ctrl+C
-    ptyProcess.write(String.fromCharCode(3));
+      // Send first Ctrl+C
+      ptyProcess.write(String.fromCharCode(3));

-    // Wait for the exit prompt
-    const showedExitPrompt = await rig.poll(
-      () => output.includes('Press Ctrl+C again to exit'),
-      1500,
-      50,
-    );
-    expect(showedExitPrompt, `Exit prompt not shown. Output: ${output}`).toBe(
-      true,
-    );
+      // Wait for the exit prompt
+      await rig.poll(
+        () => output.includes('Press Ctrl+C again to exit'),
+        1500,
+        50,
+      );

-    // Send second Ctrl+C
-    ptyProcess.write(String.fromCharCode(3));
+      // Send second Ctrl+C
+      ptyProcess.write(String.fromCharCode(3));

-    // Wait for process exit with timeout to fail fast
-    const EXIT_TIMEOUT = 5000;
-    const result = await Promise.race([
-      promise,
-      new Promise<never>((_, reject) =>
-        setTimeout(
-          () =>
-            reject(
-              new Error(
-                `Process did not exit within ${EXIT_TIMEOUT}ms. Output: ${output}`,
-              ),
-            ),
-          EXIT_TIMEOUT,
-        ),
-      ),
-    ]);
+      const result = await promise;

-    // Expect a graceful exit (code 0)
-    expect(
-      result.exitCode,
-      `Process exited with code ${result.exitCode}. Output: ${result.output}`,
-    ).toBe(0);
+      // Expect a graceful exit (code 0)
+      expect(
+        result.exitCode,
+        `Process exited with code ${result.exitCode}. Output: ${result.output}`,
+      ).toBe(0);

-    // Check that the quitting message is displayed
-    const quittingMessage = 'Agent powering down. Goodbye!';
-    // The regex below is intentionally matching the ESC control character (\x1b)
-    // to strip ANSI color codes from the terminal output.
-    // eslint-disable-next-line no-control-regex
-    const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
-    expect(cleanOutput).toContain(quittingMessage);
-  });
+      // Check that the quitting message is displayed
+      const quittingMessage = 'Agent powering down. Goodbye!';
+      // The regex below is intentionally matching the ESC control character (\x1b)
+      // to strip ANSI color codes from the terminal output.
+      // eslint-disable-next-line no-control-regex
+      const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+      expect(cleanOutput).toContain(quittingMessage);
+    },
+  );
+
+  it.skipIf(process.platform === 'win32')(
+    'should exit gracefully on second Ctrl+C when calling a tool',
+    async () => {
+      const rig = new TestRig();
+      await rig.setup(
+        'should exit gracefully on second Ctrl+C when calling a tool',
+      );
+
+      const childProcessFile = 'child_process_file.txt';
+      rig.createFile(
+        'wait.js',
+        `setTimeout(() => require('fs').writeFileSync('${childProcessFile}', 'done'), 5000)`,
+      );
+
+      const { ptyProcess, promise } = rig.runInteractive();
+
+      let output = '';
+      ptyProcess.onData((data) => {
+        output += data;
+      });
+
+      // Wait for the app to be ready by looking for the initial prompt indicator
+      await rig.poll(() => output.includes('▶'), 5000, 100);
+
+      ptyProcess.write('use the tool to run "node -e wait.js"\n');
+
+      await rig.poll(() => output.includes('Shell'), 5000, 100);
+
+      // Send first Ctrl+C
+      ptyProcess.write(String.fromCharCode(3));
+
+      // Wait for the exit prompt
+      await rig.poll(
+        () => output.includes('Press Ctrl+C again to exit'),
+        1500,
+        50,
+      );
+
+      // Send second Ctrl+C
+      ptyProcess.write(String.fromCharCode(3));
+
+      const result = await promise;
+
+      // Expect a graceful exit (code 0)
+      expect(
+        result.exitCode,
+        `Process exited with code ${result.exitCode}. Output: ${result.output}`,
+      ).toBe(0);
+
+      // Check that the quitting message is displayed
+      const quittingMessage = 'Agent powering down. Goodbye!';
+      // The regex below is intentionally matching the ESC control character (\x1b)
+      // to strip ANSI color codes from the terminal output.
+      // eslint-disable-next-line no-control-regex
+      const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+      expect(cleanOutput).toContain(quittingMessage);
+
+      // Check that the child process was terminated and did not create the file.
+      const childProcessFileExists = fs.existsSync(
+        path.join(rig.testDir!, childProcessFile),
+      );
+      expect(
+        childProcessFileExists,
+        'Child process file should not exist',
+      ).toBe(false);
+    },
+  );
 });
--- a/integration-tests/file-system-interactive.test.ts
+++ b/integration-tests/file-system-interactive.test.ts
@@ -22,19 +22,21 @@ describe('Interactive file system', () => {
    'should perform a read-then-write sequence in interactive mode',
    async () => {
      const fileName = 'version.txt';
-      await rig.setup('interactive-read-then-write', {
-        settings: {
-          security: {
-            auth: {
-              selectedType: 'openai',
-            },
-          },
-        },
-      });
+      await rig.setup('interactive-read-then-write');
      rig.createFile(fileName, '1.0.0');

      const { ptyProcess } = rig.runInteractive();

+      const authDialogAppeared = await rig.waitForText(
+        'How would you like to authenticate',
+        5000,
+      );
+
+      // select the second option if auth dialog come's up
+      if (authDialogAppeared) {
+        ptyProcess.write('2');
+      }
+
      // Wait for the app to be ready
      const isReady = await rig.waitForText('Type your message', 15000);
      expect(
--- a/integration-tests/globalSetup.ts
+++ b/integration-tests/globalSetup.ts
@@ -1,6 +1,6 @@
 /**
 * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

@@ -30,7 +30,6 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const rootDir = join(__dirname, '..');
 const integrationTestsDir = join(rootDir, '.integration-tests');
 let runDir = ''; // Make runDir accessible in teardown
-let sdkE2eRunDir = ''; // SDK E2E test run directory

 const memoryFilePath = join(
  os.homedir(),
@@ -49,36 +48,14 @@ export async function setup() {
    // File doesn't exist, which is fine.
  }

-  // Setup for CLI integration tests
  runDir = join(integrationTestsDir, `${Date.now()}`);
  await mkdir(runDir, { recursive: true });

-  // Setup for SDK E2E tests (separate directory with prefix)
-  sdkE2eRunDir = join(integrationTestsDir, `sdk-e2e-${Date.now()}`);
-  await mkdir(sdkE2eRunDir, { recursive: true });
-
  // Clean up old test runs, but keep the latest few for debugging
  try {
    const testRuns = await readdir(integrationTestsDir);
-
-    // Clean up old CLI integration test runs (without sdk-e2e- prefix)
-    const cliTestRuns = testRuns.filter((run) => !run.startsWith('sdk-e2e-'));
-    if (cliTestRuns.length > 5) {
-      const oldRuns = cliTestRuns.sort().slice(0, cliTestRuns.length - 5);
-      await Promise.all(
-        oldRuns.map((oldRun) =>
-          rm(join(integrationTestsDir, oldRun), {
-            recursive: true,
-            force: true,
-          }),
-        ),
-      );
-    }
-
-    // Clean up old SDK E2E test runs (with sdk-e2e- prefix)
-    const sdkTestRuns = testRuns.filter((run) => run.startsWith('sdk-e2e-'));
-    if (sdkTestRuns.length > 5) {
-      const oldRuns = sdkTestRuns.sort().slice(0, sdkTestRuns.length - 5);
+    if (testRuns.length > 5) {
+      const oldRuns = testRuns.sort().slice(0, testRuns.length - 5);
      await Promise.all(
        oldRuns.map((oldRun) =>
          rm(join(integrationTestsDir, oldRun), {
@@ -92,37 +69,24 @@ export async function setup() {
    console.error('Error cleaning up old test runs:', e);
  }

-  // Environment variables for CLI integration tests
  process.env['INTEGRATION_TEST_FILE_DIR'] = runDir;
  process.env['GEMINI_CLI_INTEGRATION_TEST'] = 'true';
  process.env['TELEMETRY_LOG_FILE'] = join(runDir, 'telemetry.log');

-  // Environment variables for SDK E2E tests
-  process.env['E2E_TEST_FILE_DIR'] = sdkE2eRunDir;
-  process.env['TEST_CLI_PATH'] = join(rootDir, 'dist/cli.js');
-
  if (process.env['KEEP_OUTPUT']) {
    console.log(`Keeping output for test run in: ${runDir}`);
-    console.log(`Keeping output for SDK E2E test run in: ${sdkE2eRunDir}`);
  }
  process.env['VERBOSE'] = process.env['VERBOSE'] ?? 'false';

  console.log(`\nIntegration test output directory: ${runDir}`);
-  console.log(`SDK E2E test output directory: ${sdkE2eRunDir}`);
-  console.log(`CLI path: ${process.env['TEST_CLI_PATH']}`);
 }

 export async function teardown() {
-  // Cleanup the CLI test run directory unless KEEP_OUTPUT is set
+  // Cleanup the test run directory unless KEEP_OUTPUT is set
  if (process.env['KEEP_OUTPUT'] !== 'true' && runDir) {
    await rm(runDir, { recursive: true, force: true });
  }

-  // Cleanup the SDK E2E test run directory unless KEEP_OUTPUT is set
-  if (process.env['KEEP_OUTPUT'] !== 'true' && sdkE2eRunDir) {
-    await rm(sdkE2eRunDir, { recursive: true, force: true });
-  }
-
  if (originalMemoryContent !== null) {
    await mkdir(dirname(memoryFilePath), { recursive: true });
    await writeFile(memoryFilePath, originalMemoryContent, 'utf-8');
--- a/integration-tests/json-output.test.ts
+++ b/integration-tests/json-output.test.ts
@@ -19,7 +19,7 @@ describe('JSON output', () => {
    await rig.cleanup();
  });

-  it('should return a valid JSON array with result message containing response and stats', async () => {
+  it('should return a valid JSON with response and stats', async () => {
    const result = await rig.run(
      'What is the capital of France?',
      '--output-format',
@@ -27,213 +27,15 @@ describe('JSON output', () => {
    );
    const parsed = JSON.parse(result);

-    // The output should be an array of messages
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBeGreaterThan(0);
+    expect(parsed).toHaveProperty('response');
+    expect(typeof parsed.response).toBe('string');
+    expect(parsed.response.toLowerCase()).toContain('paris');

-    // Find the result message (should be the last message)
-    const resultMessage = parsed.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'result',
-    );
-
-    expect(resultMessage).toBeDefined();
-    expect(resultMessage).toHaveProperty('is_error');
-    expect(resultMessage.is_error).toBe(false);
-    expect(resultMessage).toHaveProperty('result');
-    expect(typeof resultMessage.result).toBe('string');
-    expect(resultMessage.result.toLowerCase()).toContain('paris');
-
-    // Stats may be present if available
-    if ('stats' in resultMessage) {
-      expect(typeof resultMessage.stats).toBe('object');
-    }
-  });
-
-  it('should return line-delimited JSON messages for stream-json output format', async () => {
-    const result = await rig.run(
-      'What is the capital of France?',
-      '--output-format',
-      'stream-json',
-    );
-
-    // Stream-json output is line-delimited JSON (one JSON object per line)
-    const lines = result
-      .trim()
-      .split('\n')
-      .filter((line) => line.trim());
-    expect(lines.length).toBeGreaterThan(0);
-
-    // Parse each line as a JSON object
-    const messages: unknown[] = [];
-    for (const line of lines) {
-      try {
-        const parsed = JSON.parse(line);
-        messages.push(parsed);
-      } catch (parseError) {
-        throw new Error(
-          `Failed to parse JSON line: ${line}. Error: ${parseError}`,
-        );
-      }
-    }
-
-    // Should have at least system, assistant, and result messages
-    expect(messages.length).toBeGreaterThanOrEqual(3);
-
-    // Find system message
-    const systemMessage = messages.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'system',
-    );
-    expect(systemMessage).toBeDefined();
-    expect(systemMessage).toHaveProperty('subtype');
-    expect(systemMessage).toHaveProperty('session_id');
-
-    // Find assistant message
-    const assistantMessage = messages.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'assistant',
-    );
-    expect(assistantMessage).toBeDefined();
-    expect(assistantMessage).toHaveProperty('message');
-    expect(assistantMessage).toHaveProperty('session_id');
-
-    // Find result message (should be the last message)
-    const resultMessage = messages[messages.length - 1] as {
-      type: string;
-      is_error: boolean;
-      result: string;
-    };
-    expect(resultMessage).toBeDefined();
-    expect(
-      typeof resultMessage === 'object' &&
-        resultMessage !== null &&
-        'type' in resultMessage &&
-        resultMessage.type === 'result',
-    ).toBe(true);
-    expect(resultMessage).toHaveProperty('is_error');
-    expect(resultMessage.is_error).toBe(false);
-    expect(resultMessage).toHaveProperty('result');
-    expect(typeof resultMessage.result).toBe('string');
-    expect(resultMessage.result.toLowerCase()).toContain('paris');
-  });
-
-  it('should include stream events when using stream-json with include-partial-messages', async () => {
-    const result = await rig.run(
-      'What is the capital of France?',
-      '--output-format',
-      'stream-json',
-      '--include-partial-messages',
-    );
-
-    // Stream-json output is line-delimited JSON (one JSON object per line)
-    const lines = result
-      .trim()
-      .split('\n')
-      .filter((line) => line.trim());
-    expect(lines.length).toBeGreaterThan(0);
-
-    // Parse each line as a JSON object
-    const messages: unknown[] = [];
-    for (const line of lines) {
-      try {
-        const parsed = JSON.parse(line);
-        messages.push(parsed);
-      } catch (parseError) {
-        throw new Error(
-          `Failed to parse JSON line: ${line}. Error: ${parseError}`,
-        );
-      }
-    }
-
-    // Should have more messages than without include-partial-messages
-    // because we're including stream events
-    expect(messages.length).toBeGreaterThan(3);
-
-    // Find stream_event messages
-    const streamEvents = messages.filter(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'stream_event',
-    );
-    expect(streamEvents.length).toBeGreaterThan(0);
-
-    // Verify stream event structure
-    const firstStreamEvent = streamEvents[0];
-    expect(firstStreamEvent).toHaveProperty('event');
-    expect(firstStreamEvent).toHaveProperty('session_id');
-    expect(firstStreamEvent).toHaveProperty('uuid');
-
-    // Check for expected stream event types
-    const eventTypes = streamEvents.map((event: unknown) =>
-      typeof event === 'object' &&
-      event !== null &&
-      'event' in event &&
-      typeof event.event === 'object' &&
-      event.event !== null &&
-      'type' in event.event
-        ? event.event.type
-        : null,
-    );
-
-    // Should have message_start event
-    expect(eventTypes).toContain('message_start');
-
-    // Should have content_block_start event
-    expect(eventTypes).toContain('content_block_start');
-
-    // Should have content_block_delta events
-    expect(eventTypes).toContain('content_block_delta');
-
-    // Should have content_block_stop event
-    expect(eventTypes).toContain('content_block_stop');
-
-    // Should have message_stop event
-    expect(eventTypes).toContain('message_stop');
-
-    // Verify that we still have the complete assistant message
-    const assistantMessage = messages.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'assistant',
-    );
-    expect(assistantMessage).toBeDefined();
-    expect(assistantMessage).toHaveProperty('message');
-
-    // Verify that we still have the result message
-    const resultMessage = messages[messages.length - 1] as {
-      type: string;
-      is_error: boolean;
-      result: string;
-    };
-    expect(resultMessage).toBeDefined();
-    expect(
-      typeof resultMessage === 'object' &&
-        resultMessage !== null &&
-        'type' in resultMessage &&
-        resultMessage.type === 'result',
-    ).toBe(true);
-    expect(resultMessage).toHaveProperty('is_error');
-    expect(resultMessage.is_error).toBe(false);
-    expect(resultMessage).toHaveProperty('result');
-    expect(resultMessage.result.toLowerCase()).toContain('paris');
+    expect(parsed).toHaveProperty('stats');
+    expect(typeof parsed.stats).toBe('object');
  });

  it('should return a JSON error for enforced auth mismatch before running', async () => {
-    const originalOpenaiApiKey = process.env['OPENAI_API_KEY'];
    process.env['OPENAI_API_KEY'] = 'test-key';
    await rig.setup('json-output-auth-mismatch', {
      settings: {
@@ -248,63 +50,38 @@ describe('JSON output', () => {
    } catch (e) {
      thrown = e as Error;
    } finally {
-      process.env['OPENAI_API_KEY'] = originalOpenaiApiKey;
+      delete process.env['OPENAI_API_KEY'];
    }

    expect(thrown).toBeDefined();
    const message = (thrown as Error).message;

-    // The error JSON is written to stdout as a CLIResultMessageError
-    // Extract stdout from the error message
-    const stdoutMatch = message.match(/Stdout:\n([\s\S]*?)(?:\n\nStderr:|$)/);
+    // Use a regex to find the first complete JSON object in the string
+    const jsonMatch = message.match(/{[\s\S]*}/);
+
+    // Fail if no JSON-like text was found
    expect(
-      stdoutMatch,
-      'Expected to find stdout in the error message',
+      jsonMatch,
+      'Expected to find a JSON object in the error output',
    ).toBeTruthy();

-    const stdout = stdoutMatch![1];
-    let parsed: unknown[];
+    let payload;
    try {
-      // Parse the JSON array from stdout
-      parsed = JSON.parse(stdout);
+      // Parse the matched JSON string
+      payload = JSON.parse(jsonMatch![0]);
    } catch (parseError) {
-      console.error('Failed to parse the following JSON:', stdout);
+      console.error('Failed to parse the following JSON:', jsonMatch![0]);
      throw new Error(
-        `Test failed: Could not parse JSON from stdout. Details: ${parseError}`,
+        `Test failed: Could not parse JSON from error message. Details: ${parseError}`,
      );
    }

-    // The output should be an array of messages
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBeGreaterThan(0);
-
-    // Find the result message with error
-    const resultMessage = parsed.find(
-      (msg: unknown) =>
-        typeof msg === 'object' &&
-        msg !== null &&
-        'type' in msg &&
-        msg.type === 'result' &&
-        'is_error' in msg &&
-        msg.is_error === true,
-    ) as {
-      type: string;
-      is_error: boolean;
-      subtype: string;
-      error?: { message: string; type?: string };
-    };
-
-    expect(resultMessage).toBeDefined();
-    expect(resultMessage.is_error).toBe(true);
-    expect(resultMessage).toHaveProperty('subtype');
-    expect(resultMessage.subtype).toBe('error_during_execution');
-    expect(resultMessage).toHaveProperty('error');
-    expect(resultMessage.error).toBeDefined();
-    expect(resultMessage.error?.message).toContain(
+    expect(payload.error).toBeDefined();
+    expect(payload.error.type).toBe('Error');
+    expect(payload.error.code).toBe(1);
+    expect(payload.error.message).toContain(
      'configured auth type is qwen-oauth',
    );
-    expect(resultMessage.error?.message).toContain(
-      'current auth type is openai',
-    );
+    expect(payload.error.message).toContain('current auth type is openai');
  });
 });
--- a/integration-tests/sdk-typescript/abort-and-lifecycle.test.ts
+++ b/integration-tests/sdk-typescript/abort-and-lifecycle.test.ts
@@ -1,486 +0,0 @@
-/**
- * E2E tests based on abort-and-lifecycle.ts example
- * Tests AbortController integration and process lifecycle management
- */
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  AbortError,
-  isAbortError,
-  isSDKAssistantMessage,
-  type TextBlock,
-  type ContentBlock,
-} from '@qwen-code/sdk';
-import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-describe('AbortController and Process Lifecycle (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('abort-and-lifecycle');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-  describe('Basic AbortController Usage', () => {
-    it('should support AbortController cancellation', async () => {
-      const controller = new AbortController();
-
-      // Abort after 5 seconds
-      setTimeout(() => {
-        controller.abort();
-      }, 5000);
-
-      const q = query({
-        prompt: 'Write a very long story about TypeScript programming',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            const textBlocks = message.message.content.filter(
-              (block): block is TextBlock => block.type === 'text',
-            );
-            const text = textBlocks
-              .map((b) => b.text)
-              .join('')
-              .slice(0, 100);
-
-            // Should receive some content before abort
-            expect(text.length).toBeGreaterThan(0);
-          }
-        }
-
-        // Should not reach here - query should be aborted
-        expect(false).toBe(true);
-      } catch (error) {
-        expect(isAbortError(error)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle abort during query execution', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      let receivedFirstMessage = false;
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            if (!receivedFirstMessage) {
-              // Abort immediately after receiving first assistant message
-              receivedFirstMessage = true;
-              controller.abort();
-            }
-          }
-        }
-      } catch (error) {
-        expect(isAbortError(error)).toBe(true);
-        expect(error instanceof AbortError).toBe(true);
-        // Should have received at least one message before abort
-        expect(receivedFirstMessage).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle abort immediately after query starts', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Write a very long essay',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      // Abort immediately after query initialization
-      setTimeout(() => {
-        controller.abort();
-      }, 200);
-
-      try {
-        for await (const _message of q) {
-          // May or may not receive messages before abort
-        }
-      } catch (error) {
-        expect(isAbortError(error)).toBe(true);
-        expect(error instanceof AbortError).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Process Lifecycle Monitoring', () => {
-    it('should handle normal process completion', async () => {
-      const q = query({
-        prompt: 'Why do we choose to go to the moon?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let completedSuccessfully = false;
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            const textBlocks = message.message.content.filter(
-              (block): block is TextBlock => block.type === 'text',
-            );
-            const text = textBlocks
-              .map((b) => b.text)
-              .join('')
-              .slice(0, 100);
-            expect(text.length).toBeGreaterThan(0);
-          }
-        }
-
-        completedSuccessfully = true;
-      } catch (error) {
-        // Should not throw for normal completion
-        expect(false).toBe(true);
-      } finally {
-        await q.close();
-        expect(completedSuccessfully).toBe(true);
-      }
-    });
-
-    it('should handle process cleanup after error', async () => {
-      const q = query({
-        prompt: 'Hello world',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            const textBlocks = message.message.content.filter(
-              (block): block is TextBlock => block.type === 'text',
-            );
-            const text = textBlocks
-              .map((b) => b.text)
-              .join('')
-              .slice(0, 50);
-            expect(text.length).toBeGreaterThan(0);
-          }
-        }
-      } catch (error) {
-        // Expected to potentially have errors
-      } finally {
-        // Should cleanup successfully even after error
-        await q.close();
-        expect(true).toBe(true); // Cleanup completed
-      }
-    });
-  });
-
-  describe('Input Stream Control', () => {
-    it('should support endInput() method', async () => {
-      const q = query({
-        prompt: 'What is 2 + 2?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let receivedResponse = false;
-      let endInputCalled = false;
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message) && !endInputCalled) {
-            const textBlocks = message.message.content.filter(
-              (block: ContentBlock): block is TextBlock =>
-                block.type === 'text',
-            );
-            const text = textBlocks.map((b: TextBlock) => b.text).join('');
-
-            expect(text.length).toBeGreaterThan(0);
-            receivedResponse = true;
-
-            // End input after receiving first response
-            q.endInput();
-            endInputCalled = true;
-          }
-        }
-
-        expect(receivedResponse).toBe(true);
-        expect(endInputCalled).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Error Handling and Recovery', () => {
-    it('should handle invalid executable path', async () => {
-      try {
-        const q = query({
-          prompt: 'Hello world',
-          options: {
-            pathToQwenExecutable: '/nonexistent/path/to/cli',
-            debug: false,
-          },
-        });
-
-        // Should not reach here - query() should throw immediately
-        for await (const _message of q) {
-          // Should not reach here
-        }
-
-        // Should not reach here
-        expect(false).toBe(true);
-      } catch (error) {
-        expect(error instanceof Error).toBe(true);
-        expect((error as Error).message).toBeDefined();
-        expect((error as Error).message).toContain(
-          'Invalid pathToQwenExecutable',
-        );
-      }
-    });
-
-    it('should throw AbortError with correct properties', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Explain the concept of async programming',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      // Abort after allowing query to start
-      setTimeout(() => controller.abort(), 1000);
-
-      try {
-        for await (const _message of q) {
-          // May receive some messages before abort
-        }
-      } catch (error) {
-        // Verify error type and helper functions
-        expect(isAbortError(error)).toBe(true);
-        expect(error instanceof AbortError).toBe(true);
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBeDefined();
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Debugging with stderr callback', () => {
-    it('should capture stderr messages when debug is enabled', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Why do we choose to go to the moon?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            const textBlocks = message.message.content.filter(
-              (block): block is TextBlock => block.type === 'text',
-            );
-            const text = textBlocks
-              .map((b) => b.text)
-              .join('')
-              .slice(0, 50);
-            expect(text.length).toBeGreaterThan(0);
-          }
-        }
-      } finally {
-        await q.close();
-        expect(stderrMessages.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('should not capture stderr when debug is disabled', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      try {
-        for await (const _message of q) {
-          // Consume all messages
-        }
-      } finally {
-        await q.close();
-        // Should have minimal or no stderr output when debug is false
-        expect(stderrMessages.length).toBeLessThan(10);
-      }
-    });
-  });
-
-  describe('Abort with Cleanup', () => {
-    it('should cleanup properly after abort', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Write a very long essay about programming',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      // Abort immediately
-      setTimeout(() => controller.abort(), 100);
-
-      try {
-        for await (const _message of q) {
-          // May receive some messages before abort
-        }
-      } catch (error) {
-        if (error instanceof AbortError) {
-          expect(true).toBe(true); // Expected abort error
-        } else {
-          throw error; // Unexpected error
-        }
-      } finally {
-        await q.close();
-        expect(true).toBe(true); // Cleanup completed after abort
-      }
-    });
-
-    it('should handle multiple abort calls gracefully', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Count to 100',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      // Multiple abort calls
-      setTimeout(() => controller.abort(), 100);
-      setTimeout(() => controller.abort(), 200);
-      setTimeout(() => controller.abort(), 300);
-
-      try {
-        for await (const _message of q) {
-          // Should be interrupted
-        }
-      } catch (error) {
-        expect(isAbortError(error)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Resource Management Edge Cases', () => {
-    it('should handle close() called multiple times', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      // Start the query
-      const iterator = q[Symbol.asyncIterator]();
-      await iterator.next();
-
-      // Close multiple times
-      await q.close();
-      await q.close();
-      await q.close();
-
-      // Should not throw
-      expect(true).toBe(true);
-    });
-
-    it('should handle abort after close', async () => {
-      const controller = new AbortController();
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          abortController: controller,
-          debug: false,
-        },
-      });
-
-      // Start and close immediately
-      const iterator = q[Symbol.asyncIterator]();
-      await iterator.next();
-      await q.close();
-
-      // Abort after close
-      controller.abort();
-
-      // Should not throw
-      expect(true).toBe(true);
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/configuration-options.test.ts
+++ b/integration-tests/sdk-typescript/configuration-options.test.ts
@@ -1,640 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * E2E tests for SDK configuration options:
- * - logLevel: Controls SDK internal logging verbosity
- * - env: Environment variables passed to CLI process
- * - authType: Authentication type for AI service
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  isSDKSystemMessage,
-  type SDKMessage,
-} from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  extractText,
-  createSharedTestOptions,
-  assertSuccessfulCompletion,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-describe('Configuration Options (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('configuration-options');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-
-  describe('logLevel Option', () => {
-    it('should respect logLevel: debug and capture detailed logs', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'What is 1 + 1? Just answer the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'debug',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Debug level should produce verbose logging
-        expect(stderrMessages.length).toBeGreaterThan(0);
-
-        // Debug logs should contain detailed information like [DEBUG]
-        const hasDebugLogs = stderrMessages.some(
-          (msg) => msg.includes('[DEBUG]') || msg.includes('debug'),
-        );
-        expect(hasDebugLogs).toBe(true);
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should respect logLevel: info and filter out debug messages', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'What is 2 + 2? Just answer the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'info',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Info level should filter out debug messages
-        // Check that we don't have [DEBUG] level messages from the SDK logger
-        const sdkDebugLogs = stderrMessages.filter(
-          (msg) =>
-            msg.includes('[DEBUG]') && msg.includes('[ProcessTransport]'),
-        );
-        expect(sdkDebugLogs.length).toBe(0);
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should respect logLevel: warn and only show warnings and errors', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'warn',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Warn level should filter out info and debug messages from SDK
-        const sdkInfoOrDebugLogs = stderrMessages.filter(
-          (msg) =>
-            (msg.includes('[DEBUG]') || msg.includes('[INFO]')) &&
-            (msg.includes('[ProcessTransport]') ||
-              msg.includes('[createQuery]') ||
-              msg.includes('[Query]')),
-        );
-        expect(sdkInfoOrDebugLogs.length).toBe(0);
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should respect logLevel: error and only show error messages', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello world',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'error',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Error level should filter out all non-error messages from SDK
-        const sdkNonErrorLogs = stderrMessages.filter(
-          (msg) =>
-            (msg.includes('[DEBUG]') ||
-              msg.includes('[INFO]') ||
-              msg.includes('[WARN]')) &&
-            (msg.includes('[ProcessTransport]') ||
-              msg.includes('[createQuery]') ||
-              msg.includes('[Query]')),
-        );
-        expect(sdkNonErrorLogs.length).toBe(0);
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should use logLevel over debug flag when both are provided', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'What is 3 + 3?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: true, // Would normally enable debug logging
-          logLevel: 'error', // But logLevel should take precedence
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      try {
-        for await (const _message of q) {
-          // Consume all messages
-        }
-
-        // logLevel: error should suppress debug/info/warn even with debug: true
-        const sdkNonErrorLogs = stderrMessages.filter(
-          (msg) =>
-            (msg.includes('[DEBUG]') ||
-              msg.includes('[INFO]') ||
-              msg.includes('[WARN]')) &&
-            (msg.includes('[ProcessTransport]') ||
-              msg.includes('[createQuery]') ||
-              msg.includes('[Query]')),
-        );
-        expect(sdkNonErrorLogs.length).toBe(0);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('env Option', () => {
-    it('should pass custom environment variables to CLI process', async () => {
-      const q = query({
-        prompt: 'What is 1 + 1? Just the number please.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {
-            CUSTOM_TEST_VAR: 'test_value_12345',
-            ANOTHER_VAR: 'another_value',
-          },
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // The query should complete successfully with custom env vars
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should allow overriding existing environment variables', async () => {
-      // Store original value for comparison
-      const originalPath = process.env['PATH'];
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {
-            // Override an existing env var (not PATH as it might break things)
-            MY_TEST_OVERRIDE: 'overridden_value',
-          },
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Query should complete successfully
-        assertSuccessfulCompletion(messages);
-
-        // Verify original process env is not modified
-        expect(process.env['PATH']).toBe(originalPath);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should work with empty env object', async () => {
-      const q = query({
-        prompt: 'What is 2 + 2?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {},
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should support setting model-related environment variables', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {
-            // Common model-related env vars that CLI might respect
-            OPENAI_API_KEY: process.env['OPENAI_API_KEY'] || 'test-key',
-          },
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Should complete (may succeed or fail based on API key validity)
-        expect(messages.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should not leak env vars between query instances', async () => {
-      // First query with specific env var
-      const q1 = query({
-        prompt: 'Say one',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {
-            ISOLATED_VAR_1: 'value_1',
-          },
-          debug: false,
-        },
-      });
-
-      try {
-        for await (const _message of q1) {
-          // Consume messages
-        }
-      } finally {
-        await q1.close();
-      }
-
-      // Second query with different env var
-      const q2 = query({
-        prompt: 'Say two',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          env: {
-            ISOLATED_VAR_2: 'value_2',
-          },
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q2) {
-          messages.push(message);
-        }
-
-        // Second query should complete successfully
-        assertSuccessfulCompletion(messages);
-
-        // Verify process.env is not polluted by either query
-        expect(process.env['ISOLATED_VAR_1']).toBeUndefined();
-        expect(process.env['ISOLATED_VAR_2']).toBeUndefined();
-      } finally {
-        await q2.close();
-      }
-    });
-  });
-
-  describe('authType Option', () => {
-    it('should accept authType: openai', async () => {
-      const q = query({
-        prompt: 'What is 1 + 1? Just the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          authType: 'openai',
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Query should complete with openai auth type
-        assertSuccessfulCompletion(messages);
-
-        // Verify we got an assistant response
-        const assistantMessages = messages.filter(isSDKAssistantMessage);
-        expect(assistantMessages.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-
-    // Skip in containerized sandbox environments - qwen-oauth requires user interaction
-    // which is not possible in Docker/Podman CI environments
-    it.skipIf(
-      process.env['SANDBOX'] === 'sandbox:docker' ||
-        process.env['SANDBOX'] === 'sandbox:podman',
-    )('should accept authType: qwen-oauth', async () => {
-      // Note: qwen-oauth requires credentials in ~/.qwen and user interaction
-      // Without credentials, the auth process will timeout waiting for user
-      // This test verifies the option is accepted and passed correctly to CLI
-
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          authType: 'qwen-oauth',
-          debug: true,
-          logLevel: 'debug',
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        // Use a timeout to avoid hanging when credentials are not configured
-        const timeoutPromise = new Promise<'timeout'>((resolve) =>
-          setTimeout(() => resolve('timeout'), 20000),
-        );
-
-        const collectMessages = async () => {
-          for await (const message of q) {
-            messages.push(message);
-          }
-          return 'completed';
-        };
-
-        const result = await Promise.race([collectMessages(), timeoutPromise]);
-
-        if (result === 'timeout') {
-          // Timeout is expected when OAuth credentials are not configured
-          // Verify that CLI was spawned with correct --auth-type argument
-          const hasAuthTypeArg = stderrMessages.some((msg) =>
-            msg.includes('--auth-type'),
-          );
-          expect(hasAuthTypeArg).toBe(true);
-        } else {
-          // If credentials exist and auth completed, verify we got messages
-          expect(messages.length).toBeGreaterThan(0);
-        }
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should use default auth when authType is not specified', async () => {
-      const q = query({
-        prompt: 'What is 2 + 2? Just the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          // authType not specified - should use default
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Query should complete with default auth
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should properly pass authType to CLI process', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Say hi',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          authType: 'openai',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // There should be spawn log containing auth-type
-        const hasAuthTypeArg = stderrMessages.some((msg) =>
-          msg.includes('--auth-type'),
-        );
-        expect(hasAuthTypeArg).toBe(true);
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Combined Options', () => {
-    it('should work with logLevel, env, and authType together', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'What is 3 + 3? Just the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'debug',
-          env: {
-            COMBINED_TEST_VAR: 'combined_value',
-          },
-          authType: 'openai',
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // All three options should work together
-        expect(stderrMessages.length).toBeGreaterThan(0); // logLevel: debug produces logs
-        expect(assistantText).toMatch(/6/); // Query should work
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should maintain system message consistency with all options', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          logLevel: 'info',
-          env: {
-            SYSTEM_MSG_TEST: 'test',
-          },
-          authType: 'openai',
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Should have system init message
-        const systemMessages = messages.filter(isSDKSystemMessage);
-        const initMessage = systemMessages.find((m) => m.subtype === 'init');
-
-        expect(initMessage).toBeDefined();
-        expect(initMessage!.session_id).toBeDefined();
-        expect(initMessage!.tools).toBeDefined();
-        expect(initMessage!.permission_mode).toBeDefined();
-
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/mcp-server.test.ts
+++ b/integration-tests/sdk-typescript/mcp-server.test.ts
@@ -1,405 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * E2E tests for MCP (Model Context Protocol) server integration via SDK
- * Tests that the SDK can properly interact with MCP servers configured in qwen-code
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  isSDKResultMessage,
-  isSDKSystemMessage,
-  isSDKUserMessage,
-  type SDKMessage,
-  type ToolUseBlock,
-  type SDKSystemMessage,
-} from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  createMCPServer,
-  extractText,
-  findToolUseBlocks,
-  createSharedTestOptions,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = {
-  ...createSharedTestOptions(),
-  permissionMode: 'yolo' as const,
-};
-
-describe('MCP Server Integration (E2E)', () => {
-  let helper: SDKTestHelper;
-  let serverScriptPath: string;
-  let testDir: string;
-
-  beforeEach(async () => {
-    // Create isolated test environment using SDKTestHelper
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('mcp-server-integration');
-
-    // Create MCP server using the helper utility
-    const mcpServer = await createMCPServer(helper, 'math', 'test-math-server');
-    serverScriptPath = mcpServer.scriptPath;
-  });
-
-  afterEach(async () => {
-    // Cleanup test directory
-    await helper.cleanup();
-  });
-
-  describe('Basic MCP Tool Usage', () => {
-    it('should use MCP add tool to add two numbers', async () => {
-      const q = query({
-        prompt:
-          'Use the add tool to calculate 5 + 10. Just give me the result.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'add');
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate tool was called
-        expect(foundToolUse).toBe(true);
-
-        // Validate result contains expected answer
-        expect(assistantText).toMatch(/15/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-        if (isSDKResultMessage(lastMessage)) {
-          expect(lastMessage.subtype).toBe('success');
-        }
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should use MCP multiply tool to multiply two numbers', async () => {
-      const q = query({
-        prompt:
-          'Use the multiply tool to calculate 6 * 7. Just give me the result.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'multiply');
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate tool was called
-        expect(foundToolUse).toBe(true);
-
-        // Validate result contains expected answer
-        expect(assistantText).toMatch(/42/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('MCP Server Discovery', () => {
-    it('should list MCP servers in system init message', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      let systemMessage: SDKSystemMessage | null = null;
-
-      try {
-        for await (const message of q) {
-          if (isSDKSystemMessage(message) && message.subtype === 'init') {
-            systemMessage = message;
-            break;
-          }
-        }
-
-        // Validate MCP server is listed
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.mcp_servers).toBeDefined();
-        expect(Array.isArray(systemMessage!.mcp_servers)).toBe(true);
-
-        // Find our test server
-        const testServer = systemMessage!.mcp_servers?.find(
-          (server) => server.name === 'test-math-server',
-        );
-        expect(testServer).toBeDefined();
-
-        // Note: tools are not exposed in the mcp_servers array in system message
-        // They are available through the MCP protocol but not in the init message
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Complex MCP Operations', () => {
-    it('should chain multiple MCP tool calls', async () => {
-      const q = query({
-        prompt:
-          'First use add to calculate 10 + 5, then multiply the result by 2. Give me the final answer.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      const toolCalls: string[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message);
-            toolUseBlocks.forEach((block) => {
-              toolCalls.push(block.name);
-            });
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate both tools were called
-        expect(toolCalls).toContain('add');
-        expect(toolCalls).toContain('multiply');
-
-        // Validate result: (10 + 5) * 2 = 30
-        expect(assistantText).toMatch(/30/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle multiple calls to the same MCP tool', async () => {
-      const q = query({
-        prompt:
-          'Use the add tool twice: first add 1 + 2, then add 3 + 4. Tell me both results.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      const addToolCalls: ToolUseBlock[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'add');
-            addToolCalls.push(...toolUseBlocks);
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate add tool was called at least twice
-        expect(addToolCalls.length).toBeGreaterThanOrEqual(2);
-
-        // Validate results contain expected answers: 3 and 7
-        expect(assistantText).toMatch(/3/);
-        expect(assistantText).toMatch(/7/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('MCP Tool Message Flow', () => {
-    it('should receive proper message sequence for MCP tool usage', async () => {
-      const q = query({
-        prompt: 'Use add to calculate 2 + 3',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messageTypes: string[] = [];
-      let foundToolUse = false;
-      let foundToolResult = false;
-
-      try {
-        for await (const message of q) {
-          messageTypes.push(message.type);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message);
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-              expect(toolUseBlocks[0].name).toBe('add');
-              expect(toolUseBlocks[0].input).toBeDefined();
-            }
-          }
-
-          if (isSDKUserMessage(message)) {
-            const content = message.message.content;
-            const contentArray = Array.isArray(content)
-              ? content
-              : [{ type: 'text', text: content }];
-            const toolResultBlock = contentArray.find(
-              (block) => block.type === 'tool_result',
-            );
-            if (toolResultBlock) {
-              foundToolResult = true;
-            }
-          }
-        }
-
-        // Validate message flow
-        expect(foundToolUse).toBe(true);
-        expect(foundToolResult).toBe(true);
-        expect(messageTypes).toContain('system');
-        expect(messageTypes).toContain('assistant');
-        expect(messageTypes).toContain('user');
-        expect(messageTypes).toContain('result');
-
-        // Result should be last message
-        expect(messageTypes[messageTypes.length - 1]).toBe('result');
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle gracefully when MCP tool is not available', async () => {
-      const q = query({
-        prompt: 'Use the subtract tool to calculate 10 - 5',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'test-math-server': {
-              command: 'node',
-              args: [serverScriptPath],
-            },
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Should complete without crashing
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-
-        // Assistant should indicate tool is not available or provide alternative
-        expect(assistantText.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/multi-turn.test.ts
+++ b/integration-tests/sdk-typescript/multi-turn.test.ts
@@ -1,559 +0,0 @@
-/**
- * E2E tests based on multi-turn.ts example
- * Tests multi-turn conversation functionality with real CLI
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKUserMessage,
-  isSDKAssistantMessage,
-  isSDKSystemMessage,
-  isSDKResultMessage,
-  isSDKPartialAssistantMessage,
-  isControlRequest,
-  isControlResponse,
-  isControlCancel,
-  type SDKUserMessage,
-  type SDKAssistantMessage,
-  type TextBlock,
-  type ContentBlock,
-  type SDKMessage,
-  type ControlMessage,
-  type ToolUseBlock,
-} from '@qwen-code/sdk';
-import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-/**
- * Determine the message type using protocol type guards
- */
-function getMessageType(message: SDKMessage | ControlMessage): string {
-  if (isSDKUserMessage(message)) {
-    return '🧑 USER';
-  } else if (isSDKAssistantMessage(message)) {
-    return '🤖 ASSISTANT';
-  } else if (isSDKSystemMessage(message)) {
-    return `🖥️ SYSTEM(${message.subtype})`;
-  } else if (isSDKResultMessage(message)) {
-    return `✅ RESULT(${message.subtype})`;
-  } else if (isSDKPartialAssistantMessage(message)) {
-    return '⏳ STREAM_EVENT';
-  } else if (isControlRequest(message)) {
-    return `🎮 CONTROL_REQUEST(${message.request.subtype})`;
-  } else if (isControlResponse(message)) {
-    return `📭 CONTROL_RESPONSE(${message.response.subtype})`;
-  } else if (isControlCancel(message)) {
-    return '🛑 CONTROL_CANCEL';
-  } else {
-    return '❓ UNKNOWN';
-  }
-}
-
-/**
- * Helper to extract text from ContentBlock array
- */
-function extractText(content: ContentBlock[]): string {
-  return content
-    .filter((block): block is TextBlock => block.type === 'text')
-    .map((block) => block.text)
-    .join('');
-}
-
-describe('Multi-Turn Conversations (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('multi-turn');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-
-  describe('AsyncIterable Prompt Support', () => {
-    it('should handle multi-turn conversation using AsyncIterable prompt', async () => {
-      // Create multi-turn conversation generator
-      async function* createMultiTurnConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'What is 1 + 1?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'What is 2 + 2?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'What is 3 + 3?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      // Create multi-turn query using AsyncIterable prompt
-      const q = query({
-        prompt: createMultiTurnConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      const assistantMessages: SDKAssistantMessage[] = [];
-      const assistantTexts: string[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantMessages.push(message);
-            const text = extractText(message.message.content);
-            assistantTexts.push(text);
-          }
-        }
-
-        expect(messages.length).toBeGreaterThan(0);
-        expect(assistantMessages.length).toBeGreaterThanOrEqual(3);
-
-        // Validate content of responses
-        expect(assistantTexts[0]).toMatch(/2/);
-        expect(assistantTexts[1]).toMatch(/4/);
-        expect(assistantTexts[2]).toMatch(/6/);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should maintain session context across turns', async () => {
-      async function* createContextualConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content:
-              'Suppose we have 3 rabbits and 4 carrots. How many animals are there?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 200));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'How many animals are there? Only output the number',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createContextualConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const assistantMessages: SDKAssistantMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            assistantMessages.push(message);
-          }
-        }
-
-        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
-
-        // The second response should reference the color blue
-        const secondResponse = extractText(
-          assistantMessages[1].message.content,
-        );
-        expect(secondResponse.toLowerCase()).toContain('3');
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Tool Usage in Multi-Turn', () => {
-    it('should handle tool usage across multiple turns', async () => {
-      async function* createToolConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Create a file named test.txt with content "hello"',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 200));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Now read the test.txt file',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createToolConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          permissionMode: 'yolo',
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let toolUseCount = 0;
-      const assistantMessages: SDKAssistantMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantMessages.push(message);
-            const hasToolUseBlock = message.message.content.some(
-              (block: ContentBlock): block is ToolUseBlock =>
-                block.type === 'tool_use',
-            );
-            if (hasToolUseBlock) {
-              toolUseCount++;
-            }
-          }
-        }
-
-        expect(messages.length).toBeGreaterThan(0);
-        expect(toolUseCount).toBeGreaterThan(0);
-        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
-
-        // Validate second response mentions the file content
-        const secondResponse = extractText(
-          assistantMessages[assistantMessages.length - 1].message.content,
-        );
-        expect(secondResponse.toLowerCase()).toMatch(/hello|test\.txt/);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Message Flow and Sequencing', () => {
-    it('should process messages in correct sequence', async () => {
-      async function* createSequentialConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'First question: What is 1 + 1?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Second question: What is 2 + 2?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createSequentialConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messageSequence: string[] = [];
-      const assistantResponses: string[] = [];
-
-      try {
-        for await (const message of q) {
-          const messageType = getMessageType(message);
-          messageSequence.push(messageType);
-
-          if (isSDKAssistantMessage(message)) {
-            const text = extractText(message.message.content);
-            assistantResponses.push(text);
-          }
-        }
-
-        expect(messageSequence.length).toBeGreaterThan(0);
-        expect(assistantResponses.length).toBeGreaterThanOrEqual(2);
-
-        // Should end with result
-        expect(messageSequence[messageSequence.length - 1]).toContain('RESULT');
-
-        // Should have assistant responses
-        expect(messageSequence.some((type) => type.includes('ASSISTANT'))).toBe(
-          true,
-        );
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle conversation completion correctly', async () => {
-      async function* createSimpleConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Hello',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Goodbye',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createSimpleConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let completedNaturally = false;
-      let messageCount = 0;
-
-      try {
-        for await (const message of q) {
-          messageCount++;
-
-          if (isSDKResultMessage(message)) {
-            completedNaturally = true;
-            expect(message.subtype).toBe('success');
-          }
-        }
-
-        expect(messageCount).toBeGreaterThan(0);
-        expect(completedNaturally).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Error Handling in Multi-Turn', () => {
-    it('should handle empty conversation gracefully', async () => {
-      async function* createEmptyConversation(): AsyncIterable<SDKUserMessage> {
-        // Generator that yields nothing
-        /* eslint-disable no-constant-condition */
-        if (false) {
-          yield {} as SDKUserMessage; // Unreachable, but satisfies TypeScript
-        }
-      }
-
-      const q = query({
-        prompt: createEmptyConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Should handle empty conversation without crashing
-        expect(true).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle conversation with delays', async () => {
-      async function* createDelayedConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'First message',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        // Longer delay to test patience
-        await new Promise((resolve) => setTimeout(resolve, 500));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'Second message after delay',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createDelayedConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const assistantMessages: SDKAssistantMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            assistantMessages.push(message);
-          }
-        }
-
-        expect(assistantMessages.length).toBeGreaterThanOrEqual(2);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Partial Messages in Multi-Turn', () => {
-    it('should receive partial messages when includePartialMessages is enabled', async () => {
-      async function* createMultiTurnConversation(): AsyncIterable<SDKUserMessage> {
-        const sessionId = crypto.randomUUID();
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'What is 1 + 1?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: {
-            role: 'user',
-            content: 'What is 2 + 2?',
-          },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      }
-
-      const q = query({
-        prompt: createMultiTurnConversation(),
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          includePartialMessages: true,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let partialMessageCount = 0;
-      let assistantMessageCount = 0;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKPartialAssistantMessage(message)) {
-            partialMessageCount++;
-          }
-
-          if (isSDKAssistantMessage(message)) {
-            assistantMessageCount++;
-          }
-        }
-
-        expect(messages.length).toBeGreaterThan(0);
-        expect(partialMessageCount).toBeGreaterThan(0);
-        expect(assistantMessageCount).toBeGreaterThanOrEqual(2);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/permission-control.test.ts
+++ b/integration-tests/sdk-typescript/permission-control.test.ts
--- a/integration-tests/sdk-typescript/sdk-mcp-server.test.ts
+++ b/integration-tests/sdk-typescript/sdk-mcp-server.test.ts
@@ -1,456 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * E2E tests for SDK-embedded MCP servers
- *
- * Tests that the SDK can create and manage MCP servers running in the SDK process
- * using the tool() and createSdkMcpServer() APIs.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { z } from 'zod';
-import {
-  query,
-  tool,
-  createSdkMcpServer,
-  isSDKAssistantMessage,
-  isSDKResultMessage,
-  isSDKSystemMessage,
-  type SDKMessage,
-  type SDKSystemMessage,
-} from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  extractText,
-  findToolUseBlocks,
-  createSharedTestOptions,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = {
-  ...createSharedTestOptions(),
-  permissionMode: 'yolo' as const,
-};
-
-describe('SDK MCP Server Integration (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('sdk-mcp-server-integration');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-
-  describe('Basic SDK MCP Tool Usage', () => {
-    it('should use SDK MCP tool to perform a simple calculation', async () => {
-      // Define a simple calculator tool using the tool() API with Zod schema
-      const calculatorTool = tool(
-        'calculate_sum',
-        'Calculate the sum of two numbers',
-        z.object({
-          a: z.number().describe('First number'),
-          b: z.number().describe('Second number'),
-        }).shape,
-        async (args) => ({
-          content: [{ type: 'text', text: String(args.a + args.b) }],
-        }),
-      );
-
-      // Create SDK MCP server with the tool
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-calculator',
-        version: '1.0.0',
-        tools: [calculatorTool],
-      });
-
-      const q = query({
-        prompt:
-          'Use the calculate_sum tool to add 25 and 17. Output the result of tool only.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          mcpServers: {
-            'sdk-calculator': serverConfig,
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'calculate_sum');
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate tool was called
-        expect(foundToolUse).toBe(true);
-
-        // Validate result contains expected answer: 25 + 17 = 42
-        expect(assistantText).toMatch(/42/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-        if (isSDKResultMessage(lastMessage)) {
-          expect(lastMessage.subtype).toBe('success');
-        }
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should use SDK MCP tool with string operations', async () => {
-      // Define a string manipulation tool with Zod schema
-      const stringTool = tool(
-        'reverse_string',
-        'Reverse a string',
-        {
-          text: z.string().describe('The text to reverse'),
-        },
-        async (args) => ({
-          content: [
-            { type: 'text', text: args.text.split('').reverse().join('') },
-          ],
-        }),
-      );
-
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-string-utils',
-        version: '1.0.0',
-        tools: [stringTool],
-      });
-
-      const q = query({
-        prompt: `Use the 'reverse_string' tool to process the word "hello world". Output the tool result only.`,
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          mcpServers: {
-            'sdk-string-utils': serverConfig,
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'reverse_string');
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate tool was called
-        expect(foundToolUse).toBe(true);
-
-        // Validate result contains reversed string: "olleh"
-        expect(assistantText.toLowerCase()).toMatch(/olleh/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Multiple SDK MCP Tools', () => {
-    it('should use multiple tools from the same SDK MCP server', async () => {
-      // Define the Zod schema shape for two numbers
-      const twoNumbersSchema = {
-        a: z.number().describe('First number'),
-        b: z.number().describe('Second number'),
-      };
-
-      // Define multiple tools
-      const addTool = tool(
-        'sdk_add',
-        'Add two numbers',
-        twoNumbersSchema,
-        async (args) => ({
-          content: [{ type: 'text', text: String(args.a + args.b) }],
-        }),
-      );
-
-      const multiplyTool = tool(
-        'sdk_multiply',
-        'Multiply two numbers',
-        twoNumbersSchema,
-        async (args) => ({
-          content: [{ type: 'text', text: String(args.a * args.b) }],
-        }),
-      );
-
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-math',
-        version: '1.0.0',
-        tools: [addTool, multiplyTool],
-      });
-
-      const q = query({
-        prompt:
-          'First use sdk_add to calculate 10 + 5, then use sdk_multiply to multiply the result by 3. Give me the final answer.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'sdk-math': serverConfig,
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      const toolCalls: string[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message);
-            toolUseBlocks.forEach((block) => {
-              toolCalls.push(block.name);
-            });
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate both tools were called
-        expect(toolCalls).toContain('sdk_add');
-        expect(toolCalls).toContain('sdk_multiply');
-
-        // Validate result: (10 + 5) * 3 = 45
-        expect(assistantText).toMatch(/45/);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('SDK MCP Server Discovery', () => {
-    it('should list SDK MCP servers in system init message', async () => {
-      // Define echo tool with Zod schema
-      const echoTool = tool(
-        'echo',
-        'Echo a message',
-        {
-          message: z.string().describe('Message to echo'),
-        },
-        async (args) => ({
-          content: [{ type: 'text', text: args.message }],
-        }),
-      );
-
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-echo',
-        version: '1.0.0',
-        tools: [echoTool],
-      });
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'sdk-echo': serverConfig,
-          },
-        },
-      });
-
-      let systemMessage: SDKSystemMessage | null = null;
-
-      try {
-        for await (const message of q) {
-          if (isSDKSystemMessage(message) && message.subtype === 'init') {
-            systemMessage = message;
-            break;
-          }
-        }
-
-        // Validate MCP server is listed
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.mcp_servers).toBeDefined();
-        expect(Array.isArray(systemMessage!.mcp_servers)).toBe(true);
-
-        // Find our SDK MCP server
-        const sdkServer = systemMessage!.mcp_servers?.find(
-          (server) => server.name === 'sdk-echo',
-        );
-        expect(sdkServer).toBeDefined();
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('SDK MCP Tool Error Handling', () => {
-    it('should handle tool errors gracefully', async () => {
-      // Define a tool that throws an error with Zod schema
-      const errorTool = tool(
-        'maybe_fail',
-        'A tool that may fail based on input',
-        {
-          shouldFail: z.boolean().describe('If true, the tool will fail'),
-        },
-        async (args) => {
-          if (args.shouldFail) {
-            throw new Error('Tool intentionally failed');
-          }
-          return { content: [{ type: 'text', text: 'Success!' }] };
-        },
-      );
-
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-error-test',
-        version: '1.0.0',
-        tools: [errorTool],
-      });
-
-      const q = query({
-        prompt:
-          'Use the maybe_fail tool with shouldFail set to true. Tell me what happens.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'sdk-error-test': serverConfig,
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(message, 'maybe_fail');
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-          }
-        }
-
-        // Tool should be called
-        expect(foundToolUse).toBe(true);
-
-        // Query should complete (even with tool error)
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Async Tool Handlers', () => {
-    it('should handle async tool handlers with delays', async () => {
-      // Define a tool with async delay using Zod schema
-      const delayedTool = tool(
-        'delayed_response',
-        'Returns a value after a delay',
-        {
-          delay: z.number().describe('Delay in milliseconds (max 100)'),
-          value: z.string().describe('Value to return'),
-        },
-        async (args) => {
-          // Cap delay at 100ms for test performance
-          const actualDelay = Math.min(args.delay, 100);
-          await new Promise((resolve) => setTimeout(resolve, actualDelay));
-          return {
-            content: [{ type: 'text', text: `Delayed result: ${args.value}` }],
-          };
-        },
-      );
-
-      const serverConfig = createSdkMcpServer({
-        name: 'sdk-async',
-        version: '1.0.0',
-        tools: [delayedTool],
-      });
-
-      const q = query({
-        prompt:
-          'Use the delayed_response tool with delay=50 and value="test_async". Tell me the result.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-          mcpServers: {
-            'sdk-async': serverConfig,
-          },
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-      let foundToolUse = false;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            const toolUseBlocks = findToolUseBlocks(
-              message,
-              'delayed_response',
-            );
-            if (toolUseBlocks.length > 0) {
-              foundToolUse = true;
-            }
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate tool was called
-        expect(foundToolUse).toBe(true);
-
-        // Validate result contains the delayed response
-        expect(assistantText.toLowerCase()).toMatch(/test_async/i);
-
-        // Validate successful completion
-        const lastMessage = messages[messages.length - 1];
-        expect(isSDKResultMessage(lastMessage)).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/single-turn.test.ts
+++ b/integration-tests/sdk-typescript/single-turn.test.ts
@@ -1,528 +0,0 @@
-/**
- * E2E tests for single-turn query execution
- * Tests basic query patterns with simple prompts and clear output expectations
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  isSDKSystemMessage,
-  isSDKResultMessage,
-  isSDKPartialAssistantMessage,
-  type SDKMessage,
-  type SDKSystemMessage,
-  type SDKAssistantMessage,
-} from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  extractText,
-  createSharedTestOptions,
-  assertSuccessfulCompletion,
-  collectMessagesByType,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-describe('Single-Turn Query (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('single-turn');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-  describe('Simple Text Queries', () => {
-    it('should answer basic arithmetic question', async () => {
-      const q = query({
-        prompt: 'What is 2 + 2? Just give me the number.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: true,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate we got messages
-        expect(messages.length).toBeGreaterThan(0);
-
-        // Validate assistant response content
-        expect(assistantText.length).toBeGreaterThan(0);
-        expect(assistantText).toMatch(/4/);
-
-        // Validate message flow ends with success
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should answer simple factual question', async () => {
-      const q = query({
-        prompt: 'What is the capital of France? One word answer.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate content
-        expect(assistantText.length).toBeGreaterThan(0);
-        expect(assistantText.toLowerCase()).toContain('paris');
-
-        // Validate completion
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle greeting and self-description', async () => {
-      const q = query({
-        prompt: 'Say hello and tell me your name in one sentence.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate content contains greeting
-        expect(assistantText.length).toBeGreaterThan(0);
-        expect(assistantText.toLowerCase()).toMatch(/hello|hi|greetings/);
-
-        // Validate message types
-        const assistantMessages = collectMessagesByType(
-          messages,
-          isSDKAssistantMessage,
-        );
-        expect(assistantMessages.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('System Initialization', () => {
-    it('should receive system message with initialization info', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let systemMessage: SDKSystemMessage | null = null;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKSystemMessage(message) && message.subtype === 'init') {
-            systemMessage = message;
-          }
-        }
-
-        // Validate system message exists and has required fields
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.type).toBe('system');
-        expect(systemMessage!.subtype).toBe('init');
-        expect(systemMessage!.uuid).toBeDefined();
-        expect(systemMessage!.session_id).toBeDefined();
-        expect(systemMessage!.cwd).toBeDefined();
-        expect(systemMessage!.tools).toBeDefined();
-        expect(Array.isArray(systemMessage!.tools)).toBe(true);
-        expect(systemMessage!.mcp_servers).toBeDefined();
-        expect(Array.isArray(systemMessage!.mcp_servers)).toBe(true);
-        expect(systemMessage!.model).toBeDefined();
-        expect(systemMessage!.permission_mode).toBeDefined();
-        expect(systemMessage!.qwen_code_version).toBeDefined();
-
-        // Validate system message appears early in sequence
-        const systemMessageIndex = messages.findIndex(
-          (msg) => isSDKSystemMessage(msg) && msg.subtype === 'init',
-        );
-        expect(systemMessageIndex).toBeGreaterThanOrEqual(0);
-        expect(systemMessageIndex).toBeLessThan(3);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should maintain session ID consistency', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let systemMessage: SDKSystemMessage | null = null;
-      const sessionId = q.getSessionId();
-
-      try {
-        for await (const message of q) {
-          if (isSDKSystemMessage(message) && message.subtype === 'init') {
-            systemMessage = message;
-          }
-        }
-
-        // Validate session IDs are consistent
-        expect(sessionId).toBeDefined();
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.session_id).toBeDefined();
-        expect(systemMessage!.uuid).toBeDefined();
-        expect(systemMessage!.session_id).toBe(systemMessage!.uuid);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Message Flow', () => {
-    it('should follow expected message sequence', async () => {
-      const q = query({
-        prompt: 'Say hi',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messageTypes: string[] = [];
-
-      try {
-        for await (const message of q) {
-          messageTypes.push(message.type);
-        }
-
-        // Validate message sequence
-        expect(messageTypes.length).toBeGreaterThan(0);
-        expect(messageTypes).toContain('assistant');
-        expect(messageTypes[messageTypes.length - 1]).toBe('result');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should complete iteration naturally', async () => {
-      const q = query({
-        prompt: 'Say goodbye',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let completedNaturally = false;
-      let messageCount = 0;
-
-      try {
-        for await (const message of q) {
-          messageCount++;
-
-          if (isSDKResultMessage(message)) {
-            completedNaturally = true;
-            expect(message.subtype).toBe('success');
-          }
-        }
-
-        expect(messageCount).toBeGreaterThan(0);
-        expect(completedNaturally).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Configuration Options', () => {
-    it('should respect debug option and capture stderr', async () => {
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-        },
-      });
-
-      try {
-        for await (const _message of q) {
-          // Consume all messages
-        }
-
-        // Debug mode should produce stderr output
-        expect(stderrMessages.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should respect cwd option', async () => {
-      const q = query({
-        prompt: 'What is 1 + 1?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let hasResponse = false;
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            hasResponse = true;
-          }
-        }
-
-        expect(hasResponse).toBe(true);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should receive partial messages when includePartialMessages is enabled', async () => {
-      const q = query({
-        prompt: 'Count from 1 to 5',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          includePartialMessages: true,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let partialMessageCount = 0;
-      let assistantMessageCount = 0;
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKPartialAssistantMessage(message)) {
-            partialMessageCount++;
-          }
-
-          if (isSDKAssistantMessage(message)) {
-            assistantMessageCount++;
-          }
-        }
-
-        expect(messages.length).toBeGreaterThan(0);
-        expect(partialMessageCount).toBeGreaterThan(0);
-        expect(assistantMessageCount).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Message Type Recognition', () => {
-    it('should correctly identify all message types', async () => {
-      const q = query({
-        prompt: 'What is 5 + 5?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate type guards work correctly
-        const assistantMessages = collectMessagesByType(
-          messages,
-          isSDKAssistantMessage,
-        );
-        const resultMessages = collectMessagesByType(
-          messages,
-          isSDKResultMessage,
-        );
-        const systemMessages = collectMessagesByType(
-          messages,
-          isSDKSystemMessage,
-        );
-
-        expect(assistantMessages.length).toBeGreaterThan(0);
-        expect(resultMessages.length).toBeGreaterThan(0);
-        expect(systemMessages.length).toBeGreaterThan(0);
-
-        // Validate assistant message structure
-        const firstAssistant = assistantMessages[0];
-        expect(firstAssistant.message.content).toBeDefined();
-        expect(Array.isArray(firstAssistant.message.content)).toBe(true);
-
-        // Validate result message structure
-        const resultMessage = resultMessages[0];
-        expect(resultMessage.subtype).toBe('success');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should extract text content from assistant messages', async () => {
-      const q = query({
-        prompt: 'Count from 1 to 3',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      let assistantMessage: SDKAssistantMessage | null = null;
-
-      try {
-        for await (const message of q) {
-          if (isSDKAssistantMessage(message)) {
-            assistantMessage = message;
-          }
-        }
-
-        expect(assistantMessage).not.toBeNull();
-        expect(assistantMessage!.message.content).toBeDefined();
-
-        // Validate content contains expected numbers
-        const text = extractText(assistantMessage!.message.content);
-        expect(text.length).toBeGreaterThan(0);
-        expect(text).toMatch(/1/);
-        expect(text).toMatch(/2/);
-        expect(text).toMatch(/3/);
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should throw if CLI not found', async () => {
-      try {
-        const q = query({
-          prompt: 'Hello',
-          options: {
-            pathToQwenExecutable: '/nonexistent/path/to/cli',
-            debug: false,
-          },
-        });
-
-        for await (const _message of q) {
-          // Should not reach here
-        }
-
-        expect(false).toBe(true); // Should have thrown
-      } catch (error) {
-        expect(error).toBeDefined();
-        expect(error instanceof Error).toBe(true);
-        expect((error as Error).message).toContain(
-          'Invalid pathToQwenExecutable',
-        );
-      }
-    });
-  });
-
-  describe('Resource Management', () => {
-    it('should cleanup subprocess on close()', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      // Start and immediately close
-      const iterator = q[Symbol.asyncIterator]();
-      await iterator.next();
-
-      // Should close without error
-      await q.close();
-      expect(true).toBe(true); // Cleanup completed
-    });
-
-    it('should handle close() called multiple times', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          debug: false,
-        },
-      });
-
-      // Start the query
-      const iterator = q[Symbol.asyncIterator]();
-      await iterator.next();
-
-      // Close multiple times
-      await q.close();
-      await q.close();
-      await q.close();
-
-      // Should not throw
-      expect(true).toBe(true);
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/subagents.test.ts
+++ b/integration-tests/sdk-typescript/subagents.test.ts
@@ -1,614 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * E2E tests for subagent configuration and execution
- * Tests subagent delegation and task completion
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  type SDKMessage,
-  type SubagentConfig,
-  type ContentBlock,
-  type ToolUseBlock,
-} from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  extractText,
-  createSharedTestOptions,
-  findToolUseBlocks,
-  assertSuccessfulCompletion,
-  findSystemMessage,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-describe('Subagents (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testWorkDir: string;
-
-  beforeEach(async () => {
-    // Create isolated test environment using SDKTestHelper
-    helper = new SDKTestHelper();
-    testWorkDir = await helper.setup('subagent-tests');
-
-    // Create a simple test file for subagent to work with
-    await helper.createFile('test.txt', 'Hello from test file\n');
-  });
-
-  afterEach(async () => {
-    // Cleanup test directory
-    await helper.cleanup();
-  });
-
-  describe('Subagent Configuration', () => {
-    it('should accept session-level subagent configuration', async () => {
-      const simpleSubagent: SubagentConfig = {
-        name: 'simple-greeter',
-        description: 'A simple subagent that responds to greetings',
-        systemPrompt:
-          'You are a friendly greeter. When given a task, respond with a cheerful greeting.',
-        level: 'session',
-      };
-
-      const q = query({
-        prompt: 'Hello, let simple-greeter to say hi back to me.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [simpleSubagent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate system message includes the subagent
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('simple-greeter');
-
-        // Validate successful completion
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should accept multiple subagent configurations', async () => {
-      const greeterAgent: SubagentConfig = {
-        name: 'greeter',
-        description: 'Responds to greetings',
-        systemPrompt: 'You are a friendly greeter.',
-        level: 'session',
-      };
-
-      const mathAgent: SubagentConfig = {
-        name: 'math-helper',
-        description: 'Helps with math problems',
-        systemPrompt: 'You are a math expert. Solve math problems clearly.',
-        level: 'session',
-      };
-
-      const q = query({
-        prompt: 'What is 5 + 5?',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [greeterAgent, mathAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate both subagents are registered
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('greeter');
-        expect(systemMessage!.agents).toContain('math-helper');
-        expect(systemMessage!.agents!.length).toBeGreaterThanOrEqual(2);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle subagent with custom model config', async () => {
-      const customModelAgent: SubagentConfig = {
-        name: 'custom-model-agent',
-        description: 'Agent with custom model configuration',
-        systemPrompt: 'You are a helpful assistant.',
-        level: 'session',
-        modelConfig: {
-          temp: 0.7,
-          top_p: 0.9,
-        },
-      };
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [customModelAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate subagent is registered
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('custom-model-agent');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle subagent with run config', async () => {
-      const limitedAgent: SubagentConfig = {
-        name: 'limited-agent',
-        description: 'Agent with execution limits',
-        systemPrompt: 'You are a helpful assistant.',
-        level: 'session',
-        runConfig: {
-          max_turns: 5,
-          max_time_minutes: 1,
-        },
-      };
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [limitedAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate subagent is registered
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('limited-agent');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle subagent with specific tools', async () => {
-      const toolRestrictedAgent: SubagentConfig = {
-        name: 'read-only-agent',
-        description: 'Agent that can only read files',
-        systemPrompt:
-          'You are a file reading assistant. Read files when asked.',
-        level: 'session',
-        tools: ['read_file', 'list_directory'],
-      };
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [toolRestrictedAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate subagent is registered
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('read-only-agent');
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Subagent Execution', () => {
-    it('should delegate task to subagent when appropriate', async () => {
-      const fileReaderAgent: SubagentConfig = {
-        name: 'file-reader',
-        description: 'Reads and reports file contents',
-        systemPrompt: `You are a file reading assistant. When given a task to read a file, use the read_file tool to read it and report its contents back. Be concise in your response.`,
-        level: 'session',
-        tools: ['read_file', 'list_directory'],
-      };
-
-      const testFile = helper.getPath('test.txt');
-      const q = query({
-        prompt: `Use the file-reader subagent to read the file at ${testFile} and tell me what it contains.`,
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [fileReaderAgent],
-          debug: false,
-          permissionMode: 'yolo',
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let foundTaskTool = false;
-      let taskToolUseId: string | null = null;
-      let foundSubagentToolCall = false;
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            // Check for task tool use in content blocks (main agent calling subagent)
-            const taskToolBlocks = findToolUseBlocks(message, 'task');
-            if (taskToolBlocks.length > 0) {
-              foundTaskTool = true;
-              taskToolUseId = taskToolBlocks[0].id;
-            }
-
-            // Check if this message is from a subagent (has parent_tool_use_id)
-            if (message.parent_tool_use_id !== null) {
-              // This is a subagent message
-              const subagentToolBlocks = findToolUseBlocks(message);
-              if (subagentToolBlocks.length > 0) {
-                foundSubagentToolCall = true;
-                // Verify parent_tool_use_id matches the task tool use id
-                expect(message.parent_tool_use_id).toBe(taskToolUseId);
-              }
-            }
-
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate task tool was used (subagent delegation)
-        expect(foundTaskTool).toBe(true);
-        expect(taskToolUseId).not.toBeNull();
-
-        // Validate subagent actually made tool calls with proper parent_tool_use_id
-        expect(foundSubagentToolCall).toBe(true);
-
-        // Validate we got a response
-        expect(assistantText.length).toBeGreaterThan(0);
-
-        // Validate successful completion
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    }, 60000); // Increase timeout for subagent execution
-
-    it('should complete simple task with subagent', async () => {
-      const simpleTaskAgent: SubagentConfig = {
-        name: 'simple-calculator',
-        description: 'Performs simple arithmetic calculations',
-        systemPrompt:
-          'You are a calculator. When given a math problem, solve it and provide just the answer.',
-        level: 'session',
-      };
-
-      const q = query({
-        prompt: 'Use the simple-calculator subagent to calculate 15 + 27.',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [simpleTaskAgent],
-          debug: false,
-          permissionMode: 'yolo',
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let foundTaskTool = false;
-      let assistantText = '';
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            // Check for task tool use (main agent delegating to subagent)
-            const toolUseBlock = message.message.content.find(
-              (block: ContentBlock): block is ToolUseBlock =>
-                block.type === 'tool_use' && block.name === 'task',
-            );
-            if (toolUseBlock) {
-              foundTaskTool = true;
-            }
-
-            assistantText += extractText(message.message.content);
-          }
-        }
-
-        // Validate task tool was used (subagent was called)
-        expect(foundTaskTool).toBe(true);
-
-        // Validate we got a response
-        expect(assistantText.length).toBeGreaterThan(0);
-
-        // Validate successful completion
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    }, 60000);
-
-    it('should verify subagent execution with comprehensive parent_tool_use_id checks', async () => {
-      const comprehensiveAgent: SubagentConfig = {
-        name: 'comprehensive-agent',
-        description: 'Agent for comprehensive testing',
-        systemPrompt:
-          'You are a helpful assistant. When asked to list files, use the list_directory tool.',
-        level: 'session',
-        tools: ['list_directory', 'read_file'],
-      };
-
-      const q = query({
-        prompt: `Use the comprehensive-agent subagent to list the files in ${testWorkDir}.`,
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [comprehensiveAgent],
-          debug: false,
-          permissionMode: 'yolo',
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-      let taskToolUseId: string | null = null;
-      const subagentToolCalls: ToolUseBlock[] = [];
-      const mainAgentToolCalls: ToolUseBlock[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-
-          if (isSDKAssistantMessage(message)) {
-            // Collect all tool use blocks
-            const toolUseBlocks = message.message.content.filter(
-              (block: ContentBlock): block is ToolUseBlock =>
-                block.type === 'tool_use',
-            );
-
-            for (const toolUse of toolUseBlocks) {
-              if (toolUse.name === 'task') {
-                // This is the main agent calling the subagent
-                taskToolUseId = toolUse.id;
-                mainAgentToolCalls.push(toolUse);
-              }
-
-              // If this message has parent_tool_use_id, it's from a subagent
-              if (message.parent_tool_use_id !== null) {
-                subagentToolCalls.push(toolUse);
-              }
-            }
-          }
-        }
-
-        // Criterion 1: When a subagent is called, there must be a 'task' tool being called
-        expect(taskToolUseId).not.toBeNull();
-        expect(mainAgentToolCalls.length).toBeGreaterThan(0);
-        expect(mainAgentToolCalls.some((tc) => tc.name === 'task')).toBe(true);
-
-        // Criterion 2: A tool call from a subagent is identified by a non-null parent_tool_use_id
-        // All subagent tool calls should have parent_tool_use_id set to the task tool's id
-        expect(subagentToolCalls.length).toBeGreaterThan(0);
-
-        // Verify all subagent messages have the correct parent_tool_use_id
-        const subagentMessages = messages.filter(
-          (msg): msg is SDKMessage & { parent_tool_use_id: string } =>
-            isSDKAssistantMessage(msg) && msg.parent_tool_use_id !== null,
-        );
-
-        expect(subagentMessages.length).toBeGreaterThan(0);
-        for (const subagentMsg of subagentMessages) {
-          expect(subagentMsg.parent_tool_use_id).toBe(taskToolUseId);
-        }
-
-        // Verify no main agent tool calls (except task) have parent_tool_use_id
-        const mainAgentMessages = messages.filter(
-          (msg): msg is SDKMessage =>
-            isSDKAssistantMessage(msg) && msg.parent_tool_use_id === null,
-        );
-
-        for (const mainMsg of mainAgentMessages) {
-          if (isSDKAssistantMessage(mainMsg)) {
-            // Main agent messages should not have parent_tool_use_id
-            expect(mainMsg.parent_tool_use_id).toBeNull();
-          }
-        }
-
-        // Validate successful completion
-        assertSuccessfulCompletion(messages);
-      } finally {
-        await q.close();
-      }
-    }, 60000);
-  });
-
-  describe('Subagent Error Handling', () => {
-    it('should handle empty subagent array', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Should still work with empty agents array
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle subagent with minimal configuration', async () => {
-      const minimalAgent: SubagentConfig = {
-        name: 'minimal-agent',
-        description: 'Minimal configuration agent',
-        systemPrompt: 'You are a helpful assistant.',
-        level: 'session',
-      };
-
-      const q = query({
-        prompt: 'Say hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [minimalAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate minimal agent is registered
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('minimal-agent');
-      } finally {
-        await q.close();
-      }
-    });
-  });
-
-  describe('Subagent Integration', () => {
-    it('should work with other SDK options', async () => {
-      const testAgent: SubagentConfig = {
-        name: 'test-agent',
-        description: 'Test agent for integration',
-        systemPrompt: 'You are a test assistant.',
-        level: 'session',
-      };
-
-      const stderrMessages: string[] = [];
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [testAgent],
-          debug: true,
-          stderr: (msg: string) => {
-            stderrMessages.push(msg);
-          },
-          permissionMode: 'default',
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate subagent works with debug mode
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.agents).toBeDefined();
-        expect(systemMessage!.agents).toContain('test-agent');
-        expect(stderrMessages.length).toBeGreaterThan(0);
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should maintain session consistency with subagents', async () => {
-      const sessionAgent: SubagentConfig = {
-        name: 'session-agent',
-        description: 'Agent for session testing',
-        systemPrompt: 'You are a session test assistant.',
-        level: 'session',
-      };
-
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testWorkDir,
-          agents: [sessionAgent],
-          debug: false,
-        },
-      });
-
-      const messages: SDKMessage[] = [];
-
-      try {
-        for await (const message of q) {
-          messages.push(message);
-        }
-
-        // Validate session consistency
-        const systemMessage = findSystemMessage(messages, 'init');
-        expect(systemMessage).not.toBeNull();
-        expect(systemMessage!.session_id).toBeDefined();
-        expect(systemMessage!.uuid).toBeDefined();
-        expect(systemMessage!.session_id).toBe(systemMessage!.uuid);
-        expect(systemMessage!.agents).toContain('session-agent');
-      } finally {
-        await q.close();
-      }
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/system-control.test.ts
+++ b/integration-tests/sdk-typescript/system-control.test.ts
@@ -1,317 +0,0 @@
-/**
- * E2E tests for system controller features:
- * - setModel API for dynamic model switching
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  query,
-  isSDKAssistantMessage,
-  isSDKSystemMessage,
-  type SDKUserMessage,
-} from '@qwen-code/sdk';
-import { SDKTestHelper, createSharedTestOptions } from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-
-/**
- * Factory function that creates a streaming input with a control point.
- * After the first message is yielded, the generator waits for a resume signal,
- * allowing the test code to call query instance methods like setModel.
- *
- * @param firstMessage - The first user message to send
- * @param secondMessage - The second user message to send after control operations
- * @returns Object containing the async generator and a resume function
- */
-function createStreamingInputWithControlPoint(
-  firstMessage: string,
-  secondMessage: string,
-): {
-  generator: AsyncIterable<SDKUserMessage>;
-  resume: () => void;
-} {
-  let resumeResolve: (() => void) | null = null;
-  const resumePromise = new Promise<void>((resolve) => {
-    resumeResolve = resolve;
-  });
-
-  const generator = (async function* () {
-    const sessionId = crypto.randomUUID();
-
-    yield {
-      type: 'user',
-      session_id: sessionId,
-      message: {
-        role: 'user',
-        content: firstMessage,
-      },
-      parent_tool_use_id: null,
-    } as SDKUserMessage;
-
-    await new Promise((resolve) => setTimeout(resolve, 200));
-
-    await resumePromise;
-
-    await new Promise((resolve) => setTimeout(resolve, 200));
-
-    yield {
-      type: 'user',
-      session_id: sessionId,
-      message: {
-        role: 'user',
-        content: secondMessage,
-      },
-      parent_tool_use_id: null,
-    } as SDKUserMessage;
-  })();
-
-  const resume = () => {
-    if (resumeResolve) {
-      resumeResolve();
-    }
-  };
-
-  return { generator, resume };
-}
-
-describe('System Control (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('system-control');
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-
-  describe('setModel API', () => {
-    it('should change model dynamically during streaming input', async () => {
-      const { generator, resume } = createStreamingInputWithControlPoint(
-        'Tell me the model name.',
-        'Tell me the model name now again.',
-      );
-
-      const q = query({
-        prompt: generator,
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          model: 'qwen3-max',
-          debug: false,
-        },
-      });
-
-      try {
-        const resolvers: {
-          first?: () => void;
-          second?: () => void;
-        } = {};
-        const firstResponsePromise = new Promise<void>((resolve) => {
-          resolvers.first = resolve;
-        });
-        const secondResponsePromise = new Promise<void>((resolve) => {
-          resolvers.second = resolve;
-        });
-
-        let firstResponseReceived = false;
-        let secondResponseReceived = false;
-        const systemMessages: Array<{ model?: string }> = [];
-
-        // Consume messages in a single loop
-        (async () => {
-          for await (const message of q) {
-            if (isSDKSystemMessage(message)) {
-              systemMessages.push({ model: message.model });
-            }
-            if (isSDKAssistantMessage(message)) {
-              if (!firstResponseReceived) {
-                firstResponseReceived = true;
-                resolvers.first?.();
-              } else if (!secondResponseReceived) {
-                secondResponseReceived = true;
-                resolvers.second?.();
-              }
-            }
-          }
-        })();
-
-        // Wait for first response
-        await Promise.race([
-          firstResponsePromise,
-          new Promise((_, reject) =>
-            setTimeout(
-              () => reject(new Error('Timeout waiting for first response')),
-              15000,
-            ),
-          ),
-        ]);
-
-        expect(firstResponseReceived).toBe(true);
-
-        // Perform control operation: set model
-        await q.setModel('qwen3-vl-plus');
-
-        // Resume the input stream
-        resume();
-
-        // Wait for second response
-        await Promise.race([
-          secondResponsePromise,
-          new Promise((_, reject) =>
-            setTimeout(
-              () => reject(new Error('Timeout waiting for second response')),
-              10000,
-            ),
-          ),
-        ]);
-
-        expect(secondResponseReceived).toBe(true);
-
-        // Verify system messages - model should change from qwen3-max to qwen3-vl-plus
-        expect(systemMessages.length).toBeGreaterThanOrEqual(2);
-        expect(systemMessages[0].model).toBeOneOf(['qwen3-max', 'coder-model']);
-        expect(systemMessages[1].model).toBe('qwen3-vl-plus');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should handle multiple model changes in sequence', async () => {
-      const sessionId = crypto.randomUUID();
-      let resumeResolve1: (() => void) | null = null;
-      let resumeResolve2: (() => void) | null = null;
-      const resumePromise1 = new Promise<void>((resolve) => {
-        resumeResolve1 = resolve;
-      });
-      const resumePromise2 = new Promise<void>((resolve) => {
-        resumeResolve2 = resolve;
-      });
-
-      const generator = (async function* () {
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: { role: 'user', content: 'First message' },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        await resumePromise1;
-        await new Promise((resolve) => setTimeout(resolve, 200));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: { role: 'user', content: 'Second message' },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        await resumePromise2;
-        await new Promise((resolve) => setTimeout(resolve, 200));
-
-        yield {
-          type: 'user',
-          session_id: sessionId,
-          message: { role: 'user', content: 'Third message' },
-          parent_tool_use_id: null,
-        } as SDKUserMessage;
-      })();
-
-      const q = query({
-        prompt: generator,
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          model: 'qwen3-max',
-          debug: false,
-        },
-      });
-
-      try {
-        const systemMessages: Array<{ model?: string }> = [];
-        let responseCount = 0;
-        const resolvers: Array<() => void> = [];
-        const responsePromises = [
-          new Promise<void>((resolve) => resolvers.push(resolve)),
-          new Promise<void>((resolve) => resolvers.push(resolve)),
-          new Promise<void>((resolve) => resolvers.push(resolve)),
-        ];
-
-        (async () => {
-          for await (const message of q) {
-            if (isSDKSystemMessage(message)) {
-              systemMessages.push({ model: message.model });
-            }
-            if (isSDKAssistantMessage(message)) {
-              if (responseCount < resolvers.length) {
-                resolvers[responseCount]?.();
-                responseCount++;
-              }
-            }
-          }
-        })();
-
-        // Wait for first response
-        await Promise.race([
-          responsePromises[0],
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Timeout 1')), 10000),
-          ),
-        ]);
-
-        // First model change
-        await q.setModel('qwen3-turbo');
-        resumeResolve1!();
-
-        // Wait for second response
-        await Promise.race([
-          responsePromises[1],
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Timeout 2')), 10000),
-          ),
-        ]);
-
-        // Second model change
-        await q.setModel('qwen3-vl-plus');
-        resumeResolve2!();
-
-        // Wait for third response
-        await Promise.race([
-          responsePromises[2],
-          new Promise((_, reject) =>
-            setTimeout(() => reject(new Error('Timeout 3')), 10000),
-          ),
-        ]);
-
-        // Verify we received system messages for each model
-        expect(systemMessages.length).toBeGreaterThanOrEqual(3);
-        expect(systemMessages[0].model).toBeOneOf(['qwen3-max', 'coder-model']);
-        expect(systemMessages[1].model).toBe('qwen3-turbo');
-        expect(systemMessages[2].model).toBe('qwen3-vl-plus');
-      } finally {
-        await q.close();
-      }
-    });
-
-    it('should throw error when setModel is called on closed query', async () => {
-      const q = query({
-        prompt: 'Hello',
-        options: {
-          ...SHARED_TEST_OPTIONS,
-          cwd: testDir,
-          model: 'qwen3-max',
-        },
-      });
-
-      await q.close();
-
-      await expect(q.setModel('qwen3-turbo')).rejects.toThrow(
-        'Query is closed',
-      );
-    });
-  });
-});
--- a/integration-tests/sdk-typescript/test-helper.ts
+++ b/integration-tests/sdk-typescript/test-helper.ts
@@ -1,970 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * SDK E2E Test Helper
- * Provides utilities for SDK e2e tests including test isolation,
- * file management, MCP server setup, and common test utilities.
- */
-
-import { mkdir, writeFile, readFile, rm, chmod } from 'node:fs/promises';
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
-import type {
-  SDKMessage,
-  SDKAssistantMessage,
-  SDKSystemMessage,
-  SDKUserMessage,
-  ContentBlock,
-  TextBlock,
-  ToolUseBlock,
-} from '@qwen-code/sdk';
-import {
-  isSDKAssistantMessage,
-  isSDKSystemMessage,
-  isSDKResultMessage,
-} from '@qwen-code/sdk';
-
-// ============================================================================
-// Core Test Helper Class
-// ============================================================================
-
-export interface SDKTestHelperOptions {
-  /**
-   * Optional settings for .qwen/settings.json
-   */
-  settings?: Record<string, unknown>;
-  /**
-   * Whether to create .qwen/settings.json
-   */
-  createQwenConfig?: boolean;
-}
-
-/**
- * Helper class for SDK E2E tests
- * Provides isolated test environments for each test case
- */
-export class SDKTestHelper {
-  testDir: string | null = null;
-  testName?: string;
-  private baseDir: string;
-
-  constructor() {
-    this.baseDir = process.env['E2E_TEST_FILE_DIR']!;
-    if (!this.baseDir) {
-      throw new Error('E2E_TEST_FILE_DIR environment variable not set');
-    }
-  }
-
-  /**
-   * Setup an isolated test directory for a specific test
-   */
-  async setup(
-    testName: string,
-    options: SDKTestHelperOptions = {},
-  ): Promise<string> {
-    this.testName = testName;
-    const sanitizedName = this.sanitizeTestName(testName);
-    this.testDir = join(this.baseDir, sanitizedName);
-
-    await mkdir(this.testDir, { recursive: true });
-
-    // Optionally create .qwen/settings.json for CLI configuration
-    if (options.createQwenConfig) {
-      const qwenDir = join(this.testDir, '.qwen');
-      await mkdir(qwenDir, { recursive: true });
-
-      const settings = {
-        telemetry: {
-          enabled: false, // SDK tests don't need telemetry
-        },
-        ...options.settings,
-      };
-
-      await writeFile(
-        join(qwenDir, 'settings.json'),
-        JSON.stringify(settings, null, 2),
-        'utf-8',
-      );
-    }
-
-    return this.testDir;
-  }
-
-  /**
-   * Create a file in the test directory
-   */
-  async createFile(fileName: string, content: string): Promise<string> {
-    if (!this.testDir) {
-      throw new Error('Test directory not initialized. Call setup() first.');
-    }
-    const filePath = join(this.testDir, fileName);
-    await writeFile(filePath, content, 'utf-8');
-    return filePath;
-  }
-
-  /**
-   * Read a file from the test directory
-   */
-  async readFile(fileName: string): Promise<string> {
-    if (!this.testDir) {
-      throw new Error('Test directory not initialized. Call setup() first.');
-    }
-    const filePath = join(this.testDir, fileName);
-    return await readFile(filePath, 'utf-8');
-  }
-
-  /**
-   * Create a subdirectory in the test directory
-   */
-  async mkdir(dirName: string): Promise<string> {
-    if (!this.testDir) {
-      throw new Error('Test directory not initialized. Call setup() first.');
-    }
-    const dirPath = join(this.testDir, dirName);
-    await mkdir(dirPath, { recursive: true });
-    return dirPath;
-  }
-
-  /**
-   * Check if a file exists in the test directory
-   */
-  fileExists(fileName: string): boolean {
-    if (!this.testDir) {
-      throw new Error('Test directory not initialized. Call setup() first.');
-    }
-    const filePath = join(this.testDir, fileName);
-    return existsSync(filePath);
-  }
-
-  /**
-   * Get the full path to a file in the test directory
-   */
-  getPath(fileName: string): string {
-    if (!this.testDir) {
-      throw new Error('Test directory not initialized. Call setup() first.');
-    }
-    return join(this.testDir, fileName);
-  }
-
-  /**
-   * Cleanup test directory
-   */
-  async cleanup(): Promise<void> {
-    if (this.testDir && process.env['KEEP_OUTPUT'] !== 'true') {
-      try {
-        await rm(this.testDir, { recursive: true, force: true });
-      } catch (error) {
-        if (process.env['VERBOSE'] === 'true') {
-          console.warn('Cleanup warning:', (error as Error).message);
-        }
-      }
-    }
-  }
-
-  /**
-   * Sanitize test name to create valid directory name
-   */
-  private sanitizeTestName(name: string): string {
-    return name
-      .toLowerCase()
-      .replace(/[^a-z0-9]/g, '-')
-      .replace(/-+/g, '-')
-      .substring(0, 100); // Limit length
-  }
-}
-
-// ============================================================================
-// MCP Server Utilities
-// ============================================================================
-
-export interface MCPServerConfig {
-  command: string;
-  args: string[];
-}
-
-export interface MCPServerResult {
-  scriptPath: string;
-  config: MCPServerConfig;
-}
-
-/**
- * Built-in MCP server template: Math server with add and multiply tools
- */
-const MCP_MATH_SERVER_SCRIPT = `#!/usr/bin/env node
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-const readline = require('readline');
-const fs = require('fs');
-
-// Debug logging to stderr (only when MCP_DEBUG or VERBOSE is set)
-const debugEnabled = process.env['MCP_DEBUG'] === 'true' || process.env['VERBOSE'] === 'true';
-function debug(msg) {
-  if (debugEnabled) {
-    fs.writeSync(2, \`[MCP-DEBUG] \${msg}\\n\`);
-  }
-}
-
-debug('MCP server starting...');
-
-// Simple JSON-RPC implementation for MCP
-class SimpleJSONRPC {
-  constructor() {
-    this.handlers = new Map();
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: false
-    });
-    
-    this.rl.on('line', (line) => {
-      debug(\`Received line: \${line}\`);
-      try {
-        const message = JSON.parse(line);
-        debug(\`Parsed message: \${JSON.stringify(message)}\`);
-        this.handleMessage(message);
-      } catch (e) {
-        debug(\`Parse error: \${e.message}\`);
-      }
-    });
-  }
-  
-  send(message) {
-    const msgStr = JSON.stringify(message);
-    debug(\`Sending message: \${msgStr}\`);
-    process.stdout.write(msgStr + '\\n');
-  }
-  
-  async handleMessage(message) {
-    if (message.method && this.handlers.has(message.method)) {
-      try {
-        const result = await this.handlers.get(message.method)(message.params || {});
-        if (message.id !== undefined) {
-          this.send({
-            jsonrpc: '2.0',
-            id: message.id,
-            result
-          });
-        }
-      } catch (error) {
-        if (message.id !== undefined) {
-          this.send({
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error.message
-            }
-          });
-        }
-      }
-    } else if (message.id !== undefined) {
-      this.send({
-        jsonrpc: '2.0',
-        id: message.id,
-        error: {
-          code: -32601,
-          message: 'Method not found'
-        }
-      });
-    }
-  }
-  
-  on(method, handler) {
-    this.handlers.set(method, handler);
-  }
-}
-
-// Create MCP server
-const rpc = new SimpleJSONRPC();
-
-// Handle initialize
-rpc.on('initialize', async (params) => {
-  debug('Handling initialize request');
-  return {
-    protocolVersion: '2024-11-05',
-    capabilities: {
-      tools: {}
-    },
-    serverInfo: {
-      name: 'test-math-server',
-      version: '1.0.0'
-    }
-  };
-});
-
-// Handle tools/list
-rpc.on('tools/list', async () => {
-  debug('Handling tools/list request');
-  return {
-    tools: [
-      {
-        name: 'add',
-        description: 'Add two numbers together',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            a: { type: 'number', description: 'First number' },
-            b: { type: 'number', description: 'Second number' }
-          },
-          required: ['a', 'b']
-        }
-      },
-      {
-        name: 'multiply',
-        description: 'Multiply two numbers together',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            a: { type: 'number', description: 'First number' },
-            b: { type: 'number', description: 'Second number' }
-          },
-          required: ['a', 'b']
-        }
-      }
-    ]
-  };
-});
-
-// Handle tools/call
-rpc.on('tools/call', async (params) => {
-  debug(\`Handling tools/call request for tool: \${params.name}\`);
-  
-  if (params.name === 'add') {
-    const { a, b } = params.arguments;
-    return {
-      content: [{
-        type: 'text',
-        text: String(a + b)
-      }]
-    };
-  }
-  
-  if (params.name === 'multiply') {
-    const { a, b } = params.arguments;
-    return {
-      content: [{
-        type: 'text',
-        text: String(a * b)
-      }]
-    };
-  }
-  
-  throw new Error('Unknown tool: ' + params.name);
-});
-
-// Send initialization notification
-rpc.send({
-  jsonrpc: '2.0',
-  method: 'initialized'
-});
-`;
-
-/**
- * Create an MCP server script in the test directory
- * @param helper - SDKTestHelper instance
- * @param type - Type of MCP server ('math' or provide custom script)
- * @param serverName - Name of the MCP server (default: 'test-math-server')
- * @param customScript - Custom MCP server script (if type is not 'math')
- * @returns Object with scriptPath and config
- */
-export async function createMCPServer(
-  helper: SDKTestHelper,
-  type: 'math' | 'custom' = 'math',
-  serverName: string = 'test-math-server',
-  customScript?: string,
-): Promise<MCPServerResult> {
-  if (!helper.testDir) {
-    throw new Error('Test directory not initialized. Call setup() first.');
-  }
-
-  const script = type === 'math' ? MCP_MATH_SERVER_SCRIPT : customScript;
-  if (!script) {
-    throw new Error('Custom script required when type is "custom"');
-  }
-
-  const scriptPath = join(helper.testDir, `${serverName}.cjs`);
-  await writeFile(scriptPath, script, 'utf-8');
-
-  // Make script executable on Unix-like systems
-  if (process.platform !== 'win32') {
-    await chmod(scriptPath, 0o755);
-  }
-
-  return {
-    scriptPath,
-    config: {
-      command: 'node',
-      args: [scriptPath],
-    },
-  };
-}
-
-// ============================================================================
-// Message & Content Utilities
-// ============================================================================
-
-/**
- * Extract text from ContentBlock array
- */
-export function extractText(content: ContentBlock[]): string {
-  return content
-    .filter((block): block is TextBlock => block.type === 'text')
-    .map((block) => block.text)
-    .join('');
-}
-
-/**
- * Collect messages by type
- */
-export function collectMessagesByType<T extends SDKMessage>(
-  messages: SDKMessage[],
-  predicate: (msg: SDKMessage) => msg is T,
-): T[] {
-  return messages.filter(predicate);
-}
-
-/**
- * Find tool use blocks in a message
- */
-export function findToolUseBlocks(
-  message: SDKAssistantMessage,
-  toolName?: string,
-): ToolUseBlock[] {
-  const toolUseBlocks = message.message.content.filter(
-    (block): block is ToolUseBlock => block.type === 'tool_use',
-  );
-
-  if (toolName) {
-    return toolUseBlocks.filter((block) => block.name === toolName);
-  }
-
-  return toolUseBlocks;
-}
-
-/**
- * Extract all assistant text from messages
- */
-export function getAssistantText(messages: SDKMessage[]): string {
-  return messages
-    .filter(isSDKAssistantMessage)
-    .map((msg) => extractText(msg.message.content))
-    .join('');
-}
-
-/**
- * Find system message with optional subtype filter
- */
-export function findSystemMessage(
-  messages: SDKMessage[],
-  subtype?: string,
-): SDKSystemMessage | null {
-  const systemMessages = messages.filter(isSDKSystemMessage);
-
-  if (subtype) {
-    return systemMessages.find((msg) => msg.subtype === subtype) || null;
-  }
-
-  return systemMessages[0] || null;
-}
-
-/**
- * Find all tool calls in messages
- */
-export function findToolCalls(
-  messages: SDKMessage[],
-  toolName?: string,
-): Array<{ message: SDKAssistantMessage; toolUse: ToolUseBlock }> {
-  const results: Array<{
-    message: SDKAssistantMessage;
-    toolUse: ToolUseBlock;
-  }> = [];
-
-  for (const message of messages) {
-    if (isSDKAssistantMessage(message)) {
-      const toolUseBlocks = findToolUseBlocks(message, toolName);
-      for (const toolUse of toolUseBlocks) {
-        results.push({ message, toolUse });
-      }
-    }
-  }
-
-  return results;
-}
-
-/**
- * Find tool result for a specific tool use ID
- */
-export function findToolResult(
-  messages: SDKMessage[],
-  toolUseId: string,
-): { content: string; isError: boolean } | null {
-  for (const message of messages) {
-    if (message.type === 'user' && 'message' in message) {
-      const userMsg = message as SDKUserMessage;
-      const content = userMsg.message.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (
-            block.type === 'tool_result' &&
-            (block as { tool_use_id?: string }).tool_use_id === toolUseId
-          ) {
-            const resultBlock = block as {
-              content?: string | ContentBlock[];
-              is_error?: boolean;
-            };
-            let resultContent = '';
-            if (typeof resultBlock.content === 'string') {
-              resultContent = resultBlock.content;
-            } else if (Array.isArray(resultBlock.content)) {
-              resultContent = resultBlock.content
-                .filter((b): b is TextBlock => b.type === 'text')
-                .map((b) => b.text)
-                .join('');
-            }
-            return {
-              content: resultContent,
-              isError: resultBlock.is_error ?? false,
-            };
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Find all tool results for a specific tool name
- */
-export function findToolResults(
-  messages: SDKMessage[],
-  toolName: string,
-): Array<{ toolUseId: string; content: string; isError: boolean }> {
-  const results: Array<{
-    toolUseId: string;
-    content: string;
-    isError: boolean;
-  }> = [];
-
-  // First find all tool calls for this tool
-  const toolCalls = findToolCalls(messages, toolName);
-
-  // Then find the result for each tool call
-  for (const { toolUse } of toolCalls) {
-    const result = findToolResult(messages, toolUse.id);
-    if (result) {
-      results.push({
-        toolUseId: toolUse.id,
-        content: result.content,
-        isError: result.isError,
-      });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Find all tool result blocks from messages (without requiring tool name)
- */
-export function findAllToolResultBlocks(
-  messages: SDKMessage[],
-): Array<{ toolUseId: string; content: string; isError: boolean }> {
-  const results: Array<{
-    toolUseId: string;
-    content: string;
-    isError: boolean;
-  }> = [];
-
-  for (const message of messages) {
-    if (message.type === 'user' && 'message' in message) {
-      const userMsg = message as SDKUserMessage;
-      const content = userMsg.message.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block.type === 'tool_result' && 'tool_use_id' in block) {
-            const resultBlock = block as {
-              tool_use_id: string;
-              content?: string | ContentBlock[];
-              is_error?: boolean;
-            };
-            let resultContent = '';
-            if (typeof resultBlock.content === 'string') {
-              resultContent = resultBlock.content;
-            } else if (Array.isArray(resultBlock.content)) {
-              resultContent = (resultBlock.content as ContentBlock[])
-                .filter((b): b is TextBlock => b.type === 'text')
-                .map((b) => b.text)
-                .join('');
-            }
-            results.push({
-              toolUseId: resultBlock.tool_use_id,
-              content: resultContent,
-              isError: resultBlock.is_error ?? false,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  return results;
-}
-
-/**
- * Check if any tool results exist in messages
- */
-export function hasAnyToolResults(messages: SDKMessage[]): boolean {
-  return findAllToolResultBlocks(messages).length > 0;
-}
-
-/**
- * Check if any successful (non-error) tool results exist
- */
-export function hasSuccessfulToolResults(messages: SDKMessage[]): boolean {
-  return findAllToolResultBlocks(messages).some((r) => !r.isError);
-}
-
-/**
- * Check if any error tool results exist
- */
-export function hasErrorToolResults(messages: SDKMessage[]): boolean {
-  return findAllToolResultBlocks(messages).some((r) => r.isError);
-}
-
-// ============================================================================
-// Streaming Input Utilities
-// ============================================================================
-
-/**
- * Create a simple streaming input from an array of message contents
- */
-export async function* createStreamingInput(
-  messageContents: string[],
-  sessionId?: string,
-): AsyncIterable<SDKUserMessage> {
-  const sid = sessionId || crypto.randomUUID();
-
-  for (const content of messageContents) {
-    yield {
-      type: 'user',
-      session_id: sid,
-      message: {
-        role: 'user',
-        content: content,
-      },
-      parent_tool_use_id: null,
-    } as SDKUserMessage;
-
-    // Small delay between messages
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-}
-
-/**
- * Create a controlled streaming input with pause/resume capability
- */
-export function createControlledStreamingInput(
-  messageContents: string[],
-  sessionId?: string,
-): {
-  generator: AsyncIterable<SDKUserMessage>;
-  resume: () => void;
-  resumeAll: () => void;
-} {
-  const sid = sessionId || crypto.randomUUID();
-  const resumeResolvers: Array<() => void> = [];
-  const resumePromises: Array<Promise<void>> = [];
-
-  // Create a resume promise for each message after the first
-  for (let i = 1; i < messageContents.length; i++) {
-    const promise = new Promise<void>((resolve) => {
-      resumeResolvers.push(resolve);
-    });
-    resumePromises.push(promise);
-  }
-
-  const generator = (async function* () {
-    // Yield first message immediately
-    yield {
-      type: 'user',
-      session_id: sid,
-      message: {
-        role: 'user',
-        content: messageContents[0],
-      },
-      parent_tool_use_id: null,
-    } as SDKUserMessage;
-
-    // For subsequent messages, wait for resume
-    for (let i = 1; i < messageContents.length; i++) {
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      await resumePromises[i - 1];
-      await new Promise((resolve) => setTimeout(resolve, 200));
-
-      yield {
-        type: 'user',
-        session_id: sid,
-        message: {
-          role: 'user',
-          content: messageContents[i],
-        },
-        parent_tool_use_id: null,
-      } as SDKUserMessage;
-    }
-  })();
-
-  let currentResumeIndex = 0;
-
-  return {
-    generator,
-    resume: () => {
-      if (currentResumeIndex < resumeResolvers.length) {
-        resumeResolvers[currentResumeIndex]();
-        currentResumeIndex++;
-      }
-    },
-    resumeAll: () => {
-      resumeResolvers.forEach((resolve) => resolve());
-      currentResumeIndex = resumeResolvers.length;
-    },
-  };
-}
-
-// ============================================================================
-// Assertion Utilities
-// ============================================================================
-
-/**
- * Assert that messages follow expected type sequence
- */
-export function assertMessageSequence(
-  messages: SDKMessage[],
-  expectedTypes: string[],
-): void {
-  const actualTypes = messages.map((msg) => msg.type);
-
-  if (actualTypes.length < expectedTypes.length) {
-    throw new Error(
-      `Expected at least ${expectedTypes.length} messages, got ${actualTypes.length}`,
-    );
-  }
-
-  for (let i = 0; i < expectedTypes.length; i++) {
-    if (actualTypes[i] !== expectedTypes[i]) {
-      throw new Error(
-        `Expected message ${i} to be type '${expectedTypes[i]}', got '${actualTypes[i]}'`,
-      );
-    }
-  }
-}
-
-/**
- * Assert that a specific tool was called
- */
-export function assertToolCalled(
-  messages: SDKMessage[],
-  toolName: string,
-): void {
-  const toolCalls = findToolCalls(messages, toolName);
-
-  if (toolCalls.length === 0) {
-    const allToolCalls = findToolCalls(messages);
-    const allToolNames = allToolCalls.map((tc) => tc.toolUse.name);
-    throw new Error(
-      `Expected tool '${toolName}' to be called. Found tools: ${allToolNames.length > 0 ? allToolNames.join(', ') : 'none'}`,
-    );
-  }
-}
-
-/**
- * Assert that the conversation completed successfully
- */
-export function assertSuccessfulCompletion(messages: SDKMessage[]): void {
-  const lastMessage = messages[messages.length - 1];
-
-  if (!isSDKResultMessage(lastMessage)) {
-    throw new Error(
-      `Expected last message to be a result message, got '${lastMessage.type}'`,
-    );
-  }
-
-  if (lastMessage.subtype !== 'success') {
-    throw new Error(
-      `Expected successful completion, got result subtype '${lastMessage.subtype}'`,
-    );
-  }
-}
-
-/**
- * Wait for a condition to be true with timeout
- */
-export async function waitFor(
-  predicate: () => boolean | Promise<boolean>,
-  options: {
-    timeout?: number;
-    interval?: number;
-    errorMessage?: string;
-  } = {},
-): Promise<void> {
-  const {
-    timeout = 5000,
-    interval = 100,
-    errorMessage = 'Condition not met within timeout',
-  } = options;
-
-  const startTime = Date.now();
-
-  while (Date.now() - startTime < timeout) {
-    const result = await predicate();
-    if (result) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, interval));
-  }
-
-  throw new Error(errorMessage);
-}
-
-// ============================================================================
-// Debug and Validation Utilities
-// ============================================================================
-
-/**
- * Validate model output and warn about unexpected content
- * Inspired by integration-tests test-helper
- */
-export function validateModelOutput(
-  result: string,
-  expectedContent: string | (string | RegExp)[] | null = null,
-  testName = '',
-): boolean {
-  // First, check if there's any output at all
-  if (!result || result.trim().length === 0) {
-    throw new Error('Expected model to return some output');
-  }
-
-  // If expectedContent is provided, check for it and warn if missing
-  if (expectedContent) {
-    const contents = Array.isArray(expectedContent)
-      ? expectedContent
-      : [expectedContent];
-    const missingContent = contents.filter((content) => {
-      if (typeof content === 'string') {
-        return !result.toLowerCase().includes(content.toLowerCase());
-      } else if (content instanceof RegExp) {
-        return !content.test(result);
-      }
-      return false;
-    });
-
-    if (missingContent.length > 0) {
-      console.warn(
-        `Warning: Model did not include expected content in response: ${missingContent.join(', ')}.`,
-        'This is not ideal but not a test failure.',
-      );
-      console.warn(
-        'The tool was called successfully, which is the main requirement.',
-      );
-      return false;
-    } else if (process.env['VERBOSE'] === 'true') {
-      console.log(`${testName}: Model output validated successfully.`);
-    }
-    return true;
-  }
-
-  return true;
-}
-
-/**
- * Print debug information when tests fail
- */
-export function printDebugInfo(
-  messages: SDKMessage[],
-  context: Record<string, unknown> = {},
-): void {
-  console.error('Test failed - Debug info:');
-  console.error('Message count:', messages.length);
-
-  // Print message types
-  const messageTypes = messages.map((m) => m.type);
-  console.error('Message types:', messageTypes.join(', '));
-
-  // Print assistant text
-  const assistantText = getAssistantText(messages);
-  console.error(
-    'Assistant text (first 500 chars):',
-    assistantText.substring(0, 500),
-  );
-  if (assistantText.length > 500) {
-    console.error(
-      'Assistant text (last 500 chars):',
-      assistantText.substring(assistantText.length - 500),
-    );
-  }
-
-  // Print tool calls
-  const toolCalls = findToolCalls(messages);
-  console.error(
-    'Tool calls found:',
-    toolCalls.map((tc) => tc.toolUse.name),
-  );
-
-  // Print any additional context provided
-  Object.entries(context).forEach(([key, value]) => {
-    console.error(`${key}:`, value);
-  });
-}
-
-/**
- * Create detailed error message for tool call expectations
- */
-export function createToolCallErrorMessage(
-  expectedTools: string | string[],
-  foundTools: string[],
-  messages: SDKMessage[],
-): string {
-  const expectedStr = Array.isArray(expectedTools)
-    ? expectedTools.join(' or ')
-    : expectedTools;
-
-  const assistantText = getAssistantText(messages);
-  const preview = assistantText
-    ? assistantText.substring(0, 200) + '...'
-    : 'no output';
-
-  return (
-    `Expected to find ${expectedStr} tool call(s). ` +
-    `Found: ${foundTools.length > 0 ? foundTools.join(', ') : 'none'}. ` +
-    `Output preview: ${preview}`
-  );
-}
-
-// ============================================================================
-// Shared Test Options Helper
-// ============================================================================
-
-/**
- * Create shared test options with CLI path
- */
-export function createSharedTestOptions(
-  overrides: Record<string, unknown> = {},
-) {
-  const TEST_CLI_PATH = process.env['TEST_CLI_PATH'];
-  if (!TEST_CLI_PATH) {
-    throw new Error('TEST_CLI_PATH environment variable not set');
-  }
-
-  return {
-    pathToQwenExecutable: TEST_CLI_PATH,
-    ...overrides,
-  };
-}
--- a/integration-tests/sdk-typescript/tool-control.test.ts
+++ b/integration-tests/sdk-typescript/tool-control.test.ts
@@ -1,744 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * E2E tests for tool control parameters:
- * - coreTools: Limit available tools to a specific set
- * - excludeTools: Block specific tools from execution
- * - allowedTools: Auto-approve specific tools without confirmation
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { query, isSDKAssistantMessage, type SDKMessage } from '@qwen-code/sdk';
-import {
-  SDKTestHelper,
-  extractText,
-  findToolCalls,
-  findToolResults,
-  assertSuccessfulCompletion,
-  createSharedTestOptions,
-} from './test-helper.js';
-
-const SHARED_TEST_OPTIONS = createSharedTestOptions();
-const TEST_TIMEOUT = 60000;
-
-describe('Tool Control Parameters (E2E)', () => {
-  let helper: SDKTestHelper;
-  let testDir: string;
-
-  beforeEach(async () => {
-    helper = new SDKTestHelper();
-    testDir = await helper.setup('tool-control', {
-      createQwenConfig: false,
-    });
-  });
-
-  afterEach(async () => {
-    await helper.cleanup();
-  });
-
-  describe('coreTools parameter', () => {
-    it(
-      'should only allow specified tools when coreTools is set',
-      async () => {
-        // Create a test file
-        await helper.createFile('test.txt', 'original content');
-
-        const q = query({
-          prompt:
-            'Read the file test.txt and then write "modified" to test.txt. Finally, list the directory.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Only allow read_file and write_file, exclude list_directory
-            coreTools: ['read_file', 'write_file'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          // Should have read_file and write_file calls
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-
-          // Should NOT have list_directory since it's not in coreTools
-          expect(toolNames).not.toContain('list_directory');
-
-          // Verify file was modified
-          const content = await helper.readFile('test.txt');
-          expect(content).toContain('modified');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should work with minimal tool set',
-      async () => {
-        const q = query({
-          prompt: 'What is 2 + 2? Just answer with the number.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            // Only allow thinking, no file operations
-            coreTools: [],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-        let assistantText = '';
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-
-            if (isSDKAssistantMessage(message)) {
-              assistantText += extractText(message.message.content);
-            }
-          }
-
-          // Should answer without any tool calls
-          expect(assistantText).toMatch(/4/);
-
-          // Should have no tool calls
-          const toolCalls = findToolCalls(messages);
-          expect(toolCalls.length).toBe(0);
-
-          assertSuccessfulCompletion(messages);
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-  });
-
-  describe('excludeTools parameter', () => {
-    it(
-      'should block excluded tools from execution',
-      async () => {
-        await helper.createFile('test.txt', 'test content');
-
-        const q = query({
-          prompt:
-            'Read test.txt and then write empty content to it to clear it.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            coreTools: ['read_file', 'write_file'],
-            // Block all write_file tool
-            excludeTools: ['write_file'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should be able to read the file
-          expect(toolNames).toContain('read_file');
-
-          // The excluded tools should have been called but returned permission declined
-          // Check if write_file was attempted and got permission denied
-          const writeFileResults = findToolResults(messages, 'write_file');
-          if (writeFileResults.length > 0) {
-            // Tool was called but should have permission declined message
-            for (const result of writeFileResults) {
-              expect(result.content).toMatch(/permission.*declined/i);
-            }
-          }
-
-          // File content should remain unchanged (because write was denied)
-          const content = await helper.readFile('test.txt');
-          expect(content).toBe('test content');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should block multiple excluded tools',
-      async () => {
-        await helper.createFile('test.txt', 'test content');
-
-        const q = query({
-          prompt: 'Read test.txt, list the directory, and run "echo hello".',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Block multiple tools
-            excludeTools: ['list_directory', 'run_shell_command'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should be able to read
-          expect(toolNames).toContain('read_file');
-
-          // Excluded tools should have been attempted but returned permission declined
-          const listDirResults = findToolResults(messages, 'list_directory');
-          if (listDirResults.length > 0) {
-            for (const result of listDirResults) {
-              expect(result.content).toMatch(/permission.*declined/i);
-            }
-          }
-
-          const shellResults = findToolResults(messages, 'run_shell_command');
-          if (shellResults.length > 0) {
-            for (const result of shellResults) {
-              expect(result.content).toMatch(/permission.*declined/i);
-            }
-          }
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should block all shell commands when run_shell_command is excluded',
-      async () => {
-        const q = query({
-          prompt: 'Run "echo hello" and "ls -la" commands.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Block all shell commands - excludeTools blocks entire tools
-            excludeTools: ['run_shell_command'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          // All shell commands should have permission declined
-          const shellResults = findToolResults(messages, 'run_shell_command');
-          for (const result of shellResults) {
-            expect(result.content).toMatch(/permission.*declined/i);
-          }
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'excludeTools should take priority over allowedTools',
-      async () => {
-        await helper.createFile('test.txt', 'test content');
-
-        const q = query({
-          prompt:
-            'Clear the content of test.txt by writing empty string to it.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            // Conflicting settings: exclude takes priority
-            excludeTools: ['write_file'],
-            allowedTools: ['write_file'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          // write_file should have been attempted but returned permission declined
-          const writeFileResults = findToolResults(messages, 'write_file');
-          if (writeFileResults.length > 0) {
-            // Tool was called but should have permission declined message (exclude takes priority)
-            for (const result of writeFileResults) {
-              expect(result.content).toMatch(/permission.*declined/i);
-            }
-          }
-
-          // File content should remain unchanged (because write was denied)
-          const content = await helper.readFile('test.txt');
-          expect(content).toBe('test content');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-  });
-
-  describe('allowedTools parameter', () => {
-    it(
-      'should auto-approve allowed tools without canUseTool callback',
-      async () => {
-        await helper.createFile('test.txt', 'original');
-
-        let canUseToolCalled = false;
-
-        const q = query({
-          prompt: 'Read test.txt and write "modified" to it.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            coreTools: ['read_file', 'write_file'],
-            // Allow write_file without confirmation
-            allowedTools: ['read_file', 'write_file'],
-            canUseTool: async (_toolName) => {
-              canUseToolCalled = true;
-              return { behavior: 'deny', message: 'Should not be called' };
-            },
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should have executed the tools
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-
-          // canUseTool should NOT have been called (tools are in allowedTools)
-          expect(canUseToolCalled).toBe(false);
-
-          // Verify file was modified
-          const content = await helper.readFile('test.txt');
-          expect(content).toContain('modified');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should allow specific shell commands with pattern matching',
-      async () => {
-        const q = query({
-          prompt: 'Run "echo hello" and "ls -la" commands.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            // Allow specific shell commands
-            allowedTools: ['ShellTool(echo )', 'ShellTool(ls )'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const shellCalls = toolCalls.filter(
-            (tc) => tc.toolUse.name === 'run_shell_command',
-          );
-
-          // Should have executed shell commands
-          expect(shellCalls.length).toBeGreaterThan(0);
-
-          // All shell commands should be echo or ls
-          for (const call of shellCalls) {
-            const input = call.toolUse.input as { command?: string };
-            if (input.command) {
-              expect(input.command).toMatch(/^(echo |ls )/);
-            }
-          }
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should fall back to canUseTool for non-allowed tools',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const canUseToolCalls: string[] = [];
-
-        const q = query({
-          prompt: 'Read test.txt and append an empty line to it.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            // Only allow read_file, list_directory should trigger canUseTool
-            coreTools: ['read_file', 'write_file'],
-            allowedTools: ['read_file'],
-            canUseTool: async (toolName) => {
-              canUseToolCalls.push(toolName);
-              return {
-                behavior: 'allow',
-                updatedInput: {},
-              };
-            },
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Both tools should have been executed
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-
-          // canUseTool should have been called for write_file (not in allowedTools)
-          // but NOT for read_file (in allowedTools)
-          expect(canUseToolCalls).toContain('write_file');
-          expect(canUseToolCalls).not.toContain('read_file');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should work with permissionMode: auto-edit',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const canUseToolCalls: string[] = [];
-
-        const q = query({
-          prompt: 'Read test.txt, write "new" to it, and list the directory.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'auto-edit',
-            // Allow list_directory in addition to auto-approved edit tools
-            allowedTools: ['list_directory'],
-            canUseTool: async (toolName) => {
-              canUseToolCalls.push(toolName);
-              return {
-                behavior: 'deny',
-                message: 'Should not be called',
-              };
-            },
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // All tools should have been executed
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-          expect(toolNames).toContain('list_directory');
-
-          // canUseTool should NOT have been called
-          // (edit tools auto-approved, list_directory in allowedTools)
-          expect(canUseToolCalls.length).toBe(0);
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-  });
-
-  describe('Combined tool control scenarios', () => {
-    it(
-      'should work with coreTools + allowedTools',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const q = query({
-          prompt: 'Read test.txt and write "modified" to it.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            // Limit to specific tools
-            coreTools: ['read_file', 'write_file', 'list_directory'],
-            // Auto-approve write operations
-            allowedTools: ['write_file'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should use allowed tools from coreTools
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-
-          // Should NOT use tools outside coreTools
-          expect(toolNames).not.toContain('run_shell_command');
-
-          // Verify file was modified
-          const content = await helper.readFile('test.txt');
-          expect(content).toContain('modified');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should work with coreTools + excludeTools',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const q = query({
-          prompt:
-            'Read test.txt, write "new content" to it, and list directory.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Allow file operations
-            coreTools: ['read_file', 'write_file', 'edit', 'list_directory'],
-            // But exclude edit
-            excludeTools: ['edit'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should use non-excluded tools from coreTools
-          expect(toolNames).toContain('read_file');
-
-          // Should NOT use excluded tool
-          expect(toolNames).not.toContain('edit');
-
-          // File should still exist
-          expect(helper.fileExists('test.txt')).toBe(true);
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should work with all three parameters together',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const canUseToolCalls: string[] = [];
-
-        const q = query({
-          prompt:
-            'Read test.txt, write "modified" to it, and list the directory.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'default',
-            // Limit available tools
-            coreTools: ['read_file', 'write_file', 'list_directory', 'edit'],
-            // Block edit
-            excludeTools: ['edit'],
-            // Auto-approve write
-            allowedTools: ['write_file'],
-            canUseTool: async (toolName) => {
-              canUseToolCalls.push(toolName);
-              return {
-                behavior: 'allow',
-                updatedInput: {},
-              };
-            },
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should use allowed tools
-          expect(toolNames).toContain('read_file');
-          expect(toolNames).toContain('write_file');
-
-          // Should NOT use excluded tool
-          expect(toolNames).not.toContain('edit');
-
-          // canUseTool should be called for tools not in allowedTools
-          // but should NOT be called for write_file (in allowedTools)
-          expect(canUseToolCalls).not.toContain('write_file');
-
-          // Verify file was modified
-          const content = await helper.readFile('test.txt');
-          expect(content).toContain('modified');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-  });
-
-  describe('Edge cases and error handling', () => {
-    it(
-      'should handle non-existent tool names in excludeTools',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const q = query({
-          prompt: 'Read test.txt.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Non-existent tool names should be ignored
-            excludeTools: ['non_existent_tool', 'another_fake_tool'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should work normally
-          expect(toolNames).toContain('read_file');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-
-    it(
-      'should handle non-existent tool names in allowedTools',
-      async () => {
-        await helper.createFile('test.txt', 'test');
-
-        const q = query({
-          prompt: 'Read test.txt.',
-          options: {
-            ...SHARED_TEST_OPTIONS,
-            cwd: testDir,
-            permissionMode: 'yolo',
-            // Non-existent tool names should be ignored
-            allowedTools: ['non_existent_tool', 'read_file'],
-            debug: false,
-          },
-        });
-
-        const messages: SDKMessage[] = [];
-
-        try {
-          for await (const message of q) {
-            messages.push(message);
-          }
-
-          const toolCalls = findToolCalls(messages);
-          const toolNames = toolCalls.map((tc) => tc.toolUse.name);
-
-          // Should work normally
-          expect(toolNames).toContain('read_file');
-        } finally {
-          await q.close();
-        }
-      },
-      TEST_TIMEOUT,
-    );
-  });
-});
--- a/integration-tests/simple-mcp-server.test.ts
+++ b/integration-tests/simple-mcp-server.test.ts
@@ -213,7 +213,7 @@ describe('simple-mcp-server', () => {
  it('should add two numbers', async () => {
    // Test directory is already set up in before hook
    // Just run the command - MCP server config is in settings.json
-    const output = await rig.run('add 5 and 10, use tool if you can.');
+    const output = await rig.run('add 5 and 10');

    const foundToolCall = await rig.waitForToolCall('add');

--- a/integration-tests/test-helper.ts
+++ b/integration-tests/test-helper.ts
@@ -340,8 +340,7 @@ export class TestRig {
          // as it would corrupt the JSON
          const isJsonOutput =
            commandArgs.includes('--output-format') &&
-            (commandArgs.includes('json') ||
-              commandArgs.includes('stream-json'));
+            commandArgs.includes('json');

          // If we have stderr output and it's not a JSON test, include that also
          if (stderr && !isJsonOutput) {
@@ -350,23 +349,7 @@ export class TestRig {

          resolve(result);
        } else {
-          // Check if this is a JSON output test - for JSON errors, the error is in stdout
-          const isJsonOutputOnError =
-            commandArgs.includes('--output-format') &&
-            (commandArgs.includes('json') ||
-              commandArgs.includes('stream-json'));
-
-          // For JSON output tests, include stdout in the error message
-          // as the error JSON is written to stdout
-          if (isJsonOutputOnError && stdout) {
-            reject(
-              new Error(
-                `Process exited with code ${code}:\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
-              ),
-            );
-          } else {
-            reject(new Error(`Process exited with code ${code}:\n${stderr}`));
-          }
+          reject(new Error(`Process exited with code ${code}:\n${stderr}`));
        }
      });
    });
--- a/integration-tests/tsconfig.json
+++ b/integration-tests/tsconfig.json
@@ -2,11 +2,7 @@
  "extends": "../tsconfig.json",
  "compilerOptions": {
    "noEmit": true,
-    "allowJs": true,
-    "baseUrl": ".",
-    "paths": {
-      "@qwen-code/sdk": ["../packages/sdk-typescript/dist/index.d.ts"]
-    }
+    "allowJs": true
  },
  "include": ["**/*.ts"],
  "references": [{ "path": "../packages/core" }]
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -1,15 +1,12 @@
 /**
 * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

 import { defineConfig } from 'vitest/config';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';

-const __dirname = dirname(fileURLToPath(import.meta.url));
-const timeoutMinutes = Number(process.env['TB_TIMEOUT_MINUTES'] || '5');
+const timeoutMinutes = Number(process.env.TB_TIMEOUT_MINUTES || '5');
 const testTimeoutMs = timeoutMinutes * 60 * 1000;

 export default defineConfig({
@@ -28,13 +25,4 @@ export default defineConfig({
      },
    },
  },
-  resolve: {
-    alias: {
-      // Use built SDK bundle for e2e tests
-      '@qwen-code/sdk': resolve(
-        __dirname,
-        '../packages/sdk-typescript/dist/index.mjs',
-      ),
-    },
-  },
 });
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@qwen-code/qwen-code",
-  "version": "0.4.0",
+  "version": "0.2.2",
  "engines": {
    "node": ">=20.0.0"
  },
@@ -13,7 +13,7 @@
    "url": "git+https://github.com/QwenLM/qwen-code.git"
  },
  "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.2.2"
  },
  "scripts": {
    "start": "cross-env node scripts/start.js",
@@ -37,10 +37,6 @@
    "test:integration:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests",
    "test:integration:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests",
    "test:integration:sandbox:podman": "cross-env GEMINI_SANDBOX=podman vitest run --root ./integration-tests",
-    "test:integration:sdk:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests sdk-typescript",
-    "test:integration:sdk:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests sdk-typescript",
-    "test:integration:cli:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests --exclude '**/sdk-typescript/**'",
-    "test:integration:cli:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && GEMINI_SANDBOX=docker vitest run --root ./integration-tests --exclude '**/sdk-typescript/**'",
    "test:terminal-bench": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests",
    "test:terminal-bench:oracle": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests -t 'oracle'",
    "test:terminal-bench:qwen": "cross-env VERBOSE=true KEEP_OUTPUT=true vitest run --config ./vitest.terminal-bench.config.ts --root ./integration-tests -t 'qwen'",
@@ -50,7 +46,6 @@
    "lint:all": "node scripts/lint.js",
    "format": "prettier --experimental-cli --write .",
    "typecheck": "npm run typecheck --workspaces --if-present",
-    "check-i18n": "npm run check-i18n --workspace=packages/cli",
    "preflight": "npm run clean && npm ci && npm run format && npm run lint:ci && npm run build && npm run typecheck && npm run test:ci",
    "prepare": "husky && npm run bundle",
    "prepare:package": "node scripts/prepare-package.js",
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@qwen-code/qwen-code",
-  "version": "0.4.0",
+  "version": "0.2.2",
  "description": "Qwen Code",
  "repository": {
    "type": "git",
@@ -8,16 +8,9 @@
  },
  "type": "module",
  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
  "bin": {
    "qwen": "dist/index.js"
  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
  "scripts": {
    "build": "node ../../scripts/build_package.js",
    "start": "node dist/index.js",
@@ -26,14 +19,13 @@
    "format": "prettier --write .",
    "test": "vitest run",
    "test:ci": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "check-i18n": "tsx ../../scripts/check-i18n.ts"
+    "typecheck": "tsc --noEmit"
  },
  "files": [
    "dist"
  ],
  "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.4.0"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.2.2"
  },
  "dependencies": {
    "@google/genai": "1.16.0",
--- a/packages/cli/src/acp-integration/acpAgent.ts
+++ b/packages/cli/src/acp-integration/acpAgent.ts
@@ -1,329 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { ReadableStream, WritableStream } from 'node:stream/web';
-
-import type { Config, ConversationRecord } from '@qwen-code/qwen-code-core';
-import {
-  APPROVAL_MODE_INFO,
-  APPROVAL_MODES,
-  AuthType,
-  clearCachedCredentialFile,
-  MCPServerConfig,
-  SessionService,
-  buildApiHistoryFromConversation,
-} from '@qwen-code/qwen-code-core';
-import type { ApprovalModeValue } from './schema.js';
-import * as acp from './acp.js';
-import { AcpFileSystemService } from './service/filesystem.js';
-import { Readable, Writable } from 'node:stream';
-import type { LoadedSettings } from '../config/settings.js';
-import { SettingScope } from '../config/settings.js';
-import { z } from 'zod';
-import { ExtensionStorage, type Extension } from '../config/extension.js';
-import type { CliArgs } from '../config/config.js';
-import { loadCliConfig } from '../config/config.js';
-import { ExtensionEnablementManager } from '../config/extensions/extensionEnablement.js';
-
-// Import the modular Session class
-import { Session } from './session/Session.js';
-
-export async function runAcpAgent(
-  config: Config,
-  settings: LoadedSettings,
-  extensions: Extension[],
-  argv: CliArgs,
-) {
-  const stdout = Writable.toWeb(process.stdout) as WritableStream;
-  const stdin = Readable.toWeb(process.stdin) as ReadableStream<Uint8Array>;
-
-  // Stdout is used to send messages to the client, so console.log/console.info
-  // messages to stderr so that they don't interfere with ACP.
-  console.log = console.error;
-  console.info = console.error;
-  console.debug = console.error;
-
-  new acp.AgentSideConnection(
-    (client: acp.Client) =>
-      new GeminiAgent(config, settings, extensions, argv, client),
-    stdout,
-    stdin,
-  );
-}
-
-class GeminiAgent {
-  private sessions: Map<string, Session> = new Map();
-  private clientCapabilities: acp.ClientCapabilities | undefined;
-
-  constructor(
-    private config: Config,
-    private settings: LoadedSettings,
-    private extensions: Extension[],
-    private argv: CliArgs,
-    private client: acp.Client,
-  ) {}
-
-  async initialize(
-    args: acp.InitializeRequest,
-  ): Promise<acp.InitializeResponse> {
-    this.clientCapabilities = args.clientCapabilities;
-    const authMethods = [
-      {
-        id: AuthType.USE_OPENAI,
-        name: 'Use OpenAI API key',
-        description:
-          'Requires setting the `OPENAI_API_KEY` environment variable',
-      },
-      {
-        id: AuthType.QWEN_OAUTH,
-        name: 'Qwen OAuth',
-        description:
-          'OAuth authentication for Qwen models with 2000 daily requests',
-      },
-    ];
-
-    // Get current approval mode from config
-    const currentApprovalMode = this.config.getApprovalMode();
-
-    // Build available modes from shared APPROVAL_MODE_INFO
-    const availableModes = APPROVAL_MODES.map((mode) => ({
-      id: mode as ApprovalModeValue,
-      name: APPROVAL_MODE_INFO[mode].name,
-      description: APPROVAL_MODE_INFO[mode].description,
-    }));
-
-    const version = process.env['CLI_VERSION'] || process.version;
-
-    return {
-      protocolVersion: acp.PROTOCOL_VERSION,
-      agentInfo: {
-        name: 'qwen-code',
-        title: 'Qwen Code',
-        version,
-      },
-      authMethods,
-      modes: {
-        currentModeId: currentApprovalMode as ApprovalModeValue,
-        availableModes,
-      },
-      agentCapabilities: {
-        loadSession: true,
-        promptCapabilities: {
-          image: true,
-          audio: true,
-          embeddedContext: true,
-        },
-      },
-    };
-  }
-
-  async authenticate({ methodId }: acp.AuthenticateRequest): Promise<void> {
-    const method = z.nativeEnum(AuthType).parse(methodId);
-
-    await clearCachedCredentialFile();
-    await this.config.refreshAuth(method);
-    this.settings.setValue(
-      SettingScope.User,
-      'security.auth.selectedType',
-      method,
-    );
-  }
-
-  async newSession({
-    cwd,
-    mcpServers,
-  }: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {
-    const config = await this.newSessionConfig(cwd, mcpServers);
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
-
-    const session = await this.createAndStoreSession(config);
-
-    return {
-      sessionId: session.getId(),
-    };
-  }
-
-  async newSessionConfig(
-    cwd: string,
-    mcpServers: acp.McpServer[],
-    sessionId?: string,
-  ): Promise<Config> {
-    const mergedMcpServers = { ...this.settings.merged.mcpServers };
-
-    for (const { command, args, env: rawEnv, name } of mcpServers) {
-      const env: Record<string, string> = {};
-      for (const { name: envName, value } of rawEnv) {
-        env[envName] = value;
-      }
-      mergedMcpServers[name] = new MCPServerConfig(command, args, env, cwd);
-    }
-
-    const settings = { ...this.settings.merged, mcpServers: mergedMcpServers };
-
-    const argvForSession = {
-      ...this.argv,
-      resume: sessionId,
-      continue: false,
-    };
-
-    const config = await loadCliConfig(
-      settings,
-      this.extensions,
-      new ExtensionEnablementManager(
-        ExtensionStorage.getUserExtensionsDir(),
-        this.argv.extensions,
-      ),
-      argvForSession,
-      cwd,
-    );
-
-    await config.initialize();
-    return config;
-  }
-
-  async cancel(params: acp.CancelNotification): Promise<void> {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    await session.cancelPendingPrompt();
-  }
-
-  async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    return session.prompt(params);
-  }
-
-  async loadSession(
-    params: acp.LoadSessionRequest,
-  ): Promise<acp.LoadSessionResponse> {
-    const sessionService = new SessionService(params.cwd);
-    const exists = await sessionService.sessionExists(params.sessionId);
-    if (!exists) {
-      throw acp.RequestError.invalidParams(
-        `Session not found for id: ${params.sessionId}`,
-      );
-    }
-
-    const config = await this.newSessionConfig(
-      params.cwd,
-      params.mcpServers,
-      params.sessionId,
-    );
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
-
-    const sessionData = config.getResumedSessionData();
-    if (!sessionData) {
-      throw acp.RequestError.internalError(
-        `Failed to load session data for id: ${params.sessionId}`,
-      );
-    }
-
-    await this.createAndStoreSession(config, sessionData.conversation);
-
-    return null;
-  }
-
-  async listSessions(
-    params: acp.ListSessionsRequest,
-  ): Promise<acp.ListSessionsResponse> {
-    const sessionService = new SessionService(params.cwd);
-    const result = await sessionService.listSessions({
-      cursor: params.cursor,
-      size: params.size,
-    });
-
-    return {
-      items: result.items.map((item) => ({
-        sessionId: item.sessionId,
-        cwd: item.cwd,
-        startTime: item.startTime,
-        mtime: item.mtime,
-        prompt: item.prompt,
-        gitBranch: item.gitBranch,
-        filePath: item.filePath,
-        messageCount: item.messageCount,
-      })),
-      nextCursor: result.nextCursor,
-      hasMore: result.hasMore,
-    };
-  }
-
-  async setMode(params: acp.SetModeRequest): Promise<acp.SetModeResponse> {
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    return session.setMode(params);
-  }
-
-  private async ensureAuthenticated(config: Config): Promise<void> {
-    const selectedType = this.settings.merged.security?.auth?.selectedType;
-    if (!selectedType) {
-      throw acp.RequestError.authRequired();
-    }
-
-    try {
-      await config.refreshAuth(selectedType);
-    } catch (e) {
-      console.error(`Authentication failed: ${e}`);
-      throw acp.RequestError.authRequired();
-    }
-  }
-
-  private setupFileSystem(config: Config): void {
-    if (!this.clientCapabilities?.fs) {
-      return;
-    }
-
-    const acpFileSystemService = new AcpFileSystemService(
-      this.client,
-      config.getSessionId(),
-      this.clientCapabilities.fs,
-      config.getFileSystemService(),
-    );
-    config.setFileSystemService(acpFileSystemService);
-  }
-
-  private async createAndStoreSession(
-    config: Config,
-    conversation?: ConversationRecord,
-  ): Promise<Session> {
-    const sessionId = config.getSessionId();
-    const geminiClient = config.getGeminiClient();
-
-    const history = conversation
-      ? buildApiHistoryFromConversation(conversation)
-      : undefined;
-    const chat = history
-      ? await geminiClient.startChat(history)
-      : await geminiClient.startChat();
-
-    const session = new Session(
-      sessionId,
-      chat,
-      config,
-      this.client,
-      this.settings,
-    );
-    this.sessions.set(sessionId, session);
-
-    setTimeout(async () => {
-      await session.sendAvailableCommandsUpdate();
-    }, 0);
-
-    if (conversation && conversation.messages) {
-      await session.replayHistory(conversation.messages);
-    }
-
-    return session;
-  }
-}
--- a/packages/cli/src/acp-integration/session/HistoryReplayer.test.ts
+++ b/packages/cli/src/acp-integration/session/HistoryReplayer.test.ts
@@ -1,414 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HistoryReplayer } from './HistoryReplayer.js';
-import type { SessionContext } from './types.js';
-import type {
-  Config,
-  ChatRecord,
-  ToolRegistry,
-  ToolResultDisplay,
-  TodoResultDisplay,
-} from '@qwen-code/qwen-code-core';
-
-describe('HistoryReplayer', () => {
-  let mockContext: SessionContext;
-  let sendUpdateSpy: ReturnType<typeof vi.fn>;
-  let replayer: HistoryReplayer;
-
-  beforeEach(() => {
-    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
-    const mockToolRegistry = {
-      getTool: vi.fn().mockReturnValue(null),
-    } as unknown as ToolRegistry;
-
-    mockContext = {
-      sessionId: 'test-session-id',
-      config: {
-        getToolRegistry: () => mockToolRegistry,
-      } as unknown as Config,
-      sendUpdate: sendUpdateSpy,
-    };
-
-    replayer = new HistoryReplayer(mockContext);
-  });
-
-  const createUserRecord = (text: string): ChatRecord => ({
-    uuid: 'user-uuid',
-    parentUuid: null,
-    sessionId: 'test-session',
-    timestamp: new Date().toISOString(),
-    type: 'user',
-    cwd: '/test',
-    version: '1.0.0',
-    message: {
-      role: 'user',
-      parts: [{ text }],
-    },
-  });
-
-  const createAssistantRecord = (
-    text: string,
-    thought = false,
-  ): ChatRecord => ({
-    uuid: 'assistant-uuid',
-    parentUuid: 'user-uuid',
-    sessionId: 'test-session',
-    timestamp: new Date().toISOString(),
-    type: 'assistant',
-    cwd: '/test',
-    version: '1.0.0',
-    message: {
-      role: 'model',
-      parts: [{ text, thought }],
-    },
-  });
-
-  const createToolResultRecord = (
-    toolName: string,
-    resultDisplay?: ToolResultDisplay,
-    hasError = false,
-  ): ChatRecord => ({
-    uuid: 'tool-uuid',
-    parentUuid: 'assistant-uuid',
-    sessionId: 'test-session',
-    timestamp: new Date().toISOString(),
-    type: 'tool_result',
-    cwd: '/test',
-    version: '1.0.0',
-    message: {
-      role: 'user',
-      parts: [
-        {
-          functionResponse: {
-            name: toolName,
-            response: { result: 'ok' },
-          },
-        },
-      ],
-    },
-    toolCallResult: {
-      callId: 'call-123',
-      responseParts: [],
-      resultDisplay,
-      error: hasError ? new Error('Tool failed') : undefined,
-      errorType: undefined,
-    },
-  });
-
-  describe('replay', () => {
-    it('should replay empty records array', async () => {
-      await replayer.replay([]);
-
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-
-    it('should replay records in order', async () => {
-      const records = [
-        createUserRecord('Hello'),
-        createAssistantRecord('Hi there'),
-      ];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(2);
-      expect(sendUpdateSpy.mock.calls[0][0].sessionUpdate).toBe(
-        'user_message_chunk',
-      );
-      expect(sendUpdateSpy.mock.calls[1][0].sessionUpdate).toBe(
-        'agent_message_chunk',
-      );
-    });
-  });
-
-  describe('user message replay', () => {
-    it('should emit user_message_chunk for user records', async () => {
-      const records = [createUserRecord('Hello, world!')];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: 'Hello, world!' },
-      });
-    });
-
-    it('should skip user records without message', async () => {
-      const record: ChatRecord = {
-        ...createUserRecord('test'),
-        message: undefined,
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('assistant message replay', () => {
-    it('should emit agent_message_chunk for assistant records', async () => {
-      const records = [createAssistantRecord('I can help with that.')];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'I can help with that.' },
-      });
-    });
-
-    it('should emit agent_thought_chunk for thought parts', async () => {
-      const records = [createAssistantRecord('Thinking about this...', true)];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_thought_chunk',
-        content: { type: 'text', text: 'Thinking about this...' },
-      });
-    });
-
-    it('should handle assistant records with multiple parts', async () => {
-      const record: ChatRecord = {
-        ...createAssistantRecord('First'),
-        message: {
-          role: 'model',
-          parts: [
-            { text: 'First part' },
-            { text: 'Second part', thought: true },
-            { text: 'Third part' },
-          ],
-        },
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(3);
-      expect(sendUpdateSpy.mock.calls[0][0]).toEqual({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'First part' },
-      });
-      expect(sendUpdateSpy.mock.calls[1][0]).toEqual({
-        sessionUpdate: 'agent_thought_chunk',
-        content: { type: 'text', text: 'Second part' },
-      });
-      expect(sendUpdateSpy.mock.calls[2][0]).toEqual({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'Third part' },
-      });
-    });
-  });
-
-  describe('function call replay', () => {
-    it('should emit tool_call for function call parts', async () => {
-      const record: ChatRecord = {
-        ...createAssistantRecord(''),
-        message: {
-          role: 'model',
-          parts: [
-            {
-              functionCall: {
-                name: 'read_file',
-                args: { path: '/test.ts' },
-              },
-            },
-          ],
-        },
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call',
-          status: 'in_progress',
-          title: 'read_file',
-          rawInput: { path: '/test.ts' },
-        }),
-      );
-    });
-
-    it('should use function call id as callId when available', async () => {
-      const record: ChatRecord = {
-        ...createAssistantRecord(''),
-        message: {
-          role: 'model',
-          parts: [
-            {
-              functionCall: {
-                id: 'custom-call-id',
-                name: 'read_file',
-                args: {},
-              },
-            },
-          ],
-        },
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          toolCallId: 'custom-call-id',
-        }),
-      );
-    });
-  });
-
-  describe('tool result replay', () => {
-    it('should emit tool_call_update for tool result records', async () => {
-      const records = [
-        createToolResultRecord('read_file', 'File contents here'),
-      ];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call_update',
-        toolCallId: 'call-123',
-        status: 'completed',
-        content: [
-          {
-            type: 'content',
-            // Content comes from functionResponse.response (stringified)
-            content: { type: 'text', text: '{"result":"ok"}' },
-          },
-        ],
-        // resultDisplay is included as rawOutput
-        rawOutput: 'File contents here',
-      });
-    });
-
-    it('should emit failed status for tool results with errors', async () => {
-      const records = [createToolResultRecord('failing_tool', undefined, true)];
-
-      await replayer.replay(records);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call_update',
-          status: 'failed',
-        }),
-      );
-    });
-
-    it('should emit plan update for TodoWriteTool results', async () => {
-      const todoDisplay: TodoResultDisplay = {
-        type: 'todo_list',
-        todos: [
-          { id: '1', content: 'Task 1', status: 'pending' },
-          { id: '2', content: 'Task 2', status: 'completed' },
-        ],
-      };
-      const record = createToolResultRecord('todo_write', todoDisplay);
-      // Override the function response name
-      record.message = {
-        role: 'user',
-        parts: [
-          {
-            functionResponse: {
-              name: 'todo_write',
-              response: { result: 'ok' },
-            },
-          },
-        ],
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'plan',
-        entries: [
-          { content: 'Task 1', priority: 'medium', status: 'pending' },
-          { content: 'Task 2', priority: 'medium', status: 'completed' },
-        ],
-      });
-    });
-
-    it('should use record uuid as callId when toolCallResult.callId is missing', async () => {
-      const record: ChatRecord = {
-        ...createToolResultRecord('test_tool'),
-        uuid: 'fallback-uuid',
-        toolCallResult: {
-          callId: undefined as unknown as string,
-          responseParts: [],
-          resultDisplay: 'Result',
-          error: undefined,
-          errorType: undefined,
-        },
-      };
-
-      await replayer.replay([record]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          toolCallId: 'fallback-uuid',
-        }),
-      );
-    });
-  });
-
-  describe('system records', () => {
-    it('should skip system records', async () => {
-      const systemRecord: ChatRecord = {
-        uuid: 'system-uuid',
-        parentUuid: null,
-        sessionId: 'test-session',
-        timestamp: new Date().toISOString(),
-        type: 'system',
-        subtype: 'chat_compression',
-        cwd: '/test',
-        version: '1.0.0',
-      };
-
-      await replayer.replay([systemRecord]);
-
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('mixed record types', () => {
-    it('should handle a complete conversation replay', async () => {
-      const records: ChatRecord[] = [
-        createUserRecord('Read the file test.ts'),
-        {
-          ...createAssistantRecord(''),
-          message: {
-            role: 'model',
-            parts: [
-              { text: "I'll read that file for you.", thought: true },
-              {
-                functionCall: {
-                  id: 'call-read',
-                  name: 'read_file',
-                  args: { path: 'test.ts' },
-                },
-              },
-            ],
-          },
-        },
-        createToolResultRecord('read_file', 'export const x = 1;'),
-        createAssistantRecord('The file contains a simple export.'),
-      ];
-
-      await replayer.replay(records);
-
-      // Verify order and types of updates
-      const updateTypes = sendUpdateSpy.mock.calls.map(
-        (call: unknown[]) =>
-          (call[0] as { sessionUpdate: string }).sessionUpdate,
-      );
-      expect(updateTypes).toEqual([
-        'user_message_chunk',
-        'agent_thought_chunk',
-        'tool_call',
-        'tool_call_update',
-        'agent_message_chunk',
-      ]);
-    });
-  });
-});
--- a/packages/cli/src/acp-integration/session/HistoryReplayer.ts
+++ b/packages/cli/src/acp-integration/session/HistoryReplayer.ts
@@ -1,137 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { ChatRecord } from '@qwen-code/qwen-code-core';
-import type { Content } from '@google/genai';
-import type { SessionContext } from './types.js';
-import { MessageEmitter } from './emitters/MessageEmitter.js';
-import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
-
-/**
- * Handles replaying session history on session load.
- *
- * Uses the unified emitters to ensure consistency with normal flow.
- * This ensures that replayed history looks identical to how it would
- * have appeared during the original session.
- */
-export class HistoryReplayer {
-  private readonly messageEmitter: MessageEmitter;
-  private readonly toolCallEmitter: ToolCallEmitter;
-
-  constructor(ctx: SessionContext) {
-    this.messageEmitter = new MessageEmitter(ctx);
-    this.toolCallEmitter = new ToolCallEmitter(ctx);
-  }
-
-  /**
-   * Replays all chat records from a loaded session.
-   *
-   * @param records - Array of chat records to replay
-   */
-  async replay(records: ChatRecord[]): Promise<void> {
-    for (const record of records) {
-      await this.replayRecord(record);
-    }
-  }
-
-  /**
-   * Replays a single chat record.
-   */
-  private async replayRecord(record: ChatRecord): Promise<void> {
-    switch (record.type) {
-      case 'user':
-        if (record.message) {
-          await this.replayContent(record.message, 'user');
-        }
-        break;
-
-      case 'assistant':
-        if (record.message) {
-          await this.replayContent(record.message, 'assistant');
-        }
-        break;
-
-      case 'tool_result':
-        await this.replayToolResult(record);
-        break;
-
-      default:
-        // Skip system records (compression, telemetry, slash commands)
-        break;
-    }
-  }
-
-  /**
-   * Replays content from a message (user or assistant).
-   * Handles text parts, thought parts, and function calls.
-   */
-  private async replayContent(
-    content: Content,
-    role: 'user' | 'assistant',
-  ): Promise<void> {
-    for (const part of content.parts ?? []) {
-      // Text content
-      if ('text' in part && part.text) {
-        const isThought = (part as { thought?: boolean }).thought ?? false;
-        await this.messageEmitter.emitMessage(part.text, role, isThought);
-      }
-
-      // Function call (tool start)
-      if ('functionCall' in part && part.functionCall) {
-        const functionName = part.functionCall.name ?? '';
-        const callId = part.functionCall.id ?? `${functionName}-${Date.now()}`;
-
-        await this.toolCallEmitter.emitStart({
-          toolName: functionName,
-          callId,
-          args: part.functionCall.args as Record<string, unknown>,
-        });
-      }
-    }
-  }
-
-  /**
-   * Replays a tool result record.
-   */
-  private async replayToolResult(record: ChatRecord): Promise<void> {
-    // message is required - skip if not present
-    if (!record.message?.parts) {
-      return;
-    }
-
-    const result = record.toolCallResult;
-    const callId = result?.callId ?? record.uuid;
-
-    // Extract tool name from the function response in message if available
-    const toolName = this.extractToolNameFromRecord(record);
-
-    await this.toolCallEmitter.emitResult({
-      toolName,
-      callId,
-      success: !result?.error,
-      message: record.message.parts,
-      resultDisplay: result?.resultDisplay,
-      // For TodoWriteTool fallback, try to extract args from the record
-      // Note: args aren't stored in tool_result records by default
-      args: undefined,
-    });
-  }
-
-  /**
-   * Extracts tool name from a chat record's function response.
-   */
-  private extractToolNameFromRecord(record: ChatRecord): string {
-    // Try to get from functionResponse in message
-    if (record.message?.parts) {
-      for (const part of record.message.parts) {
-        if ('functionResponse' in part && part.functionResponse?.name) {
-          return part.functionResponse.name;
-        }
-      }
-    }
-    return '';
-  }
-}
--- a/packages/cli/src/acp-integration/session/Session.ts
+++ b/packages/cli/src/acp-integration/session/Session.ts
@@ -1,981 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Content, FunctionCall, Part } from '@google/genai';
-import type {
-  Config,
-  GeminiChat,
-  ToolCallConfirmationDetails,
-  ToolResult,
-  ChatRecord,
-  SubAgentEventEmitter,
-} from '@qwen-code/qwen-code-core';
-import {
-  ApprovalMode,
-  convertToFunctionResponse,
-  DiscoveredMCPTool,
-  StreamEventType,
-  ToolConfirmationOutcome,
-  logToolCall,
-  logUserPrompt,
-  getErrorStatus,
-  isWithinRoot,
-  isNodeError,
-  TaskTool,
-  UserPromptEvent,
-  TodoWriteTool,
-  ExitPlanModeTool,
-} from '@qwen-code/qwen-code-core';
-
-import * as acp from '../acp.js';
-import type { LoadedSettings } from '../../config/settings.js';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { z } from 'zod';
-import { getErrorMessage } from '../../utils/errors.js';
-import {
-  handleSlashCommand,
-  getAvailableCommands,
-} from '../../nonInteractiveCliCommands.js';
-import type {
-  AvailableCommand,
-  AvailableCommandsUpdate,
-  SetModeRequest,
-  SetModeResponse,
-  ApprovalModeValue,
-  CurrentModeUpdate,
-} from '../schema.js';
-import { isSlashCommand } from '../../ui/utils/commandUtils.js';
-
-// Import modular session components
-import type { SessionContext, ToolCallStartParams } from './types.js';
-import { HistoryReplayer } from './HistoryReplayer.js';
-import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
-import { PlanEmitter } from './emitters/PlanEmitter.js';
-import { SubAgentTracker } from './SubAgentTracker.js';
-
-/**
- * Built-in commands that are allowed in ACP integration mode.
- * Only safe, read-only commands that don't require interactive UI.
- */
-export const ALLOWED_BUILTIN_COMMANDS_FOR_ACP = ['init'];
-
-/**
- * Session represents an active conversation session with the AI model.
- * It uses modular components for consistent event emission:
- * - HistoryReplayer for replaying past conversations
- * - ToolCallEmitter for tool-related session updates
- * - PlanEmitter for todo/plan updates
- * - SubAgentTracker for tracking sub-agent tool calls
- */
-export class Session implements SessionContext {
-  private pendingPrompt: AbortController | null = null;
-  private turn: number = 0;
-
-  // Modular components
-  private readonly historyReplayer: HistoryReplayer;
-  private readonly toolCallEmitter: ToolCallEmitter;
-  private readonly planEmitter: PlanEmitter;
-
-  // Implement SessionContext interface
-  readonly sessionId: string;
-
-  constructor(
-    id: string,
-    private readonly chat: GeminiChat,
-    readonly config: Config,
-    private readonly client: acp.Client,
-    private readonly settings: LoadedSettings,
-  ) {
-    this.sessionId = id;
-
-    // Initialize modular components with this session as context
-    this.toolCallEmitter = new ToolCallEmitter(this);
-    this.planEmitter = new PlanEmitter(this);
-    this.historyReplayer = new HistoryReplayer(this);
-  }
-
-  getId(): string {
-    return this.sessionId;
-  }
-
-  getConfig(): Config {
-    return this.config;
-  }
-
-  /**
-   * Replays conversation history to the client using modular components.
-   * Delegates to HistoryReplayer for consistent event emission.
-   */
-  async replayHistory(records: ChatRecord[]): Promise<void> {
-    await this.historyReplayer.replay(records);
-  }
-
-  async cancelPendingPrompt(): Promise<void> {
-    if (!this.pendingPrompt) {
-      throw new Error('Not currently generating');
-    }
-
-    this.pendingPrompt.abort();
-    this.pendingPrompt = null;
-  }
-
-  async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
-    this.pendingPrompt?.abort();
-    const pendingSend = new AbortController();
-    this.pendingPrompt = pendingSend;
-
-    // Increment turn counter for each user prompt
-    this.turn += 1;
-
-    const chat = this.chat;
-    const promptId = this.config.getSessionId() + '########' + this.turn;
-
-    // Extract text from all text blocks to construct the full prompt text for logging
-    const promptText = params.prompt
-      .filter((block) => block.type === 'text')
-      .map((block) => (block.type === 'text' ? block.text : ''))
-      .join(' ');
-
-    // Log user prompt
-    logUserPrompt(
-      this.config,
-      new UserPromptEvent(
-        promptText.length,
-        promptId,
-        this.config.getContentGeneratorConfig()?.authType,
-        promptText,
-      ),
-    );
-
-    // record user message for session management
-    this.config.getChatRecordingService()?.recordUserMessage(promptText);
-
-    // Check if the input contains a slash command
-    // Extract text from the first text block if present
-    const firstTextBlock = params.prompt.find((block) => block.type === 'text');
-    const inputText = firstTextBlock?.text || '';
-
-    let parts: Part[];
-
-    if (isSlashCommand(inputText)) {
-      // Handle slash command - allow specific built-in commands for ACP integration
-      const slashCommandResult = await handleSlashCommand(
-        inputText,
-        pendingSend,
-        this.config,
-        this.settings,
-        ALLOWED_BUILTIN_COMMANDS_FOR_ACP,
-      );
-
-      if (slashCommandResult) {
-        // Use the result from the slash command
-        parts = slashCommandResult as Part[];
-      } else {
-        // Slash command didn't return a prompt, continue with normal processing
-        parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
-      }
-    } else {
-      // Normal processing for non-slash commands
-      parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
-    }
-
-    let nextMessage: Content | null = { role: 'user', parts };
-
-    while (nextMessage !== null) {
-      if (pendingSend.signal.aborted) {
-        chat.addHistory(nextMessage);
-        return { stopReason: 'cancelled' };
-      }
-
-      const functionCalls: FunctionCall[] = [];
-
-      try {
-        const responseStream = await chat.sendMessageStream(
-          this.config.getModel(),
-          {
-            message: nextMessage?.parts ?? [],
-            config: {
-              abortSignal: pendingSend.signal,
-            },
-          },
-          promptId,
-        );
-        nextMessage = null;
-
-        for await (const resp of responseStream) {
-          if (pendingSend.signal.aborted) {
-            return { stopReason: 'cancelled' };
-          }
-
-          if (
-            resp.type === StreamEventType.CHUNK &&
-            resp.value.candidates &&
-            resp.value.candidates.length > 0
-          ) {
-            const candidate = resp.value.candidates[0];
-            for (const part of candidate.content?.parts ?? []) {
-              if (!part.text) {
-                continue;
-              }
-
-              const content: acp.ContentBlock = {
-                type: 'text',
-                text: part.text,
-              };
-
-              this.sendUpdate({
-                sessionUpdate: part.thought
-                  ? 'agent_thought_chunk'
-                  : 'agent_message_chunk',
-                content,
-              });
-            }
-          }
-
-          if (resp.type === StreamEventType.CHUNK && resp.value.functionCalls) {
-            functionCalls.push(...resp.value.functionCalls);
-          }
-        }
-      } catch (error) {
-        if (getErrorStatus(error) === 429) {
-          throw new acp.RequestError(
-            429,
-            'Rate limit exceeded. Try again later.',
-          );
-        }
-
-        throw error;
-      }
-
-      if (functionCalls.length > 0) {
-        const toolResponseParts: Part[] = [];
-
-        for (const fc of functionCalls) {
-          const response = await this.runTool(pendingSend.signal, promptId, fc);
-          toolResponseParts.push(...response);
-        }
-
-        nextMessage = { role: 'user', parts: toolResponseParts };
-      }
-    }
-
-    return { stopReason: 'end_turn' };
-  }
-
-  async sendUpdate(update: acp.SessionUpdate): Promise<void> {
-    const params: acp.SessionNotification = {
-      sessionId: this.sessionId,
-      update,
-    };
-
-    await this.client.sessionUpdate(params);
-  }
-
-  async sendAvailableCommandsUpdate(): Promise<void> {
-    const abortController = new AbortController();
-    try {
-      const slashCommands = await getAvailableCommands(
-        this.config,
-        this.settings,
-        abortController.signal,
-        ALLOWED_BUILTIN_COMMANDS_FOR_ACP,
-      );
-
-      // Convert SlashCommand[] to AvailableCommand[] format for ACP protocol
-      const availableCommands: AvailableCommand[] = slashCommands.map(
-        (cmd) => ({
-          name: cmd.name,
-          description: cmd.description,
-          input: null,
-        }),
-      );
-
-      const update: AvailableCommandsUpdate = {
-        sessionUpdate: 'available_commands_update',
-        availableCommands,
-      };
-
-      await this.sendUpdate(update);
-    } catch (error) {
-      // Log error but don't fail session creation
-      console.error('Error sending available commands update:', error);
-    }
-  }
-
-  /**
-   * Requests permission from the client for a tool call.
-   * Used by SubAgentTracker for sub-agent approval requests.
-   */
-  async requestPermission(
-    params: acp.RequestPermissionRequest,
-  ): Promise<acp.RequestPermissionResponse> {
-    return this.client.requestPermission(params);
-  }
-
-  /**
-   * Sets the approval mode for the current session.
-   * Maps ACP approval mode values to core ApprovalMode enum.
-   */
-  async setMode(params: SetModeRequest): Promise<SetModeResponse> {
-    const modeMap: Record<ApprovalModeValue, ApprovalMode> = {
-      plan: ApprovalMode.PLAN,
-      default: ApprovalMode.DEFAULT,
-      'auto-edit': ApprovalMode.AUTO_EDIT,
-      yolo: ApprovalMode.YOLO,
-    };
-
-    const approvalMode = modeMap[params.modeId];
-    this.config.setApprovalMode(approvalMode);
-
-    return { modeId: params.modeId };
-  }
-
-  /**
-   * Sends a current_mode_update notification to the client.
-   * Called after the agent switches modes (e.g., from exit_plan_mode tool).
-   */
-  private async sendCurrentModeUpdateNotification(
-    outcome: ToolConfirmationOutcome,
-  ): Promise<void> {
-    // Determine the new mode based on the approval outcome
-    // This mirrors the logic in ExitPlanModeTool.onConfirm
-    let newModeId: ApprovalModeValue;
-    switch (outcome) {
-      case ToolConfirmationOutcome.ProceedAlways:
-        newModeId = 'auto-edit';
-        break;
-      case ToolConfirmationOutcome.ProceedOnce:
-      default:
-        newModeId = 'default';
-        break;
-    }
-
-    const update: CurrentModeUpdate = {
-      sessionUpdate: 'current_mode_update',
-      modeId: newModeId,
-    };
-
-    await this.sendUpdate(update);
-  }
-
-  private async runTool(
-    abortSignal: AbortSignal,
-    promptId: string,
-    fc: FunctionCall,
-  ): Promise<Part[]> {
-    const callId = fc.id ?? `${fc.name}-${Date.now()}`;
-    const args = (fc.args ?? {}) as Record<string, unknown>;
-
-    const startTime = Date.now();
-
-    const errorResponse = (error: Error) => {
-      const durationMs = Date.now() - startTime;
-      logToolCall(this.config, {
-        'event.name': 'tool_call',
-        'event.timestamp': new Date().toISOString(),
-        prompt_id: promptId,
-        function_name: fc.name ?? '',
-        function_args: args,
-        duration_ms: durationMs,
-        status: 'error',
-        success: false,
-        error: error.message,
-        tool_type:
-          typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
-            ? 'mcp'
-            : 'native',
-      });
-
-      return [
-        {
-          functionResponse: {
-            id: callId,
-            name: fc.name ?? '',
-            response: { error: error.message },
-          },
-        },
-      ];
-    };
-
-    if (!fc.name) {
-      return errorResponse(new Error('Missing function name'));
-    }
-
-    const toolRegistry = this.config.getToolRegistry();
-    const tool = toolRegistry.getTool(fc.name as string);
-
-    if (!tool) {
-      return errorResponse(
-        new Error(`Tool "${fc.name}" not found in registry.`),
-      );
-    }
-
-    // Detect TodoWriteTool early - route to plan updates instead of tool_call events
-    const isTodoWriteTool = tool.name === TodoWriteTool.Name;
-    const isTaskTool = tool.name === TaskTool.Name;
-    const isExitPlanModeTool = tool.name === ExitPlanModeTool.Name;
-
-    // Track cleanup functions for sub-agent event listeners
-    let subAgentCleanupFunctions: Array<() => void> = [];
-
-    try {
-      const invocation = tool.build(args);
-
-      if (isTaskTool && 'eventEmitter' in invocation) {
-        // Access eventEmitter from TaskTool invocation
-        const taskEventEmitter = (
-          invocation as {
-            eventEmitter: SubAgentEventEmitter;
-          }
-        ).eventEmitter;
-
-        // Create a SubAgentTracker for this tool execution
-        const subAgentTracker = new SubAgentTracker(this, this.client);
-
-        // Set up sub-agent tool tracking
-        subAgentCleanupFunctions = subAgentTracker.setup(
-          taskEventEmitter,
-          abortSignal,
-        );
-      }
-
-      const confirmationDetails =
-        await invocation.shouldConfirmExecute(abortSignal);
-
-      if (confirmationDetails) {
-        const content: acp.ToolCallContent[] = [];
-
-        if (confirmationDetails.type === 'edit') {
-          content.push({
-            type: 'diff',
-            path: confirmationDetails.fileName,
-            oldText: confirmationDetails.originalContent,
-            newText: confirmationDetails.newContent,
-          });
-        }
-
-        // Add plan content for exit_plan_mode
-        if (confirmationDetails.type === 'plan') {
-          content.push({
-            type: 'content',
-            content: {
-              type: 'text',
-              text: confirmationDetails.plan,
-            },
-          });
-        }
-
-        // Map tool kind, using switch_mode for exit_plan_mode per ACP spec
-        const mappedKind = this.toolCallEmitter.mapToolKind(tool.kind, fc.name);
-
-        const params: acp.RequestPermissionRequest = {
-          sessionId: this.sessionId,
-          options: toPermissionOptions(confirmationDetails),
-          toolCall: {
-            toolCallId: callId,
-            status: 'pending',
-            title: invocation.getDescription(),
-            content,
-            locations: invocation.toolLocations(),
-            kind: mappedKind,
-          },
-        };
-
-        const output = await this.client.requestPermission(params);
-        const outcome =
-          output.outcome.outcome === 'cancelled'
-            ? ToolConfirmationOutcome.Cancel
-            : z
-                .nativeEnum(ToolConfirmationOutcome)
-                .parse(output.outcome.optionId);
-
-        await confirmationDetails.onConfirm(outcome);
-
-        // After exit_plan_mode confirmation, send current_mode_update notification
-        if (isExitPlanModeTool && outcome !== ToolConfirmationOutcome.Cancel) {
-          await this.sendCurrentModeUpdateNotification(outcome);
-        }
-
-        switch (outcome) {
-          case ToolConfirmationOutcome.Cancel:
-            return errorResponse(
-              new Error(`Tool "${fc.name}" was canceled by the user.`),
-            );
-          case ToolConfirmationOutcome.ProceedOnce:
-          case ToolConfirmationOutcome.ProceedAlways:
-          case ToolConfirmationOutcome.ProceedAlwaysServer:
-          case ToolConfirmationOutcome.ProceedAlwaysTool:
-          case ToolConfirmationOutcome.ModifyWithEditor:
-            break;
-          default: {
-            const resultOutcome: never = outcome;
-            throw new Error(`Unexpected: ${resultOutcome}`);
-          }
-        }
-      } else if (!isTodoWriteTool) {
-        // Skip tool_call event for TodoWriteTool - use ToolCallEmitter
-        const startParams: ToolCallStartParams = {
-          callId,
-          toolName: fc.name,
-          args,
-        };
-        await this.toolCallEmitter.emitStart(startParams);
-      }
-
-      const toolResult: ToolResult = await invocation.execute(abortSignal);
-
-      // Clean up event listeners
-      subAgentCleanupFunctions.forEach((cleanup) => cleanup());
-
-      // Create response parts first (needed for emitResult and recordToolResult)
-      const responseParts = convertToFunctionResponse(
-        fc.name,
-        callId,
-        toolResult.llmContent,
-      );
-
-      // Handle TodoWriteTool: extract todos and send plan update
-      if (isTodoWriteTool) {
-        const todos = this.planEmitter.extractTodos(
-          toolResult.returnDisplay,
-          args,
-        );
-
-        // Match original logic: emit plan if todos.length > 0 OR if args had todos
-        if ((todos && todos.length > 0) || Array.isArray(args['todos'])) {
-          await this.planEmitter.emitPlan(todos ?? []);
-        }
-
-        // Skip tool_call_update event for TodoWriteTool
-        // Still log and return function response for LLM
-      } else {
-        // Normal tool handling: emit result using ToolCallEmitter
-        // Convert toolResult.error to Error type if present
-        const error = toolResult.error
-          ? new Error(toolResult.error.message)
-          : undefined;
-
-        await this.toolCallEmitter.emitResult({
-          callId,
-          toolName: fc.name,
-          args,
-          message: responseParts,
-          resultDisplay: toolResult.returnDisplay,
-          error,
-          success: !toolResult.error,
-        });
-      }
-
-      const durationMs = Date.now() - startTime;
-      logToolCall(this.config, {
-        'event.name': 'tool_call',
-        'event.timestamp': new Date().toISOString(),
-        function_name: fc.name,
-        function_args: args,
-        duration_ms: durationMs,
-        status: 'success',
-        success: true,
-        prompt_id: promptId,
-        tool_type:
-          typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
-            ? 'mcp'
-            : 'native',
-      });
-
-      // Record tool result for session management
-      this.config.getChatRecordingService()?.recordToolResult(responseParts, {
-        callId,
-        status: 'success',
-        resultDisplay: toolResult.returnDisplay,
-        error: undefined,
-        errorType: undefined,
-      });
-
-      return responseParts;
-    } catch (e) {
-      // Ensure cleanup on error
-      subAgentCleanupFunctions.forEach((cleanup) => cleanup());
-
-      const error = e instanceof Error ? e : new Error(String(e));
-
-      // Use ToolCallEmitter for error handling
-      await this.toolCallEmitter.emitError(callId, error);
-
-      // Record tool error for session management
-      const errorParts = [
-        {
-          functionResponse: {
-            id: callId,
-            name: fc.name ?? '',
-            response: { error: error.message },
-          },
-        },
-      ];
-      this.config.getChatRecordingService()?.recordToolResult(errorParts, {
-        callId,
-        status: 'error',
-        resultDisplay: undefined,
-        error,
-        errorType: undefined,
-      });
-
-      return errorResponse(error);
-    }
-  }
-
-  async #resolvePrompt(
-    message: acp.ContentBlock[],
-    abortSignal: AbortSignal,
-  ): Promise<Part[]> {
-    const FILE_URI_SCHEME = 'file://';
-
-    const embeddedContext: acp.EmbeddedResourceResource[] = [];
-
-    const parts = message.map((part) => {
-      switch (part.type) {
-        case 'text':
-          return { text: part.text };
-        case 'image':
-        case 'audio':
-          return {
-            inlineData: {
-              mimeType: part.mimeType,
-              data: part.data,
-            },
-          };
-        case 'resource_link': {
-          if (part.uri.startsWith(FILE_URI_SCHEME)) {
-            return {
-              fileData: {
-                mimeData: part.mimeType,
-                name: part.name,
-                fileUri: part.uri.slice(FILE_URI_SCHEME.length),
-              },
-            };
-          } else {
-            return { text: `@${part.uri}` };
-          }
-        }
-        case 'resource': {
-          embeddedContext.push(part.resource);
-          return { text: `@${part.resource.uri}` };
-        }
-        default: {
-          const unreachable: never = part;
-          throw new Error(`Unexpected chunk type: '${unreachable}'`);
-        }
-      }
-    });
-
-    const atPathCommandParts = parts.filter((part) => 'fileData' in part);
-
-    if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
-      return parts;
-    }
-
-    const atPathToResolvedSpecMap = new Map<string, string>();
-
-    // Get centralized file discovery service
-    const fileDiscovery = this.config.getFileService();
-    const respectGitIgnore = this.config.getFileFilteringRespectGitIgnore();
-
-    const pathSpecsToRead: string[] = [];
-    const contentLabelsForDisplay: string[] = [];
-    const ignoredPaths: string[] = [];
-
-    const toolRegistry = this.config.getToolRegistry();
-    const readManyFilesTool = toolRegistry.getTool('read_many_files');
-    const globTool = toolRegistry.getTool('glob');
-
-    if (!readManyFilesTool) {
-      throw new Error('Error: read_many_files tool not found.');
-    }
-
-    for (const atPathPart of atPathCommandParts) {
-      const pathName = atPathPart.fileData!.fileUri;
-      // Check if path should be ignored by git
-      if (fileDiscovery.shouldGitIgnoreFile(pathName)) {
-        ignoredPaths.push(pathName);
-        const reason = respectGitIgnore
-          ? 'git-ignored and will be skipped'
-          : 'ignored by custom patterns';
-        console.warn(`Path ${pathName} is ${reason}.`);
-        continue;
-      }
-      let currentPathSpec = pathName;
-      let resolvedSuccessfully = false;
-      try {
-        const absolutePath = path.resolve(this.config.getTargetDir(), pathName);
-        if (isWithinRoot(absolutePath, this.config.getTargetDir())) {
-          const stats = await fs.stat(absolutePath);
-          if (stats.isDirectory()) {
-            currentPathSpec = pathName.endsWith('/')
-              ? `${pathName}**`
-              : `${pathName}/**`;
-            this.debug(
-              `Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`,
-            );
-          } else {
-            this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
-          }
-          resolvedSuccessfully = true;
-        } else {
-          this.debug(
-            `Path ${pathName} is outside the project directory. Skipping.`,
-          );
-        }
-      } catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-          if (this.config.getEnableRecursiveFileSearch() && globTool) {
-            this.debug(
-              `Path ${pathName} not found directly, attempting glob search.`,
-            );
-            try {
-              const globResult = await globTool.buildAndExecute(
-                {
-                  pattern: `**/*${pathName}*`,
-                  path: this.config.getTargetDir(),
-                },
-                abortSignal,
-              );
-              if (
-                globResult.llmContent &&
-                typeof globResult.llmContent === 'string' &&
-                !globResult.llmContent.startsWith('No files found') &&
-                !globResult.llmContent.startsWith('Error:')
-              ) {
-                const lines = globResult.llmContent.split('\n');
-                if (lines.length > 1 && lines[1]) {
-                  const firstMatchAbsolute = lines[1].trim();
-                  currentPathSpec = path.relative(
-                    this.config.getTargetDir(),
-                    firstMatchAbsolute,
-                  );
-                  this.debug(
-                    `Glob search for ${pathName} found ${firstMatchAbsolute}, using relative path: ${currentPathSpec}`,
-                  );
-                  resolvedSuccessfully = true;
-                } else {
-                  this.debug(
-                    `Glob search for '**/*${pathName}*' did not return a usable path. Path ${pathName} will be skipped.`,
-                  );
-                }
-              } else {
-                this.debug(
-                  `Glob search for '**/*${pathName}*' found no files or an error. Path ${pathName} will be skipped.`,
-                );
-              }
-            } catch (globError) {
-              console.error(
-                `Error during glob search for ${pathName}: ${getErrorMessage(globError)}`,
-              );
-            }
-          } else {
-            this.debug(
-              `Glob tool not found. Path ${pathName} will be skipped.`,
-            );
-          }
-        } else {
-          console.error(
-            `Error stating path ${pathName}. Path ${pathName} will be skipped.`,
-          );
-        }
-      }
-      if (resolvedSuccessfully) {
-        pathSpecsToRead.push(currentPathSpec);
-        atPathToResolvedSpecMap.set(pathName, currentPathSpec);
-        contentLabelsForDisplay.push(pathName);
-      }
-    }
-
-    // Construct the initial part of the query for the LLM
-    let initialQueryText = '';
-    for (let i = 0; i < parts.length; i++) {
-      const chunk = parts[i];
-      if ('text' in chunk) {
-        initialQueryText += chunk.text;
-      } else {
-        // type === 'atPath'
-        const resolvedSpec =
-          chunk.fileData && atPathToResolvedSpecMap.get(chunk.fileData.fileUri);
-        if (
-          i > 0 &&
-          initialQueryText.length > 0 &&
-          !initialQueryText.endsWith(' ') &&
-          resolvedSpec
-        ) {
-          // Add space if previous part was text and didn't end with space, or if previous was @path
-          const prevPart = parts[i - 1];
-          if (
-            'text' in prevPart ||
-            ('fileData' in prevPart &&
-              atPathToResolvedSpecMap.has(prevPart.fileData!.fileUri))
-          ) {
-            initialQueryText += ' ';
-          }
-        }
-        // Append the resolved path spec for display purposes
-        if (resolvedSpec) {
-          initialQueryText += `@${resolvedSpec}`;
-        }
-      }
-    }
-
-    // Handle ignored paths message
-    let ignoredPathsMessage = '';
-    if (ignoredPaths.length > 0) {
-      const pathList = ignoredPaths.map((p) => `- ${p}`).join('\n');
-      ignoredPathsMessage = `Note: The following paths were skipped because they are ignored:\n${pathList}\n\n`;
-    }
-
-    const processedQueryParts: Part[] = [];
-
-    // Read files using read_many_files tool
-    if (pathSpecsToRead.length > 0) {
-      const readResult = await readManyFilesTool.buildAndExecute(
-        {
-          paths_with_line_ranges: pathSpecsToRead,
-        },
-        abortSignal,
-      );
-
-      const contentForLlm =
-        typeof readResult.llmContent === 'string'
-          ? readResult.llmContent
-          : JSON.stringify(readResult.llmContent);
-
-      // Combine content label, ignored paths message, file content, and user query
-      const combinedText = `${ignoredPathsMessage}${contentForLlm}`.trim();
-      processedQueryParts.push({ text: combinedText });
-      processedQueryParts.push({ text: initialQueryText });
-    } else if (embeddedContext.length > 0) {
-      // No @path files to read, but we have embedded context
-      processedQueryParts.push({
-        text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
-      });
-    } else {
-      // No @path files found or resolved
-      processedQueryParts.push({
-        text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
-      });
-    }
-
-    // Process embedded context from resource blocks
-    for (const contextPart of embeddedContext) {
-      // Type guard for text resources
-      if ('text' in contextPart && contextPart.text) {
-        processedQueryParts.push({
-          text: `File: ${contextPart.uri}\n${contextPart.text}`,
-        });
-      }
-      // Type guard for blob resources
-      if ('blob' in contextPart && contextPart.blob) {
-        processedQueryParts.push({
-          inlineData: {
-            mimeType: contextPart.mimeType ?? 'application/octet-stream',
-            data: contextPart.blob,
-          },
-        });
-      }
-    }
-
-    return processedQueryParts;
-  }
-
-  debug(msg: string): void {
-    if (this.config.getDebugMode()) {
-      console.warn(msg);
-    }
-  }
-}
-
-// ============================================================================
-// Helper functions
-// ============================================================================
-
-const basicPermissionOptions = [
-  {
-    optionId: ToolConfirmationOutcome.ProceedOnce,
-    name: 'Allow',
-    kind: 'allow_once',
-  },
-  {
-    optionId: ToolConfirmationOutcome.Cancel,
-    name: 'Reject',
-    kind: 'reject_once',
-  },
-] as const;
-
-function toPermissionOptions(
-  confirmation: ToolCallConfirmationDetails,
-): acp.PermissionOption[] {
-  switch (confirmation.type) {
-    case 'edit':
-      return [
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlways,
-          name: 'Allow All Edits',
-          kind: 'allow_always',
-        },
-        ...basicPermissionOptions,
-      ];
-    case 'exec':
-      return [
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlways,
-          name: `Always Allow ${confirmation.rootCommand}`,
-          kind: 'allow_always',
-        },
-        ...basicPermissionOptions,
-      ];
-    case 'mcp':
-      return [
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
-          name: `Always Allow ${confirmation.serverName}`,
-          kind: 'allow_always',
-        },
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
-          name: `Always Allow ${confirmation.toolName}`,
-          kind: 'allow_always',
-        },
-        ...basicPermissionOptions,
-      ];
-    case 'info':
-      return [
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlways,
-          name: `Always Allow`,
-          kind: 'allow_always',
-        },
-        ...basicPermissionOptions,
-      ];
-    case 'plan':
-      return [
-        {
-          optionId: ToolConfirmationOutcome.ProceedAlways,
-          name: `Yes, and auto-accept edits`,
-          kind: 'allow_always',
-        },
-        {
-          optionId: ToolConfirmationOutcome.ProceedOnce,
-          name: `Yes, and manually approve edits`,
-          kind: 'allow_once',
-        },
-        {
-          optionId: ToolConfirmationOutcome.Cancel,
-          name: `No, keep planning (esc)`,
-          kind: 'reject_once',
-        },
-      ];
-    default: {
-      const unreachable: never = confirmation;
-      throw new Error(`Unexpected: ${unreachable}`);
-    }
-  }
-}
--- a/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts
+++ b/packages/cli/src/acp-integration/session/SubAgentTracker.test.ts
@@ -1,525 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { SubAgentTracker } from './SubAgentTracker.js';
-import type { SessionContext } from './types.js';
-import type {
-  Config,
-  ToolRegistry,
-  SubAgentEventEmitter,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentApprovalRequestEvent,
-  ToolEditConfirmationDetails,
-  ToolInfoConfirmationDetails,
-} from '@qwen-code/qwen-code-core';
-import {
-  SubAgentEventType,
-  ToolConfirmationOutcome,
-  TodoWriteTool,
-} from '@qwen-code/qwen-code-core';
-import type * as acp from '../acp.js';
-import { EventEmitter } from 'node:events';
-
-// Helper to create a mock SubAgentToolCallEvent with required fields
-function createToolCallEvent(
-  overrides: Partial<SubAgentToolCallEvent> & { name: string; callId: string },
-): SubAgentToolCallEvent {
-  return {
-    subagentId: 'test-subagent',
-    round: 1,
-    timestamp: Date.now(),
-    description: `Calling ${overrides.name}`,
-    args: {},
-    ...overrides,
-  };
-}
-
-// Helper to create a mock SubAgentToolResultEvent with required fields
-function createToolResultEvent(
-  overrides: Partial<SubAgentToolResultEvent> & {
-    name: string;
-    callId: string;
-    success: boolean;
-  },
-): SubAgentToolResultEvent {
-  return {
-    subagentId: 'test-subagent',
-    round: 1,
-    timestamp: Date.now(),
-    ...overrides,
-  };
-}
-
-// Helper to create a mock SubAgentApprovalRequestEvent with required fields
-function createApprovalEvent(
-  overrides: Partial<SubAgentApprovalRequestEvent> & {
-    name: string;
-    callId: string;
-    confirmationDetails: SubAgentApprovalRequestEvent['confirmationDetails'];
-    respond: SubAgentApprovalRequestEvent['respond'];
-  },
-): SubAgentApprovalRequestEvent {
-  return {
-    subagentId: 'test-subagent',
-    round: 1,
-    timestamp: Date.now(),
-    description: `Awaiting approval for ${overrides.name}`,
-    ...overrides,
-  };
-}
-
-// Helper to create edit confirmation details
-function createEditConfirmation(
-  overrides: Partial<Omit<ToolEditConfirmationDetails, 'onConfirm' | 'type'>>,
-): Omit<ToolEditConfirmationDetails, 'onConfirm'> {
-  return {
-    type: 'edit',
-    title: 'Edit file',
-    fileName: '/test.ts',
-    filePath: '/test.ts',
-    fileDiff: '',
-    originalContent: '',
-    newContent: '',
-    ...overrides,
-  };
-}
-
-// Helper to create info confirmation details
-function createInfoConfirmation(
-  overrides?: Partial<Omit<ToolInfoConfirmationDetails, 'onConfirm' | 'type'>>,
-): Omit<ToolInfoConfirmationDetails, 'onConfirm'> {
-  return {
-    type: 'info',
-    title: 'Tool requires approval',
-    prompt: 'Allow this action?',
-    ...overrides,
-  };
-}
-
-describe('SubAgentTracker', () => {
-  let mockContext: SessionContext;
-  let mockClient: acp.Client;
-  let sendUpdateSpy: ReturnType<typeof vi.fn>;
-  let requestPermissionSpy: ReturnType<typeof vi.fn>;
-  let tracker: SubAgentTracker;
-  let eventEmitter: SubAgentEventEmitter;
-  let abortController: AbortController;
-
-  beforeEach(() => {
-    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
-    requestPermissionSpy = vi.fn().mockResolvedValue({
-      outcome: { optionId: ToolConfirmationOutcome.ProceedOnce },
-    });
-
-    const mockToolRegistry = {
-      getTool: vi.fn().mockReturnValue(null),
-    } as unknown as ToolRegistry;
-
-    mockContext = {
-      sessionId: 'test-session-id',
-      config: {
-        getToolRegistry: () => mockToolRegistry,
-      } as unknown as Config,
-      sendUpdate: sendUpdateSpy,
-    };
-
-    mockClient = {
-      requestPermission: requestPermissionSpy,
-    } as unknown as acp.Client;
-
-    tracker = new SubAgentTracker(mockContext, mockClient);
-    eventEmitter = new EventEmitter() as unknown as SubAgentEventEmitter;
-    abortController = new AbortController();
-  });
-
-  describe('setup', () => {
-    it('should return cleanup function', () => {
-      const cleanups = tracker.setup(eventEmitter, abortController.signal);
-
-      expect(cleanups).toHaveLength(1);
-      expect(typeof cleanups[0]).toBe('function');
-    });
-
-    it('should register event listeners', () => {
-      const onSpy = vi.spyOn(eventEmitter, 'on');
-
-      tracker.setup(eventEmitter, abortController.signal);
-
-      expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_CALL,
-        expect.any(Function),
-      );
-      expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_RESULT,
-        expect.any(Function),
-      );
-      expect(onSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_WAITING_APPROVAL,
-        expect.any(Function),
-      );
-    });
-
-    it('should remove event listeners on cleanup', () => {
-      const offSpy = vi.spyOn(eventEmitter, 'off');
-      const cleanups = tracker.setup(eventEmitter, abortController.signal);
-
-      cleanups[0]();
-
-      expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_CALL,
-        expect.any(Function),
-      );
-      expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_RESULT,
-        expect.any(Function),
-      );
-      expect(offSpy).toHaveBeenCalledWith(
-        SubAgentEventType.TOOL_WAITING_APPROVAL,
-        expect.any(Function),
-      );
-    });
-  });
-
-  describe('tool call handling', () => {
-    it('should emit tool_call on TOOL_CALL event', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const event = createToolCallEvent({
-        name: 'read_file',
-        callId: 'call-123',
-        args: { path: '/test.ts' },
-        description: 'Reading file',
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
-
-      // Allow async operations to complete
-      await vi.waitFor(() => {
-        expect(sendUpdateSpy).toHaveBeenCalled();
-      });
-
-      // ToolCallEmitter resolves metadata from registry - uses toolName when tool not found
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call',
-          toolCallId: 'call-123',
-          status: 'in_progress',
-          title: 'read_file',
-          content: [],
-          locations: [],
-          kind: 'other',
-          rawInput: { path: '/test.ts' },
-        }),
-      );
-    });
-
-    it('should skip tool_call for TodoWriteTool', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const event = createToolCallEvent({
-        name: TodoWriteTool.Name,
-        callId: 'call-todo',
-        args: { todos: [] },
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
-
-      // Give time for any async operation
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-
-    it('should not emit when aborted', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-      abortController.abort();
-
-      const event = createToolCallEvent({
-        name: 'read_file',
-        callId: 'call-123',
-        args: {},
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_CALL, event);
-
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('tool result handling', () => {
-    it('should emit tool_call_update on TOOL_RESULT event', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      // First emit tool call to store state
-      eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
-        createToolCallEvent({
-          name: 'read_file',
-          callId: 'call-123',
-          args: { path: '/test.ts' },
-        }),
-      );
-
-      // Then emit result
-      const resultEvent = createToolResultEvent({
-        name: 'read_file',
-        callId: 'call-123',
-        success: true,
-        resultDisplay: 'File contents',
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
-
-      await vi.waitFor(() => {
-        expect(sendUpdateSpy).toHaveBeenCalledWith(
-          expect.objectContaining({
-            sessionUpdate: 'tool_call_update',
-            toolCallId: 'call-123',
-            status: 'completed',
-          }),
-        );
-      });
-    });
-
-    it('should emit failed status on unsuccessful result', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const resultEvent = createToolResultEvent({
-        name: 'read_file',
-        callId: 'call-fail',
-        success: false,
-        resultDisplay: undefined,
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
-
-      await vi.waitFor(() => {
-        expect(sendUpdateSpy).toHaveBeenCalledWith(
-          expect.objectContaining({
-            sessionUpdate: 'tool_call_update',
-            status: 'failed',
-          }),
-        );
-      });
-    });
-
-    it('should emit plan update for TodoWriteTool results', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      // Store args via tool call
-      eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
-        createToolCallEvent({
-          name: TodoWriteTool.Name,
-          callId: 'call-todo',
-          args: {
-            todos: [{ id: '1', content: 'Task 1', status: 'pending' }],
-          },
-        }),
-      );
-
-      // Emit result with todo_list display
-      const resultEvent = createToolResultEvent({
-        name: TodoWriteTool.Name,
-        callId: 'call-todo',
-        success: true,
-        resultDisplay: JSON.stringify({
-          type: 'todo_list',
-          todos: [{ id: '1', content: 'Task 1', status: 'completed' }],
-        }),
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_RESULT, resultEvent);
-
-      await vi.waitFor(() => {
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'plan',
-          entries: [
-            { content: 'Task 1', priority: 'medium', status: 'completed' },
-          ],
-        });
-      });
-    });
-
-    it('should clean up state after result', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      eventEmitter.emit(
-        SubAgentEventType.TOOL_CALL,
-        createToolCallEvent({
-          name: 'test_tool',
-          callId: 'call-cleanup',
-          args: { test: true },
-        }),
-      );
-
-      eventEmitter.emit(
-        SubAgentEventType.TOOL_RESULT,
-        createToolResultEvent({
-          name: 'test_tool',
-          callId: 'call-cleanup',
-          success: true,
-        }),
-      );
-
-      // Emit another result for same callId - should not have stored args
-      sendUpdateSpy.mockClear();
-      eventEmitter.emit(
-        SubAgentEventType.TOOL_RESULT,
-        createToolResultEvent({
-          name: 'test_tool',
-          callId: 'call-cleanup',
-          success: true,
-        }),
-      );
-
-      await vi.waitFor(() => {
-        expect(sendUpdateSpy).toHaveBeenCalled();
-      });
-
-      // Second call should not have args from first call
-      // (state was cleaned up)
-    });
-  });
-
-  describe('approval handling', () => {
-    it('should request permission from client', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const respondSpy = vi.fn().mockResolvedValue(undefined);
-      const event = createApprovalEvent({
-        name: 'edit_file',
-        callId: 'call-edit',
-        description: 'Editing file',
-        confirmationDetails: createEditConfirmation({
-          fileName: '/test.ts',
-          originalContent: 'old',
-          newContent: 'new',
-        }),
-        respond: respondSpy,
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
-
-      await vi.waitFor(() => {
-        expect(requestPermissionSpy).toHaveBeenCalled();
-      });
-
-      expect(requestPermissionSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionId: 'test-session-id',
-          toolCall: expect.objectContaining({
-            toolCallId: 'call-edit',
-            status: 'pending',
-            content: [
-              {
-                type: 'diff',
-                path: '/test.ts',
-                oldText: 'old',
-                newText: 'new',
-              },
-            ],
-          }),
-        }),
-      );
-    });
-
-    it('should respond to subagent with permission outcome', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const respondSpy = vi.fn().mockResolvedValue(undefined);
-      const event = createApprovalEvent({
-        name: 'test_tool',
-        callId: 'call-123',
-        confirmationDetails: createInfoConfirmation(),
-        respond: respondSpy,
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
-
-      await vi.waitFor(() => {
-        expect(respondSpy).toHaveBeenCalledWith(
-          ToolConfirmationOutcome.ProceedOnce,
-        );
-      });
-    });
-
-    it('should cancel on permission request failure', async () => {
-      requestPermissionSpy.mockRejectedValue(new Error('Network error'));
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const respondSpy = vi.fn().mockResolvedValue(undefined);
-      const event = createApprovalEvent({
-        name: 'test_tool',
-        callId: 'call-123',
-        confirmationDetails: createInfoConfirmation(),
-        respond: respondSpy,
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
-
-      await vi.waitFor(() => {
-        expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
-      });
-    });
-
-    it('should handle cancelled outcome from client', async () => {
-      requestPermissionSpy.mockResolvedValue({
-        outcome: { outcome: 'cancelled' },
-      });
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const respondSpy = vi.fn().mockResolvedValue(undefined);
-      const event = createApprovalEvent({
-        name: 'test_tool',
-        callId: 'call-123',
-        confirmationDetails: createInfoConfirmation(),
-        respond: respondSpy,
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
-
-      await vi.waitFor(() => {
-        expect(respondSpy).toHaveBeenCalledWith(ToolConfirmationOutcome.Cancel);
-      });
-    });
-  });
-
-  describe('permission options', () => {
-    it('should include "Allow All Edits" for edit type', async () => {
-      tracker.setup(eventEmitter, abortController.signal);
-
-      const event = createApprovalEvent({
-        name: 'edit_file',
-        callId: 'call-123',
-        confirmationDetails: createEditConfirmation({
-          fileName: '/test.ts',
-          originalContent: '',
-          newContent: 'new',
-        }),
-        respond: vi.fn(),
-      });
-
-      eventEmitter.emit(SubAgentEventType.TOOL_WAITING_APPROVAL, event);
-
-      await vi.waitFor(() => {
-        expect(requestPermissionSpy).toHaveBeenCalled();
-      });
-
-      const call = requestPermissionSpy.mock.calls[0][0];
-      expect(call.options).toContainEqual(
-        expect.objectContaining({
-          optionId: ToolConfirmationOutcome.ProceedAlways,
-          name: 'Allow All Edits',
-        }),
-      );
-    });
-  });
-});
--- a/packages/cli/src/acp-integration/session/SubAgentTracker.ts
+++ b/packages/cli/src/acp-integration/session/SubAgentTracker.ts
@@ -1,318 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  SubAgentEventEmitter,
-  SubAgentToolCallEvent,
-  SubAgentToolResultEvent,
-  SubAgentApprovalRequestEvent,
-  ToolCallConfirmationDetails,
-  AnyDeclarativeTool,
-  AnyToolInvocation,
-} from '@qwen-code/qwen-code-core';
-import {
-  SubAgentEventType,
-  ToolConfirmationOutcome,
-} from '@qwen-code/qwen-code-core';
-import { z } from 'zod';
-import type { SessionContext } from './types.js';
-import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
-import type * as acp from '../acp.js';
-
-/**
- * Permission option kind type matching ACP schema.
- */
-type PermissionKind =
-  | 'allow_once'
-  | 'reject_once'
-  | 'allow_always'
-  | 'reject_always';
-
-/**
- * Configuration for permission options displayed to users.
- */
-interface PermissionOptionConfig {
-  optionId: ToolConfirmationOutcome;
-  name: string;
-  kind: PermissionKind;
-}
-
-const basicPermissionOptions: readonly PermissionOptionConfig[] = [
-  {
-    optionId: ToolConfirmationOutcome.ProceedOnce,
-    name: 'Allow',
-    kind: 'allow_once',
-  },
-  {
-    optionId: ToolConfirmationOutcome.Cancel,
-    name: 'Reject',
-    kind: 'reject_once',
-  },
-] as const;
-
-/**
- * Tracks and emits events for sub-agent tool calls within TaskTool execution.
- *
- * Uses the unified ToolCallEmitter for consistency with normal flow
- * and history replay. Also handles permission requests for tools that
- * require user approval.
- */
-export class SubAgentTracker {
-  private readonly toolCallEmitter: ToolCallEmitter;
-  private readonly toolStates = new Map<
-    string,
-    {
-      tool?: AnyDeclarativeTool;
-      invocation?: AnyToolInvocation;
-      args?: Record<string, unknown>;
-    }
-  >();
-
-  constructor(
-    private readonly ctx: SessionContext,
-    private readonly client: acp.Client,
-  ) {
-    this.toolCallEmitter = new ToolCallEmitter(ctx);
-  }
-
-  /**
-   * Sets up event listeners for a sub-agent's tool events.
-   *
-   * @param eventEmitter - The SubAgentEventEmitter from TaskTool
-   * @param abortSignal - Signal to abort tracking if parent is cancelled
-   * @returns Array of cleanup functions to remove listeners
-   */
-  setup(
-    eventEmitter: SubAgentEventEmitter,
-    abortSignal: AbortSignal,
-  ): Array<() => void> {
-    const onToolCall = this.createToolCallHandler(abortSignal);
-    const onToolResult = this.createToolResultHandler(abortSignal);
-    const onApproval = this.createApprovalHandler(abortSignal);
-
-    eventEmitter.on(SubAgentEventType.TOOL_CALL, onToolCall);
-    eventEmitter.on(SubAgentEventType.TOOL_RESULT, onToolResult);
-    eventEmitter.on(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
-
-    return [
-      () => {
-        eventEmitter.off(SubAgentEventType.TOOL_CALL, onToolCall);
-        eventEmitter.off(SubAgentEventType.TOOL_RESULT, onToolResult);
-        eventEmitter.off(SubAgentEventType.TOOL_WAITING_APPROVAL, onApproval);
-        // Clean up any remaining states
-        this.toolStates.clear();
-      },
-    ];
-  }
-
-  /**
-   * Creates a handler for tool call start events.
-   */
-  private createToolCallHandler(
-    abortSignal: AbortSignal,
-  ): (...args: unknown[]) => void {
-    return (...args: unknown[]) => {
-      const event = args[0] as SubAgentToolCallEvent;
-      if (abortSignal.aborted) return;
-
-      // Look up tool and build invocation for metadata
-      const toolRegistry = this.ctx.config.getToolRegistry();
-      const tool = toolRegistry.getTool(event.name);
-      let invocation: AnyToolInvocation | undefined;
-
-      if (tool) {
-        try {
-          invocation = tool.build(event.args);
-        } catch (e) {
-          // If building fails, continue with defaults
-          console.warn(`Failed to build subagent tool ${event.name}:`, e);
-        }
-      }
-
-      // Store tool, invocation, and args for result handling
-      this.toolStates.set(event.callId, {
-        tool,
-        invocation,
-        args: event.args,
-      });
-
-      // Use unified emitter - handles TodoWriteTool skipping internally
-      void this.toolCallEmitter.emitStart({
-        toolName: event.name,
-        callId: event.callId,
-        args: event.args,
-      });
-    };
-  }
-
-  /**
-   * Creates a handler for tool result events.
-   */
-  private createToolResultHandler(
-    abortSignal: AbortSignal,
-  ): (...args: unknown[]) => void {
-    return (...args: unknown[]) => {
-      const event = args[0] as SubAgentToolResultEvent;
-      if (abortSignal.aborted) return;
-
-      const state = this.toolStates.get(event.callId);
-
-      // Use unified emitter - handles TodoWriteTool plan updates internally
-      void this.toolCallEmitter.emitResult({
-        toolName: event.name,
-        callId: event.callId,
-        success: event.success,
-        message: event.responseParts ?? [],
-        resultDisplay: event.resultDisplay,
-        args: state?.args,
-      });
-
-      // Clean up state
-      this.toolStates.delete(event.callId);
-    };
-  }
-
-  /**
-   * Creates a handler for tool approval request events.
-   */
-  private createApprovalHandler(
-    abortSignal: AbortSignal,
-  ): (...args: unknown[]) => Promise<void> {
-    return async (...args: unknown[]) => {
-      const event = args[0] as SubAgentApprovalRequestEvent;
-      if (abortSignal.aborted) return;
-
-      const state = this.toolStates.get(event.callId);
-      const content: acp.ToolCallContent[] = [];
-
-      // Handle edit confirmation type - show diff
-      if (event.confirmationDetails.type === 'edit') {
-        const editDetails = event.confirmationDetails as unknown as {
-          type: 'edit';
-          fileName: string;
-          originalContent: string | null;
-          newContent: string;
-        };
-        content.push({
-          type: 'diff',
-          path: editDetails.fileName,
-          oldText: editDetails.originalContent ?? '',
-          newText: editDetails.newContent,
-        });
-      }
-
-      // Build permission request
-      const fullConfirmationDetails = {
-        ...event.confirmationDetails,
-        onConfirm: async () => {
-          // Placeholder - actual response handled via event.respond
-        },
-      } as unknown as ToolCallConfirmationDetails;
-
-      const { title, locations, kind } =
-        this.toolCallEmitter.resolveToolMetadata(event.name, state?.args);
-
-      const params: acp.RequestPermissionRequest = {
-        sessionId: this.ctx.sessionId,
-        options: this.toPermissionOptions(fullConfirmationDetails),
-        toolCall: {
-          toolCallId: event.callId,
-          status: 'pending',
-          title,
-          content,
-          locations,
-          kind,
-          rawInput: state?.args,
-        },
-      };
-
-      try {
-        // Request permission from client
-        const output = await this.client.requestPermission(params);
-        const outcome =
-          output.outcome.outcome === 'cancelled'
-            ? ToolConfirmationOutcome.Cancel
-            : z
-                .nativeEnum(ToolConfirmationOutcome)
-                .parse(output.outcome.optionId);
-
-        // Respond to subagent with the outcome
-        await event.respond(outcome);
-      } catch (error) {
-        // If permission request fails, cancel the tool call
-        console.error(
-          `Permission request failed for subagent tool ${event.name}:`,
-          error,
-        );
-        await event.respond(ToolConfirmationOutcome.Cancel);
-      }
-    };
-  }
-
-  /**
-   * Converts confirmation details to permission options for the client.
-   */
-  private toPermissionOptions(
-    confirmation: ToolCallConfirmationDetails,
-  ): acp.PermissionOption[] {
-    switch (confirmation.type) {
-      case 'edit':
-        return [
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlways,
-            name: 'Allow All Edits',
-            kind: 'allow_always',
-          },
-          ...basicPermissionOptions,
-        ];
-      case 'exec':
-        return [
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlways,
-            name: `Always Allow ${(confirmation as { rootCommand?: string }).rootCommand ?? 'command'}`,
-            kind: 'allow_always',
-          },
-          ...basicPermissionOptions,
-        ];
-      case 'mcp':
-        return [
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
-            name: `Always Allow ${(confirmation as { serverName?: string }).serverName ?? 'server'}`,
-            kind: 'allow_always',
-          },
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
-            name: `Always Allow ${(confirmation as { toolName?: string }).toolName ?? 'tool'}`,
-            kind: 'allow_always',
-          },
-          ...basicPermissionOptions,
-        ];
-      case 'info':
-        return [
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlways,
-            name: 'Always Allow',
-            kind: 'allow_always',
-          },
-          ...basicPermissionOptions,
-        ];
-      case 'plan':
-        return [
-          {
-            optionId: ToolConfirmationOutcome.ProceedAlways,
-            name: 'Always Allow Plans',
-            kind: 'allow_always',
-          },
-          ...basicPermissionOptions,
-        ];
-      default: {
-        // Fallback for unknown types
-        return [...basicPermissionOptions];
-      }
-    }
-  }
-}
--- a/packages/cli/src/acp-integration/session/emitters/BaseEmitter.ts
+++ b/packages/cli/src/acp-integration/session/emitters/BaseEmitter.ts
@@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { SessionContext } from '../types.js';
-import type * as acp from '../../acp.js';
-
-/**
- * Abstract base class for all session event emitters.
- * Provides common functionality and access to session context.
- */
-export abstract class BaseEmitter {
-  constructor(protected readonly ctx: SessionContext) {}
-
-  /**
-   * Sends a session update to the ACP client.
-   */
-  protected async sendUpdate(update: acp.SessionUpdate): Promise<void> {
-    return this.ctx.sendUpdate(update);
-  }
-
-  /**
-   * Gets the session configuration.
-   */
-  protected get config() {
-    return this.ctx.config;
-  }
-
-  /**
-   * Gets the session ID.
-   */
-  protected get sessionId() {
-    return this.ctx.sessionId;
-  }
-}
--- a/packages/cli/src/acp-integration/session/emitters/MessageEmitter.test.ts
+++ b/packages/cli/src/acp-integration/session/emitters/MessageEmitter.test.ts
@@ -1,151 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MessageEmitter } from './MessageEmitter.js';
-import type { SessionContext } from '../types.js';
-import type { Config } from '@qwen-code/qwen-code-core';
-
-describe('MessageEmitter', () => {
-  let mockContext: SessionContext;
-  let sendUpdateSpy: ReturnType<typeof vi.fn>;
-  let emitter: MessageEmitter;
-
-  beforeEach(() => {
-    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
-    mockContext = {
-      sessionId: 'test-session-id',
-      config: {} as Config,
-      sendUpdate: sendUpdateSpy,
-    };
-    emitter = new MessageEmitter(mockContext);
-  });
-
-  describe('emitUserMessage', () => {
-    it('should send user_message_chunk update with text content', async () => {
-      await emitter.emitUserMessage('Hello, world!');
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: 'Hello, world!' },
-      });
-    });
-
-    it('should handle empty text', async () => {
-      await emitter.emitUserMessage('');
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: '' },
-      });
-    });
-
-    it('should handle multiline text', async () => {
-      const multilineText = 'Line 1\nLine 2\nLine 3';
-      await emitter.emitUserMessage(multilineText);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: multilineText },
-      });
-    });
-  });
-
-  describe('emitAgentMessage', () => {
-    it('should send agent_message_chunk update with text content', async () => {
-      await emitter.emitAgentMessage('I can help you with that.');
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'I can help you with that.' },
-      });
-    });
-  });
-
-  describe('emitAgentThought', () => {
-    it('should send agent_thought_chunk update with text content', async () => {
-      await emitter.emitAgentThought('Let me think about this...');
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_thought_chunk',
-        content: { type: 'text', text: 'Let me think about this...' },
-      });
-    });
-  });
-
-  describe('emitMessage', () => {
-    it('should emit user message when role is user', async () => {
-      await emitter.emitMessage('User input', 'user');
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: 'User input' },
-      });
-    });
-
-    it('should emit agent message when role is assistant and isThought is false', async () => {
-      await emitter.emitMessage('Agent response', 'assistant', false);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'Agent response' },
-      });
-    });
-
-    it('should emit agent message when role is assistant and isThought is not provided', async () => {
-      await emitter.emitMessage('Agent response', 'assistant');
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'Agent response' },
-      });
-    });
-
-    it('should emit agent thought when role is assistant and isThought is true', async () => {
-      await emitter.emitAgentThought('Thinking...');
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'agent_thought_chunk',
-        content: { type: 'text', text: 'Thinking...' },
-      });
-    });
-
-    it('should ignore isThought when role is user', async () => {
-      // Even if isThought is true, user messages should still be user_message_chunk
-      await emitter.emitMessage('User input', 'user', true);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: 'User input' },
-      });
-    });
-  });
-
-  describe('multiple emissions', () => {
-    it('should handle multiple sequential emissions', async () => {
-      await emitter.emitUserMessage('First');
-      await emitter.emitAgentMessage('Second');
-      await emitter.emitAgentThought('Third');
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(3);
-      expect(sendUpdateSpy).toHaveBeenNthCalledWith(1, {
-        sessionUpdate: 'user_message_chunk',
-        content: { type: 'text', text: 'First' },
-      });
-      expect(sendUpdateSpy).toHaveBeenNthCalledWith(2, {
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'Second' },
-      });
-      expect(sendUpdateSpy).toHaveBeenNthCalledWith(3, {
-        sessionUpdate: 'agent_thought_chunk',
-        content: { type: 'text', text: 'Third' },
-      });
-    });
-  });
-});
--- a/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+++ b/packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
@@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { BaseEmitter } from './BaseEmitter.js';
-
-/**
- * Handles emission of text message chunks (user, agent, thought).
- *
- * This emitter is responsible for sending message content to the ACP client
- * in a consistent format, regardless of whether the message comes from
- * normal flow, history replay, or other sources.
- */
-export class MessageEmitter extends BaseEmitter {
-  /**
-   * Emits a user message chunk.
-   */
-  async emitUserMessage(text: string): Promise<void> {
-    await this.sendUpdate({
-      sessionUpdate: 'user_message_chunk',
-      content: { type: 'text', text },
-    });
-  }
-
-  /**
-   * Emits an agent message chunk.
-   */
-  async emitAgentMessage(text: string): Promise<void> {
-    await this.sendUpdate({
-      sessionUpdate: 'agent_message_chunk',
-      content: { type: 'text', text },
-    });
-  }
-
-  /**
-   * Emits an agent thought chunk.
-   */
-  async emitAgentThought(text: string): Promise<void> {
-    await this.sendUpdate({
-      sessionUpdate: 'agent_thought_chunk',
-      content: { type: 'text', text },
-    });
-  }
-
-  /**
-   * Emits a message chunk based on role and thought flag.
-   * This is the unified method that handles all message types.
-   *
-   * @param text - The message text content
-   * @param role - Whether this is a user or assistant message
-   * @param isThought - Whether this is an assistant thought (only applies to assistant role)
-   */
-  async emitMessage(
-    text: string,
-    role: 'user' | 'assistant',
-    isThought: boolean = false,
-  ): Promise<void> {
-    if (role === 'user') {
-      return this.emitUserMessage(text);
-    }
-    return isThought
-      ? this.emitAgentThought(text)
-      : this.emitAgentMessage(text);
-  }
-}
--- a/packages/cli/src/acp-integration/session/emitters/PlanEmitter.test.ts
+++ b/packages/cli/src/acp-integration/session/emitters/PlanEmitter.test.ts
@@ -1,228 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { PlanEmitter } from './PlanEmitter.js';
-import type { SessionContext, TodoItem } from '../types.js';
-import type { Config } from '@qwen-code/qwen-code-core';
-
-describe('PlanEmitter', () => {
-  let mockContext: SessionContext;
-  let sendUpdateSpy: ReturnType<typeof vi.fn>;
-  let emitter: PlanEmitter;
-
-  beforeEach(() => {
-    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
-    mockContext = {
-      sessionId: 'test-session-id',
-      config: {} as Config,
-      sendUpdate: sendUpdateSpy,
-    };
-    emitter = new PlanEmitter(mockContext);
-  });
-
-  describe('emitPlan', () => {
-    it('should send plan update with converted todo entries', async () => {
-      const todos: TodoItem[] = [
-        { id: '1', content: 'First task', status: 'pending' },
-        { id: '2', content: 'Second task', status: 'in_progress' },
-        { id: '3', content: 'Third task', status: 'completed' },
-      ];
-
-      await emitter.emitPlan(todos);
-
-      expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'plan',
-        entries: [
-          { content: 'First task', priority: 'medium', status: 'pending' },
-          { content: 'Second task', priority: 'medium', status: 'in_progress' },
-          { content: 'Third task', priority: 'medium', status: 'completed' },
-        ],
-      });
-    });
-
-    it('should handle empty todos array', async () => {
-      await emitter.emitPlan([]);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'plan',
-        entries: [],
-      });
-    });
-
-    it('should set default priority to medium for all entries', async () => {
-      const todos: TodoItem[] = [
-        { id: '1', content: 'Task', status: 'pending' },
-      ];
-
-      await emitter.emitPlan(todos);
-
-      const call = sendUpdateSpy.mock.calls[0][0];
-      expect(call.entries[0].priority).toBe('medium');
-    });
-  });
-
-  describe('extractTodos', () => {
-    describe('from resultDisplay object', () => {
-      it('should extract todos from valid todo_list object', () => {
-        const resultDisplay = {
-          type: 'todo_list',
-          todos: [
-            { id: '1', content: 'Task 1', status: 'pending' as const },
-            { id: '2', content: 'Task 2', status: 'completed' as const },
-          ],
-        };
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toEqual([
-          { id: '1', content: 'Task 1', status: 'pending' },
-          { id: '2', content: 'Task 2', status: 'completed' },
-        ]);
-      });
-
-      it('should return null for object without type todo_list', () => {
-        const resultDisplay = {
-          type: 'other',
-          todos: [],
-        };
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toBeNull();
-      });
-
-      it('should return null for object without todos array', () => {
-        const resultDisplay = {
-          type: 'todo_list',
-          items: [], // wrong key
-        };
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toBeNull();
-      });
-    });
-
-    describe('from resultDisplay JSON string', () => {
-      it('should extract todos from valid JSON string', () => {
-        const resultDisplay = JSON.stringify({
-          type: 'todo_list',
-          todos: [{ id: '1', content: 'Task', status: 'pending' }],
-        });
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toEqual([
-          { id: '1', content: 'Task', status: 'pending' },
-        ]);
-      });
-
-      it('should return null for invalid JSON string', () => {
-        const resultDisplay = 'not valid json';
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toBeNull();
-      });
-
-      it('should return null for JSON without todo_list type', () => {
-        const resultDisplay = JSON.stringify({
-          type: 'other',
-          data: {},
-        });
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toBeNull();
-      });
-    });
-
-    describe('from args fallback', () => {
-      it('should extract todos from args when resultDisplay is null', () => {
-        const args = {
-          todos: [{ id: '1', content: 'From args', status: 'pending' }],
-        };
-
-        const result = emitter.extractTodos(null, args);
-
-        expect(result).toEqual([
-          { id: '1', content: 'From args', status: 'pending' },
-        ]);
-      });
-
-      it('should extract todos from args when resultDisplay is undefined', () => {
-        const args = {
-          todos: [{ id: '1', content: 'From args', status: 'pending' }],
-        };
-
-        const result = emitter.extractTodos(undefined, args);
-
-        expect(result).toEqual([
-          { id: '1', content: 'From args', status: 'pending' },
-        ]);
-      });
-
-      it('should prefer resultDisplay over args', () => {
-        const resultDisplay = {
-          type: 'todo_list',
-          todos: [{ id: '1', content: 'From display', status: 'completed' }],
-        };
-        const args = {
-          todos: [{ id: '2', content: 'From args', status: 'pending' }],
-        };
-
-        const result = emitter.extractTodos(resultDisplay, args);
-
-        expect(result).toEqual([
-          { id: '1', content: 'From display', status: 'completed' },
-        ]);
-      });
-
-      it('should return null when args has no todos array', () => {
-        const args = { other: 'value' };
-
-        const result = emitter.extractTodos(null, args);
-
-        expect(result).toBeNull();
-      });
-
-      it('should return null when args.todos is not an array', () => {
-        const args = { todos: 'not an array' };
-
-        const result = emitter.extractTodos(null, args);
-
-        expect(result).toBeNull();
-      });
-    });
-
-    describe('edge cases', () => {
-      it('should return null when both resultDisplay and args are undefined', () => {
-        const result = emitter.extractTodos(undefined, undefined);
-
-        expect(result).toBeNull();
-      });
-
-      it('should return null when resultDisplay is empty object', () => {
-        const result = emitter.extractTodos({});
-
-        expect(result).toBeNull();
-      });
-
-      it('should handle resultDisplay with todos but wrong type', () => {
-        const resultDisplay = {
-          type: 'not_todo_list',
-          todos: [{ id: '1', content: 'Task', status: 'pending' }],
-        };
-
-        const result = emitter.extractTodos(resultDisplay);
-
-        expect(result).toBeNull();
-      });
-    });
-  });
-});
--- a/packages/cli/src/acp-integration/session/emitters/PlanEmitter.ts
+++ b/packages/cli/src/acp-integration/session/emitters/PlanEmitter.ts
@@ -1,96 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { BaseEmitter } from './BaseEmitter.js';
-import type { TodoItem } from '../types.js';
-import type * as acp from '../../acp.js';
-
-/**
- * Handles emission of plan/todo updates.
- *
- * This emitter is responsible for converting todo items to ACP plan entries
- * and sending plan updates to the client. It also provides utilities for
- * extracting todos from various sources (tool result displays, args, etc.).
- */
-export class PlanEmitter extends BaseEmitter {
-  /**
-   * Emits a plan update with the given todo items.
-   *
-   * @param todos - Array of todo items to send as plan entries
-   */
-  async emitPlan(todos: TodoItem[]): Promise<void> {
-    const entries: acp.PlanEntry[] = todos.map((todo) => ({
-      content: todo.content,
-      priority: 'medium' as const, // Default priority since todos don't have priority
-      status: todo.status,
-    }));
-
-    await this.sendUpdate({
-      sessionUpdate: 'plan',
-      entries,
-    });
-  }
-
-  /**
-   * Extracts todos from tool result display or args.
-   * Tries multiple sources in priority order:
-   * 1. Result display object with type 'todo_list'
-   * 2. Result display as JSON string
-   * 3. Args with 'todos' array
-   *
-   * @param resultDisplay - The tool result display (object, string, or undefined)
-   * @param args - The tool call arguments (fallback source)
-   * @returns Array of todos if found, null otherwise
-   */
-  extractTodos(
-    resultDisplay: unknown,
-    args?: Record<string, unknown>,
-  ): TodoItem[] | null {
-    // Try resultDisplay first (final state from tool execution)
-    const fromDisplay = this.extractFromResultDisplay(resultDisplay);
-    if (fromDisplay) return fromDisplay;
-
-    // Fallback to args (initial state)
-    if (args && Array.isArray(args['todos'])) {
-      return args['todos'] as TodoItem[];
-    }
-
-    return null;
-  }
-
-  /**
-   * Extracts todos from a result display value.
-   * Handles both object and JSON string formats.
-   */
-  private extractFromResultDisplay(resultDisplay: unknown): TodoItem[] | null {
-    if (!resultDisplay) return null;
-
-    // Handle direct object with type 'todo_list'
-    if (typeof resultDisplay === 'object') {
-      const obj = resultDisplay as Record<string, unknown>;
-      if (obj['type'] === 'todo_list' && Array.isArray(obj['todos'])) {
-        return obj['todos'] as TodoItem[];
-      }
-    }
-
-    // Handle JSON string (from subagent events)
-    if (typeof resultDisplay === 'string') {
-      try {
-        const parsed = JSON.parse(resultDisplay) as Record<string, unknown>;
-        if (
-          parsed?.['type'] === 'todo_list' &&
-          Array.isArray(parsed['todos'])
-        ) {
-          return parsed['todos'] as TodoItem[];
-        }
-      } catch {
-        // Not JSON, ignore
-      }
-    }
-
-    return null;
-  }
-}
--- a/packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.test.ts
+++ b/packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.test.ts
@@ -1,662 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ToolCallEmitter } from './ToolCallEmitter.js';
-import type { SessionContext } from '../types.js';
-import type {
-  Config,
-  ToolRegistry,
-  AnyDeclarativeTool,
-  AnyToolInvocation,
-} from '@qwen-code/qwen-code-core';
-import { Kind, TodoWriteTool } from '@qwen-code/qwen-code-core';
-import type { Part } from '@google/genai';
-
-// Helper to create mock message parts for tests
-const createMockMessage = (text?: string): Part[] =>
-  text
-    ? [{ functionResponse: { name: 'test', response: { output: text } } }]
-    : [];
-
-describe('ToolCallEmitter', () => {
-  let mockContext: SessionContext;
-  let sendUpdateSpy: ReturnType<typeof vi.fn>;
-  let mockToolRegistry: ToolRegistry;
-  let emitter: ToolCallEmitter;
-
-  // Helper to create mock tool
-  const createMockTool = (
-    overrides: Partial<AnyDeclarativeTool> = {},
-  ): AnyDeclarativeTool =>
-    ({
-      name: 'test_tool',
-      kind: Kind.Other,
-      build: vi.fn().mockReturnValue({
-        getDescription: () => 'Test tool description',
-        toolLocations: () => [{ path: '/test/file.ts', line: 10 }],
-      } as unknown as AnyToolInvocation),
-      ...overrides,
-    }) as unknown as AnyDeclarativeTool;
-
-  beforeEach(() => {
-    sendUpdateSpy = vi.fn().mockResolvedValue(undefined);
-    mockToolRegistry = {
-      getTool: vi.fn().mockReturnValue(null),
-    } as unknown as ToolRegistry;
-
-    mockContext = {
-      sessionId: 'test-session-id',
-      config: {
-        getToolRegistry: () => mockToolRegistry,
-      } as unknown as Config,
-      sendUpdate: sendUpdateSpy,
-    };
-
-    emitter = new ToolCallEmitter(mockContext);
-  });
-
-  describe('emitStart', () => {
-    it('should emit tool_call update with basic params when tool not in registry', async () => {
-      const result = await emitter.emitStart({
-        toolName: 'unknown_tool',
-        callId: 'call-123',
-        args: { arg1: 'value1' },
-      });
-
-      expect(result).toBe(true);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'call-123',
-        status: 'in_progress',
-        title: 'unknown_tool', // Falls back to tool name
-        content: [],
-        locations: [],
-        kind: 'other',
-        rawInput: { arg1: 'value1' },
-      });
-    });
-
-    it('should emit tool_call with resolved metadata when tool is in registry', async () => {
-      const mockTool = createMockTool({ kind: Kind.Edit });
-      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-
-      const result = await emitter.emitStart({
-        toolName: 'edit_file',
-        callId: 'call-456',
-        args: { path: '/test.ts' },
-      });
-
-      expect(result).toBe(true);
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'call-456',
-        status: 'in_progress',
-        title: 'edit_file: Test tool description',
-        content: [],
-        locations: [{ path: '/test/file.ts', line: 10 }],
-        kind: 'edit',
-        rawInput: { path: '/test.ts' },
-      });
-    });
-
-    it('should skip emit for TodoWriteTool and return false', async () => {
-      const result = await emitter.emitStart({
-        toolName: TodoWriteTool.Name,
-        callId: 'call-todo',
-        args: { todos: [] },
-      });
-
-      expect(result).toBe(false);
-      expect(sendUpdateSpy).not.toHaveBeenCalled();
-    });
-
-    it('should handle empty args', async () => {
-      await emitter.emitStart({
-        toolName: 'test_tool',
-        callId: 'call-empty',
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          rawInput: {},
-        }),
-      );
-    });
-
-    it('should fall back gracefully when tool build fails', async () => {
-      const mockTool = createMockTool();
-      vi.mocked(mockTool.build).mockImplementation(() => {
-        throw new Error('Build failed');
-      });
-      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-
-      await emitter.emitStart({
-        toolName: 'failing_tool',
-        callId: 'call-fail',
-        args: { invalid: true },
-      });
-
-      // Should use fallback values
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call',
-        toolCallId: 'call-fail',
-        status: 'in_progress',
-        title: 'failing_tool', // Fallback to tool name
-        content: [],
-        locations: [], // Fallback to empty
-        kind: 'other', // Fallback to other
-        rawInput: { invalid: true },
-      });
-    });
-  });
-
-  describe('emitResult', () => {
-    it('should emit tool_call_update with completed status on success', async () => {
-      await emitter.emitResult({
-        toolName: 'test_tool',
-        callId: 'call-123',
-        success: true,
-        message: createMockMessage('Tool completed successfully'),
-        resultDisplay: 'Tool completed successfully',
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call_update',
-          toolCallId: 'call-123',
-          status: 'completed',
-          rawOutput: 'Tool completed successfully',
-        }),
-      );
-    });
-
-    it('should emit tool_call_update with failed status on failure', async () => {
-      await emitter.emitResult({
-        toolName: 'test_tool',
-        callId: 'call-123',
-        success: false,
-        message: [],
-        error: new Error('Something went wrong'),
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call_update',
-        toolCallId: 'call-123',
-        status: 'failed',
-        content: [
-          {
-            type: 'content',
-            content: { type: 'text', text: 'Something went wrong' },
-          },
-        ],
-      });
-    });
-
-    it('should handle diff display format', async () => {
-      await emitter.emitResult({
-        toolName: 'edit_file',
-        callId: 'call-edit',
-        success: true,
-        message: [],
-        resultDisplay: {
-          fileName: '/test/file.ts',
-          originalContent: 'old content',
-          newContent: 'new content',
-        },
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call_update',
-          toolCallId: 'call-edit',
-          status: 'completed',
-          content: [
-            {
-              type: 'diff',
-              path: '/test/file.ts',
-              oldText: 'old content',
-              newText: 'new content',
-            },
-          ],
-        }),
-      );
-    });
-
-    it('should transform message parts to content', async () => {
-      await emitter.emitResult({
-        toolName: 'test_tool',
-        callId: 'call-123',
-        success: true,
-        message: [{ text: 'Some text output' }],
-        resultDisplay: 'raw output',
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          sessionUpdate: 'tool_call_update',
-          toolCallId: 'call-123',
-          status: 'completed',
-          content: [
-            {
-              type: 'content',
-              content: { type: 'text', text: 'Some text output' },
-            },
-          ],
-          rawOutput: 'raw output',
-        }),
-      );
-    });
-
-    it('should handle empty message parts', async () => {
-      await emitter.emitResult({
-        toolName: 'test_tool',
-        callId: 'call-empty',
-        success: true,
-        message: [],
-      });
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call_update',
-        toolCallId: 'call-empty',
-        status: 'completed',
-        content: [],
-      });
-    });
-
-    describe('TodoWriteTool handling', () => {
-      it('should emit plan update instead of tool_call_update for TodoWriteTool', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo',
-          success: true,
-          message: [],
-          resultDisplay: {
-            type: 'todo_list',
-            todos: [
-              { id: '1', content: 'Task 1', status: 'pending' },
-              { id: '2', content: 'Task 2', status: 'in_progress' },
-            ],
-          },
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledTimes(1);
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'plan',
-          entries: [
-            { content: 'Task 1', priority: 'medium', status: 'pending' },
-            { content: 'Task 2', priority: 'medium', status: 'in_progress' },
-          ],
-        });
-      });
-
-      it('should use args as fallback for TodoWriteTool todos', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo',
-          success: true,
-          message: [],
-          resultDisplay: null,
-          args: {
-            todos: [{ id: '1', content: 'From args', status: 'completed' }],
-          },
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'plan',
-          entries: [
-            { content: 'From args', priority: 'medium', status: 'completed' },
-          ],
-        });
-      });
-
-      it('should not emit anything for TodoWriteTool with empty todos', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo',
-          success: true,
-          message: [],
-          resultDisplay: { type: 'todo_list', todos: [] },
-        });
-
-        expect(sendUpdateSpy).not.toHaveBeenCalled();
-      });
-
-      it('should not emit anything for TodoWriteTool with no extractable todos', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo',
-          success: true,
-          message: [],
-          resultDisplay: 'Some string result',
-        });
-
-        expect(sendUpdateSpy).not.toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('emitError', () => {
-    it('should emit tool_call_update with failed status and error message', async () => {
-      const error = new Error('Connection timeout');
-
-      await emitter.emitError('call-123', error);
-
-      expect(sendUpdateSpy).toHaveBeenCalledWith({
-        sessionUpdate: 'tool_call_update',
-        toolCallId: 'call-123',
-        status: 'failed',
-        content: [
-          {
-            type: 'content',
-            content: { type: 'text', text: 'Connection timeout' },
-          },
-        ],
-      });
-    });
-  });
-
-  describe('isTodoWriteTool', () => {
-    it('should return true for TodoWriteTool.Name', () => {
-      expect(emitter.isTodoWriteTool(TodoWriteTool.Name)).toBe(true);
-    });
-
-    it('should return false for other tool names', () => {
-      expect(emitter.isTodoWriteTool('read_file')).toBe(false);
-      expect(emitter.isTodoWriteTool('edit_file')).toBe(false);
-      expect(emitter.isTodoWriteTool('')).toBe(false);
-    });
-  });
-
-  describe('mapToolKind', () => {
-    it('should map all Kind values correctly', () => {
-      expect(emitter.mapToolKind(Kind.Read)).toBe('read');
-      expect(emitter.mapToolKind(Kind.Edit)).toBe('edit');
-      expect(emitter.mapToolKind(Kind.Delete)).toBe('delete');
-      expect(emitter.mapToolKind(Kind.Move)).toBe('move');
-      expect(emitter.mapToolKind(Kind.Search)).toBe('search');
-      expect(emitter.mapToolKind(Kind.Execute)).toBe('execute');
-      expect(emitter.mapToolKind(Kind.Think)).toBe('think');
-      expect(emitter.mapToolKind(Kind.Fetch)).toBe('fetch');
-      expect(emitter.mapToolKind(Kind.Other)).toBe('other');
-    });
-
-    it('should map exit_plan_mode tool to switch_mode kind', () => {
-      // exit_plan_mode uses Kind.Think internally, but should map to switch_mode per ACP spec
-      expect(emitter.mapToolKind(Kind.Think, 'exit_plan_mode')).toBe(
-        'switch_mode',
-      );
-    });
-
-    it('should not affect other tools with Kind.Think', () => {
-      // Other tools with Kind.Think should still map to think
-      expect(emitter.mapToolKind(Kind.Think, 'todo_write')).toBe('think');
-      expect(emitter.mapToolKind(Kind.Think, 'some_other_tool')).toBe('think');
-    });
-  });
-
-  describe('isExitPlanModeTool', () => {
-    it('should return true for exit_plan_mode tool name', () => {
-      expect(emitter.isExitPlanModeTool('exit_plan_mode')).toBe(true);
-    });
-
-    it('should return false for other tool names', () => {
-      expect(emitter.isExitPlanModeTool('read_file')).toBe(false);
-      expect(emitter.isExitPlanModeTool('edit_file')).toBe(false);
-      expect(emitter.isExitPlanModeTool('todo_write')).toBe(false);
-      expect(emitter.isExitPlanModeTool('')).toBe(false);
-    });
-  });
-
-  describe('resolveToolMetadata', () => {
-    it('should return defaults when tool not found', () => {
-      const metadata = emitter.resolveToolMetadata('unknown_tool', {
-        arg: 'value',
-      });
-
-      expect(metadata).toEqual({
-        title: 'unknown_tool',
-        locations: [],
-        kind: 'other',
-      });
-    });
-
-    it('should return tool metadata when tool found and built successfully', () => {
-      const mockTool = createMockTool({ kind: Kind.Search });
-      vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-
-      const metadata = emitter.resolveToolMetadata('search_tool', {
-        query: 'test',
-      });
-
-      expect(metadata).toEqual({
-        title: 'search_tool: Test tool description',
-        locations: [{ path: '/test/file.ts', line: 10 }],
-        kind: 'search',
-      });
-    });
-  });
-
-  describe('integration: consistent behavior across flows', () => {
-    it('should handle the same params consistently regardless of source', async () => {
-      // This test verifies that the emitter produces consistent output
-      // whether called from normal flow, replay, or subagent
-
-      const params = {
-        toolName: 'read_file',
-        callId: 'consistent-call',
-        args: { path: '/test.ts' },
-      };
-
-      // First call (e.g., from normal flow)
-      await emitter.emitStart(params);
-      const firstCall = sendUpdateSpy.mock.calls[0][0];
-
-      // Reset and call again (e.g., from replay)
-      sendUpdateSpy.mockClear();
-      await emitter.emitStart(params);
-      const secondCall = sendUpdateSpy.mock.calls[0][0];
-
-      // Both should produce identical output
-      expect(firstCall).toEqual(secondCall);
-    });
-  });
-
-  describe('fixes verification', () => {
-    describe('Fix 2: functionResponse parts are stringified', () => {
-      it('should stringify functionResponse parts in message', async () => {
-        await emitter.emitResult({
-          toolName: 'test_tool',
-          callId: 'call-func',
-          success: true,
-          message: [
-            {
-              functionResponse: {
-                name: 'test',
-                response: { output: 'test output' },
-              },
-            },
-          ],
-          resultDisplay: { unknownField: 'value', nested: { data: 123 } },
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith(
-          expect.objectContaining({
-            sessionUpdate: 'tool_call_update',
-            toolCallId: 'call-func',
-            status: 'completed',
-            content: [
-              {
-                type: 'content',
-                content: {
-                  type: 'text',
-                  text: '{"output":"test output"}',
-                },
-              },
-            ],
-            rawOutput: { unknownField: 'value', nested: { data: 123 } },
-          }),
-        );
-      });
-    });
-
-    describe('Fix 3: rawOutput is included in emitResult', () => {
-      it('should include rawOutput when resultDisplay is provided', async () => {
-        await emitter.emitResult({
-          toolName: 'test_tool',
-          callId: 'call-extra',
-          success: true,
-          message: [{ text: 'Result text' }],
-          resultDisplay: 'Result text',
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith(
-          expect.objectContaining({
-            sessionUpdate: 'tool_call_update',
-            toolCallId: 'call-extra',
-            status: 'completed',
-            rawOutput: 'Result text',
-          }),
-        );
-      });
-
-      it('should not include rawOutput when resultDisplay is undefined', async () => {
-        await emitter.emitResult({
-          toolName: 'test_tool',
-          callId: 'call-null',
-          success: true,
-          message: [],
-        });
-
-        const call = sendUpdateSpy.mock.calls[0][0];
-        expect(call.rawOutput).toBeUndefined();
-      });
-    });
-
-    describe('Fix 5: Line null mapping in resolveToolMetadata', () => {
-      it('should map undefined line to null in locations', () => {
-        const mockTool = createMockTool();
-        // Override toolLocations to return undefined line
-        vi.mocked(mockTool.build).mockReturnValue({
-          getDescription: () => 'Description',
-          toolLocations: () => [
-            { path: '/file1.ts', line: 10 },
-            { path: '/file2.ts', line: undefined },
-            { path: '/file3.ts' }, // no line property
-          ],
-        } as unknown as AnyToolInvocation);
-        vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockTool);
-
-        const metadata = emitter.resolveToolMetadata('test_tool', {
-          arg: 'value',
-        });
-
-        expect(metadata.locations).toEqual([
-          { path: '/file1.ts', line: 10 },
-          { path: '/file2.ts', line: null },
-          { path: '/file3.ts', line: null },
-        ]);
-      });
-    });
-
-    describe('Fix 6: Empty plan emission when args has todos', () => {
-      it('should emit empty plan when args had todos but result has none', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo-empty',
-          success: true,
-          message: [],
-          resultDisplay: null, // No result display
-          args: {
-            todos: [], // Empty array in args
-          },
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'plan',
-          entries: [],
-        });
-      });
-
-      it('should emit empty plan when result todos is empty but args had todos', async () => {
-        await emitter.emitResult({
-          toolName: TodoWriteTool.Name,
-          callId: 'call-todo-cleared',
-          success: true,
-          message: [],
-          resultDisplay: {
-            type: 'todo_list',
-            todos: [], // Empty result
-          },
-          args: {
-            todos: [{ id: '1', content: 'Was here', status: 'pending' }],
-          },
-        });
-
-        // Should still emit empty plan (result takes precedence but we emit empty)
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'plan',
-          entries: [],
-        });
-      });
-    });
-
-    describe('Message transformation', () => {
-      it('should transform text parts from message', async () => {
-        await emitter.emitResult({
-          toolName: 'test_tool',
-          callId: 'call-text',
-          success: true,
-          message: [{ text: 'Text content from message' }],
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith({
-          sessionUpdate: 'tool_call_update',
-          toolCallId: 'call-text',
-          status: 'completed',
-          content: [
-            {
-              type: 'content',
-              content: { type: 'text', text: 'Text content from message' },
-            },
-          ],
-        });
-      });
-
-      it('should transform functionResponse parts from message', async () => {
-        await emitter.emitResult({
-          toolName: 'test_tool',
-          callId: 'call-func-resp',
-          success: true,
-          message: [
-            {
-              functionResponse: {
-                name: 'test_tool',
-                response: { output: 'Function output' },
-              },
-            },
-          ],
-          resultDisplay: 'raw result',
-        });
-
-        expect(sendUpdateSpy).toHaveBeenCalledWith(
-          expect.objectContaining({
-            sessionUpdate: 'tool_call_update',
-            toolCallId: 'call-func-resp',
-            status: 'completed',
-            content: [
-              {
-                type: 'content',
-                content: { type: 'text', text: '{"output":"Function output"}' },
-              },
-            ],
-            rawOutput: 'raw result',
-          }),
-        );
-      });
-    });
-  });
-});
--- a/packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.ts
+++ b/packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.ts
@@ -1,291 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { BaseEmitter } from './BaseEmitter.js';
-import { PlanEmitter } from './PlanEmitter.js';
-import type {
-  SessionContext,
-  ToolCallStartParams,
-  ToolCallResultParams,
-  ResolvedToolMetadata,
-} from '../types.js';
-import type * as acp from '../../acp.js';
-import type { Part } from '@google/genai';
-import {
-  TodoWriteTool,
-  Kind,
-  ExitPlanModeTool,
-} from '@qwen-code/qwen-code-core';
-
-/**
- * Unified tool call event emitter.
- *
- * Handles tool_call and tool_call_update for ALL flows:
- * - Normal tool execution in runTool()
- * - History replay in HistoryReplayer
- * - SubAgent tool tracking in SubAgentTracker
- *
- * This ensures consistent behavior across all tool event sources,
- * including special handling for tools like TodoWriteTool.
- */
-export class ToolCallEmitter extends BaseEmitter {
-  private readonly planEmitter: PlanEmitter;
-
-  constructor(ctx: SessionContext) {
-    super(ctx);
-    this.planEmitter = new PlanEmitter(ctx);
-  }
-
-  /**
-   * Emits a tool call start event.
-   *
-   * @param params - Tool call start parameters
-   * @returns true if event was emitted, false if skipped (e.g., TodoWriteTool)
-   */
-  async emitStart(params: ToolCallStartParams): Promise<boolean> {
-    // Skip tool_call for TodoWriteTool - plan updates sent on result
-    if (this.isTodoWriteTool(params.toolName)) {
-      return false;
-    }
-
-    const { title, locations, kind } = this.resolveToolMetadata(
-      params.toolName,
-      params.args,
-    );
-
-    await this.sendUpdate({
-      sessionUpdate: 'tool_call',
-      toolCallId: params.callId,
-      status: 'in_progress',
-      title,
-      content: [],
-      locations,
-      kind,
-      rawInput: params.args ?? {},
-    });
-
-    return true;
-  }
-
-  /**
-   * Emits a tool call result event.
-   * Handles TodoWriteTool specially by routing to plan updates.
-   *
-   * @param params - Tool call result parameters
-   */
-  async emitResult(params: ToolCallResultParams): Promise<void> {
-    // Handle TodoWriteTool specially - send plan update instead
-    if (this.isTodoWriteTool(params.toolName)) {
-      const todos = this.planEmitter.extractTodos(
-        params.resultDisplay,
-        params.args,
-      );
-      // Match original behavior: send plan even if empty when args['todos'] exists
-      // This ensures the UI is updated even when all todos are removed
-      if (todos && todos.length > 0) {
-        await this.planEmitter.emitPlan(todos);
-      } else if (params.args && Array.isArray(params.args['todos'])) {
-        // Send empty plan when args had todos but result has none
-        await this.planEmitter.emitPlan([]);
-      }
-      return; // Skip tool_call_update for TodoWriteTool
-    }
-
-    // Determine content for the update
-    let contentArray: acp.ToolCallContent[] = [];
-
-    // Special case: diff result from edit tools (format from resultDisplay)
-    const diffContent = this.extractDiffContent(params.resultDisplay);
-    if (diffContent) {
-      contentArray = [diffContent];
-    } else if (params.error) {
-      // Error case: show error message
-      contentArray = [
-        {
-          type: 'content',
-          content: { type: 'text', text: params.error.message },
-        },
-      ];
-    } else {
-      // Normal case: transform message parts to ToolCallContent[]
-      contentArray = this.transformPartsToToolCallContent(params.message);
-    }
-
-    // Build the update
-    const update: Parameters<typeof this.sendUpdate>[0] = {
-      sessionUpdate: 'tool_call_update',
-      toolCallId: params.callId,
-      status: params.success ? 'completed' : 'failed',
-      content: contentArray,
-    };
-
-    // Add rawOutput from resultDisplay
-    if (params.resultDisplay !== undefined) {
-      (update as Record<string, unknown>)['rawOutput'] = params.resultDisplay;
-    }
-
-    await this.sendUpdate(update);
-  }
-
-  /**
-   * Emits a tool call error event.
-   * Use this for explicit error handling when not using emitResult.
-   *
-   * @param callId - The tool call ID
-   * @param error - The error that occurred
-   */
-  async emitError(callId: string, error: Error): Promise<void> {
-    await this.sendUpdate({
-      sessionUpdate: 'tool_call_update',
-      toolCallId: callId,
-      status: 'failed',
-      content: [
-        { type: 'content', content: { type: 'text', text: error.message } },
-      ],
-    });
-  }
-
-  // ==================== Public Utilities ====================
-
-  /**
-   * Checks if a tool name is the TodoWriteTool.
-   * Exposed for external use in components that need to check this.
-   */
-  isTodoWriteTool(toolName: string): boolean {
-    return toolName === TodoWriteTool.Name;
-  }
-
-  /**
-   * Checks if a tool name is the ExitPlanModeTool.
-   */
-  isExitPlanModeTool(toolName: string): boolean {
-    return toolName === ExitPlanModeTool.Name;
-  }
-
-  /**
-   * Resolves tool metadata from the registry.
-   * Falls back to defaults if tool not found or build fails.
-   *
-   * @param toolName - Name of the tool
-   * @param args - Tool call arguments (used to build invocation)
-   */
-  resolveToolMetadata(
-    toolName: string,
-    args?: Record<string, unknown>,
-  ): ResolvedToolMetadata {
-    const toolRegistry = this.config.getToolRegistry();
-    const tool = toolRegistry.getTool(toolName);
-
-    let title = tool?.displayName ?? toolName;
-    let locations: acp.ToolCallLocation[] = [];
-    let kind: acp.ToolKind = 'other';
-
-    if (tool && args) {
-      try {
-        const invocation = tool.build(args);
-        title = `${title}: ${invocation.getDescription()}`;
-        // Map locations to ensure line is null instead of undefined (for ACP consistency)
-        locations = invocation.toolLocations().map((loc) => ({
-          path: loc.path,
-          line: loc.line ?? null,
-        }));
-        // Pass tool name to handle special cases like exit_plan_mode -> switch_mode
-        kind = this.mapToolKind(tool.kind, toolName);
-      } catch {
-        // Use defaults on build failure
-      }
-    }
-
-    return { title, locations, kind };
-  }
-
-  /**
-   * Maps core Tool Kind enum to ACP ToolKind string literals.
-   *
-   * @param kind - The core Kind enum value
-   * @param toolName - Optional tool name to handle special cases like exit_plan_mode
-   */
-  mapToolKind(kind: Kind, toolName?: string): acp.ToolKind {
-    // Special case: exit_plan_mode uses 'switch_mode' kind per ACP spec
-    if (toolName && this.isExitPlanModeTool(toolName)) {
-      return 'switch_mode';
-    }
-
-    const kindMap: Record<Kind, acp.ToolKind> = {
-      [Kind.Read]: 'read',
-      [Kind.Edit]: 'edit',
-      [Kind.Delete]: 'delete',
-      [Kind.Move]: 'move',
-      [Kind.Search]: 'search',
-      [Kind.Execute]: 'execute',
-      [Kind.Think]: 'think',
-      [Kind.Fetch]: 'fetch',
-      [Kind.Other]: 'other',
-    };
-    return kindMap[kind] ?? 'other';
-  }
-
-  // ==================== Private Helpers ====================
-
-  /**
-   * Extracts diff content from resultDisplay if it's a diff type (edit tool result).
-   * Returns null if not a diff.
-   */
-  private extractDiffContent(
-    resultDisplay: unknown,
-  ): acp.ToolCallContent | null {
-    if (!resultDisplay || typeof resultDisplay !== 'object') return null;
-
-    const obj = resultDisplay as Record<string, unknown>;
-
-    // Check if this is a diff display (edit tool result)
-    if ('fileName' in obj && 'newContent' in obj) {
-      return {
-        type: 'diff',
-        path: obj['fileName'] as string,
-        oldText: (obj['originalContent'] as string) ?? '',
-        newText: obj['newContent'] as string,
-      };
-    }
-
-    return null;
-  }
-
-  /**
-   * Transforms Part[] to ToolCallContent[].
-   * Extracts text from functionResponse parts and text parts.
-   */
-  private transformPartsToToolCallContent(
-    parts: Part[],
-  ): acp.ToolCallContent[] {
-    const result: acp.ToolCallContent[] = [];
-
-    for (const part of parts) {
-      // Handle text parts
-      if ('text' in part && part.text) {
-        result.push({
-          type: 'content',
-          content: { type: 'text', text: part.text },
-        });
-      }
-
-      // Handle functionResponse parts - stringify the response
-      if ('functionResponse' in part && part.functionResponse) {
-        try {
-          const responseText = JSON.stringify(part.functionResponse.response);
-          result.push({
-            type: 'content',
-            content: { type: 'text', text: responseText },
-          });
-        } catch {
-          // Ignore serialization errors
-        }
-      }
-    }
-
-    return result;
-  }
-}
--- a/packages/cli/src/acp-integration/session/emitters/index.ts
+++ b/packages/cli/src/acp-integration/session/emitters/index.ts
@@ -1,10 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export { BaseEmitter } from './BaseEmitter.js';
-export { MessageEmitter } from './MessageEmitter.js';
-export { PlanEmitter } from './PlanEmitter.js';
-export { ToolCallEmitter } from './ToolCallEmitter.js';
--- a/packages/cli/src/acp-integration/session/index.ts
+++ b/packages/cli/src/acp-integration/session/index.ts
@@ -1,40 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Session module for ACP/Zed integration.
- *
- * This module provides a modular architecture for handling session events:
- * - **Emitters**: Unified event emission (MessageEmitter, ToolCallEmitter, PlanEmitter)
- * - **HistoryReplayer**: Replays session history using unified emitters
- * - **SubAgentTracker**: Tracks sub-agent tool events using unified emitters
- *
- * The key benefit is that all event emission goes through the same emitters,
- * ensuring consistency between normal flow, history replay, and sub-agent events.
- */
-
-// Types
-export type {
-  SessionContext,
-  SessionUpdateSender,
-  ToolCallStartParams,
-  ToolCallResultParams,
-  TodoItem,
-  ResolvedToolMetadata,
-} from './types.js';
-
-// Emitters
-export { BaseEmitter } from './emitters/BaseEmitter.js';
-export { MessageEmitter } from './emitters/MessageEmitter.js';
-export { PlanEmitter } from './emitters/PlanEmitter.js';
-export { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
-
-// Components
-export { HistoryReplayer } from './HistoryReplayer.js';
-export { SubAgentTracker } from './SubAgentTracker.js';
-
-// Main Session class
-export { Session } from './Session.js';
--- a/packages/cli/src/acp-integration/session/types.ts
+++ b/packages/cli/src/acp-integration/session/types.ts
@@ -1,76 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Config } from '@qwen-code/qwen-code-core';
-import type { Part } from '@google/genai';
-import type * as acp from '../acp.js';
-
-/**
- * Interface for sending session updates to the ACP client.
- * Implemented by Session class and used by all emitters.
- */
-export interface SessionUpdateSender {
-  sendUpdate(update: acp.SessionUpdate): Promise<void>;
-}
-
-/**
- * Session context shared across all emitters.
- * Provides access to session state and configuration.
- */
-export interface SessionContext extends SessionUpdateSender {
-  readonly sessionId: string;
-  readonly config: Config;
-}
-
-/**
- * Parameters for emitting a tool call start event.
- */
-export interface ToolCallStartParams {
-  /** Name of the tool being called */
-  toolName: string;
-  /** Unique identifier for this tool call */
-  callId: string;
-  /** Arguments passed to the tool */
-  args?: Record<string, unknown>;
-}
-
-/**
- * Parameters for emitting a tool call result event.
- */
-export interface ToolCallResultParams {
-  /** Name of the tool that was called */
-  toolName: string;
-  /** Unique identifier for this tool call */
-  callId: string;
-  /** Whether the tool execution succeeded */
-  success: boolean;
-  /** The response parts from tool execution (maps to content in update event) */
-  message: Part[];
-  /** Display result from tool execution (maps to rawOutput in update event) */
-  resultDisplay?: unknown;
-  /** Error if tool execution failed */
-  error?: Error;
-  /** Original args (fallback for TodoWriteTool todos extraction) */
-  args?: Record<string, unknown>;
-}
-
-/**
- * Todo item structure for plan updates.
- */
-export interface TodoItem {
-  id: string;
-  content: string;
-  status: 'pending' | 'in_progress' | 'completed';
-}
-
-/**
- * Resolved tool metadata from the registry.
- */
-export interface ResolvedToolMetadata {
-  title: string;
-  locations: acp.ToolCallLocation[];
-  kind: acp.ToolKind;
-}
--- a/packages/cli/src/config/config.integration.test.ts
+++ b/packages/cli/src/config/config.integration.test.ts
@@ -15,7 +15,6 @@ import type {
 import { Config } from '@qwen-code/qwen-code-core';
 import { http, HttpResponse } from 'msw';
 import { setupServer } from 'msw/node';
-import type { Settings } from './settings.js';

 export const server = setupServer();

@@ -74,10 +73,12 @@ describe('Configuration Integration Tests', () => {
    it('should load default file filtering settings', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
+        fileFilteringRespectGitIgnore: undefined, // Should default to true
      };

      const config = new Config(configParams);
@@ -88,8 +89,9 @@ describe('Configuration Integration Tests', () => {
    it('should load custom file filtering settings from configuration', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        fileFiltering: {
@@ -105,10 +107,12 @@ describe('Configuration Integration Tests', () => {
    it('should merge user and workspace file filtering settings', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
+        fileFilteringRespectGitIgnore: true,
      };

      const config = new Config(configParams);
@@ -121,8 +125,9 @@ describe('Configuration Integration Tests', () => {
    it('should handle partial configuration objects gracefully', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        fileFiltering: {
@@ -139,10 +144,12 @@ describe('Configuration Integration Tests', () => {
    it('should handle empty configuration objects gracefully', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
+        fileFilteringRespectGitIgnore: undefined,
      };

      const config = new Config(configParams);
@@ -154,8 +161,9 @@ describe('Configuration Integration Tests', () => {
    it('should handle missing configuration sections gracefully', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        // Missing fileFiltering configuration
@@ -172,10 +180,12 @@ describe('Configuration Integration Tests', () => {
    it('should handle a security-focused configuration', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
+        fileFilteringRespectGitIgnore: true,
      };

      const config = new Config(configParams);
@@ -186,8 +196,9 @@ describe('Configuration Integration Tests', () => {
    it('should handle a CI/CD environment configuration', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        fileFiltering: {
@@ -205,8 +216,9 @@ describe('Configuration Integration Tests', () => {
    it('should enable checkpointing when the setting is true', async () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        checkpointing: true,
@@ -222,8 +234,9 @@ describe('Configuration Integration Tests', () => {
    it('should have an empty array for extension context files by default', () => {
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
      };
@@ -235,8 +248,9 @@ describe('Configuration Integration Tests', () => {
      const contextFiles = ['/path/to/file1.txt', '/path/to/file2.js'];
      const configParams: ConfigParameters = {
        cwd: '/tmp',
-        generationConfig: TEST_CONTENT_GENERATOR_CONFIG,
+        contentGeneratorConfig: TEST_CONTENT_GENERATOR_CONFIG,
        embeddingModel: 'test-embedding-model',
+        sandbox: false,
        targetDir: tempDir,
        debugMode: false,
        extensionContextFilePaths: contextFiles,
@@ -247,11 +261,11 @@ describe('Configuration Integration Tests', () => {
  });

  describe('Approval Mode Integration Tests', () => {
-    let parseArguments: typeof import('./config.js').parseArguments;
+    let parseArguments: typeof import('./config').parseArguments;

    beforeEach(async () => {
      // Import the argument parsing function for integration testing
-      const { parseArguments: parseArgs } = await import('./config.js');
+      const { parseArguments: parseArgs } = await import('./config');
      parseArguments = parseArgs;
    });

--- a/packages/cli/src/config/config.test.ts
+++ b/packages/cli/src/config/config.test.ts
@@ -392,49 +392,6 @@ describe('parseArguments', () => {
    mockConsoleError.mockRestore();
  });

-  it('should throw an error when include-partial-messages is used without stream-json output', async () => {
-    process.argv = ['node', 'script.js', '--include-partial-messages'];
-
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
-      throw new Error('process.exit called');
-    });
-
-    const mockConsoleError = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => {});
-
-    await expect(parseArguments({} as Settings)).rejects.toThrow(
-      'process.exit called',
-    );
-
-    expect(mockConsoleError).toHaveBeenCalledWith(
-      expect.stringContaining(
-        '--include-partial-messages requires --output-format stream-json',
-      ),
-    );
-
-    mockExit.mockRestore();
-    mockConsoleError.mockRestore();
-  });
-
-  it('should parse stream-json formats and include-partial-messages flag', async () => {
-    process.argv = [
-      'node',
-      'script.js',
-      '--output-format',
-      'stream-json',
-      '--input-format',
-      'stream-json',
-      '--include-partial-messages',
-    ];
-
-    const argv = await parseArguments({} as Settings);
-
-    expect(argv.outputFormat).toBe('stream-json');
-    expect(argv.inputFormat).toBe('stream-json');
-    expect(argv.includePartialMessages).toBe(true);
-  });
-
  it('should allow --approval-mode without --yolo', async () => {
    process.argv = ['node', 'script.js', '--approval-mode', 'auto-edit'];
    const argv = await parseArguments({} as Settings);
@@ -516,33 +473,6 @@ describe('loadCliConfig', () => {
    vi.restoreAllMocks();
  });

-  it('should propagate stream-json formats to config', async () => {
-    process.argv = [
-      'node',
-      'script.js',
-      '--output-format',
-      'stream-json',
-      '--input-format',
-      'stream-json',
-      '--include-partial-messages',
-    ];
-    const argv = await parseArguments({} as Settings);
-    const settings: Settings = {};
-    const config = await loadCliConfig(
-      settings,
-      [],
-      new ExtensionEnablementManager(
-        ExtensionStorage.getUserExtensionsDir(),
-        argv.extensions,
-      ),
-      argv,
-    );
-
-    expect(config.getOutputFormat()).toBe('stream-json');
-    expect(config.getInputFormat()).toBe('stream-json');
-    expect(config.getIncludePartialMessages()).toBe(true);
-  });
-
  it('should set showMemoryUsage to true when --show-memory-usage flag is present', async () => {
    process.argv = ['node', 'script.js', '--show-memory-usage'];
    const argv = await parseArguments({} as Settings);
@@ -554,6 +484,7 @@ describe('loadCliConfig', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getShowMemoryUsage()).toBe(true);
@@ -570,6 +501,7 @@ describe('loadCliConfig', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getShowMemoryUsage()).toBe(false);
@@ -586,6 +518,7 @@ describe('loadCliConfig', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getShowMemoryUsage()).toBe(false);
@@ -602,6 +535,7 @@ describe('loadCliConfig', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getShowMemoryUsage()).toBe(true);
@@ -644,6 +578,7 @@ describe('loadCliConfig', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
+        'test-session',
        argv,
      );
      expect(config.getProxy()).toBeFalsy();
@@ -693,6 +628,7 @@ describe('loadCliConfig', () => {
            ExtensionStorage.getUserExtensionsDir(),
            argv.extensions,
          ),
+          'test-session',
          argv,
        );
        expect(config.getProxy()).toBe(expected);
@@ -710,6 +646,7 @@ describe('loadCliConfig', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
+        'test-session',
        argv,
      );
      expect(config.getProxy()).toBe('http://localhost:7890');
@@ -727,6 +664,7 @@ describe('loadCliConfig', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
+        'test-session',
        argv,
      );
      expect(config.getProxy()).toBe('http://localhost:7890');
@@ -760,6 +698,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(false);
@@ -776,6 +715,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -792,6 +732,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(false);
@@ -808,6 +749,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -824,6 +766,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(false);
@@ -840,6 +783,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -856,6 +800,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(false);
@@ -874,6 +819,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpEndpoint()).toBe(
@@ -899,6 +845,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpEndpoint()).toBe('http://cli.example.com');
@@ -915,6 +862,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpEndpoint()).toBe('http://localhost:4317');
@@ -933,6 +881,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryTarget()).toBe(
@@ -953,6 +902,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryTarget()).toBe('gcp');
@@ -969,6 +919,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryTarget()).toBe(
@@ -987,6 +938,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -1003,6 +955,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -1019,6 +972,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -1035,6 +989,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -1053,6 +1008,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -1071,6 +1027,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -1087,6 +1044,7 @@ describe('loadCliConfig telemetry', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpProtocol()).toBe('grpc');
@@ -1168,10 +1126,12 @@ describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
    await loadCliConfig(
      settings,
      extensions,
+
      new ExtensionEnablementManager(
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'session-id',
      argv,
    );
    expect(ServerConfig.loadServerHierarchicalMemory).toHaveBeenCalledWith(
@@ -1252,6 +1212,7 @@ describe('mergeMcpServers', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(settings).toEqual(originalSettings);
@@ -1301,6 +1262,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(
@@ -1331,6 +1293,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(
@@ -1370,6 +1333,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(
@@ -1391,6 +1355,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual([]);
@@ -1409,6 +1374,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(defaultExcludes);
@@ -1426,6 +1392,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(
@@ -1456,6 +1423,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toEqual(
@@ -1487,6 +1455,7 @@ describe('mergeExcludeTools', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(settings).toEqual(originalSettings);
@@ -1518,6 +1487,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1547,6 +1517,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1576,6 +1547,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1605,6 +1577,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1634,6 +1607,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1656,6 +1630,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1690,7 +1665,7 @@ describe('Approval mode tool exclusion logic', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );

@@ -1721,6 +1696,7 @@ describe('Approval mode tool exclusion logic', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -1750,7 +1726,7 @@ describe('Approval mode tool exclusion logic', () => {
          ExtensionStorage.getUserExtensionsDir(),
          invalidArgv.extensions,
        ),
-
+        'test-session',
        invalidArgv as CliArgs,
      ),
    ).rejects.toThrow(
@@ -1792,6 +1768,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual(baseSettings.mcpServers);
@@ -1812,6 +1789,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1836,6 +1814,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1861,6 +1840,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1878,6 +1858,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({});
@@ -1897,6 +1878,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1919,6 +1901,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1943,6 +1926,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -1972,6 +1956,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -2003,6 +1988,7 @@ describe('loadCliConfig with allowed-mcp-server-names', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getMcpServers()).toEqual({
@@ -2037,6 +2023,7 @@ describe('loadCliConfig extensions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExtensionContextFilePaths()).toEqual([
@@ -2056,6 +2043,7 @@ describe('loadCliConfig extensions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExtensionContextFilePaths()).toEqual(['/path/to/ext1.md']);
@@ -2077,6 +2065,7 @@ describe('loadCliConfig model selection', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -2095,6 +2084,7 @@ describe('loadCliConfig model selection', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -2115,6 +2105,7 @@ describe('loadCliConfig model selection', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -2133,6 +2124,7 @@ describe('loadCliConfig model selection', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );

@@ -2172,6 +2164,7 @@ describe('loadCliConfig folderTrust', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getFolderTrust()).toBe(false);
@@ -2194,6 +2187,7 @@ describe('loadCliConfig folderTrust', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getFolderTrust()).toBe(true);
@@ -2210,6 +2204,7 @@ describe('loadCliConfig folderTrust', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getFolderTrust()).toBe(false);
@@ -2259,6 +2254,7 @@ describe('loadCliConfig with includeDirectories', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    const expected = [
@@ -2310,6 +2306,7 @@ describe('loadCliConfig chatCompression', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getChatCompression()).toEqual({
@@ -2328,6 +2325,7 @@ describe('loadCliConfig chatCompression', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getChatCompression()).toBeUndefined();
@@ -2360,6 +2358,7 @@ describe('loadCliConfig useRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseRipgrep()).toBe(true);
@@ -2376,6 +2375,7 @@ describe('loadCliConfig useRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseRipgrep()).toBe(false);
@@ -2392,6 +2392,7 @@ describe('loadCliConfig useRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseRipgrep()).toBe(true);
@@ -2424,6 +2425,7 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseBuiltinRipgrep()).toBe(true);
@@ -2440,6 +2442,7 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseBuiltinRipgrep()).toBe(false);
@@ -2456,6 +2459,7 @@ describe('loadCliConfig useBuiltinRipgrep', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getUseBuiltinRipgrep()).toBe(true);
@@ -2490,6 +2494,7 @@ describe('screenReader configuration', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getScreenReader()).toBe(true);
@@ -2508,6 +2513,7 @@ describe('screenReader configuration', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getScreenReader()).toBe(false);
@@ -2526,6 +2532,7 @@ describe('screenReader configuration', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getScreenReader()).toBe(true);
@@ -2542,6 +2549,7 @@ describe('screenReader configuration', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getScreenReader()).toBe(false);
@@ -2578,6 +2586,7 @@ describe('loadCliConfig tool exclusions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2596,6 +2605,7 @@ describe('loadCliConfig tool exclusions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2614,6 +2624,7 @@ describe('loadCliConfig tool exclusions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).toContain('run_shell_command');
@@ -2632,6 +2643,7 @@ describe('loadCliConfig tool exclusions', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getExcludeTools()).not.toContain('run_shell_command');
@@ -2669,6 +2681,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(true);
@@ -2685,6 +2698,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(true);
@@ -2701,6 +2715,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(false);
@@ -2717,6 +2732,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(false);
@@ -2733,6 +2749,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(false);
@@ -2756,6 +2773,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(false);
@@ -2775,6 +2793,7 @@ describe('loadCliConfig interactive', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.isInteractive()).toBe(true);
@@ -2808,6 +2827,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -2823,6 +2843,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -2838,6 +2859,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -2853,6 +2875,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -2868,6 +2891,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -2883,6 +2907,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.AUTO_EDIT);
@@ -2898,6 +2923,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -2914,6 +2940,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -2930,6 +2957,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.AUTO_EDIT);
@@ -2947,7 +2975,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      ),
    ).rejects.toThrow(
@@ -2969,6 +2997,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -2984,6 +3013,7 @@ describe('loadCliConfig approval mode', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.YOLO);
@@ -3008,7 +3038,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3024,7 +3054,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3040,7 +3070,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3056,7 +3086,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.DEFAULT);
@@ -3072,7 +3102,7 @@ describe('loadCliConfig approval mode', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(config.getApprovalMode()).toBe(ServerConfig.ApprovalMode.PLAN);
@@ -3159,7 +3189,7 @@ describe('loadCliConfig fileFiltering', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      );
      expect(getter(config)).toBe(value);
@@ -3178,6 +3208,7 @@ describe('Output format', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getOutputFormat()).toBe(OutputFormat.TEXT);
@@ -3193,6 +3224,7 @@ describe('Output format', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
@@ -3208,6 +3240,7 @@ describe('Output format', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getOutputFormat()).toBe(OutputFormat.JSON);
@@ -3300,6 +3333,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -3317,6 +3351,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryTarget()).toBe('gcp');
@@ -3335,7 +3370,7 @@ describe('Telemetry configuration via environment variables', () => {
          ExtensionStorage.getUserExtensionsDir(),
          argv.extensions,
        ),
-
+        'test-session',
        argv,
      ),
    ).rejects.toThrow(
@@ -3359,6 +3394,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpEndpoint()).toBe('http://gemini.env.com');
@@ -3376,6 +3412,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOtlpProtocol()).toBe('http');
@@ -3393,6 +3430,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
@@ -3412,6 +3450,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryOutfile()).toBe('/gemini/env/telemetry.log');
@@ -3429,6 +3468,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryUseCollector()).toBe(true);
@@ -3446,6 +3486,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -3463,6 +3504,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryTarget()).toBe('local');
@@ -3479,6 +3521,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(true);
@@ -3495,6 +3538,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryEnabled()).toBe(false);
@@ -3511,6 +3555,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(true);
@@ -3527,6 +3572,7 @@ describe('Telemetry configuration via environment variables', () => {
        ExtensionStorage.getUserExtensionsDir(),
        argv.extensions,
      ),
+      'test-session',
      argv,
    );
    expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -4,9 +4,14 @@
 * SPDX-License-Identifier: Apache-2.0
 */

+import type {
+  FileFilteringOptions,
+  MCPServerConfig,
+  OutputFormat,
+} from '@qwen-code/qwen-code-core';
+import { extensionsCommand } from '../commands/extensions.js';
 import {
  ApprovalMode,
-  AuthType,
  Config,
  DEFAULT_QWEN_EMBEDDING_MODEL,
  DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
@@ -19,15 +24,7 @@ import {
  WriteFileTool,
  resolveTelemetrySettings,
  FatalConfigError,
-  Storage,
-  InputFormat,
-  OutputFormat,
-  SessionService,
-  type ResumedSessionData,
-  type FileFilteringOptions,
-  type MCPServerConfig,
 } from '@qwen-code/qwen-code-core';
-import { extensionsCommand } from '../commands/extensions.js';
 import type { Settings } from './settings.js';
 import yargs, { type Argv } from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -127,32 +124,7 @@ export interface CliArgs {
  screenReader: boolean | undefined;
  vlmSwitchMode: string | undefined;
  useSmartEdit: boolean | undefined;
-  inputFormat?: string | undefined;
  outputFormat: string | undefined;
-  includePartialMessages?: boolean;
-  /** Resume the most recent session for the current project */
-  continue: boolean | undefined;
-  /** Resume a specific session by its ID */
-  resume: string | undefined;
-  maxSessionTurns: number | undefined;
-  coreTools: string[] | undefined;
-  excludeTools: string[] | undefined;
-  authType: string | undefined;
-}
-
-function normalizeOutputFormat(
-  format: string | OutputFormat | undefined,
-): OutputFormat | undefined {
-  if (!format) {
-    return undefined;
-  }
-  if (format === OutputFormat.STREAM_JSON) {
-    return OutputFormat.STREAM_JSON;
-  }
-  if (format === 'json' || format === OutputFormat.JSON) {
-    return OutputFormat.JSON;
-  }
-  return OutputFormat.TEXT;
 }

 export async function parseArguments(settings: Settings): Promise<CliArgs> {
@@ -387,64 +359,11 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
            'Default behavior when images are detected in input. Values: once (one-time switch), session (switch for entire session), persist (continue with current model). Overrides settings files.',
          default: process.env['VLM_SWITCH_MODE'],
        })
-        .option('input-format', {
-          type: 'string',
-          choices: ['text', 'stream-json'],
-          description: 'The format consumed from standard input.',
-          default: 'text',
-        })
        .option('output-format', {
          alias: 'o',
          type: 'string',
          description: 'The format of the CLI output.',
-          choices: ['text', 'json', 'stream-json'],
-        })
-        .option('include-partial-messages', {
-          type: 'boolean',
-          description:
-            'Include partial assistant messages when using stream-json output.',
-          default: false,
-        })
-        .option('continue', {
-          type: 'boolean',
-          description:
-            'Resume the most recent session for the current project.',
-          default: false,
-        })
-        .option('resume', {
-          type: 'string',
-          description:
-            'Resume a specific session by its ID. Use without an ID to show session picker.',
-        })
-        .option('max-session-turns', {
-          type: 'number',
-          description: 'Maximum number of session turns',
-        })
-        .option('core-tools', {
-          type: 'array',
-          string: true,
-          description: 'Core tool paths',
-          coerce: (tools: string[]) =>
-            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
-        })
-        .option('exclude-tools', {
-          type: 'array',
-          string: true,
-          description: 'Tools to exclude',
-          coerce: (tools: string[]) =>
-            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
-        })
-        .option('allowed-tools', {
-          type: 'array',
-          string: true,
-          description: 'Tools to allow, will bypass confirmation',
-          coerce: (tools: string[]) =>
-            tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
-        })
-        .option('auth-type', {
-          type: 'string',
-          choices: [AuthType.USE_OPENAI, AuthType.QWEN_OAUTH],
-          description: 'Authentication type',
+          choices: ['text', 'json'],
        })
        .deprecateOption(
          'show-memory-usage',
@@ -489,21 +408,6 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
          if (argv['yolo'] && argv['approvalMode']) {
            return 'Cannot use both --yolo (-y) and --approval-mode together. Use --approval-mode=yolo instead.';
          }
-          if (
-            argv['includePartialMessages'] &&
-            argv['outputFormat'] !== OutputFormat.STREAM_JSON
-          ) {
-            return '--include-partial-messages requires --output-format stream-json';
-          }
-          if (
-            argv['inputFormat'] === 'stream-json' &&
-            argv['outputFormat'] !== OutputFormat.STREAM_JSON
-          ) {
-            return '--input-format stream-json requires --output-format stream-json';
-          }
-          if (argv['continue'] && argv['resume']) {
-            return 'Cannot use both --continue and --resume together. Use --continue to resume the latest session, or --resume <sessionId> to resume a specific session.';
-          }
          return true;
        }),
    )
@@ -618,6 +522,7 @@ export async function loadCliConfig(
  settings: Settings,
  extensions: Extension[],
  extensionEnablementManager: ExtensionEnablementManager,
+  sessionId: string,
  argv: CliArgs,
  cwd: string = process.cwd(),
 ): Promise<Config> {
@@ -655,20 +560,6 @@ export async function loadCliConfig(
    (e) => e.contextFiles,
  );

-  // Automatically load output-language.md if it exists
-  const outputLanguageFilePath = path.join(
-    Storage.getGlobalQwenDir(),
-    'output-language.md',
-  );
-  if (fs.existsSync(outputLanguageFilePath)) {
-    extensionContextFilePaths.push(outputLanguageFilePath);
-    if (debugMode) {
-      logger.debug(
-        `Found output-language.md, adding to context files: ${outputLanguageFilePath}`,
-      );
-    }
-  }
-
  const fileService = new FileDiscoveryService(cwd);

  const fileFiltering = {
@@ -697,22 +588,6 @@ export async function loadCliConfig(

  let mcpServers = mergeMcpServers(settings, activeExtensions);
  const question = argv.promptInteractive || argv.prompt || '';
-  const inputFormat: InputFormat =
-    (argv.inputFormat as InputFormat | undefined) ?? InputFormat.TEXT;
-  const argvOutputFormat = normalizeOutputFormat(
-    argv.outputFormat as string | OutputFormat | undefined,
-  );
-  const settingsOutputFormat = normalizeOutputFormat(settings.output?.format);
-  const outputFormat =
-    argvOutputFormat ?? settingsOutputFormat ?? OutputFormat.TEXT;
-  const outputSettingsFormat: OutputFormat =
-    outputFormat === OutputFormat.STREAM_JSON
-      ? settingsOutputFormat &&
-        settingsOutputFormat !== OutputFormat.STREAM_JSON
-        ? settingsOutputFormat
-        : OutputFormat.TEXT
-      : (outputFormat as OutputFormat);
-  const includePartialMessages = Boolean(argv.includePartialMessages);

  // Determine approval mode with backward compatibility
  let approvalMode: ApprovalMode;
@@ -754,40 +629,14 @@ export async function loadCliConfig(
    throw err;
  }

-  // Interactive mode determination with priority:
-  // 1. If promptInteractive (-i flag) is provided, it is explicitly interactive
-  // 2. If outputFormat is stream-json or json (no matter input-format) along with query or prompt, it is non-interactive
-  // 3. If no query or prompt is provided, check isTTY: TTY means interactive, non-TTY means non-interactive
+  // Interactive mode: explicit -i flag or (TTY + no args + no -p flag)
  const hasQuery = !!argv.query;
-  const hasPrompt = !!argv.prompt;
-  let interactive: boolean;
-  if (argv.promptInteractive) {
-    // Priority 1: Explicit -i flag means interactive
-    interactive = true;
-  } else if (
-    (outputFormat === OutputFormat.STREAM_JSON ||
-      outputFormat === OutputFormat.JSON) &&
-    (hasQuery || hasPrompt)
-  ) {
-    // Priority 2: JSON/stream-json output with query/prompt means non-interactive
-    interactive = false;
-  } else if (!hasQuery && !hasPrompt) {
-    // Priority 3: No query or prompt means interactive only if TTY (format arguments ignored)
-    interactive = process.stdin.isTTY ?? false;
-  } else {
-    // Default: If we have query/prompt but output format is TEXT, assume non-interactive
-    // (fallback for edge cases where query/prompt is provided with TEXT output)
-    interactive = false;
-  }
+  const interactive =
+    !!argv.promptInteractive ||
+    (process.stdin.isTTY && !hasQuery && !argv.prompt);
  // In non-interactive mode, exclude tools that require a prompt.
-  // However, if stream-json input is used, control can be requested via JSON messages,
-  // so tools should not be excluded in that case.
  const extraExcludes: string[] = [];
-  if (
-    !interactive &&
-    !argv.experimentalAcp &&
-    inputFormat !== InputFormat.STREAM_JSON
-  ) {
+  if (!interactive && !argv.experimentalAcp) {
    switch (approvalMode) {
      case ApprovalMode.PLAN:
      case ApprovalMode.DEFAULT:
@@ -811,7 +660,6 @@ export async function loadCliConfig(
    settings,
    activeExtensions,
    extraExcludes.length > 0 ? extraExcludes : undefined,
-    argv.excludeTools,
  );
  const blockedMcpServers: Array<{ name: string; extensionName: string }> = [];

@@ -856,33 +704,8 @@ export async function loadCliConfig(

  const vlmSwitchMode =
    argv.vlmSwitchMode || settings.experimental?.vlmSwitchMode;
-
-  let sessionId: string | undefined;
-  let sessionData: ResumedSessionData | undefined;
-
-  if (argv.continue || argv.resume) {
-    const sessionService = new SessionService(cwd);
-    if (argv.continue) {
-      sessionData = await sessionService.loadLastSession();
-      if (sessionData) {
-        sessionId = sessionData.conversation.sessionId;
-      }
-    }
-
-    if (argv.resume) {
-      sessionId = argv.resume;
-      sessionData = await sessionService.loadSession(argv.resume);
-      if (!sessionData) {
-        const message = `No saved session found with ID ${argv.resume}. Run \`qwen --resume\` without an ID to choose from existing sessions.`;
-        console.log(message);
-        process.exit(1);
-      }
-    }
-  }
-
  return new Config({
    sessionId,
-    sessionData,
    embeddingModel: DEFAULT_QWEN_EMBEDDING_MODEL,
    sandbox: sandboxConfig,
    targetDir: cwd,
@@ -892,7 +715,7 @@ export async function loadCliConfig(
    debugMode,
    question,
    fullContext: argv.allFiles || false,
-    coreTools: argv.coreTools || settings.tools?.core || undefined,
+    coreTools: settings.tools?.core || undefined,
    allowedTools: argv.allowedTools || settings.tools?.allowed || undefined,
    excludeTools,
    toolDiscoveryCommand: settings.tools?.discoveryCommand,
@@ -925,19 +748,13 @@ export async function loadCliConfig(
    model: resolvedModel,
    extensionContextFilePaths,
    sessionTokenLimit: settings.model?.sessionTokenLimit ?? -1,
-    maxSessionTurns:
-      argv.maxSessionTurns ?? settings.model?.maxSessionTurns ?? -1,
+    maxSessionTurns: settings.model?.maxSessionTurns ?? -1,
    experimentalZedIntegration: argv.experimentalAcp || false,
    listExtensions: argv.listExtensions || false,
    extensions: allExtensions,
    blockedMcpServers,
    noBrowser: !!process.env['NO_BROWSER'],
-    authType:
-      (argv.authType as AuthType | undefined) ||
-      settings.security?.auth?.selectedType,
-    inputFormat,
-    outputFormat,
-    includePartialMessages,
+    authType: settings.security?.auth?.selectedType,
    generationConfig: {
      ...(settings.model?.generationConfig || {}),
      model: resolvedModel,
@@ -972,6 +789,7 @@ export async function loadCliConfig(
    useBuiltinRipgrep: settings.tools?.useBuiltinRipgrep,
    shouldUseNodePtyShell: settings.tools?.shell?.enableInteractiveShell,
    skipNextSpeakerCheck: settings.model?.skipNextSpeakerCheck,
+    enablePromptCompletion: settings.general?.enablePromptCompletion ?? false,
    skipLoopDetection: settings.model?.skipLoopDetection ?? false,
    skipStartupContext: settings.model?.skipStartupContext ?? false,
    vlmSwitchMode,
@@ -981,7 +799,7 @@ export async function loadCliConfig(
    eventEmitter: appEvents,
    useSmartEdit: argv.useSmartEdit ?? settings.useSmartEdit,
    output: {
-      format: outputSettingsFormat,
+      format: (argv.outputFormat ?? settings.output?.format) as OutputFormat,
    },
  });
 }
@@ -1042,10 +860,8 @@ function mergeExcludeTools(
  settings: Settings,
  extensions: Extension[],
  extraExcludes?: string[] | undefined,
-  cliExcludeTools?: string[] | undefined,
 ): string[] {
  const allExcludeTools = new Set([
-    ...(cliExcludeTools || []),
    ...(settings.tools?.exclude || []),
    ...(extraExcludes || []),
  ]);
--- a/packages/cli/src/config/extension.ts
+++ b/packages/cli/src/config/extension.ts
@@ -30,6 +30,7 @@ import { getErrorMessage } from '../utils/errors.js';
 import { recursivelyHydrateStrings } from './extensions/variables.js';
 import { isWorkspaceTrusted } from './trustedFolders.js';
 import { resolveEnvVarsInObject } from '../utils/envVarResolver.js';
+import { randomUUID } from 'node:crypto';
 import {
  cloneFromGit,
  downloadFromGitHubRelease,
@@ -133,6 +134,7 @@ function getTelemetryConfig(cwd: string) {
  const config = new Config({
    telemetry: settings.merged.telemetry,
    interactive: false,
+    sessionId: randomUUID(),
    targetDir: cwd,
    cwd,
    model: '',
--- a/packages/cli/src/config/settings.ts
+++ b/packages/cli/src/config/settings.ts
@@ -77,6 +77,7 @@ const MIGRATION_MAP: Record<string, string> = {
  disableAutoUpdate: 'general.disableAutoUpdate',
  disableUpdateNag: 'general.disableUpdateNag',
  dnsResolutionOrder: 'advanced.dnsResolutionOrder',
+  enablePromptCompletion: 'general.enablePromptCompletion',
  enforcedAuthType: 'security.auth.enforcedType',
  excludeTools: 'tools.exclude',
  excludeMCPServers: 'mcp.excluded',
@@ -483,27 +484,6 @@ export class LoadedSettings {
  }
 }

-/**
- * Creates a minimal LoadedSettings instance with empty settings.
- * Used in stream-json mode where settings are ignored.
- */
-export function createMinimalSettings(): LoadedSettings {
-  const emptySettingsFile: SettingsFile = {
-    path: '',
-    settings: {},
-    originalSettings: {},
-    rawJson: '{}',
-  };
-  return new LoadedSettings(
-    emptySettingsFile,
-    emptySettingsFile,
-    emptySettingsFile,
-    emptySettingsFile,
-    false,
-    new Set(),
-  );
-}
-
 function findEnvFile(startDir: string): string | null {
  let currentDir = path.resolve(startDir);
  while (true) {
@@ -859,6 +839,5 @@ export function saveSettings(settingsFile: SettingsFile): void {
    );
  } catch (error) {
    console.error('Error saving user settings file:', error);
-    throw error;
  }
 }
--- a/packages/cli/src/config/settingsSchema.ts
+++ b/packages/cli/src/config/settingsSchema.ts
@@ -167,6 +167,16 @@ const SETTINGS_SCHEMA = {
          },
        },
      },
+      enablePromptCompletion: {
+        type: 'boolean',
+        label: 'Enable Prompt Completion',
+        category: 'General',
+        requiresRestart: true,
+        default: false,
+        description:
+          'Enable AI-powered prompt completion suggestions while typing.',
+        showInDialog: true,
+      },
      debugKeystrokeLogging: {
        type: 'boolean',
        label: 'Debug Keystroke Logging',
@@ -176,23 +186,6 @@ const SETTINGS_SCHEMA = {
        description: 'Enable debug logging of keystrokes to the console.',
        showInDialog: true,
      },
-      language: {
-        type: 'enum',
-        label: 'Language',
-        category: 'General',
-        requiresRestart: false,
-        default: 'auto',
-        description:
-          'The language for the user interface. Use "auto" to detect from system settings. ' +
-          'You can also use custom language codes (e.g., "es", "fr") by placing JS language files ' +
-          'in ~/.qwen/locales/ (e.g., ~/.qwen/locales/es.js).',
-        showInDialog: true,
-        options: [
-          { value: 'auto', label: 'Auto (detect from system)' },
-          { value: 'en', label: 'English' },
-          { value: 'zh', label: '中文 (Chinese)' },
-        ],
-      },
    },
  },
  output: {
--- a/packages/cli/src/core/auth.ts
+++ b/packages/cli/src/core/auth.ts
@@ -8,8 +8,6 @@ import {
  type AuthType,
  type Config,
  getErrorMessage,
-  logAuth,
-  AuthEvent,
 } from '@qwen-code/qwen-code-core';

 /**
@@ -27,21 +25,11 @@ export async function performInitialAuth(
  }

  try {
-    await config.refreshAuth(authType, true);
+    await config.refreshAuth(authType);
    // The console.log is intentionally left out here.
    // We can add a dedicated startup message later if needed.
-
-    // Log authentication success
-    const authEvent = new AuthEvent(authType, 'auto', 'success');
-    logAuth(config, authEvent);
  } catch (e) {
-    const errorMessage = `Failed to login. Message: ${getErrorMessage(e)}`;
-
-    // Log authentication failure
-    const authEvent = new AuthEvent(authType, 'auto', 'error', errorMessage);
-    logAuth(config, authEvent);
-
-    return errorMessage;
+    return `Failed to login. Message: ${getErrorMessage(e)}`;
  }

  return null;
--- a/packages/cli/src/core/initializer.ts
+++ b/packages/cli/src/core/initializer.ts
@@ -11,10 +11,9 @@ import {
  logIdeConnection,
  type Config,
 } from '@qwen-code/qwen-code-core';
-import { type LoadedSettings, SettingScope } from '../config/settings.js';
+import { type LoadedSettings } from '../config/settings.js';
 import { performInitialAuth } from './auth.js';
 import { validateTheme } from './theme.js';
-import { initializeI18n } from '../i18n/index.js';

 export interface InitializationResult {
  authError: string | null;
@@ -34,24 +33,10 @@ export async function initializeApp(
  config: Config,
  settings: LoadedSettings,
 ): Promise<InitializationResult> {
-  // Initialize i18n system
-  const languageSetting =
-    process.env['QWEN_CODE_LANG'] ||
-    settings.merged.general?.language ||
-    'auto';
-  await initializeI18n(languageSetting);
-
-  const authType = settings.merged.security?.auth?.selectedType;
-  const authError = await performInitialAuth(config, authType);
-
-  // Fallback to user select when initial authentication fails
-  if (authError) {
-    settings.setValue(
-      SettingScope.User,
-      'security.auth.selectedType',
-      undefined,
-    );
-  }
+  const authError = await performInitialAuth(
+    config,
+    settings.merged.security?.auth?.selectedType,
+  );
  const themeError = validateTheme(settings);

  const shouldOpenAuthDialog =
--- a/packages/cli/src/core/theme.ts
+++ b/packages/cli/src/core/theme.ts
@@ -6,7 +6,6 @@

 import { themeManager } from '../ui/themes/theme-manager.js';
 import { type LoadedSettings } from '../config/settings.js';
-import { t } from '../i18n/index.js';

 /**
 * Validates the configured theme.
@@ -16,9 +15,7 @@ import { t } from '../i18n/index.js';
 export function validateTheme(settings: LoadedSettings): string | null {
  const effectiveTheme = settings.merged.ui?.theme;
  if (effectiveTheme && !themeManager.findThemeByName(effectiveTheme)) {
-    return t('Theme "{{themeName}}" not found.', {
-      themeName: effectiveTheme,
-    });
+    return `Theme "${effectiveTheme}" not found.`;
  }
  return null;
 }
--- a/packages/cli/src/gemini.test.tsx
+++ b/packages/cli/src/gemini.test.tsx
@@ -22,7 +22,6 @@ import {
 import { type LoadedSettings } from './config/settings.js';
 import { appEvents, AppEvent } from './utils/events.js';
 import type { Config } from '@qwen-code/qwen-code-core';
-import { OutputFormat } from '@qwen-code/qwen-code-core';

 // Custom error to identify mock process.exit calls
 class MockProcessExitError extends Error {
@@ -159,7 +158,6 @@ describe('gemini.tsx main function', () => {
        getScreenReader: () => false,
        getGeminiMdFileCount: () => 0,
        getProjectRoot: () => '/',
-        getOutputFormat: () => OutputFormat.TEXT,
      } as unknown as Config;
    });
    vi.mocked(loadSettings).mockReturnValue({
@@ -232,143 +230,6 @@ describe('gemini.tsx main function', () => {
    // Avoid the process.exit error from being thrown.
    processExitSpy.mockRestore();
  });
-
-  it('invokes runNonInteractiveStreamJson and performs cleanup in stream-json mode', async () => {
-    const originalIsTTY = Object.getOwnPropertyDescriptor(
-      process.stdin,
-      'isTTY',
-    );
-    const originalIsRaw = Object.getOwnPropertyDescriptor(
-      process.stdin,
-      'isRaw',
-    );
-    Object.defineProperty(process.stdin, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    Object.defineProperty(process.stdin, 'isRaw', {
-      value: false,
-      configurable: true,
-    });
-
-    const processExitSpy = vi
-      .spyOn(process, 'exit')
-      .mockImplementation((code) => {
-        throw new MockProcessExitError(code);
-      });
-
-    const { loadCliConfig, parseArguments } = await import(
-      './config/config.js'
-    );
-    const { loadSettings } = await import('./config/settings.js');
-    const cleanupModule = await import('./utils/cleanup.js');
-    const extensionModule = await import('./config/extension.js');
-    const validatorModule = await import('./validateNonInterActiveAuth.js');
-    const streamJsonModule = await import('./nonInteractive/session.js');
-    const initializerModule = await import('./core/initializer.js');
-    const startupWarningsModule = await import('./utils/startupWarnings.js');
-    const userStartupWarningsModule = await import(
-      './utils/userStartupWarnings.js'
-    );
-
-    vi.mocked(cleanupModule.cleanupCheckpoints).mockResolvedValue(undefined);
-    vi.mocked(cleanupModule.registerCleanup).mockImplementation(() => {});
-    const runExitCleanupMock = vi.mocked(cleanupModule.runExitCleanup);
-    runExitCleanupMock.mockResolvedValue(undefined);
-    vi.spyOn(extensionModule, 'loadExtensions').mockReturnValue([]);
-    vi.spyOn(
-      extensionModule.ExtensionStorage,
-      'getUserExtensionsDir',
-    ).mockReturnValue('/tmp/extensions');
-    vi.spyOn(initializerModule, 'initializeApp').mockResolvedValue({
-      authError: null,
-      themeError: null,
-      shouldOpenAuthDialog: false,
-      geminiMdFileCount: 0,
-    });
-    vi.spyOn(startupWarningsModule, 'getStartupWarnings').mockResolvedValue([]);
-    vi.spyOn(
-      userStartupWarningsModule,
-      'getUserStartupWarnings',
-    ).mockResolvedValue([]);
-
-    const validatedConfig = { validated: true } as unknown as Config;
-    const validateAuthSpy = vi
-      .spyOn(validatorModule, 'validateNonInteractiveAuth')
-      .mockResolvedValue(validatedConfig);
-    const runStreamJsonSpy = vi
-      .spyOn(streamJsonModule, 'runNonInteractiveStreamJson')
-      .mockResolvedValue(undefined);
-
-    vi.mocked(loadSettings).mockReturnValue({
-      errors: [],
-      merged: {
-        advanced: {},
-        security: { auth: {} },
-        ui: {},
-      },
-      setValue: vi.fn(),
-      forScope: () => ({ settings: {}, originalSettings: {}, path: '' }),
-    } as never);
-
-    vi.mocked(parseArguments).mockResolvedValue({
-      extensions: [],
-    } as never);
-
-    const configStub = {
-      isInteractive: () => false,
-      getQuestion: () => '  hello stream  ',
-      getSandbox: () => false,
-      getDebugMode: () => false,
-      getListExtensions: () => false,
-      getMcpServers: () => ({}),
-      initialize: vi.fn().mockResolvedValue(undefined),
-      getIdeMode: () => false,
-      getExperimentalZedIntegration: () => false,
-      getScreenReader: () => false,
-      getGeminiMdFileCount: () => 0,
-      getProjectRoot: () => '/',
-      getInputFormat: () => 'stream-json',
-      getContentGeneratorConfig: () => ({ authType: 'test-auth' }),
-    } as unknown as Config;
-
-    vi.mocked(loadCliConfig).mockResolvedValue(configStub);
-
-    process.env['SANDBOX'] = '1';
-    try {
-      await main();
-    } catch (error) {
-      if (!(error instanceof MockProcessExitError)) {
-        throw error;
-      }
-    } finally {
-      processExitSpy.mockRestore();
-      if (originalIsTTY) {
-        Object.defineProperty(process.stdin, 'isTTY', originalIsTTY);
-      } else {
-        delete (process.stdin as { isTTY?: unknown }).isTTY;
-      }
-      if (originalIsRaw) {
-        Object.defineProperty(process.stdin, 'isRaw', originalIsRaw);
-      } else {
-        delete (process.stdin as { isRaw?: unknown }).isRaw;
-      }
-      delete process.env['SANDBOX'];
-    }
-
-    expect(runStreamJsonSpy).toHaveBeenCalledTimes(1);
-    const [configArg, inputArg] = runStreamJsonSpy.mock.calls[0];
-    expect(configArg).toBe(validatedConfig);
-    expect(inputArg).toBe('hello stream');
-
-    expect(validateAuthSpy).toHaveBeenCalledWith(
-      undefined,
-      undefined,
-      configStub,
-      expect.any(Object),
-    );
-    expect(runExitCleanupMock).toHaveBeenCalledTimes(1);
-  });
 });

 describe('gemini.tsx main function kitty protocol', () => {
@@ -476,15 +337,7 @@ describe('gemini.tsx main function kitty protocol', () => {
      screenReader: undefined,
      vlmSwitchMode: undefined,
      useSmartEdit: undefined,
-      inputFormat: undefined,
      outputFormat: undefined,
-      includePartialMessages: undefined,
-      continue: undefined,
-      resume: undefined,
-      coreTools: undefined,
-      excludeTools: undefined,
-      authType: undefined,
-      maxSessionTurns: undefined,
    });

    await main();
@@ -559,7 +412,6 @@ describe('startInteractiveUI', () => {
  vi.mock('./utils/cleanup.js', () => ({
    cleanupCheckpoints: vi.fn(() => Promise.resolve()),
    registerCleanup: vi.fn(),
-    runExitCleanup: vi.fn(() => Promise.resolve()),
  }));

  vi.mock('ink', () => ({
--- a/packages/cli/src/gemini.tsx
+++ b/packages/cli/src/gemini.tsx
@@ -4,61 +4,59 @@
 * SPDX-License-Identifier: Apache-2.0
 */

-import type { Config } from '@qwen-code/qwen-code-core';
-import {
-  AuthType,
-  getOauthClient,
-  InputFormat,
-  logUserPrompt,
-} from '@qwen-code/qwen-code-core';
+import React from 'react';
 import { render } from 'ink';
-import dns from 'node:dns';
-import os from 'node:os';
+import { AppContainer } from './ui/AppContainer.js';
+import { loadCliConfig, parseArguments } from './config/config.js';
+import * as cliConfig from './config/config.js';
+import { readStdin } from './utils/readStdin.js';
 import { basename } from 'node:path';
 import v8 from 'node:v8';
-import React from 'react';
-import { validateAuthMethod } from './config/auth.js';
-import * as cliConfig from './config/config.js';
-import { loadCliConfig, parseArguments } from './config/config.js';
-import { ExtensionStorage, loadExtensions } from './config/extension.js';
+import os from 'node:os';
+import dns from 'node:dns';
+import { randomUUID } from 'node:crypto';
+import { start_sandbox } from './utils/sandbox.js';
 import type { DnsResolutionOrder, LoadedSettings } from './config/settings.js';
 import { loadSettings, migrateDeprecatedSettings } from './config/settings.js';
-import {
-  initializeApp,
-  type InitializationResult,
-} from './core/initializer.js';
-import { runNonInteractive } from './nonInteractiveCli.js';
-import { runNonInteractiveStreamJson } from './nonInteractive/session.js';
-import { AppContainer } from './ui/AppContainer.js';
-import { setMaxSizedBoxDebugging } from './ui/components/shared/MaxSizedBox.js';
-import { KeypressProvider } from './ui/contexts/KeypressContext.js';
-import { SessionStatsProvider } from './ui/contexts/SessionContext.js';
-import { SettingsContext } from './ui/contexts/SettingsContext.js';
-import { VimModeProvider } from './ui/contexts/VimModeContext.js';
-import { useKittyKeyboardProtocol } from './ui/hooks/useKittyKeyboardProtocol.js';
 import { themeManager } from './ui/themes/theme-manager.js';
+import { getStartupWarnings } from './utils/startupWarnings.js';
+import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
 import { ConsolePatcher } from './ui/utils/ConsolePatcher.js';
-import { detectAndEnableKittyProtocol } from './ui/utils/kittyProtocolDetector.js';
-import { checkForUpdates } from './ui/utils/updateCheck.js';
+import { runNonInteractive } from './nonInteractiveCli.js';
+import { ExtensionStorage, loadExtensions } from './config/extension.js';
 import {
  cleanupCheckpoints,
  registerCleanup,
  runExitCleanup,
 } from './utils/cleanup.js';
-import { AppEvent, appEvents } from './utils/events.js';
-import { handleAutoUpdate } from './utils/handleAutoUpdate.js';
-import { readStdin } from './utils/readStdin.js';
-import {
-  relaunchAppInChildProcess,
-  relaunchOnExitCode,
-} from './utils/relaunch.js';
-import { start_sandbox } from './utils/sandbox.js';
-import { getStartupWarnings } from './utils/startupWarnings.js';
-import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
 import { getCliVersion } from './utils/version.js';
+import type { Config } from '@qwen-code/qwen-code-core';
+import {
+  AuthType,
+  getOauthClient,
+  logUserPrompt,
+} from '@qwen-code/qwen-code-core';
+import {
+  initializeApp,
+  type InitializationResult,
+} from './core/initializer.js';
+import { validateAuthMethod } from './config/auth.js';
+import { setMaxSizedBoxDebugging } from './ui/components/shared/MaxSizedBox.js';
+import { SettingsContext } from './ui/contexts/SettingsContext.js';
+import { detectAndEnableKittyProtocol } from './ui/utils/kittyProtocolDetector.js';
+import { checkForUpdates } from './ui/utils/updateCheck.js';
+import { handleAutoUpdate } from './utils/handleAutoUpdate.js';
 import { computeWindowTitle } from './utils/windowTitle.js';
+import { SessionStatsProvider } from './ui/contexts/SessionContext.js';
+import { VimModeProvider } from './ui/contexts/VimModeContext.js';
+import { KeypressProvider } from './ui/contexts/KeypressContext.js';
+import { appEvents, AppEvent } from './utils/events.js';
+import { useKittyKeyboardProtocol } from './ui/hooks/useKittyKeyboardProtocol.js';
+import {
+  relaunchOnExitCode,
+  relaunchAppInChildProcess,
+} from './utils/relaunch.js';
 import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
-import { showResumeSessionPicker } from './ui/components/ResumeSessionPicker.js';

 export function validateDnsResolutionOrder(
  order: string | undefined,
@@ -108,9 +106,9 @@ function getNodeMemoryArgs(isDebugMode: boolean): string[] {
  return [];
 }

-import { ExtensionEnablementManager } from './config/extensions/extensionEnablement.js';
+import { runZedIntegration } from './zed-integration/zedIntegration.js';
 import { loadSandboxConfig } from './config/sandboxConfig.js';
-import { runAcpAgent } from './acp-integration/acpAgent.js';
+import { ExtensionEnablementManager } from './config/extensions/extensionEnablement.js';

 export function setupUnhandledRejectionHandler() {
  let unhandledRejectionOccurred = false;
@@ -158,7 +156,7 @@ export async function startInteractiveUI(
            process.platform === 'win32' || nodeMajorVersion < 20
          }
        >
-          <SessionStatsProvider sessionId={config.getSessionId()}>
+          <SessionStatsProvider>
            <VimModeProvider settings={settings}>
              <AppContainer
                config={config}
@@ -207,8 +205,9 @@ export async function main() {
  const settings = loadSettings();
  migrateDeprecatedSettings(settings);
  await cleanupCheckpoints();
+  const sessionId = randomUUID();

-  let argv = await parseArguments(settings.merged);
+  const argv = await parseArguments(settings.merged);

  // Check for invalid input combinations early to prevent crashes
  if (argv.promptInteractive && !process.stdin.isTTY) {
@@ -219,6 +218,12 @@ export async function main() {
  }

  const isDebugMode = cliConfig.isDebugMode(argv);
+  const consolePatcher = new ConsolePatcher({
+    stderr: true,
+    debugMode: isDebugMode,
+  });
+  consolePatcher.patch();
+  registerCleanup(consolePatcher.cleanup);

  dns.setDefaultResultOrder(
    validateDnsResolutionOrder(settings.merged.advanced?.dnsResolutionOrder),
@@ -252,6 +257,7 @@ export async function main() {
        settings.merged,
        [],
        new ExtensionEnablementManager(ExtensionStorage.getUserExtensionsDir()),
+        sessionId,
        argv,
      );

@@ -276,11 +282,8 @@ export async function main() {
          process.exit(1);
        }
      }
-      // For stream-json mode, don't read stdin here - it should be forwarded to the sandbox
-      // and consumed by StreamJsonInputReader inside the container
-      const inputFormat = argv.inputFormat as string | undefined;
      let stdinData = '';
-      if (!process.stdin.isTTY && inputFormat !== 'stream-json') {
+      if (!process.stdin.isTTY) {
        stdinData = await readStdin();
      }

@@ -320,18 +323,6 @@ export async function main() {
    }
  }

-  // Handle --resume without a session ID by showing the session picker
-  if (argv.resume === '') {
-    const selectedSessionId = await showResumeSessionPicker();
-    if (!selectedSessionId) {
-      // User cancelled or no sessions available
-      process.exit(0);
-    }
-
-    // Update argv with the selected session ID
-    argv = { ...argv, resume: selectedSessionId };
-  }
-
  // We are now past the logic handling potentially launching a child process
  // to run Gemini CLI. It is now safe to perform expensive initialization that
  // may have side effects.
@@ -345,6 +336,7 @@ export async function main() {
      settings.merged,
      extensions,
      extensionEnablementManager,
+      sessionId,
      argv,
    );

@@ -356,15 +348,6 @@ export async function main() {
      process.exit(0);
    }

-    // Setup unified ConsolePatcher based on interactive mode
-    const isInteractive = config.isInteractive();
-    const consolePatcher = new ConsolePatcher({
-      stderr: isInteractive,
-      debugMode: isDebugMode,
-    });
-    consolePatcher.patch();
-    registerCleanup(consolePatcher.cleanup);
-
    const wasRaw = process.stdin.isRaw;
    let kittyProtocolDetectionComplete: Promise<boolean> | undefined;
    if (config.isInteractive() && !wasRaw && process.stdin.isTTY) {
@@ -386,18 +369,7 @@ export async function main() {

    setMaxSizedBoxDebugging(isDebugMode);

-    // Check input format early to determine initialization flow
-    const inputFormat =
-      typeof config.getInputFormat === 'function'
-        ? config.getInputFormat()
-        : InputFormat.TEXT;
-
-    // For stream-json mode, defer config.initialize() until after the initialize control request
-    // For other modes, initialize normally
-    let initializationResult: InitializationResult | undefined;
-    if (inputFormat !== InputFormat.STREAM_JSON) {
-      initializationResult = await initializeApp(config, settings);
-    }
+    const initializationResult = await initializeApp(config, settings);

    if (
      settings.merged.security?.auth?.selectedType ===
@@ -409,7 +381,7 @@ export async function main() {
    }

    if (config.getExperimentalZedIntegration()) {
-      return runAcpAgent(config, settings, extensions, argv);
+      return runZedIntegration(config, settings, extensions, argv);
    }

    let input = config.getQuestion();
@@ -431,47 +403,21 @@ export async function main() {
        settings,
        startupWarnings,
        process.cwd(),
-        initializationResult!,
+        initializationResult,
      );
      return;
    }

-    // For non-stream-json mode, initialize config here
-    if (inputFormat !== InputFormat.STREAM_JSON) {
-      await config.initialize();
-    }
+    await config.initialize();

-    // Only read stdin if NOT in stream-json mode
-    // In stream-json mode, stdin is used for protocol messages (control requests, etc.)
-    // and should be consumed by StreamJsonInputReader instead
-    if (inputFormat !== InputFormat.STREAM_JSON && !process.stdin.isTTY) {
+    // If not a TTY, read from stdin
+    // This is for cases where the user pipes input directly into the command
+    if (!process.stdin.isTTY) {
      const stdinData = await readStdin();
      if (stdinData) {
        input = `${stdinData}\n\n${input}`;
      }
    }
-
-    const nonInteractiveConfig = await validateNonInteractiveAuth(
-      (argv.authType as AuthType) ||
-        settings.merged.security?.auth?.selectedType,
-      settings.merged.security?.auth?.useExternal,
-      config,
-      settings,
-    );
-
-    const prompt_id = Math.random().toString(16).slice(2);
-
-    if (inputFormat === InputFormat.STREAM_JSON) {
-      const trimmedInput = (input ?? '').trim();
-
-      await runNonInteractiveStreamJson(
-        nonInteractiveConfig,
-        trimmedInput.length > 0 ? trimmedInput : '',
-      );
-      await runExitCleanup();
-      process.exit(0);
-    }
-
    if (!input) {
      console.error(
        `No input provided via stdin. Input can be provided by piping data into gemini or using the --prompt option.`,
@@ -479,6 +425,7 @@ export async function main() {
      process.exit(1);
    }

+    const prompt_id = Math.random().toString(16).slice(2);
    logUserPrompt(config, {
      'event.name': 'user_prompt',
      'event.timestamp': new Date().toISOString(),
@@ -488,8 +435,15 @@ export async function main() {
      prompt_length: input.length,
    });

+    const nonInteractiveConfig = await validateNonInteractiveAuth(
+      settings.merged.security?.auth?.selectedType,
+      settings.merged.security?.auth?.useExternal,
+      config,
+      settings,
+    );
+
    if (config.getDebugMode()) {
-      console.log('Session ID: %s', config.getSessionId());
+      console.log('Session ID: %s', sessionId);
    }

    await runNonInteractive(nonInteractiveConfig, settings, input, prompt_id);
--- a/packages/cli/src/i18n/index.ts
+++ b/packages/cli/src/i18n/index.ts
@@ -1,232 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { homedir } from 'node:os';
-
-export type SupportedLanguage = 'en' | 'zh' | string; // Allow custom language codes
-
-// State
-let currentLanguage: SupportedLanguage = 'en';
-let translations: Record<string, string> = {};
-
-// Cache
-type TranslationDict = Record<string, string>;
-const translationCache: Record<string, TranslationDict> = {};
-const loadingPromises: Record<string, Promise<TranslationDict>> = {};
-
-// Path helpers
-const getBuiltinLocalesDir = (): string => {
-  const __filename = fileURLToPath(import.meta.url);
-  return path.join(path.dirname(__filename), 'locales');
-};
-
-const getUserLocalesDir = (): string =>
-  path.join(homedir(), '.qwen', 'locales');
-
-/**
- * Get the path to the user's custom locales directory.
- * Users can place custom language packs (e.g., es.js, fr.js) in this directory.
- * @returns The path to ~/.qwen/locales
- */
-export function getUserLocalesDirectory(): string {
-  return getUserLocalesDir();
-}
-
-const getLocalePath = (
-  lang: SupportedLanguage,
-  useUserDir: boolean = false,
-): string => {
-  const baseDir = useUserDir ? getUserLocalesDir() : getBuiltinLocalesDir();
-  return path.join(baseDir, `${lang}.js`);
-};
-
-// Language detection
-export function detectSystemLanguage(): SupportedLanguage {
-  const envLang = process.env['QWEN_CODE_LANG'] || process.env['LANG'];
-  if (envLang?.startsWith('zh')) return 'zh';
-  if (envLang?.startsWith('en')) return 'en';
-
-  try {
-    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-    if (locale.startsWith('zh')) return 'zh';
-  } catch {
-    // Fallback to default
-  }
-
-  return 'en';
-}
-
-// Translation loading
-async function loadTranslationsAsync(
-  lang: SupportedLanguage,
-): Promise<TranslationDict> {
-  if (translationCache[lang]) {
-    return translationCache[lang];
-  }
-
-  const existingPromise = loadingPromises[lang];
-  if (existingPromise) {
-    return existingPromise;
-  }
-
-  const loadPromise = (async () => {
-    // Try user directory first (for custom language packs), then builtin directory
-    const searchDirs = [
-      { dir: getUserLocalesDir(), isUser: true },
-      { dir: getBuiltinLocalesDir(), isUser: false },
-    ];
-
-    for (const { dir, isUser } of searchDirs) {
-      // Ensure directory exists
-      if (!fs.existsSync(dir)) {
-        continue;
-      }
-
-      const jsPath = getLocalePath(lang, isUser);
-      if (!fs.existsSync(jsPath)) {
-        continue;
-      }
-
-      try {
-        // Convert file path to file:// URL for cross-platform compatibility
-        const fileUrl = pathToFileURL(jsPath).href;
-        try {
-          const module = await import(fileUrl);
-          const result = module.default || module;
-          if (
-            result &&
-            typeof result === 'object' &&
-            Object.keys(result).length > 0
-          ) {
-            translationCache[lang] = result;
-            return result;
-          } else {
-            throw new Error('Module loaded but result is empty or invalid');
-          }
-        } catch {
-          // For builtin locales, try alternative import method (relative path)
-          if (!isUser) {
-            try {
-              const module = await import(`./locales/${lang}.js`);
-              const result = module.default || module;
-              if (
-                result &&
-                typeof result === 'object' &&
-                Object.keys(result).length > 0
-              ) {
-                translationCache[lang] = result;
-                return result;
-              }
-            } catch {
-              // Continue to next directory
-            }
-          }
-          // If import failed, continue to next directory
-          continue;
-        }
-      } catch (error) {
-        // Log warning but continue to next directory
-        if (isUser) {
-          console.warn(
-            `Failed to load translations from user directory for ${lang}:`,
-            error,
-          );
-        } else {
-          console.warn(`Failed to load JS translations for ${lang}:`, error);
-          if (error instanceof Error) {
-            console.warn(`Error details: ${error.message}`);
-            console.warn(`Stack: ${error.stack}`);
-          }
-        }
-        // Continue to next directory
-        continue;
-      }
-    }
-
-    // Return empty object if both directories fail
-    // Cache it to avoid repeated failed attempts
-    translationCache[lang] = {};
-    return {};
-  })();
-
-  loadingPromises[lang] = loadPromise;
-
-  // Clean up promise after completion to allow retry on next call if needed
-  loadPromise.finally(() => {
-    delete loadingPromises[lang];
-  });
-
-  return loadPromise;
-}
-
-function loadTranslations(lang: SupportedLanguage): TranslationDict {
-  // Only return from cache (JS files require async loading)
-  return translationCache[lang] || {};
-}
-
-// String interpolation
-function interpolate(
-  template: string,
-  params?: Record<string, string>,
-): string {
-  if (!params) return template;
-  return template.replace(
-    /\{\{(\w+)\}\}/g,
-    (match, key) => params[key] ?? match,
-  );
-}
-
-// Language setting helpers
-function resolveLanguage(lang: SupportedLanguage | 'auto'): SupportedLanguage {
-  return lang === 'auto' ? detectSystemLanguage() : lang;
-}
-
-// Public API
-export function setLanguage(lang: SupportedLanguage | 'auto'): void {
-  const resolvedLang = resolveLanguage(lang);
-  currentLanguage = resolvedLang;
-
-  // Try to load translations synchronously (from cache only)
-  const loaded = loadTranslations(resolvedLang);
-  translations = loaded;
-
-  // Warn if translations are empty and JS file exists (requires async loading)
-  if (Object.keys(loaded).length === 0) {
-    const userJsPath = getLocalePath(resolvedLang, true);
-    const builtinJsPath = getLocalePath(resolvedLang, false);
-    if (fs.existsSync(userJsPath) || fs.existsSync(builtinJsPath)) {
-      console.warn(
-        `Language file for ${resolvedLang} requires async loading. ` +
-          `Use setLanguageAsync() instead, or call initializeI18n() first.`,
-      );
-    }
-  }
-}
-
-export async function setLanguageAsync(
-  lang: SupportedLanguage | 'auto',
-): Promise<void> {
-  currentLanguage = resolveLanguage(lang);
-  translations = await loadTranslationsAsync(currentLanguage);
-}
-
-export function getCurrentLanguage(): SupportedLanguage {
-  return currentLanguage;
-}
-
-export function t(key: string, params?: Record<string, string>): string {
-  const translation = translations[key] ?? key;
-  return interpolate(translation, params);
-}
-
-export async function initializeI18n(
-  lang?: SupportedLanguage | 'auto',
-): Promise<void> {
-  await setLanguageAsync(lang ?? 'auto');
-}
--- a/packages/cli/src/i18n/locales/en.js
+++ b/packages/cli/src/i18n/locales/en.js
--- a/packages/cli/src/i18n/locales/zh.js
+++ b/packages/cli/src/i18n/locales/zh.js
--- a/packages/cli/src/nonInteractive/control/ControlContext.ts
+++ b/packages/cli/src/nonInteractive/control/ControlContext.ts
@@ -1,76 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Control Context
- *
- * Layer 1 of the control plane architecture. Provides shared, session-scoped
- * state for all controllers and services, eliminating the need for prop
- * drilling. Mutable fields are intentionally exposed so controllers can track
- * runtime state (e.g. permission mode, active MCP clients).
- */
-
-import type { Config, MCPServerConfig } from '@qwen-code/qwen-code-core';
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import type { StreamJsonOutputAdapter } from '../io/StreamJsonOutputAdapter.js';
-import type { PermissionMode } from '../types.js';
-
-/**
- * Control Context interface
- *
- * Provides shared access to session-scoped resources and mutable state
- * for all controllers across both ControlDispatcher (protocol routing) and
- * ControlService (programmatic API).
- */
-export interface IControlContext {
-  readonly config: Config;
-  readonly streamJson: StreamJsonOutputAdapter;
-  readonly sessionId: string;
-  readonly abortSignal: AbortSignal;
-  readonly debugMode: boolean;
-
-  permissionMode: PermissionMode;
-  sdkMcpServers: Set<string>;
-  mcpClients: Map<string, { client: Client; config: MCPServerConfig }>;
-
-  onInterrupt?: () => void;
-}
-
-/**
- * Control Context implementation
- */
-export class ControlContext implements IControlContext {
-  readonly config: Config;
-  readonly streamJson: StreamJsonOutputAdapter;
-  readonly sessionId: string;
-  readonly abortSignal: AbortSignal;
-  readonly debugMode: boolean;
-
-  permissionMode: PermissionMode;
-  sdkMcpServers: Set<string>;
-  mcpClients: Map<string, { client: Client; config: MCPServerConfig }>;
-
-  onInterrupt?: () => void;
-
-  constructor(options: {
-    config: Config;
-    streamJson: StreamJsonOutputAdapter;
-    sessionId: string;
-    abortSignal: AbortSignal;
-    permissionMode?: PermissionMode;
-    onInterrupt?: () => void;
-  }) {
-    this.config = options.config;
-    this.streamJson = options.streamJson;
-    this.sessionId = options.sessionId;
-    this.abortSignal = options.abortSignal;
-    this.debugMode = options.config.getDebugMode();
-    this.permissionMode = options.permissionMode || 'default';
-    this.sdkMcpServers = new Set();
-    this.mcpClients = new Map();
-    this.onInterrupt = options.onInterrupt;
-  }
-}
--- a/packages/cli/src/nonInteractive/control/ControlDispatcher.test.ts
+++ b/packages/cli/src/nonInteractive/control/ControlDispatcher.test.ts
@@ -1,924 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ControlDispatcher } from './ControlDispatcher.js';
-import type { IControlContext } from './ControlContext.js';
-import type { SystemController } from './controllers/systemController.js';
-import type { StreamJsonOutputAdapter } from '../io/StreamJsonOutputAdapter.js';
-import type {
-  CLIControlRequest,
-  CLIControlResponse,
-  ControlResponse,
-  ControlRequestPayload,
-  CLIControlInitializeRequest,
-  CLIControlInterruptRequest,
-  CLIControlSetModelRequest,
-  CLIControlSupportedCommandsRequest,
-} from '../types.js';
-
-/**
- * Creates a mock control context for testing
- */
-function createMockContext(debugMode: boolean = false): IControlContext {
-  const abortController = new AbortController();
-  const mockStreamJson = {
-    send: vi.fn(),
-  } as unknown as StreamJsonOutputAdapter;
-
-  const mockConfig = {
-    getDebugMode: vi.fn().mockReturnValue(debugMode),
-  };
-
-  return {
-    config: mockConfig as unknown as IControlContext['config'],
-    streamJson: mockStreamJson,
-    sessionId: 'test-session-id',
-    abortSignal: abortController.signal,
-    debugMode,
-    permissionMode: 'default',
-    sdkMcpServers: new Set<string>(),
-    mcpClients: new Map(),
-  };
-}
-
-/**
- * Creates a mock system controller for testing
- */
-function createMockSystemController() {
-  return {
-    handleRequest: vi.fn(),
-    sendControlRequest: vi.fn(),
-    cleanup: vi.fn(),
-  } as unknown as SystemController;
-}
-
-describe('ControlDispatcher', () => {
-  let dispatcher: ControlDispatcher;
-  let mockContext: IControlContext;
-  let mockSystemController: SystemController;
-
-  beforeEach(() => {
-    mockContext = createMockContext();
-    mockSystemController = createMockSystemController();
-
-    // Mock SystemController constructor
-    vi.doMock('./controllers/systemController.js', () => ({
-      SystemController: vi.fn().mockImplementation(() => mockSystemController),
-    }));
-
-    dispatcher = new ControlDispatcher(mockContext);
-    // Replace with mock controller for easier testing
-    (
-      dispatcher as unknown as { systemController: SystemController }
-    ).systemController = mockSystemController;
-  });
-
-  describe('constructor', () => {
-    it('should initialize with context and create controllers', () => {
-      expect(dispatcher).toBeDefined();
-      expect(dispatcher.systemController).toBeDefined();
-    });
-
-    it('should listen to abort signal and shutdown when aborted', () => {
-      const abortController = new AbortController();
-
-      const context = {
-        ...createMockContext(),
-        abortSignal: abortController.signal,
-      };
-
-      const newDispatcher = new ControlDispatcher(context);
-      vi.spyOn(newDispatcher, 'shutdown');
-
-      abortController.abort();
-
-      // Give event loop a chance to process
-      return new Promise<void>((resolve) => {
-        setImmediate(() => {
-          expect(newDispatcher.shutdown).toHaveBeenCalled();
-          resolve();
-        });
-      });
-    });
-  });
-
-  describe('dispatch', () => {
-    it('should route initialize request to system controller', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-1',
-        request: {
-          subtype: 'initialize',
-        } as CLIControlInitializeRequest,
-      };
-
-      const mockResponse = {
-        subtype: 'initialize',
-        capabilities: { test: true },
-      };
-
-      vi.mocked(mockSystemController.handleRequest).mockResolvedValue(
-        mockResponse,
-      );
-
-      await dispatcher.dispatch(request);
-
-      expect(mockSystemController.handleRequest).toHaveBeenCalledWith(
-        request.request,
-        'req-1',
-      );
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'req-1',
-          response: mockResponse,
-        },
-      });
-    });
-
-    it('should route interrupt request to system controller', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-2',
-        request: {
-          subtype: 'interrupt',
-        } as CLIControlInterruptRequest,
-      };
-
-      const mockResponse = { subtype: 'interrupt' };
-
-      vi.mocked(mockSystemController.handleRequest).mockResolvedValue(
-        mockResponse,
-      );
-
-      await dispatcher.dispatch(request);
-
-      expect(mockSystemController.handleRequest).toHaveBeenCalledWith(
-        request.request,
-        'req-2',
-      );
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'req-2',
-          response: mockResponse,
-        },
-      });
-    });
-
-    it('should route set_model request to system controller', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-3',
-        request: {
-          subtype: 'set_model',
-          model: 'test-model',
-        } as CLIControlSetModelRequest,
-      };
-
-      const mockResponse = {
-        subtype: 'set_model',
-        model: 'test-model',
-      };
-
-      vi.mocked(mockSystemController.handleRequest).mockResolvedValue(
-        mockResponse,
-      );
-
-      await dispatcher.dispatch(request);
-
-      expect(mockSystemController.handleRequest).toHaveBeenCalledWith(
-        request.request,
-        'req-3',
-      );
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'req-3',
-          response: mockResponse,
-        },
-      });
-    });
-
-    it('should route supported_commands request to system controller', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-4',
-        request: {
-          subtype: 'supported_commands',
-        } as CLIControlSupportedCommandsRequest,
-      };
-
-      const mockResponse = {
-        subtype: 'supported_commands',
-        commands: ['initialize', 'interrupt'],
-      };
-
-      vi.mocked(mockSystemController.handleRequest).mockResolvedValue(
-        mockResponse,
-      );
-
-      await dispatcher.dispatch(request);
-
-      expect(mockSystemController.handleRequest).toHaveBeenCalledWith(
-        request.request,
-        'req-4',
-      );
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'req-4',
-          response: mockResponse,
-        },
-      });
-    });
-
-    it('should send error response when controller throws error', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-5',
-        request: {
-          subtype: 'initialize',
-        } as CLIControlInitializeRequest,
-      };
-
-      const error = new Error('Test error');
-      vi.mocked(mockSystemController.handleRequest).mockRejectedValue(error);
-
-      await dispatcher.dispatch(request);
-
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: 'req-5',
-          error: 'Test error',
-        },
-      });
-    });
-
-    it('should handle non-Error thrown values', async () => {
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: 'req-6',
-        request: {
-          subtype: 'initialize',
-        } as CLIControlInitializeRequest,
-      };
-
-      vi.mocked(mockSystemController.handleRequest).mockRejectedValue(
-        'String error',
-      );
-
-      await dispatcher.dispatch(request);
-
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: 'req-6',
-          error: 'String error',
-        },
-      });
-    });
-
-    it('should send error response for unknown request subtype', async () => {
-      const request = {
-        type: 'control_request' as const,
-        request_id: 'req-7',
-        request: {
-          subtype: 'unknown_subtype',
-        } as unknown as ControlRequestPayload,
-      };
-
-      await dispatcher.dispatch(request);
-
-      // Dispatch catches errors and sends error response instead of throwing
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: 'req-7',
-          error: 'Unknown control request subtype: unknown_subtype',
-        },
-      });
-    });
-  });
-
-  describe('handleControlResponse', () => {
-    it('should resolve pending outgoing request on success response', () => {
-      const requestId = 'outgoing-req-1';
-      const response: CLIControlResponse = {
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: requestId,
-          response: { result: 'success' },
-        },
-      };
-
-      // Register a pending outgoing request
-      const resolve = vi.fn();
-      const reject = vi.fn();
-      const timeoutId = setTimeout(() => {}, 1000);
-
-      // Access private method through type casting
-      (
-        dispatcher as unknown as {
-          registerOutgoingRequest: (
-            id: string,
-            controller: string,
-            resolve: (r: ControlResponse) => void,
-            reject: (e: Error) => void,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerOutgoingRequest(
-        requestId,
-        'SystemController',
-        resolve,
-        reject,
-        timeoutId,
-      );
-
-      dispatcher.handleControlResponse(response);
-
-      expect(resolve).toHaveBeenCalledWith(response.response);
-      expect(reject).not.toHaveBeenCalled();
-    });
-
-    it('should reject pending outgoing request on error response', () => {
-      const requestId = 'outgoing-req-2';
-      const response: CLIControlResponse = {
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: requestId,
-          error: 'Request failed',
-        },
-      };
-
-      const resolve = vi.fn();
-      const reject = vi.fn();
-      const timeoutId = setTimeout(() => {}, 1000);
-
-      (
-        dispatcher as unknown as {
-          registerOutgoingRequest: (
-            id: string,
-            controller: string,
-            resolve: (r: ControlResponse) => void,
-            reject: (e: Error) => void,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerOutgoingRequest(
-        requestId,
-        'SystemController',
-        resolve,
-        reject,
-        timeoutId,
-      );
-
-      dispatcher.handleControlResponse(response);
-
-      expect(reject).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'Request failed',
-        }),
-      );
-      expect(resolve).not.toHaveBeenCalled();
-    });
-
-    it('should handle error object in error response', () => {
-      const requestId = 'outgoing-req-3';
-      const response: CLIControlResponse = {
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: requestId,
-          error: { message: 'Detailed error', code: 500 },
-        },
-      };
-
-      const resolve = vi.fn();
-      const reject = vi.fn();
-      const timeoutId = setTimeout(() => {}, 1000);
-
-      (
-        dispatcher as unknown as {
-          registerOutgoingRequest: (
-            id: string,
-            controller: string,
-            resolve: (r: ControlResponse) => void,
-            reject: (e: Error) => void,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerOutgoingRequest(
-        requestId,
-        'SystemController',
-        resolve,
-        reject,
-        timeoutId,
-      );
-
-      dispatcher.handleControlResponse(response);
-
-      expect(reject).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'Detailed error',
-        }),
-      );
-    });
-
-    it('should handle response for non-existent pending request gracefully', () => {
-      const response: CLIControlResponse = {
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'non-existent',
-          response: {},
-        },
-      };
-
-      // Should not throw
-      expect(() => dispatcher.handleControlResponse(response)).not.toThrow();
-    });
-
-    it('should handle response for non-existent request in debug mode', () => {
-      const context = createMockContext(true);
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => {});
-
-      const dispatcherWithDebug = new ControlDispatcher(context);
-      const response: CLIControlResponse = {
-        type: 'control_response',
-        response: {
-          subtype: 'success',
-          request_id: 'non-existent',
-          response: {},
-        },
-      };
-
-      dispatcherWithDebug.handleControlResponse(response);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          '[ControlDispatcher] No pending outgoing request for: non-existent',
-        ),
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('sendControlRequest', () => {
-    it('should delegate to system controller sendControlRequest', async () => {
-      const payload: ControlRequestPayload = {
-        subtype: 'initialize',
-      } as CLIControlInitializeRequest;
-
-      const expectedResponse: ControlResponse = {
-        subtype: 'success',
-        request_id: 'test-id',
-        response: {},
-      };
-
-      vi.mocked(mockSystemController.sendControlRequest).mockResolvedValue(
-        expectedResponse,
-      );
-
-      const result = await dispatcher.sendControlRequest(payload, 5000);
-
-      expect(mockSystemController.sendControlRequest).toHaveBeenCalledWith(
-        payload,
-        5000,
-      );
-      expect(result).toBe(expectedResponse);
-    });
-  });
-
-  describe('handleCancel', () => {
-    it('should cancel specific incoming request', () => {
-      const requestId = 'cancel-req-1';
-      const abortController = new AbortController();
-      const timeoutId = setTimeout(() => {}, 1000);
-
-      const abortSpy = vi.spyOn(abortController, 'abort');
-
-      (
-        dispatcher as unknown as {
-          registerIncomingRequest: (
-            id: string,
-            controller: string,
-            abortController: AbortController,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerIncomingRequest(
-        requestId,
-        'SystemController',
-        abortController,
-        timeoutId,
-      );
-
-      dispatcher.handleCancel(requestId);
-
-      expect(abortSpy).toHaveBeenCalled();
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: requestId,
-          error: 'Request cancelled',
-        },
-      });
-    });
-
-    it('should cancel all incoming requests when no requestId provided', () => {
-      const requestId1 = 'cancel-req-2';
-      const requestId2 = 'cancel-req-3';
-
-      const abortController1 = new AbortController();
-      const abortController2 = new AbortController();
-      const timeoutId1 = setTimeout(() => {}, 1000);
-      const timeoutId2 = setTimeout(() => {}, 1000);
-
-      const abortSpy1 = vi.spyOn(abortController1, 'abort');
-      const abortSpy2 = vi.spyOn(abortController2, 'abort');
-
-      const register = (
-        dispatcher as unknown as {
-          registerIncomingRequest: (
-            id: string,
-            controller: string,
-            abortController: AbortController,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerIncomingRequest.bind(dispatcher);
-
-      register(requestId1, 'SystemController', abortController1, timeoutId1);
-      register(requestId2, 'SystemController', abortController2, timeoutId2);
-
-      dispatcher.handleCancel();
-
-      expect(abortSpy1).toHaveBeenCalled();
-      expect(abortSpy2).toHaveBeenCalled();
-      expect(mockContext.streamJson.send).toHaveBeenCalledTimes(2);
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: requestId1,
-          error: 'All requests cancelled',
-        },
-      });
-      expect(mockContext.streamJson.send).toHaveBeenCalledWith({
-        type: 'control_response',
-        response: {
-          subtype: 'error',
-          request_id: requestId2,
-          error: 'All requests cancelled',
-        },
-      });
-    });
-
-    it('should handle cancel of non-existent request gracefully', () => {
-      expect(() => dispatcher.handleCancel('non-existent')).not.toThrow();
-    });
-
-    it('should log cancellation in debug mode', () => {
-      const context = createMockContext(true);
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => {});
-
-      const dispatcherWithDebug = new ControlDispatcher(context);
-      const requestId = 'cancel-req-debug';
-      const abortController = new AbortController();
-      const timeoutId = setTimeout(() => {}, 1000);
-
-      (
-        dispatcherWithDebug as unknown as {
-          registerIncomingRequest: (
-            id: string,
-            controller: string,
-            abortController: AbortController,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerIncomingRequest(
-        requestId,
-        'SystemController',
-        abortController,
-        timeoutId,
-      );
-
-      dispatcherWithDebug.handleCancel(requestId);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          '[ControlDispatcher] Cancelled incoming request: cancel-req-debug',
-        ),
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('shutdown', () => {
-    it('should cancel all pending incoming requests', () => {
-      const requestId1 = 'shutdown-req-1';
-      const requestId2 = 'shutdown-req-2';
-
-      const abortController1 = new AbortController();
-      const abortController2 = new AbortController();
-      const timeoutId1 = setTimeout(() => {}, 1000);
-      const timeoutId2 = setTimeout(() => {}, 1000);
-
-      const abortSpy1 = vi.spyOn(abortController1, 'abort');
-      const abortSpy2 = vi.spyOn(abortController2, 'abort');
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-
-      const register = (
-        dispatcher as unknown as {
-          registerIncomingRequest: (
-            id: string,
-            controller: string,
-            abortController: AbortController,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerIncomingRequest.bind(dispatcher);
-
-      register(requestId1, 'SystemController', abortController1, timeoutId1);
-      register(requestId2, 'SystemController', abortController2, timeoutId2);
-
-      dispatcher.shutdown();
-
-      expect(abortSpy1).toHaveBeenCalled();
-      expect(abortSpy2).toHaveBeenCalled();
-      expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId1);
-      expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId2);
-    });
-
-    it('should reject all pending outgoing requests', () => {
-      const requestId1 = 'outgoing-shutdown-1';
-      const requestId2 = 'outgoing-shutdown-2';
-
-      const reject1 = vi.fn();
-      const reject2 = vi.fn();
-      const timeoutId1 = setTimeout(() => {}, 1000);
-      const timeoutId2 = setTimeout(() => {}, 1000);
-
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-
-      const register = (
-        dispatcher as unknown as {
-          registerOutgoingRequest: (
-            id: string,
-            controller: string,
-            resolve: (r: ControlResponse) => void,
-            reject: (e: Error) => void,
-            timeoutId: NodeJS.Timeout,
-          ) => void;
-        }
-      ).registerOutgoingRequest.bind(dispatcher);
-
-      register(requestId1, 'SystemController', vi.fn(), reject1, timeoutId1);
-      register(requestId2, 'SystemController', vi.fn(), reject2, timeoutId2);
-
-      dispatcher.shutdown();
-
-      expect(reject1).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'Dispatcher shutdown',
-        }),
-      );
-      expect(reject2).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'Dispatcher shutdown',
-        }),
-      );
-      expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId1);
-      expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId2);
-    });
-
-    it('should cleanup all controllers', () => {
-      vi.mocked(mockSystemController.cleanup).mockImplementation(() => {});
-
-      dispatcher.shutdown();
-
-      expect(mockSystemController.cleanup).toHaveBeenCalled();
-    });
-
-    it('should log shutdown in debug mode', () => {
-      const context = createMockContext(true);
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => {});
-
-      const dispatcherWithDebug = new ControlDispatcher(context);
-
-      dispatcherWithDebug.shutdown();
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[ControlDispatcher] Shutting down',
-      );
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('pending request registry', () => {
-    describe('registerIncomingRequest', () => {
-      it('should register incoming request', () => {
-        const requestId = 'reg-incoming-1';
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => {}, 1000);
-
-        (
-          dispatcher as unknown as {
-            registerIncomingRequest: (
-              id: string,
-              controller: string,
-              abortController: AbortController,
-              timeoutId: NodeJS.Timeout,
-            ) => void;
-          }
-        ).registerIncomingRequest(
-          requestId,
-          'SystemController',
-          abortController,
-          timeoutId,
-        );
-
-        // Verify it was registered by trying to cancel it
-        dispatcher.handleCancel(requestId);
-        expect(abortController.signal.aborted).toBe(true);
-      });
-    });
-
-    describe('deregisterIncomingRequest', () => {
-      it('should deregister incoming request', () => {
-        const requestId = 'dereg-incoming-1';
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => {}, 1000);
-
-        const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-
-        (
-          dispatcher as unknown as {
-            registerIncomingRequest: (
-              id: string,
-              controller: string,
-              abortController: AbortController,
-              timeoutId: NodeJS.Timeout,
-            ) => void;
-            deregisterIncomingRequest: (id: string) => void;
-          }
-        ).registerIncomingRequest(
-          requestId,
-          'SystemController',
-          abortController,
-          timeoutId,
-        );
-
-        (
-          dispatcher as unknown as {
-            deregisterIncomingRequest: (id: string) => void;
-          }
-        ).deregisterIncomingRequest(requestId);
-
-        // Verify it was deregistered - cancel should not find it
-        const sendMock = vi.mocked(mockContext.streamJson.send);
-        const sendCallCount = sendMock.mock.calls.length;
-        dispatcher.handleCancel(requestId);
-        // Should not send cancel response for non-existent request
-        expect(sendMock.mock.calls.length).toBe(sendCallCount);
-        expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId);
-      });
-
-      it('should handle deregister of non-existent request gracefully', () => {
-        expect(() => {
-          (
-            dispatcher as unknown as {
-              deregisterIncomingRequest: (id: string) => void;
-            }
-          ).deregisterIncomingRequest('non-existent');
-        }).not.toThrow();
-      });
-    });
-
-    describe('registerOutgoingRequest', () => {
-      it('should register outgoing request', () => {
-        const requestId = 'reg-outgoing-1';
-        const resolve = vi.fn();
-        const reject = vi.fn();
-        const timeoutId = setTimeout(() => {}, 1000);
-
-        (
-          dispatcher as unknown as {
-            registerOutgoingRequest: (
-              id: string,
-              controller: string,
-              resolve: (r: ControlResponse) => void,
-              reject: (e: Error) => void,
-              timeoutId: NodeJS.Timeout,
-            ) => void;
-          }
-        ).registerOutgoingRequest(
-          requestId,
-          'SystemController',
-          resolve,
-          reject,
-          timeoutId,
-        );
-
-        // Verify it was registered by handling a response
-        const response: CLIControlResponse = {
-          type: 'control_response',
-          response: {
-            subtype: 'success',
-            request_id: requestId,
-            response: {},
-          },
-        };
-
-        dispatcher.handleControlResponse(response);
-        expect(resolve).toHaveBeenCalled();
-      });
-    });
-
-    describe('deregisterOutgoingRequest', () => {
-      it('should deregister outgoing request', () => {
-        const requestId = 'dereg-outgoing-1';
-        const resolve = vi.fn();
-        const reject = vi.fn();
-        const timeoutId = setTimeout(() => {}, 1000);
-
-        const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-
-        (
-          dispatcher as unknown as {
-            registerOutgoingRequest: (
-              id: string,
-              controller: string,
-              resolve: (r: ControlResponse) => void,
-              reject: (e: Error) => void,
-              timeoutId: NodeJS.Timeout,
-            ) => void;
-            deregisterOutgoingRequest: (id: string) => void;
-          }
-        ).registerOutgoingRequest(
-          requestId,
-          'SystemController',
-          resolve,
-          reject,
-          timeoutId,
-        );
-
-        (
-          dispatcher as unknown as {
-            deregisterOutgoingRequest: (id: string) => void;
-          }
-        ).deregisterOutgoingRequest(requestId);
-
-        // Verify it was deregistered - response should not find it
-        const response: CLIControlResponse = {
-          type: 'control_response',
-          response: {
-            subtype: 'success',
-            request_id: requestId,
-            response: {},
-          },
-        };
-
-        dispatcher.handleControlResponse(response);
-        expect(resolve).not.toHaveBeenCalled();
-        expect(clearTimeoutSpy).toHaveBeenCalledWith(timeoutId);
-      });
-
-      it('should handle deregister of non-existent request gracefully', () => {
-        expect(() => {
-          (
-            dispatcher as unknown as {
-              deregisterOutgoingRequest: (id: string) => void;
-            }
-          ).deregisterOutgoingRequest('non-existent');
-        }).not.toThrow();
-      });
-    });
-  });
-});
--- a/packages/cli/src/nonInteractive/control/ControlDispatcher.ts
+++ b/packages/cli/src/nonInteractive/control/ControlDispatcher.ts
@@ -1,400 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Control Dispatcher
- *
- * Layer 2 of the control plane architecture. Routes control requests between
- * SDK and CLI to appropriate controllers, manages pending request registries,
- * and handles cancellation/cleanup. Application code MUST NOT depend on
- * controller instances exposed by this class; instead, use ControlService,
- * which wraps these controllers with a stable programmatic API.
- *
- * Controllers:
- * - SystemController: initialize, interrupt, set_model, supported_commands
- * - PermissionController: can_use_tool, set_permission_mode
- * - SdkMcpController: mcp_server_status (mcp_message handled via callback)
- * - HookController: hook_callback
- *
- * Note: mcp_message requests are NOT routed through the dispatcher. CLI MCP
- * clients send messages via SdkMcpController.createSendSdkMcpMessage() callback.
- *
- * Note: Control request types are centrally defined in the ControlRequestType
- * enum in packages/sdk/typescript/src/types/controlRequests.ts
- */
-
-import type { IControlContext } from './ControlContext.js';
-import type { IPendingRequestRegistry } from './controllers/baseController.js';
-import { SystemController } from './controllers/systemController.js';
-import { PermissionController } from './controllers/permissionController.js';
-import { SdkMcpController } from './controllers/sdkMcpController.js';
-// import { HookController } from './controllers/hookController.js';
-import type {
-  CLIControlRequest,
-  CLIControlResponse,
-  ControlResponse,
-  ControlRequestPayload,
-} from '../types.js';
-
-/**
- * Tracks an incoming request from SDK awaiting CLI response
- */
-interface PendingIncomingRequest {
-  controller: string;
-  abortController: AbortController;
-  timeoutId: NodeJS.Timeout;
-}
-
-/**
- * Tracks an outgoing request from CLI awaiting SDK response
- */
-interface PendingOutgoingRequest {
-  controller: string;
-  resolve: (response: ControlResponse) => void;
-  reject: (error: Error) => void;
-  timeoutId: NodeJS.Timeout;
-}
-
-/**
- * Central coordinator for control plane communication.
- * Routes requests to controllers and manages request lifecycle.
- */
-export class ControlDispatcher implements IPendingRequestRegistry {
-  private context: IControlContext;
-
-  // Make controllers publicly accessible
-  readonly systemController: SystemController;
-  readonly permissionController: PermissionController;
-  readonly sdkMcpController: SdkMcpController;
-  // readonly hookController: HookController;
-
-  // Central pending request registries
-  private pendingIncomingRequests: Map<string, PendingIncomingRequest> =
-    new Map();
-  private pendingOutgoingRequests: Map<string, PendingOutgoingRequest> =
-    new Map();
-
-  constructor(context: IControlContext) {
-    this.context = context;
-
-    // Create domain controllers with context and registry
-    this.systemController = new SystemController(
-      context,
-      this,
-      'SystemController',
-    );
-    this.permissionController = new PermissionController(
-      context,
-      this,
-      'PermissionController',
-    );
-    this.sdkMcpController = new SdkMcpController(
-      context,
-      this,
-      'SdkMcpController',
-    );
-    // this.hookController = new HookController(context, this, 'HookController');
-
-    // Listen for main abort signal
-    this.context.abortSignal.addEventListener('abort', () => {
-      this.shutdown();
-    });
-  }
-
-  /**
-   * Routes an incoming request to the appropriate controller and sends response
-   */
-  async dispatch(request: CLIControlRequest): Promise<void> {
-    const { request_id, request: payload } = request;
-
-    try {
-      // Route to appropriate controller
-      const controller = this.getControllerForRequest(payload.subtype);
-      const response = await controller.handleRequest(payload, request_id);
-
-      // Send success response
-      this.sendSuccessResponse(request_id, response);
-    } catch (error) {
-      // Send error response
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      this.sendErrorResponse(request_id, errorMessage);
-    }
-  }
-
-  /**
-   * Processes response from SDK for an outgoing request
-   */
-  handleControlResponse(response: CLIControlResponse): void {
-    const responsePayload = response.response;
-    const requestId = responsePayload.request_id;
-
-    const pending = this.pendingOutgoingRequests.get(requestId);
-    if (!pending) {
-      // No pending request found - may have timed out or been cancelled
-      if (this.context.debugMode) {
-        console.error(
-          `[ControlDispatcher] No pending outgoing request for: ${requestId}`,
-        );
-      }
-      return;
-    }
-
-    // Deregister
-    this.deregisterOutgoingRequest(requestId);
-
-    // Resolve or reject based on response type
-    if (responsePayload.subtype === 'success') {
-      pending.resolve(responsePayload);
-    } else {
-      const errorMessage =
-        typeof responsePayload.error === 'string'
-          ? responsePayload.error
-          : (responsePayload.error?.message ?? 'Unknown error');
-      pending.reject(new Error(errorMessage));
-    }
-  }
-
-  /**
-   * Sends a control request to SDK and waits for response
-   */
-  async sendControlRequest(
-    payload: ControlRequestPayload,
-    timeoutMs?: number,
-  ): Promise<ControlResponse> {
-    // Delegate to system controller (or any controller, they all have the same method)
-    return this.systemController.sendControlRequest(payload, timeoutMs);
-  }
-
-  /**
-   * Cancels a specific request or all pending requests
-   */
-  handleCancel(requestId?: string): void {
-    if (requestId) {
-      // Cancel specific incoming request
-      const pending = this.pendingIncomingRequests.get(requestId);
-      if (pending) {
-        pending.abortController.abort();
-        this.deregisterIncomingRequest(requestId);
-        this.sendErrorResponse(requestId, 'Request cancelled');
-
-        if (this.context.debugMode) {
-          console.error(
-            `[ControlDispatcher] Cancelled incoming request: ${requestId}`,
-          );
-        }
-      }
-    } else {
-      // Cancel ALL pending incoming requests
-      const requestIds = Array.from(this.pendingIncomingRequests.keys());
-      for (const id of requestIds) {
-        const pending = this.pendingIncomingRequests.get(id);
-        if (pending) {
-          pending.abortController.abort();
-          this.deregisterIncomingRequest(id);
-          this.sendErrorResponse(id, 'All requests cancelled');
-        }
-      }
-
-      if (this.context.debugMode) {
-        console.error(
-          `[ControlDispatcher] Cancelled all ${requestIds.length} pending incoming requests`,
-        );
-      }
-    }
-  }
-
-  /**
-   * Stops all pending requests and cleans up all controllers
-   */
-  shutdown(): void {
-    if (this.context.debugMode) {
-      console.error('[ControlDispatcher] Shutting down');
-    }
-
-    // Cancel all incoming requests
-    for (const [
-      _requestId,
-      pending,
-    ] of this.pendingIncomingRequests.entries()) {
-      pending.abortController.abort();
-      clearTimeout(pending.timeoutId);
-    }
-    this.pendingIncomingRequests.clear();
-
-    // Cancel all outgoing requests
-    for (const [
-      _requestId,
-      pending,
-    ] of this.pendingOutgoingRequests.entries()) {
-      clearTimeout(pending.timeoutId);
-      pending.reject(new Error('Dispatcher shutdown'));
-    }
-    this.pendingOutgoingRequests.clear();
-
-    // Cleanup controllers
-    this.systemController.cleanup();
-    this.permissionController.cleanup();
-    this.sdkMcpController.cleanup();
-    // this.hookController.cleanup();
-  }
-
-  /**
-   * Registers an incoming request in the pending registry
-   */
-  registerIncomingRequest(
-    requestId: string,
-    controller: string,
-    abortController: AbortController,
-    timeoutId: NodeJS.Timeout,
-  ): void {
-    this.pendingIncomingRequests.set(requestId, {
-      controller,
-      abortController,
-      timeoutId,
-    });
-  }
-
-  /**
-   * Removes an incoming request from the pending registry
-   */
-  deregisterIncomingRequest(requestId: string): void {
-    const pending = this.pendingIncomingRequests.get(requestId);
-    if (pending) {
-      clearTimeout(pending.timeoutId);
-      this.pendingIncomingRequests.delete(requestId);
-    }
-  }
-
-  /**
-   * Registers an outgoing request in the pending registry
-   */
-  registerOutgoingRequest(
-    requestId: string,
-    controller: string,
-    resolve: (response: ControlResponse) => void,
-    reject: (error: Error) => void,
-    timeoutId: NodeJS.Timeout,
-  ): void {
-    this.pendingOutgoingRequests.set(requestId, {
-      controller,
-      resolve,
-      reject,
-      timeoutId,
-    });
-  }
-
-  /**
-   * Removes an outgoing request from the pending registry
-   */
-  deregisterOutgoingRequest(requestId: string): void {
-    const pending = this.pendingOutgoingRequests.get(requestId);
-    if (pending) {
-      clearTimeout(pending.timeoutId);
-      this.pendingOutgoingRequests.delete(requestId);
-    }
-  }
-
-  /**
-   * Get count of pending incoming requests (for debugging)
-   */
-  getPendingIncomingRequestCount(): number {
-    return this.pendingIncomingRequests.size;
-  }
-
-  /**
-   * Wait for all incoming request handlers to complete.
-   *
-   * Uses polling since we don't have direct Promise references to handlers.
-   * The pendingIncomingRequests map is managed by BaseController:
-   * - Registered when handler starts (in handleRequest)
-   * - Deregistered when handler completes (success or error)
-   *
-   * @param pollIntervalMs - How often to check (default 50ms)
-   * @param timeoutMs - Maximum wait time (default 30s)
-   */
-  async waitForPendingIncomingRequests(
-    pollIntervalMs: number = 50,
-    timeoutMs: number = 30000,
-  ): Promise<void> {
-    const startTime = Date.now();
-
-    while (this.pendingIncomingRequests.size > 0) {
-      if (Date.now() - startTime > timeoutMs) {
-        if (this.context.debugMode) {
-          console.error(
-            `[ControlDispatcher] Timeout waiting for ${this.pendingIncomingRequests.size} pending incoming requests`,
-          );
-        }
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-    }
-
-    if (this.context.debugMode && this.pendingIncomingRequests.size === 0) {
-      console.error('[ControlDispatcher] All incoming requests completed');
-    }
-  }
-
-  /**
-   * Returns the controller that handles the given request subtype
-   */
-  private getControllerForRequest(subtype: string) {
-    switch (subtype) {
-      case 'initialize':
-      case 'interrupt':
-      case 'set_model':
-      case 'supported_commands':
-        return this.systemController;
-
-      case 'can_use_tool':
-      case 'set_permission_mode':
-        return this.permissionController;
-
-      case 'mcp_server_status':
-        return this.sdkMcpController;
-
-      // case 'hook_callback':
-      //   return this.hookController;
-
-      default:
-        throw new Error(`Unknown control request subtype: ${subtype}`);
-    }
-  }
-
-  /**
-   * Sends a success response back to SDK
-   */
-  private sendSuccessResponse(
-    requestId: string,
-    response: Record<string, unknown>,
-  ): void {
-    const controlResponse: CLIControlResponse = {
-      type: 'control_response',
-      response: {
-        subtype: 'success',
-        request_id: requestId,
-        response,
-      },
-    };
-    this.context.streamJson.send(controlResponse);
-  }
-
-  /**
-   * Sends an error response back to SDK
-   */
-  private sendErrorResponse(requestId: string, error: string): void {
-    const controlResponse: CLIControlResponse = {
-      type: 'control_response',
-      response: {
-        subtype: 'error',
-        request_id: requestId,
-        error,
-      },
-    };
-    this.context.streamJson.send(controlResponse);
-  }
-}
--- a/packages/cli/src/nonInteractive/control/ControlService.ts
+++ b/packages/cli/src/nonInteractive/control/ControlService.ts
@@ -1,179 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Control Service - Public Programmatic API
- *
- * Provides type-safe access to control plane functionality for internal
- * CLI code. This is the ONLY programmatic interface that should be used by:
- * - nonInteractiveCli
- * - Session managers
- * - Tool execution handlers
- * - Internal CLI logic
- *
- * DO NOT use ControlDispatcher or controllers directly from application code.
- *
- * Architecture:
- * - ControlContext stores shared session state (Layer 1)
- * - ControlDispatcher handles protocol-level routing (Layer 2)
- * - ControlService provides programmatic API for internal CLI usage (Layer 3)
- *
- * ControlService and ControlDispatcher share controller instances to ensure
- * a single source of truth. All higher level code MUST access the control
- * plane exclusively through ControlService.
- */
-
-import type { IControlContext } from './ControlContext.js';
-import type { ControlDispatcher } from './ControlDispatcher.js';
-import type {
-  PermissionServiceAPI,
-  SystemServiceAPI,
-  // McpServiceAPI,
-  // HookServiceAPI,
-} from './types/serviceAPIs.js';
-
-/**
- * Control Service
- *
- * Facade layer providing domain-grouped APIs for control plane operations.
- * Shares controller instances with ControlDispatcher to ensure single source
- * of truth and state consistency.
- */
-export class ControlService {
-  private dispatcher: ControlDispatcher;
-
-  /**
-   * Construct ControlService
-   *
-   * @param context - Control context (unused directly, passed to dispatcher)
-   * @param dispatcher - Control dispatcher that owns the controller instances
-   */
-  constructor(context: IControlContext, dispatcher: ControlDispatcher) {
-    this.dispatcher = dispatcher;
-  }
-
-  /**
-   * Permission Domain API
-   *
-   * Handles tool execution permissions, approval checks, and callbacks.
-   * Delegates to the shared PermissionController instance.
-   */
-  get permission(): PermissionServiceAPI {
-    const controller = this.dispatcher.permissionController;
-    return {
-      /**
-       * Build UI suggestions for tool confirmation dialogs
-       *
-       * Creates actionable permission suggestions based on tool confirmation details.
-       *
-       * @param confirmationDetails - Tool confirmation details
-       * @returns Array of permission suggestions or null
-       */
-      buildPermissionSuggestions:
-        controller.buildPermissionSuggestions.bind(controller),
-
-      /**
-       * Get callback for monitoring tool call status updates
-       *
-       * Returns callback function for integration with CoreToolScheduler.
-       *
-       * @returns Callback function for tool call updates
-       */
-      getToolCallUpdateCallback:
-        controller.getToolCallUpdateCallback.bind(controller),
-    };
-  }
-
-  /**
-   * System Domain API
-   *
-   * Handles system-level operations and session management.
-   * Delegates to the shared SystemController instance.
-   */
-  get system(): SystemServiceAPI {
-    const controller = this.dispatcher.systemController;
-    return {
-      /**
-       * Get control capabilities
-       *
-       * Returns the control capabilities object indicating what control
-       * features are available. Used exclusively for the initialize
-       * control response. System messages do not include capabilities.
-       *
-       * @returns Control capabilities object
-       */
-      getControlCapabilities: () => controller.buildControlCapabilities(),
-    };
-  }
-
-  /**
-   * MCP Domain API
-   *
-   * Handles Model Context Protocol server interactions.
-   * Delegates to the shared MCPController instance.
-   */
-  // get mcp(): McpServiceAPI {
-  //   return {
-  //     /**
-  //      * Get or create MCP client for a server (lazy initialization)
-  //      *
-  //      * Returns existing client or creates new connection.
-  //      *
-  //      * @param serverName - Name of the MCP server
-  //      * @returns Promise with client and config
-  //      */
-  //     getMcpClient: async (serverName: string) => {
-  //       // MCPController has a private method getOrCreateMcpClient
-  //       // We need to expose it via the API
-  //       // For now, throw error as placeholder
-  //       // The actual implementation will be added when we update MCPController
-  //       throw new Error(
-  //         `getMcpClient not yet implemented in ControlService. Server: ${serverName}`,
-  //       );
-  //     },
-  //
-  //     /**
-  //      * List all available MCP servers
-  //      *
-  //      * Returns names of configured/connected MCP servers.
-  //      *
-  //      * @returns Array of server names
-  //      */
-  //     listServers: () => {
-  //       // Get servers from context
-  //       const sdkServers = Array.from(
-  //         this.dispatcher.mcpController['context'].sdkMcpServers,
-  //       );
-  //       const cliServers = Array.from(
-  //         this.dispatcher.mcpController['context'].mcpClients.keys(),
-  //       );
-  //       return [...new Set([...sdkServers, ...cliServers])];
-  //     },
-  //   };
-  // }
-
-  /**
-   * Hook Domain API
-   *
-   * Handles hook callback processing (placeholder for future expansion).
-   * Delegates to the shared HookController instance.
-   */
-  // get hook(): HookServiceAPI {
-  //   // HookController has no public methods yet - controller access reserved for future use
-  //   return {};
-  // }
-
-  /**
-   * Cleanup all controllers
-   *
-   * Should be called on session shutdown. Delegates to dispatcher's shutdown
-   * method to ensure all controllers are properly cleaned up.
-   */
-  cleanup(): void {
-    // Delegate to dispatcher which manages controller cleanup
-    this.dispatcher.shutdown();
-  }
-}
--- a/packages/cli/src/nonInteractive/control/controllers/baseController.ts
+++ b/packages/cli/src/nonInteractive/control/controllers/baseController.ts
@@ -1,221 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Base Controller
- *
- * Abstract base class for domain-specific control plane controllers.
- * Provides common functionality for:
- * - Handling incoming control requests (SDK -> CLI)
- * - Sending outgoing control requests (CLI -> SDK)
- * - Request lifecycle management with timeout and cancellation
- * - Integration with central pending request registry
- */
-
-import { randomUUID } from 'node:crypto';
-import type { IControlContext } from '../ControlContext.js';
-import type {
-  ControlRequestPayload,
-  ControlResponse,
-  CLIControlRequest,
-} from '../../types.js';
-
-const DEFAULT_REQUEST_TIMEOUT_MS = 30000; // 30 seconds
-
-/**
- * Registry interface for controllers to register/deregister pending requests
- */
-export interface IPendingRequestRegistry {
-  registerIncomingRequest(
-    requestId: string,
-    controller: string,
-    abortController: AbortController,
-    timeoutId: NodeJS.Timeout,
-  ): void;
-  deregisterIncomingRequest(requestId: string): void;
-
-  registerOutgoingRequest(
-    requestId: string,
-    controller: string,
-    resolve: (response: ControlResponse) => void,
-    reject: (error: Error) => void,
-    timeoutId: NodeJS.Timeout,
-  ): void;
-  deregisterOutgoingRequest(requestId: string): void;
-}
-
-/**
- * Abstract base controller class
- *
- * Subclasses should implement handleRequestPayload() to process specific
- * control request types.
- */
-export abstract class BaseController {
-  protected context: IControlContext;
-  protected registry: IPendingRequestRegistry;
-  protected controllerName: string;
-
-  constructor(
-    context: IControlContext,
-    registry: IPendingRequestRegistry,
-    controllerName: string,
-  ) {
-    this.context = context;
-    this.registry = registry;
-    this.controllerName = controllerName;
-  }
-
-  /**
-   * Handle an incoming control request
-   *
-   * Manages lifecycle: register -> process -> deregister
-   */
-  async handleRequest(
-    payload: ControlRequestPayload,
-    requestId: string,
-  ): Promise<Record<string, unknown>> {
-    const requestAbortController = new AbortController();
-
-    // Setup timeout
-    const timeoutId = setTimeout(() => {
-      requestAbortController.abort();
-      this.registry.deregisterIncomingRequest(requestId);
-      if (this.context.debugMode) {
-        console.error(`[${this.controllerName}] Request timeout: ${requestId}`);
-      }
-    }, DEFAULT_REQUEST_TIMEOUT_MS);
-
-    // Register with central registry
-    this.registry.registerIncomingRequest(
-      requestId,
-      this.controllerName,
-      requestAbortController,
-      timeoutId,
-    );
-
-    try {
-      const response = await this.handleRequestPayload(
-        payload,
-        requestAbortController.signal,
-      );
-
-      // Success - deregister
-      this.registry.deregisterIncomingRequest(requestId);
-
-      return response;
-    } catch (error) {
-      // Error - deregister
-      this.registry.deregisterIncomingRequest(requestId);
-      throw error;
-    }
-  }
-
-  /**
-   * Send an outgoing control request to SDK
-   *
-   * Manages lifecycle: register -> send -> wait for response -> deregister
-   * Respects the provided AbortSignal for cancellation.
-   */
-  async sendControlRequest(
-    payload: ControlRequestPayload,
-    timeoutMs: number = DEFAULT_REQUEST_TIMEOUT_MS,
-    signal?: AbortSignal,
-  ): Promise<ControlResponse> {
-    // Check if already aborted
-    if (signal?.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    const requestId = randomUUID();
-
-    return new Promise<ControlResponse>((resolve, reject) => {
-      // Setup abort handler
-      const abortHandler = () => {
-        this.registry.deregisterOutgoingRequest(requestId);
-        reject(new Error('Request aborted'));
-        if (this.context.debugMode) {
-          console.error(
-            `[${this.controllerName}] Outgoing request aborted: ${requestId}`,
-          );
-        }
-      };
-
-      if (signal) {
-        signal.addEventListener('abort', abortHandler, { once: true });
-      }
-
-      // Setup timeout
-      const timeoutId = setTimeout(() => {
-        if (signal) {
-          signal.removeEventListener('abort', abortHandler);
-        }
-        this.registry.deregisterOutgoingRequest(requestId);
-        reject(new Error('Control request timeout'));
-        if (this.context.debugMode) {
-          console.error(
-            `[${this.controllerName}] Outgoing request timeout: ${requestId}`,
-          );
-        }
-      }, timeoutMs);
-
-      // Wrap resolve/reject to clean up abort listener
-      const wrappedResolve = (response: ControlResponse) => {
-        if (signal) {
-          signal.removeEventListener('abort', abortHandler);
-        }
-        resolve(response);
-      };
-
-      const wrappedReject = (error: Error) => {
-        if (signal) {
-          signal.removeEventListener('abort', abortHandler);
-        }
-        reject(error);
-      };
-
-      // Register with central registry
-      this.registry.registerOutgoingRequest(
-        requestId,
-        this.controllerName,
-        wrappedResolve,
-        wrappedReject,
-        timeoutId,
-      );
-
-      // Send control request
-      const request: CLIControlRequest = {
-        type: 'control_request',
-        request_id: requestId,
-        request: payload,
-      };
-
-      try {
-        this.context.streamJson.send(request);
-      } catch (error) {
-        if (signal) {
-          signal.removeEventListener('abort', abortHandler);
-        }
-        this.registry.deregisterOutgoingRequest(requestId);
-        reject(error);
-      }
-    });
-  }
-
-  /**
-   * Abstract method: Handle specific request payload
-   *
-   * Subclasses must implement this to process their domain-specific requests.
-   */
-  protected abstract handleRequestPayload(
-    payload: ControlRequestPayload,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>>;
-
-  /**
-   * Cleanup resources
-   */
-  cleanup(): void {}
-}
--- a/packages/cli/src/nonInteractive/control/controllers/hookController.ts
+++ b/packages/cli/src/nonInteractive/control/controllers/hookController.ts
@@ -1,56 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Hook Controller
- *
- * Handles hook-related control requests:
- * - hook_callback: Process hook callbacks (placeholder for future)
- */
-
-import { BaseController } from './baseController.js';
-import type {
-  ControlRequestPayload,
-  CLIHookCallbackRequest,
-} from '../../types.js';
-
-export class HookController extends BaseController {
-  /**
-   * Handle hook control requests
-   */
-  protected async handleRequestPayload(
-    payload: ControlRequestPayload,
-    _signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    switch (payload.subtype) {
-      case 'hook_callback':
-        return this.handleHookCallback(payload as CLIHookCallbackRequest);
-
-      default:
-        throw new Error(`Unsupported request subtype in HookController`);
-    }
-  }
-
-  /**
-   * Handle hook_callback request
-   *
-   * Processes hook callbacks (placeholder implementation)
-   */
-  private async handleHookCallback(
-    payload: CLIHookCallbackRequest,
-  ): Promise<Record<string, unknown>> {
-    if (this.context.debugMode) {
-      console.error(`[HookController] Hook callback: ${payload.callback_id}`);
-    }
-
-    // Hook callback processing not yet implemented
-    return {
-      result: 'Hook callback processing not yet implemented',
-      callback_id: payload.callback_id,
-      tool_use_id: payload.tool_use_id,
-    };
-  }
-}
--- a/packages/cli/src/nonInteractive/control/controllers/permissionController.ts
+++ b/packages/cli/src/nonInteractive/control/controllers/permissionController.ts
@@ -1,493 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Permission Controller
- *
- * Handles permission-related control requests:
- * - can_use_tool: Check if tool usage is allowed
- * - set_permission_mode: Change permission mode at runtime
- *
- * Abstracts all permission logic from the session manager to keep it clean.
- */
-
-import type {
-  WaitingToolCall,
-  ToolExecuteConfirmationDetails,
-  ToolMcpConfirmationDetails,
-  ApprovalMode,
-} from '@qwen-code/qwen-code-core';
-import {
-  InputFormat,
-  ToolConfirmationOutcome,
-} from '@qwen-code/qwen-code-core';
-import type {
-  CLIControlPermissionRequest,
-  CLIControlSetPermissionModeRequest,
-  ControlRequestPayload,
-  PermissionMode,
-  PermissionSuggestion,
-} from '../../types.js';
-import { BaseController } from './baseController.js';
-
-// Import ToolCallConfirmationDetails types for type alignment
-type ToolConfirmationType = 'edit' | 'exec' | 'mcp' | 'info' | 'plan';
-
-export class PermissionController extends BaseController {
-  private pendingOutgoingRequests = new Set<string>();
-
-  /**
-   * Handle permission control requests
-   */
-  protected async handleRequestPayload(
-    payload: ControlRequestPayload,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    switch (payload.subtype) {
-      case 'can_use_tool':
-        return this.handleCanUseTool(
-          payload as CLIControlPermissionRequest,
-          signal,
-        );
-
-      case 'set_permission_mode':
-        return this.handleSetPermissionMode(
-          payload as CLIControlSetPermissionModeRequest,
-          signal,
-        );
-
-      default:
-        throw new Error(`Unsupported request subtype in PermissionController`);
-    }
-  }
-
-  /**
-   * Handle can_use_tool request
-   *
-   * Comprehensive permission evaluation based on:
-   * - Permission mode (approval level)
-   * - Tool registry validation
-   * - Error handling with safe defaults
-   */
-  private async handleCanUseTool(
-    payload: CLIControlPermissionRequest,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    const toolName = payload.tool_name;
-    if (
-      !toolName ||
-      typeof toolName !== 'string' ||
-      toolName.trim().length === 0
-    ) {
-      return {
-        subtype: 'can_use_tool',
-        behavior: 'deny',
-        message: 'Missing or invalid tool_name in can_use_tool request',
-      };
-    }
-
-    let behavior: 'allow' | 'deny' = 'allow';
-    let message: string | undefined;
-
-    try {
-      // Check permission mode first
-      const permissionResult = this.checkPermissionMode();
-      if (!permissionResult.allowed) {
-        behavior = 'deny';
-        message = permissionResult.message;
-      }
-
-      // Check tool registry if permission mode allows
-      if (behavior === 'allow') {
-        const registryResult = this.checkToolRegistry(toolName);
-        if (!registryResult.allowed) {
-          behavior = 'deny';
-          message = registryResult.message;
-        }
-      }
-    } catch (error) {
-      behavior = 'deny';
-      message =
-        error instanceof Error
-          ? `Failed to evaluate tool permission: ${error.message}`
-          : 'Failed to evaluate tool permission';
-    }
-
-    const response: Record<string, unknown> = {
-      subtype: 'can_use_tool',
-      behavior,
-    };
-
-    if (message) {
-      response['message'] = message;
-    }
-
-    return response;
-  }
-
-  /**
-   * Check permission mode for tool execution
-   */
-  private checkPermissionMode(): { allowed: boolean; message?: string } {
-    const mode = this.context.permissionMode;
-
-    // Map permission modes to approval logic (aligned with VALID_APPROVAL_MODE_VALUES)
-    switch (mode) {
-      case 'yolo': // Allow all tools
-      case 'auto-edit': // Auto-approve edit operations
-      case 'plan': // Auto-approve planning operations
-        return { allowed: true };
-
-      case 'default': // TODO: allow all tools for test
-      default:
-        return {
-          allowed: false,
-          message:
-            'Tool execution requires manual approval. Update permission mode or approve via host.',
-        };
-    }
-  }
-
-  /**
-   * Check if tool exists in registry
-   */
-  private checkToolRegistry(toolName: string): {
-    allowed: boolean;
-    message?: string;
-  } {
-    try {
-      // Access tool registry through config
-      const config = this.context.config;
-      const registryProvider = config as unknown as {
-        getToolRegistry?: () => {
-          getTool?: (name: string) => unknown;
-        };
-      };
-
-      if (typeof registryProvider.getToolRegistry === 'function') {
-        const registry = registryProvider.getToolRegistry();
-        if (
-          registry &&
-          typeof registry.getTool === 'function' &&
-          !registry.getTool(toolName)
-        ) {
-          return {
-            allowed: false,
-            message: `Tool "${toolName}" is not registered.`,
-          };
-        }
-      }
-
-      return { allowed: true };
-    } catch (error) {
-      return {
-        allowed: false,
-        message: `Failed to check tool registry: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      };
-    }
-  }
-
-  /**
-   * Handle set_permission_mode request
-   *
-   * Updates the permission mode in the context
-   */
-  private async handleSetPermissionMode(
-    payload: CLIControlSetPermissionModeRequest,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    const mode = payload.mode;
-    const validModes: PermissionMode[] = [
-      'default',
-      'plan',
-      'auto-edit',
-      'yolo',
-    ];
-
-    if (!validModes.includes(mode)) {
-      throw new Error(
-        `Invalid permission mode: ${mode}. Valid values are: ${validModes.join(', ')}`,
-      );
-    }
-
-    this.context.permissionMode = mode;
-    this.context.config.setApprovalMode(mode as ApprovalMode);
-
-    if (this.context.debugMode) {
-      console.error(
-        `[PermissionController] Permission mode updated to: ${mode}`,
-      );
-    }
-
-    return { status: 'updated', mode };
-  }
-
-  /**
-   * Build permission suggestions for tool confirmation UI
-   *
-   * This method creates UI suggestions based on tool confirmation details,
-   * helping the host application present appropriate permission options.
-   */
-  buildPermissionSuggestions(
-    confirmationDetails: unknown,
-  ): PermissionSuggestion[] | null {
-    if (
-      !confirmationDetails ||
-      typeof confirmationDetails !== 'object' ||
-      !('type' in confirmationDetails)
-    ) {
-      return null;
-    }
-
-    const details = confirmationDetails as Record<string, unknown>;
-    const type = String(details['type'] ?? '');
-    const title =
-      typeof details['title'] === 'string' ? details['title'] : undefined;
-
-    // Ensure type matches ToolCallConfirmationDetails union
-    const confirmationType = type as ToolConfirmationType;
-
-    switch (confirmationType) {
-      case 'exec': // ToolExecuteConfirmationDetails
-        return [
-          {
-            type: 'allow',
-            label: 'Allow Command',
-            description: `Execute: ${details['command']}`,
-          },
-          {
-            type: 'deny',
-            label: 'Deny',
-            description: 'Block this command execution',
-          },
-        ];
-
-      case 'edit': // ToolEditConfirmationDetails
-        return [
-          {
-            type: 'allow',
-            label: 'Allow Edit',
-            description: `Edit file: ${details['fileName']}`,
-          },
-          {
-            type: 'deny',
-            label: 'Deny',
-            description: 'Block this file edit',
-          },
-          {
-            type: 'modify',
-            label: 'Review Changes',
-            description: 'Review the proposed changes before applying',
-          },
-        ];
-
-      case 'plan': // ToolPlanConfirmationDetails
-        return [
-          {
-            type: 'allow',
-            label: 'Approve Plan',
-            description: title || 'Execute the proposed plan',
-          },
-          {
-            type: 'deny',
-            label: 'Reject Plan',
-            description: 'Do not execute this plan',
-          },
-        ];
-
-      case 'mcp': // ToolMcpConfirmationDetails
-        return [
-          {
-            type: 'allow',
-            label: 'Allow MCP Call',
-            description: `${details['serverName']}: ${details['toolName']}`,
-          },
-          {
-            type: 'deny',
-            label: 'Deny',
-            description: 'Block this MCP server call',
-          },
-        ];
-
-      case 'info': // ToolInfoConfirmationDetails
-        return [
-          {
-            type: 'allow',
-            label: 'Allow Info Request',
-            description: title || 'Allow information request',
-          },
-          {
-            type: 'deny',
-            label: 'Deny',
-            description: 'Block this information request',
-          },
-        ];
-
-      default:
-        // Fallback for unknown types
-        return [
-          {
-            type: 'allow',
-            label: 'Allow',
-            description: title || `Allow ${type} operation`,
-          },
-          {
-            type: 'deny',
-            label: 'Deny',
-            description: `Block ${type} operation`,
-          },
-        ];
-    }
-  }
-
-  /**
-   * Get callback for monitoring tool calls and handling outgoing permission requests
-   * This is passed to executeToolCall to hook into CoreToolScheduler updates
-   */
-  getToolCallUpdateCallback(): (toolCalls: unknown[]) => void {
-    return (toolCalls: unknown[]) => {
-      for (const call of toolCalls) {
-        if (
-          call &&
-          typeof call === 'object' &&
-          (call as { status?: string }).status === 'awaiting_approval'
-        ) {
-          const awaiting = call as WaitingToolCall;
-          if (
-            typeof awaiting.confirmationDetails?.onConfirm === 'function' &&
-            !this.pendingOutgoingRequests.has(awaiting.request.callId)
-          ) {
-            this.pendingOutgoingRequests.add(awaiting.request.callId);
-            void this.handleOutgoingPermissionRequest(awaiting);
-          }
-        }
-      }
-    };
-  }
-
-  /**
-   * Handle outgoing permission request
-   *
-   * Behavior depends on input format:
-   * - stream-json mode: Send can_use_tool to SDK and await response
-   * - Other modes: Check local approval mode and decide immediately
-   */
-  private async handleOutgoingPermissionRequest(
-    toolCall: WaitingToolCall,
-  ): Promise<void> {
-    try {
-      // Check if already aborted
-      if (this.context.abortSignal?.aborted) {
-        await toolCall.confirmationDetails.onConfirm(
-          ToolConfirmationOutcome.Cancel,
-        );
-        return;
-      }
-
-      const inputFormat = this.context.config.getInputFormat?.();
-      const isStreamJsonMode = inputFormat === InputFormat.STREAM_JSON;
-
-      if (!isStreamJsonMode) {
-        // No SDK available - use local permission check
-        const modeCheck = this.checkPermissionMode();
-        const outcome = modeCheck.allowed
-          ? ToolConfirmationOutcome.ProceedOnce
-          : ToolConfirmationOutcome.Cancel;
-
-        await toolCall.confirmationDetails.onConfirm(outcome);
-        return;
-      }
-
-      // Stream-json mode: ask SDK for permission
-      const permissionSuggestions = this.buildPermissionSuggestions(
-        toolCall.confirmationDetails,
-      );
-
-      const response = await this.sendControlRequest(
-        {
-          subtype: 'can_use_tool',
-          tool_name: toolCall.request.name,
-          tool_use_id: toolCall.request.callId,
-          input: toolCall.request.args,
-          permission_suggestions: permissionSuggestions,
-          blocked_path: null,
-        } as CLIControlPermissionRequest,
-        undefined, // use default timeout
-        this.context.abortSignal,
-      );
-
-      if (response.subtype !== 'success') {
-        await toolCall.confirmationDetails.onConfirm(
-          ToolConfirmationOutcome.Cancel,
-        );
-        return;
-      }
-
-      const payload = (response.response || {}) as Record<string, unknown>;
-      const behavior = String(payload['behavior'] || '').toLowerCase();
-
-      if (behavior === 'allow') {
-        // Handle updated input if provided
-        const updatedInput = payload['updatedInput'];
-        if (updatedInput && typeof updatedInput === 'object') {
-          toolCall.request.args = updatedInput as Record<string, unknown>;
-        }
-        await toolCall.confirmationDetails.onConfirm(
-          ToolConfirmationOutcome.ProceedOnce,
-        );
-      } else {
-        // Extract cancel message from response if available
-        const cancelMessage =
-          typeof payload['message'] === 'string'
-            ? payload['message']
-            : undefined;
-
-        await toolCall.confirmationDetails.onConfirm(
-          ToolConfirmationOutcome.Cancel,
-          cancelMessage ? { cancelMessage } : undefined,
-        );
-      }
-    } catch (error) {
-      if (this.context.debugMode) {
-        console.error(
-          '[PermissionController] Outgoing permission failed:',
-          error,
-        );
-      }
-      // On error, use default cancel message
-      // Only pass payload for exec and mcp types that support it
-      const confirmationType = toolCall.confirmationDetails.type;
-      if (['edit', 'exec', 'mcp'].includes(confirmationType)) {
-        const execOrMcpDetails = toolCall.confirmationDetails as
-          | ToolExecuteConfirmationDetails
-          | ToolMcpConfirmationDetails;
-        await execOrMcpDetails.onConfirm(
-          ToolConfirmationOutcome.Cancel,
-          undefined,
-        );
-      } else {
-        // For other types, don't pass payload (backward compatible)
-        await toolCall.confirmationDetails.onConfirm(
-          ToolConfirmationOutcome.Cancel,
-        );
-      }
-    } finally {
-      this.pendingOutgoingRequests.delete(toolCall.request.callId);
-    }
-  }
-}
--- a/packages/cli/src/nonInteractive/control/controllers/sdkMcpController.ts
+++ b/packages/cli/src/nonInteractive/control/controllers/sdkMcpController.ts
@@ -1,138 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * SDK MCP Controller
- *
- * Handles MCP communication between CLI MCP clients and SDK MCP servers:
- * - Provides sendSdkMcpMessage callback for CLI → SDK MCP message routing
- * - mcp_server_status: Returns status of SDK MCP servers
- *
- * Message Flow (CLI MCP Client → SDK MCP Server):
- * CLI MCP Client → SdkControlClientTransport.send() →
- * sendSdkMcpMessage callback → control_request (mcp_message) → SDK →
- * SDK MCP Server processes → control_response → CLI MCP Client
- */
-
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { BaseController } from './baseController.js';
-import type {
-  ControlRequestPayload,
-  CLIControlMcpMessageRequest,
-} from '../../types.js';
-
-const MCP_REQUEST_TIMEOUT = 30_000; // 30 seconds
-
-export class SdkMcpController extends BaseController {
-  /**
-   * Handle SDK MCP control requests from ControlDispatcher
-   *
-   * Note: mcp_message requests are NOT handled here. CLI MCP clients
-   * send messages via the sendSdkMcpMessage callback directly, not
-   * through the control dispatcher.
-   */
-  protected async handleRequestPayload(
-    payload: ControlRequestPayload,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    switch (payload.subtype) {
-      case 'mcp_server_status':
-        return this.handleMcpStatus();
-
-      default:
-        throw new Error(`Unsupported request subtype in SdkMcpController`);
-    }
-  }
-
-  /**
-   * Handle mcp_server_status request
-   *
-   * Returns status of all registered SDK MCP servers.
-   * SDK servers are considered "connected" if they are registered.
-   */
-  private async handleMcpStatus(): Promise<Record<string, unknown>> {
-    const status: Record<string, string> = {};
-
-    for (const serverName of this.context.sdkMcpServers) {
-      // SDK MCP servers are "connected" once registered since they run in SDK process
-      status[serverName] = 'connected';
-    }
-
-    return {
-      subtype: 'mcp_server_status',
-      status,
-    };
-  }
-
-  /**
-   * Send MCP message to SDK server via control plane
-   *
-   * @param serverName - Name of the SDK MCP server
-   * @param message - MCP JSON-RPC message to send
-   * @returns MCP JSON-RPC response from SDK server
-   */
-  private async sendMcpMessageToSdk(
-    serverName: string,
-    message: JSONRPCMessage,
-  ): Promise<JSONRPCMessage> {
-    if (this.context.debugMode) {
-      console.error(
-        `[SdkMcpController] Sending MCP message to SDK server '${serverName}':`,
-        JSON.stringify(message),
-      );
-    }
-
-    // Send control request to SDK with the MCP message
-    const response = await this.sendControlRequest(
-      {
-        subtype: 'mcp_message',
-        server_name: serverName,
-        message: message as CLIControlMcpMessageRequest['message'],
-      },
-      MCP_REQUEST_TIMEOUT,
-      this.context.abortSignal,
-    );
-
-    // Extract MCP response from control response
-    const responsePayload = response.response as Record<string, unknown>;
-    const mcpResponse = responsePayload?.['mcp_response'] as JSONRPCMessage;
-
-    if (!mcpResponse) {
-      throw new Error(
-        `Invalid MCP response from SDK for server '${serverName}'`,
-      );
-    }
-
-    if (this.context.debugMode) {
-      console.error(
-        `[SdkMcpController] Received MCP response from SDK server '${serverName}':`,
-        JSON.stringify(mcpResponse),
-      );
-    }
-
-    return mcpResponse;
-  }
-
-  /**
-   * Create a callback function for sending MCP messages to SDK servers.
-   *
-   * This callback is used by McpClientManager/SdkControlClientTransport to send
-   * MCP messages from CLI MCP clients to SDK MCP servers via the control plane.
-   *
-   * @returns A function that sends MCP messages to SDK and returns the response
-   */
-  createSendSdkMcpMessage(): (
-    serverName: string,
-    message: JSONRPCMessage,
-  ) => Promise<JSONRPCMessage> {
-    return (serverName: string, message: JSONRPCMessage) =>
-      this.sendMcpMessageToSdk(serverName, message);
-  }
-}
--- a/packages/cli/src/nonInteractive/control/controllers/systemController.ts
+++ b/packages/cli/src/nonInteractive/control/controllers/systemController.ts
@@ -1,451 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * System Controller
- *
- * Handles system-level control requests:
- * - initialize: Setup session and return system info
- * - interrupt: Cancel current operations
- * - set_model: Switch model (placeholder)
- */
-
-import { BaseController } from './baseController.js';
-import type {
-  ControlRequestPayload,
-  CLIControlInitializeRequest,
-  CLIControlSetModelRequest,
-  CLIMcpServerConfig,
-} from '../../types.js';
-import { CommandService } from '../../../services/CommandService.js';
-import { BuiltinCommandLoader } from '../../../services/BuiltinCommandLoader.js';
-import {
-  MCPServerConfig,
-  AuthProviderType,
-  type MCPOAuthConfig,
-} from '@qwen-code/qwen-code-core';
-
-export class SystemController extends BaseController {
-  /**
-   * Handle system control requests
-   */
-  protected async handleRequestPayload(
-    payload: ControlRequestPayload,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    switch (payload.subtype) {
-      case 'initialize':
-        return this.handleInitialize(
-          payload as CLIControlInitializeRequest,
-          signal,
-        );
-
-      case 'interrupt':
-        return this.handleInterrupt();
-
-      case 'set_model':
-        return this.handleSetModel(
-          payload as CLIControlSetModelRequest,
-          signal,
-        );
-
-      case 'supported_commands':
-        return this.handleSupportedCommands(signal);
-
-      default:
-        throw new Error(`Unsupported request subtype in SystemController`);
-    }
-  }
-
-  /**
-   * Handle initialize request
-   *
-   * Processes SDK MCP servers config.
-   * SDK servers are registered in context.sdkMcpServers
-   * and added to config.mcpServers with the sdk type flag.
-   * External MCP servers are configured separately in settings.
-   */
-  private async handleInitialize(
-    payload: CLIControlInitializeRequest,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    this.context.config.setSdkMode(true);
-
-    // Process SDK MCP servers
-    if (
-      payload.sdkMcpServers &&
-      typeof payload.sdkMcpServers === 'object' &&
-      payload.sdkMcpServers !== null
-    ) {
-      const sdkServers: Record<string, MCPServerConfig> = {};
-      for (const [key, wireConfig] of Object.entries(payload.sdkMcpServers)) {
-        const name =
-          typeof wireConfig?.name === 'string' && wireConfig.name.trim().length
-            ? wireConfig.name
-            : key;
-
-        this.context.sdkMcpServers.add(name);
-        sdkServers[name] = new MCPServerConfig(
-          undefined, // command
-          undefined, // args
-          undefined, // env
-          undefined, // cwd
-          undefined, // url
-          undefined, // httpUrl
-          undefined, // headers
-          undefined, // tcp
-          undefined, // timeout
-          true, // trust - SDK servers are trusted
-          undefined, // description
-          undefined, // includeTools
-          undefined, // excludeTools
-          undefined, // extensionName
-          undefined, // oauth
-          undefined, // authProviderType
-          undefined, // targetAudience
-          undefined, // targetServiceAccount
-          'sdk', // type
-        );
-      }
-
-      const sdkServerCount = Object.keys(sdkServers).length;
-      if (sdkServerCount > 0) {
-        try {
-          this.context.config.addMcpServers(sdkServers);
-          if (this.context.debugMode) {
-            console.error(
-              `[SystemController] Added ${sdkServerCount} SDK MCP servers to config`,
-            );
-          }
-        } catch (error) {
-          if (this.context.debugMode) {
-            console.error(
-              '[SystemController] Failed to add SDK MCP servers:',
-              error,
-            );
-          }
-        }
-      }
-    }
-
-    if (
-      payload.mcpServers &&
-      typeof payload.mcpServers === 'object' &&
-      payload.mcpServers !== null
-    ) {
-      const externalServers: Record<string, MCPServerConfig> = {};
-      for (const [name, serverConfig] of Object.entries(payload.mcpServers)) {
-        const normalized = this.normalizeMcpServerConfig(
-          name,
-          serverConfig as CLIMcpServerConfig | undefined,
-        );
-        if (normalized) {
-          externalServers[name] = normalized;
-        }
-      }
-
-      const externalCount = Object.keys(externalServers).length;
-      if (externalCount > 0) {
-        try {
-          this.context.config.addMcpServers(externalServers);
-          if (this.context.debugMode) {
-            console.error(
-              `[SystemController] Added ${externalCount} external MCP servers to config`,
-            );
-          }
-        } catch (error) {
-          if (this.context.debugMode) {
-            console.error(
-              '[SystemController] Failed to add external MCP servers:',
-              error,
-            );
-          }
-        }
-      }
-    }
-
-    if (payload.agents && Array.isArray(payload.agents)) {
-      try {
-        this.context.config.setSessionSubagents(payload.agents);
-
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Added ${payload.agents.length} session subagents to config`,
-          );
-        }
-      } catch (error) {
-        if (this.context.debugMode) {
-          console.error(
-            '[SystemController] Failed to add session subagents:',
-            error,
-          );
-        }
-      }
-    }
-
-    // Build capabilities for response
-    const capabilities = this.buildControlCapabilities();
-
-    if (this.context.debugMode) {
-      console.error(
-        `[SystemController] Initialized with ${this.context.sdkMcpServers.size} SDK MCP servers`,
-      );
-    }
-
-    return {
-      subtype: 'initialize',
-      capabilities,
-    };
-  }
-
-  /**
-   * Build control capabilities for initialize control response
-   *
-   * This method constructs the control capabilities object that indicates
-   * what control features are available. It is used exclusively in the
-   * initialize control response.
-   */
-  buildControlCapabilities(): Record<string, unknown> {
-    const capabilities: Record<string, unknown> = {
-      can_handle_can_use_tool: true,
-      can_handle_hook_callback: false,
-      can_set_permission_mode:
-        typeof this.context.config.setApprovalMode === 'function',
-      can_set_model: typeof this.context.config.setModel === 'function',
-      // SDK MCP servers are supported - messages routed through control plane
-      can_handle_mcp_message: true,
-    };
-
-    return capabilities;
-  }
-
-  private normalizeMcpServerConfig(
-    serverName: string,
-    config?: CLIMcpServerConfig,
-  ): MCPServerConfig | null {
-    if (!config || typeof config !== 'object') {
-      if (this.context.debugMode) {
-        console.error(
-          `[SystemController] Ignoring invalid MCP server config for '${serverName}'`,
-        );
-      }
-      return null;
-    }
-
-    const authProvider = this.normalizeAuthProviderType(
-      config.authProviderType,
-    );
-    const oauthConfig = this.normalizeOAuthConfig(config.oauth);
-
-    return new MCPServerConfig(
-      config.command,
-      config.args,
-      config.env,
-      config.cwd,
-      config.url,
-      config.httpUrl,
-      config.headers,
-      config.tcp,
-      config.timeout,
-      config.trust,
-      config.description,
-      config.includeTools,
-      config.excludeTools,
-      config.extensionName,
-      oauthConfig,
-      authProvider,
-      config.targetAudience,
-      config.targetServiceAccount,
-    );
-  }
-
-  private normalizeAuthProviderType(
-    value?: string,
-  ): AuthProviderType | undefined {
-    if (!value) {
-      return undefined;
-    }
-
-    switch (value) {
-      case AuthProviderType.DYNAMIC_DISCOVERY:
-      case AuthProviderType.GOOGLE_CREDENTIALS:
-      case AuthProviderType.SERVICE_ACCOUNT_IMPERSONATION:
-        return value;
-      default:
-        if (this.context.debugMode) {
-          console.error(
-            `[SystemController] Unsupported authProviderType '${value}', skipping`,
-          );
-        }
-        return undefined;
-    }
-  }
-
-  private normalizeOAuthConfig(
-    oauth?: CLIMcpServerConfig['oauth'],
-  ): MCPOAuthConfig | undefined {
-    if (!oauth) {
-      return undefined;
-    }
-
-    return {
-      enabled: oauth.enabled,
-      clientId: oauth.clientId,
-      clientSecret: oauth.clientSecret,
-      authorizationUrl: oauth.authorizationUrl,
-      tokenUrl: oauth.tokenUrl,
-      scopes: oauth.scopes,
-      audiences: oauth.audiences,
-      redirectUri: oauth.redirectUri,
-      tokenParamName: oauth.tokenParamName,
-      registrationUrl: oauth.registrationUrl,
-    };
-  }
-
-  /**
-   * Handle interrupt request
-   *
-   * Triggers the interrupt callback to cancel current operations
-   */
-  private async handleInterrupt(): Promise<Record<string, unknown>> {
-    // Trigger interrupt callback if available
-    if (this.context.onInterrupt) {
-      this.context.onInterrupt();
-    }
-
-    // Abort the main signal to cancel ongoing operations
-    if (this.context.abortSignal && !this.context.abortSignal.aborted) {
-      // Note: We can't directly abort the signal, but the onInterrupt callback should handle this
-      if (this.context.debugMode) {
-        console.error('[SystemController] Interrupt signal triggered');
-      }
-    }
-
-    if (this.context.debugMode) {
-      console.error('[SystemController] Interrupt handled');
-    }
-
-    return { subtype: 'interrupt' };
-  }
-
-  /**
-   * Handle set_model request
-   *
-   * Implements actual model switching with validation and error handling
-   */
-  private async handleSetModel(
-    payload: CLIControlSetModelRequest,
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    const model = payload.model;
-
-    // Validate model parameter
-    if (typeof model !== 'string' || model.trim() === '') {
-      throw new Error('Invalid model specified for set_model request');
-    }
-
-    try {
-      // Attempt to set the model using config
-      await this.context.config.setModel(model);
-
-      if (this.context.debugMode) {
-        console.error(`[SystemController] Model switched to: ${model}`);
-      }
-
-      return {
-        subtype: 'set_model',
-        model,
-      };
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : 'Failed to set model';
-
-      if (this.context.debugMode) {
-        console.error(
-          `[SystemController] Failed to set model ${model}:`,
-          error,
-        );
-      }
-
-      throw new Error(errorMessage);
-    }
-  }
-
-  /**
-   * Handle supported_commands request
-   *
-   * Returns list of supported slash commands loaded dynamically
-   */
-  private async handleSupportedCommands(
-    signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    if (signal.aborted) {
-      throw new Error('Request aborted');
-    }
-
-    const slashCommands = await this.loadSlashCommandNames(signal);
-
-    return {
-      subtype: 'supported_commands',
-      commands: slashCommands,
-    };
-  }
-
-  /**
-   * Load slash command names using CommandService
-   *
-   * @param signal - AbortSignal to respect for cancellation
-   * @returns Promise resolving to array of slash command names
-   */
-  private async loadSlashCommandNames(signal: AbortSignal): Promise<string[]> {
-    if (signal.aborted) {
-      return [];
-    }
-
-    try {
-      const service = await CommandService.create(
-        [new BuiltinCommandLoader(this.context.config)],
-        signal,
-      );
-
-      if (signal.aborted) {
-        return [];
-      }
-
-      const names = new Set<string>();
-      const commands = service.getCommands();
-      for (const command of commands) {
-        names.add(command.name);
-      }
-      return Array.from(names).sort();
-    } catch (error) {
-      // Check if the error is due to abort
-      if (signal.aborted) {
-        return [];
-      }
-
-      if (this.context.debugMode) {
-        console.error(
-          '[SystemController] Failed to load slash commands:',
-          error,
-        );
-      }
-      return [];
-    }
-  }
-}
--- a/packages/cli/src/nonInteractive/control/types/serviceAPIs.ts
+++ b/packages/cli/src/nonInteractive/control/types/serviceAPIs.ts
@@ -1,117 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Service API Types
- *
- * These interfaces define the public API contract for the ControlService facade.
- * They provide type-safe, domain-grouped access to control plane functionality
- * for internal CLI code (nonInteractiveCli, session managers, etc.).
- */
-
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import type { MCPServerConfig } from '@qwen-code/qwen-code-core';
-import type { PermissionSuggestion } from '../../types.js';
-
-/**
- * Permission Service API
- *
- * Provides permission-related operations including tool execution approval,
- * permission suggestions, and tool call monitoring callbacks.
- */
-export interface PermissionServiceAPI {
-  /**
-   * Build UI suggestions for tool confirmation dialogs
-   *
-   * Creates actionable permission suggestions based on tool confirmation details,
-   * helping host applications present appropriate approval/denial options.
-   *
-   * @param confirmationDetails - Tool confirmation details (type, title, metadata)
-   * @returns Array of permission suggestions or null if details are invalid
-   */
-  buildPermissionSuggestions(
-    confirmationDetails: unknown,
-  ): PermissionSuggestion[] | null;
-
-  /**
-   * Get callback for monitoring tool call status updates
-   *
-   * Returns a callback function that should be passed to executeToolCall
-   * to enable integration with CoreToolScheduler updates. This callback
-   * handles outgoing permission requests for tools awaiting approval.
-   *
-   * @returns Callback function that processes tool call updates
-   */
-  getToolCallUpdateCallback(): (toolCalls: unknown[]) => void;
-}
-
-/**
- * System Service API
- *
- * Provides system-level operations for the control system.
- *
- * Note: System messages and slash commands are NOT part of the control system API.
- * They are handled independently via buildSystemMessage() from nonInteractiveHelpers.ts,
- * regardless of whether the control system is available.
- */
-export interface SystemServiceAPI {
-  /**
-   * Get control capabilities
-   *
-   * Returns the control capabilities object indicating what control
-   * features are available. Used exclusively for the initialize control
-   * response. System messages do not include capabilities as they are
-   * independent of the control system.
-   *
-   * @returns Control capabilities object
-   */
-  getControlCapabilities(): Record<string, unknown>;
-}
-
-/**
- * MCP Service API
- *
- * Provides Model Context Protocol server interaction including
- * lazy client initialization and server discovery.
- */
-export interface McpServiceAPI {
-  /**
-   * Get or create MCP client for a server (lazy initialization)
-   *
-   * Returns an existing client from cache or creates a new connection
-   * if this is the first request for the server. Handles connection
-   * lifecycle and error recovery.
-   *
-   * @param serverName - Name of the MCP server to connect to
-   * @returns Promise resolving to client instance and server configuration
-   * @throws Error if server is not configured or connection fails
-   */
-  getMcpClient(serverName: string): Promise<{
-    client: Client;
-    config: MCPServerConfig;
-  }>;
-
-  /**
-   * List all available MCP servers
-   *
-   * Returns names of both SDK-managed and CLI-managed MCP servers
-   * that are currently configured or connected.
-   *
-   * @returns Array of server names
-   */
-  listServers(): string[];
-}
-
-/**
- * Hook Service API
- *
- * Provides hook callback processing (placeholder for future expansion).
- */
-export interface HookServiceAPI {
-  // Future: Hook-related methods will be added here
-  // For now, hook functionality is handled only via control requests
-  registerHookCallback(callback: unknown): void;
-}
--- a/packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.test.ts
+++ b/packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.test.ts
--- a/packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.ts
+++ b/packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.ts
--- a/packages/cli/src/nonInteractive/io/JsonOutputAdapter.test.ts
+++ b/packages/cli/src/nonInteractive/io/JsonOutputAdapter.test.ts
@@ -1,791 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import type {
-  Config,
-  ServerGeminiStreamEvent,
-} from '@qwen-code/qwen-code-core';
-import { GeminiEventType } from '@qwen-code/qwen-code-core';
-import type { Part } from '@google/genai';
-import { JsonOutputAdapter } from './JsonOutputAdapter.js';
-
-function createMockConfig(): Config {
-  return {
-    getSessionId: vi.fn().mockReturnValue('test-session-id'),
-    getModel: vi.fn().mockReturnValue('test-model'),
-  } as unknown as Config;
-}
-
-describe('JsonOutputAdapter', () => {
-  let adapter: JsonOutputAdapter;
-  let mockConfig: Config;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let stdoutWriteSpy: any;
-
-  beforeEach(() => {
-    mockConfig = createMockConfig();
-    adapter = new JsonOutputAdapter(mockConfig);
-    stdoutWriteSpy = vi
-      .spyOn(process.stdout, 'write')
-      .mockImplementation(() => true);
-  });
-
-  afterEach(() => {
-    stdoutWriteSpy.mockRestore();
-  });
-
-  describe('startAssistantMessage', () => {
-    it('should reset state for new message', () => {
-      adapter.startAssistantMessage();
-      adapter.startAssistantMessage(); // Start second message
-      // Should not throw
-      expect(() => adapter.finalizeAssistantMessage()).not.toThrow();
-    });
-  });
-
-  describe('processEvent', () => {
-    beforeEach(() => {
-      adapter.startAssistantMessage();
-    });
-
-    it('should append text content from Content events', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Content,
-        value: 'Hello',
-      };
-      adapter.processEvent(event);
-
-      const event2: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Content,
-        value: ' World',
-      };
-      adapter.processEvent(event2);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: 'Hello World',
-      });
-    });
-
-    it('should append citation content from Citation events', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Citation,
-        value: 'Citation text',
-      };
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: expect.stringContaining('Citation text'),
-      });
-    });
-
-    it('should ignore non-string citation values', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Citation,
-        value: 123,
-      } as unknown as ServerGeminiStreamEvent;
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(0);
-    });
-
-    it('should append thinking from Thought events', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: 'Thinking about the task',
-        },
-      };
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'thinking',
-        thinking: 'Planning: Thinking about the task',
-        signature: 'Planning',
-      });
-    });
-
-    it('should handle thinking with only subject', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: '',
-        },
-      };
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content[0]).toMatchObject({
-        type: 'thinking',
-        signature: 'Planning',
-      });
-    });
-
-    it('should append tool use from ToolCallRequest events', () => {
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      };
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'tool_use',
-        id: 'tool-call-1',
-        name: 'test_tool',
-        input: { param1: 'value1' },
-      });
-    });
-
-    it('should set stop_reason to tool_use when message contains only tool_use blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBe('tool_use');
-    });
-
-    it('should set stop_reason to null when message contains text blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Some text',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBeNull();
-    });
-
-    it('should set stop_reason to null when message contains thinking blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: 'Thinking about the task',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBeNull();
-    });
-
-    it('should set stop_reason to tool_use when message contains multiple tool_use blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool_1',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-2',
-          name: 'test_tool_2',
-          args: { param2: 'value2' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(2);
-      expect(
-        message.message.content.every((block) => block.type === 'tool_use'),
-      ).toBe(true);
-      expect(message.message.stop_reason).toBe('tool_use');
-    });
-
-    it('should update usage from Finished event', () => {
-      const usageMetadata = {
-        promptTokenCount: 100,
-        candidatesTokenCount: 50,
-        cachedContentTokenCount: 10,
-        totalTokenCount: 160,
-      };
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Finished,
-        value: {
-          reason: undefined,
-          usageMetadata,
-        },
-      };
-      adapter.processEvent(event);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.usage).toMatchObject({
-        input_tokens: 100,
-        output_tokens: 50,
-        cache_read_input_tokens: 10,
-        total_tokens: 160,
-      });
-    });
-
-    it('should finalize pending blocks on Finished event', () => {
-      // Add some text first
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Some text',
-      });
-
-      const event: ServerGeminiStreamEvent = {
-        type: GeminiEventType.Finished,
-        value: { reason: undefined, usageMetadata: undefined },
-      };
-      adapter.processEvent(event);
-
-      // Should not throw when finalizing
-      expect(() => adapter.finalizeAssistantMessage()).not.toThrow();
-    });
-
-    it('should ignore events after finalization', () => {
-      adapter.finalizeAssistantMessage();
-      const originalContent =
-        adapter.finalizeAssistantMessage().message.content;
-
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Should be ignored',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toEqual(originalContent);
-    });
-  });
-
-  describe('finalizeAssistantMessage', () => {
-    beforeEach(() => {
-      adapter.startAssistantMessage();
-    });
-
-    it('should build and emit a complete assistant message', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test response',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-
-      expect(message.type).toBe('assistant');
-      expect(message.uuid).toBeTruthy();
-      expect(message.session_id).toBe('test-session-id');
-      expect(message.parent_tool_use_id).toBeNull();
-      expect(message.message.role).toBe('assistant');
-      expect(message.message.model).toBe('test-model');
-      expect(message.message.content).toHaveLength(1);
-    });
-
-    it('should return same message on subsequent calls', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test',
-      });
-
-      const message1 = adapter.finalizeAssistantMessage();
-      const message2 = adapter.finalizeAssistantMessage();
-
-      expect(message1).toEqual(message2);
-    });
-
-    it('should split different block types into separate assistant messages', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: { subject: 'Thinking', description: 'Thought' },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0].type).toBe('thinking');
-
-      const storedMessages = (adapter as unknown as { messages: unknown[] })
-        .messages;
-      const assistantMessages = storedMessages.filter(
-        (
-          msg,
-        ): msg is {
-          type: string;
-          message: { content: Array<{ type: string }> };
-        } => {
-          if (
-            typeof msg !== 'object' ||
-            msg === null ||
-            !('type' in msg) ||
-            (msg as { type?: string }).type !== 'assistant' ||
-            !('message' in msg)
-          ) {
-            return false;
-          }
-          const message = (msg as { message?: unknown }).message;
-          return (
-            typeof message === 'object' &&
-            message !== null &&
-            'content' in message &&
-            Array.isArray((message as { content?: unknown }).content)
-          );
-        },
-      );
-
-      expect(assistantMessages).toHaveLength(2);
-      for (const assistant of assistantMessages) {
-        const uniqueTypes = new Set(
-          assistant.message.content.map((block) => block.type),
-        );
-        expect(uniqueTypes.size).toBeLessThanOrEqual(1);
-      }
-    });
-
-    it('should throw if message not started', () => {
-      adapter = new JsonOutputAdapter(mockConfig);
-      expect(() => adapter.finalizeAssistantMessage()).toThrow(
-        'Message not started',
-      );
-    });
-  });
-
-  describe('emitResult', () => {
-    beforeEach(() => {
-      adapter.startAssistantMessage();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Response text',
-      });
-      adapter.finalizeAssistantMessage();
-    });
-
-    it('should emit success result as JSON array', () => {
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(Array.isArray(parsed)).toBe(true);
-      const resultMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'result',
-      );
-
-      expect(resultMessage).toBeDefined();
-      expect(resultMessage.is_error).toBe(false);
-      expect(resultMessage.subtype).toBe('success');
-      expect(resultMessage.result).toBe('Response text');
-      expect(resultMessage.duration_ms).toBe(1000);
-      expect(resultMessage.num_turns).toBe(1);
-    });
-
-    it('should emit error result', () => {
-      adapter.emitResult({
-        isError: true,
-        errorMessage: 'Test error',
-        durationMs: 500,
-        apiDurationMs: 300,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const resultMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'result',
-      );
-
-      expect(resultMessage.is_error).toBe(true);
-      expect(resultMessage.subtype).toBe('error_during_execution');
-      expect(resultMessage.error?.message).toBe('Test error');
-    });
-
-    it('should use provided summary over extracted text', () => {
-      adapter.emitResult({
-        isError: false,
-        summary: 'Custom summary',
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const resultMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'result',
-      );
-
-      expect(resultMessage.result).toBe('Custom summary');
-    });
-
-    it('should include usage information', () => {
-      const usage = {
-        input_tokens: 100,
-        output_tokens: 50,
-        total_tokens: 150,
-      };
-
-      adapter.emitResult({
-        isError: false,
-        usage,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const resultMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'result',
-      );
-
-      expect(resultMessage.usage).toEqual(usage);
-    });
-
-    it('should include stats when provided', () => {
-      const stats = {
-        models: {},
-        tools: {
-          totalCalls: 5,
-          totalSuccess: 4,
-          totalFail: 1,
-          totalDurationMs: 1000,
-          totalDecisions: {
-            accept: 3,
-            reject: 1,
-            modify: 0,
-            auto_accept: 1,
-          },
-          byName: {},
-        },
-        files: {
-          totalLinesAdded: 10,
-          totalLinesRemoved: 5,
-        },
-      };
-
-      adapter.emitResult({
-        isError: false,
-        stats,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const resultMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'result',
-      );
-
-      expect(resultMessage.stats).toEqual(stats);
-    });
-  });
-
-  describe('emitUserMessage', () => {
-    it('should add user message to collection', () => {
-      const parts: Part[] = [{ text: 'Hello user' }];
-      adapter.emitUserMessage(parts);
-
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const userMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'user',
-      );
-
-      expect(userMessage).toBeDefined();
-      expect(Array.isArray(userMessage.message.content)).toBe(true);
-      if (Array.isArray(userMessage.message.content)) {
-        expect(userMessage.message.content).toHaveLength(1);
-        expect(userMessage.message.content[0]).toEqual({
-          type: 'text',
-          text: 'Hello user',
-        });
-      }
-    });
-
-    it('should handle parent_tool_use_id', () => {
-      const parts: Part[] = [{ text: 'Tool response' }];
-      adapter.emitUserMessage(parts);
-
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const userMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'user',
-      );
-
-      // emitUserMessage currently sets parent_tool_use_id to null
-      expect(userMessage.parent_tool_use_id).toBeNull();
-    });
-  });
-
-  describe('emitToolResult', () => {
-    it('should emit tool result message', () => {
-      const request = {
-        callId: 'tool-1',
-        name: 'test_tool',
-        args: {},
-        isClientInitiated: false,
-        prompt_id: 'prompt-1',
-      };
-      const response = {
-        callId: 'tool-1',
-        responseParts: [],
-        resultDisplay: 'Tool executed successfully',
-        error: undefined,
-        errorType: undefined,
-      };
-
-      adapter.emitToolResult(request, response);
-
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const toolResult = parsed.find(
-        (
-          msg: unknown,
-        ): msg is { type: 'user'; message: { content: unknown[] } } =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'user' &&
-          'message' in msg &&
-          typeof msg.message === 'object' &&
-          msg.message !== null &&
-          'content' in msg.message &&
-          Array.isArray(msg.message.content) &&
-          msg.message.content[0] &&
-          typeof msg.message.content[0] === 'object' &&
-          'type' in msg.message.content[0] &&
-          msg.message.content[0].type === 'tool_result',
-      );
-
-      expect(toolResult).toBeDefined();
-      const block = toolResult.message.content[0] as {
-        type: 'tool_result';
-        tool_use_id: string;
-        content?: string;
-        is_error?: boolean;
-      };
-      expect(block).toMatchObject({
-        type: 'tool_result',
-        tool_use_id: 'tool-1',
-        content: 'Tool executed successfully',
-        is_error: false,
-      });
-    });
-
-    it('should mark error tool results', () => {
-      const request = {
-        callId: 'tool-1',
-        name: 'test_tool',
-        args: {},
-        isClientInitiated: false,
-        prompt_id: 'prompt-1',
-      };
-      const response = {
-        callId: 'tool-1',
-        responseParts: [],
-        resultDisplay: undefined,
-        error: new Error('Tool failed'),
-        errorType: undefined,
-      };
-
-      adapter.emitToolResult(request, response);
-
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const toolResult = parsed.find(
-        (
-          msg: unknown,
-        ): msg is { type: 'user'; message: { content: unknown[] } } =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'user' &&
-          'message' in msg &&
-          typeof msg.message === 'object' &&
-          msg.message !== null &&
-          'content' in msg.message &&
-          Array.isArray(msg.message.content),
-      );
-
-      const block = toolResult.message.content[0] as {
-        is_error?: boolean;
-      };
-      expect(block.is_error).toBe(true);
-    });
-  });
-
-  describe('emitSystemMessage', () => {
-    it('should add system message to collection', () => {
-      adapter.emitSystemMessage('test_subtype', { data: 'value' });
-
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      const systemMessage = parsed.find(
-        (msg: unknown) =>
-          typeof msg === 'object' &&
-          msg !== null &&
-          'type' in msg &&
-          msg.type === 'system',
-      );
-
-      expect(systemMessage).toBeDefined();
-      expect(systemMessage.subtype).toBe('test_subtype');
-      expect(systemMessage.data).toEqual({ data: 'value' });
-    });
-  });
-
-  describe('getSessionId and getModel', () => {
-    it('should return session ID from config', () => {
-      expect(adapter.getSessionId()).toBe('test-session-id');
-      expect(mockConfig.getSessionId).toHaveBeenCalled();
-    });
-
-    it('should return model from config', () => {
-      expect(adapter.getModel()).toBe('test-model');
-      expect(mockConfig.getModel).toHaveBeenCalled();
-    });
-  });
-
-  describe('multiple messages in collection', () => {
-    it('should collect all messages and emit as array', () => {
-      adapter.emitSystemMessage('init', {});
-      adapter.emitUserMessage([{ text: 'User input' }]);
-      adapter.startAssistantMessage();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Assistant response',
-      });
-      adapter.finalizeAssistantMessage();
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(Array.isArray(parsed)).toBe(true);
-      expect(parsed.length).toBeGreaterThanOrEqual(3);
-      const systemMsg = parsed[0] as { type?: string };
-      const userMsg = parsed[1] as { type?: string };
-      expect(systemMsg.type).toBe('system');
-      expect(userMsg.type).toBe('user');
-      expect(
-        parsed.find(
-          (msg: unknown) =>
-            typeof msg === 'object' &&
-            msg !== null &&
-            'type' in msg &&
-            (msg as { type?: string }).type === 'assistant',
-        ),
-      ).toBeDefined();
-      expect(
-        parsed.find(
-          (msg: unknown) =>
-            typeof msg === 'object' &&
-            msg !== null &&
-            'type' in msg &&
-            (msg as { type?: string }).type === 'result',
-        ),
-      ).toBeDefined();
-    });
-  });
-});
--- a/packages/cli/src/nonInteractive/io/JsonOutputAdapter.ts
+++ b/packages/cli/src/nonInteractive/io/JsonOutputAdapter.ts
@@ -1,81 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Config } from '@qwen-code/qwen-code-core';
-import type { CLIAssistantMessage, CLIMessage } from '../types.js';
-import {
-  BaseJsonOutputAdapter,
-  type JsonOutputAdapterInterface,
-  type ResultOptions,
-} from './BaseJsonOutputAdapter.js';
-
-/**
- * JSON output adapter that collects all messages and emits them
- * as a single JSON array at the end of the turn.
- * Supports both main agent and subagent messages through distinct APIs.
- */
-export class JsonOutputAdapter
-  extends BaseJsonOutputAdapter
-  implements JsonOutputAdapterInterface
-{
-  private readonly messages: CLIMessage[] = [];
-
-  constructor(config: Config) {
-    super(config);
-  }
-
-  /**
-   * Emits message to the messages array (batch mode).
-   * Tracks the last assistant message for efficient result text extraction.
-   */
-  protected emitMessageImpl(message: CLIMessage): void {
-    this.messages.push(message);
-    // Track assistant messages for result generation
-    if (
-      typeof message === 'object' &&
-      message !== null &&
-      'type' in message &&
-      message.type === 'assistant'
-    ) {
-      this.updateLastAssistantMessage(message as CLIAssistantMessage);
-    }
-  }
-
-  /**
-   * JSON mode does not emit stream events.
-   */
-  protected shouldEmitStreamEvents(): boolean {
-    return false;
-  }
-
-  finalizeAssistantMessage(): CLIAssistantMessage {
-    const message = this.finalizeAssistantMessageInternal(
-      this.mainAgentMessageState,
-      null,
-    );
-    this.updateLastAssistantMessage(message);
-    return message;
-  }
-
-  emitResult(options: ResultOptions): void {
-    const resultMessage = this.buildResultMessage(
-      options,
-      this.lastAssistantMessage,
-    );
-    this.messages.push(resultMessage);
-
-    // Emit the entire messages array as JSON (includes all main agent + subagent messages)
-    const json = JSON.stringify(this.messages);
-    process.stdout.write(`${json}\n`);
-  }
-
-  emitMessage(message: CLIMessage): void {
-    // In JSON mode, messages are collected in the messages array
-    // This is called by the base class's finalizeAssistantMessageInternal
-    // but can also be called directly for user/tool/system messages
-    this.messages.push(message);
-  }
-}
--- a/packages/cli/src/nonInteractive/io/StreamJsonInputReader.test.ts
+++ b/packages/cli/src/nonInteractive/io/StreamJsonInputReader.test.ts
@@ -1,215 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { PassThrough } from 'node:stream';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import {
-  StreamJsonInputReader,
-  StreamJsonParseError,
-  type StreamJsonInputMessage,
-} from './StreamJsonInputReader.js';
-
-describe('StreamJsonInputReader', () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('read', () => {
-    /**
-     * Test parsing all supported message types in a single test
-     */
-    it('should parse valid messages of all types', async () => {
-      const input = new PassThrough();
-      const reader = new StreamJsonInputReader(input);
-
-      const messages = [
-        {
-          type: 'user',
-          session_id: 'test-session',
-          message: {
-            role: 'user',
-            content: [{ type: 'text', text: 'hello world' }],
-          },
-          parent_tool_use_id: null,
-        },
-        {
-          type: 'control_request',
-          request_id: 'req-1',
-          request: { subtype: 'initialize' },
-        },
-        {
-          type: 'control_response',
-          response: {
-            subtype: 'success',
-            request_id: 'req-1',
-            response: { initialized: true },
-          },
-        },
-        {
-          type: 'control_cancel_request',
-          request_id: 'req-1',
-        },
-      ];
-
-      for (const msg of messages) {
-        input.write(JSON.stringify(msg) + '\n');
-      }
-      input.end();
-
-      const parsed: StreamJsonInputMessage[] = [];
-      for await (const msg of reader.read()) {
-        parsed.push(msg);
-      }
-
-      expect(parsed).toHaveLength(messages.length);
-      expect(parsed).toEqual(messages);
-    });
-
-    it('should parse multiple messages', async () => {
-      const input = new PassThrough();
-      const reader = new StreamJsonInputReader(input);
-
-      const message1 = {
-        type: 'control_request',
-        request_id: 'req-1',
-        request: { subtype: 'initialize' },
-      };
-
-      const message2 = {
-        type: 'user',
-        session_id: 'test-session',
-        message: {
-          role: 'user',
-          content: [{ type: 'text', text: 'hello' }],
-        },
-        parent_tool_use_id: null,
-      };
-
-      input.write(JSON.stringify(message1) + '\n');
-      input.write(JSON.stringify(message2) + '\n');
-      input.end();
-
-      const messages: StreamJsonInputMessage[] = [];
-      for await (const msg of reader.read()) {
-        messages.push(msg);
-      }
-
-      expect(messages).toHaveLength(2);
-      expect(messages[0]).toEqual(message1);
-      expect(messages[1]).toEqual(message2);
-    });
-
-    it('should skip empty lines and trim whitespace', async () => {
-      const input = new PassThrough();
-      const reader = new StreamJsonInputReader(input);
-
-      const message = {
-        type: 'user',
-        session_id: 'test-session',
-        message: {
-          role: 'user',
-          content: [{ type: 'text', text: 'hello' }],
-        },
-        parent_tool_use_id: null,
-      };
-
-      input.write('\n');
-      input.write('  ' + JSON.stringify(message) + '  \n');
-      input.write('  \n');
-      input.write('\t\n');
-      input.end();
-
-      const messages: StreamJsonInputMessage[] = [];
-      for await (const msg of reader.read()) {
-        messages.push(msg);
-      }
-
-      expect(messages).toHaveLength(1);
-      expect(messages[0]).toEqual(message);
-    });
-
-    /**
-     * Consolidated error handling test cases
-     */
-    it.each([
-      {
-        name: 'invalid JSON',
-        input: '{"invalid": json}\n',
-        expectedError: 'Failed to parse stream-json line',
-      },
-      {
-        name: 'missing type field',
-        input:
-          JSON.stringify({ session_id: 'test-session', message: 'hello' }) +
-          '\n',
-        expectedError: 'Missing required "type" field',
-      },
-      {
-        name: 'non-object value (string)',
-        input: '"just a string"\n',
-        expectedError: 'Parsed value is not an object',
-      },
-      {
-        name: 'non-object value (null)',
-        input: 'null\n',
-        expectedError: 'Parsed value is not an object',
-      },
-      {
-        name: 'array value',
-        input: '[1, 2, 3]\n',
-        expectedError: 'Missing required "type" field',
-      },
-      {
-        name: 'type field not a string',
-        input: JSON.stringify({ type: 123, session_id: 'test-session' }) + '\n',
-        expectedError: 'Missing required "type" field',
-      },
-    ])(
-      'should throw StreamJsonParseError for $name',
-      async ({ input: inputLine, expectedError }) => {
-        const input = new PassThrough();
-        const reader = new StreamJsonInputReader(input);
-
-        input.write(inputLine);
-        input.end();
-
-        const messages: StreamJsonInputMessage[] = [];
-        let error: unknown;
-
-        try {
-          for await (const msg of reader.read()) {
-            messages.push(msg);
-          }
-        } catch (e) {
-          error = e;
-        }
-
-        expect(messages).toHaveLength(0);
-        expect(error).toBeInstanceOf(StreamJsonParseError);
-        expect((error as StreamJsonParseError).message).toContain(
-          expectedError,
-        );
-      },
-    );
-
-    it('should use process.stdin as default input', () => {
-      const reader = new StreamJsonInputReader();
-      // Access private field for testing constructor default parameter
-      expect((reader as unknown as { input: typeof process.stdin }).input).toBe(
-        process.stdin,
-      );
-    });
-
-    it('should use provided input stream', () => {
-      const customInput = new PassThrough();
-      const reader = new StreamJsonInputReader(customInput);
-      // Access private field for testing constructor parameter
-      expect((reader as unknown as { input: typeof customInput }).input).toBe(
-        customInput,
-      );
-    });
-  });
-});
--- a/packages/cli/src/nonInteractive/io/StreamJsonInputReader.ts
+++ b/packages/cli/src/nonInteractive/io/StreamJsonInputReader.ts
@@ -1,73 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { createInterface } from 'node:readline/promises';
-import type { Readable } from 'node:stream';
-import process from 'node:process';
-import type {
-  CLIControlRequest,
-  CLIControlResponse,
-  CLIMessage,
-  ControlCancelRequest,
-} from '../types.js';
-
-export type StreamJsonInputMessage =
-  | CLIMessage
-  | CLIControlRequest
-  | CLIControlResponse
-  | ControlCancelRequest;
-
-export class StreamJsonParseError extends Error {}
-
-export class StreamJsonInputReader {
-  private readonly input: Readable;
-
-  constructor(input: Readable = process.stdin) {
-    this.input = input;
-  }
-
-  async *read(): AsyncGenerator<StreamJsonInputMessage> {
-    const rl = createInterface({
-      input: this.input,
-      crlfDelay: Number.POSITIVE_INFINITY,
-      terminal: false,
-    });
-
-    try {
-      for await (const rawLine of rl) {
-        const line = rawLine.trim();
-        if (!line) {
-          continue;
-        }
-
-        yield this.parse(line);
-      }
-    } finally {
-      rl.close();
-    }
-  }
-
-  private parse(line: string): StreamJsonInputMessage {
-    try {
-      const parsed = JSON.parse(line) as StreamJsonInputMessage;
-      if (!parsed || typeof parsed !== 'object') {
-        throw new StreamJsonParseError('Parsed value is not an object');
-      }
-      if (!('type' in parsed) || typeof parsed.type !== 'string') {
-        throw new StreamJsonParseError('Missing required "type" field');
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof StreamJsonParseError) {
-        throw error;
-      }
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new StreamJsonParseError(
-        `Failed to parse stream-json line: ${reason}`,
-      );
-    }
-  }
-}
--- a/packages/cli/src/nonInteractive/io/StreamJsonOutputAdapter.test.ts
+++ b/packages/cli/src/nonInteractive/io/StreamJsonOutputAdapter.test.ts
@@ -1,997 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import type {
-  Config,
-  ServerGeminiStreamEvent,
-} from '@qwen-code/qwen-code-core';
-import { GeminiEventType } from '@qwen-code/qwen-code-core';
-import type { Part } from '@google/genai';
-import { StreamJsonOutputAdapter } from './StreamJsonOutputAdapter.js';
-
-function createMockConfig(): Config {
-  return {
-    getSessionId: vi.fn().mockReturnValue('test-session-id'),
-    getModel: vi.fn().mockReturnValue('test-model'),
-  } as unknown as Config;
-}
-
-describe('StreamJsonOutputAdapter', () => {
-  let adapter: StreamJsonOutputAdapter;
-  let mockConfig: Config;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let stdoutWriteSpy: any;
-
-  beforeEach(() => {
-    mockConfig = createMockConfig();
-    stdoutWriteSpy = vi
-      .spyOn(process.stdout, 'write')
-      .mockImplementation(() => true);
-  });
-
-  afterEach(() => {
-    stdoutWriteSpy.mockRestore();
-  });
-
-  describe('with partial messages enabled', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, true);
-    });
-
-    describe('startAssistantMessage', () => {
-      it('should reset state for new message', () => {
-        adapter.startAssistantMessage();
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'First',
-        });
-        adapter.finalizeAssistantMessage();
-
-        adapter.startAssistantMessage();
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'Second',
-        });
-
-        const message = adapter.finalizeAssistantMessage();
-        expect(message.message.content[0]).toMatchObject({
-          type: 'text',
-          text: 'Second',
-        });
-      });
-    });
-
-    describe('processEvent with stream events', () => {
-      beforeEach(() => {
-        adapter.startAssistantMessage();
-      });
-
-      it('should emit stream events for text deltas', () => {
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'Hello',
-        });
-
-        const calls = stdoutWriteSpy.mock.calls;
-        expect(calls.length).toBeGreaterThan(0);
-
-        const deltaEventCall = calls.find((call: unknown[]) => {
-          try {
-            const parsed = JSON.parse(call[0] as string);
-            return (
-              parsed.type === 'stream_event' &&
-              parsed.event.type === 'content_block_delta'
-            );
-          } catch {
-            return false;
-          }
-        });
-
-        expect(deltaEventCall).toBeDefined();
-        const parsed = JSON.parse(deltaEventCall![0] as string);
-        expect(parsed.event.type).toBe('content_block_delta');
-        expect(parsed.event.delta).toMatchObject({
-          type: 'text_delta',
-          text: 'Hello',
-        });
-      });
-
-      it('should emit message_start event on first content', () => {
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'First',
-        });
-
-        const calls = stdoutWriteSpy.mock.calls;
-        const messageStartCall = calls.find((call: unknown[]) => {
-          try {
-            const parsed = JSON.parse(call[0] as string);
-            return (
-              parsed.type === 'stream_event' &&
-              parsed.event.type === 'message_start'
-            );
-          } catch {
-            return false;
-          }
-        });
-
-        expect(messageStartCall).toBeDefined();
-      });
-
-      it('should emit content_block_start for new blocks', () => {
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'Text',
-        });
-
-        const calls = stdoutWriteSpy.mock.calls;
-        const blockStartCall = calls.find((call: unknown[]) => {
-          try {
-            const parsed = JSON.parse(call[0] as string);
-            return (
-              parsed.type === 'stream_event' &&
-              parsed.event.type === 'content_block_start'
-            );
-          } catch {
-            return false;
-          }
-        });
-
-        expect(blockStartCall).toBeDefined();
-      });
-
-      it('should emit thinking delta events', () => {
-        adapter.processEvent({
-          type: GeminiEventType.Thought,
-          value: {
-            subject: 'Planning',
-            description: 'Thinking',
-          },
-        });
-
-        const calls = stdoutWriteSpy.mock.calls;
-        const deltaCall = calls.find((call: unknown[]) => {
-          try {
-            const parsed = JSON.parse(call[0] as string);
-            return (
-              parsed.type === 'stream_event' &&
-              parsed.event.type === 'content_block_delta' &&
-              parsed.event.delta.type === 'thinking_delta'
-            );
-          } catch {
-            return false;
-          }
-        });
-
-        expect(deltaCall).toBeDefined();
-      });
-
-      it('should emit message_stop on finalization', () => {
-        adapter.processEvent({
-          type: GeminiEventType.Content,
-          value: 'Text',
-        });
-        adapter.finalizeAssistantMessage();
-
-        const calls = stdoutWriteSpy.mock.calls;
-        const messageStopCall = calls.find((call: unknown[]) => {
-          try {
-            const parsed = JSON.parse(call[0] as string);
-            return (
-              parsed.type === 'stream_event' &&
-              parsed.event.type === 'message_stop'
-            );
-          } catch {
-            return false;
-          }
-        });
-
-        expect(messageStopCall).toBeDefined();
-      });
-    });
-  });
-
-  describe('with partial messages disabled', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-    });
-
-    it('should not emit stream events', () => {
-      adapter.startAssistantMessage();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text',
-      });
-
-      const calls = stdoutWriteSpy.mock.calls;
-      const streamEventCall = calls.find((call: unknown[]) => {
-        try {
-          const parsed = JSON.parse(call[0] as string);
-          return parsed.type === 'stream_event';
-        } catch {
-          return false;
-        }
-      });
-
-      expect(streamEventCall).toBeUndefined();
-    });
-
-    it('should still emit final assistant message', () => {
-      adapter.startAssistantMessage();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text',
-      });
-      adapter.finalizeAssistantMessage();
-
-      const calls = stdoutWriteSpy.mock.calls;
-      const assistantCall = calls.find((call: unknown[]) => {
-        try {
-          const parsed = JSON.parse(call[0] as string);
-          return parsed.type === 'assistant';
-        } catch {
-          return false;
-        }
-      });
-
-      expect(assistantCall).toBeDefined();
-    });
-  });
-
-  describe('processEvent', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      adapter.startAssistantMessage();
-    });
-
-    it('should append text content from Content events', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Hello',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: ' World',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: 'Hello World',
-      });
-    });
-
-    it('should append citation content from Citation events', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Citation,
-        value: 'Citation text',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: expect.stringContaining('Citation text'),
-      });
-    });
-
-    it('should ignore non-string citation values', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Citation,
-        value: 123,
-      } as unknown as ServerGeminiStreamEvent);
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(0);
-    });
-
-    it('should append thinking from Thought events', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: 'Thinking about the task',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'thinking',
-        thinking: 'Planning: Thinking about the task',
-        signature: 'Planning',
-      });
-    });
-
-    it('should handle thinking with only subject', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: '',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content[0]).toMatchObject({
-        type: 'thinking',
-        signature: 'Planning',
-      });
-    });
-
-    it('should append tool use from ToolCallRequest events', () => {
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'tool_use',
-        id: 'tool-call-1',
-        name: 'test_tool',
-        input: { param1: 'value1' },
-      });
-    });
-
-    it('should set stop_reason to tool_use when message contains only tool_use blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBe('tool_use');
-    });
-
-    it('should set stop_reason to null when message contains text blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Some text',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBeNull();
-    });
-
-    it('should set stop_reason to null when message contains thinking blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: {
-          subject: 'Planning',
-          description: 'Thinking about the task',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.stop_reason).toBeNull();
-    });
-
-    it('should set stop_reason to tool_use when message contains multiple tool_use blocks', () => {
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-1',
-          name: 'test_tool_1',
-          args: { param1: 'value1' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-      adapter.processEvent({
-        type: GeminiEventType.ToolCallRequest,
-        value: {
-          callId: 'tool-call-2',
-          name: 'test_tool_2',
-          args: { param2: 'value2' },
-          isClientInitiated: false,
-          prompt_id: 'prompt-1',
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(2);
-      expect(
-        message.message.content.every((block) => block.type === 'tool_use'),
-      ).toBe(true);
-      expect(message.message.stop_reason).toBe('tool_use');
-    });
-
-    it('should update usage from Finished event', () => {
-      const usageMetadata = {
-        promptTokenCount: 100,
-        candidatesTokenCount: 50,
-        cachedContentTokenCount: 10,
-        totalTokenCount: 160,
-      };
-      adapter.processEvent({
-        type: GeminiEventType.Finished,
-        value: {
-          reason: undefined,
-          usageMetadata,
-        },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.usage).toMatchObject({
-        input_tokens: 100,
-        output_tokens: 50,
-        cache_read_input_tokens: 10,
-        total_tokens: 160,
-      });
-    });
-
-    it('should ignore events after finalization', () => {
-      adapter.finalizeAssistantMessage();
-      const originalContent =
-        adapter.finalizeAssistantMessage().message.content;
-
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Should be ignored',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toEqual(originalContent);
-    });
-  });
-
-  describe('finalizeAssistantMessage', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      adapter.startAssistantMessage();
-    });
-
-    it('should build and emit a complete assistant message', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test response',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-
-      expect(message.type).toBe('assistant');
-      expect(message.uuid).toBeTruthy();
-      expect(message.session_id).toBe('test-session-id');
-      expect(message.parent_tool_use_id).toBeNull();
-      expect(message.message.role).toBe('assistant');
-      expect(message.message.model).toBe('test-model');
-      expect(message.message.content).toHaveLength(1);
-    });
-
-    it('should emit message to stdout immediately', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test',
-      });
-
-      stdoutWriteSpy.mockClear();
-      adapter.finalizeAssistantMessage();
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-      expect(parsed.type).toBe('assistant');
-    });
-
-    it('should store message in lastAssistantMessage', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      // Access protected property for testing
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((adapter as any).lastAssistantMessage).toEqual(message);
-    });
-
-    it('should return same message on subsequent calls', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Test',
-      });
-
-      const message1 = adapter.finalizeAssistantMessage();
-      const message2 = adapter.finalizeAssistantMessage();
-
-      expect(message1).toEqual(message2);
-    });
-
-    it('should split different block types into separate assistant messages', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: { subject: 'Thinking', description: 'Thought' },
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0].type).toBe('thinking');
-
-      const assistantMessages = stdoutWriteSpy.mock.calls
-        .map((call: unknown[]) => JSON.parse(call[0] as string))
-        .filter(
-          (
-            payload: unknown,
-          ): payload is {
-            type: string;
-            message: { content: Array<{ type: string }> };
-          } => {
-            if (
-              typeof payload !== 'object' ||
-              payload === null ||
-              !('type' in payload) ||
-              (payload as { type?: string }).type !== 'assistant' ||
-              !('message' in payload)
-            ) {
-              return false;
-            }
-            const message = (payload as { message?: unknown }).message;
-            if (
-              typeof message !== 'object' ||
-              message === null ||
-              !('content' in message)
-            ) {
-              return false;
-            }
-            const content = (message as { content?: unknown }).content;
-            return (
-              Array.isArray(content) &&
-              content.length > 0 &&
-              content.every(
-                (block: unknown) =>
-                  typeof block === 'object' &&
-                  block !== null &&
-                  'type' in block,
-              )
-            );
-          },
-        );
-
-      expect(assistantMessages).toHaveLength(2);
-      const observedTypes = assistantMessages.map(
-        (payload: {
-          type: string;
-          message: { content: Array<{ type: string }> };
-        }) => payload.message.content[0]?.type ?? '',
-      );
-      expect(observedTypes).toEqual(['text', 'thinking']);
-      for (const payload of assistantMessages) {
-        const uniqueTypes = new Set(
-          payload.message.content.map((block: { type: string }) => block.type),
-        );
-        expect(uniqueTypes.size).toBeLessThanOrEqual(1);
-      }
-    });
-
-    it('should throw if message not started', () => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      expect(() => adapter.finalizeAssistantMessage()).toThrow(
-        'Message not started',
-      );
-    });
-  });
-
-  describe('emitResult', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      adapter.startAssistantMessage();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Response text',
-      });
-      adapter.finalizeAssistantMessage();
-    });
-
-    it('should emit success result immediately', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.type).toBe('result');
-      expect(parsed.is_error).toBe(false);
-      expect(parsed.subtype).toBe('success');
-      expect(parsed.result).toBe('Response text');
-      expect(parsed.duration_ms).toBe(1000);
-      expect(parsed.num_turns).toBe(1);
-    });
-
-    it('should emit error result', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.emitResult({
-        isError: true,
-        errorMessage: 'Test error',
-        durationMs: 500,
-        apiDurationMs: 300,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.is_error).toBe(true);
-      expect(parsed.subtype).toBe('error_during_execution');
-      expect(parsed.error?.message).toBe('Test error');
-    });
-
-    it('should use provided summary over extracted text', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.emitResult({
-        isError: false,
-        summary: 'Custom summary',
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.result).toBe('Custom summary');
-    });
-
-    it('should include usage information', () => {
-      const usage = {
-        input_tokens: 100,
-        output_tokens: 50,
-        total_tokens: 150,
-      };
-
-      stdoutWriteSpy.mockClear();
-      adapter.emitResult({
-        isError: false,
-        usage,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.usage).toEqual(usage);
-    });
-
-    it('should handle result without assistant message', () => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      stdoutWriteSpy.mockClear();
-      adapter.emitResult({
-        isError: false,
-        durationMs: 1000,
-        apiDurationMs: 800,
-        numTurns: 1,
-      });
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.result).toBe('');
-    });
-  });
-
-  describe('emitUserMessage', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-    });
-
-    it('should emit user message immediately', () => {
-      stdoutWriteSpy.mockClear();
-      const parts: Part[] = [{ text: 'Hello user' }];
-      adapter.emitUserMessage(parts);
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.type).toBe('user');
-      expect(Array.isArray(parsed.message.content)).toBe(true);
-      if (Array.isArray(parsed.message.content)) {
-        expect(parsed.message.content).toHaveLength(1);
-        expect(parsed.message.content[0]).toEqual({
-          type: 'text',
-          text: 'Hello user',
-        });
-      }
-    });
-
-    it('should handle parent_tool_use_id', () => {
-      const parts: Part[] = [{ text: 'Tool response' }];
-      adapter.emitUserMessage(parts);
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      // emitUserMessage currently sets parent_tool_use_id to null
-      expect(parsed.parent_tool_use_id).toBeNull();
-    });
-  });
-
-  describe('emitToolResult', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-    });
-
-    it('should emit tool result message immediately', () => {
-      stdoutWriteSpy.mockClear();
-      const request = {
-        callId: 'tool-1',
-        name: 'test_tool',
-        args: {},
-        isClientInitiated: false,
-        prompt_id: 'prompt-1',
-      };
-      const response = {
-        callId: 'tool-1',
-        responseParts: [],
-        resultDisplay: 'Tool executed successfully',
-        error: undefined,
-        errorType: undefined,
-      };
-
-      adapter.emitToolResult(request, response);
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.type).toBe('user');
-      expect(parsed.parent_tool_use_id).toBeNull();
-      const block = parsed.message.content[0];
-      expect(block).toMatchObject({
-        type: 'tool_result',
-        tool_use_id: 'tool-1',
-        content: 'Tool executed successfully',
-        is_error: false,
-      });
-    });
-
-    it('should mark error tool results', () => {
-      const request = {
-        callId: 'tool-1',
-        name: 'test_tool',
-        args: {},
-        isClientInitiated: false,
-        prompt_id: 'prompt-1',
-      };
-      const response = {
-        callId: 'tool-1',
-        responseParts: [],
-        resultDisplay: undefined,
-        error: new Error('Tool failed'),
-        errorType: undefined,
-      };
-
-      adapter.emitToolResult(request, response);
-
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      const block = parsed.message.content[0];
-      expect(block.is_error).toBe(true);
-    });
-  });
-
-  describe('emitSystemMessage', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-    });
-
-    it('should emit system message immediately', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.emitSystemMessage('test_subtype', { data: 'value' });
-
-      expect(stdoutWriteSpy).toHaveBeenCalled();
-      const output = stdoutWriteSpy.mock.calls[0][0] as string;
-      const parsed = JSON.parse(output);
-
-      expect(parsed.type).toBe('system');
-      expect(parsed.subtype).toBe('test_subtype');
-      expect(parsed.data).toEqual({ data: 'value' });
-    });
-  });
-
-  describe('getSessionId and getModel', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-    });
-
-    it('should return session ID from config', () => {
-      expect(adapter.getSessionId()).toBe('test-session-id');
-      expect(mockConfig.getSessionId).toHaveBeenCalled();
-    });
-
-    it('should return model from config', () => {
-      expect(adapter.getModel()).toBe('test-model');
-      expect(mockConfig.getModel).toHaveBeenCalled();
-    });
-  });
-
-  describe('message_id in stream events', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, true);
-      adapter.startAssistantMessage();
-    });
-
-    it('should include message_id in stream events after message starts', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text',
-      });
-      // Process another event to ensure messageStarted is true
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'More',
-      });
-
-      const calls = stdoutWriteSpy.mock.calls;
-      // Find all delta events
-      const deltaCalls = calls.filter((call: unknown[]) => {
-        try {
-          const parsed = JSON.parse(call[0] as string);
-          return (
-            parsed.type === 'stream_event' &&
-            parsed.event.type === 'content_block_delta'
-          );
-        } catch {
-          return false;
-        }
-      });
-
-      expect(deltaCalls.length).toBeGreaterThan(0);
-      // The second delta event should have message_id (after messageStarted becomes true)
-      // message_id is added to the event object, so check parsed.event.message_id
-      if (deltaCalls.length > 1) {
-        const secondDelta = JSON.parse(
-          (deltaCalls[1] as unknown[])[0] as string,
-        );
-        // message_id is on the enriched event object
-        expect(
-          secondDelta.event.message_id || secondDelta.message_id,
-        ).toBeTruthy();
-      } else {
-        // If only one delta, check if message_id exists
-        const delta = JSON.parse((deltaCalls[0] as unknown[])[0] as string);
-        // message_id is added when messageStarted is true
-        // First event may or may not have it, but subsequent ones should
-        expect(delta.event.message_id || delta.message_id).toBeTruthy();
-      }
-    });
-  });
-
-  describe('multiple text blocks', () => {
-    beforeEach(() => {
-      adapter = new StreamJsonOutputAdapter(mockConfig, false);
-      adapter.startAssistantMessage();
-    });
-
-    it('should split assistant messages when block types change repeatedly', () => {
-      stdoutWriteSpy.mockClear();
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Text content',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Thought,
-        value: { subject: 'Thinking', description: 'Thought' },
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'More text',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: 'More text',
-      });
-
-      const assistantMessages = stdoutWriteSpy.mock.calls
-        .map((call: unknown[]) => JSON.parse(call[0] as string))
-        .filter(
-          (
-            payload: unknown,
-          ): payload is {
-            type: string;
-            message: { content: Array<{ type: string; text?: string }> };
-          } => {
-            if (
-              typeof payload !== 'object' ||
-              payload === null ||
-              !('type' in payload) ||
-              (payload as { type?: string }).type !== 'assistant' ||
-              !('message' in payload)
-            ) {
-              return false;
-            }
-            const message = (payload as { message?: unknown }).message;
-            if (
-              typeof message !== 'object' ||
-              message === null ||
-              !('content' in message)
-            ) {
-              return false;
-            }
-            const content = (message as { content?: unknown }).content;
-            return (
-              Array.isArray(content) &&
-              content.length > 0 &&
-              content.every(
-                (block: unknown) =>
-                  typeof block === 'object' &&
-                  block !== null &&
-                  'type' in block,
-              )
-            );
-          },
-        );
-
-      expect(assistantMessages).toHaveLength(3);
-      const observedTypes = assistantMessages.map(
-        (msg: {
-          type: string;
-          message: { content: Array<{ type: string; text?: string }> };
-        }) => msg.message.content[0]?.type ?? '',
-      );
-      expect(observedTypes).toEqual(['text', 'thinking', 'text']);
-      for (const msg of assistantMessages) {
-        const uniqueTypes = new Set(
-          msg.message.content.map((block: { type: string }) => block.type),
-        );
-        expect(uniqueTypes.size).toBeLessThanOrEqual(1);
-      }
-    });
-
-    it('should merge consecutive text fragments', () => {
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'Hello',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: ' ',
-      });
-      adapter.processEvent({
-        type: GeminiEventType.Content,
-        value: 'World',
-      });
-
-      const message = adapter.finalizeAssistantMessage();
-      expect(message.message.content).toHaveLength(1);
-      expect(message.message.content[0]).toMatchObject({
-        type: 'text',
-        text: 'Hello World',
-      });
-    });
-  });
-});
--- a/packages/cli/src/nonInteractive/io/StreamJsonOutputAdapter.ts
+++ b/packages/cli/src/nonInteractive/io/StreamJsonOutputAdapter.ts
@@ -1,300 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { randomUUID } from 'node:crypto';
-import type { Config } from '@qwen-code/qwen-code-core';
-import type {
-  CLIAssistantMessage,
-  CLIMessage,
-  CLIPartialAssistantMessage,
-  ControlMessage,
-  StreamEvent,
-  TextBlock,
-  ThinkingBlock,
-  ToolUseBlock,
-} from '../types.js';
-import {
-  BaseJsonOutputAdapter,
-  type MessageState,
-  type ResultOptions,
-  type JsonOutputAdapterInterface,
-} from './BaseJsonOutputAdapter.js';
-
-/**
- * Stream JSON output adapter that emits messages immediately
- * as they are completed during the streaming process.
- * Supports both main agent and subagent messages through distinct APIs.
- */
-export class StreamJsonOutputAdapter
-  extends BaseJsonOutputAdapter
-  implements JsonOutputAdapterInterface
-{
-  constructor(
-    config: Config,
-    private readonly includePartialMessages: boolean,
-  ) {
-    super(config);
-  }
-
-  /**
-   * Emits message immediately to stdout (stream mode).
-   */
-  protected emitMessageImpl(message: CLIMessage | ControlMessage): void {
-    // Track assistant messages for result generation
-    if (
-      typeof message === 'object' &&
-      message !== null &&
-      'type' in message &&
-      message.type === 'assistant'
-    ) {
-      this.updateLastAssistantMessage(message as CLIAssistantMessage);
-    }
-
-    // Emit messages immediately in stream mode
-    process.stdout.write(`${JSON.stringify(message)}\n`);
-  }
-
-  /**
-   * Stream mode emits stream events when includePartialMessages is enabled.
-   */
-  protected shouldEmitStreamEvents(): boolean {
-    return this.includePartialMessages;
-  }
-
-  finalizeAssistantMessage(): CLIAssistantMessage {
-    const state = this.mainAgentMessageState;
-    if (state.finalized) {
-      return this.buildMessage(null);
-    }
-    state.finalized = true;
-
-    this.finalizePendingBlocks(state, null);
-    const orderedOpenBlocks = Array.from(state.openBlocks).sort(
-      (a, b) => a - b,
-    );
-    for (const index of orderedOpenBlocks) {
-      this.onBlockClosed(state, index, null);
-      this.closeBlock(state, index);
-    }
-
-    if (state.messageStarted && this.includePartialMessages) {
-      this.emitStreamEventIfEnabled({ type: 'message_stop' }, null);
-    }
-
-    const message = this.buildMessage(null);
-    this.updateLastAssistantMessage(message);
-    this.emitMessageImpl(message);
-    return message;
-  }
-
-  emitResult(options: ResultOptions): void {
-    const resultMessage = this.buildResultMessage(
-      options,
-      this.lastAssistantMessage,
-    );
-    this.emitMessageImpl(resultMessage);
-  }
-
-  emitMessage(message: CLIMessage | ControlMessage): void {
-    // In stream mode, emit immediately
-    this.emitMessageImpl(message);
-  }
-
-  send(message: CLIMessage | ControlMessage): void {
-    this.emitMessage(message);
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when text block is created.
-   */
-  protected override onTextBlockCreated(
-    state: MessageState,
-    index: number,
-    block: TextBlock,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_start',
-        index,
-        content_block: block,
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when text is appended.
-   */
-  protected override onTextAppended(
-    state: MessageState,
-    index: number,
-    fragment: string,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_delta',
-        index,
-        delta: { type: 'text_delta', text: fragment },
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when thinking block is created.
-   */
-  protected override onThinkingBlockCreated(
-    state: MessageState,
-    index: number,
-    block: ThinkingBlock,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_start',
-        index,
-        content_block: block,
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when thinking is appended.
-   */
-  protected override onThinkingAppended(
-    state: MessageState,
-    index: number,
-    fragment: string,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_delta',
-        index,
-        delta: { type: 'thinking_delta', thinking: fragment },
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when tool_use block is created.
-   */
-  protected override onToolUseBlockCreated(
-    state: MessageState,
-    index: number,
-    block: ToolUseBlock,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_start',
-        index,
-        content_block: block,
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when tool_use input is set.
-   */
-  protected override onToolUseInputSet(
-    state: MessageState,
-    index: number,
-    input: unknown,
-    parentToolUseId: string | null,
-  ): void {
-    this.emitStreamEventIfEnabled(
-      {
-        type: 'content_block_delta',
-        index,
-        delta: {
-          type: 'input_json_delta',
-          partial_json: JSON.stringify(input),
-        },
-      },
-      parentToolUseId,
-    );
-  }
-
-  /**
-   * Overrides base class hook to emit stream event when block is closed.
-   */
-  protected override onBlockClosed(
-    state: MessageState,
-    index: number,
-    parentToolUseId: string | null,
-  ): void {
-    if (this.includePartialMessages) {
-      this.emitStreamEventIfEnabled(
-        {
-          type: 'content_block_stop',
-          index,
-        },
-        parentToolUseId,
-      );
-    }
-  }
-
-  /**
-   * Overrides base class hook to emit message_start event when message is started.
-   * Only emits for main agent, not for subagents.
-   */
-  protected override onEnsureMessageStarted(
-    state: MessageState,
-    parentToolUseId: string | null,
-  ): void {
-    // Only emit message_start for main agent, not for subagents
-    if (parentToolUseId === null) {
-      this.emitStreamEventIfEnabled(
-        {
-          type: 'message_start',
-          message: {
-            id: state.messageId!,
-            role: 'assistant',
-            model: this.config.getModel(),
-          },
-        },
-        null,
-      );
-    }
-  }
-
-  /**
-   * Emits stream events when partial messages are enabled.
-   * This is a private method specific to StreamJsonOutputAdapter.
-   * @param event - Stream event to emit
-   * @param parentToolUseId - null for main agent, string for subagent
-   */
-  private emitStreamEventIfEnabled(
-    event: StreamEvent,
-    parentToolUseId: string | null,
-  ): void {
-    if (!this.includePartialMessages) {
-      return;
-    }
-
-    const state = this.getMessageState(parentToolUseId);
-    const enrichedEvent = state.messageStarted
-      ? ({ ...event, message_id: state.messageId } as StreamEvent & {
-          message_id: string;
-        })
-      : event;
-
-    const partial: CLIPartialAssistantMessage = {
-      type: 'stream_event',
-      uuid: randomUUID(),
-      session_id: this.getSessionId(),
-      parent_tool_use_id: parentToolUseId,
-      event: enrichedEvent,
-    };
-    this.emitMessageImpl(partial);
-  }
-}
--- a/packages/cli/src/nonInteractive/session.test.ts
+++ b/packages/cli/src/nonInteractive/session.test.ts
@@ -1,602 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Config } from '@qwen-code/qwen-code-core';
-import { runNonInteractiveStreamJson } from './session.js';
-import type {
-  CLIUserMessage,
-  CLIControlRequest,
-  CLIControlResponse,
-  ControlCancelRequest,
-} from './types.js';
-import { StreamJsonInputReader } from './io/StreamJsonInputReader.js';
-import { StreamJsonOutputAdapter } from './io/StreamJsonOutputAdapter.js';
-import { ControlDispatcher } from './control/ControlDispatcher.js';
-import { ControlContext } from './control/ControlContext.js';
-import { ControlService } from './control/ControlService.js';
-import { ConsolePatcher } from '../ui/utils/ConsolePatcher.js';
-
-const runNonInteractiveMock = vi.fn();
-
-// Mock dependencies
-vi.mock('../nonInteractiveCli.js', () => ({
-  runNonInteractive: (...args: unknown[]) => runNonInteractiveMock(...args),
-}));
-
-vi.mock('./io/StreamJsonInputReader.js', () => ({
-  StreamJsonInputReader: vi.fn(),
-}));
-
-vi.mock('./io/StreamJsonOutputAdapter.js', () => ({
-  StreamJsonOutputAdapter: vi.fn(),
-}));
-
-vi.mock('./control/ControlDispatcher.js', () => ({
-  ControlDispatcher: vi.fn(),
-}));
-
-vi.mock('./control/ControlContext.js', () => ({
-  ControlContext: vi.fn(),
-}));
-
-vi.mock('./control/ControlService.js', () => ({
-  ControlService: vi.fn(),
-}));
-
-vi.mock('../ui/utils/ConsolePatcher.js', () => ({
-  ConsolePatcher: vi.fn(),
-}));
-
-interface ConfigOverrides {
-  getSessionId?: () => string;
-  getModel?: () => string;
-  getIncludePartialMessages?: () => boolean;
-  getDebugMode?: () => boolean;
-  getApprovalMode?: () => string;
-  getOutputFormat?: () => string;
-  [key: string]: unknown;
-}
-
-function createConfig(overrides: ConfigOverrides = {}): Config {
-  const base = {
-    getSessionId: () => 'test-session',
-    getModel: () => 'test-model',
-    getIncludePartialMessages: () => false,
-    getDebugMode: () => false,
-    getApprovalMode: () => 'auto',
-    getOutputFormat: () => 'stream-json',
-    initialize: vi.fn(),
-  };
-  return { ...base, ...overrides } as unknown as Config;
-}
-
-function createUserMessage(content: string): CLIUserMessage {
-  return {
-    type: 'user',
-    session_id: 'test-session',
-    message: {
-      role: 'user',
-      content,
-    },
-    parent_tool_use_id: null,
-  };
-}
-
-function createControlRequest(
-  subtype: 'initialize' | 'set_model' | 'interrupt' = 'initialize',
-): CLIControlRequest {
-  if (subtype === 'set_model') {
-    return {
-      type: 'control_request',
-      request_id: 'req-1',
-      request: {
-        subtype: 'set_model',
-        model: 'test-model',
-      },
-    };
-  }
-  if (subtype === 'interrupt') {
-    return {
-      type: 'control_request',
-      request_id: 'req-1',
-      request: {
-        subtype: 'interrupt',
-      },
-    };
-  }
-  return {
-    type: 'control_request',
-    request_id: 'req-1',
-    request: {
-      subtype: 'initialize',
-    },
-  };
-}
-
-function createControlResponse(requestId: string): CLIControlResponse {
-  return {
-    type: 'control_response',
-    response: {
-      subtype: 'success',
-      request_id: requestId,
-      response: {},
-    },
-  };
-}
-
-function createControlCancel(requestId: string): ControlCancelRequest {
-  return {
-    type: 'control_cancel_request',
-    request_id: requestId,
-  };
-}
-
-describe('runNonInteractiveStreamJson', () => {
-  let config: Config;
-  let mockInputReader: {
-    read: () => AsyncGenerator<
-      | CLIUserMessage
-      | CLIControlRequest
-      | CLIControlResponse
-      | ControlCancelRequest
-    >;
-  };
-  let mockOutputAdapter: {
-    emitResult: ReturnType<typeof vi.fn>;
-  };
-  let mockDispatcher: {
-    dispatch: ReturnType<typeof vi.fn>;
-    handleControlResponse: ReturnType<typeof vi.fn>;
-    handleCancel: ReturnType<typeof vi.fn>;
-    shutdown: ReturnType<typeof vi.fn>;
-    getPendingIncomingRequestCount: ReturnType<typeof vi.fn>;
-    waitForPendingIncomingRequests: ReturnType<typeof vi.fn>;
-    sdkMcpController: {
-      createSendSdkMcpMessage: ReturnType<typeof vi.fn>;
-    };
-  };
-  let mockConsolePatcher: {
-    patch: ReturnType<typeof vi.fn>;
-    cleanup: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    config = createConfig();
-    runNonInteractiveMock.mockReset();
-
-    // Setup mocks
-    mockConsolePatcher = {
-      patch: vi.fn(),
-      cleanup: vi.fn(),
-    };
-    (ConsolePatcher as unknown as ReturnType<typeof vi.fn>).mockImplementation(
-      () => mockConsolePatcher,
-    );
-
-    mockOutputAdapter = {
-      emitResult: vi.fn(),
-    } as {
-      emitResult: ReturnType<typeof vi.fn>;
-      [key: string]: unknown;
-    };
-    (
-      StreamJsonOutputAdapter as unknown as ReturnType<typeof vi.fn>
-    ).mockImplementation(() => mockOutputAdapter);
-
-    mockDispatcher = {
-      dispatch: vi.fn().mockResolvedValue(undefined),
-      handleControlResponse: vi.fn(),
-      handleCancel: vi.fn(),
-      shutdown: vi.fn(),
-      getPendingIncomingRequestCount: vi.fn().mockReturnValue(0),
-      waitForPendingIncomingRequests: vi.fn().mockResolvedValue(undefined),
-      sdkMcpController: {
-        createSendSdkMcpMessage: vi.fn().mockReturnValue(vi.fn()),
-      },
-    };
-    (
-      ControlDispatcher as unknown as ReturnType<typeof vi.fn>
-    ).mockImplementation(() => mockDispatcher);
-    (ControlContext as unknown as ReturnType<typeof vi.fn>).mockImplementation(
-      () => ({}),
-    );
-    (ControlService as unknown as ReturnType<typeof vi.fn>).mockImplementation(
-      () => ({}),
-    );
-
-    mockInputReader = {
-      async *read() {
-        // Default: empty stream
-        // Override in tests as needed
-      },
-    };
-    (
-      StreamJsonInputReader as unknown as ReturnType<typeof vi.fn>
-    ).mockImplementation(() => mockInputReader);
-
-    runNonInteractiveMock.mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('initializes session and processes initialize control request', async () => {
-    const initRequest = createControlRequest('initialize');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockConsolePatcher.patch).toHaveBeenCalledTimes(1);
-    expect(mockDispatcher.dispatch).toHaveBeenCalledWith(initRequest);
-    expect(mockConsolePatcher.cleanup).toHaveBeenCalledTimes(1);
-  });
-
-  it('processes user message when received as first message', async () => {
-    const userMessage = createUserMessage('Hello world');
-
-    mockInputReader.read = async function* () {
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(1);
-    const runCall = runNonInteractiveMock.mock.calls[0];
-    expect(runCall[2]).toBe('Hello world'); // Direct text, not processed
-    expect(typeof runCall[3]).toBe('string'); // promptId
-    expect(runCall[4]).toEqual(
-      expect.objectContaining({
-        abortController: expect.any(AbortController),
-        adapter: mockOutputAdapter,
-      }),
-    );
-  });
-
-  it('processes multiple user messages sequentially', async () => {
-    // Initialize first to enable multi-query mode
-    const initRequest = createControlRequest('initialize');
-    const userMessage1 = createUserMessage('First message');
-    const userMessage2 = createUserMessage('Second message');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield userMessage1;
-      yield userMessage2;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(2);
-  });
-
-  it('enqueues user messages received during processing', async () => {
-    const initRequest = createControlRequest('initialize');
-    const userMessage1 = createUserMessage('First message');
-    const userMessage2 = createUserMessage('Second message');
-
-    // Make runNonInteractive take some time to simulate processing
-    runNonInteractiveMock.mockImplementation(
-      () => new Promise((resolve) => setTimeout(resolve, 10)),
-    );
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield userMessage1;
-      yield userMessage2;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    // Both messages should be processed
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(2);
-  });
-
-  it('processes control request in idle state', async () => {
-    const initRequest = createControlRequest('initialize');
-    const controlRequest = createControlRequest('set_model');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield controlRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.dispatch).toHaveBeenCalledTimes(2);
-    expect(mockDispatcher.dispatch).toHaveBeenNthCalledWith(1, initRequest);
-    expect(mockDispatcher.dispatch).toHaveBeenNthCalledWith(2, controlRequest);
-  });
-
-  it('handles control response in idle state', async () => {
-    const initRequest = createControlRequest('initialize');
-    const controlResponse = createControlResponse('req-2');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield controlResponse;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.handleControlResponse).toHaveBeenCalledWith(
-      controlResponse,
-    );
-  });
-
-  it('handles control cancel in idle state', async () => {
-    const initRequest = createControlRequest('initialize');
-    const cancelRequest = createControlCancel('req-2');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield cancelRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.handleCancel).toHaveBeenCalledWith('req-2');
-  });
-
-  it('handles control request during processing state', async () => {
-    const initRequest = createControlRequest('initialize');
-    const userMessage = createUserMessage('Process me');
-    const controlRequest = createControlRequest('set_model');
-
-    runNonInteractiveMock.mockImplementation(
-      () => new Promise((resolve) => setTimeout(resolve, 10)),
-    );
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield userMessage;
-      yield controlRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.dispatch).toHaveBeenCalledWith(controlRequest);
-  });
-
-  it('handles control response during processing state', async () => {
-    const initRequest = createControlRequest('initialize');
-    const userMessage = createUserMessage('Process me');
-    const controlResponse = createControlResponse('req-1');
-
-    runNonInteractiveMock.mockImplementation(
-      () => new Promise((resolve) => setTimeout(resolve, 10)),
-    );
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield userMessage;
-      yield controlResponse;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.handleControlResponse).toHaveBeenCalledWith(
-      controlResponse,
-    );
-  });
-
-  it('handles user message with text content', async () => {
-    const userMessage = createUserMessage('Test message');
-
-    mockInputReader.read = async function* () {
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(1);
-    expect(runNonInteractiveMock).toHaveBeenCalledWith(
-      config,
-      expect.objectContaining({ merged: expect.any(Object) }),
-      'Test message',
-      expect.stringContaining('test-session'),
-      expect.objectContaining({
-        abortController: expect.any(AbortController),
-        adapter: mockOutputAdapter,
-      }),
-    );
-  });
-
-  it('handles user message with array content blocks', async () => {
-    const userMessage: CLIUserMessage = {
-      type: 'user',
-      session_id: 'test-session',
-      message: {
-        role: 'user',
-        content: [
-          { type: 'text', text: 'First part' },
-          { type: 'text', text: 'Second part' },
-        ],
-      },
-      parent_tool_use_id: null,
-    };
-
-    mockInputReader.read = async function* () {
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(1);
-    expect(runNonInteractiveMock).toHaveBeenCalledWith(
-      config,
-      expect.objectContaining({ merged: expect.any(Object) }),
-      'First part\nSecond part',
-      expect.stringContaining('test-session'),
-      expect.objectContaining({
-        abortController: expect.any(AbortController),
-        adapter: mockOutputAdapter,
-      }),
-    );
-  });
-
-  it('skips user message with no text content', async () => {
-    const userMessage: CLIUserMessage = {
-      type: 'user',
-      session_id: 'test-session',
-      message: {
-        role: 'user',
-        content: [],
-      },
-      parent_tool_use_id: null,
-    };
-
-    mockInputReader.read = async function* () {
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).not.toHaveBeenCalled();
-  });
-
-  it('handles error from processUserMessage', async () => {
-    const userMessage = createUserMessage('Test message');
-
-    const error = new Error('Processing error');
-    runNonInteractiveMock.mockRejectedValue(error);
-
-    mockInputReader.read = async function* () {
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    // Error should be caught and handled gracefully
-  });
-
-  it('handles stream error gracefully', async () => {
-    const streamError = new Error('Stream error');
-    // eslint-disable-next-line require-yield
-    mockInputReader.read = async function* () {
-      throw streamError;
-    } as typeof mockInputReader.read;
-
-    await expect(runNonInteractiveStreamJson(config, '')).rejects.toThrow(
-      'Stream error',
-    );
-
-    expect(mockConsolePatcher.cleanup).toHaveBeenCalled();
-  });
-
-  it('stops processing when abort signal is triggered', async () => {
-    const initRequest = createControlRequest('initialize');
-    const userMessage = createUserMessage('Test message');
-
-    // Capture abort signal from ControlContext
-    let abortSignal: AbortSignal | null = null;
-    (ControlContext as unknown as ReturnType<typeof vi.fn>).mockImplementation(
-      (options: { abortSignal?: AbortSignal }) => {
-        abortSignal = options.abortSignal ?? null;
-        return {};
-      },
-    );
-
-    // Create input reader that aborts after first message
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      // Abort the signal after initialization
-      if (abortSignal && !abortSignal.aborted) {
-        // The signal doesn't have an abort method, but the controller does
-        // Since we can't access the controller directly, we'll test by
-        // verifying that cleanup happens properly
-      }
-      // Yield second message - if abort works, it should be checked
-      yield userMessage;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    // Verify initialization happened
-    expect(mockDispatcher.dispatch).toHaveBeenCalledWith(initRequest);
-    expect(mockDispatcher.shutdown).toHaveBeenCalled();
-  });
-
-  it('generates unique prompt IDs for each message', async () => {
-    // Initialize first to enable multi-query mode
-    const initRequest = createControlRequest('initialize');
-    const userMessage1 = createUserMessage('First');
-    const userMessage2 = createUserMessage('Second');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-      yield userMessage1;
-      yield userMessage2;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(runNonInteractiveMock).toHaveBeenCalledTimes(2);
-    const promptId1 = runNonInteractiveMock.mock.calls[0][3] as string;
-    const promptId2 = runNonInteractiveMock.mock.calls[1][3] as string;
-    expect(promptId1).not.toBe(promptId2);
-    expect(promptId1).toContain('test-session');
-    expect(promptId2).toContain('test-session');
-  });
-
-  it('ignores non-initialize control request during initialization', async () => {
-    const controlRequest = createControlRequest('set_model');
-
-    mockInputReader.read = async function* () {
-      yield controlRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    // Should not transition to idle since it's not an initialize request
-    expect(mockDispatcher.dispatch).not.toHaveBeenCalled();
-  });
-
-  it('cleans up console patcher on completion', async () => {
-    mockInputReader.read = async function* () {
-      // Empty stream - should complete immediately
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockConsolePatcher.patch).toHaveBeenCalledTimes(1);
-    expect(mockConsolePatcher.cleanup).toHaveBeenCalledTimes(1);
-  });
-
-  it('cleans up output adapter on completion', async () => {
-    mockInputReader.read = async function* () {
-      // Empty stream
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-  });
-
-  it('calls dispatcher shutdown on completion', async () => {
-    const initRequest = createControlRequest('initialize');
-
-    mockInputReader.read = async function* () {
-      yield initRequest;
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockDispatcher.shutdown).toHaveBeenCalledTimes(1);
-  });
-
-  it('handles empty stream gracefully', async () => {
-    mockInputReader.read = async function* () {
-      // Empty stream
-    };
-
-    await runNonInteractiveStreamJson(config, '');
-
-    expect(mockConsolePatcher.cleanup).toHaveBeenCalled();
-  });
-});
--- a/packages/cli/src/nonInteractive/session.ts
+++ b/packages/cli/src/nonInteractive/session.ts
@@ -1,668 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  Config,
-  ConfigInitializeOptions,
-} from '@qwen-code/qwen-code-core';
-import { StreamJsonInputReader } from './io/StreamJsonInputReader.js';
-import { StreamJsonOutputAdapter } from './io/StreamJsonOutputAdapter.js';
-import { ControlContext } from './control/ControlContext.js';
-import { ControlDispatcher } from './control/ControlDispatcher.js';
-import { ControlService } from './control/ControlService.js';
-import type {
-  CLIMessage,
-  CLIUserMessage,
-  CLIControlRequest,
-  CLIControlResponse,
-  ControlCancelRequest,
-} from './types.js';
-import {
-  isCLIUserMessage,
-  isCLIAssistantMessage,
-  isCLISystemMessage,
-  isCLIResultMessage,
-  isCLIPartialAssistantMessage,
-  isControlRequest,
-  isControlResponse,
-  isControlCancel,
-} from './types.js';
-import { createMinimalSettings } from '../config/settings.js';
-import { runNonInteractive } from '../nonInteractiveCli.js';
-import { ConsolePatcher } from '../ui/utils/ConsolePatcher.js';
-
-class Session {
-  private userMessageQueue: CLIUserMessage[] = [];
-  private abortController: AbortController;
-  private config: Config;
-  private sessionId: string;
-  private promptIdCounter: number = 0;
-  private inputReader: StreamJsonInputReader;
-  private outputAdapter: StreamJsonOutputAdapter;
-  private controlContext: ControlContext | null = null;
-  private dispatcher: ControlDispatcher | null = null;
-  private controlService: ControlService | null = null;
-  private controlSystemEnabled: boolean | null = null;
-  private debugMode: boolean;
-  private shutdownHandler: (() => void) | null = null;
-  private initialPrompt: CLIUserMessage | null = null;
-  private processingPromise: Promise<void> | null = null;
-  private isShuttingDown: boolean = false;
-  private configInitialized: boolean = false;
-
-  // Single initialization promise that resolves when session is ready for user messages.
-  // Created lazily once initialization actually starts.
-  private initializationPromise: Promise<void> | null = null;
-  private initializationResolve: (() => void) | null = null;
-  private initializationReject: ((error: Error) => void) | null = null;
-
-  constructor(config: Config, initialPrompt?: CLIUserMessage) {
-    this.config = config;
-    this.sessionId = config.getSessionId();
-    this.debugMode = config.getDebugMode();
-    this.abortController = new AbortController();
-    this.initialPrompt = initialPrompt ?? null;
-
-    this.inputReader = new StreamJsonInputReader();
-    this.outputAdapter = new StreamJsonOutputAdapter(
-      config,
-      config.getIncludePartialMessages(),
-    );
-
-    this.setupSignalHandlers();
-  }
-
-  private ensureInitializationPromise(): void {
-    if (this.initializationPromise) {
-      return;
-    }
-    this.initializationPromise = new Promise<void>((resolve, reject) => {
-      this.initializationResolve = () => {
-        resolve();
-        this.initializationResolve = null;
-        this.initializationReject = null;
-      };
-      this.initializationReject = (error: Error) => {
-        reject(error);
-        this.initializationResolve = null;
-        this.initializationReject = null;
-      };
-    });
-  }
-
-  private getNextPromptId(): string {
-    this.promptIdCounter++;
-    return `${this.sessionId}########${this.promptIdCounter}`;
-  }
-
-  private async ensureConfigInitialized(
-    options?: ConfigInitializeOptions,
-  ): Promise<void> {
-    if (this.configInitialized) {
-      return;
-    }
-
-    if (this.debugMode) {
-      console.error('[Session] Initializing config');
-    }
-
-    try {
-      await this.config.initialize(options);
-      this.configInitialized = true;
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] Failed to initialize config:', error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Mark initialization as complete
-   */
-  private completeInitialization(): void {
-    if (this.initializationResolve) {
-      if (this.debugMode) {
-        console.error('[Session] Initialization complete');
-      }
-      this.initializationResolve();
-      this.initializationResolve = null;
-      this.initializationReject = null;
-    }
-  }
-
-  /**
-   * Mark initialization as failed
-   */
-  private failInitialization(error: Error): void {
-    if (this.initializationReject) {
-      if (this.debugMode) {
-        console.error('[Session] Initialization failed:', error);
-      }
-      this.initializationReject(error);
-      this.initializationResolve = null;
-      this.initializationReject = null;
-    }
-  }
-
-  /**
-   * Wait for session to be ready for user messages
-   */
-  private async waitForInitialization(): Promise<void> {
-    if (!this.initializationPromise) {
-      return;
-    }
-    await this.initializationPromise;
-  }
-
-  private ensureControlSystem(): void {
-    if (this.controlContext && this.dispatcher && this.controlService) {
-      return;
-    }
-    this.controlContext = new ControlContext({
-      config: this.config,
-      streamJson: this.outputAdapter,
-      sessionId: this.sessionId,
-      abortSignal: this.abortController.signal,
-      permissionMode: this.config.getApprovalMode(),
-      onInterrupt: () => this.handleInterrupt(),
-    });
-    this.dispatcher = new ControlDispatcher(this.controlContext);
-    this.controlService = new ControlService(
-      this.controlContext,
-      this.dispatcher,
-    );
-  }
-
-  private getDispatcher(): ControlDispatcher | null {
-    if (this.controlSystemEnabled !== true) {
-      return null;
-    }
-    if (!this.dispatcher) {
-      this.ensureControlSystem();
-    }
-    return this.dispatcher;
-  }
-
-  /**
-   * Handle the first message to determine session mode (SDK vs direct).
-   * This is synchronous from the message loop's perspective - it starts
-   * async work but does not return a promise that the loop awaits.
-   *
-   * The initialization completes asynchronously and resolves initializationPromise
-   * when ready for user messages.
-   */
-  private handleFirstMessage(
-    message:
-      | CLIMessage
-      | CLIControlRequest
-      | CLIControlResponse
-      | ControlCancelRequest,
-  ): void {
-    if (isControlRequest(message)) {
-      const request = message as CLIControlRequest;
-      this.controlSystemEnabled = true;
-      this.ensureControlSystem();
-
-      if (request.request.subtype === 'initialize') {
-        // Start SDK mode initialization (fire-and-forget from loop perspective)
-        void this.initializeSdkMode(request);
-        return;
-      }
-
-      if (this.debugMode) {
-        console.error(
-          '[Session] Ignoring non-initialize control request during initialization',
-        );
-      }
-      return;
-    }
-
-    if (isCLIUserMessage(message)) {
-      this.controlSystemEnabled = false;
-      // Start direct mode initialization (fire-and-forget from loop perspective)
-      void this.initializeDirectMode(message as CLIUserMessage);
-      return;
-    }
-
-    this.controlSystemEnabled = false;
-  }
-
-  /**
-   * SDK mode initialization flow
-   * Dispatches initialize request and initializes config with MCP support
-   */
-  private async initializeSdkMode(request: CLIControlRequest): Promise<void> {
-    this.ensureInitializationPromise();
-    try {
-      // Dispatch the initialize request first
-      // This registers SDK MCP servers in the control context
-      await this.dispatcher?.dispatch(request);
-
-      // Get sendSdkMcpMessage callback from SdkMcpController
-      // This callback is used by McpClientManager to send MCP messages
-      // from CLI MCP clients to SDK MCP servers via the control plane
-      const sendSdkMcpMessage =
-        this.dispatcher?.sdkMcpController.createSendSdkMcpMessage();
-
-      // Initialize config with SDK MCP message support
-      await this.ensureConfigInitialized({ sendSdkMcpMessage });
-
-      // Initialization complete!
-      this.completeInitialization();
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] SDK mode initialization failed:', error);
-      }
-      this.failInitialization(
-        error instanceof Error ? error : new Error(String(error)),
-      );
-    }
-  }
-
-  /**
-   * Direct mode initialization flow
-   * Initializes config and enqueues the first user message
-   */
-  private async initializeDirectMode(
-    userMessage: CLIUserMessage,
-  ): Promise<void> {
-    this.ensureInitializationPromise();
-    try {
-      // Initialize config
-      await this.ensureConfigInitialized();
-
-      // Initialization complete!
-      this.completeInitialization();
-
-      // Enqueue the first user message for processing
-      this.enqueueUserMessage(userMessage);
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] Direct mode initialization failed:', error);
-      }
-      this.failInitialization(
-        error instanceof Error ? error : new Error(String(error)),
-      );
-    }
-  }
-
-  /**
-   * Handle control request asynchronously (fire-and-forget from main loop).
-   * Errors are handled internally and responses sent by dispatcher.
-   */
-  private handleControlRequestAsync(request: CLIControlRequest): void {
-    const dispatcher = this.getDispatcher();
-    if (!dispatcher) {
-      if (this.debugMode) {
-        console.error('[Session] Control system not enabled');
-      }
-      return;
-    }
-
-    // Fire-and-forget: dispatch runs concurrently
-    // The dispatcher's pendingIncomingRequests tracks completion
-    void dispatcher.dispatch(request).catch((error) => {
-      if (this.debugMode) {
-        console.error('[Session] Control request dispatch error:', error);
-      }
-      // Error response is already sent by dispatcher.dispatch()
-    });
-  }
-
-  /**
-   * Handle control response - MUST be synchronous
-   * This resolves pending outgoing requests, breaking the deadlock cycle.
-   */
-  private handleControlResponse(response: CLIControlResponse): void {
-    const dispatcher = this.getDispatcher();
-    if (!dispatcher) {
-      return;
-    }
-
-    dispatcher.handleControlResponse(response);
-  }
-
-  private handleControlCancel(cancelRequest: ControlCancelRequest): void {
-    const dispatcher = this.getDispatcher();
-    if (!dispatcher) {
-      return;
-    }
-
-    dispatcher.handleCancel(cancelRequest.request_id);
-  }
-
-  private async processUserMessage(userMessage: CLIUserMessage): Promise<void> {
-    const input = extractUserMessageText(userMessage);
-    if (!input) {
-      if (this.debugMode) {
-        console.error('[Session] No text content in user message');
-      }
-      return;
-    }
-
-    // Wait for initialization to complete before processing user messages
-    await this.waitForInitialization();
-
-    const promptId = this.getNextPromptId();
-
-    try {
-      await runNonInteractive(
-        this.config,
-        createMinimalSettings(),
-        input,
-        promptId,
-        {
-          abortController: this.abortController,
-          adapter: this.outputAdapter,
-          controlService: this.controlService ?? undefined,
-        },
-      );
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] Query execution error:', error);
-      }
-    }
-  }
-
-  private async processUserMessageQueue(): Promise<void> {
-    if (this.isShuttingDown || this.abortController.signal.aborted) {
-      return;
-    }
-
-    while (
-      this.userMessageQueue.length > 0 &&
-      !this.isShuttingDown &&
-      !this.abortController.signal.aborted
-    ) {
-      const userMessage = this.userMessageQueue.shift()!;
-      try {
-        await this.processUserMessage(userMessage);
-      } catch (error) {
-        if (this.debugMode) {
-          console.error('[Session] Error processing user message:', error);
-        }
-        this.emitErrorResult(error);
-      }
-    }
-  }
-
-  private enqueueUserMessage(userMessage: CLIUserMessage): void {
-    this.userMessageQueue.push(userMessage);
-    this.ensureProcessingStarted();
-  }
-
-  private ensureProcessingStarted(): void {
-    if (this.processingPromise) {
-      return;
-    }
-
-    this.processingPromise = this.processUserMessageQueue().finally(() => {
-      this.processingPromise = null;
-      if (
-        this.userMessageQueue.length > 0 &&
-        !this.isShuttingDown &&
-        !this.abortController.signal.aborted
-      ) {
-        this.ensureProcessingStarted();
-      }
-    });
-  }
-
-  private emitErrorResult(
-    error: unknown,
-    numTurns: number = 0,
-    durationMs: number = 0,
-    apiDurationMs: number = 0,
-  ): void {
-    const message = error instanceof Error ? error.message : String(error);
-    this.outputAdapter.emitResult({
-      isError: true,
-      errorMessage: message,
-      durationMs,
-      apiDurationMs,
-      numTurns,
-      usage: undefined,
-    });
-  }
-
-  private handleInterrupt(): void {
-    if (this.debugMode) {
-      console.error('[Session] Interrupt requested');
-    }
-    this.abortController.abort();
-    this.abortController = new AbortController();
-  }
-
-  private setupSignalHandlers(): void {
-    this.shutdownHandler = () => {
-      if (this.debugMode) {
-        console.error('[Session] Shutdown signal received');
-      }
-      this.isShuttingDown = true;
-      this.abortController.abort();
-    };
-
-    process.on('SIGINT', this.shutdownHandler);
-    process.on('SIGTERM', this.shutdownHandler);
-  }
-
-  /**
-   * Wait for all pending work to complete before shutdown
-   */
-  private async waitForAllPendingWork(): Promise<void> {
-    // 1. Wait for initialization to complete (or fail)
-    try {
-      await this.waitForInitialization();
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] Initialization error during shutdown:', error);
-      }
-    }
-
-    // 2. Wait for all control request handlers using dispatcher's tracking
-    if (this.dispatcher) {
-      const pendingCount = this.dispatcher.getPendingIncomingRequestCount();
-      if (pendingCount > 0 && this.debugMode) {
-        console.error(
-          `[Session] Waiting for ${pendingCount} pending control request handlers`,
-        );
-      }
-      await this.dispatcher.waitForPendingIncomingRequests();
-    }
-
-    // 3. Wait for user message processing queue
-    while (this.processingPromise) {
-      if (this.debugMode) {
-        console.error('[Session] Waiting for user message processing');
-      }
-      try {
-        await this.processingPromise;
-      } catch (error) {
-        if (this.debugMode) {
-          console.error('[Session] Error in user message processing:', error);
-        }
-      }
-    }
-  }
-
-  private async shutdown(): Promise<void> {
-    if (this.debugMode) {
-      console.error('[Session] Shutting down');
-    }
-
-    this.isShuttingDown = true;
-
-    // Wait for all pending work
-    await this.waitForAllPendingWork();
-
-    this.dispatcher?.shutdown();
-    this.cleanupSignalHandlers();
-  }
-
-  private cleanupSignalHandlers(): void {
-    if (this.shutdownHandler) {
-      process.removeListener('SIGINT', this.shutdownHandler);
-      process.removeListener('SIGTERM', this.shutdownHandler);
-      this.shutdownHandler = null;
-    }
-  }
-
-  /**
-   * Main message processing loop
-   *
-   * CRITICAL: This loop must NEVER await handlers that might need to
-   * send control requests and wait for responses. Such handlers must
-   * be started in fire-and-forget mode, allowing the loop to continue
-   * reading responses that resolve pending requests.
-   *
-   * Message handling order:
-   * 1. control_response - FIRST, synchronously resolves pending requests
-   * 2. First message - determines mode, starts async initialization
-   * 3. control_request - fire-and-forget, tracked by dispatcher
-   * 4. control_cancel - synchronous
-   * 5. user_message - enqueued for processing
-   */
-  async run(): Promise<void> {
-    try {
-      if (this.debugMode) {
-        console.error('[Session] Starting session', this.sessionId);
-      }
-
-      // Handle initial prompt if provided (fire-and-forget)
-      if (this.initialPrompt !== null) {
-        this.handleFirstMessage(this.initialPrompt);
-      }
-
-      try {
-        for await (const message of this.inputReader.read()) {
-          if (this.abortController.signal.aborted) {
-            break;
-          }
-
-          // ============================================================
-          // CRITICAL: Handle control_response FIRST and SYNCHRONOUSLY
-          // This resolves pending outgoing requests, breaking deadlock.
-          // ============================================================
-          if (isControlResponse(message)) {
-            this.handleControlResponse(message as CLIControlResponse);
-            continue;
-          }
-
-          // Handle first message to determine session mode
-          if (this.controlSystemEnabled === null) {
-            this.handleFirstMessage(message);
-            continue;
-          }
-
-          // ============================================================
-          // CRITICAL: Handle control_request in FIRE-AND-FORGET mode
-          // DON'T await - let handler run concurrently while loop continues
-          // Dispatcher's pendingIncomingRequests tracks completion
-          // ============================================================
-          if (isControlRequest(message)) {
-            this.handleControlRequestAsync(message as CLIControlRequest);
-          } else if (isControlCancel(message)) {
-            // Cancel is synchronous - OK to handle inline
-            this.handleControlCancel(message as ControlCancelRequest);
-          } else if (isCLIUserMessage(message)) {
-            // User messages are enqueued, processing runs separately
-            this.enqueueUserMessage(message as CLIUserMessage);
-          } else if (this.debugMode) {
-            if (
-              !isCLIAssistantMessage(message) &&
-              !isCLISystemMessage(message) &&
-              !isCLIResultMessage(message) &&
-              !isCLIPartialAssistantMessage(message)
-            ) {
-              console.error(
-                '[Session] Unknown message type:',
-                JSON.stringify(message, null, 2),
-              );
-            }
-          }
-
-          if (this.isShuttingDown) {
-            break;
-          }
-        }
-      } catch (streamError) {
-        if (this.debugMode) {
-          console.error('[Session] Stream reading error:', streamError);
-        }
-        throw streamError;
-      }
-
-      // Stream ended - wait for all pending work before shutdown
-      await this.waitForAllPendingWork();
-      await this.shutdown();
-    } catch (error) {
-      if (this.debugMode) {
-        console.error('[Session] Error:', error);
-      }
-      await this.shutdown();
-      throw error;
-    } finally {
-      this.cleanupSignalHandlers();
-    }
-  }
-}
-
-function extractUserMessageText(message: CLIUserMessage): string | null {
-  const content = message.message.content;
-  if (typeof content === 'string') {
-    return content;
-  }
-
-  if (Array.isArray(content)) {
-    const parts = content
-      .map((block) => {
-        if (!block || typeof block !== 'object') {
-          return '';
-        }
-        if ('type' in block && block.type === 'text' && 'text' in block) {
-          return typeof block.text === 'string' ? block.text : '';
-        }
-        return JSON.stringify(block);
-      })
-      .filter((part) => part.length > 0);
-
-    return parts.length > 0 ? parts.join('\n') : null;
-  }
-
-  return null;
-}
-
-export async function runNonInteractiveStreamJson(
-  config: Config,
-  input: string,
-): Promise<void> {
-  const consolePatcher = new ConsolePatcher({
-    debugMode: config.getDebugMode(),
-  });
-  consolePatcher.patch();
-
-  try {
-    let initialPrompt: CLIUserMessage | undefined = undefined;
-    if (input && input.trim().length > 0) {
-      const sessionId = config.getSessionId();
-      initialPrompt = {
-        type: 'user',
-        session_id: sessionId,
-        message: {
-          role: 'user',
-          content: input.trim(),
-        },
-        parent_tool_use_id: null,
-      };
-    }
-
-    const manager = new Session(config, initialPrompt);
-    await manager.run();
-  } finally {
-    consolePatcher.cleanup();
-  }
-}
--- a/packages/cli/src/nonInteractive/types.ts
+++ b/packages/cli/src/nonInteractive/types.ts
@@ -1,568 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { SubagentConfig } from '@qwen-code/qwen-code-core';
-
-/**
- * Annotation for attaching metadata to content blocks
- */
-export interface Annotation {
-  type: string;
-  value: string;
-}
-
-/**
- * Usage information types
- */
-export interface Usage {
-  input_tokens: number;
-  output_tokens: number;
-  cache_creation_input_tokens?: number;
-  cache_read_input_tokens?: number;
-  total_tokens?: number;
-}
-
-export interface ExtendedUsage extends Usage {
-  server_tool_use?: {
-    web_search_requests: number;
-  };
-  service_tier?: string;
-  cache_creation?: {
-    ephemeral_1h_input_tokens: number;
-    ephemeral_5m_input_tokens: number;
-  };
-}
-
-export interface ModelUsage {
-  inputTokens: number;
-  outputTokens: number;
-  cacheReadInputTokens: number;
-  cacheCreationInputTokens: number;
-  webSearchRequests: number;
-  contextWindow: number;
-}
-
-/**
- * Permission denial information
- */
-export interface CLIPermissionDenial {
-  tool_name: string;
-  tool_use_id: string;
-  tool_input: unknown;
-}
-
-/**
- * Content block types from Anthropic SDK
- */
-export interface TextBlock {
-  type: 'text';
-  text: string;
-  annotations?: Annotation[];
-}
-
-export interface ThinkingBlock {
-  type: 'thinking';
-  thinking: string;
-  signature?: string;
-  annotations?: Annotation[];
-}
-
-export interface ToolUseBlock {
-  type: 'tool_use';
-  id: string;
-  name: string;
-  input: unknown;
-  annotations?: Annotation[];
-}
-
-export interface ToolResultBlock {
-  type: 'tool_result';
-  tool_use_id: string;
-  content?: string | ContentBlock[];
-  is_error?: boolean;
-  annotations?: Annotation[];
-}
-
-export type ContentBlock =
-  | TextBlock
-  | ThinkingBlock
-  | ToolUseBlock
-  | ToolResultBlock;
-
-/**
- * Anthropic SDK Message types
- */
-export interface APIUserMessage {
-  role: 'user';
-  content: string | ContentBlock[];
-}
-
-export interface APIAssistantMessage {
-  id: string;
-  type: 'message';
-  role: 'assistant';
-  model: string;
-  content: ContentBlock[];
-  stop_reason?: string | null;
-  usage: Usage;
-}
-
-/**
- * CLI Message wrapper types
- */
-export interface CLIUserMessage {
-  type: 'user';
-  uuid?: string;
-  session_id: string;
-  message: APIUserMessage;
-  parent_tool_use_id: string | null;
-  options?: Record<string, unknown>;
-}
-
-export interface CLIAssistantMessage {
-  type: 'assistant';
-  uuid: string;
-  session_id: string;
-  message: APIAssistantMessage;
-  parent_tool_use_id: string | null;
-}
-
-export interface CLISystemMessage {
-  type: 'system';
-  subtype: string;
-  uuid: string;
-  session_id: string;
-  data?: unknown;
-  cwd?: string;
-  tools?: string[];
-  mcp_servers?: Array<{
-    name: string;
-    status: string;
-  }>;
-  model?: string;
-  permission_mode?: string;
-  slash_commands?: string[];
-  qwen_code_version?: string;
-  output_style?: string;
-  agents?: string[];
-  skills?: string[];
-  capabilities?: Record<string, unknown>;
-  compact_metadata?: {
-    trigger: 'manual' | 'auto';
-    pre_tokens: number;
-  };
-}
-
-export interface CLIResultMessageSuccess {
-  type: 'result';
-  subtype: 'success';
-  uuid: string;
-  session_id: string;
-  is_error: false;
-  duration_ms: number;
-  duration_api_ms: number;
-  num_turns: number;
-  result: string;
-  usage: ExtendedUsage;
-  modelUsage?: Record<string, ModelUsage>;
-  permission_denials: CLIPermissionDenial[];
-  [key: string]: unknown;
-}
-
-export interface CLIResultMessageError {
-  type: 'result';
-  subtype: 'error_max_turns' | 'error_during_execution';
-  uuid: string;
-  session_id: string;
-  is_error: true;
-  duration_ms: number;
-  duration_api_ms: number;
-  num_turns: number;
-  usage: ExtendedUsage;
-  modelUsage?: Record<string, ModelUsage>;
-  permission_denials: CLIPermissionDenial[];
-  error?: {
-    type?: string;
-    message: string;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-}
-
-export type CLIResultMessage = CLIResultMessageSuccess | CLIResultMessageError;
-
-/**
- * Stream event types for real-time message updates
- */
-export interface MessageStartStreamEvent {
-  type: 'message_start';
-  message: {
-    id: string;
-    role: 'assistant';
-    model: string;
-  };
-}
-
-export interface ContentBlockStartEvent {
-  type: 'content_block_start';
-  index: number;
-  content_block: ContentBlock;
-}
-
-export type ContentBlockDelta =
-  | {
-      type: 'text_delta';
-      text: string;
-    }
-  | {
-      type: 'thinking_delta';
-      thinking: string;
-    }
-  | {
-      type: 'input_json_delta';
-      partial_json: string;
-    };
-
-export interface ContentBlockDeltaEvent {
-  type: 'content_block_delta';
-  index: number;
-  delta: ContentBlockDelta;
-}
-
-export interface ContentBlockStopEvent {
-  type: 'content_block_stop';
-  index: number;
-}
-
-export interface MessageStopStreamEvent {
-  type: 'message_stop';
-}
-
-export type StreamEvent =
-  | MessageStartStreamEvent
-  | ContentBlockStartEvent
-  | ContentBlockDeltaEvent
-  | ContentBlockStopEvent
-  | MessageStopStreamEvent;
-
-export interface CLIPartialAssistantMessage {
-  type: 'stream_event';
-  uuid: string;
-  session_id: string;
-  event: StreamEvent;
-  parent_tool_use_id: string | null;
-}
-
-export type PermissionMode = 'default' | 'plan' | 'auto-edit' | 'yolo';
-
-/**
- * Permission suggestion for tool use requests
- * TODO: Align with `ToolCallConfirmationDetails`
- */
-export interface PermissionSuggestion {
-  type: 'allow' | 'deny' | 'modify';
-  label: string;
-  description?: string;
-  modifiedInput?: unknown;
-}
-
-/**
- * Hook callback placeholder for future implementation
- */
-export interface HookRegistration {
-  event: string;
-  callback_id: string;
-}
-
-/**
- * Hook callback result placeholder for future implementation
- */
-export interface HookCallbackResult {
-  shouldSkip?: boolean;
-  shouldInterrupt?: boolean;
-  suppressOutput?: boolean;
-  message?: string;
-}
-
-export interface CLIControlInterruptRequest {
-  subtype: 'interrupt';
-}
-
-export interface CLIControlPermissionRequest {
-  subtype: 'can_use_tool';
-  tool_name: string;
-  tool_use_id: string;
-  input: unknown;
-  permission_suggestions: PermissionSuggestion[] | null;
-  blocked_path: string | null;
-}
-
-/**
- * Wire format for SDK MCP server config in initialization request.
- * The actual Server instance stays in the SDK process.
- */
-export interface SDKMcpServerConfig {
-  type: 'sdk';
-  name: string;
-}
-
-/**
- * Wire format for external MCP server config in initialization request.
- * Represents stdio/SSE/HTTP/TCP transports that must run in the CLI process.
- */
-export interface CLIMcpServerConfig {
-  command?: string;
-  args?: string[];
-  env?: Record<string, string>;
-  cwd?: string;
-  url?: string;
-  httpUrl?: string;
-  headers?: Record<string, string>;
-  tcp?: string;
-  timeout?: number;
-  trust?: boolean;
-  description?: string;
-  includeTools?: string[];
-  excludeTools?: string[];
-  extensionName?: string;
-  oauth?: {
-    enabled?: boolean;
-    clientId?: string;
-    clientSecret?: string;
-    authorizationUrl?: string;
-    tokenUrl?: string;
-    scopes?: string[];
-    audiences?: string[];
-    redirectUri?: string;
-    tokenParamName?: string;
-    registrationUrl?: string;
-  };
-  authProviderType?:
-    | 'dynamic_discovery'
-    | 'google_credentials'
-    | 'service_account_impersonation';
-  targetAudience?: string;
-  targetServiceAccount?: string;
-}
-
-export interface CLIControlInitializeRequest {
-  subtype: 'initialize';
-  hooks?: HookRegistration[] | null;
-  /**
-   * SDK MCP servers config
-   * These are MCP servers running in the SDK process, connected via control plane.
-   * External MCP servers are configured separately in settings, not via initialization.
-   */
-  sdkMcpServers?: Record<string, Omit<SDKMcpServerConfig, 'instance'>>;
-  /**
-   * External MCP servers that the SDK wants the CLI to manage.
-   * These run outside the SDK process and require CLI-side transport setup.
-   */
-  mcpServers?: Record<string, CLIMcpServerConfig>;
-  agents?: SubagentConfig[];
-}
-
-export interface CLIControlSetPermissionModeRequest {
-  subtype: 'set_permission_mode';
-  mode: PermissionMode;
-}
-
-export interface CLIHookCallbackRequest {
-  subtype: 'hook_callback';
-  callback_id: string;
-  input: unknown;
-  tool_use_id: string | null;
-}
-
-export interface CLIControlMcpMessageRequest {
-  subtype: 'mcp_message';
-  server_name: string;
-  message: {
-    jsonrpc?: string;
-    method: string;
-    params?: Record<string, unknown>;
-    id?: string | number | null;
-  };
-}
-
-export interface CLIControlSetModelRequest {
-  subtype: 'set_model';
-  model: string;
-}
-
-export interface CLIControlMcpStatusRequest {
-  subtype: 'mcp_server_status';
-}
-
-export interface CLIControlSupportedCommandsRequest {
-  subtype: 'supported_commands';
-}
-
-export type ControlRequestPayload =
-  | CLIControlInterruptRequest
-  | CLIControlPermissionRequest
-  | CLIControlInitializeRequest
-  | CLIControlSetPermissionModeRequest
-  | CLIHookCallbackRequest
-  | CLIControlMcpMessageRequest
-  | CLIControlSetModelRequest
-  | CLIControlMcpStatusRequest
-  | CLIControlSupportedCommandsRequest;
-
-export interface CLIControlRequest {
-  type: 'control_request';
-  request_id: string;
-  request: ControlRequestPayload;
-}
-
-/**
- * Permission approval result
- */
-export interface PermissionApproval {
-  allowed: boolean;
-  reason?: string;
-  modifiedInput?: unknown;
-}
-
-export interface ControlResponse {
-  subtype: 'success';
-  request_id: string;
-  response: unknown;
-}
-
-export interface ControlErrorResponse {
-  subtype: 'error';
-  request_id: string;
-  error: string | { message: string; [key: string]: unknown };
-}
-
-export interface CLIControlResponse {
-  type: 'control_response';
-  response: ControlResponse | ControlErrorResponse;
-}
-
-export interface ControlCancelRequest {
-  type: 'control_cancel_request';
-  request_id?: string;
-}
-
-export type ControlMessage =
-  | CLIControlRequest
-  | CLIControlResponse
-  | ControlCancelRequest;
-
-/**
- * Union of all CLI message types
- */
-export type CLIMessage =
-  | CLIUserMessage
-  | CLIAssistantMessage
-  | CLISystemMessage
-  | CLIResultMessage
-  | CLIPartialAssistantMessage;
-
-/**
- * Type guard functions for message discrimination
- */
-
-export function isCLIUserMessage(msg: any): msg is CLIUserMessage {
-  return (
-    msg && typeof msg === 'object' && msg.type === 'user' && 'message' in msg
-  );
-}
-
-export function isCLIAssistantMessage(msg: any): msg is CLIAssistantMessage {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'assistant' &&
-    'uuid' in msg &&
-    'message' in msg &&
-    'session_id' in msg &&
-    'parent_tool_use_id' in msg
-  );
-}
-
-export function isCLISystemMessage(msg: any): msg is CLISystemMessage {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'system' &&
-    'subtype' in msg &&
-    'uuid' in msg &&
-    'session_id' in msg
-  );
-}
-
-export function isCLIResultMessage(msg: any): msg is CLIResultMessage {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'result' &&
-    'subtype' in msg &&
-    'duration_ms' in msg &&
-    'is_error' in msg &&
-    'uuid' in msg &&
-    'session_id' in msg
-  );
-}
-
-export function isCLIPartialAssistantMessage(
-  msg: any,
-): msg is CLIPartialAssistantMessage {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'stream_event' &&
-    'uuid' in msg &&
-    'session_id' in msg &&
-    'event' in msg &&
-    'parent_tool_use_id' in msg
-  );
-}
-
-export function isControlRequest(msg: any): msg is CLIControlRequest {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'control_request' &&
-    'request_id' in msg &&
-    'request' in msg
-  );
-}
-
-export function isControlResponse(msg: any): msg is CLIControlResponse {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'control_response' &&
-    'response' in msg
-  );
-}
-
-export function isControlCancel(msg: any): msg is ControlCancelRequest {
-  return (
-    msg &&
-    typeof msg === 'object' &&
-    msg.type === 'control_cancel_request' &&
-    'request_id' in msg
-  );
-}
-
-/**
- * Content block type guards
- */
-
-export function isTextBlock(block: any): block is TextBlock {
-  return block && typeof block === 'object' && block.type === 'text';
-}
-
-export function isThinkingBlock(block: any): block is ThinkingBlock {
-  return block && typeof block === 'object' && block.type === 'thinking';
-}
-
-export function isToolUseBlock(block: any): block is ToolUseBlock {
-  return block && typeof block === 'object' && block.type === 'tool_use';
-}
-
-export function isToolResultBlock(block: any): block is ToolResultBlock {
-  return block && typeof block === 'object' && block.type === 'tool_result';
-}
--- a/packages/cli/src/nonInteractiveCli.test.ts
+++ b/packages/cli/src/nonInteractiveCli.test.ts
--- a/packages/cli/src/nonInteractiveCli.ts
+++ b/packages/cli/src/nonInteractiveCli.ts
@@ -15,18 +15,14 @@ import {
  FatalInputError,
  promptIdContext,
  OutputFormat,
-  InputFormat,
+  JsonFormatter,
  uiTelemetryService,
-  parseAndFormatApiError,
 } from '@qwen-code/qwen-code-core';
-import type { Content, Part, PartListUnion } from '@google/genai';
-import type { CLIUserMessage, PermissionMode } from './nonInteractive/types.js';
-import type { JsonOutputAdapterInterface } from './nonInteractive/io/BaseJsonOutputAdapter.js';
-import { JsonOutputAdapter } from './nonInteractive/io/JsonOutputAdapter.js';
-import { StreamJsonOutputAdapter } from './nonInteractive/io/StreamJsonOutputAdapter.js';
-import type { ControlService } from './nonInteractive/control/ControlService.js';
+
+import type { Content, Part } from '@google/genai';

 import { handleSlashCommand } from './nonInteractiveCliCommands.js';
+import { ConsolePatcher } from './ui/utils/ConsolePatcher.js';
 import { handleAtCommand } from './ui/hooks/atCommandProcessor.js';
 import {
  handleError,
@@ -34,145 +30,73 @@ import {
  handleCancellationError,
  handleMaxTurnsExceededError,
 } from './utils/errors.js';
-import {
-  normalizePartList,
-  extractPartsFromUserMessage,
-  buildSystemMessage,
-  createTaskToolProgressHandler,
-  computeUsageFromMetrics,
-} from './utils/nonInteractiveHelpers.js';

-/**
- * Provides optional overrides for `runNonInteractive` execution.
- *
- * @param abortController - Optional abort controller for cancellation.
- * @param adapter - Optional JSON output adapter for structured output formats.
- * @param userMessage - Optional CLI user message payload for preformatted input.
- * @param controlService - Optional control service for future permission handling.
- */
-export interface RunNonInteractiveOptions {
-  abortController?: AbortController;
-  adapter?: JsonOutputAdapterInterface;
-  userMessage?: CLIUserMessage;
-  controlService?: ControlService;
-}
-
-/**
- * Executes the non-interactive CLI flow for a single request.
- */
 export async function runNonInteractive(
  config: Config,
  settings: LoadedSettings,
  input: string,
  prompt_id: string,
-  options: RunNonInteractiveOptions = {},
 ): Promise<void> {
  return promptIdContext.run(prompt_id, async () => {
-    // Create output adapter based on format
-    let adapter: JsonOutputAdapterInterface | undefined;
-    const outputFormat = config.getOutputFormat();
-
-    if (options.adapter) {
-      adapter = options.adapter;
-    } else if (outputFormat === OutputFormat.JSON) {
-      adapter = new JsonOutputAdapter(config);
-    } else if (outputFormat === OutputFormat.STREAM_JSON) {
-      adapter = new StreamJsonOutputAdapter(
-        config,
-        config.getIncludePartialMessages(),
-      );
-    }
-
-    // Get readonly values once at the start
-    const sessionId = config.getSessionId();
-    const permissionMode = config.getApprovalMode() as PermissionMode;
-
-    let turnCount = 0;
-    let totalApiDurationMs = 0;
-    const startTime = Date.now();
-
-    const stdoutErrorHandler = (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EPIPE') {
-        process.stdout.removeListener('error', stdoutErrorHandler);
-        process.exit(0);
-      }
-    };
-
-    const geminiClient = config.getGeminiClient();
-    const abortController = options.abortController ?? new AbortController();
-
-    // Setup signal handlers for graceful shutdown
-    const shutdownHandler = () => {
-      if (config.getDebugMode()) {
-        console.error('[runNonInteractive] Shutdown signal received');
-      }
-      abortController.abort();
-    };
+    const consolePatcher = new ConsolePatcher({
+      stderr: true,
+      debugMode: config.getDebugMode(),
+    });

    try {
-      process.stdout.on('error', stdoutErrorHandler);
-
-      process.on('SIGINT', shutdownHandler);
-      process.on('SIGTERM', shutdownHandler);
-
-      let initialPartList: PartListUnion | null = extractPartsFromUserMessage(
-        options.userMessage,
-      );
-
-      if (!initialPartList) {
-        let slashHandled = false;
-        if (isSlashCommand(input)) {
-          const slashCommandResult = await handleSlashCommand(
-            input,
-            abortController,
-            config,
-            settings,
-          );
-          if (slashCommandResult) {
-            // A slash command can replace the prompt entirely; fall back to @-command processing otherwise.
-            initialPartList = slashCommandResult as PartListUnion;
-            slashHandled = true;
-          }
+      consolePatcher.patch();
+      // Handle EPIPE errors when the output is piped to a command that closes early.
+      process.stdout.on('error', (err: NodeJS.ErrnoException) => {
+        if (err.code === 'EPIPE') {
+          // Exit gracefully if the pipe is closed.
+          process.exit(0);
        }
+      });

-        if (!slashHandled) {
-          const { processedQuery, shouldProceed } = await handleAtCommand({
-            query: input,
-            config,
-            addItem: (_item, _timestamp) => 0,
-            onDebugMessage: () => {},
-            messageId: Date.now(),
-            signal: abortController.signal,
-          });
+      const geminiClient = config.getGeminiClient();

-          if (!shouldProceed || !processedQuery) {
-            // An error occurred during @include processing (e.g., file not found).
-            // The error message is already logged by handleAtCommand.
-            throw new FatalInputError(
-              'Exiting due to an error processing the @ command.',
-            );
-          }
-          initialPartList = processedQuery as PartListUnion;
-        }
-      }
+      const abortController = new AbortController();

-      if (!initialPartList) {
-        initialPartList = [{ text: input }];
-      }
+      let query: Part[] | undefined;

-      const initialParts = normalizePartList(initialPartList);
-      let currentMessages: Content[] = [{ role: 'user', parts: initialParts }];
-
-      if (adapter) {
-        const systemMessage = await buildSystemMessage(
+      if (isSlashCommand(input)) {
+        const slashCommandResult = await handleSlashCommand(
+          input,
+          abortController,
          config,
-          sessionId,
-          permissionMode,
+          settings,
        );
-        adapter.emitMessage(systemMessage);
+        // If a slash command is found and returns a prompt, use it.
+        // Otherwise, slashCommandResult fall through to the default prompt
+        // handling.
+        if (slashCommandResult) {
+          query = slashCommandResult as Part[];
+        }
      }

-      let isFirstTurn = true;
+      if (!query) {
+        const { processedQuery, shouldProceed } = await handleAtCommand({
+          query: input,
+          config,
+          addItem: (_item, _timestamp) => 0,
+          onDebugMessage: () => {},
+          messageId: Date.now(),
+          signal: abortController.signal,
+        });
+
+        if (!shouldProceed || !processedQuery) {
+          // An error occurred during @include processing (e.g., file not found).
+          // The error message is already logged by handleAtCommand.
+          throw new FatalInputError(
+            'Exiting due to an error processing the @ command.',
+          );
+        }
+        query = processedQuery as Part[];
+      }
+
+      let currentMessages: Content[] = [{ role: 'user', parts: query }];
+
+      let turnCount = 0;
      while (true) {
        turnCount++;
        if (
@@ -181,111 +105,43 @@ export async function runNonInteractive(
        ) {
          handleMaxTurnsExceededError(config);
        }
-
        const toolCallRequests: ToolCallRequestInfo[] = [];
-        const apiStartTime = Date.now();
+
        const responseStream = geminiClient.sendMessageStream(
          currentMessages[0]?.parts || [],
          abortController.signal,
          prompt_id,
-          { isContinuation: !isFirstTurn },
        );
-        isFirstTurn = false;
-
-        // Start assistant message for this turn
-        if (adapter) {
-          adapter.startAssistantMessage();
-        }

+        let responseText = '';
        for await (const event of responseStream) {
          if (abortController.signal.aborted) {
            handleCancellationError(config);
          }

-          if (adapter) {
-            // Use adapter for all event processing
-            adapter.processEvent(event);
-            if (event.type === GeminiEventType.ToolCallRequest) {
-              toolCallRequests.push(event.value);
-            }
-          } else {
-            // Text output mode - direct stdout
-            if (event.type === GeminiEventType.Thought) {
-              process.stdout.write(event.value.description);
-            } else if (event.type === GeminiEventType.Content) {
+          if (event.type === GeminiEventType.Content) {
+            if (config.getOutputFormat() === OutputFormat.JSON) {
+              responseText += event.value;
+            } else {
              process.stdout.write(event.value);
-            } else if (event.type === GeminiEventType.ToolCallRequest) {
-              toolCallRequests.push(event.value);
-            } else if (event.type === GeminiEventType.Error) {
-              // Format and output the error message for text mode
-              const errorText = parseAndFormatApiError(
-                event.value.error,
-                config.getContentGeneratorConfig()?.authType,
-                undefined,
-                config.getModel(),
-              );
-              process.stderr.write(`${errorText}\n`);
            }
+          } else if (event.type === GeminiEventType.ToolCallRequest) {
+            toolCallRequests.push(event.value);
          }
        }

-        // Finalize assistant message
-        if (adapter) {
-          adapter.finalizeAssistantMessage();
-        }
-        totalApiDurationMs += Date.now() - apiStartTime;
-
        if (toolCallRequests.length > 0) {
          const toolResponseParts: Part[] = [];
-
          for (const requestInfo of toolCallRequests) {
-            const finalRequestInfo = requestInfo;
-
-            const inputFormat =
-              typeof config.getInputFormat === 'function'
-                ? config.getInputFormat()
-                : InputFormat.TEXT;
-            const toolCallUpdateCallback =
-              inputFormat === InputFormat.STREAM_JSON && options.controlService
-                ? options.controlService.permission.getToolCallUpdateCallback()
-                : undefined;
-
-            // Only pass outputUpdateHandler for Task tool
-            const isTaskTool = finalRequestInfo.name === 'task';
-            const taskToolProgress = isTaskTool
-              ? createTaskToolProgressHandler(
-                  config,
-                  finalRequestInfo.callId,
-                  adapter,
-                )
-              : undefined;
-            const taskToolProgressHandler = taskToolProgress?.handler;
            const toolResponse = await executeToolCall(
              config,
-              finalRequestInfo,
+              requestInfo,
              abortController.signal,
-              isTaskTool && taskToolProgressHandler
-                ? {
-                    outputUpdateHandler: taskToolProgressHandler,
-                    onToolCallsUpdate: toolCallUpdateCallback,
-                  }
-                : toolCallUpdateCallback
-                  ? {
-                      onToolCallsUpdate: toolCallUpdateCallback,
-                    }
-                  : undefined,
            );

-            // Note: In JSON mode, subagent messages are automatically added to the main
-            // adapter's messages array and will be output together on emitResult()
-
            if (toolResponse.error) {
-              // In JSON/STREAM_JSON mode, tool errors are tolerated and formatted
-              // as tool_result blocks. handleToolError will detect JSON/STREAM_JSON mode
-              // from config and allow the session to continue so the LLM can decide what to do next.
-              // In text mode, we still log the error.
              handleToolError(
-                finalRequestInfo.name,
+                requestInfo.name,
                toolResponse.error,
                config,
                toolResponse.errorType || 'TOOL_EXECUTION_ERROR',
@@ -295,67 +151,26 @@ export async function runNonInteractive(
              );
            }

-            if (adapter) {
-              adapter.emitToolResult(finalRequestInfo, toolResponse);
-            }
-
            if (toolResponse.responseParts) {
              toolResponseParts.push(...toolResponse.responseParts);
            }
          }
          currentMessages = [{ role: 'user', parts: toolResponseParts }];
        } else {
-          // For JSON and STREAM_JSON modes, compute usage from metrics
-          if (adapter) {
-            const metrics = uiTelemetryService.getMetrics();
-            const usage = computeUsageFromMetrics(metrics);
-            // Get stats for JSON format output
-            const stats =
-              outputFormat === OutputFormat.JSON
-                ? uiTelemetryService.getMetrics()
-                : undefined;
-            adapter.emitResult({
-              isError: false,
-              durationMs: Date.now() - startTime,
-              apiDurationMs: totalApiDurationMs,
-              numTurns: turnCount,
-              usage,
-              stats,
-            });
+          if (config.getOutputFormat() === OutputFormat.JSON) {
+            const formatter = new JsonFormatter();
+            const stats = uiTelemetryService.getMetrics();
+            process.stdout.write(formatter.format(responseText, stats));
          } else {
-            // Text output mode - no usage needed
-            process.stdout.write('\n');
+            process.stdout.write('\n'); // Ensure a final newline
          }
          return;
        }
      }
    } catch (error) {
-      // For JSON and STREAM_JSON modes, compute usage from metrics
-      const message = error instanceof Error ? error.message : String(error);
-      if (adapter) {
-        const metrics = uiTelemetryService.getMetrics();
-        const usage = computeUsageFromMetrics(metrics);
-        // Get stats for JSON format output
-        const stats =
-          outputFormat === OutputFormat.JSON
-            ? uiTelemetryService.getMetrics()
-            : undefined;
-        adapter.emitResult({
-          isError: true,
-          durationMs: Date.now() - startTime,
-          apiDurationMs: totalApiDurationMs,
-          numTurns: turnCount,
-          errorMessage: message,
-          usage,
-          stats,
-        });
-      }
      handleError(error, config);
    } finally {
-      process.stdout.removeListener('error', stdoutErrorHandler);
-      // Cleanup signal handlers
-      process.removeListener('SIGINT', shutdownHandler);
-      process.removeListener('SIGTERM', shutdownHandler);
+      consolePatcher.cleanup();
      if (isTelemetrySdkInitialized()) {
        await shutdownTelemetry(config);
      }
--- a/packages/cli/src/services/BuiltinCommandLoader.test.ts
+++ b/packages/cli/src/services/BuiltinCommandLoader.test.ts
@@ -56,6 +56,7 @@ import { restoreCommand } from '../ui/commands/restoreCommand.js';

 vi.mock('../ui/commands/authCommand.js', () => ({ authCommand: {} }));
 vi.mock('../ui/commands/bugCommand.js', () => ({ bugCommand: {} }));
+vi.mock('../ui/commands/chatCommand.js', () => ({ chatCommand: {} }));
 vi.mock('../ui/commands/clearCommand.js', () => ({ clearCommand: {} }));
 vi.mock('../ui/commands/compressCommand.js', () => ({ compressCommand: {} }));
 vi.mock('../ui/commands/corgiCommand.js', () => ({ corgiCommand: {} }));
@@ -71,6 +72,7 @@ vi.mock('../ui/commands/modelCommand.js', () => ({
 }));
 vi.mock('../ui/commands/quitCommand.js', () => ({
  quitCommand: {},
+  quitConfirmCommand: {},
 }));
 vi.mock('../ui/commands/statsCommand.js', () => ({ statsCommand: {} }));
 vi.mock('../ui/commands/themeCommand.js', () => ({ themeCommand: {} }));
--- a/packages/cli/src/services/BuiltinCommandLoader.ts
+++ b/packages/cli/src/services/BuiltinCommandLoader.ts
@@ -12,6 +12,7 @@ import { agentsCommand } from '../ui/commands/agentsCommand.js';
 import { approvalModeCommand } from '../ui/commands/approvalModeCommand.js';
 import { authCommand } from '../ui/commands/authCommand.js';
 import { bugCommand } from '../ui/commands/bugCommand.js';
+import { chatCommand } from '../ui/commands/chatCommand.js';
 import { clearCommand } from '../ui/commands/clearCommand.js';
 import { compressCommand } from '../ui/commands/compressCommand.js';
 import { copyCommand } from '../ui/commands/copyCommand.js';
@@ -23,12 +24,11 @@ import { extensionsCommand } from '../ui/commands/extensionsCommand.js';
 import { helpCommand } from '../ui/commands/helpCommand.js';
 import { ideCommand } from '../ui/commands/ideCommand.js';
 import { initCommand } from '../ui/commands/initCommand.js';
-import { languageCommand } from '../ui/commands/languageCommand.js';
 import { mcpCommand } from '../ui/commands/mcpCommand.js';
 import { memoryCommand } from '../ui/commands/memoryCommand.js';
 import { modelCommand } from '../ui/commands/modelCommand.js';
 import { permissionsCommand } from '../ui/commands/permissionsCommand.js';
-import { quitCommand } from '../ui/commands/quitCommand.js';
+import { quitCommand, quitConfirmCommand } from '../ui/commands/quitCommand.js';
 import { restoreCommand } from '../ui/commands/restoreCommand.js';
 import { settingsCommand } from '../ui/commands/settingsCommand.js';
 import { statsCommand } from '../ui/commands/statsCommand.js';
@@ -60,6 +60,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
      approvalModeCommand,
      authCommand,
      bugCommand,
+      chatCommand,
      clearCommand,
      compressCommand,
      copyCommand,
@@ -71,12 +72,12 @@ export class BuiltinCommandLoader implements ICommandLoader {
      helpCommand,
      await ideCommand(),
      initCommand,
-      languageCommand,
      mcpCommand,
      memoryCommand,
      modelCommand,
      ...(this.config?.getFolderTrust() ? [permissionsCommand] : []),
      quitCommand,
+      quitConfirmCommand,
      restoreCommand(this.config),
      statsCommand,
      summaryCommand,
--- a/packages/cli/src/test-utils/mockCommandContext.ts
+++ b/packages/cli/src/test-utils/mockCommandContext.ts
@@ -9,7 +9,6 @@ import type { CommandContext } from '../ui/commands/types.js';
 import type { LoadedSettings } from '../config/settings.js';
 import type { GitService } from '@qwen-code/qwen-code-core';
 import type { SessionStatsState } from '../ui/contexts/SessionContext.js';
-import { ToolCallDecision } from '../ui/contexts/SessionContext.js';

 // A utility type to make all properties of an object, and its nested objects, partial.
 type DeepPartial<T> = T extends object
@@ -64,9 +63,7 @@ export const createMockCommandContext = (
    } as any,
    session: {
      sessionShellAllowlist: new Set<string>(),
-      startNewSession: vi.fn(),
      stats: {
-        sessionId: '',
        sessionStartTime: new Date(),
        lastPromptTokenCount: 0,
        metrics: {
@@ -76,15 +73,9 @@ export const createMockCommandContext = (
            totalSuccess: 0,
            totalFail: 0,
            totalDurationMs: 0,
-            totalDecisions: {
-              [ToolCallDecision.ACCEPT]: 0,
-              [ToolCallDecision.REJECT]: 0,
-              [ToolCallDecision.MODIFY]: 0,
-              [ToolCallDecision.AUTO_ACCEPT]: 0,
-            },
+            totalDecisions: { accept: 0, reject: 0, modify: 0 },
            byName: {},
          },
-          files: { totalLinesAdded: 0, totalLinesRemoved: 0 },
        },
        promptCount: 0,
      } as SessionStatsState,
--- a/packages/cli/src/ui/AppContainer.tsx
+++ b/packages/cli/src/ui/AppContainer.tsx
@@ -25,6 +25,7 @@ import {
  type HistoryItem,
  ToolCallStatus,
  type HistoryItemWithoutId,
+  AuthState,
 } from './types.js';
 import { MessageType, StreamingState } from './types.js';
 import {
@@ -40,7 +41,6 @@ import {
  getAllGeminiMdFilenames,
  ShellExecutionService,
 } from '@qwen-code/qwen-code-core';
-import { buildResumedHistoryItems } from './utils/resumeHistoryUtils.js';
 import { validateAuthMethod } from '../config/auth.js';
 import { loadHierarchicalGeminiMemory } from '../config/config.js';
 import process from 'node:process';
@@ -48,6 +48,7 @@ import { useHistory } from './hooks/useHistoryManager.js';
 import { useMemoryMonitor } from './hooks/useMemoryMonitor.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './auth/useAuth.js';
+import { useQwenAuth } from './hooks/useQwenAuth.js';
 import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { useEditorSettings } from './hooks/useEditorSettings.js';
 import { useSettingsCommand } from './hooks/useSettingsCommand.js';
@@ -89,15 +90,13 @@ import { useSessionStats } from './contexts/SessionContext.js';
 import { useGitBranchName } from './hooks/useGitBranchName.js';
 import { useExtensionUpdates } from './hooks/useExtensionUpdates.js';
 import { ShellFocusContext } from './contexts/ShellFocusContext.js';
-import { t } from '../i18n/index.js';
+import { useQuitConfirmation } from './hooks/useQuitConfirmation.js';
 import { useWelcomeBack } from './hooks/useWelcomeBack.js';
 import { useDialogClose } from './hooks/useDialogClose.js';
-import { useInitializationAuthError } from './hooks/useInitializationAuthError.js';
 import { type VisionSwitchOutcome } from './components/ModelSwitchDialog.js';
 import { processVisionSwitchOutcome } from './hooks/useVisionAutoSwitch.js';
 import { useSubagentCreateDialog } from './hooks/useSubagentCreateDialog.js';
 import { useAgentsManagerDialog } from './hooks/useAgentsManagerDialog.js';
-import { useAttentionNotifications } from './hooks/useAttentionNotifications.js';

 const CTRL_EXIT_PROMPT_DURATION_MS = 1000;

@@ -196,6 +195,7 @@ export const AppContainer = (props: AppContainerProps) => {

  const [isConfigInitialized, setConfigInitialized] = useState(false);

+  const logger = useLogger(config.storage);
  const [userMessages, setUserMessages] = useState<string[]>([]);

  // Terminal and layout hooks
@@ -205,7 +205,6 @@ export const AppContainer = (props: AppContainerProps) => {

  // Additional hooks moved from App.tsx
  const { stats: sessionStats } = useSessionStats();
-  const logger = useLogger(config.storage, sessionStats.sessionId);
  const branchName = useGitBranchName(config.getTargetDir());

  // Layout measurements
@@ -216,28 +215,17 @@ export const AppContainer = (props: AppContainerProps) => {
  const lastTitleRef = useRef<string | null>(null);
  const staticExtraHeight = 3;

-  // Initialize config (runs once on mount)
  useEffect(() => {
    (async () => {
      // Note: the program will not work if this fails so let errors be
      // handled by the global catch.
      await config.initialize();
      setConfigInitialized(true);
-
-      const resumedSessionData = config.getResumedSessionData();
-      if (resumedSessionData) {
-        const historyItems = buildResumedHistoryItems(
-          resumedSessionData,
-          config,
-        );
-        historyManager.loadHistory(historyItems);
-      }
    })();
    registerCleanup(async () => {
      const ideClient = await IdeClient.getInstance();
      await ideClient.disconnect();
    });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [config]);

  useEffect(
@@ -360,12 +348,19 @@ export const AppContainer = (props: AppContainerProps) => {
    onAuthError,
    isAuthDialogOpen,
    isAuthenticating,
-    pendingAuthType,
-    qwenAuthState,
    handleAuthSelect,
    openAuthDialog,
-    cancelAuthentication,
-  } = useAuthCommand(settings, config, historyManager.addItem);
+  } = useAuthCommand(settings, config);
+
+  // Qwen OAuth authentication state
+  const {
+    isQwenAuth,
+    isQwenAuthenticating,
+    deviceAuth,
+    authStatus,
+    authMessage,
+    cancelQwenAuth,
+  } = useQwenAuth(settings, isAuthenticating);

  const { proQuotaRequest, handleProQuotaChoice } = useQuotaAndFallback({
    config,
@@ -375,7 +370,19 @@ export const AppContainer = (props: AppContainerProps) => {
    setModelSwitchedFromQuotaError,
  });

-  useInitializationAuthError(initializationResult.authError, onAuthError);
+  // Handle Qwen OAuth timeout
+  const handleQwenAuthTimeout = useCallback(() => {
+    onAuthError('Qwen OAuth authentication timed out. Please try again.');
+    cancelQwenAuth();
+    setAuthState(AuthState.Updating);
+  }, [onAuthError, cancelQwenAuth, setAuthState]);
+
+  // Handle Qwen OAuth cancel
+  const handleQwenAuthCancel = useCallback(() => {
+    onAuthError('Qwen OAuth authentication cancelled.');
+    cancelQwenAuth();
+    setAuthState(AuthState.Updating);
+  }, [onAuthError, cancelQwenAuth, setAuthState]);

  // Sync user tier from config when authentication changes
  // TODO: Implement getUserTier() method on Config if needed
@@ -387,8 +394,6 @@ export const AppContainer = (props: AppContainerProps) => {

  // Check for enforced auth type mismatch
  useEffect(() => {
-    // Check for initialization error first
-
    if (
      settings.merged.security?.auth?.enforcedType &&
      settings.merged.security?.auth.selectedType &&
@@ -396,13 +401,7 @@ export const AppContainer = (props: AppContainerProps) => {
        settings.merged.security?.auth.selectedType
    ) {
      onAuthError(
-        t(
-          'Authentication is enforced to be {{enforcedType}}, but you are currently using {{currentType}}.',
-          {
-            enforcedType: settings.merged.security?.auth.enforcedType,
-            currentType: settings.merged.security?.auth.selectedType,
-          },
-        ),
+        `Authentication is enforced to be ${settings.merged.security?.auth.enforcedType}, but you are currently using ${settings.merged.security?.auth.selectedType}.`,
      );
    } else if (
      settings.merged.security?.auth?.selectedType &&
@@ -445,6 +444,8 @@ export const AppContainer = (props: AppContainerProps) => {

  const { toggleVimEnabled } = useVimMode();

+  const { showQuitConfirmation } = useQuitConfirmation();
+
  const {
    isSubagentCreateDialogOpen,
    openSubagentCreateDialog,
@@ -490,6 +491,7 @@ export const AppContainer = (props: AppContainerProps) => {
      addConfirmUpdateExtensionRequest,
      openSubagentCreateDialog,
      openAgentsManagerDialog,
+      _showQuitConfirmation: showQuitConfirmation,
    }),
    [
      openAuthDialog,
@@ -503,6 +505,7 @@ export const AppContainer = (props: AppContainerProps) => {
      openPermissionsDialog,
      openApprovalModeDialog,
      addConfirmUpdateExtensionRequest,
+      showQuitConfirmation,
      openSubagentCreateDialog,
      openAgentsManagerDialog,
    ],
@@ -515,6 +518,7 @@ export const AppContainer = (props: AppContainerProps) => {
    commandContext,
    shellConfirmationRequest,
    confirmationRequest,
+    quitConfirmationRequest,
  } = useSlashCommandProcessor(
    config,
    settings,
@@ -528,7 +532,6 @@ export const AppContainer = (props: AppContainerProps) => {
    slashCommandActions,
    extensionsUpdateStateInternal,
    isConfigInitialized,
-    logger,
  );

  // Vision switch handlers
@@ -941,12 +944,6 @@ export const AppContainer = (props: AppContainerProps) => {
    settings.merged.ui?.customWittyPhrases,
  );

-  useAttentionNotifications({
-    isFocused,
-    streamingState,
-    elapsedTime,
-  });
-
  // Dialog close functionality
  const { closeAnyOpenDialog } = useDialogClose({
    isThemeDialogOpen,
@@ -955,7 +952,7 @@ export const AppContainer = (props: AppContainerProps) => {
    handleApprovalModeSelect,
    isAuthDialogOpen,
    handleAuthSelect,
-    pendingAuthType,
+    selectedAuthType: settings.merged.security?.auth?.selectedType,
    isEditorDialogOpen,
    exitEditorDialog,
    isSettingsDialogOpen,
@@ -963,6 +960,7 @@ export const AppContainer = (props: AppContainerProps) => {
    isFolderTrustDialogOpen,
    showWelcomeBackDialog,
    handleWelcomeBackClose,
+    quitConfirmationRequest,
  });

  const handleExit = useCallback(
@@ -976,18 +974,25 @@ export const AppContainer = (props: AppContainerProps) => {
        if (timerRef.current) {
          clearTimeout(timerRef.current);
        }
-        // Exit directly
+        // Exit directly without showing confirmation dialog
        handleSlashCommand('/quit');
        return;
      }

      // First press: Prioritize cleanup tasks

+      // Special case: If quit-confirm dialog is open, Ctrl+C means "quit immediately"
+      if (quitConfirmationRequest) {
+        handleSlashCommand('/quit');
+        return;
+      }
+
      // 1. Close other dialogs (highest priority)
      /**
       * For AuthDialog it is required to complete the authentication process,
       * otherwise user cannot proceed to the next step.
-       * So a quit on AuthDialog should go with normal two press quit.
+       * So a quit on AuthDialog should go with normal two press quit
+       * and without quit-confirm dialog.
       */
      if (isAuthDialogOpen) {
        setPressedOnce(true);
@@ -1008,17 +1013,14 @@ export const AppContainer = (props: AppContainerProps) => {
        return; // Request cancelled, end processing
      }

-      // 4. Clear input buffer (if has content)
+      // 3. Clear input buffer (if has content)
      if (buffer.text.length > 0) {
        buffer.setText('');
        return; // Input cleared, end processing
      }

-      // All cleanup tasks completed, set flag for double-press to quit
-      setPressedOnce(true);
-      timerRef.current = setTimeout(() => {
-        setPressedOnce(false);
-      }, CTRL_EXIT_PROMPT_DURATION_MS);
+      // All cleanup tasks completed, show quit confirmation dialog
+      handleSlashCommand('/quit-confirm');
    },
    [
      isAuthDialogOpen,
@@ -1026,6 +1028,7 @@ export const AppContainer = (props: AppContainerProps) => {
      closeAnyOpenDialog,
      streamingState,
      cancelOngoingRequest,
+      quitConfirmationRequest,
      buffer,
    ],
  );
@@ -1042,8 +1045,8 @@ export const AppContainer = (props: AppContainerProps) => {
          return;
        }

-        // On first press: set flag, start timer, and call handleExit for cleanup
-        // On second press (within timeout): handleExit sees flag and does fast quit
+        // On first press: set flag, start timer, and call handleExit for cleanup/quit-confirm
+        // On second press (within 500ms): handleExit sees flag and does fast quit
        if (!ctrlCPressedOnce) {
          setCtrlCPressedOnce(true);
          ctrlCTimerRef.current = setTimeout(() => {
@@ -1184,13 +1187,14 @@ export const AppContainer = (props: AppContainerProps) => {
    !!confirmationRequest ||
    confirmUpdateExtensionRequests.length > 0 ||
    !!loopDetectionConfirmationRequest ||
+    !!quitConfirmationRequest ||
    isThemeDialogOpen ||
    isSettingsDialogOpen ||
    isModelDialogOpen ||
    isVisionSwitchDialogOpen ||
    isPermissionsDialogOpen ||
    isAuthDialogOpen ||
-    isAuthenticating ||
+    (isAuthenticating && isQwenAuthenticating) ||
    isEditorDialogOpen ||
    showIdeRestartPrompt ||
    !!proQuotaRequest ||
@@ -1213,9 +1217,12 @@ export const AppContainer = (props: AppContainerProps) => {
      isConfigInitialized,
      authError,
      isAuthDialogOpen,
-      pendingAuthType,
      // Qwen OAuth state
-      qwenAuthState,
+      isQwenAuth,
+      isQwenAuthenticating,
+      deviceAuth,
+      authStatus,
+      authMessage,
      editorError,
      isEditorDialogOpen,
      corgiMode,
@@ -1232,6 +1239,7 @@ export const AppContainer = (props: AppContainerProps) => {
      confirmationRequest,
      confirmUpdateExtensionRequests,
      loopDetectionConfirmationRequest,
+      quitConfirmationRequest,
      geminiMdFileCount,
      streamingState,
      initError,
@@ -1304,9 +1312,12 @@ export const AppContainer = (props: AppContainerProps) => {
      isConfigInitialized,
      authError,
      isAuthDialogOpen,
-      pendingAuthType,
      // Qwen OAuth state
-      qwenAuthState,
+      isQwenAuth,
+      isQwenAuthenticating,
+      deviceAuth,
+      authStatus,
+      authMessage,
      editorError,
      isEditorDialogOpen,
      corgiMode,
@@ -1323,6 +1334,7 @@ export const AppContainer = (props: AppContainerProps) => {
      confirmationRequest,
      confirmUpdateExtensionRequests,
      loopDetectionConfirmationRequest,
+      quitConfirmationRequest,
      geminiMdFileCount,
      streamingState,
      initError,
@@ -1399,7 +1411,9 @@ export const AppContainer = (props: AppContainerProps) => {
      handleAuthSelect,
      setAuthState,
      onAuthError,
-      cancelAuthentication,
+      // Qwen OAuth handlers
+      handleQwenAuthTimeout,
+      handleQwenAuthCancel,
      handleEditorSelect,
      exitEditorDialog,
      closeSettingsDialog,
@@ -1433,7 +1447,9 @@ export const AppContainer = (props: AppContainerProps) => {
      handleAuthSelect,
      setAuthState,
      onAuthError,
-      cancelAuthentication,
+      // Qwen OAuth handlers
+      handleQwenAuthTimeout,
+      handleQwenAuthCancel,
      handleEditorSelect,
      exitEditorDialog,
      closeSettingsDialog,
--- a/packages/cli/src/ui/auth/AuthDialog.test.tsx
+++ b/packages/cli/src/ui/auth/AuthDialog.test.tsx
@@ -9,53 +9,6 @@ import { AuthDialog } from './AuthDialog.js';
 import { LoadedSettings, SettingScope } from '../../config/settings.js';
 import { AuthType } from '@qwen-code/qwen-code-core';
 import { renderWithProviders } from '../../test-utils/render.js';
-import { UIStateContext } from '../contexts/UIStateContext.js';
-import { UIActionsContext } from '../contexts/UIActionsContext.js';
-import type { UIState } from '../contexts/UIStateContext.js';
-import type { UIActions } from '../contexts/UIActionsContext.js';
-
-const createMockUIState = (overrides: Partial<UIState> = {}): UIState => {
-  // AuthDialog only uses authError and pendingAuthType
-  const baseState = {
-    authError: null,
-    pendingAuthType: undefined,
-  } as Partial<UIState>;
-
-  return {
-    ...baseState,
-    ...overrides,
-  } as UIState;
-};
-
-const createMockUIActions = (overrides: Partial<UIActions> = {}): UIActions => {
-  // AuthDialog only uses handleAuthSelect
-  const baseActions = {
-    handleAuthSelect: vi.fn(),
-  } as Partial<UIActions>;
-
-  return {
-    ...baseActions,
-    ...overrides,
-  } as UIActions;
-};
-
-const renderAuthDialog = (
-  settings: LoadedSettings,
-  uiStateOverrides: Partial<UIState> = {},
-  uiActionsOverrides: Partial<UIActions> = {},
-) => {
-  const uiState = createMockUIState(uiStateOverrides);
-  const uiActions = createMockUIActions(uiActionsOverrides);
-
-  return renderWithProviders(
-    <UIStateContext.Provider value={uiState}>
-      <UIActionsContext.Provider value={uiActions}>
-        <AuthDialog />
-      </UIActionsContext.Provider>
-    </UIStateContext.Provider>,
-    { settings },
-  );
-};

 describe('AuthDialog', () => {
  const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -113,9 +66,13 @@ describe('AuthDialog', () => {
      new Set(),
    );

-    const { lastFrame } = renderAuthDialog(settings, {
-      authError: 'GEMINI_API_KEY  environment variable not found',
-    });
+    const { lastFrame } = renderWithProviders(
+      <AuthDialog
+        onSelect={() => {}}
+        settings={settings}
+        initialErrorMessage="GEMINI_API_KEY  environment variable not found"
+      />,
+    );

    expect(lastFrame()).toContain(
      'GEMINI_API_KEY  environment variable not found',
@@ -159,7 +116,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      // Since the auth dialog only shows OpenAI option now,
      // it won't show GEMINI_API_KEY messages
@@ -203,7 +162,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      expect(lastFrame()).not.toContain(
        'Existing API key detected (GEMINI_API_KEY)',
@@ -247,7 +208,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      // Since the auth dialog only shows OpenAI option now,
      // it won't show GEMINI_API_KEY messages
@@ -292,7 +255,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      // This is a bit brittle, but it's the best way to check which item is selected.
      expect(lastFrame()).toContain('● 2. OpenAI');
@@ -332,7 +297,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      // Default is Qwen OAuth (first option)
      expect(lastFrame()).toContain('● 1. Qwen OAuth');
@@ -374,7 +341,9 @@ describe('AuthDialog', () => {
        new Set(),
      );

-      const { lastFrame } = renderAuthDialog(settings);
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );

      // Since the auth dialog doesn't show QWEN_DEFAULT_AUTH_TYPE errors anymore,
      // it will just show the default Qwen OAuth option
@@ -383,7 +352,7 @@ describe('AuthDialog', () => {
  });

  it('should prevent exiting when no auth method is selected and show error message', async () => {
-    const handleAuthSelect = vi.fn();
+    const onSelect = vi.fn();
    const settings: LoadedSettings = new LoadedSettings(
      {
        settings: { ui: { customThemes: {} }, mcpServers: {} },
@@ -417,10 +386,8 @@ describe('AuthDialog', () => {
      new Set(),
    );

-    const { lastFrame, stdin, unmount } = renderAuthDialog(
-      settings,
-      {},
-      { handleAuthSelect },
+    const { lastFrame, stdin, unmount } = renderWithProviders(
+      <AuthDialog onSelect={onSelect} settings={settings} />,
    );
    await wait();

@@ -428,16 +395,16 @@ describe('AuthDialog', () => {
    stdin.write('\u001b'); // ESC key
    await wait();

-    // Should show error message instead of calling handleAuthSelect
+    // Should show error message instead of calling onSelect
    expect(lastFrame()).toContain(
      'You must select an auth method to proceed. Press Ctrl+C again to exit.',
    );
-    expect(handleAuthSelect).not.toHaveBeenCalled();
+    expect(onSelect).not.toHaveBeenCalled();
    unmount();
  });

  it('should not exit if there is already an error message', async () => {
-    const handleAuthSelect = vi.fn();
+    const onSelect = vi.fn();
    const settings: LoadedSettings = new LoadedSettings(
      {
        settings: { ui: { customThemes: {} }, mcpServers: {} },
@@ -471,10 +438,12 @@ describe('AuthDialog', () => {
      new Set(),
    );

-    const { lastFrame, stdin, unmount } = renderAuthDialog(
-      settings,
-      { authError: 'Initial error' },
-      { handleAuthSelect },
+    const { lastFrame, stdin, unmount } = renderWithProviders(
+      <AuthDialog
+        onSelect={onSelect}
+        settings={settings}
+        initialErrorMessage="Initial error"
+      />,
    );
    await wait();

@@ -484,13 +453,13 @@ describe('AuthDialog', () => {
    stdin.write('\u001b'); // ESC key
    await wait();

-    // Should not call handleAuthSelect
-    expect(handleAuthSelect).not.toHaveBeenCalled();
+    // Should not call onSelect
+    expect(onSelect).not.toHaveBeenCalled();
    unmount();
  });

  it('should allow exiting when auth method is already selected', async () => {
-    const handleAuthSelect = vi.fn();
+    const onSelect = vi.fn();
    const settings: LoadedSettings = new LoadedSettings(
      {
        settings: { ui: { customThemes: {} }, mcpServers: {} },
@@ -524,10 +493,8 @@ describe('AuthDialog', () => {
      new Set(),
    );

-    const { stdin, unmount } = renderAuthDialog(
-      settings,
-      {},
-      { handleAuthSelect },
+    const { stdin, unmount } = renderWithProviders(
+      <AuthDialog onSelect={onSelect} settings={settings} />,
    );
    await wait();

@@ -535,8 +502,8 @@ describe('AuthDialog', () => {
    stdin.write('\u001b'); // ESC key
    await wait();

-    // Should call handleAuthSelect with undefined to exit
-    expect(handleAuthSelect).toHaveBeenCalledWith(undefined, SettingScope.User);
+    // Should call onSelect with undefined to exit
+    expect(onSelect).toHaveBeenCalledWith(undefined, SettingScope.User);
    unmount();
  });
 });
--- a/packages/cli/src/ui/auth/AuthDialog.tsx
+++ b/packages/cli/src/ui/auth/AuthDialog.tsx
@@ -8,14 +8,26 @@ import type React from 'react';
 import { useState } from 'react';
 import { AuthType } from '@qwen-code/qwen-code-core';
 import { Box, Text } from 'ink';
-import { SettingScope } from '../../config/settings.js';
+import { validateAuthMethod } from '../../config/auth.js';
+import { type LoadedSettings, SettingScope } from '../../config/settings.js';
 import { Colors } from '../colors.js';
 import { useKeypress } from '../hooks/useKeypress.js';
+import { OpenAIKeyPrompt } from '../components/OpenAIKeyPrompt.js';
 import { RadioButtonSelect } from '../components/shared/RadioButtonSelect.js';
-import { useUIState } from '../contexts/UIStateContext.js';
-import { useUIActions } from '../contexts/UIActionsContext.js';
-import { useSettings } from '../contexts/SettingsContext.js';
-import { t } from '../../i18n/index.js';
+
+interface AuthDialogProps {
+  onSelect: (
+    authMethod: AuthType | undefined,
+    scope: SettingScope,
+    credentials?: {
+      apiKey?: string;
+      baseUrl?: string;
+      model?: string;
+    },
+  ) => void;
+  settings: LoadedSettings;
+  initialErrorMessage?: string | null;
+}

 function parseDefaultAuthType(
  defaultAuthType: string | undefined,
@@ -29,41 +41,31 @@ function parseDefaultAuthType(
  return null;
 }

-export function AuthDialog(): React.JSX.Element {
-  const { pendingAuthType, authError } = useUIState();
-  const { handleAuthSelect: onAuthSelect } = useUIActions();
-  const settings = useSettings();
-
-  const [errorMessage, setErrorMessage] = useState<string | null>(null);
-  const [selectedIndex, setSelectedIndex] = useState<number | null>(null);
-
+export function AuthDialog({
+  onSelect,
+  settings,
+  initialErrorMessage,
+}: AuthDialogProps): React.JSX.Element {
+  const [errorMessage, setErrorMessage] = useState<string | null>(
+    initialErrorMessage || null,
+  );
+  const [showOpenAIKeyPrompt, setShowOpenAIKeyPrompt] = useState(false);
  const items = [
    {
      key: AuthType.QWEN_OAUTH,
-      label: t('Qwen OAuth'),
+      label: 'Qwen OAuth',
      value: AuthType.QWEN_OAUTH,
    },
-    {
-      key: AuthType.USE_OPENAI,
-      label: t('OpenAI'),
-      value: AuthType.USE_OPENAI,
-    },
+    { key: AuthType.USE_OPENAI, label: 'OpenAI', value: AuthType.USE_OPENAI },
  ];

  const initialAuthIndex = Math.max(
    0,
    items.findIndex((item) => {
-      // Priority 1: pendingAuthType
-      if (pendingAuthType) {
-        return item.value === pendingAuthType;
-      }
-
-      // Priority 2: settings.merged.security?.auth?.selectedType
      if (settings.merged.security?.auth?.selectedType) {
        return item.value === settings.merged.security?.auth?.selectedType;
      }

-      // Priority 3: QWEN_DEFAULT_AUTH_TYPE env var
      const defaultAuthType = parseDefaultAuthType(
        process.env['QWEN_DEFAULT_AUTH_TYPE'],
      );
@@ -71,29 +73,49 @@ export function AuthDialog(): React.JSX.Element {
        return item.value === defaultAuthType;
      }

-      // Priority 4: default to QWEN_OAUTH
      return item.value === AuthType.QWEN_OAUTH;
    }),
  );

-  const hasApiKey = Boolean(settings.merged.security?.auth?.apiKey);
-  const currentSelectedAuthType =
-    selectedIndex !== null
-      ? items[selectedIndex]?.value
-      : items[initialAuthIndex]?.value;
-
-  const handleAuthSelect = async (authMethod: AuthType) => {
-    setErrorMessage(null);
-    await onAuthSelect(authMethod, SettingScope.User);
+  const handleAuthSelect = (authMethod: AuthType) => {
+    if (authMethod === AuthType.USE_OPENAI) {
+      setShowOpenAIKeyPrompt(true);
+      setErrorMessage(null);
+    } else {
+      const error = validateAuthMethod(authMethod);
+      if (error) {
+        setErrorMessage(error);
+      } else {
+        setErrorMessage(null);
+        onSelect(authMethod, SettingScope.User);
+      }
+    }
  };

-  const handleHighlight = (authMethod: AuthType) => {
-    const index = items.findIndex((item) => item.value === authMethod);
-    setSelectedIndex(index);
+  const handleOpenAIKeySubmit = (
+    apiKey: string,
+    baseUrl: string,
+    model: string,
+  ) => {
+    setShowOpenAIKeyPrompt(false);
+    onSelect(AuthType.USE_OPENAI, SettingScope.User, {
+      apiKey,
+      baseUrl,
+      model,
+    });
+  };
+
+  const handleOpenAIKeyCancel = () => {
+    setShowOpenAIKeyPrompt(false);
+    setErrorMessage('OpenAI API key is required to use OpenAI authentication.');
  };

  useKeypress(
    (key) => {
+      if (showOpenAIKeyPrompt) {
+        return;
+      }
+
      if (key.name === 'escape') {
        // Prevent exit if there is an error message.
        // This means they user is not authenticated yet.
@@ -103,17 +125,37 @@ export function AuthDialog(): React.JSX.Element {
        if (settings.merged.security?.auth?.selectedType === undefined) {
          // Prevent exiting if no auth method is set
          setErrorMessage(
-            t(
-              'You must select an auth method to proceed. Press Ctrl+C again to exit.',
-            ),
+            'You must select an auth method to proceed. Press Ctrl+C again to exit.',
          );
          return;
        }
-        onAuthSelect(undefined, SettingScope.User);
+        onSelect(undefined, SettingScope.User);
      }
    },
    { isActive: true },
  );
+  const getDefaultOpenAIConfig = () => {
+    const fromSettings = settings.merged.security?.auth;
+    const modelSettings = settings.merged.model;
+    return {
+      apiKey: fromSettings?.apiKey || process.env['OPENAI_API_KEY'] || '',
+      baseUrl: fromSettings?.baseUrl || process.env['OPENAI_BASE_URL'] || '',
+      model: modelSettings?.name || process.env['OPENAI_MODEL'] || '',
+    };
+  };
+
+  if (showOpenAIKeyPrompt) {
+    const defaults = getDefaultOpenAIConfig();
+    return (
+      <OpenAIKeyPrompt
+        defaultApiKey={defaults.apiKey}
+        defaultBaseUrl={defaults.baseUrl}
+        defaultModel={defaults.model}
+        onSubmit={handleOpenAIKeySubmit}
+        onCancel={handleOpenAIKeyCancel}
+      />
+    );
+  }

  return (
    <Box
@@ -123,37 +165,27 @@ export function AuthDialog(): React.JSX.Element {
      padding={1}
      width="100%"
    >
-      <Text bold>{t('Get started')}</Text>
+      <Text bold>Get started</Text>
      <Box marginTop={1}>
-        <Text>{t('How would you like to authenticate for this project?')}</Text>
+        <Text>How would you like to authenticate for this project?</Text>
      </Box>
      <Box marginTop={1}>
        <RadioButtonSelect
          items={items}
          initialIndex={initialAuthIndex}
          onSelect={handleAuthSelect}
-          onHighlight={handleHighlight}
        />
      </Box>
-      {(authError || errorMessage) && (
+      {errorMessage && (
        <Box marginTop={1}>
-          <Text color={Colors.AccentRed}>{authError || errorMessage}</Text>
+          <Text color={Colors.AccentRed}>{errorMessage}</Text>
        </Box>
      )}
      <Box marginTop={1}>
-        <Text color={Colors.AccentPurple}>{t('(Use Enter to Set Auth)')}</Text>
+        <Text color={Colors.AccentPurple}>(Use Enter to Set Auth)</Text>
      </Box>
-      {hasApiKey && currentSelectedAuthType === AuthType.QWEN_OAUTH && (
-        <Box marginTop={1}>
-          <Text color={Colors.Gray}>
-            {t(
-              'Note: Your existing API key in settings.json will not be cleared when using Qwen OAuth. You can switch back to OpenAI authentication later if needed.',
-            )}
-          </Text>
-        </Box>
-      )}
      <Box marginTop={1}>
-        <Text>{t('Terms of Services and Privacy Notice for Qwen Code')}</Text>
+        <Text>Terms of Services and Privacy Notice for Qwen Code</Text>
      </Box>
      <Box marginTop={1}>
        <Text color={Colors.AccentBlue}>
--- a/packages/cli/src/ui/auth/AuthInProgress.tsx
+++ b/packages/cli/src/ui/auth/AuthInProgress.tsx
@@ -10,7 +10,6 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { theme } from '../semantic-colors.js';
 import { useKeypress } from '../hooks/useKeypress.js';
-import { t } from '../../i18n/index.js';

 interface AuthInProgressProps {
  onTimeout: () => void;
@@ -49,13 +48,13 @@ export function AuthInProgress({
    >
      {timedOut ? (
        <Text color={theme.status.error}>
-          {t('Authentication timed out. Please try again.')}
+          Authentication timed out. Please try again.
        </Text>
      ) : (
        <Box>
          <Text>
-            <Spinner type="dots" />{' '}
-            {t('Waiting for auth... (Press ESC or CTRL+C to cancel)')}
+            <Spinner type="dots" /> Waiting for auth... (Press ESC or CTRL+C to
+            cancel)
          </Text>
        </Box>
      )}
--- a/packages/cli/src/ui/auth/useAuth.ts
+++ b/packages/cli/src/ui/auth/useAuth.ts
@@ -4,29 +4,31 @@
 * SPDX-License-Identifier: Apache-2.0
 */

-import type { Config } from '@qwen-code/qwen-code-core';
+import { useState, useCallback, useEffect } from 'react';
+import type { LoadedSettings, SettingScope } from '../../config/settings.js';
+import type { AuthType, Config } from '@qwen-code/qwen-code-core';
 import {
-  AuthEvent,
-  AuthType,
  clearCachedCredentialFile,
  getErrorMessage,
-  logAuth,
 } from '@qwen-code/qwen-code-core';
-import { useCallback, useEffect, useState } from 'react';
-import type { LoadedSettings, SettingScope } from '../../config/settings.js';
-import type { OpenAICredentials } from '../components/OpenAIKeyPrompt.js';
-import { useQwenAuth } from '../hooks/useQwenAuth.js';
-import { AuthState, MessageType } from '../types.js';
-import type { HistoryItem } from '../types.js';
-import { t } from '../../i18n/index.js';
+import { AuthState } from '../types.js';
+import { validateAuthMethod } from '../../config/auth.js';

-export type { QwenAuthState } from '../hooks/useQwenAuth.js';
-
-export const useAuthCommand = (
+export function validateAuthMethodWithSettings(
+  authType: AuthType,
  settings: LoadedSettings,
-  config: Config,
-  addItem: (item: Omit<HistoryItem, 'id'>, timestamp: number) => void,
-) => {
+): string | null {
+  const enforcedType = settings.merged.security?.auth?.enforcedType;
+  if (enforcedType && enforcedType !== authType) {
+    return `Authentication is enforced to be ${enforcedType}, but you are currently using ${authType}.`;
+  }
+  if (settings.merged.security?.auth?.useExternal) {
+    return null;
+  }
+  return validateAuthMethod(authType);
+}
+
+export const useAuthCommand = (settings: LoadedSettings, config: Config) => {
  const unAuthenticated =
    settings.merged.security?.auth?.selectedType === undefined;

@@ -38,14 +40,6 @@ export const useAuthCommand = (

  const [isAuthenticating, setIsAuthenticating] = useState(false);
  const [isAuthDialogOpen, setIsAuthDialogOpen] = useState(unAuthenticated);
-  const [pendingAuthType, setPendingAuthType] = useState<AuthType | undefined>(
-    undefined,
-  );
-
-  const { qwenAuthState, cancelQwenAuth } = useQwenAuth(
-    pendingAuthType,
-    isAuthenticating,
-  );

  const onAuthError = useCallback(
    (error: string | null) => {
@@ -58,136 +52,90 @@ export const useAuthCommand = (
    [setAuthError, setAuthState],
  );

-  const handleAuthFailure = useCallback(
-    (error: unknown) => {
-      setIsAuthenticating(false);
-      const errorMessage = t('Failed to authenticate. Message: {{message}}', {
-        message: getErrorMessage(error),
-      });
-      onAuthError(errorMessage);
-
-      // Log authentication failure
-      if (pendingAuthType) {
-        const authEvent = new AuthEvent(
-          pendingAuthType,
-          'manual',
-          'error',
-          errorMessage,
-        );
-        logAuth(config, authEvent);
+  // Authentication flow
+  useEffect(() => {
+    const authFlow = async () => {
+      const authType = settings.merged.security?.auth?.selectedType;
+      if (isAuthDialogOpen || !authType) {
+        return;
+      }
+
+      const validationError = validateAuthMethodWithSettings(
+        authType,
+        settings,
+      );
+      if (validationError) {
+        onAuthError(validationError);
+        return;
      }
-    },
-    [onAuthError, pendingAuthType, config],
-  );

-  const handleAuthSuccess = useCallback(
-    async (
-      authType: AuthType,
-      scope: SettingScope,
-      credentials?: OpenAICredentials,
-    ) => {
      try {
-        settings.setValue(scope, 'security.auth.selectedType', authType);
+        setIsAuthenticating(true);
+        await config.refreshAuth(authType);
+        console.log(`Authenticated via "${authType}".`);
+        setAuthError(null);
+        setAuthState(AuthState.Authenticated);
+      } catch (e) {
+        onAuthError(`Failed to login. Message: ${getErrorMessage(e)}`);
+      } finally {
+        setIsAuthenticating(false);
+      }
+    };

-        // Only update credentials if not switching to QWEN_OAUTH,
-        // so that OpenAI credentials are preserved when switching to QWEN_OAUTH.
-        if (authType !== AuthType.QWEN_OAUTH && credentials) {
-          if (credentials?.apiKey != null) {
+    void authFlow();
+  }, [isAuthDialogOpen, settings, config, onAuthError]);
+
+  // Handle auth selection from dialog
+  const handleAuthSelect = useCallback(
+    async (
+      authType: AuthType | undefined,
+      scope: SettingScope,
+      credentials?: {
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+      },
+    ) => {
+      if (authType) {
+        await clearCachedCredentialFile();
+
+        // Save OpenAI credentials if provided
+        if (credentials) {
+          // Update Config's internal generationConfig before calling refreshAuth
+          // This ensures refreshAuth has access to the new credentials
+          config.updateCredentials({
+            apiKey: credentials.apiKey,
+            baseUrl: credentials.baseUrl,
+            model: credentials.model,
+          });
+
+          // Also set environment variables for compatibility with other parts of the code
+          if (credentials.apiKey) {
            settings.setValue(
              scope,
              'security.auth.apiKey',
              credentials.apiKey,
            );
          }
-          if (credentials?.baseUrl != null) {
+          if (credentials.baseUrl) {
            settings.setValue(
              scope,
              'security.auth.baseUrl',
              credentials.baseUrl,
            );
          }
-          if (credentials?.model != null) {
+          if (credentials.model) {
            settings.setValue(scope, 'model.name', credentials.model);
          }
-          await clearCachedCredentialFile();
        }
-      } catch (error) {
-        handleAuthFailure(error);
-        return;
+
+        settings.setValue(scope, 'security.auth.selectedType', authType);
      }

-      setAuthError(null);
-      setAuthState(AuthState.Authenticated);
-      setPendingAuthType(undefined);
      setIsAuthDialogOpen(false);
-      setIsAuthenticating(false);
-
-      // Log authentication success
-      const authEvent = new AuthEvent(authType, 'manual', 'success');
-      logAuth(config, authEvent);
-
-      // Show success message
-      addItem(
-        {
-          type: MessageType.INFO,
-          text: t('Authenticated successfully with {{authType}} credentials.', {
-            authType,
-          }),
-        },
-        Date.now(),
-      );
-    },
-    [settings, handleAuthFailure, config, addItem],
-  );
-
-  const performAuth = useCallback(
-    async (
-      authType: AuthType,
-      scope: SettingScope,
-      credentials?: OpenAICredentials,
-    ) => {
-      try {
-        await config.refreshAuth(authType);
-        handleAuthSuccess(authType, scope, credentials);
-      } catch (e) {
-        handleAuthFailure(e);
-      }
-    },
-    [config, handleAuthSuccess, handleAuthFailure],
-  );
-
-  const handleAuthSelect = useCallback(
-    async (
-      authType: AuthType | undefined,
-      scope: SettingScope,
-      credentials?: OpenAICredentials,
-    ) => {
-      if (!authType) {
-        setIsAuthDialogOpen(false);
-        setAuthError(null);
-        return;
-      }
-
-      setPendingAuthType(authType);
      setAuthError(null);
-      setIsAuthDialogOpen(false);
-      setIsAuthenticating(true);
-
-      if (authType === AuthType.USE_OPENAI) {
-        if (credentials) {
-          config.updateCredentials({
-            apiKey: credentials.apiKey,
-            baseUrl: credentials.baseUrl,
-            model: credentials.model,
-          });
-          await performAuth(authType, scope, credentials);
-        }
-        return;
-      }
-
-      await performAuth(authType, scope);
    },
-    [config, performAuth],
+    [settings, config],
  );

  const openAuthDialog = useCallback(() => {
@@ -195,51 +143,8 @@ export const useAuthCommand = (
  }, []);

  const cancelAuthentication = useCallback(() => {
-    if (isAuthenticating && pendingAuthType === AuthType.QWEN_OAUTH) {
-      cancelQwenAuth();
-    }
-
-    // Log authentication cancellation
-    if (isAuthenticating && pendingAuthType) {
-      const authEvent = new AuthEvent(pendingAuthType, 'manual', 'cancelled');
-      logAuth(config, authEvent);
-    }
-
-    // Do not reset pendingAuthType here, persist the previously selected type.
    setIsAuthenticating(false);
-    setIsAuthDialogOpen(true);
-    setAuthError(null);
-  }, [isAuthenticating, pendingAuthType, cancelQwenAuth, config]);
-
-  /**
-   /**
-    * We previously used a useEffect to trigger authentication automatically when
-    * settings.security.auth.selectedType changed. This caused problems: if authentication failed,
-    * the UI could get stuck, since settings.json would update before success. Now, we
-    * update selectedType in settings only when authentication fully succeeds.
-    * Authentication is triggered explicitly—either during initial app startup or when the
-    * user switches methods—not reactively through settings changes. This avoids repeated
-    * or broken authentication cycles.
-    */
-  useEffect(() => {
-    const defaultAuthType = process.env['QWEN_DEFAULT_AUTH_TYPE'];
-    if (
-      defaultAuthType &&
-      ![AuthType.QWEN_OAUTH, AuthType.USE_OPENAI].includes(
-        defaultAuthType as AuthType,
-      )
-    ) {
-      onAuthError(
-        t(
-          'Invalid QWEN_DEFAULT_AUTH_TYPE value: "{{value}}". Valid values are: {{validValues}}',
-          {
-            value: defaultAuthType,
-            validValues: [AuthType.QWEN_OAUTH, AuthType.USE_OPENAI].join(', '),
-          },
-        ),
-      );
-    }
-  }, [onAuthError]);
+  }, []);

  return {
    authState,
@@ -248,8 +153,6 @@ export const useAuthCommand = (
    onAuthError,
    isAuthDialogOpen,
    isAuthenticating,
-    pendingAuthType,
-    qwenAuthState,
    handleAuthSelect,
    openAuthDialog,
    cancelAuthentication,
--- a/packages/cli/src/ui/commands/aboutCommand.ts
+++ b/packages/cli/src/ui/commands/aboutCommand.ts
@@ -8,13 +8,10 @@ import type { SlashCommand } from './types.js';
 import { CommandKind } from './types.js';
 import { MessageType, type HistoryItemAbout } from '../types.js';
 import { getExtendedSystemInfo } from '../../utils/systemInfo.js';
-import { t } from '../../i18n/index.js';

 export const aboutCommand: SlashCommand = {
  name: 'about',
-  get description() {
-    return t('show version info');
-  },
+  description: 'show version info',
  kind: CommandKind.BUILT_IN,
  action: async (context) => {
    const systemInfo = await getExtendedSystemInfo(context);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mingholy.lmh	0afc50970f	Merge branch 'main' of github.com:QwenLM/qwen-code into mingholy/fix/acp-slashcommands	2025-11-18 13:23:12 +08:00
mingholy.lmh	11ae56c18a	fix: basic slash command support	2025-11-13 10:32:28 +08:00