Refine ADK migration design doc

Auth:
- Coast Assist / LOGIN_WITH_GOOGLE uses AuthClient.request() against a
  Code Assist backend, NOT the standard Gemini API
- GcliAgentModel must extend BaseLlm directly with dual transport
  (API-key via httpOptions.headers, Coast Assist via AuthClient.request())
- OAuth flow, token refresh, credential caching all work as-is

Telemetry:
- Stream-interceptor approach replaced with BasePlugin recommendation
- ClearcutTelemetryPlugin for token counts (afterModelCallback),
  per-tool timing (beforeToolCallback/afterToolCallback with functionCallId),
  agent lifecycle, and model errors
- Corrects earlier claim: token usage IS available on ADK events
  (llm_agent.ts spreads LlmResponse into events)
- HTTP-level metrics captured in GcliAgentModel wrapper
- ~70% of Clearcut metrics stay in existing call sites unchanged

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.gemini/settings.json

@@ -2,6 +2,7 @@
   "experimental": {
     "extensionReloading": true,
     "modelSteering": true,
+    "memoryManager": false,
     "topicUpdateNarration": true
   },
   "general": {

.gemini/skills/behavioral-evals/references/fixing.md

@@ -33,35 +33,6 @@ evaluation.
     - **Warning**: Do not lose test fidelity by making prompts too direct/easy.
     - **Primary Fix Trigger**: Adjust tool descriptions, system prompts
       (`snippets.ts`), or **modules that contribute to the prompt template**.
-    - Fixes should generally try to improve the prompt
-      `@packages/core/src/prompts/snippets.ts` first.
-    - **Instructional Generality**: Changes to the system prompt should aim to
-      be as general as possible while still accomplishing the goal. Specificity
-      should be added only as needed.
-      - **Principle**: Instead of creating "forbidden lists" for specific syntax
-        (e.g., "Don't use `Object.create()`"), formulate a broader engineering
-        principle that covers the underlying issue (e.g., "Prioritize explicit
-        composition over hidden prototype manipulation"). This improves
-        steerability across a wider range of similar scenarios.
-      - _Low Specificity_: "Follow ecosystem best practices"
-      - _Medium Specificity_: "Utilize OOP and functional best practices, as
-        applicable"
-      - _High Specificity_: Provide ecosystem-specific hints as examples of a
-        broader principle rather than direct instructions. e.g., "NEVER use
-        hacks like bypassing the type system or employing 'hidden' logic (e.g.:
-        reflection, prototype manipulation). Instead, use explicit and idiomatic
-        language features (e.g.: type guards, explicit class instantiation, or
-        object spread) that maintain structural integrity."
-    - **Prompt Simplification**: Once the test is passing, use `ask_user` to
-      determine if prompt simplification is desired.
-      - **Criteria**: Simplification should be attempted only if there are
-        related clauses that can be de-duplicated or reparented under a single
-        heading.
-      - **Verification**: As part of simplification, you MUST identify and run
-        any behavioral eval tests that might be affected by the changes to
-        ensure no regressions are introduced.
-    - Test fixes should not "cheat" by changing a test's `GEMINI.md` file or by
-      updating the test's prompt to instruct it to not repro the bug.
     - **Warning**: Prompts have multiple configurations; ensure your fix targets
       the correct config for the model in question.
 4.  **Architecture Options**: If prompt or instruction tuning triggers no

.github/workflows/chained_e2e.yml

@@ -335,8 +335,6 @@ jobs:
         env:
           GEMINI_API_KEY: '${{ secrets.GEMINI_API_KEY }}'
           GEMINI_MODEL: 'gemini-3-pro-preview'
-          # Only run always passes behavioral tests.
-          EVAL_SUITE_TYPE: 'behavioral'
           # Disable Vitest internal retries to avoid double-retrying;
           # custom retry logic is handled in evals/test-helper.ts
           VITEST_RETRY: 0

.github/workflows/eval-pr.yml

@@ -1,7 +1,7 @@
 name: 'Evals: PR Evaluation & Regression'
 
 on:
-  pull_request_target:
+  pull_request:
     types: ['opened', 'synchronize', 'reopened', 'ready_for_review']
     paths:
       - 'packages/core/src/prompts/**'
@@ -23,73 +23,13 @@ permissions:
   actions: 'read'
 
 jobs:
-  detect-changes:
-    name: 'Detect Steering Changes'
-    runs-on: 'gemini-cli-ubuntu-16-core'
-    # Security: pull_request_target allows secrets, so we must gate carefully.
-    # Detection should not run code from the fork.
-    if: "github.repository == 'google-gemini/gemini-cli' && github.event.pull_request.draft == false"
-    outputs:
-      SHOULD_RUN: '${{ steps.detect.outputs.SHOULD_RUN }}'
-      STEERING_DETECTED: '${{ steps.detect.outputs.STEERING_DETECTED }}'
-    steps:
-      - name: 'Checkout'
-        uses: 'actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955' # ratchet:actions/checkout@v5
-        with:
-          # Check out the trusted code from main for detection
-          fetch-depth: 0
-
-      - name: 'Detect Steering Changes'
-        id: 'detect'
-        env:
-          # Use the PR's head SHA for comparison without checking it out
-          PR_HEAD_SHA: '${{ github.event.pull_request.head.sha }}'
-        run: |
-          # Fetch the fork's PR branch for analysis
-          git fetch origin pull/${{ github.event.pull_request.number }}/head:pr-head
-
-          # Run the trusted script from main
-          SHOULD_RUN=$(node scripts/changed_prompt.js)
-          STEERING_DETECTED=$(node scripts/changed_prompt.js --steering-only)
-          echo "SHOULD_RUN=$SHOULD_RUN" >> "$GITHUB_OUTPUT"
-          echo "STEERING_DETECTED=$STEERING_DETECTED" >> "$GITHUB_OUTPUT"
-
-      - name: 'Notify Approval Required'
-        if: "steps.detect.outputs.SHOULD_RUN == 'true'"
-        env:
-          GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
-        run: |
-          RUN_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-          COMMENT_BODY="### 🛑 Action Required: Evaluation Approval
-
-          Steering changes have been detected in this PR. To prevent regressions, a maintainer must approve the evaluation run before this PR can be merged.
-
-          **Maintainers:**
-          1. Go to the [**Workflow Run Summary**]($RUN_URL).
-          2. Click the yellow **'Review deployments'** button.
-          3. Select the **'eval-gate'** environment and click **'Approve'**.
-
-          Once approved, the evaluation results will be posted here automatically.
-
-          <!-- eval-approval-notification -->"
-
-          # Check if comment already exists to avoid spamming
-          COMMENT_ID=$(gh pr view ${{ github.event.pull_request.number }} --json comments --jq '.comments[] | select(.body | contains("<!-- eval-approval-notification -->")) | .url' | grep -oE "[0-9]+$" | head -n 1)
-
-          if [ -z "$COMMENT_ID" ]; then
-            gh pr comment ${{ github.event.pull_request.number }} --body "$COMMENT_BODY"
-          else
-            echo "Updating existing notification comment $COMMENT_ID..."
-            gh api -X PATCH "repos/${{ github.repository }}/issues/comments/$COMMENT_ID" -F body="$COMMENT_BODY"
-          fi
-
   pr-evaluation:
     name: 'Evaluate Steering & Regressions'
-    needs: 'detect-changes'
-    if: "needs.detect-changes.outputs.SHOULD_RUN == 'true'"
-    # Manual approval gate via environment
-    environment: 'eval-gate'
     runs-on: 'gemini-cli-ubuntu-16-core'
+    if: "github.repository == 'google-gemini/gemini-cli' && (github.event_name != 'pull_request' || (github.event.pull_request.draft == false && github.event.pull_request.head.repo.full_name == github.repository))"
+    # External contributors' PRs will wait for approval in this environment
+    environment: |-
+      ${{ (github.event.pull_request.head.repo.full_name == github.repository) && 'internal' || 'external-evals' }}
     env:
       # CENTRALIZED MODEL LIST
       MODEL_LIST: 'gemini-3-flash-preview'
@@ -98,40 +38,32 @@ jobs:
       - name: 'Checkout'
         uses: 'actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955' # ratchet:actions/checkout@v5
         with:
-          # Check out the fork's PR code for the actual evaluation
-          # This only runs AFTER manual approval
-          ref: '${{ github.event.pull_request.head.sha }}'
           fetch-depth: 0
 
-      - name: 'Remove Approval Notification'
-        # Run even if other steps fail, to ensure we clean up the "Action Required" message
-        if: 'always()'
-        env:
-          GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
-          PR_NUMBER: '${{ github.event.pull_request.number }}'
-        run: |
-          echo "Debug: PR_NUMBER is '$PR_NUMBER'"
-          # Search for the notification comment by its hidden tag
-          COMMENT_ID=$(gh pr view "$PR_NUMBER" --json comments --jq '.comments[] | select(.body | contains("<!-- eval-approval-notification -->")) | .url' | grep -oE "[0-9]+$" | head -n 1)
-          if [ -n "$COMMENT_ID" ]; then
-            echo "Removing notification comment $COMMENT_ID now that run is approved..."
-            gh api -X DELETE "repos/${{ github.repository }}/issues/comments/$COMMENT_ID"
-          fi
-
       - name: 'Set up Node.js'
         uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4.4.0
         with:
           node-version-file: '.nvmrc'
           cache: 'npm'
 
+      - name: 'Detect Steering Changes'
+        id: 'detect'
+        run: |
+          SHOULD_RUN=$(node scripts/changed_prompt.js)
+          STEERING_DETECTED=$(node scripts/changed_prompt.js --steering-only)
+          echo "SHOULD_RUN=$SHOULD_RUN" >> "$GITHUB_OUTPUT"
+          echo "STEERING_DETECTED=$STEERING_DETECTED" >> "$GITHUB_OUTPUT"
+
       - name: 'Install dependencies'
+        if: "steps.detect.outputs.SHOULD_RUN == 'true'"
         run: 'npm ci'
 
       - name: 'Build project'
+        if: "steps.detect.outputs.SHOULD_RUN == 'true'"
         run: 'npm run build'
 
       - name: 'Analyze PR Content (Guidance)'
-        if: "needs.detect-changes.outputs.STEERING_DETECTED == 'true'"
+        if: "steps.detect.outputs.STEERING_DETECTED == 'true'"
         id: 'analysis'
         env:
           GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
@@ -149,6 +81,7 @@ jobs:
           fi
 
       - name: 'Execute Regression Check'
+        if: "steps.detect.outputs.SHOULD_RUN == 'true'"
         env:
           GEMINI_API_KEY: '${{ secrets.GEMINI_API_KEY }}'
           GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
@@ -163,7 +96,7 @@ jobs:
           fi
 
       - name: 'Post or Update PR Comment'
-        if: "always() && (needs.detect-changes.outputs.STEERING_DETECTED == 'true' || env.REPORT_FILE != '')"
+        if: "always() && (steps.detect.outputs.STEERING_DETECTED == 'true' || env.REPORT_FILE != '')"
         env:
           GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
         run: |
@@ -174,7 +107,7 @@ jobs:
               echo ""
             fi
 
-            if [[ "${{ needs.detect-changes.outputs.STEERING_DETECTED }}" == "true" ]]; then
+            if [[ "${{ steps.detect.outputs.STEERING_DETECTED }}" == "true" ]]; then
               echo "### 🧠 Model Steering Guidance"
               echo ""
               echo "This PR modifies files that affect the model's behavior (prompts, tools, or instructions)."

.github/workflows/evals-nightly.yml

@@ -5,18 +5,10 @@ on:
     - cron: '0 1 * * *' # Runs at 1 AM every day
   workflow_dispatch:
     inputs:
-      suite_type:
-        description: 'Suite type to run'
-        type: 'choice'
-        options:
-          - 'behavioral'
-          - 'component-level'
-          - 'hero-scenario'
-        default: 'behavioral'
-      suite_name:
-        description: 'Specific suite name to run'
-        required: false
-        type: 'string'
+      run_all:
+        description: 'Run all evaluations (including usually passing)'
+        type: 'boolean'
+        default: true
       test_name_pattern:
         description: 'Test name pattern or file name'
         required: false
@@ -67,9 +59,7 @@ jobs:
         env:
           GEMINI_API_KEY: '${{ secrets.GEMINI_API_KEY }}'
           GEMINI_MODEL: '${{ matrix.model }}'
-          RUN_EVALS: 'true'
-          EVAL_SUITE_TYPE: "${{ github.event.inputs.suite_type || 'behavioral' }}"
-          EVAL_SUITE_NAME: '${{ github.event.inputs.suite_name }}'
+          RUN_EVALS: "${{ github.event.inputs.run_all != 'false' }}"
           TEST_NAME_PATTERN: '${{ github.event.inputs.test_name_pattern }}'
           # Disable Vitest internal retries to avoid double-retrying;
           # custom retry logic is handled in evals/test-helper.ts

.github/workflows/memory-nightly.yml

@@ -1,33 +0,0 @@
-name: 'Memory Tests: Nightly'
-
-on:
-  schedule:
-    - cron: '0 2 * * *' # Runs at 2 AM every day
-  workflow_dispatch: # Allow manual trigger
-
-permissions:
-  contents: 'read'
-
-jobs:
-  memory-test:
-    name: 'Run Memory Usage Tests'
-    runs-on: 'gemini-cli-ubuntu-16-core'
-    if: "github.repository == 'google-gemini/gemini-cli'"
-    steps:
-      - name: 'Checkout'
-        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
-
-      - name: 'Set up 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: 'Build project'
-        run: 'npm run build'
-
-      - name: 'Run Memory Tests'
-        run: 'npm run test:memory'

.github/workflows/perf-nightly.yml

@@ -1,33 +0,0 @@
-name: 'Performance Tests: Nightly'
-
-on:
-  schedule:
-    - cron: '0 3 * * *' # Runs at 3 AM every day
-  workflow_dispatch: # Allow manual trigger
-
-permissions:
-  contents: 'read'
-
-jobs:
-  perf-test:
-    name: 'Run Performance Usage Tests'
-    runs-on: 'gemini-cli-ubuntu-16-core'
-    if: "github.repository == 'google-gemini/gemini-cli'"
-    steps:
-      - name: 'Checkout'
-        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
-
-      - name: 'Set up 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: 'Build project'
-        run: 'npm run build'
-
-      - name: 'Run Performance Tests'
-        run: 'npm run test:perf'

.gitignore

@@ -48,7 +48,6 @@ packages/cli/src/generated/
 packages/core/src/generated/
 packages/devtools/src/_client-assets.ts
 .integration-tests/
-.perf-tests/
 packages/vscode-ide-companion/*.vsix
 packages/cli/download-ripgrep*/
 
@@ -65,6 +64,3 @@ gemini-debug.log
 evals/logs/
 
 temp_agents/
-
-# conductor extension and planning directories
-conductor/

GEMINI.md

@@ -44,13 +44,6 @@ powerful tool for developers.
 - **Test Commands:**
   - **Unit (All):** `npm run test`
   - **Integration (E2E):** `npm run test:e2e`
-  - > **NOTE**: Please run the memory and perf tests locally **only if** you are
-    > implementing changes related to those test areas. Otherwise skip these
-    > tests locally and rely on CI to run them on nightly builds.
-  - **Memory (Nightly):** `npm run test:memory` (Runs memory regression tests
-    against baselines. Excluded from `preflight`, run nightly.)
-  - **Performance (Nightly):** `npm run test:perf` (Runs CPU performance
-    regression tests against baselines. Excluded from `preflight`, run nightly.)
   - **Workspace-Specific:** `npm test -w <pkg> -- <path>` (Note: `<path>` must
     be relative to the workspace root, e.g.,
     `-w @google/gemini-cli-core -- src/routing/modelRouterService.test.ts`)

docs/adk-replat/NOTES-adk-alignment.md

@@ -0,0 +1,529 @@
+# ADK-TS Alignment Pass
+
+Every interface in our outline must map cleanly to ADK-TS. This document
+verifies that mapping field-by-field, identifies gaps, and confirms
+HITL/plugin/transfer patterns work.
+
+Source: ADK-TS v0.4.0 at `/Users/adamfweidman/Desktop/adk-int/adk-js/core/src/`
+
+---
+
+## 1. AgentDescriptor ↔ ADK Agent Hierarchy
+
+### Field-by-field mapping
+
+| AgentDescriptor field        | ADK-TS source                                | Notes                                                                                                                                                    |
+| ---------------------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`                       | `BaseAgent.name`                             | Direct. ADK validates it's a valid JS identifier.                                                                                                        |
+| `displayName`                | —                                            | ADK doesn't have this. No conflict.                                                                                                                      |
+| `description`                | `BaseAgent.description` (optional in ADK)    | Direct. Used for model routing in AgentTool.                                                                                                             |
+| `executor`                   | —                                            | New concept. ADK agents are always 'adk'. Adapter sets this.                                                                                             |
+| `inputSchema`                | `LlmAgent.inputSchema` (Zod or JSON Schema)  | Direct. ADK's AgentTool uses this for tool parameter generation.                                                                                         |
+| `outputSchema`               | `LlmAgent.outputSchema` (Zod or JSON Schema) | Direct. ADK uses for structured output + AgentTool response.                                                                                             |
+| `capabilities`               | —                                            | New concept. Adapter infers from agent type: LlmAgent gets `['elicitation', 'streaming', 'host_tool_execution']`, LoopAgent gets `['composition']`, etc. |
+| `ownTools`                   | `LlmAgent.tools: ToolUnion[]`                | Maps via ToolDescriptor adapter. ADK tools have `name`, `description`, `_getDeclaration()` which returns JSON Schema.                                    |
+| `requiredTools`              | —                                            | New concept. ADK agents don't declare required host tools. Adapter can infer from tool references.                                                       |
+| `subAgents`                  | `BaseAgent.subAgents: BaseAgent[]`           | Recursive. Each sub-agent becomes a nested AgentDescriptor.                                                                                              |
+| `constraints.maxTurns`       | `RunConfig.maxLlmCalls` (default 500)        | Maps, though semantics differ slightly (LLM calls vs turns).                                                                                             |
+| `constraints.maxTimeMinutes` | —                                            | ADK doesn't have time limits. No conflict — host enforces.                                                                                               |
+| `constraints.maxBudgetUsd`   | —                                            | ADK doesn't have budget. No conflict — host enforces.                                                                                                    |
+| `metadata`                   | —                                            | New concept. Adapter can populate from agent registration context.                                                                                       |
+
+### ADK-specific fields NOT in AgentDescriptor
+
+| ADK field                           | Where it lives | Our approach                                                                                               |
+| ----------------------------------- | -------------- | ---------------------------------------------------------------------------------------------------------- |
+| `instruction` / `globalInstruction` | LlmAgent       | Executor-internal. Not in descriptor (it's runtime config, not identity).                                  |
+| `model`                             | LlmAgent       | Goes in ExecutionOptions.model or executor-internal config.                                                |
+| `generateContentConfig`             | LlmAgent       | Executor-internal.                                                                                         |
+| `disallowTransferToParent/Peers`    | LlmAgent       | Could be `constraints` or `_meta`. Transfer policy is host-enforced.                                       |
+| `includeContents`                   | LlmAgent       | Executor-internal (context management).                                                                    |
+| `outputKey`                         | LlmAgent       | Executor-internal (state management).                                                                      |
+| `beforeModelCallback`, etc.         | LlmAgent       | Executor-internal. These are ADK's callback system — our LifecycleInterceptor is the interface equivalent. |
+
+### Verdict: CLEAN MAPPING
+
+AgentDescriptor captures everything needed to describe an ADK agent externally.
+ADK-specific runtime config (instruction, model, callbacks) stays inside the
+executor — exactly right for the descriptor/executor separation.
+
+**Key ADK pattern preserved:** AgentTool wraps an agent as a tool using
+`inputSchema` for parameters and `description` for the tool description. Our
+AgentDescriptor has both, so SubagentTool can do the same thing.
+
+---
+
+## 2. AgentSession ↔ ADK Runner
+
+### Method mapping
+
+| AgentSession method     | ADK-TS equivalent                                               | How adapter works                                                                                                                                                   |
+| ----------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `stream(data, options)` | `Runner.runAsync({ userId, sessionId, newMessage, runConfig })` | Adapter creates/loads session, maps data+options → runAsync params, wraps Event generator → AgentEvent generator. Each `stream()` call triggers a new `runAsync()`. |
+| `update(config)`        | No direct equivalent                                            | ADK doesn't support mid-stream config changes. Adapter queues updates for next `runAsync()` call.                                                                   |
+| `steer(data)`           | No direct equivalent                                            | ADK doesn't support mid-stream intervention. Adapter can queue for next invocation or ignore.                                                                       |
+| `abort()`               | No direct equivalent                                            | ADK uses `invocationContext.endInvocation = true`. Adapter sets this flag. Could also use AbortController.                                                          |
+
+### ExecutionRequest → Runner.runAsync mapping
+
+| ExecutionRequest field      | ADK mapping                                                      |
+| --------------------------- | ---------------------------------------------------------------- |
+| `descriptor`                | Used to find/create the BaseAgent instance                       |
+| `input`                     | → `newMessage: Content` (converted from ContentPart[] → Content) |
+| `sessionRef`                | → `sessionId` (string) or creates session from SessionSnapshot   |
+| `forkSession`               | Adapter clones session before running                            |
+| `options.tools`             | → merged into agent's `tools` config                             |
+| `options.model`             | → `LlmAgent.model` override                                      |
+| `options.hostToolExecution` | → `RunConfig.pauseOnToolCalls: true`                             |
+| `options.streaming`         | → `RunConfig.streamingMode`                                      |
+| `options.permissionMode`    | → SecurityPlugin config                                          |
+| `signal`                    | → wired to `invocationContext.endInvocation`                     |
+
+### HITL: How pauseOnToolCalls works end-to-end
+
+This is the critical path. Here's the full flow:
+
+```
+1. LLM returns tool call (FunctionCall in Event)
+2. ADK checks RunConfig.pauseOnToolCalls === true
+3. ADK sets invocationContext.endInvocation = true
+4. ADK yields the Event (with FunctionCall) and stops
+5. Runner.runAsync() generator completes
+
+   --- OUR INTERFACE BOUNDARY ---
+
+6. Adapter translates ADK Event → ToolRequestEvent
+7. Host receives ToolRequestEvent from session.stream() generator
+8. Host runs policy check (PolicyEvaluator.evaluate())
+9. Host fires hooks (LifecycleInterceptor.fire('before_tool', ...))
+10. If policy allows → Host executes tool → gets ToolResultData
+11. Host calls session.stream({ kind: 'tool_result', ... }) to get next stream
+
+   --- BACK INTO ADK ---
+
+12. Adapter receives tool result
+13. Adapter creates FunctionResponse Content
+14. Adapter calls Runner.runAsync() again with FunctionResponse as newMessage
+15. ADK loads session (has prior tool call event)
+16. ADK resumes agent with tool response
+17. Loop continues from step 1
+```
+
+**Why this works:** ADK's `pauseOnToolCalls` was designed exactly for this
+pattern — external tool execution by a host. The adapter translates between
+ADK's "end invocation + resume with FunctionResponse" pattern and our
+"ToolRequestEvent + send(tool_result)" pattern.
+
+**Key insight:** Each `session.stream()` call triggers a new `Runner.runAsync()`
+call. This means each ADK "invocation" maps to one `stream()` call. The session
+persists state across invocations. Mid-stream `update()` and `steer()` calls are
+queued for the next invocation since ADK doesn't support mid-turn changes.
+
+### HITL: ToolConfirmation flow
+
+ADK also has a separate ToolConfirmation pattern (via
+`context.requestConfirmation()`):
+
+```
+1. beforeToolCallback calls context.requestConfirmation({ hint: '...' })
+2. This sets eventActions.requestedToolConfirmations[functionCallId]
+3. ADK yields event with requestedToolConfirmations populated
+4. Runner completes (invocation ends)
+
+   --- OUR INTERFACE BOUNDARY ---
+
+5. Adapter sees requestedToolConfirmations in event
+6. Adapter translates → ElicitationRequest { kind: 'tool_confirmation', ... }
+7. Host renders confirmation UI
+8. User responds → ElicitationResponse { action: 'accept' | 'decline' }
+
+   --- BACK INTO ADK ---
+
+9. Adapter receives elicitation response
+10. If accepted: Adapter creates FunctionResponse with confirmed=true
+11. Calls Runner.runAsync() with FunctionResponse
+12. ADK's SecurityPlugin or callback reads confirmation from session
+13. Tool executes
+```
+
+**Maps to our ElicitationRequest:** ADK's `ToolConfirmation.hint` →
+`ElicitationRequest.message`. ADK's `ToolConfirmation.payload` →
+`ElicitationRequest.context`. The `kind: 'tool_confirmation'` is the
+discriminator.
+
+### HITL: Auth request flow
+
+```
+1. Tool or callback calls context.requestCredential(authConfig)
+2. Sets eventActions.requestedAuthConfigs[functionCallId]
+3. Event yields, invocation ends
+
+   --- OUR INTERFACE BOUNDARY ---
+
+4. Adapter sees requestedAuthConfigs
+5. Translates → ElicitationRequest { kind: 'auth_required', context: authConfig }
+6. User provides credentials
+7. ElicitationResponse { action: 'accept', content: { credential: ... } }
+
+   --- BACK INTO ADK ---
+
+8. Adapter stores credential via CredentialService
+9. Calls Runner.runAsync() again
+10. Tool calls context.getAuthResponse() → gets credential
+```
+
+**Maps to our ElicitationRequest:** ADK's auth pattern is just another
+elicitation kind. This validates our generic elicitation design — it handles
+tool confirmation, auth, and any future interaction type.
+
+---
+
+## 3. AgentEvent ↔ ADK Event
+
+### Event type mapping
+
+| Our AgentEvent        | ADK Event pattern                                                                 | Adapter translation                           |
+| --------------------- | --------------------------------------------------------------------------------- | --------------------------------------------- |
+| `InitializeEvent`     | First event from Runner.runAsync()                                                | Adapter emits on first stream() call          |
+| `SessionUpdateEvent`  | `eventActions.stateDelta`                                                         | Adapter emits when stateDelta is non-empty    |
+| `MessageEvent`        | `event.content` with text Parts                                                   | Filter text/thought parts from Content        |
+| `ToolRequestEvent`    | `getFunctionCalls(event)` returns FunctionCall[]                                  | Each FunctionCall → one ToolRequestEvent      |
+| `ToolUpdateEvent`     | `event.longRunningToolIds`                                                        | Adapter emits progress for long-running tools |
+| `ToolResponseEvent`   | `getFunctionResponses(event)` returns FunctionResponse[]                          | Each FunctionResponse → one ToolResponseEvent |
+| `ElicitationRequest`  | `eventActions.requestedToolConfirmations` or `requestedAuthConfigs`               | Map to generic elicitation                    |
+| `ElicitationResponse` | User input → FunctionResponse in next runAsync call                               | Reverse of above                              |
+| `UsageEvent`          | `event.usageMetadata` (GenerateContentResponseUsageMetadata)                      | Map token counts                              |
+| `ErrorEvent`          | `event.errorCode` + `event.errorMessage`                                          | Map error fields                              |
+| `stream_end`          | `isFinalResponse(event)`, `eventActions.transferToAgent`, `eventActions.escalate` | Derive `stream_end` reason from ADK signals   |
+| `CustomEvent`         | `event.customMetadata`                                                            | Pass through                                  |
+
+### ADK EventActions → Our events
+
+| EventActions field           | Our event                                                                 | Notes                                                                                                        |
+| ---------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `stateDelta`                 | SessionUpdate or embedded in other events                                 | Delta state is a core ADK pattern                                                                            |
+| `artifactDelta`              | `CustomEvent { kind: 'artifact_delta' }`                                  | Artifacts not in our core events                                                                             |
+| `transferToAgent`            | Tool call (`transfer_to_agent`) + `stream_end` `reason: 'completed'`      | Handoff is a tool call. Host intercepts the tool request, mediates the handoff, originating agent completes. |
+| `escalate`                   | `stream_end` `reason: 'completed'` with `data: { escalateReason: '...' }` | LoopAgent exit signal. ADK's escalate = "I'm done, pass control back up"                                     |
+| `requestedToolConfirmations` | `ElicitationRequest { kind: 'tool_confirmation' }`                        | Per function call ID                                                                                         |
+| `requestedAuthConfigs`       | `ElicitationRequest { kind: 'auth_required' }`                            | Per function call ID                                                                                         |
+| `skipSummarization`          | `_meta: { skipSummarization: true }`                                      | ADK-specific, goes in metadata                                                                               |
+
+### AgentEventBase mapping
+
+| AgentEventBase field | ADK Event field                          | Notes                                             |
+| -------------------- | ---------------------------------------- | ------------------------------------------------- |
+| `id`                 | `event.id`                               | Direct                                            |
+| `timestamp`          | `event.timestamp` (number)               | Convert to ISO 8601 string                        |
+| `type`               | Derived from content analysis            | ADK doesn't have event types — adapter classifies |
+| `agentId`            | `event.author` (agent name) or context   | **New field** — which agent emitted this event    |
+| `threadId`           | `event.branch` (e.g., "agent_1.agent_2") | Direct mapping                                    |
+| `source`             | `event.author` ("user" or agent name)    | Direct                                            |
+| `_meta`              | `event.customMetadata`                   | Direct                                            |
+
+### Verdict: CLEAN MAPPING
+
+Every ADK event pattern maps to our event types. The adapter classifies ADK's
+untyped events into our typed event taxonomy. Key insight: ADK events are richer
+(they carry EventActions, function calls, auth requests all in one event), so
+the adapter may fan out one ADK Event into multiple AgentEvents (e.g., one
+Message + one ToolRequest + one ElicitationRequest). The new `agentId` field
+maps directly from ADK's `event.author`.
+
+---
+
+## 4. ToolContract ↔ ADK Tool System
+
+### ToolDescriptor ↔ BaseTool
+
+| ToolDescriptor field      | ADK source                                                    | Notes                             |
+| ------------------------- | ------------------------------------------------------------- | --------------------------------- |
+| `name`                    | `BaseTool.name`                                               | Direct                            |
+| `displayName`             | —                                                             | ADK doesn't have this             |
+| `description`             | `BaseTool.description`                                        | Direct                            |
+| `parametersSchema`        | `BaseTool._getDeclaration()` → FunctionDeclaration.parameters | JSON Schema from declaration      |
+| `annotations.readOnly`    | Inferred from tool type                                       | FunctionTool with no side effects |
+| `annotations.longRunning` | `BaseTool.isLongRunning`                                      | Direct                            |
+
+### ToolCallRequest ↔ FunctionCall
+
+| ToolCallRequest | ADK FunctionCall    | Notes  |
+| --------------- | ------------------- | ------ |
+| `requestId`     | `functionCall.id`   | Direct |
+| `name`          | `functionCall.name` | Direct |
+| `args`          | `functionCall.args` | Direct |
+
+### ToolResultData ↔ FunctionResponse + tool return
+
+| ToolResultData   | ADK                            | Notes                                            |
+| ---------------- | ------------------------------ | ------------------------------------------------ |
+| `llmContent`     | `FunctionResponse.response`    | Adapter wraps into ContentPart[]                 |
+| `displayContent` | —                              | ADK doesn't separate display from model content  |
+| `isError`        | Error thrown from `runAsync()` | Adapter catches and sets flag                    |
+| `tailCalls`      | —                              | ADK doesn't have tail calls (gemini-cli concept) |
+
+### AgentTool pattern
+
+ADK's `AgentTool` wraps a `BaseAgent` as a `BaseTool`:
+
+- Uses `agent.inputSchema` for tool parameters
+- Uses `agent.description` for tool description
+- Creates internal Runner with isolated session
+- Returns agent output as tool result
+- Merges state deltas back to parent
+
+**Our equivalent:** `SubagentTool` wraps `AgentDescriptor` as a tool:
+
+- Uses `descriptor.inputSchema` for tool parameters
+- Uses `descriptor.description` for tool description
+- Creates executor via `SessionFactory.create(descriptor, context)`
+- Returns execution result as tool result
+
+**Mapping is 1:1.** The only difference is ADK does it with concrete agent
+instances; we do it with descriptors + factory.
+
+---
+
+## 5. LifecycleInterceptor ↔ ADK Plugin System
+
+### Hook point mapping
+
+| Our hook point string | ADK Plugin callback     | Mapping                                    |
+| --------------------- | ----------------------- | ------------------------------------------ |
+| `'before_agent'`      | `beforeAgentCallback`   | `payload: { agent, context }`              |
+| `'after_agent'`       | `afterAgentCallback`    | `payload: { agent, context }`              |
+| `'before_model'`      | `beforeModelCallback`   | `payload: { context, llmRequest }`         |
+| `'after_model'`       | `afterModelCallback`    | `payload: { context, llmResponse }`        |
+| `'before_tool'`       | `beforeToolCallback`    | `payload: { tool, args, context }`         |
+| `'after_tool'`        | `afterToolCallback`     | `payload: { tool, args, context, result }` |
+| `'on_event'`          | `onEventCallback`       | `payload: { event }`                       |
+| `'on_user_message'`   | `onUserMessageCallback` | `payload: { userMessage }`                 |
+| `'before_run'`        | `beforeRunCallback`     | `payload: { context }`                     |
+| `'after_run'`         | `afterRunCallback`      | `payload: { context }`                     |
+| `'on_model_error'`    | `onModelErrorCallback`  | `payload: { request, error }`              |
+| `'on_tool_error'`     | `onToolErrorCallback`   | `payload: { tool, args, error }`           |
+
+### HookResult ↔ ADK callback return
+
+| HookResult field    | ADK pattern                                     | Notes                               |
+| ------------------- | ----------------------------------------------- | ----------------------------------- |
+| `action: 'proceed'` | Return `undefined`                              | Plugin returns nothing → continue   |
+| `action: 'block'`   | Return `Content` (for agent/model) or throw     | Non-undefined return short-circuits |
+| `modifications`     | Return modified `LlmRequest`/`LlmResponse`/args | Plugin returns modified version     |
+
+### ADK's early-exit pattern
+
+ADK plugins use "first non-undefined return wins":
+
+- `beforeModelCallback` returns `LlmResponse` → skips LLM call entirely (cache
+  hit)
+- `beforeToolCallback` returns modified `args` → tool runs with new args
+- `beforeAgentCallback` returns `Content` → skips agent run entirely
+
+Our `HookResult.modifications` carries the same data. The `action: 'block'` +
+return value pattern maps cleanly.
+
+### gemini-cli hooks NOT in ADK
+
+| gemini-cli hook       | ADK equivalent                       | Notes                                                         |
+| --------------------- | ------------------------------------ | ------------------------------------------------------------- |
+| `BeforeToolSelection` | —                                    | ADK doesn't let you modify which tools are available mid-turn |
+| `Notification`        | —                                    | ADK doesn't have notification hooks                           |
+| `SessionStart`        | `onUserMessageCallback` (first call) | Close enough                                                  |
+| `SessionEnd`          | `afterRunCallback`                   | Close enough                                                  |
+| `PreCompress`         | —                                    | ADK doesn't have context compression hooks                    |
+
+These gaps are fine — they're gemini-cli-specific hook points. Our generic
+`fire(hookPoint, payload)` handles them because the hook point is an open
+string. ADK executors simply don't fire these hook points, and
+`supportedHookPoints()` reflects that.
+
+---
+
+## 6. PolicyEvaluator ↔ ADK SecurityPlugin
+
+### ADK SecurityPlugin
+
+```typescript
+class SecurityPlugin extends BasePlugin {
+  policyEngine: BasePolicyEngine;
+
+  // In beforeToolCallback:
+  async beforeToolCallback({ tool, args, context }) {
+    const outcome = await this.policyEngine.evaluate(tool.name, args);
+    switch (outcome) {
+      case PolicyOutcome.DENY:
+        throw error;
+      case PolicyOutcome.CONFIRM:
+        context.requestConfirmation({ hint });
+      case PolicyOutcome.ALLOW:
+        return undefined; // proceed
+    }
+  }
+}
+```
+
+### Mapping
+
+| Our PolicyEvaluator       | ADK SecurityPlugin                                        | Notes                                      |
+| ------------------------- | --------------------------------------------------------- | ------------------------------------------ |
+| `evaluate(request)`       | `policyEngine.evaluate(toolName, args)`                   | ADK is simpler — tool name + args only     |
+| `PolicyDecision.allow`    | `PolicyOutcome.ALLOW`                                     | Direct                                     |
+| `PolicyDecision.deny`     | `PolicyOutcome.DENY`                                      | Direct                                     |
+| `PolicyDecision.ask_user` | `PolicyOutcome.CONFIRM` → `context.requestConfirmation()` | ADK chains to ToolConfirmation             |
+| `getExcluded()`           | —                                                         | ADK doesn't pre-filter tools               |
+| `request.principal`       | —                                                         | ADK doesn't track who's calling            |
+| `request.principalPath`   | Could use `context.agentName` + branch                    | For hierarchical policy                    |
+| `request.context`         | —                                                         | Our extension point for host-specific data |
+
+### How ADK policy maps when host controls execution
+
+With `pauseOnToolCalls: true`, the flow is:
+
+1. ADK yields tool call → adapter converts to ToolRequestEvent
+2. **Host** runs PolicyEvaluator.evaluate() — NOT ADK's SecurityPlugin
+3. Host decides allow/deny/ask_user
+4. If allowed, host executes tool and sends result via `session.stream()`
+
+This means **ADK's SecurityPlugin is bypassed when the host controls tool
+execution** — which is correct! The host's PolicyEvaluator is the authority.
+ADK's SecurityPlugin only matters when ADK executes tools internally
+(`pauseOnToolCalls: false`).
+
+---
+
+## 7. SessionContract ↔ ADK Session
+
+### Session mapping
+
+| Our SessionHandle | ADK Session                              | Notes                                     |
+| ----------------- | ---------------------------------------- | ----------------------------------------- |
+| `id`              | `Session.id`                             | Direct                                    |
+| `agentName`       | `Session.appName`                        | ADK uses appName, not agent name          |
+| `events`          | `Session.events: Event[]`                | Direct (but ADK Events → our AgentEvents) |
+| `state`           | `Session.state: Record<string, unknown>` | Direct                                    |
+| `lastUpdateTime`  | `Session.lastUpdateTime`                 | Direct                                    |
+
+### SessionProvider ↔ BaseSessionService
+
+| Our SessionProvider           | ADK BaseSessionService                          | Notes                      |
+| ----------------------------- | ----------------------------------------------- | -------------------------- |
+| `create(agentName, metadata)` | `createSession({ appName, userId })`            | ADK requires userId        |
+| `load(sessionId)`             | `getSession({ appName, userId, sessionId })`    | ADK requires all three IDs |
+| `list(agentName)`             | `listSessions({ appName, userId })`             | ADK scopes by userId       |
+| `delete(sessionId)`           | `deleteSession({ appName, userId, sessionId })` | Same pattern               |
+
+### Gap: ADK requires userId
+
+ADK sessions are scoped by `(appName, userId, sessionId)`. Our interface uses
+just `sessionId`. The adapter can embed userId in the session metadata or derive
+it from HostContext.
+
+### State prefixes (ADK-specific)
+
+ADK uses prefixed state keys:
+
+- `app:` — app-scoped, persisted
+- `user:` — user-scoped, persisted
+- `temp:` — temporary, stripped before persistence
+
+Our `SessionHandle.state` is a flat `Record<string, unknown>`. The adapter
+preserves prefixes as-is — they're just string keys. No conflict.
+
+---
+
+## 8. ContentPart ↔ ADK Content/Part
+
+### ADK uses Google GenAI types
+
+ADK's `Content` and `Part` come from `@google/genai`:
+
+```typescript
+interface Content {
+  role?: string;  // 'user' | 'model'
+  parts: Part[];
+}
+
+type Part = TextPart | InlineDataPart | FunctionCallPart | FunctionResponsePart | ...
+```
+
+### Mapping
+
+| Our ContentPart                                     | ADK/GenAI Part                                 | Notes                                                  |
+| --------------------------------------------------- | ---------------------------------------------- | ------------------------------------------------------ |
+| `{ type: 'text', text }`                            | `{ text: string }`                             | Direct                                                 |
+| `{ type: 'thought', thought }`                      | `{ thought: true, text: string }`              | ADK uses `thought` boolean flag on TextPart            |
+| `{ type: 'media', mimeType, data }`                 | `{ inlineData: { mimeType, data } }`           | Restructure                                            |
+| `{ type: 'reference', text, uri }`                  | `{ fileData: { fileUri, mimeType } }`          | Map fileData → reference                               |
+| `{ type: 'refusal', text }`                         | —                                              | Not in ADK/GenAI. Adapter would map from finishReason. |
+| `{ type: 'function_call', name, args, id }`         | `{ functionCall: { name, args, id } }`         | Unwrap                                                 |
+| `{ type: 'function_response', name, response, id }` | `{ functionResponse: { name, response, id } }` | Unwrap                                                 |
+
+### Verdict: CLEAN MAPPING
+
+The adapter converts between our flat discriminated union and ADK's nested Part
+structure. No information loss in either direction.
+
+---
+
+## 9. Composition ↔ ADK Agent Patterns
+
+| Our CompositionConfig.pattern | ADK Agent type                         | Notes                                            |
+| ----------------------------- | -------------------------------------- | ------------------------------------------------ |
+| `'hierarchical'`              | Any agent with `subAgents`             | Default — parent calls sub-agents as tools       |
+| `'sequential'`                | `SequentialAgent`                      | Runs children in order                           |
+| `'parallel'`                  | `ParallelAgent`                        | Runs children concurrently, branch isolation     |
+| `'loop'`                      | `LoopAgent`                            | Repeats children until escalate or maxIterations |
+| `'transfer'`                  | LlmAgent with `transfer_to_agent` tool | Peer-to-peer handoff                             |
+
+### Branch isolation
+
+ADK's `ParallelAgent` gives each child an isolated `branch` context:
+
+- Children don't see peer events
+- Each gets unique branch path: `"parent.child_0"`, `"parent.child_1"`
+- Results merged after all complete
+
+Maps to our `threadId` — each parallel branch gets a unique threadId. Events
+from different branches are interleaved by the host.
+
+---
+
+## 10. Summary: Gaps and Resolutions
+
+### No gaps blocking ADK integration:
+
+| Concern                 | Status    | Resolution                                                                |
+| ----------------------- | --------- | ------------------------------------------------------------------------- |
+| pauseOnToolCalls HITL   | **Works** | Adapter maps to stream() cycle (§2)                                       |
+| ToolConfirmation        | **Works** | Maps to ElicitationRequest (§2)                                           |
+| Auth requests           | **Works** | Maps to ElicitationRequest (§2)                                           |
+| Plugin hooks (12 types) | **Works** | Maps to LifecycleInterceptor.fire() (§5)                                  |
+| Agent transfers         | **Works** | Tool call (`transfer_to_agent`) + `stream_end` `reason: 'completed'` (§3) |
+| State delta pattern     | **Works** | SessionUpdateEvent or \_meta (§3)                                         |
+| Branch isolation        | **Works** | threadId mapping (§9)                                                     |
+| AgentTool pattern       | **Works** | SubagentTool with descriptor + factory (§4)                               |
+| Session management      | **Works** | Adapter maps userId into session (§7)                                     |
+
+### Minor adapter complexity:
+
+1. **Event fan-out:** One ADK Event may become multiple AgentEvents (message +
+   tool call + elicitation). Adapter logic needed but straightforward.
+2. **userId scoping:** ADK sessions require userId; our interface doesn't.
+   Adapter derives from HostContext.
+3. **Timestamp format:** ADK uses `number` (epoch ms); we use ISO 8601 string.
+   Simple conversion.
+4. **Content structure:** ADK uses nested Part types; we use flat discriminated
+   union. Adapter converts bidirectionally.
+
+### ADK features our interface supports that gemini-cli doesn't have yet:
+
+- `LoopAgent` / `ParallelAgent` / `SequentialAgent` composition → our
+  CompositionConfig
+- `eventActions.stateDelta` → our SessionUpdateEvent
+- `eventActions.transferToAgent` → tool call (`transfer_to_agent`) +
+  `stream_end` `reason: 'completed'`
+- `eventActions.escalate` → `stream_end` `reason: 'completed'` with
+  `data: { escalateReason }`
+- Long-running tools → our ToolUpdateEvent
+- Auth credential flow → our ElicitationRequest with kind: 'auth_required'

docs/adk-replat/NOTES-adk-ts-architecture.md

@@ -0,0 +1,274 @@
+# ADK-TS (Agent Development Kit - TypeScript) Architecture Notes
+
+## Package: `@google/adk` v0.4.0
+
+**Location:** `/Users/adamfweidman/Desktop/adk-int/adk-js/core/`
+
+## Agent Hierarchy
+
+```
+BaseAgent (abstract)
+├── LlmAgent         - Model-driven agent with tools (the main one)
+├── LoopAgent         - Runs sub-agents in a loop (maxIterations, escalate to exit)
+├── ParallelAgent     - Runs sub-agents concurrently (isolated branches)
+└── SequentialAgent   - Runs sub-agents sequentially
+```
+
+### BaseAgent Config
+
+- `name: string` - Unique identifier (must be valid JS identifier)
+- `description?: string` - One-line capability for model routing
+- `parentAgent?: BaseAgent` - Parent in agent tree
+- `subAgents?: BaseAgent[]` - Child agents
+- `beforeAgentCallback / afterAgentCallback` - Pre/post execution hooks
+
+### LlmAgent Config (extends BaseAgent)
+
+- `model?: string | BaseLlm` - LLM to use
+- `instruction?: string | InstructionProvider` - Agent-specific instructions
+- `globalInstruction?: string | InstructionProvider` - Tree-wide (root only)
+- `tools?: ToolUnion[]` - Available tools
+- `generateContentConfig?: GenerateContentConfig` - LLM params
+- `disallowTransferToParent / disallowTransferToPeers` - Transfer controls
+- `includeContents?: 'default' | 'none'` - Context history inclusion
+- `inputSchema / outputSchema` - Validation schemas
+- `outputKey?: string` - Session state key for output storage
+- `beforeModelCallback / afterModelCallback` - LLM hooks
+- `beforeToolCallback / afterToolCallback` - Tool hooks
+- `requestProcessors / responseProcessors` - LLM request/response processors
+- `codeExecutor?: BaseCodeExecutor`
+
+## Event System
+
+### Event Interface
+
+```typescript
+interface Event extends LlmResponse {
+  id: string;
+  invocationId: string;
+  author?: string; // "user" or agent name
+  actions: EventActions; // State/artifact/auth/transfer operations
+  longRunningToolIds?: string[];
+  branch?: string; // Hierarchical agent path
+  timestamp: number;
+  content?: Content;
+  partial?: boolean; // Streaming indicator
+}
+```
+
+### EventActions
+
+```typescript
+interface EventActions {
+  skipSummarization?: boolean;
+  stateDelta: Record<string, unknown>;
+  artifactDelta: Record<string, number>;
+  transferToAgent?: string;
+  escalate?: boolean;
+  requestedAuthConfigs: Record<string, AuthConfig>;
+  requestedToolConfirmations: Record<string, ToolConfirmation>;
+}
+```
+
+### Structured Events (utility layer)
+
+Converts raw Event to discriminated union:
+
+```
+EventType: THOUGHT | CONTENT | TOOL_CALL | TOOL_RESULT | CALL_CODE |
+           CODE_RESULT | ERROR | ACTIVITY | TOOL_CONFIRMATION | FINISHED
+```
+
+## Tool System
+
+### BaseTool (abstract)
+
+- `name, description, isLongRunning`
+- `_getDeclaration(): FunctionDeclaration` - OpenAPI schema for LLM
+- `runAsync(request): Promise<unknown>` - Execute tool
+- `processLlmRequest(request): Promise<void>` - Preprocessing
+
+### Concrete Tool Types
+
+1. **FunctionTool** - Generic typed tools (Zod schema support)
+2. **AgentTool** - Wrap agents as tools (for hierarchical composition)
+3. **MCPTool** - Model Context Protocol server tools
+4. **GoogleSearchTool** - Built-in web search
+5. **ExitLoopTool** - Signal loop exit
+6. **LongRunningFunctionTool** - Async long-running operations
+
+### BaseToolset
+
+- Filter tools by predicate or string list
+- `getTools(context)`, `close()`, `isToolSelected()`
+- **MCPToolset** - Toolset for MCP server connections
+
+## Session Management
+
+### Session Interface
+
+```typescript
+interface Session {
+  id: string;
+  appName: string;
+  userId: string;
+  state: Record<string, unknown>; // Mutable key-value store
+  events: Event[]; // Complete conversation history
+  lastUpdateTime: number;
+}
+```
+
+### Session Services
+
+- `BaseSessionService` (abstract) - createSession, getSession, listSessions,
+  deleteSession, appendEvent
+- `InMemorySessionService` - In-process storage
+- `DatabaseSessionService` - Mikro-ORM backed (SQL)
+
+### State Management
+
+- `State` class wraps base state + delta
+- `get()` returns from delta if present, else base
+- `set()` updates delta only
+- `hasDelta()` checks if changes made
+
+## Human-in-the-Loop (HITL)
+
+### Tool Confirmation
+
+```typescript
+class ToolConfirmation {
+  hint?: string; // Guidance for user
+  confirmed: boolean; // User approval
+  payload?: unknown; // Additional context
+}
+```
+
+### Security Plugin
+
+- `beforeToolCallback` - Evaluates policy before tool execution
+- `BasePolicyEngine` interface with `evaluate()` method
+- `PolicyOutcome`: DENY | CONFIRM | ALLOW
+
+### Auth Requests
+
+- `context.requestCredential(authConfig)` - Request auth from user
+- `context.getAuthResponse(authConfig)` - Check for auth response
+- Sets `eventActions.requestedAuthConfigs[functionCallId]`
+
+## Multi-Agent Patterns
+
+### Agent Transfer
+
+- LlmAgent injects `transfer_to_agent(agentName)` tool
+- Sets `eventActions.transferToAgent = targetAgentName`
+- Runner resolves target and continues
+- Can transfer to: sub-agents, parent (if not disabled), peers (if not disabled)
+
+### Parallel Agent
+
+- Runs all subAgents concurrently
+- Isolates each via `branch` context
+- Sub-agents don't see peer history
+- Merges event streams with fair ordering
+
+### Loop Agent
+
+- Repeatedly runs subAgents
+- `maxIterations` caps loop count
+- Exits on `event.actions.escalate === true`
+
+## Plugin System
+
+### BasePlugin Lifecycle Hooks (14 hooks!)
+
+- `onUserMessageCallback` - Preprocess user messages
+- `beforeRunCallback` - Before agent run (can short-circuit)
+- `onEventCallback` - Per-event (can modify events)
+- `afterRunCallback` - Final cleanup
+- `beforeAgentCallback / afterAgentCallback` - Agent lifecycle
+- `beforeModelCallback / afterModelCallback` - LLM lifecycle
+- `onModelErrorCallback` - Model error handling
+- `beforeToolCallback / afterToolCallback` - Tool lifecycle
+- `onToolErrorCallback` - Tool error handling
+
+### Built-in Plugins
+
+- **LoggingPlugin** - Debug logging
+- **SecurityPlugin** - Policy enforcement + tool confirmation
+- **PluginManager** - Plugin orchestration
+
+## Runner
+
+### Runner Config
+
+```typescript
+interface RunnerConfig {
+  appName: string;
+  agent: BaseAgent; // Root agent
+  plugins?: BasePlugin[];
+  artifactService?: BaseArtifactService;
+  sessionService: BaseSessionService; // Required
+  memoryService?: BaseMemoryService;
+  credentialService?: BaseCredentialService;
+}
+```
+
+### RunConfig (per-run options)
+
+```typescript
+interface RunConfig {
+  speechConfig?: SpeechConfig;
+  responseModalities?: Modality[];
+  maxLlmCalls?: number; // Default 500
+  pauseOnToolCalls?: boolean; // Client-side tool execution
+  streamingMode?: StreamingMode; // NONE | SSE | BIDI
+  // ... audio/live configs
+}
+```
+
+### Execution Pipeline
+
+1. Load or create session
+2. Create InvocationContext
+3. Run pluginManager.runOnUserMessageCallback()
+4. Append user message to session
+5. Run agent.runAsync(invocationContext) → yields events
+6. For each non-partial event: append to session
+7. Run pluginManager.runOnEventCallback()
+8. Run pluginManager.runAfterRunCallback()
+
+## Model Layer
+
+### BaseLlm (abstract)
+
+- `generateContentAsync(llmRequest, stream?): AsyncGenerator<LlmResponse>`
+- `connect(llmRequest): Promise<BaseLlmConnection>` - For live/streaming
+
+### Implementations
+
+- `Gemini` - Google Gemini API
+- `ApigeeLlm` - Apigee-wrapped models
+- `LLMRegistry` - Static registry for model lookup
+
+## Service Adapters (all abstract base + implementations)
+
+| Service               | Implementations                |
+| --------------------- | ------------------------------ |
+| BaseSessionService    | InMemory, Database (Mikro-ORM) |
+| BaseArtifactService   | InMemory, File, GCS            |
+| BaseMemoryService     | InMemory                       |
+| BaseCredentialService | InMemory                       |
+| BaseCodeExecutor      | BuiltIn                        |
+
+## Design Patterns
+
+1. **Symbol-based type guards** - Every class uses `Symbol.for()` + `isXxx()`
+2. **Abstract base classes** - Service interfaces via abstract classes
+3. **Async generators** - All agent execution yields events
+4. **Context objects** - Rich context passed to callbacks/tools
+5. **Delta state** - Session state + event action deltas
+6. **Plugin middleware** - 14 hooks at multiple execution points
+7. **Tree-based hierarchy** - Parent-child agents with root traversal
+8. **Branch isolation** - Parallel agents use branch paths
+9. **Callback chains** - Multiple callbacks per stage with early termination

docs/adk-replat/NOTES-cross-sdk-comparison.md

@@ -0,0 +1,587 @@
+# Cross-SDK Comparison: Events, Agents, and Interface Superset
+
+## 1. AgentEvents: Our Outline vs Michael's
+
+Our outline and Michael's `Gemini CLI Agents.txt` are **nearly identical** in
+event taxonomy. The only difference is we added a `stream_end` event type:
+
+| #   | Michael's Events       | Our Outline           | Delta                                                                           |
+| --- | ---------------------- | --------------------- | ------------------------------------------------------------------------------- |
+| 1   | `initialize`           | `InitializeEvent`     | Same                                                                            |
+| 2   | `session_update`       | `SessionUpdateEvent`  | Same                                                                            |
+| 3   | `message`              | `MessageEvent`        | Same — streaming handled by AsyncGenerator                                      |
+| 4   | `tool_request`         | `ToolRequestEvent`    | Same                                                                            |
+| 5   | `tool_update`          | `ToolUpdateEvent`     | Same                                                                            |
+| 6   | `tool_response`        | `ToolResponseEvent`   | Same                                                                            |
+| 7   | `elicitation_request`  | `ElicitationRequest`  | Same                                                                            |
+| 8   | `elicitation_response` | `ElicitationResponse` | Same                                                                            |
+| 9   | `usage`                | `UsageEvent`          | Same                                                                            |
+| 10  | `error`                | `ErrorEvent`          | Same                                                                            |
+| 11  | `custom`               | `CustomEvent`         | Same                                                                            |
+| 12  | —                      | **StreamEnd**         | **Added**: completed, failed, aborted, max_turns, max_budget, max_time, refusal |
+
+### Minor structural differences:
+
+| Aspect                 | Michael                                             | Our Outline                                                               |
+| ---------------------- | --------------------------------------------------- | ------------------------------------------------------------------------- |
+| **Base type**          | `AgentEventCommon` with `type: string` (fully open) | `AgentEventBase` with `type: AgentEventType` (`'known' \| (string & {})`) |
+| **Agent ID**           | —                                                   | `agentId` on event base (which agent emitted this event)                  |
+| **Event map**          | Generic `interface AgentEvents` + mapped type       | Same — adopted Michael's pattern for declaration merging extensibility    |
+| **ContentPart.\_meta** | Required (`_meta: Record<string, unknown>`)         | Optional (`_meta?: Record<string, unknown>`)                              |
+| **ErrorData.status**   | Google RPC codes (`'RESOURCE_EXHAUSTED' \| '...'`)  | Open string (per our generic philosophy)                                  |
+| **Message.role**       | `'user' \| 'agent' \| 'developer'`                  | Same                                                                      |
+| **Stream end**         | Only `initialize`                                   | `stream_end` with `reason` field + open `data` bag                        |
+| **Handoff**            | Not covered                                         | Tool call (`transfer_to_agent`) — no dedicated event                      |
+| **Pausing**            | Implicit (elicitation/tool events)                  | Same — no explicit pause/resume events                                    |
+
+### Design decisions adopted from Michael
+
+1. **`interface AgentEvents` + mapped type** — Michael's pattern enables
+   declaration merging, letting any module add new event types without modifying
+   the base definition. Strictly better than an explicit union type.
+2. **`_meta` on ContentPart** — More extensible. We adopted it (as optional).
+3. **Implicit pausing** — No separate pause/resume events. When the agent emits
+   an `elicitation_request` or `tool_request`, the stream naturally pauses. The
+   host calls `stream()` to resume.
+
+---
+
+## 2. Claude Agent SDK — Key Interfaces
+
+Source: `@anthropic-ai/claude-agent-sdk`
+
+### Agent Execution Model
+
+```typescript
+// Entry point — not an interface, a function
+function query({
+  prompt: string | AsyncIterable<SDKUserMessage>,
+  options?: Options
+}): Query  // extends AsyncGenerator<SDKMessage, void>
+```
+
+### Message Types (Event Stream)
+
+```typescript
+type SDKMessage =
+  | SystemMessage // subtype: "init" | "compact_boundary"
+  | AssistantMessage // Claude's response with tool calls
+  | UserMessage // Tool results fed back
+  | StreamEvent // Raw API stream events (opt-in)
+  | ResultMessage // Final: success | error_max_turns | error_max_budget_usd | error_during_execution
+  | CompactBoundaryMessage; // Context compaction marker
+```
+
+### Tool Approval (HITL)
+
+```typescript
+canUseTool: async (toolName: string, input: Record<string, any>) =>
+  Promise<
+    | { behavior: 'allow'; updatedInput: Record<string, any> }
+    | { behavior: 'deny'; message: string }
+  >;
+```
+
+### Subagent Definition
+
+```typescript
+interface AgentDefinition {
+  description: string; // When to invoke
+  prompt: string; // System prompt
+  tools?: string[]; // Available tools (defaults to all)
+  model?: 'sonnet' | 'opus' | 'haiku' | 'inherit';
+}
+```
+
+### Session Management
+
+```typescript
+interface Options {
+  continue?: boolean;         // Resume most recent session
+  resume?: string;            // Resume by session ID
+  forkSession?: boolean;      // Branch from resume point
+  persistSession?: boolean;   // Default: true
+  maxTurns?: number;
+  maxBudgetUsd?: number;      // Spend limit
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions';
+  structuredOutput?: { type: "json_schema", ... };
+}
+```
+
+### Result (Termination)
+
+```typescript
+interface SDKResultMessage {
+  type: 'result';
+  subtype:
+    | 'success'
+    | 'error_max_turns'
+    | 'error_max_budget_usd'
+    | 'error_during_execution'
+    | 'error_max_structured_output_retries';
+  result?: string;
+  total_cost_usd: number;
+  usage: { input_tokens: number; output_tokens: number };
+  num_turns: number;
+  session_id: string;
+  stop_reason: string | null; // "end_turn", "max_tokens", "refusal"
+}
+```
+
+### V2 Preview (Simpler API)
+
+```typescript
+await using session = unstable_v2_createSession({ model: "..." });
+await session.send("Hello!");
+for await (const msg of session.stream()) { ... }
+await session.send("Follow-up");
+for await (const msg of session.stream()) { ... }
+```
+
+---
+
+## 3. OpenAI Codex SDK / Responses API — Key Interfaces
+
+### Codex SDK (TypeScript)
+
+```typescript
+// Client
+const codex = new Codex({ env?, config? });
+const thread = codex.startThread({ workingDirectory?, skipGitRepoCheck? });
+const thread = codex.resumeThread(threadId);
+
+// Execution
+const turn = await thread.run(prompt: string | InputEntry[], options?);
+const { events } = await thread.runStreamed(prompt);
+
+// Streaming
+for await (const event of events) {
+  switch (event.type) {
+    case "item.completed": // event.item
+    case "turn.completed": // event.usage
+  }
+}
+```
+
+### Responses API Streaming Events (53 types)
+
+Organized hierarchically:
+
+**Response Lifecycle (7):**
+
+- `response.queued`, `response.created`, `response.in_progress`
+- `response.completed`, `response.incomplete`, `response.failed`
+- `error`
+
+**Content Streaming (8):**
+
+- `response.output_item.added`, `response.output_item.done`
+- `response.content_part.added`, `response.content_part.done`
+- `response.output_text.delta`, `response.output_text.done`
+- `response.refusal.delta`, `response.refusal.done`
+
+**Reasoning (6):**
+
+- `response.reasoning_text.delta`, `response.reasoning_text.done`
+- `response.reasoning_summary_part.added`,
+  `response.reasoning_summary_part.done`
+- `response.reasoning_summary_text.delta`,
+  `response.reasoning_summary_text.done`
+
+**Function Calls (2):**
+
+- `response.function_call_arguments.delta`,
+  `response.function_call_arguments.done`
+
+**MCP (8):**
+
+- `response.mcp_call_arguments.delta`, `response.mcp_call_arguments.done`
+- `response.mcp_call.in_progress`, `response.mcp_call.completed`,
+  `response.mcp_call.failed`
+- `response.mcp_list_tools.in_progress`, `response.mcp_list_tools.completed`,
+  `response.mcp_list_tools.failed`
+
+**Built-in Tools (15):**
+
+- File search: `in_progress`, `searching`, `completed`
+- Web search: `in_progress`, `searching`, `completed`
+- Code interpreter: `in_progress`, `interpreting`, `code.delta`, `code.done`,
+  `completed`
+- Image gen: `in_progress`, `generating`, `partial_image`, `completed`
+
+**Audio (4):**
+
+- `response.audio.delta`, `response.audio.done`
+- `response.audio.transcript.delta`, `response.audio.transcript.done`
+
+**Annotations (1):**
+
+- `response.output_text.annotation.added`
+
+### OpenAI Agents SDK (higher-level)
+
+```python
+# Python-first, but patterns apply
+class RunItemStreamEvent:
+    name: Literal[
+        "message_output_created",
+        "handoff_requested",
+        "handoff_occurred",
+        "tool_called",
+        "tool_output",
+        "tool_search_called",
+        "tool_search_output_created",
+        "reasoning_item_created",
+        "mcp_approval_requested",
+        "mcp_approval_response",
+        "mcp_list_tools",
+    ]
+
+class AgentUpdatedStreamEvent:
+    # Fires when current agent changes (handoff)
+    new_agent: Agent
+```
+
+---
+
+## 4. Superset Analysis — What Changes Our Interfaces?
+
+### Concepts Present in ALL Systems
+
+| Concept               | gemini-cli | ADK-TS | Claude SDK    | Codex/OpenAI   | Our Interfaces          |
+| --------------------- | ---------- | ------ | ------------- | -------------- | ----------------------- |
+| Text streaming        | ✅         | ✅     | ✅            | ✅             | ✅ MessageEvent         |
+| Tool request/response | ✅         | ✅     | ✅            | ✅             | ✅ ToolRequest/Response |
+| Thinking/reasoning    | ✅         | ✅     | ✅ (thinking) | ✅ (reasoning) | ✅ ContentPart.thought  |
+| Error events          | ✅         | ✅     | ✅            | ✅             | ✅ ErrorEvent           |
+| Token usage           | ✅         | ✅     | ✅            | ✅             | ✅ UsageEvent           |
+| Tool progress         | ✅         | ✅     | —             | ✅             | ✅ ToolUpdateEvent      |
+| Session resume        | ✅         | ✅     | ✅            | ✅             | ✅ sessionRef           |
+| Subagents             | ✅         | ✅     | ✅            | —              | ✅ threadId             |
+| Abort/cancel          | ✅         | ✅     | ✅            | ✅             | ✅ abort()              |
+| Metadata escape hatch | —          | ✅     | —             | —              | ✅ \_meta               |
+
+### NEW Concepts From Claude/Codex That We Should Incorporate
+
+#### 4.1 Structured Stream End Reasons (HIGH PRIORITY)
+
+**What:** Claude SDK has typed termination:
+`success | error_max_turns | error_max_budget_usd | error_during_execution`.
+OpenAI has `completed | incomplete | failed`.
+
+**Why it matters:** We need a `stream_end` event that captures why the stream
+ended — the one signal not covered by other event types.
+
+**Final design — `stream_end` with `reason` + open `data` bag:**
+
+```typescript
+type StreamEndReason =
+  | 'completed'
+  | 'failed'
+  | 'aborted'
+  | 'max_turns'
+  | 'max_budget'
+  | 'max_time'
+  | 'refusal'
+  | (string & {});
+
+interface StreamEnd {
+  reason: StreamEndReason;
+  data?: Record<string, unknown>; // { result?, cost?, usage?, numTurns?, error?, ... }
+}
+```
+
+**Design rationale:**
+
+- Start is covered by `initialize`. Pausing is implicit (elicitation/tool
+  request events). Handoff is a tool call (`transfer_to_agent`).
+- End-of-stream details go in `data` as an open bag, not fixed fields.
+
+#### 4.2 Budget Constraints (MEDIUM PRIORITY)
+
+**What:** Claude SDK has `maxBudgetUsd`. Neither gemini-cli nor ADK has this
+today.
+
+**Why it matters:** Cost control is critical for production deployments.
+
+**Proposed change to AgentConstraints:**
+
+```typescript
+interface AgentConstraints {
+  maxTurns?: number;
+  maxTimeMinutes?: number;
+  maxLlmCalls?: number;
+  maxBudgetUsd?: number; // NEW: from Claude SDK
+}
+```
+
+#### 4.3 Session Forking (MEDIUM PRIORITY)
+
+**What:** Claude SDK supports `forkSession: boolean` — branch from a resume
+point to explore alternatives.
+
+**Why it matters:** Enables "what if" exploration without destroying history.
+Useful for plan mode.
+
+**Proposed change to ExecutionRequest:**
+
+```typescript
+interface ExecutionRequest {
+  // ... existing fields ...
+  sessionRef?: string | SessionSnapshot;
+  forkSession?: boolean; // NEW: branch from sessionRef instead of continuing
+}
+```
+
+#### 4.4 Permission Modes on Execution (MEDIUM PRIORITY)
+
+**What:** Claude has 5 permission modes:
+`default | acceptEdits | plan | dontAsk | bypassPermissions`. gemini-cli has 4
+approval modes: `default | autoEdit | yolo | plan`.
+
+**Why it matters:** Both systems have this concept. It should be in
+ExecutionOptions, not hard-coded.
+
+**Proposed change to ExecutionOptions:**
+
+```typescript
+interface ExecutionOptions {
+  // ... existing fields ...
+  permissionMode?: string; // Open string. Conventions: 'default' | 'auto_edit' | 'autonomous' | 'plan' | string
+}
+```
+
+#### 4.5 Agent Handoff (MEDIUM PRIORITY)
+
+**What:** OpenAI Agents SDK has explicit `handoff_requested` /
+`handoff_occurred` events plus `AgentUpdatedStreamEvent`. ADK has
+`transfer_to_agent` tool + `eventActions.transferToAgent`. Claude SDK has
+subagent invocation via Agent tool.
+
+**Why it matters:** When agent A delegates to agent B, the host/UI needs to
+know.
+
+**Design decision: Handoff is a tool call, not a separate event type.**
+
+The agent calls `transfer_to_agent` as a tool (ToolRequest event). The host
+intercepts this tool call (since host controls tool execution), looks up the
+target agent, creates a new executor via the factory, and mediates the handoff.
+The originating agent's stream ends with `stream_end` reason `'completed'`.
+
+```typescript
+// 1. Agent emits tool request:
+{ type: 'tool_request', name: 'transfer_to_agent', args: { target: 'coder', reason: '...' } }
+
+// 2. Host mediates handoff, originating agent completes:
+{ type: 'stream_end', reason: 'completed', agentId: 'planner', data: { handoffTarget: 'coder' } }
+```
+
+This avoids duplicating routing logic between stream_end events and tool calls.
+Matches ADK's `transfer_to_agent` tool pattern.
+
+#### 4.6 Refusal as Distinct Signal (LOW PRIORITY)
+
+**What:** OpenAI has explicit `response.refusal.delta/done` events. Claude has
+`stop_reason: "refusal"`.
+
+**Why it matters:** Model refusals are operationally important (safety, policy).
+
+**Proposed:** No new event type. Handle via `MessageEvent` with a `refusal`
+content part type, or via `ErrorEvent` with specific error code. ContentPart can
+be extended:
+
+```typescript
+| { type: 'refusal'; text: string }
+```
+
+#### 4.7 Content Annotations (LOW PRIORITY)
+
+**What:** OpenAI has `response.output_text.annotation.added` for citations, file
+paths.
+
+**Why it matters:** Citations and source attribution are increasingly important.
+
+**Proposed:** Michael's `reference` ContentPart already covers this. No change
+needed — `reference` with `uri` and `text` handles citations.
+
+#### 4.8 Context Compaction Events (LOW PRIORITY)
+
+**What:** Claude SDK has `CompactBoundaryMessage` marking when context was
+compressed.
+
+**Why it matters:** For long sessions, knowing when context was compressed helps
+with debugging and UI.
+
+**Proposed:** `CustomEvent` with `kind: 'compact_boundary'`. No new event type
+needed.
+
+#### 4.9 Structured Output Schema (ALREADY COVERED)
+
+**What:** Both Claude (`structuredOutput`) and OpenAI support JSON Schema output
+constraints.
+
+**Status:** Already covered by `AgentDescriptor.outputSchema: JsonSchema`. No
+change needed.
+
+### Concepts We DON'T Need to Adopt
+
+| Concept                                                                   | Why Skip                                                                                                               |
+| ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| OpenAI's 53 granular streaming events                                     | Too coupled to Responses API internals. Our `ToolUpdateEvent` + `MessageEvent` via AsyncGenerator abstracts over this. |
+| OpenAI's per-tool-type events (file_search, web_search, code_interpreter) | Tool-specific progress belongs in `ToolUpdateEvent.data`, not in the event taxonomy.                                   |
+| Audio/Image streaming events                                              | Handle via `ToolUpdateEvent` with media ContentParts. When needed, add as ContentPart types, not event types.          |
+| Claude's raw `StreamEvent` wrapper                                        | Implementation detail of the Claude API client. Our adapters consume these internally.                                 |
+| MCP-specific events (mcp_call, mcp_list_tools)                            | MCP tools are just tools. Use generic `ToolRequestEvent/ToolResponseEvent`. MCP approval is an `ElicitationRequest`.   |
+
+---
+
+## 5. Updated Event Type Comparison (Full Superset)
+
+| #   | Event Type           | Michael | Our Outline | Claude SDK                    | OpenAI                            | Verdict                                        |
+| --- | -------------------- | ------- | ----------- | ----------------------------- | --------------------------------- | ---------------------------------------------- |
+| 1   | Initialize           | ✅      | ✅          | SystemMessage(init)           | —                                 | **Keep**                                       |
+| 2   | Session Update       | ✅      | ✅          | —                             | —                                 | **Keep**                                       |
+| 3   | Message              | ✅      | ✅          | AssistantMessage              | output_text.delta/done            | **Keep**                                       |
+| 4   | Tool Request         | ✅      | ✅          | AssistantMessage.tool_use     | function_call_arguments           | **Keep**                                       |
+| 5   | Tool Update          | ✅      | ✅          | —                             | per-tool progress events          | **Keep**                                       |
+| 6   | Tool Response        | ✅      | ✅          | UserMessage                   | —                                 | **Keep**                                       |
+| 7   | Elicitation Request  | ✅      | ✅          | canUseTool callback           | mcp_approval_requested            | **Keep**                                       |
+| 8   | Elicitation Response | ✅      | ✅          | canUseTool return             | mcp_approval_response             | **Keep**                                       |
+| 9   | Usage                | ✅      | ✅          | ResultMessage.usage           | response.completed                | **Keep**                                       |
+| 10  | Error                | ✅      | ✅          | ResultMessage(error\_\*)      | response.failed                   | **Keep**                                       |
+| 11  | Custom               | ✅      | ✅          | —                             | —                                 | **Keep**                                       |
+| 12  | StreamEnd            | —       | ✅          | ResultMessage + SystemMessage | response.created/completed/failed | **Keep — `stream_end` with `reason` + `data`** |
+
+**Result: Our 12 event types are the right abstraction level.** Claude and
+OpenAI validate every category. The granularity differences (OpenAI's 53 vs
+our 12) are implementation details that adapters handle internally. `stream_end`
+uses a single `reason` field with an open `data` bag. Handoff is a tool call.
+Pausing is implicit.
+
+---
+
+## 6. Updated ContentPart Types (Superset)
+
+```typescript
+type ContentPart = (
+  | { type: 'text'; text: string }
+  | { type: 'thought'; thought: string; thoughtSignature?: string }
+  | { type: 'media'; data?: string; uri?: string; mimeType?: string }
+  | {
+      type: 'reference';
+      text: string;
+      data?: string;
+      uri?: string;
+      mimeType?: string;
+    }
+  | { type: 'refusal'; text: string } // NEW: from OpenAI
+) &
+  // Future: type: string for unknown types from new SDKs
+  { _meta?: Record<string, unknown> };
+```
+
+Adding `refusal` as a ContentPart type (rather than a new event) keeps the event
+taxonomy stable while supporting model refusals from both Claude and OpenAI.
+
+---
+
+## 7. Key Architectural Patterns Across SDKs
+
+### Pattern: Execution Entry Points
+
+| SDK         | Entry Point                                                               | Multi-turn Pattern                              |
+| ----------- | ------------------------------------------------------------------------- | ----------------------------------------------- |
+| Michael     | `agent.send(trajectory, data)` / `session.send()` + `session.update()`    | Same method / three-method session              |
+| Our Outline | `session.stream(data)` + `session.update(config)` + `session.steer(data)` | Four-method session (stream/update/steer/abort) |
+| Claude SDK  | `query({ prompt, options })`                                              | New `query()` call with `resume: sessionId`     |
+| Claude V2   | `session.send()` + `session.stream()`                                     | Separate send/stream                            |
+| Codex SDK   | `thread.run(prompt)` / `thread.runStreamed(prompt)`                       | Same thread object                              |
+
+**Observation:** Claude V2 and Codex both use a stateful session/thread object
+with send+stream. Michael uses a single `send()` method. Our `stream()` method
+is the unified version — the first call starts, subsequent calls continue (like
+ADK's `runAsync()`).
+
+### Pattern: Tool Approval
+
+| SDK         | Pattern                                                  | Sync/Async               |
+| ----------- | -------------------------------------------------------- | ------------------------ |
+| gemini-cli  | PolicyEngine + ConfirmationBus                           | Async (message bus)      |
+| ADK-TS      | SecurityPlugin.policyCheck()                             | Async (plugin callback)  |
+| Claude SDK  | `canUseTool()` callback                                  | Async (callback)         |
+| OpenAI      | `mcp_approval_requested` event                           | Event-based              |
+| Our Outline | `ElicitationRequest` event + `PolicyEvaluator` interface | Both (event + interface) |
+
+**Observation:** Our approach covers both patterns — the `ElicitationRequest`
+event for event-based approval (like OpenAI), and the `PolicyEvaluator`
+interface for synchronous policy checks (like gemini-cli/ADK/Claude). This is
+the right superset.
+
+### Pattern: Subagent Definition
+
+| SDK           | Pattern                          | Key Fields                                                                                 |
+| ------------- | -------------------------------- | ------------------------------------------------------------------------------------------ |
+| gemini-cli    | `AgentDefinition` (local/remote) | name, description, kind, tools, model                                                      |
+| ADK-TS        | `BaseAgentConfig`                | name, description, subAgents, tools                                                        |
+| Claude SDK    | `AgentDefinition`                | description, prompt, tools, model                                                          |
+| OpenAI Agents | `Agent` class                    | name, instructions, tools, handoffs, model                                                 |
+| Our Outline   | `AgentDescriptor`                | name, description, executor, inputSchema, capabilities, ownTools, requiredTools, subAgents |
+
+**Observation:** Our `AgentDescriptor` is the most complete. Claude's `prompt`
+field and OpenAI's `instructions` are executor-level concerns (system prompt),
+not descriptor-level. The descriptor declares identity; the executor uses the
+prompt. This separation is correct.
+
+One gap: **handoffs**. OpenAI Agents has an explicit `handoffs` field listing
+which agents can be delegated to. Our `subAgents` field serves the same purpose
+but the naming implies hierarchy rather than peer delegation. Consider whether
+`subAgents` should be renamed to `delegateAgents` or kept as-is with
+documentation clarifying it covers both hierarchical and peer delegation.
+
+---
+
+## 8. Concrete Changes to outline.md
+
+Based on this analysis, the following changes should be made:
+
+### Applied (validated by multiple SDKs):
+
+1. ✅ **`type: AgentEventType`** with known values + `(string & {})`
+   (autocomplete + extensibility)
+2. ✅ **`interface AgentEvents` + mapped type** (adopted from Michael for
+   declaration merging)
+3. ✅ **`agentId` on event base** (which agent emitted this event)
+4. ✅ **`_meta` on ContentPart** (aligned with Michael)
+5. ✅ **`stream_end` event** — signals why the stream ended, with `reason`
+   field + open `data` bag
+6. ✅ **Handoff as tool call** — `transfer_to_agent` tool, not a separate event
+7. ✅ **`maxBudgetUsd` in AgentConstraints** (Claude SDK, increasingly standard)
+8. ✅ **`refusal` ContentPart type** (both Claude and OpenAI surface refusals)
+9. ✅ **`forkSession` in ExecutionRequest** (Claude SDK, valuable for
+   exploration)
+10. ✅ **`permissionMode` in ExecutionOptions** (both gemini-cli and Claude SDK)
+11. ✅ **`cost` field on Usage** (Claude SDK tracks total_cost_usd)
+
+### Correctly abstracted (no change needed):
+
+- Event taxonomy (12 types) — validated as right abstraction level
+- `AgentDescriptor` shape — most complete across all SDKs
+- `AgentSession.stream/update/steer/abort` — covers all SDK patterns
+- ToolUpdate — correctly abstracts over OpenAI's 15+ tool-specific progress
+  events
+- `ElicitationRequest/Response` — covers both callback and event patterns
+- `ContentPart` types — text/thought/media/reference/refusal
+
+---
+
+## Sources
+
+- [Claude Agent SDK TypeScript Reference](https://platform.claude.com/docs/en/agent-sdk/typescript)
+- [Claude Agent SDK Streaming](https://platform.claude.com/docs/en/agent-sdk/streaming-output)
+- [Claude Agent SDK Sessions](https://platform.claude.com/docs/en/agent-sdk/sessions)
+- [Claude Agent SDK Subagents](https://platform.claude.com/docs/en/agent-sdk/subagents)
+- [OpenAI Codex SDK TypeScript](https://github.com/openai/codex/tree/main/sdk/typescript)
+- [OpenAI Codex SDK Docs](https://developers.openai.com/codex/sdk/)
+- [OpenAI Responses API Streaming Events](https://developers.openai.com/api/reference/resources/responses/streaming-events/)
+- [OpenAI Agents SDK Streaming](https://openai.github.io/openai-agents-python/streaming/)
+- [Responses API Streaming Guide (Community)](https://community.openai.com/t/responses-api-streaming-the-simple-guide-to-events/1363122)

docs/adk-replat/NOTES-gemini-cli-architecture.md

@@ -0,0 +1,259 @@
+# Gemini CLI Architecture Notes
+
+## Project Structure
+
+**Monorepo packages:**
+
+- `packages/core/` - Main execution engine (the big one)
+- `packages/cli/` - CLI frontend
+- `packages/sdk/` - SDK for extensions
+- `packages/a2a-server/` - Agent-to-agent server
+- `packages/devtools/` - Dev utilities
+- `packages/vscode-ide-companion/` - VS Code extension
+
+## Core Execution Loop
+
+### GeminiClient (`core/src/core/client.ts` ~38KB)
+
+- **Primary orchestrator** for user interactions
+- Manages session lifecycle, message routing, model selection
+- Coordinates hooks, context management, error recovery
+- Enforces `MAX_TURNS = 100` per session
+- Tracks `currentSequenceModel` for multi-turn stickiness
+- Handles history compression when context grows
+
+### GeminiChat (`core/src/core/geminiChat.ts` ~34KB)
+
+- Bidirectional LLM communication
+- Maintains `history[]` alternating user/model turns
+- Retry logic: max 2 attempts, 500ms delay for invalid responses
+- Fires `BeforeModel` and `AfterModel` hooks
+- Integrates ChatRecordingService for persistence
+
+### Scheduler (`core/src/scheduler/scheduler.ts` ~23KB)
+
+- **Three-phase event-driven**: Ingestion → Processing → Completion
+- Tool call state machine:
+  `Validating → AwaitingApproval → Scheduled → Executing → Terminal`
+- Terminal states: `Success`, `Error`, `Cancelled`
+- Parallel execution for read-only and agent-type tools
+- Yields to event loop for user approval
+- Publishes state changes via MessageBus
+
+### CoreToolScheduler (`core/src/core/coreToolScheduler.ts` ~38KB)
+
+- Sequential, queue-based tool processing
+- Validates policy via PolicyEngine
+- Confirmation handling via ToolModificationHandler (editor integration)
+- Uses MessageBus for async confirmation responses
+
+## Tool System
+
+### DeclarativeTool Pattern
+
+- **Separation of concerns**: build() → validate → createInvocation() →
+  execute()
+- `ToolBuilder` defines metadata (name, displayName, description, kind) + schema
+  via `getSchema()`
+- `ToolInvocation` has: `getDescription()`, `toolLocations()`,
+  `shouldConfirmExecute()`, `execute()`
+- `ToolResult` contains: `llmContent` (for LLM), `returnDisplay` (for UI), error
+  details, tail calls
+
+### BaseToolInvocation
+
+- Abstract base with MessageBus integration for policy/confirmation
+- Three decision paths: ALLOW, DENY, ASK_USER via `getMessageBusDecision()`
+
+### ToolRegistry (`core/src/tools/tool-registry.ts`)
+
+- Registers tools via `registerTool()`
+- MCP tools with fully qualified names: `mcp_serverName_toolName`
+- Priority sorting: built-in → discovered → MCP (by server name)
+- Filters by active status based on configuration
+
+### Confirmation System
+
+- `ToolCallConfirmationDetails` union: edit, execute, MCP, info, ask_user,
+  exit_plan_mode
+- `ToolConfirmationOutcome` enum: ProceedOnce, ProceedAlways, etc.
+- Async confirmation via MessageBus pub/sub
+
+## Hooks System
+
+### Hook Types (11 hook points)
+
+| Hook                  | Trigger                 | Key Capability                    |
+| --------------------- | ----------------------- | --------------------------------- |
+| `BeforeTool`          | Before tool execution   | Modify tool_input                 |
+| `AfterTool`           | After tool completion   | Context injection, tail calls     |
+| `BeforeAgent`         | Before agent prompt     | Additional context                |
+| `AfterAgent`          | After agent response    | Clear context flag                |
+| `BeforeModel`         | Before LLM request      | Modify request or inject response |
+| `AfterModel`          | After LLM response      | Modify response                   |
+| `BeforeToolSelection` | Before tool selection   | Modify toolConfig                 |
+| `Notification`        | When notifications fire | Suppress/modify message           |
+| `SessionStart`        | Session begins          | Additional context                |
+| `SessionEnd`          | Session terminates      | Cleanup                           |
+| `PreCompress`         | Before compression      | Suppress/modify                   |
+
+### Hook Output Fields (common to all hooks)
+
+- `continue` - Whether execution proceeds
+- `stopReason` - Reason to halt
+- `suppressOutput` - Hide from user
+- `systemMessage` - Add to system context
+- `decision` - ask/block/deny/approve/allow
+
+### Hook System Components
+
+- `HookSystem` - Main coordinator
+- `HookRegistry` - Stores/manages configurations
+- `HookRunner` - Executes registered hooks
+- `HookAggregator` - Combines multiple hook results
+- `HookPlanner` - Determines execution order
+- `HookEventHandler` - Orchestrates event firing
+- `HookTranslator` - Converts between formats
+
+## Policy Engine
+
+### Rule Structure
+
+```
+PolicyRule {
+  toolName: string;        // wildcards supported
+  decision: PolicyDecision; // ALLOW | DENY | ASK_USER
+  priority: number;
+  argsPattern?: RegExp;    // conditional on args
+  mcpName?: string;
+  source: string;
+}
+```
+
+### Tier Hierarchy (lowest → highest priority)
+
+1. Default (1) - Core built-in policies
+2. Extension (2) - Extension contributions
+3. Workspace (3) - Project-scoped (.gemini/)
+4. User (4) - User-provided (~/.gemini/)
+5. Admin (5) - System-level policies
+
+### Dynamic Rule Priorities (within User Tier)
+
+- 4.9 - MCP_EXCLUDED (persistent server blocks)
+- 4.4 - EXCLUDE_TOOLS_FLAG (CLI exclusions)
+- 4.3 - ALLOWED_TOOLS_FLAG (CLI allows)
+- 4.2 - TRUSTED_MCP_SERVER
+- 4.1 - ALLOWED_MCP_SERVER
+- 3.95 - ALWAYS_ALLOW (interactive selections)
+
+### Security Constraint
+
+- Extensions CANNOT contribute ALLOW rules or YOLO mode
+
+## Agent System
+
+### Agent Registry (`core/src/agents/registry.ts`)
+
+Discovery sources:
+
+1. Built-in: CodebaseInvestigator, CliHelp, Generalist, Browser
+2. User-level: `~/.gemini/agents/`
+3. Project-level: `.gemini/agents/` (requires folder trust)
+4. Extension-based: From active extensions
+
+### LocalAgentExecutor (`core/src/agents/local-executor.ts`)
+
+- Prompt processing: input augmentation → template expansion → system prompt
+  construction
+- Uses GeminiChat for accumulating conversation
+- ChatCompressionService for history management
+- Turn loop: invoke model → extract function calls → check auth → append results
+- Termination: complete_task tool, max turns, timeout
+
+### SubagentTool (`core/src/agents/subagent-tool.ts`)
+
+- Extends BaseDeclarativeTool - agents invoked like standard tools
+- Read-only status checking, user hint propagation
+- Execution: validate → optional confirmation → parameter enrichment →
+  SubagentToolWrapper
+
+### Remote Agents
+
+- A2A client manager for agent-to-agent protocol
+- Remote invocation for external agents
+- Agent acknowledgement system (security for project agents)
+
+## Model System
+
+### ModelConfigService
+
+- **Hierarchical alias system**: children override parents
+- Resolution: alias chain → level assignment → apply overrides
+- Deep merging with array override capability
+- Fallback to `chat-base` alias for unknown models
+
+### ModelRouterService
+
+Sequential strategy pattern:
+
+1. Fallback & Override
+2. Approval Mode Strategy
+3. Gemma Classifier (if enabled)
+4. Generic Classifier
+5. Numerical Classifier
+6. Default Strategy
+
+### ModelAvailabilityService
+
+Health states:
+
+- **Terminal** - permanently unavailable
+- **Sticky Retry** - failed once, can retry once per turn
+- **Healthy** - no issues
+
+## Services
+
+| Service                     | Purpose                                 |
+| --------------------------- | --------------------------------------- |
+| ChatRecordingService        | Session persistence (JSON files)        |
+| ChatCompressionService      | History summarization for token budgets |
+| ModelConfigService          | Hierarchical model config with aliases  |
+| ModelAvailabilityService    | Model health tracking                   |
+| ModelRouterService          | Model selection via strategies          |
+| FolderTrustDiscoveryService | Workspace security scanning             |
+| KeychainService             | Credential storage                      |
+| LoopDetectionService        | Detect repetitive agent loops           |
+
+## UI + Core Separation
+
+### IDE Client (`core/src/ide/ide-client.ts`)
+
+- Singleton managing CLI ↔ IDE communication via MCP
+- **Outbound** (CLI → IDE): `openDiff`, `closeDiff`
+- **Inbound** (IDE → CLI): `ide/contextUpdate`, `ide/diffAccepted`,
+  `ide/diffRejected`
+
+### Event Contract
+
+```typescript
+interface IdeContextNotification {
+  method: 'ide/contextUpdate';
+  params: { workspaceState: { openFiles: string[]; isTrusted: boolean } };
+}
+```
+
+### Confirmation Bus
+
+- `TOOL_CONFIRMATION_REQUEST` / `TOOL_CONFIRMATION_RESPONSE`
+- Detail types: edit, execute, MCP, info, ask_user, exit_plan_mode
+- Async pub/sub via MessageBus
+
+## Configuration (`core/src/config/config.ts` ~95KB!)
+
+- Tool config: core tools, allowed/excluded, MCP servers
+- File filtering: git ignore, fuzzy search, max counts, timeouts
+- Approval modes: policy engine config
+- Experiments: feature flags (GEMINI_3_1_PRO_LAUNCHED, ENABLE_ADMIN_CONTROLS,
+  etc.)
+- FolderTrust: discovery scans for commands, skills, settings, MCP, hooks

docs/adk-replat/NOTES-key-systems-deep-dive.md

@@ -0,0 +1,296 @@
+# Deep Dive: Key Gemini-CLI Systems
+
+## Hooks System (Complete)
+
+### 11 Hook Points
+
+| Hook                | Input                                  | Key Output Capabilities                       |
+| ------------------- | -------------------------------------- | --------------------------------------------- |
+| BeforeTool          | toolName, toolInput, mcpContext        | Modify tool_input, block/allow, systemMessage |
+| AfterTool           | toolName, toolInput, toolResponse      | additionalContext, tailToolCallRequest        |
+| BeforeAgent         | prompt                                 | Additional context                            |
+| AfterAgent          | prompt, response, stopHookActive       | Clear context                                 |
+| BeforeModel         | llmRequest (GenerateContentParameters) | Modify llm_request OR inject llm_response     |
+| AfterModel          | llmRequest, llmResponse                | Modify llm_response                           |
+| BeforeToolSelection | llmRequest                             | Modify toolConfig (function list, mode)       |
+| Notification        | type, message, details                 | Suppress/modify                               |
+| SessionStart        | source (Startup/Resume/Clear)          | Additional context                            |
+| SessionEnd          | reason (Exit/Clear/Logout/etc)         | Cleanup                                       |
+| PreCompress         | trigger (Manual/Auto)                  | Suppress/modify                               |
+
+### Hook Configuration Types
+
+- **Runtime hooks** (HookType.Runtime): JS/TS functions, registered
+  programmatically
+- **Command hooks** (HookType.Command): External shell commands with JSON I/O
+
+### Exit Code Semantics (Command Hooks)
+
+- 0 = Success (allowed with system message)
+- 1 = Non-blocking error (warning, continues)
+- 2+ = Blocking failure (denied, stderr as reason)
+
+### Hook Decision Values
+
+`'ask' | 'block' | 'deny' | 'approve' | 'allow' | undefined`
+
+### Execution Strategies
+
+- **Parallel** (default): Promise.all(), independent
+- **Sequential** (opt-in per hook): Chained, output→input cascading
+
+### Aggregation
+
+- Blocking decisions: OR logic (any block → all block)
+- Field replacement: later overrides earlier
+- Tool selection: union of allowed functions, mode precedence NONE > ANY > AUTO
+
+### Trust Model
+
+- Project hooks require folder trust verification
+- TrustedHooksManager at `~/.gemini/trusted-hooks.json`
+- Environment sanitized for command hooks (sensitive vars removed)
+- `GEMINI_PROJECT_DIR` injected
+
+### Key Insight for Abstraction
+
+Hooks fire inside gemini-cli's execution loop. When ADK controls the model:
+
+- BeforeModel/AfterModel still fire because AdkGeminiModel wraps GeminiChat
+- BeforeTool/AfterTool still fire because AdkToolAdapter wraps DeclarativeTool
+- This is dewitt's solution: adapters preserve hook injection points
+
+**For OpenRouter or opaque agents, hooks CANNOT fire unless the agent delegates
+model/tool calls back to gemini-cli.**
+
+---
+
+## Policy Engine (Complete)
+
+### TOML Rule Format
+
+```toml
+[[rules]]
+decision = "allow" | "deny" | "ask_user"
+priority = 0-999
+toolName = "tool_name"       # wildcards: *, mcp_*, mcp_server_*
+mcpName = "server_name"      # MCP server filter
+argsPattern = "regex"        # matches JSON-stringified args
+commandPrefix = "cmd"        # shell command prefix match
+commandRegex = "regex"       # shell command regex (mutually exclusive with prefix)
+modes = ["default", "autoEdit", "yolo", "plan"]
+annotations = ["read-only", "experimental"]
+allowRedirection = true      # for shell commands
+allowMessage = "..."         # user-facing message on allow
+denyMessage = "..."          # user-facing message on deny
+```
+
+### 5-Tier Priority System
+
+- Tier 5 (Admin): 5.000-5.999
+- Tier 4 (User): 4.000-4.999
+- Tier 3 (Workspace): 3.000-3.999
+- Tier 2 (Extension): 2.000-2.999
+- Tier 1 (Default): 1.000-1.999
+
+Formula: `tier + (priority / 1000)`
+
+### 4 Approval Modes
+
+1. **default** — ASK_USER decisions prompt user
+2. **autoEdit** — File writes auto-approved with safety checking (conseca)
+3. **yolo** — All auto-approved except explicit ask_user rules
+4. **plan** — Read-only, blocks modifications, allows planning docs
+
+### Shell Command Safety
+
+- Parses multi-command sequences (&&, ;, ||)
+- Detects injection: $(...), `...`, <(...), >(...), --flag=$(...)
+- Each subcommand evaluated independently
+- DENY overrides everything; ASK_USER escalates; ALLOW only if all pass
+- Redirections (>) downgrade ALLOW → ASK_USER unless allowRedirection=true
+
+### Security Constraints
+
+- Extensions cannot contribute ALLOW rules or YOLO mode
+- Regex patterns validated for ReDoS
+- Tool name typos detected via Levenshtein distance ≤3
+- Policy file integrity: SHA-256 hash checking
+
+### Key Insight for Abstraction
+
+Policy is evaluated at the tool execution boundary. For the interface layer:
+
+- If CLI controls tool execution → policy naturally applies
+- If agent controls tool execution internally → policy bypassed (danger!)
+- This reinforces the `pauseOnToolCalls: true` approach for ADK
+- Need a `PolicyEvaluator` interface that any executor can call
+
+---
+
+## Tool System (Complete)
+
+### Core Abstraction Chain
+
+```
+ToolBuilder (metadata + schema)
+  → build(params) validates → ToolInvocation (ready to execute)
+    → shouldConfirmExecute() → execute(signal) → ToolResult
+```
+
+### DeclarativeTool Pattern
+
+- `build(params)` — Validate and create invocation
+- `buildAndExecute(params)` — One-step convenience
+- `validateBuildAndExecute(params)` — Non-throwing variant
+
+### BaseToolInvocation
+
+- Message bus integration for policy decisions
+- Three decision paths: ALLOW → execute, DENY → reject, ASK_USER → confirm
+
+### ToolResult Structure
+
+- `llmContent` — For LLM conversation history
+- `returnDisplay` — For UI presentation
+- `displayContent` — Additional display formatting
+- `errorDetails` — Optional error info
+- `result` — Structured data payload
+- `tailCall` — Optional chaining requests
+
+### Confirmation System (6 types)
+
+1. **edit** — File modification with diff
+2. **execute** — Command execution
+3. **mcp** — MCP tool with allowlist mgmt
+4. **info** — Information-only
+5. **ask_user** — General user approval
+6. **exit_plan_mode** — Plan exit notification
+
+### Confirmation Outcomes (7 values)
+
+ProceedOnce, ProceedAlways, ProceedAlwaysAndSave, ProceedAlwaysServer,
+ProceedAlwaysTool, ModifyWithEditor, Cancel
+
+### Tool Kinds
+
+- **Mutator**: Edit, Delete, Move, Execute
+- **Read-Only**: Read, Search, Fetch
+- **Other**: Think, Agent, Communicate, Plan, SwitchMode, Other
+
+### MCP Tools
+
+- Naming: `mcp_<server>_<toolname>` (64-char limit)
+- Schema validation via LenientJsonSchemaValidator
+- Response types: McpTextBlock, McpMediaBlock, McpResourceBlock,
+  McpResourceLinkBlock
+- Transform to GenAI Parts format
+
+### Error Types (20+)
+
+- **Recoverable**: INVALID_TOOL_PARAMS, FILE_NOT_FOUND,
+  EDIT_NO_OCCURRENCE_FOUND, SHELL_TIMEOUT, MCP_TOOL_ERROR...
+- **Fatal**: NO_SPACE_LEFT (only one!)
+
+### ModifiableTool
+
+- Extends DeclarativeTool with external editor support
+- `getModifyContext()` → temp files → editor opens → `getUpdatedParams()` → diff
+
+---
+
+## Execution Loop (Complete)
+
+### LocalAgentExecutor Flow
+
+1. Collect user hints, setup deadline timer
+2. **Turn loop**: executeTurn() repeatedly until completion
+3. Per-turn: compress chat → callModel() → processFunctionCalls()
+4. On limit hit: executeFinalWarningTurn() with 60s grace period
+5. Return OutputObject { result, terminate_reason }
+
+### AgentTerminateMode
+
+GOAL | TIMEOUT | MAX_TURNS | ABORTED | ERROR | ERROR_NO_COMPLETE_TASK_CALL
+
+### SubagentTool Architecture
+
+```
+Parent Agent
+  └─ SubagentTool (wraps AgentDefinition as DeclarativeTool)
+       └─ SubagentToolWrapper (routes by agent kind)
+            ├─ LocalSubagentInvocation → LocalAgentExecutor
+            ├─ RemoteAgentInvocation → A2AClientManager
+            └─ BrowserAgentInvocation
+```
+
+### Agent Types
+
+- `LocalAgentDefinition` — kind: 'local', has promptConfig, modelConfig,
+  runConfig, toolConfig
+- `RemoteAgentDefinition` — kind: 'remote', has agentCardUrl, auth config
+
+### Key Defaults
+
+- DEFAULT_MAX_TURNS = 15
+- DEFAULT_MAX_TIME_MINUTES = 5
+- A2A_TIMEOUT = 1800000 (30 min for remote agents)
+
+---
+
+## Services/Config (Complete)
+
+### ModelConfigService
+
+- **Alias chains**: Inheritance with `extends`, merged root-to-leaf
+- **Overrides**: Contextual (model, scope, retry, isChatModel), sorted by
+  specificity
+- **Runtime registration**: Dynamic aliases and overrides
+- **Deep merge**: Objects merged, arrays replaced entirely
+
+### ModelRouterService (Strategy Chain)
+
+1. Fallback & Override → 2. Approval Mode → 3. Gemma Classifier → 4. Generic
+   Classifier → 5. Numerical Classifier → 6. Default
+
+### ModelAvailabilityService
+
+- Terminal (permanent), Sticky_retry (one retry per turn), Healthy
+- `selectFirstAvailable()` iterates fallback chain
+- `resetTurn()` at turn boundaries enables fresh retries
+
+### Config (~95KB!)
+
+Central dependency injection. Initializes: ModelAvailabilityService →
+ModelConfigService → FolderTrustDiscoveryService → PolicyEngine →
+FileDiscoveryService → GitService → ToolRegistry → MCP → GeminiClient →
+HookSystem
+
+### CoreEventEmitter (UI Events)
+
+Event types: UserFeedback, ModelChanged, ConsoleLog, Output, RetryAttempt,
+ConsentRequest, McpProgress, Hook, QuotaChanged
+
+Backlog buffering (max 10,000) with head-pointer eviction and auto-compaction.
+
+### Scheduler Types
+
+```typescript
+ToolCallRequestInfo {
+  callId, name, args, originalRequestName,
+  isClientInitiated, prompt_id, checkpoint, traceId,
+  parentCallId, schedulerId
+}
+ToolCallResponseInfo {
+  callId, responseParts, resultDisplay, error, errorType,
+  outputFile, contentLength, data
+}
+CoreToolCallStatus: Validating → AwaitingApproval → Scheduled → Executing → Success|Error|Cancelled
+```
+
+### FolderTrust
+
+Scans: commands (.toml), skills (SKILL.md), settings.json, MCP servers, hooks
+Security warnings: auto-approved tools, autonomous agents, disabled trust,
+disabled sandbox Pattern: discovery → review → execution (no code runs during
+scan)

docs/adk-replat/PRIORITY-ANALYSIS.md

@@ -0,0 +1,349 @@
+# Interface Priority Analysis & Open Questions
+
+## The Big Picture
+
+We're defining **framework-agnostic interfaces** that allow gemini-cli to:
+
+1. Keep its existing execution loop working unchanged (Legacy path)
+2. Swap in ADK as an alternative runtime via config flag
+3. Eventually support OpenRouter or other agent backends
+4. Maintain all existing CLI behavior: hooks, policies, confirmations, UI events
+
+## Proposed Interface Layers (Priority Order)
+
+---
+
+### P0 (Critical Path - Must Define First)
+
+#### 1. AgentEvent / Event Stream Contract
+
+**Why first:** Everything else consumes or produces these events. The UI renders
+them. The hooks intercept them. The adapters translate to/from them.
+
+**Key decision:** Merge Dewitt's simpler model with Coworker's richer model?
+
+**Recommendation:** Coworker's approach is more complete. Key additions:
+
+- `threadId` for sub-agent tracking (AG-UI has `parentRunId`)
+- `tool_update` for progress on long-running tools
+- `elicitation_request/response` as first-class (not just tool_confirmation)
+- `usage` event for token tracking
+- `_meta` escape hatch (matches AG-UI's extensibility philosophy)
+- `initialize` event (matches AG-UI's RunStarted)
+
+**Open questions:**
+
+- Do we need AG-UI's start/content/end triple pattern for streaming? Or is
+  yielding partial events sufficient?
+- How do ContentPart types map to existing gemini-cli Part types?
+- Should events carry a `source` field? (useful for hook attribution)
+
+#### 2. Agent Interface
+
+**Why second:** This is the primary abstraction that LocalAgentExecutor, ADK
+adapters, and future OpenRouter adapters all implement.
+
+**Key decision:** Dewitt's `runAsync/runEphemeral` vs Coworker's
+`send(Trajectory|string)`
+
+**Recommendation:** Hybrid approach:
+
+- Dewitt's `runAsync/runEphemeral` split is ADK-aligned and cleaner for the
+  factory pattern
+- BUT add Coworker's elicitation support via AgentSend union type
+- The Trajectory concept is powerful but may be too opinionated for Phase 2
+
+```
+Agent<TInput, TOutput>
+  name: string
+  description: string
+  runAsync(input, options) → AsyncGenerator<AgentEvent, TOutput>
+  runEphemeral(input, options) → AsyncGenerator<AgentEvent, TOutput>
+```
+
+**Open questions:**
+
+- Should Agent also support `send()` for mid-stream interactions (elicitations)?
+- How does AbortSignal propagate through the adapter boundary?
+- Do we need a `capabilities` field (supports elicitation? supports HITL? etc.)?
+
+#### 3. Tool Execution Contract
+
+**Why third:** Tools are the primary action mechanism. Both the policy engine
+and hooks system wrap tool execution.
+
+**What needs abstracting:**
+
+- Tool declaration (name, schema) — already somewhat generic via JSON Schema
+- Tool execution (args → result)
+- Tool confirmation flow (ASK_USER → user decision → proceed/deny)
+- Tool result shape (llmContent + displayContent + error + tailCalls)
+
+**Key decision:** Keep DeclarativeTool pattern or flatten to a simpler
+interface?
+
+**Recommendation:** Define a minimal `ToolExecutor` interface:
+
+```
+ToolExecutor {
+  name: string
+  description: string
+  schema: JSONSchema
+  execute(args, context): Promise<ToolResult>
+  requiresConfirmation?(args, context): Promise<boolean>
+}
+```
+
+DeclarativeTool remains the concrete implementation. ADK's BaseTool adapts to
+this.
+
+**Open questions:**
+
+- How do MCP tools fit? They already have their own protocol.
+- Tool annotations (destructive hints) — should these be in the interface?
+- Long-running tools need progress reporting — how does this interact with
+  tool_update events?
+
+---
+
+### P1 (Important - Define After P0)
+
+#### 4. Policy / Permission Interface
+
+**Why important:** Every tool call goes through policy. External agents need
+policy enforcement too.
+
+**Current state:** gemini-cli has a sophisticated TOML-based policy engine with
+tiered priorities. ADK-TS has a simpler SecurityPlugin with PolicyOutcome
+(DENY/CONFIRM/ALLOW).
+
+**What needs abstracting:**
+
+```
+PolicyEngine {
+  evaluate(toolName, args, context): PolicyDecision  // ALLOW | DENY | ASK_USER
+  getExcludedTools(): string[]  // Tools statically denied
+}
+```
+
+**Key decision:** Do external agents (OpenRouter, etc.) get the same policy
+enforcement?
+
+**Open questions:**
+
+- If an ADK agent calls a tool internally, does gemini-cli's policy apply?
+- With `pauseOnToolCalls: true` in ADK, the CLI controls execution — but what
+  about headless mode?
+- How do agent-level policies work? (allow/deny entire agents, not just tools)
+- Should policy be a middleware (AG-UI pattern) or a callback (ADK plugin
+  pattern)?
+
+#### 5. Hooks Interface
+
+**Why important:** Hooks are a major gemini-cli feature. They need to work
+regardless of which agent backend runs.
+
+**Current state:** 11 hook types firing at specific lifecycle points.
+
+**What needs abstracting:**
+
+- Hook lifecycle must be backend-agnostic
+- BeforeModel/AfterModel hooks need to work even when ADK controls the model
+- BeforeTool/AfterTool hooks need to intercept regardless of who executes the
+  tool
+
+**Key challenge:** When ADK runs the model internally, gemini-cli hooks can't
+easily intercept. **Dewitt's solution:** ADK uses gemini-cli's model via
+AdkGeminiModel adapter — hooks fire inside GeminiChat.
+
+**Open questions:**
+
+- If OpenRouter runs the model, how do BeforeModel/AfterModel hooks work?
+- Do we need a "model steering" abstraction (injecting context mid-stream)?
+- Can hooks be expressed as AG-UI middleware? (intercept event stream)
+
+#### 6. Model / LLM Interface
+
+**Why important:** Model abstraction enables swapping LLM providers.
+
+**Dewitt's approach:** Exposes Model interface, ADK uses it via AdkGeminiModel
+adapter. **Coworker's approach:** Model is internal to Agent (no separate Model
+interface).
+
+**Recommendation:** Keep Dewitt's separate Model interface BUT make it
+provider-agnostic:
+
+- Remove `@google/genai` types from the interface signature
+- Define generic Message/Content types
+- Model interface is an implementation detail, not part of the Agent contract
+
+**Open questions:**
+
+- Can we define a truly provider-agnostic Model interface?
+- Or is the Model always tied to the agent backend? (ADK uses Gemini, OpenRouter
+  uses whatever)
+- Model routing (choosing which model) — is this a concern of the Model
+  interface or a separate service?
+
+---
+
+### P2 (Important but Can Follow)
+
+#### 7. Session / State Interface
+
+**Current state:** gemini-cli uses ChatRecordingService (JSON files). ADK uses
+Session with BaseSessionService.
+
+**What needs abstracting:**
+
+- Session creation/retrieval
+- State persistence across turns
+- History/trajectory management
+
+**Open questions:**
+
+- Does the trajectory (coworker's concept) replace gemini-cli's chat recording?
+- Should session state be shared between gemini-cli and the agent backend?
+
+#### 8. Elicitation / User Interaction Interface
+
+**What it covers:** Model fallback dialogs, tool confirmations, Ctrl+B
+interrupts, user questions
+
+**Current state:** gemini-cli uses ConfirmationBus + MessageBus. AG-UI uses
+frontend tools.
+
+**Open questions:**
+
+- Is elicitation just a special case of tool calls (AG-UI approach)?
+- Or is it a first-class event type (coworker's approach)?
+- How does Ctrl+B (cancel/interrupt) propagate through the agent boundary?
+
+#### 9. Configuration / Capability Discovery
+
+**What it covers:** Feature flags, experiment settings, agent capabilities
+
+**Open questions:**
+
+- How does an external agent declare its capabilities?
+- Does OpenRouter support HITL? Elicitation? Tool confirmation? Each agent may
+  differ.
+- Need a `capabilities` negotiation at connection time?
+
+---
+
+### P3 (Future / Can Defer)
+
+#### 10. A2UI / Rich UI Interface
+
+- Declarative UI generation from agents
+- Not critical for Phase 2 but important for differentiation
+
+#### 11. Memory / Artifact Interface
+
+- ADK has memory/artifact services
+- gemini-cli has ChatRecordingService + memory tools
+- Can standardize later
+
+#### 12. Telemetry / Observability Interface
+
+- Both systems have telemetry
+- Can standardize later
+
+---
+
+## Critical Open Questions (Need Team Discussion)
+
+### 1. OpenRouter Integration Model
+
+**Question:** When OpenRouter (or any external agent) is used, what does the
+integration look like?
+
+**Option A: Full Agent Interface** — OpenRouter implements the Agent interface
+directly
+
+- Pro: Clean, uniform
+- Con: OpenRouter doesn't support HITL, hooks, policies natively
+
+**Option B: ACP Shim** — Agent Communication Protocol between CLI and external
+agents
+
+- Pro: Standards-based
+- Con: Additional protocol layer, may be premature
+
+**Option C: Model-only Integration** — OpenRouter is just an alternative Model,
+not Agent
+
+- Pro: Simpler, leverages existing agent loop
+- Con: Doesn't support OpenRouter-specific features
+
+**Recommendation:** Start with Option C (model-only). OpenRouter provides an LLM
+endpoint. Gemini-cli's own agent loop handles tools, policies, hooks. This means
+defining a provider-agnostic Model interface is the key enabler.
+
+### 2. Tool Execution: Client-side vs Agent-side
+
+**Question:** Who executes tools — the CLI or the agent backend?
+
+**Option A: Always client-side** (CLI executes, agent suspends)
+
+- ADK: `pauseOnToolCalls: true`
+- Pro: CLI maintains control, policies enforced, hooks fire
+- Con: Higher latency, more round-trips
+
+**Option B: Agent-side execution** (agent runs tools internally)
+
+- Pro: Faster, simpler
+- Con: Bypasses CLI policies, hooks, confirmations
+
+**Option C: Configurable** — CLI decides per-tool or per-agent
+
+- Pro: Flexible
+- Con: Complex
+
+**Recommendation:** Option A for safety-critical CLI use case. Option B only for
+trusted/sandboxed sub-agents.
+
+### 3. Model Steering (Hooks that inject context mid-stream)
+
+**Question:** How do user-local hooks (like injecting project context) work with
+external agents?
+
+**Answer:** They can only work if:
+
+- The CLI controls the model (via Model interface adapter) — then BeforeModel
+  hook injects context
+- OR the agent supports a "system instruction update" mechanism
+
+For OpenRouter: model steering works because CLI controls the model call. For
+ADK: model steering works because AdkGeminiModel wraps GeminiChat. For fully
+opaque agents: model steering **cannot work** — this is a known limitation.
+
+### 4. Elicitation Flow
+
+**Question:** When the agent needs user input (model fallback, clarification),
+how does it work?
+
+**For CLI-controlled agents:** Agent yields an elicitation_request event → CLI
+renders prompt → user responds → CLI sends response back via session.stream({
+kind: 'elicitation_response', ... }) to resume
+
+**For external agents:** Agent uses A2A protocol or similar to send elicitation
+→ CLI bridges the request to user → response sent back via protocol
+
+**Key insight:** Elicitation is fundamentally about the agent SUSPENDING and
+waiting for user input. ADK already supports this via `pauseOnToolCalls`. Can we
+generalize to `pauseOnElicitation`?
+
+### 5. Sub-agent Identity and Policies
+
+**Question:** When a sub-agent spawns, does it inherit parent policies? Get its
+own?
+
+**Current gemini-cli behavior:** Sub-agents registered as tools, go through same
+policy engine. **ADK behavior:** Sub-agents are child nodes in agent tree, get
+parent's plugins.
+
+**Recommendation:** Sub-agents inherit parent policy context. Additional
+restrictions can be layered (e.g., sub-agent X cannot use shell tool). This is
+already how gemini-cli works.

docs/adk-replat/adk_migration_design_doc.md

@@ -0,0 +1,438 @@
+# Architectural Design: Gemini CLI to ADK Migration
+
+| Authors: [Adam Weidman](mailto:adamfweidman@google.com)  Contributors:  Reviewers: *See section [Status of this document](#status-of-this-document).* | Status: Draft  Last revised: Apr 7, 2026 Visibility: Confidential |
+| :--- | :--- |
+
+---
+
+# Goal
+
+To migrate the Gemini CLI backend execution engine from its legacy fragmented loop structure to the Agent Development Kit (ADK). This migration will unify how agents and subagents are orchestrated, simplify state persistence, and expose a standard `AgentSession` interface for the CLI, future SDK surfaces, and subagent execution.
+
+---
+
+# Context
+
+Over time, Gemini CLI has accumulated complex runtime behaviors: multi-tier tool scheduling, policy-driven approvals, payload masking, dynamic routing, and fine-grained telemetry. Integrating these with ADK requires a clean boundary that preserves Gemini CLI semantics without forking ADK core behavior.
+
+The key migration boundary is:
+
+- ADK runtime semantics -> Gemini CLI `AgentProtocol` / `AgentSession`
+- ADK `Event` stream -> Gemini CLI `AgentEvent` stream
+
+That boundary, not the model wrapper alone, is the architectural center of this design.
+
+---
+
+# Current State and Proposed Mappings
+
+The following analysis maps existing Gemini CLI components onto ADK capabilities, citing both repositories (`gemini-cli` and `adk-js`).
+
+## Core Runtime Architecture
+
+The migration uses one shared ADK-backed runtime core. Every orchestrated agent, including subagents, is exposed through the same external session contract:
+
+- **Top-level CLI agent** -> `AgentSession`
+- **Future SDK entry point** -> `AgentSession`
+- **Subagent execution** -> `AgentSession`
+
+The runtime owns:
+
+- ADK runner/session lifecycle
+- tool execution
+- policy integration
+- routing, availability, compaction, and masking hooks
+- persistence integration
+
+The adapters own:
+
+- `streamId` timing guarantees
+- replay / reattach behavior
+- translation from ADK `Event` to Gemini CLI `AgentEvent`
+- top-level versus subagent event projection
+- projection of a child `AgentSession` into parent-facing tool or thread events when a subagent is embedded inside another agent
+
+The minimum shape is:
+
+```typescript
+interface PipelineServices {
+  run(
+    request: LlmRequest,
+    baseModel: BaseLlm,
+    stream: boolean,
+  ): AsyncGenerator<LlmResponse, void>;
+  connect(
+    request: LlmRequest,
+    baseModel: BaseLlm,
+  ): Promise<BaseLlmConnection>;
+}
+
+class GcliAgentModel extends BaseLlm {
+  constructor(
+    private baseModel: BaseLlm,
+    private pipeline: PipelineServices,
+  ) {
+    super({model: 'gcli-consolidated'});
+  }
+
+  async *generateContentAsync(
+    request: LlmRequest,
+    stream = false,
+  ): AsyncGenerator<LlmResponse, void> {
+    yield* this.pipeline.run(request, this.baseModel, stream);
+  }
+
+  async connect(request: LlmRequest): Promise<BaseLlmConnection> {
+    return this.pipeline.connect(request, this.baseModel);
+  }
+}
+```
+
+Design rule:
+
+- request mutation stays in the pipeline
+- all orchestrated agents expose the same `AgentSession` contract
+- session lifecycle, replay, approvals, and subagent projection stay in the runtime/adapters
+
+`AdkAgentService` is the composition root for this architecture. It creates and resumes both top-level and subagent `AgentSession`s, builds scoped registries and message-bus instances, wires policy and approval bridges, and embeds child sessions through projection adapters rather than through a separate subagent runtime. See Appendix A for the intended initialization shape.
+
+Composition rule:
+
+- stateful tools are cloned or reinstantiated per session when needed; stateless tools may be shared
+- MCP discovery is shared at the manager layer but registered into session-local tool, prompt, and resource registries
+- `AgentLoopContext` is decomposed into pipeline config, tool/subagent config, session services, callback bridges, and UI projection rather than passed through as a single runtime object
+- file persistence remains Gemini CLI-owned through `GcliFileSessionService extends BaseSessionService`
+
+Persistence rule:
+
+- persisted history is an append-only event log plus derived app/user/session state
+- the session service provides atomic append, crash-safe recovery, and single-writer enforcement
+- rewind truncates the event log, recomputes derived state, and invalidates confirmation/resumption state past the rewind point
+
+## 3.1 Authentication Flexibility
+
+The CLI resolves distinct authentication flows (OAuth, ADC, Compute metadata) using standard Google libraries.
+
+*   **Current State:** Resolved in `packages/core/src/code_assist/oauth2.ts` based on `AuthType`.
+    *   OAuth (`LOGIN_WITH_GOOGLE`)
+    *   Compute Metadata Server (`COMPUTE_ADC`)
+*   **Constraint:** Standard `Gemini` construction in `adk-js/core/src/models/google_llm.ts` still selects backend from constructor-level `apiKey` or Vertex config. It does **not** natively accept Gemini CLI's `AuthClient`-driven auth shape.
+*   **Proposed ADK Mapping:** Phase 1 keeps auth in `GcliAgentModel`. The pipeline resolves refreshed credentials and injects them through `request.config.httpOptions.headers` for unary requests and `request.liveConnectConfig.httpOptions.headers` for live connections.
+*   **Design position:** This is a **bridge**, not native ADK auth parity. Long-term cleanup is either:
+    *   a `CodeAssistLlm extends BaseLlm`, or
+    *   an upstream ADK auth-provider abstraction.
+
+```typescript
+request.config ??= {};
+request.config.httpOptions ??= {};
+request.config.httpOptions.headers = {
+  ...request.config.httpOptions.headers,
+  Authorization: `Bearer ${await auth.getAccessToken()}`,
+};
+```
+
+## 3.2 Model Steering and Mid-Stream Injection
+
+User interjections (hints) course-correct the loop mid-turn.
+
+*   **Current State:** Steering today is tied to the legacy loop and injection services.
+*   **Proposed ADK Mapping (Next-Step Steering):** Supported in Phase 1. `beforeModelCallback` can read queued hints and mutate the next outbound request.
+*   **Proposed ADK Mapping (True Real-Time Interrupt):** Still blocked. TypeScript ADK live runtime is not complete yet, and input-stream semantics are not a stable dependency.
+*   **Phase 1 behavior:** user interjections are queued and prepended to the next model request at tool or turn boundaries. True in-place turn interruption remains out of scope.
+
+## 3.3 State Management and Token Compaction
+
+The CLI truncates large tool responses and summarizes older history to protect token budgets.
+
+*   **Current State:** `ChatCompressionService` in `packages/core/src/context/chatCompressionService.ts` implements reverse token budgeting and a two-phase verification loop.
+*   **Proposed ADK Mapping:** Compaction remains a Gemini CLI-owned history processor invoked by the request pipeline.
+*   **Design position:** Phase 1 does **not** force this onto ADK `BaseContextCompactor`. Gemini CLI compression is currently an outbound-history projection with truncation plus summary/verification sub-calls, while ADK's native compactor path is event-log-centric and mutates session history.
+*   **Design choice:** In Phase 1, compaction mutates **outgoing request history only**. The persisted session event log remains canonical.
+*   **Utility calls:** Compaction sub-calls use the same routing, auth, and availability pipeline as primary model calls.
+
+## 3.4 Model Configuration and Hierarchical Overrides
+
+Dynamic aliasing (for example, temperature scoped to specific sub-commands).
+
+*   **Current State:** Managed by `ModelConfigService`.
+*   **Proposed ADK Mapping:** Resolution stays **request-scoped**, not session-init-scoped.
+*   **Design choice:** The session stores requested model and override state. The runtime resolves the concrete model and temperature on each request, including retries, subagents, and utility calls.
+
+## 3.5 Universal Policy Enforcement (TOML Rules)
+
+Tiered workspace restrictions (for example, read-only tools in untrusted folders).
+
+*   **Current State:** Intercepted at tool scheduling time in legacy scheduler loops.
+*   **Proposed ADK Mapping (Container):** Standardize on ADK `SecurityPlugin`.
+*   **Proposed ADK Mapping (Decision Brain):** Implement `GcliPolicyEngineAdapter implements BasePolicyEngine`.
+*   **Richer context:** The adapter is fed session/mode/subagent/MCP metadata from the runtime so current Gemini CLI policy semantics are preserved as closely as possible.
+*   **Phase 1 suspension flow:** current tool approvals use existing Gemini CLI callbacks. This is intentionally **non-native** and **non-resumable across process death**.
+*   **Long-term target:** move the same policy decisions onto native ADK confirmation/resumption semantics once the broader live/elicitation surface is ready.
+
+```typescript
+interface GcliPolicyBridge {
+  evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
+}
+
+export class GcliPolicyEngineAdapter implements BasePolicyEngine {
+  constructor(private readonly policyBridge: GcliPolicyBridge) {}
+
+  async evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult> {
+    return this.policyBridge.evaluate(context);
+  }
+}
+```
+
+## 3.6 Telemetry and Observability (Clearcut Tracking)
+
+Hardware metrics, token counts, and step durations.
+
+*   **Current State:** `ClearcutLogger` reads system metrics and relies on deep scheduler hooks for latency accounting.
+*   **Proposed ADK Mapping:** Use a combination of:
+    *   passive event-stream observation, and
+    *   explicit runtime instrumentation where passive ADK events are insufficient.
+*   **Correlation rule:** tool timing is keyed by `functionCall.id`, **not** by `event.id`.
+*   **Design position:** Passive stream interception alone is not assumed to provide full parity.
+
+## 3.7 Dynamic Model Routing and Configurability
+
+Banning a model mid-turn, auto-routing via classifiers, and falling back dynamically without reinitializing the session.
+
+*   **Current State:** Managed by `ModelRouterService` and a chain of `RoutingStrategy` implementations which require the full `RoutingContext` (`history`, `request`, `AbortSignal`).
+*   **Proposed ADK Mapping:** Mostly implementable now, but not “100% possible today” without bridge logic.
+*   **Design choice:** The runtime constructs a proper `RoutingContext` from:
+    *   canonical session history
+    *   the pending user request
+    *   requested model
+    *   abort signal
+*   **Execution point:** routing remains request-scoped and runs before final dispatch.
+*   **Model banning:** treated as routing/fallback selection, not as a synthetic terminal model error.
+
+## 3.8 Fallbacks and Availability Management
+
+Ensuring availability by retrying or switching models when rate limits (429s) or terminal faults occur.
+
+*   **Current State:** Managed by `ModelAvailabilityService` and `ModelPool`.
+*   **Proposed ADK Mapping (Preflight):** availability and fallback selection run before dispatch and before routing commits to a concrete model.
+*   **Proposed ADK Mapping (Post-failure):** handled separately by the runtime. Availability state mutation and retry decisions are not treated as pure request preprocessing.
+*   **Global Application:** utility calls use the same availability/fallback services as primary model calls.
+*   **Retry safety rule:** automatic full-turn replay is allowed only before any side-effecting tool has executed. After side effects, the runtime surfaces the failure and requires explicit user action.
+*   **Phase 1 transition path:** approvals and fallback prompts continue to use existing Gemini CLI callbacks. The doc treats this as an internal bridge, not as an existing standard ADK elicitation API.
+
+## 3.9 State-Driven Mode Switching (Plan Mode)
+
+Dynamically shifting system prompts and active tools when users switch interaction tiers (for example, Chat Mode to Plan Mode).
+
+*   **Current State:** Toggled via `/plan`, which changes `ApprovalMode` and related legacy scheduler behavior.
+*   **Proposed ADK Mapping (Dynamic Prompt):** Use `InstructionProvider` in `LlmAgentConfig.instruction`.
+*   **Proposed ADK Mapping (Dynamic Tooling):** Use a custom `BaseToolset` whose filter is derived from session mode.
+*   **Single source of truth:** mode is session/runtime state derived from current approval mode; prompt, toolset, policy, routing, and UI all consume the same state.
+
+```typescript
+export class GcliModeAwareToolset extends BaseToolset {
+  constructor(
+    private readonly chatTools: BaseTool[],
+    private readonly planTools: BaseTool[],
+  ) {
+    super(() => true);
+  }
+
+  async getTools(context?: ReadonlyContext): Promise<BaseTool[]> {
+    const isPlan = context?.state.get('plan_mode') === true;
+    return isPlan ? this.planTools : this.chatTools;
+  }
+
+  async close(): Promise<void> {}
+}
+```
+
+## 3.10 Tool Output Masking
+
+Managing context window efficiency by offloading bulky tool outputs (for example, shell logs and large file reads) to files.
+
+*   **Current State:** `ToolOutputMaskingService` in `packages/core/src/context/toolOutputMaskingService.ts`.
+*   **Proposed ADK Mapping:** masking runs on **outgoing request history only**, after compaction.
+*   **Design choice:** persisted session history remains the canonical event log. Masking artifacts are session-scoped files referenced from the outbound request projection.
+
+---
+
+# 5. Known Gaps in ADK (Gating Blockers)
+
+This section highlights existing gaps in standard ADK that prevent a seamless cutover without bridge logic or upstream changes.
+
+## 5.1 Real-Time User Message Injections (Aborted Turns)
+
+While next-step steering is possible today using `beforeModelCallback`, true real-time interruption requires:
+
+- stable input-stream support, and
+- a complete TypeScript live runtime
+
+Until then, the supported behavior is queued next-step steering at model boundaries, not mid-stream interruption.
+
+## 5.2 Conversation Rewind and State Reversal
+
+Translating manual trajectory drops to ADK runtime state is cumbersome. While Python ADK supports rollback, TypeScript ADK does not yet support it natively.
+
+*   **Resolution Strategy:** Gemini CLI implements rewind in `GcliFileSessionService`, but **not** as a shallow JSON edit. Rewind truncates the event log, recomputes derived state, and invalidates any confirmation/resumption state past the rewind point.
+
+## 5.3 Phase 1 Non-Goals
+
+To keep the migration surface bounded, Phase 1 intentionally excludes:
+
+- non-interactive surfacing of `elicitation_request` / `elicitation_response`
+- true live/bidi interruption semantics
+- native ADK confirmation/resumption parity for approvals and fallback prompts
+
+---
+
+# Long-Term Vision: Unification of Agents and Subagents
+
+The long-term vision is that subagents and the primary agent share:
+
+- the same runtime core
+- the same tool definitions
+- the same policy constraints
+- the same configuration schemas
+- the same orchestration contract: `AgentSession`
+
+What may differ is the **embedding adapter**:
+
+- standalone/top-level agent -> consumed directly as `AgentSession`
+- subagent embedded by a parent agent -> projected from its `AgentSession` into parent-facing tool or child-thread events
+
+For SDK-first unification, Gemini CLI orchestration targets `AgentSession`, not a specific ADK tool abstraction. When a subagent must be exposed to a parent model as a tool, Gemini CLI wraps that child `AgentSession` with a `FunctionTool` or custom `BaseTool` projection. `AgentTool` remains the native ADK nested-agent option if we later want full ADK-native nested-agent semantics.
+
+---
+
+# Migration Sequence and Unification Checklist
+
+The migration remains non-sequential, but each phase has an explicit success condition:
+
+- [ ] **Non-interactive session parity** `#22699`
+  output/error parity, basic replay correctness, feature-flagged rollout
+- [ ] **Interactive session parity** `#22701`
+  projected event parity, approval bridge wiring, no live-interrupt claim
+- [ ] **Subagent adapter parity** `#22700`
+  tool isolation, activity projection, policy/routing parity for child runs
+- [ ] **ADK session conformance** `#22974`
+  `AgentSession` timing/replay guarantees preserved by the adapter
+- [ ] **Skills parity** `#22966`
+  skills work through the shared runtime without special legacy paths
+- [ ] **Policy and confirmation parity** `#22964`
+  phase-1 callback bridge stable; native confirmation migration scoped separately
+- [ ] **Compaction quality parity** `#22979`
+  comparable summarization and truncation quality to current behavior
+
+---
+
+# Appendix A: Initialization Sketch
+
+The main agent and subagents share the same composition root. The difference is whether the resulting `AgentSession` is consumed directly or projected into a parent session.
+
+```typescript
+shared = {
+  baseModel,
+  modelConfigService,
+  availabilityService,
+  router,
+  authService,
+  policyEngine,
+  mcpClientManager,
+  skillCatalog,
+  baseToolCatalog,
+  sessionService,
+}
+
+agentService = new AdkAgentService(shared)
+
+function createSession(definition, parentSessionId?) {
+  sessionRecord = sessionService.create({ definition, parentSessionId })
+  registries = buildScopedRegistries(definition, parentSessionId)
+  pipeline = createPipeline({
+    sessionId: sessionRecord.id,
+    agentId: definition.name,
+    parentSessionId,
+  })
+
+  model = new GcliAgentModel(baseModel, pipeline)
+  runtime = createAdkRuntime({
+    definition,
+    model,
+    sessionRecord,
+    registries,
+    policyEngine,
+  })
+
+  return new AgentSession(new AdkAgentProtocolAdapter(runtime))
+}
+
+function createSubagentTool(definition) {
+  return new FunctionTool(async (input, toolContext) => {
+    child = createSession(definition, toolContext.sessionId)
+    stream = await child.send(userMessage(input))
+
+    for await (event of child.stream(stream)) {
+      projectChildEventToParent(toolContext, event)
+    }
+
+    return collectFinalText()
+  })
+}
+```
+
+Child session projection shape:
+
+```typescript
+emit(tool_request({ requestId, name: definition.name, args: input }))
+
+for await (event of childSession.stream({ streamId })) {
+  if (event.type === 'message' || event.type === 'tool_update') {
+    emit(
+      tool_update({
+        requestId,
+        content: projectDisplayContent(event),
+      }),
+    )
+    continue
+  }
+
+  if (event.type === 'error') {
+    emit(
+      tool_response({
+        requestId,
+        name: definition.name,
+        isError: true,
+        content: projectErrorContent(event),
+      }),
+    )
+    return
+  }
+
+  if (event.type === 'agent_end') {
+    emit(
+      tool_response({
+        requestId,
+        name: definition.name,
+        content: collectFinalChildResult(),
+      }),
+    )
+    return
+  }
+}
+```
+
+Only the final `tool_response` is returned to the parent model. `tool_update` remains a progress/UI projection surface.
+
+Service lifetime split:
+
+- shared across sessions: model config, availability, routing, auth, policy engine, MCP manager, skill catalog
+- scoped per agent/session: `AgentSession`, pipeline instance, tool/prompt/resource registries, derived message bus
+- scoped per invocation: shell process, MCP request, confirmation continuation, tool progress updates
+
+---
+
+# Status of this document approvals table {#status-of-this-document}
+
+| #begin-approvals-addon-section See [go/g3a-approvals](http://goto.google.com/g3a-approvals) for instructions on adding reviewers. |
+| :---: |
+.

docs/adk-replat/unified-review.md

@@ -0,0 +1,554 @@
+# Unified ADK CLI Design Review
+
+Date: 2026-04-06
+
+> **Rollout:** All ADK migration work is feature-gated behind `experimental.adk` flags. No behavioral changes ship without an explicit opt-in. This applies to both non-interactive and interactive flows.
+
+Inputs merged:
+- `claude-adk-cli-design-review.md` (adversarial code-level review)
+- `codex-adk-cli-design-review.md`
+- Follow-up review discussion on subagent architecture, session semantics, and `BaseContextCompactor`
+
+Scope reviewed:
+- `gemini-cli/docs/adk-replat/adk_migration_design_doc.md`
+- `gemini-cli` `AgentProtocol` / `AgentSession` / interactive migration work
+- `adk-js` runner / session / tool / security / model architecture
+- PR context for interactive migration, including `google-gemini/gemini-cli#24297`
+
+## Executive Summary
+
+The design is directionally sound and the migration goal is correct. However, the document is not yet principal-review ready due to:
+
+1. **Four non-compilable code samples** (C1-C4) that will immediately erode reviewer confidence
+2. **An under-specified translation boundary** — the ADK→AgentProtocol mapping is the real architecture, but the doc treats it as an afterthought
+3. **Overclaimed parity** in routing, telemetry, and approvals
+4. **Missing phased plan** with clear milestones and non-goals
+
+The central architectural insight is right: the migration boundary is:
+
+- `adk-js Event -> Gemini CLI AgentEvent`
+- `adk-js session/runtime semantics -> AgentProtocol / AgentSession semantics`
+
+That boundary carries stream lifecycle, replay/resume, event projection, approval correlation, and persistence correctness. Until the translation architecture is explicit, parity claims remain unsupported.
+
+## Compilation Blockers (Must Fix First)
+
+These are binary errors — the code samples in the design doc will not compile against current ADK types.
+
+### C1. `LlmRequest` has no `headers` field
+
+`adk-js/core/src/models/llm_request.ts` defines: `model?`, `contents`, `config?`, `liveConnectConfig`, `toolsDict`. The design doc's `request.headers = {...}` will silently fail or not compile. **Fix:** use `llmRequest.config.httpOptions.headers` or pass headers at `Gemini` constructor time.
+
+### C2. `BaseLlm.connect()` is abstract and unimplemented
+
+`adk-js/core/src/models/base_llm.ts:67-78` has TWO abstract methods: `generateContentAsync` and `connect()`. `GcliAgentModel` must implement both. **Fix:** add `connect()` — stub with `throw new Error('not supported')` if live connections are out of scope.
+
+### C3. `BaseToolset` constructor signature is wrong
+
+`adk-js/core/src/tools/base_toolset.ts:46-49`: `constructor(readonly toolFilter: ToolPredicate | string[], readonly prefix?: string)`. The design doc's `super([])` passes an empty array as `toolFilter`, which makes `isToolSelected` return false for all tools — a silent bug. Also `close()` is abstract and must be implemented. **Fix:** match the actual signature.
+
+### C4. `FunctionalTool` does not exist
+
+The design doc references `FunctionalTool` for subagent wrapping. This class does not exist in adk-js. The correct classes are `FunctionTool` (wraps a plain function) and `AgentTool` (wraps an agent with isolated runner). See subagent architecture section below for the recommended approach.
+
+---
+
+## High-Risk Findings
+
+### 1. The actual migration boundary is under-specified
+
+Current `AgentProtocol` requires `send()` timing guarantees, replay/reattach semantics, `streamId`, and optional `threadId` for subagent threads in `gemini-cli/packages/core/src/agent/types.ts` and `gemini-cli/packages/core/src/agent/agent-session.ts`.
+
+ADK emits a different event model in `adk-js/core/src/events/event.ts`.
+
+The doc needs a first-class architecture section for:
+- `AdkSessionRuntime`
+- `AdkEventTranslator`
+- event buffering / replay
+- `threadId` mapping
+- `tool_update` mapping
+- `agent_start` / `agent_end` ownership
+
+Without that, the rest of the design sits on an unstated core contract.
+
+### 2. The consolidated decorator needs two concerns extracted
+
+The `GcliAgentModel.generateContentAsync` pipeline is a reasonable orchestrator pattern — each concern is a separate injected service call, not a monolithic class. However, two concerns don't belong in the model layer:
+
+- **Quota/availability prompting** — involves interactive UI suspension, not request mutation. Should use `beforeModelCallback` on `LlmAgent`.
+- **Policy/approval control flow** — involves blocking for user input. Should use `beforeToolCallback` or the `ApprovalBridge` (see architecture section).
+
+The remaining concerns (auth header injection, routing/model rewrite, compaction, masking) are legitimate request-preprocessing and can stay in the model pipeline.
+
+### 3. The design frequently conflates “possible with custom logic” with “supported by current ADK architecture”
+
+This is one of the main wording risks.
+
+Several statements currently read like native ADK parity when the real meaning is:
+- possible with substantial Gemini CLI-owned bridge logic
+- possible by bypassing native ADK facilities
+- possible only for phase 1 with intentionally degraded semantics
+
+That distinction needs to be explicit everywhere the doc uses strong language like “validated” or “100% possible today.”
+
+### 4. Auth architecture is deeper than header injection — Coast Assist requires a custom transport
+
+The auth section has two distinct problems:
+
+**Problem A: API surface mismatch (C1).** `LlmRequest` has no `headers` field. Per-request headers are possible via `llmRequest.config.httpOptions.headers`, and `Gemini` constructor accepts a `headers` param (`google_llm.ts:57,79`). This is fixable.
+
+**Problem B: Coast Assist / `LOGIN_WITH_GOOGLE` uses a different backend entirely.** The current `CodeAssistServer` (`packages/core/src/code_assist/server.ts:407`) does NOT call the standard Gemini API. It uses `google-auth-library`'s `AuthClient.request()` to talk to a Code Assist backend endpoint. The OAuth flow (`packages/core/src/code_assist/oauth2.ts`) handles browser launch (L305), local callback server (L492-615), token exchange (L546-550), credential caching (L739-750), and automatic token refresh via `OAuth2Client`.
+
+This means `GcliAgentModel` cannot wrap a standard `Gemini` BaseLlm and just inject headers. For Coast Assist auth, `GcliAgentModel` must **extend `BaseLlm` directly** and implement its own HTTP transport using `AuthClient.request()`, translating between `LlmRequest`/`LlmResponse` and the Code Assist protocol.
+
+What works:
+- The OAuth dance itself (browser launch, token caching, refresh) runs before the agent session starts — no blocking inside `generateContentAsync`
+- `OAuth2Client.getAccessToken()` handles mid-session token refresh transparently
+- Per-request header injection works for API-key-based auth via `httpOptions.headers`
+
+What the design doc must change:
+- Stop assuming `Gemini` as the inner model — `GcliAgentModel extends BaseLlm` directly
+- Define two transport paths: standard Gemini API (API key) and Code Assist backend (OAuth)
+- The dummy-key workaround is irrelevant for Coast Assist — you never call `GoogleGenAI.models.generateContent`
+
+### 5. Approval / elicitation bridging is acceptable only as a temporary non-native bridge
+
+The design’s callback-based approval approach is pragmatic for phase 1, but it bypasses native ADK confirmation semantics.
+
+`adk-js/core/src/plugins/security_plugin.ts` and `adk-js/core/src/agents/processors/request_confirmation_llm_request_processor.ts` show that ADK’s model is:
+- `ALLOW | DENY | CONFIRM`
+- persisted confirmation state
+- later resumption from history
+
+Blocking in callbacks may be acceptable for the first rollout, but the doc must say clearly:
+- local-only bridge
+- not resumable across process death
+- not long-term SDK behavior
+- intentionally non-native pending future elicitation/bidi work
+
+### 6. Rewind is deeper than file truncation
+
+The doc treats rewind as storage truncation. The storage part is straightforward — `GcliFileSessionService` wraps the existing `ChatRecordingService` and implements 4 abstract methods (`createSession`, `getSession`, `listSessions`, `deleteSession`). DB-level concerns (locking, stale-writer detection, `PESSIMISTIC_WRITE`) do not apply to a single-user CLI.
+
+However, rewind itself is not just storage:
+- `adk-js/core/src/agents/processors/request_confirmation_llm_request_processor.ts` scans event history to reconstruct pending confirmations and resume tool execution
+- `adk-js/core/src/runner/runner.ts:447` has a TODO acknowledging the event log is used as a transaction log
+- Truncating events without rolling back derived state (pending confirmations, app/user state prefixes) will break resumption
+
+The doc should define rewind as: event-log truncation + session state recomputation + confirmation/auth state rollback.
+
+Note: `BaseSessionService.appendEvent` handles state merging with `app:`, `user:`, `temp:` prefixed keys automatically — this is inherited for free.
+
+### 7. Routing, telemetry, and plan mode are all overclaimed
+
+Routing:
+- current routing requires a richer `RoutingContext`
+- `contents.slice(0, -1)` / `contents.pop()` is not a sufficient or type-accurate mapping
+- model banning via simulated error is not the same as model routing
+
+Telemetry:
+- **The stream-interceptor approach in section 3.6 is wrong.** The correct mechanism is ADK's `BasePlugin` system.
+- `event.id` is not a safe per-tool correlation key — use `functionCall.id` via `beforeToolCallback`/`afterToolCallback`
+- ADK can batch multiple function calls or responses in one event — stream interception cannot distinguish them, but plugin hooks fire per-tool with distinct `functionCallId`
+- **Correction:** Token usage IS available on ADK events. `llm_agent.ts:831-834` spreads `LlmResponse` (including `usageMetadata`) into the event via `createEvent({...modelResponseEvent, ...llmResponse})`. Additionally, `afterModelCallback` receives the raw `LlmResponse` with `usageMetadata` directly — providing a second capture point.
+- HTTP-level metrics (status code, request duration) are NOT on ADK events — must be captured in the `GcliAgentModel` wrapper
+- The sample APIs in the design do not match the current `ClearcutLogger` taxonomy (~195 distinct metadata keys)
+
+**Recommended telemetry architecture:**
+
+| Metric Category | Capture Mechanism | ADK Hook |
+|---|---|---|
+| Token counts (input, output, cached, thinking) | `afterModelCallback` → `LlmResponse.usageMetadata` | `BasePlugin.afterModelCallback` |
+| Per-tool timing | Timer keyed on `functionCallId` | `BasePlugin.beforeToolCallback` / `afterToolCallback` |
+| Agent lifecycle | Start/end tracking | `BasePlugin.beforeAgentCallback` / `afterAgentCallback` |
+| Model errors | Error classification | `BasePlugin.onModelErrorCallback` |
+| HTTP status, API duration | Captured in model wrapper | `GcliAgentModel.generateContentAsync` |
+| Routing decisions, latency | Captured in model or beforeModelCallback | `beforeModelCallback` / model wrapper |
+| Context token breakdowns (system, tools, history) | Computed in request pipeline | Model wrapper |
+| Tool approval decisions | Injected from approval layer | `ApprovalBridge` |
+| Session config, compression, rewind, IDE, extensions, billing, slash commands, hooks, plan execution, onboarding | **Unchanged** — stays in current call sites | Existing gemini-cli code |
+
+~30% of Clearcut metrics map to ADK plugin hooks. ~70% remain in their current call sites unchanged.
+
+Plan mode:
+- current behavior is broader than prompt + tool filtering
+- policy, approval mode, routing, and config refresh are all part of the behavior
+
+### 8. Retry safety around side effects (note)
+
+The “full turn reset” proposal could duplicate side effects (file writes, shell commands, MCP mutations) if the turn already executed side-effecting tools before the stream failure. This is an ADK-wide concern, not specific to this migration. A brief note acknowledging this limitation is sufficient — a full retry safety taxonomy is out of scope for this design.
+
+### 9. Design ignores ADK's native `BaseContextCompactor`
+
+ADK already has a compaction extension point: `BaseContextCompactor` (`adk-js/core/src/context/base_context_compactor.ts`) with `shouldCompact(invocationContext)` + `compact(invocationContext)`. It's wired into the request processor pipeline via `ContextCompactorRequestProcessor` at `llm_agent.ts:407-420`.
+
+The design doc proposes running compaction inside `GcliAgentModel.generateContentAsync` instead. This works but bypasses the native slot. Recommendation: implement `BaseContextCompactor`, delegate to the existing `ChatCompressionService` internally. ADK provides the trigger point; your service provides the logic. Note that `BaseContextCompactor` returns void — failure states (COMPRESSED, NOOP, CONTENT_TRUNCATED, etc.) must be communicated via session state or custom events.
+
+### 10. Existing `isStructuredError` type-guard bug
+
+`gemini-cli/packages/core/src/agent/event-translator.ts:431-438`: `isStructuredError()` checks only `typeof error === 'object' && 'message' in error && typeof error.message === 'string'`. Since every `Error` instance has `message: string`, plain `Error` objects pass this guard. In `mapError` (lines 390-429), the structured branch runs before `instanceof Error`, so plain errors get incorrect HTTP→gRPC status mapping. This should be fixed before the translator becomes the long-term session boundary. **Fix:** add `'status' in error` to the guard, or check `instanceof Error` first.
+
+### 11. The review should distinguish architecture defects from rollout-status evidence
+
+The interactive PR findings matter:
+- stacked-branch dependency
+- hook-order risk in `#24297`
+- `_meta.legacyState` leakage into protocol events
+
+But they are secondary to the core design defect, which is the missing runtime/translation architecture.
+
+These findings should stay in the review, but as credibility and rollout-risk evidence rather than the centerpiece.
+
+## Recommended Architecture
+
+This is the cleanest merged recommendation from both reviews plus follow-up discussion.
+
+### Core principle
+
+Use one shared ADK-based execution/runtime core, then put different adapters on top of it.
+
+Do not make `AgentSession` the innermost engine.
+
+### Recommended split
+
+1. `AdkRuntimeCore`
+- owns the ADK runner loop
+- owns tool execution, policy integration, routing integration, masking, compaction hooks, and persistence hooks
+- emits runtime-level activity/events
+
+2. `TopLevelSessionAdapter`
+- exposes the runtime as `AgentProtocol` / `AgentSession`
+- owns replay, reattach, `streamId`, `threadId`, `agent_start` / `agent_end`, and top-level event projection
+
+3. `SubagentTools` (custom `BaseTool` implementations)
+- subagents invoke the same shared runtime core as the main agent
+- the only difference is the type mapping at the boundary (projecting child activity into parent-facing `tool_update` / `tool_response` or `threadId`-scoped events)
+- `AgentTool` is explicitly rejected — it creates a fully isolated runner/session, which conflicts with the shared-core goal
+- custom `BaseTool` wrappers allow subagents to share policy, routing, tool definitions, and config with the parent while keeping the door open for future resumability and richer state sharing
+
+4. `ApprovalBridge`
+- phase-1 callback bridge for approvals / elicitation using existing callbacks
+- clearly documented as temporary and non-native
+- eventual migration to full elicitation bidi format
+
+5. `GcliFileSessionService`
+- file-backed persistence wrapping existing `ChatRecordingService`
+- implements 4 abstract methods from `BaseSessionService`
+- inherits state-merging (app/user/temp prefixes) for free
+- single-writer model — concurrent runs per session are forbidden
+
+### Subagent architecture decision
+
+`AgentTool` is not the right abstraction for this migration. It creates an isolated runner with its own `InMemorySessionService`, meaning:
+- state is NOT shared with the parent
+- events are NOT projected into the parent stream
+- policy, routing, and config are NOT inherited
+
+The core requirement is that subagents use the same core loop functionality as the main agent — the only difference is how results are mapped back to the parent. Custom `BaseTool` implementations that invoke the shared `AdkRuntimeCore` achieve this. This also positions subagents for future complexity (resumability, richer state sharing, MCP-scoped tool sets) without fighting AgentTool's isolation model.
+
+### Session conclusion
+
+Main agent and subagents can share the same underlying runtime core.
+
+But they should not necessarily share the exact same public adapter.
+
+The right formulation is:
+- same core runtime
+- different event/session projections depending on embedding context
+
+## Section-by-Section Unified Review
+
+### 3.1 Authentication Flexibility
+
+Assessment: implementable, but the design doc’s approach is wrong for Coast Assist.
+
+Keep:
+- ADK `Gemini` does not natively accept the CLI’s auth shape
+
+Change:
+- `GcliAgentModel` must extend `BaseLlm` directly, not wrap `Gemini` — Coast Assist uses `AuthClient.request()` against a non-standard backend, not `GoogleGenAI`
+- fix `request.headers` to `llmRequest.config.httpOptions.headers` (C1)
+- define two transport paths: API-key (standard Gemini) and OAuth (Code Assist)
+- token refresh is transparent via `OAuth2Client` — this works as-is
+- browser-based OAuth runs before agent session starts — no blocking concern
+
+### 3.2 Model Steering and Mid-Stream Injection
+
+Assessment: next-turn steering is plausible now; true live interruption is still blocked.
+
+Required change:
+- split “next-step steering” from “true mid-turn interruption”
+- define temporary user-visible behavior until live input-stream support exists
+
+### 3.3 State Management and Token Compaction
+
+Assessment: plausible, but too wrapper-centric.
+
+Required change:
+- specify whether compaction operates on persisted history, outgoing request history, or both
+- define recursion guards and utility-call isolation
+- define artifact ownership across sessions and subagents
+
+### 3.4 Model Configuration and Hierarchical Overrides
+
+Assessment: under-specified.
+
+Required change:
+- model config resolution should remain request-scoped
+- preserve scoped overrides and retry-aware behavior
+- explain subagent and utility-call override behavior
+
+### 3.5 Universal Policy Enforcement
+
+Assessment: acceptable as a bridge, not as full parity.
+
+Required change:
+- explicitly document reduced phase-1 semantics
+- list policy inputs lost unless extra context plumbing is added
+- separate short-term callback bridge from long-term native confirmation flow
+
+### 3.6 Telemetry and Observability (Clearcut)
+
+Assessment: fully implementable, but the stream-interceptor approach must be replaced with a `BasePlugin`.
+
+Required change:
+- replace stream interception with `ClearcutTelemetryPlugin extends BasePlugin`
+- use `afterModelCallback` for token counts (`LlmResponse.usageMetadata` is available)
+- use `beforeToolCallback`/`afterToolCallback` with `functionCallId` for per-tool timing
+- capture HTTP-level metrics (status code, duration) in `GcliAgentModel` wrapper
+- ~70% of Clearcut metrics stay in their current call sites unchanged — document which
+- replace fake API examples with a telemetry parity matrix showing capture mechanism per metric
+
+### 3.7 Dynamic Model Routing and Configurability
+
+Assessment: partly feasible, materially overstated.
+
+Required change:
+- remove “100% possible today”
+- separate alias rewrite, fallback selection, classifier routing, and banning/rejection behavior
+- define a real `RoutingContextBuilder`
+
+### 3.8 Fallbacks and Availability Management
+
+Assessment: incomplete.
+
+Required change:
+- split preflight fallback from post-failure transition behavior
+- define retry safety
+- define main-call vs utility-call fallback ownership
+
+### 3.9 State-Driven Mode Switching
+
+Assessment: too narrow.
+
+Required change:
+- define a single mode state source of truth
+- enumerate all consumers: prompt, toolset, policy, router, UI
+
+### 3.10 Tool Output Masking
+
+Assessment: one of the stronger sections.
+
+Required change:
+- define whether masking mutates persisted history or only outgoing request history
+- define ordering and idempotence relative to compaction
+- define file/artifact lifecycle
+
+### 4. SDK Facade / Stateful Orchestration
+
+Assessment: this should become the architectural center of the document.
+
+Required change:
+- expand ownership boundaries
+- describe the shared runtime plus adapter model
+- document temporary approval/elicitation limitations explicitly
+
+### 4.1 Hybrid Tool Instantiation
+
+Assessment: directionally good.
+
+Required change:
+- include message bus derivation
+- include MCP discovery scoping
+- include recursion prevention and tool isolation details
+
+### 4.2 Custom File-Based Persistence
+
+Assessment: straightforward for storage, but rewind semantics need work.
+
+The storage layer itself is low-risk — `GcliFileSessionService` wraps existing `ChatRecordingService` and implements 4 abstract methods. DB concerns (locking, stale-writer, crash recovery) don't apply to a single-user CLI.
+
+Required change:
+- define rewind as event-log truncation + state recomputation (not just file truncation)
+- state that concurrent runs per session are forbidden (single-writer)
+- define how app/user/temp state prefixes map to existing workspace JSON
+
+### 4.3 Decomposing `AgentLoopContext`
+
+Assessment: right instinct, incomplete decomposition.
+
+Required change:
+- account for message bus / confirmation routing
+- account for injection queues
+- account for prompt/resource registries and MCP scoping
+
+### 5.1 Real-Time User Message Injections
+
+Assessment: blocker analysis is incomplete.
+
+Required change:
+- mention TS live runtime gaps directly
+- describe temporary UX until true interruption exists
+
+### 5.2 Conversation Rewind and State Reversal
+
+Assessment: too shallow today.
+
+Required change:
+- define rewind as event-log truncation plus state rollback semantics
+- define confirmation/auth rollback semantics
+- define artifact/version rollback expectations
+
+### 5.3 Concurrent Sessions
+
+Assessment: a single-user CLI does not need DB-level locking.
+
+Required change:
+- state that concurrent runs per session are forbidden (single-writer model)
+- this is sufficient for a CLI — no further locking design needed
+
+## Corrections to Earlier Reviews
+
+### Auth is implementable, not blocked
+API-key auth works via `httpOptions.headers`. Coast Assist / `LOGIN_WITH_GOOGLE` requires `GcliAgentModel` to extend `BaseLlm` directly with its own transport (using `AuthClient.request()`), not wrap `Gemini`. The OAuth flow, token refresh, and credential caching all work as-is — the issue was the design doc's assumption about the inner model, not auth capability.
+
+### Persistence is simpler than initially claimed
+DB-level concerns (PESSIMISTIC_WRITE, stale-writer detection, concurrent append policy) come from `DatabaseSessionService` and don't apply. The file-backed service wraps existing `ChatRecordingService`. Only rewind semantics need deeper design.
+
+### Interactive PR findings are rollout-risk evidence, not architecture defects
+The branch-stack dependency, hook-order risk, and `_meta.legacyState` leakage in PR #24297 are real but secondary to the core architecture gaps above.
+
+## What To Change Before Principal Review
+
+1. **Fix the 4 compilation blockers** (C1-C4) — these will be the first thing reviewers check
+2. **Add an explicit ADK→AgentProtocol translation architecture section** — this is the real design center
+3. **Add the shared-core subagent architecture** — custom `BaseTool` over shared runtime, not `AgentTool`
+4. **Use `BaseContextCompactor`** for compaction instead of embedding it in the model layer
+5. **Replace “100% possible today” and similar language** with explicit labels: native / bridgeable / blocked
+6. **Add a parity matrix** (feature | ADK mechanism | status | bridge workaround | long-term target)
+
+## Phased Migration Plan
+
+### Phase 0: Foundation (current state → near-term)
+**Goal:** Establish the shared runtime core and translation layer.
+
+- [ ] Fix compilation blockers (C1-C4) in design doc code samples
+- [ ] Implement `AdkRuntimeCore` wrapping ADK `Runner` + `LlmAgent`
+- [ ] Implement `AdkEventTranslator` (ADK `Event` → gemini-cli `AgentEvent`)
+- [ ] Implement `GcliAgentModel extends BaseLlm` with dual transport (API-key via `httpOptions.headers`, Coast Assist via `AuthClient.request()`)
+- [ ] Implement `GcliFileSessionService extends BaseSessionService` wrapping `ChatRecordingService`
+- [ ] Implement `GcliContextCompactor implements BaseContextCompactor` wrapping `ChatCompressionService`
+- [ ] Wire behind `experimental.adk` feature gate
+
+**Non-goals for Phase 0:**
+- No interactive flow changes
+- No subagent support
+- No live/bidi connections
+- No resumable approvals
+
+**Exit criteria:** Non-interactive flow produces identical output behind feature gate.
+
+### Phase 1: Non-Interactive Parity
+**Goal:** Feature-gated non-interactive flow matches legacy behavior.
+
+- [ ] Tool output masking via `BaseLlmRequestProcessor`
+- [ ] Model routing via `beforeModelCallback` + `RoutingContextBuilder` adapter
+- [ ] Policy enforcement via `beforeToolCallback` using existing callbacks (temporary bridge)
+- [ ] Quota/availability handling via `beforeModelCallback`
+- [ ] `ClearcutTelemetryPlugin extends BasePlugin` for token counts (`afterModelCallback`), per-tool timing (`beforeToolCallback`/`afterToolCallback` with `functionCallId`), agent lifecycle, model errors
+- [ ] HTTP-level telemetry (status code, duration) captured in `GcliAgentModel` wrapper
+- [ ] Verify ~70% of existing Clearcut call sites work unchanged
+
+**Non-goals for Phase 1:**
+- No interactive UI changes
+- No plan mode switching
+- No subagents
+- Approvals are callback-based, not resumable
+
+**Exit criteria:** Non-interactive tests pass with `experimental.adk.enabled = true`. Legacy path remains default.
+
+### Phase 2: Interactive Flow Migration
+**Goal:** Interactive flow uses the same ADK runtime behind `TopLevelSessionAdapter`.
+
+- [ ] `TopLevelSessionAdapter` exposing runtime as `AgentProtocol` / `AgentSession`
+- [ ] Stream lifecycle (`agent_start` / `agent_end` / `streamId` ownership)
+- [ ] Replay/reattach semantics matching current `AgentSession.stream()` behavior
+- [ ] Plan mode via dynamic `BaseToolset` + `InstructionProvider` + mode state
+- [ ] `ApprovalBridge` for tool confirmations using existing UI callbacks
+- [ ] Elicitation via existing callbacks (not yet bidi)
+- [ ] `_meta.legacyState` bridge for UI rendering (documented as temporary)
+
+**Non-goals for Phase 2:**
+- No live/bidi parity (`runLiveImpl` is still a stub in ADK TS)
+- No true mid-turn interruption (steering limited to once-per-LLM-call)
+- No resumable approvals across process death
+- No concurrent multi-stream sessions
+
+**Exit criteria:** Interactive flow works behind feature gate. Legacy path remains default.
+
+### Phase 3: Subagents and SDK Readiness
+**Goal:** Subagents share the core runtime. The architecture is SDK-reusable.
+
+- [ ] Custom `BaseTool` subagent wrappers over shared `AdkRuntimeCore`
+- [ ] `threadId`-scoped event projection for child activity
+- [ ] Shared policy, routing, and config inheritance
+- [ ] Remove `_meta.legacyState` — replace with proper event/adapter separation
+- [ ] Migrate approval bridge to native ADK elicitation/bidi (when available)
+- [ ] Define SDK public API surface
+
+**Non-goals for Phase 3:**
+- Full ADK Dev UI compatibility
+- Agent-to-agent transfer via ADK's native mechanism
+
+**Exit criteria:** Subagent invocation works. Architecture is documented for SDK consumers.
+
+## Positive Signals
+
+- Feature-gating behind `experimental.adk` is the right rollout pattern
+- Tool output masking maps cleanly to request-preprocessing
+- Dynamic toolset + `InstructionProvider` for plan mode is a good ADK-native fit
+- The phased migration checklist with tracking issues shows good engineering discipline
+- The doc correctly identifies 3 known ADK gaps (sections 5.1-5.3)
+- `AgentProtocol` / `AgentSession` is the right consumer-facing boundary
+- The policy adapter pattern is directionally sound even with reduced phase-1 semantics
+
+## Concern Decomposition
+
+| Concern | Level | ADK Mechanism |
+|---|---|---|
+| Auth (API key) | Transport | `BaseLlm` constructor / `httpOptions.headers` |
+| Auth (Coast Assist) | Transport | `BaseLlm` direct — custom transport via `AuthClient.request()` |
+| Model rewrite | Transport | `BaseLlm.generateContentAsync` model override |
+| Model routing | Agent | `beforeModelCallback` + `RoutingContextBuilder` |
+| Token compaction | Agent | `BaseContextCompactor` (native ADK) |
+| Quota/availability | Agent | `beforeModelCallback` |
+| Tool masking | Agent | `BaseLlmRequestProcessor` |
+| Tool confirmations | Agent+Consumer | `beforeToolCallback` + existing callbacks (phase 1) |
+| Telemetry (lifecycle) | Agent | `ClearcutTelemetryPlugin` — `afterModelCallback`, `beforeToolCallback`/`afterToolCallback` |
+| Telemetry (HTTP) | Transport | `GcliAgentModel` wrapper (status code, duration) |
+| Telemetry (CLI) | Consumer | Existing call sites (~70% of Clearcut metrics, unchanged) |
+| UI rendering | Consumer | Event subscriber / adapter |
+| Subagent invocation | Agent | Custom `BaseTool` over shared runtime core |
+
+## Final Verdict
+
+The design is architecturally correct in its goal. To be principal-review ready:
+
+1. Fix the 4 compilation blockers
+2. Add the ADK→AgentProtocol translation architecture as the design center
+3. Adopt native `BaseContextCompactor` instead of model-layer compaction
+4. Use custom `BaseTool` subagents over shared core (not `AgentTool`)
+5. Downgrade parity claims to match reality
+6. Add the phased plan with explicit non-goals per phase
+
+The migration path is: shared runtime core → translation layer → adapters (top-level session, subagent tools, approval bridge). Each phase ships independently behind the feature gate.

docs/changelogs/index.md

@@ -18,27 +18,6 @@ on GitHub.
 | [Preview](preview.md) | Experimental features ready for early feedback. |
 | [Stable](latest.md)   | Stable, recommended for general use.            |
 
-## Announcements: v0.37.0 - 2026-04-08
-
-- **Dynamic Sandbox Expansion:** Implemented dynamic sandbox expansion and
-  worktree support for Linux and Windows, improving developer workflows in
-  isolated environments
-  ([#23692](https://github.com/google-gemini/gemini-cli/pull/23692) by @galz10,
-  [#23691](https://github.com/google-gemini/gemini-cli/pull/23691) by
-  @scidomino).
-- **Chapters Narrative Flow:** Introduced tool-based topic grouping ("Chapters")
-  to provide better session structure and narrative continuity
-  ([#23150](https://github.com/google-gemini/gemini-cli/pull/23150) by
-  @Abhijit-2592,
-  [#24079](https://github.com/google-gemini/gemini-cli/pull/24079) by
-  @gundermanc).
-- **Advanced Browser Capabilities:** Enhanced the browser agent with persistent
-  sessions and dynamic tool discovery
-  ([#21306](https://github.com/google-gemini/gemini-cli/pull/21306) by
-  @kunal-10-cloud,
-  [#23805](https://github.com/google-gemini/gemini-cli/pull/23805) by
-  @cynthialong0-0).
-
 ## Announcements: v0.36.0 - 2026-04-01
 
 - **Multi-Registry Architecture and Sandboxing:** Introduced a multi-registry

docs/changelogs/latest.md

@@ -1,6 +1,6 @@
-# Latest stable release: v0.37.0
+# Latest stable release: v0.36.0
 
-Released: April 08, 2026
+Released: April 1, 2026
 
 For most users, our latest stable release is the recommended release. Install
 the latest stable version with:
@@ -11,409 +11,372 @@ npm install -g @google/gemini-cli
 
 ## Highlights
 
-- **Dynamic Sandbox Expansion:** Implemented dynamic sandbox expansion and
-  worktree support for both Linux and Windows, enhancing development flexibility
-  in restricted environments.
-- **Tool-Based Topic Grouping (Chapters):** Introduced "Chapters" to logically
-  group agent interactions based on tool usage and intent, providing a clearer
-  narrative flow in long sessions.
-- **Enhanced Browser Agent:** Added persistent session management, dynamic
-  read-only tool discovery, and sandbox-aware initialization for the browser
-  agent.
-- **Security & Permission Hardening:** Implemented secret visibility lockdown
-  for environment files and integrated integrity controls for Windows
-  sandboxing.
+- **Multi-Registry Architecture and Tool Isolation:** Introduced a
+  multi-registry architecture for subagents and implemented strict sandboxing
+  for macOS (Seatbelt) and Windows to enhance security and isolation.
+- **Improved Subagent Coordination:** Enhanced subagents with local execution
+  capabilities, JIT context injection (upward traversal capped at git root), and
+  resilient tool rejection with contextual feedback.
+- **Enhanced UI and UX:** Implemented a refreshed UX for the Composer layout,
+  improved terminal fallback warnings, and resolved various UI flickering and
+  state persistence issues.
+- **Git Worktree Support:** Added support for Git worktrees to enable isolated
+  parallel sessions within the same repository.
+- **Plan Mode Improvements:** Plan mode now supports non-interactive execution
+  and includes hardened sandbox path resolution to prevent hallucinations.
 
 ## What's Changed
 
-- feat(evals): centralize test agents into test-utils for reuse by @Samee24 in
-  [#23616](https://github.com/google-gemini/gemini-cli/pull/23616)
-- revert: chore(config): disable agents by default by @abhipatel12 in
-  [#23672](https://github.com/google-gemini/gemini-cli/pull/23672)
-- fix(plan): update telemetry attribute keys and add timestamp by @Adib234 in
-  [#23685](https://github.com/google-gemini/gemini-cli/pull/23685)
-- fix(core): prevent premature MCP discovery completion by @jackwotherspoon in
-  [#23637](https://github.com/google-gemini/gemini-cli/pull/23637)
-- feat(browser): add maxActionsPerTask for browser agent setting by
-  @cynthialong0-0 in
-  [#23216](https://github.com/google-gemini/gemini-cli/pull/23216)
-- fix(core): improve agent loader error formatting for empty paths by
-  @adamfweidman in
-  [#23690](https://github.com/google-gemini/gemini-cli/pull/23690)
-- fix(cli): only show updating spinner when auto-update is in progress by
-  @scidomino in [#23709](https://github.com/google-gemini/gemini-cli/pull/23709)
-- Refine onboarding metrics to log the duration explicitly and use the tier
-  name. by @yunaseoul in
-  [#23678](https://github.com/google-gemini/gemini-cli/pull/23678)
-- chore(tools): add toJSON to tools and invocations to reduce logging verbosity
-  by @alisa-alisa in
-  [#22899](https://github.com/google-gemini/gemini-cli/pull/22899)
-- fix(cli): stabilize copy mode to prevent flickering and cursor resets by
+- Changelog for v0.33.2 by @gemini-cli-robot in
+  [#22730](https://github.com/google-gemini/gemini-cli/pull/22730)
+- feat(core): multi-registry architecture and tool filtering for subagents by
+  @akh64bit in [#22712](https://github.com/google-gemini/gemini-cli/pull/22712)
+- Changelog for v0.34.0-preview.4 by @gemini-cli-robot in
+  [#22752](https://github.com/google-gemini/gemini-cli/pull/22752)
+- fix(devtools): use theme-aware text colors for console warnings and errors by
+  @SandyTao520 in
+  [#22181](https://github.com/google-gemini/gemini-cli/pull/22181)
+- Add support for dynamic model Resolution to ModelConfigService by @kevinjwang1
+  in [#22578](https://github.com/google-gemini/gemini-cli/pull/22578)
+- chore(release): bump version to 0.36.0-nightly.20260317.2f90b4653 by
+  @gemini-cli-robot in
+  [#22858](https://github.com/google-gemini/gemini-cli/pull/22858)
+- fix(cli): use active sessionId in useLogger and improve resume robustness by
   @mattKorwel in
-  [#22584](https://github.com/google-gemini/gemini-cli/pull/22584)
-- fix(test): move flaky ctrl-c-exit test to non-blocking suite by @mattKorwel in
-  [#23732](https://github.com/google-gemini/gemini-cli/pull/23732)
-- feat(skills): add ci skill for automated failure replication by @mattKorwel in
-  [#23720](https://github.com/google-gemini/gemini-cli/pull/23720)
-- feat(sandbox): implement forbiddenPaths for OS-specific sandbox managers by
-  @ehedlund in [#23282](https://github.com/google-gemini/gemini-cli/pull/23282)
-- fix(core): conditionally expose additional_permissions in shell tool by
-  @galz10 in [#23729](https://github.com/google-gemini/gemini-cli/pull/23729)
-- refactor(core): standardize OS-specific sandbox tests and extract linux helper
-  methods by @ehedlund in
-  [#23715](https://github.com/google-gemini/gemini-cli/pull/23715)
-- format recently added script by @scidomino in
-  [#23739](https://github.com/google-gemini/gemini-cli/pull/23739)
-- fix(ui): prevent over-eager slash subcommand completion by @keithguerin in
-  [#20136](https://github.com/google-gemini/gemini-cli/pull/20136)
-- Fix dynamic model routing for gemini 3.1 pro to customtools model by
-  @kevinjwang1 in
-  [#23641](https://github.com/google-gemini/gemini-cli/pull/23641)
-- feat(core): support inline agentCardJson for remote agents by @adamfweidman in
-  [#23743](https://github.com/google-gemini/gemini-cli/pull/23743)
-- fix(cli): skip console log/info in headless mode by @cynthialong0-0 in
-  [#22739](https://github.com/google-gemini/gemini-cli/pull/22739)
-- test(core): install bubblewrap on Linux CI for sandbox integration tests by
-  @ehedlund in [#23583](https://github.com/google-gemini/gemini-cli/pull/23583)
-- docs(reference): split tools table into category sections by @sheikhlimon in
-  [#21516](https://github.com/google-gemini/gemini-cli/pull/21516)
-- fix(browser): detect embedded URLs in query params to prevent allowedDomains
-  bypass by @tony-shi in
-  [#23225](https://github.com/google-gemini/gemini-cli/pull/23225)
-- fix(browser): add proxy bypass constraint to domain restriction system prompt
-  by @tony-shi in
-  [#23229](https://github.com/google-gemini/gemini-cli/pull/23229)
-- fix(policy): relax write_file argsPattern in plan mode to allow paths without
-  session ID by @Adib234 in
-  [#23695](https://github.com/google-gemini/gemini-cli/pull/23695)
-- docs: fix grammar in CONTRIBUTING and numbering in sandbox docs by
-  @splint-disk-8i in
-  [#23448](https://github.com/google-gemini/gemini-cli/pull/23448)
-- fix(acp): allow attachments by adding a permission prompt by @sripasg in
-  [#23680](https://github.com/google-gemini/gemini-cli/pull/23680)
-- fix(core): thread AbortSignal to chat compression requests (#20405) by
-  @SH20RAJ in [#20778](https://github.com/google-gemini/gemini-cli/pull/20778)
-- feat(core): implement Windows sandbox dynamic expansion Phase 1 and 2.1 by
-  @scidomino in [#23691](https://github.com/google-gemini/gemini-cli/pull/23691)
-- Add note about root privileges in sandbox docs by @diodesign in
-  [#23314](https://github.com/google-gemini/gemini-cli/pull/23314)
-- docs(core): document agent_card_json string literal options for remote agents
-  by @adamfweidman in
-  [#23797](https://github.com/google-gemini/gemini-cli/pull/23797)
-- fix(cli): resolve TTY hang on headless environments by unconditionally
-  resuming process.stdin before React Ink launch by @cocosheng-g in
-  [#23673](https://github.com/google-gemini/gemini-cli/pull/23673)
-- fix(ui): cleanup estimated string length hacks in composer by @keithguerin in
-  [#23694](https://github.com/google-gemini/gemini-cli/pull/23694)
-- feat(browser): dynamically discover read-only tools by @cynthialong0-0 in
-  [#23805](https://github.com/google-gemini/gemini-cli/pull/23805)
-- docs: clarify policy requirement for `general.plan.directory` in settings
-  schema by @jerop in
-  [#23784](https://github.com/google-gemini/gemini-cli/pull/23784)
-- Revert "perf(cli): optimize --version startup time (#23671)" by @scidomino in
-  [#23812](https://github.com/google-gemini/gemini-cli/pull/23812)
-- don't silence errors from wombat by @scidomino in
-  [#23822](https://github.com/google-gemini/gemini-cli/pull/23822)
-- fix(ui): prevent escape key from cancelling requests in shell mode by
-  @PrasannaPal21 in
-  [#21245](https://github.com/google-gemini/gemini-cli/pull/21245)
-- Changelog for v0.36.0-preview.0 by @gemini-cli-robot in
-  [#23702](https://github.com/google-gemini/gemini-cli/pull/23702)
-- feat(core,ui): Add experiment-gated support for gemini flash 3.1 lite by
-  @chrstnb in [#23794](https://github.com/google-gemini/gemini-cli/pull/23794)
-- Changelog for v0.36.0-preview.3 by @gemini-cli-robot in
-  [#23827](https://github.com/google-gemini/gemini-cli/pull/23827)
-- new linting check: github-actions-pinning by @alisa-alisa in
-  [#23808](https://github.com/google-gemini/gemini-cli/pull/23808)
-- fix(cli): show helpful guidance when no skills are available by @Niralisj in
-  [#23785](https://github.com/google-gemini/gemini-cli/pull/23785)
-- fix: Chat logs and errors handle tail tool calls correctly by @googlestrobe in
-  [#22460](https://github.com/google-gemini/gemini-cli/pull/22460)
-- Don't try removing a tag from a non-existent release. by @scidomino in
-  [#23830](https://github.com/google-gemini/gemini-cli/pull/23830)
-- fix(cli): allow ask question dialog to take full window height by @jacob314 in
-  [#23693](https://github.com/google-gemini/gemini-cli/pull/23693)
-- fix(core): strip leading underscores from error types in telemetry by
-  @yunaseoul in [#23824](https://github.com/google-gemini/gemini-cli/pull/23824)
-- Changelog for v0.35.0 by @gemini-cli-robot in
-  [#23819](https://github.com/google-gemini/gemini-cli/pull/23819)
-- feat(evals): add reliability harvester and 500/503 retry support by
+  [#22606](https://github.com/google-gemini/gemini-cli/pull/22606)
+- fix(cli): expand tilde in policy paths from settings.json by @abhipatel12 in
+  [#22772](https://github.com/google-gemini/gemini-cli/pull/22772)
+- fix(core): add actionable warnings for terminal fallbacks (#14426) by
+  @spencer426 in
+  [#22211](https://github.com/google-gemini/gemini-cli/pull/22211)
+- feat(tracker): integrate task tracker protocol into core system prompt by
+  @anj-s in [#22442](https://github.com/google-gemini/gemini-cli/pull/22442)
+- chore: add posttest build hooks and fix missing dependencies by @NTaylorMullen
+  in [#22865](https://github.com/google-gemini/gemini-cli/pull/22865)
+- feat(a2a): add agent acknowledgment command and enhance registry discovery by
   @alisa-alisa in
-  [#23626](https://github.com/google-gemini/gemini-cli/pull/23626)
-- feat(sandbox): dynamic Linux sandbox expansion and worktree support by @galz10
-  in [#23692](https://github.com/google-gemini/gemini-cli/pull/23692)
-- Merge examples of use into quickstart documentation by @diodesign in
-  [#23319](https://github.com/google-gemini/gemini-cli/pull/23319)
-- fix(cli): prioritize primary name matches in slash command search by @sehoon38
-  in [#23850](https://github.com/google-gemini/gemini-cli/pull/23850)
-- Changelog for v0.35.1 by @gemini-cli-robot in
-  [#23840](https://github.com/google-gemini/gemini-cli/pull/23840)
-- fix(browser): keep input blocker active across navigations by @kunal-10-cloud
-  in [#22562](https://github.com/google-gemini/gemini-cli/pull/22562)
-- feat(core): new skill to look for duplicated code while reviewing PRs by
-  @devr0306 in [#23704](https://github.com/google-gemini/gemini-cli/pull/23704)
-- fix(core): replace hardcoded non-interactive ASK_USER denial with explicit
-  policy rules by @ruomengz in
-  [#23668](https://github.com/google-gemini/gemini-cli/pull/23668)
-- fix(plan): after exiting plan mode switches model to a flash model by @Adib234
-  in [#23885](https://github.com/google-gemini/gemini-cli/pull/23885)
-- feat(gcp): add development worker infrastructure by @mattKorwel in
-  [#23814](https://github.com/google-gemini/gemini-cli/pull/23814)
-- fix(a2a-server): A2A server should execute ask policies in interactive mode by
-  @kschaab in [#23831](https://github.com/google-gemini/gemini-cli/pull/23831)
-- feat(core): define TrajectoryProvider interface by @sehoon38 in
-  [#23050](https://github.com/google-gemini/gemini-cli/pull/23050)
-- Docs: Update quotas and pricing by @jkcinouye in
-  [#23835](https://github.com/google-gemini/gemini-cli/pull/23835)
-- fix(core): allow disabling environment variable redaction by @galz10 in
-  [#23927](https://github.com/google-gemini/gemini-cli/pull/23927)
-- feat(cli): enable notifications cross-platform via terminal bell fallback by
-  @genneth in [#21618](https://github.com/google-gemini/gemini-cli/pull/21618)
-- feat(sandbox): implement secret visibility lockdown for env files by
-  @DavidAPierce in
-  [#23712](https://github.com/google-gemini/gemini-cli/pull/23712)
-- fix(core): remove shell outputChunks buffer caching to prevent memory bloat
-  and sanitize prompt input by @spencer426 in
-  [#23751](https://github.com/google-gemini/gemini-cli/pull/23751)
-- feat(core): implement persistent browser session management by @kunal-10-cloud
-  in [#21306](https://github.com/google-gemini/gemini-cli/pull/21306)
-- refactor(core): delegate sandbox denial parsing to SandboxManager by
-  @scidomino in [#23928](https://github.com/google-gemini/gemini-cli/pull/23928)
-- dep(update) Update Ink version to 6.5.0 by @jacob314 in
-  [#23843](https://github.com/google-gemini/gemini-cli/pull/23843)
-- Docs: Update 'docs-writer' skill for relative links by @jkcinouye in
-  [#21463](https://github.com/google-gemini/gemini-cli/pull/21463)
-- Changelog for v0.36.0-preview.4 by @gemini-cli-robot in
-  [#23935](https://github.com/google-gemini/gemini-cli/pull/23935)
-- fix(acp): Update allow approval policy flow for ACP clients to fix config
-  persistence and compatible with TUI by @sripasg in
-  [#23818](https://github.com/google-gemini/gemini-cli/pull/23818)
-- Changelog for v0.35.2 by @gemini-cli-robot in
-  [#23960](https://github.com/google-gemini/gemini-cli/pull/23960)
-- ACP integration documents by @g-samroberts in
-  [#22254](https://github.com/google-gemini/gemini-cli/pull/22254)
-- fix(core): explicitly set error names to avoid bundling renaming issues by
-  @yunaseoul in [#23913](https://github.com/google-gemini/gemini-cli/pull/23913)
-- feat(core): subagent isolation and cleanup hardening by @abhipatel12 in
-  [#23903](https://github.com/google-gemini/gemini-cli/pull/23903)
-- disable extension-reload test by @scidomino in
-  [#24018](https://github.com/google-gemini/gemini-cli/pull/24018)
-- feat(core): add forbiddenPaths to GlobalSandboxOptions and refactor
-  createSandboxManager by @ehedlund in
-  [#23936](https://github.com/google-gemini/gemini-cli/pull/23936)
-- refactor(core): improve ignore resolution and fix directory-matching bug by
-  @ehedlund in [#23816](https://github.com/google-gemini/gemini-cli/pull/23816)
-- revert(core): support custom base URL via env vars by @spencer426 in
-  [#23976](https://github.com/google-gemini/gemini-cli/pull/23976)
-- Increase memory limited for eslint. by @jacob314 in
-  [#24022](https://github.com/google-gemini/gemini-cli/pull/24022)
-- fix(acp): prevent crash on empty response in ACP mode by @sripasg in
-  [#23952](https://github.com/google-gemini/gemini-cli/pull/23952)
-- feat(core): Land `AgentHistoryProvider`. by @joshualitt in
-  [#23978](https://github.com/google-gemini/gemini-cli/pull/23978)
-- fix(core): switch to subshells for shell tool wrapping to fix heredocs and
-  edge cases by @abhipatel12 in
-  [#24024](https://github.com/google-gemini/gemini-cli/pull/24024)
-- Debug command. by @jacob314 in
-  [#23851](https://github.com/google-gemini/gemini-cli/pull/23851)
-- Changelog for v0.36.0-preview.5 by @gemini-cli-robot in
-  [#24046](https://github.com/google-gemini/gemini-cli/pull/24046)
-- Fix test flakes by globally mocking ink-spinner by @jacob314 in
-  [#24044](https://github.com/google-gemini/gemini-cli/pull/24044)
-- Enable network access in sandbox configuration by @galz10 in
-  [#24055](https://github.com/google-gemini/gemini-cli/pull/24055)
-- feat(context): add configurable memoryBoundaryMarkers setting by @SandyTao520
-  in [#24020](https://github.com/google-gemini/gemini-cli/pull/24020)
-- feat(core): implement windows sandbox expansion and denial detection by
-  @scidomino in [#24027](https://github.com/google-gemini/gemini-cli/pull/24027)
-- fix(core): resolve ACP Operation Aborted Errors in grep_search by @ivanporty
-  in [#23821](https://github.com/google-gemini/gemini-cli/pull/23821)
-- fix(hooks): prevent SessionEnd from firing twice in non-interactive mode by
-  @krishdef7 in [#22139](https://github.com/google-gemini/gemini-cli/pull/22139)
-- Re-word intro to Gemini 3 page. by @g-samroberts in
-  [#24069](https://github.com/google-gemini/gemini-cli/pull/24069)
-- fix(cli): resolve layout contention and flashing loop in StatusRow by
-  @keithguerin in
-  [#24065](https://github.com/google-gemini/gemini-cli/pull/24065)
-- fix(sandbox): implement Windows Mandatory Integrity Control for GeminiSandbox
-  by @galz10 in [#24057](https://github.com/google-gemini/gemini-cli/pull/24057)
-- feat(core): implement tool-based topic grouping (Chapters) by @Abhijit-2592 in
-  [#23150](https://github.com/google-gemini/gemini-cli/pull/23150)
-- feat(cli): support 'tab to queue' for messages while generating by @gundermanc
-  in [#24052](https://github.com/google-gemini/gemini-cli/pull/24052)
-- feat(core): agnostic background task UI with CompletionBehavior by
-  @adamfweidman in
-  [#22740](https://github.com/google-gemini/gemini-cli/pull/22740)
-- UX for topic narration tool by @gundermanc in
-  [#24079](https://github.com/google-gemini/gemini-cli/pull/24079)
-- fix: shellcheck warnings in scripts by @scidomino in
-  [#24035](https://github.com/google-gemini/gemini-cli/pull/24035)
-- test(evals): add comprehensive subagent delegation evaluations by @abhipatel12
-  in [#24132](https://github.com/google-gemini/gemini-cli/pull/24132)
-- fix(a2a-server): prioritize ADC before evaluating headless constraints for
-  auth initialization by @spencer426 in
-  [#23614](https://github.com/google-gemini/gemini-cli/pull/23614)
-- Text can be added after /plan command by @rambleraptor in
-  [#22833](https://github.com/google-gemini/gemini-cli/pull/22833)
-- fix(cli): resolve missing F12 logs via global console store by @scidomino in
-  [#24235](https://github.com/google-gemini/gemini-cli/pull/24235)
-- fix broken tests by @scidomino in
-  [#24279](https://github.com/google-gemini/gemini-cli/pull/24279)
-- fix(evals): add update_topic behavioral eval by @gundermanc in
-  [#24223](https://github.com/google-gemini/gemini-cli/pull/24223)
-- feat(core): Unified Context Management and Tool Distillation. by @joshualitt
-  in [#24157](https://github.com/google-gemini/gemini-cli/pull/24157)
-- Default enable narration for the team. by @gundermanc in
-  [#24224](https://github.com/google-gemini/gemini-cli/pull/24224)
-- fix(core): ensure default agents provide tools and use model-specific schemas
-  by @abhipatel12 in
-  [#24268](https://github.com/google-gemini/gemini-cli/pull/24268)
-- feat(cli): show Flash Lite Preview model regardless of user tier by @sehoon38
-  in [#23904](https://github.com/google-gemini/gemini-cli/pull/23904)
-- feat(cli): implement compact tool output by @jwhelangoog in
-  [#20974](https://github.com/google-gemini/gemini-cli/pull/20974)
-- Add security settings for tool sandboxing by @galz10 in
-  [#23923](https://github.com/google-gemini/gemini-cli/pull/23923)
-- chore(test-utils): switch integration tests to use PREVIEW_GEMINI_MODEL by
-  @sehoon38 in [#24276](https://github.com/google-gemini/gemini-cli/pull/24276)
-- feat(core): enable topic update narration for legacy models by @Abhijit-2592
-  in [#24241](https://github.com/google-gemini/gemini-cli/pull/24241)
-- feat(core): add project-level memory scope to save_memory tool by @SandyTao520
-  in [#24161](https://github.com/google-gemini/gemini-cli/pull/24161)
-- test(integration): fix plan mode write denial test false positive by @sehoon38
-  in [#24299](https://github.com/google-gemini/gemini-cli/pull/24299)
-- feat(plan): support `Plan` mode in untrusted folders by @Adib234 in
-  [#17586](https://github.com/google-gemini/gemini-cli/pull/17586)
-- fix(core): enable mid-stream retries for all models and re-enable compression
-  test by @sehoon38 in
-  [#24302](https://github.com/google-gemini/gemini-cli/pull/24302)
-- Changelog for v0.36.0-preview.6 by @gemini-cli-robot in
-  [#24082](https://github.com/google-gemini/gemini-cli/pull/24082)
-- Changelog for v0.35.3 by @gemini-cli-robot in
-  [#24083](https://github.com/google-gemini/gemini-cli/pull/24083)
-- feat(cli): add auth info to footer by @sehoon38 in
-  [#24042](https://github.com/google-gemini/gemini-cli/pull/24042)
-- fix(browser): reset action counter for each agent session and let it ignore
-  internal actions by @cynthialong0-0 in
-  [#24228](https://github.com/google-gemini/gemini-cli/pull/24228)
-- feat(plan): promote planning feature to stable by @ruomengz in
-  [#24282](https://github.com/google-gemini/gemini-cli/pull/24282)
-- fix(browser): terminate subagent immediately on domain restriction violations
-  by @gsquared94 in
-  [#24313](https://github.com/google-gemini/gemini-cli/pull/24313)
-- feat(cli): add UI to update extensions by @ruomengz in
-  [#23682](https://github.com/google-gemini/gemini-cli/pull/23682)
-- Fix(browser): terminate immediately for "browser is already running" error by
-  @cynthialong0-0 in
-  [#24233](https://github.com/google-gemini/gemini-cli/pull/24233)
-- docs: Add 'plan' option to approval mode in CLI reference by @YifanRuan in
-  [#24134](https://github.com/google-gemini/gemini-cli/pull/24134)
-- fix(core): batch macOS seatbelt rules into a profile file to prevent ARG_MAX
-  errors by @ehedlund in
-  [#24255](https://github.com/google-gemini/gemini-cli/pull/24255)
-- fix(core): fix race condition between browser agent and main closing process
-  by @cynthialong0-0 in
-  [#24340](https://github.com/google-gemini/gemini-cli/pull/24340)
-- perf(build): optimize build scripts for parallel execution and remove
-  redundant checks by @sehoon38 in
-  [#24307](https://github.com/google-gemini/gemini-cli/pull/24307)
-- ci: install bubblewrap on Linux for release workflows by @ehedlund in
-  [#24347](https://github.com/google-gemini/gemini-cli/pull/24347)
-- chore(release): allow bundling for all builds, including stable by @sehoon38
-  in [#24305](https://github.com/google-gemini/gemini-cli/pull/24305)
-- Revert "Add security settings for tool sandboxing" by @jerop in
-  [#24357](https://github.com/google-gemini/gemini-cli/pull/24357)
-- docs: update subagents docs to not be experimental by @abhipatel12 in
-  [#24343](https://github.com/google-gemini/gemini-cli/pull/24343)
-- fix(core): implement **read and **write commands in sandbox managers by
-  @galz10 in [#24283](https://github.com/google-gemini/gemini-cli/pull/24283)
-- don't try to remove tags in dry run by @scidomino in
-  [#24356](https://github.com/google-gemini/gemini-cli/pull/24356)
-- fix(config): disable JIT context loading by default by @SandyTao520 in
-  [#24364](https://github.com/google-gemini/gemini-cli/pull/24364)
-- test(sandbox): add integration test for dynamic permission expansion by
-  @galz10 in [#24359](https://github.com/google-gemini/gemini-cli/pull/24359)
-- docs(policy): remove unsupported mcpName wildcard edge case by @abhipatel12 in
-  [#24133](https://github.com/google-gemini/gemini-cli/pull/24133)
-- docs: fix broken GEMINI.md link in CONTRIBUTING.md by @Panchal-Tirth in
-  [#24182](https://github.com/google-gemini/gemini-cli/pull/24182)
-- feat(core): infrastructure for event-driven subagent history by @abhipatel12
-  in [#23914](https://github.com/google-gemini/gemini-cli/pull/23914)
-- fix(core): resolve Plan Mode deadlock during plan file creation due to sandbox
-  restrictions by @DavidAPierce in
-  [#24047](https://github.com/google-gemini/gemini-cli/pull/24047)
-- fix(core): fix browser agent UX issues and improve E2E test reliability by
-  @gsquared94 in
-  [#24312](https://github.com/google-gemini/gemini-cli/pull/24312)
-- fix(ui): wrap topic and intent fields in TopicMessage by @jwhelangoog in
-  [#24386](https://github.com/google-gemini/gemini-cli/pull/24386)
-- refactor(core): Centralize context management logic into src/context by
-  @joshualitt in
-  [#24380](https://github.com/google-gemini/gemini-cli/pull/24380)
-- fix(core): pin AuthType.GATEWAY to use Gemini 3.1 Pro/Flash Lite by default by
-  @sripasg in [#24375](https://github.com/google-gemini/gemini-cli/pull/24375)
-- feat(ui): add Tokyo Night theme by @danrneal in
-  [#24054](https://github.com/google-gemini/gemini-cli/pull/24054)
-- fix(cli): refactor test config loading and mock debugLogger in test-setup by
-  @mattKorwel in
-  [#24389](https://github.com/google-gemini/gemini-cli/pull/24389)
-- Set memoryManager to false in settings.json by @mattKorwel in
-  [#24393](https://github.com/google-gemini/gemini-cli/pull/24393)
-- ink 6.6.3 by @jacob314 in
-  [#24372](https://github.com/google-gemini/gemini-cli/pull/24372)
-- fix(core): resolve subagent chat recording gaps and directory inheritance by
+  [#22389](https://github.com/google-gemini/gemini-cli/pull/22389)
+- fix(cli): automatically add all VSCode workspace folders to Gemini context by
+  @sakshisemalti in
+  [#21380](https://github.com/google-gemini/gemini-cli/pull/21380)
+- feat: add 'blocked' status to tasks and todos by @anj-s in
+  [#22735](https://github.com/google-gemini/gemini-cli/pull/22735)
+- refactor(cli): remove extra newlines in ShellToolMessage.tsx by @NTaylorMullen
+  in [#22868](https://github.com/google-gemini/gemini-cli/pull/22868)
+- fix(cli): lazily load settings in onModelChange to prevent stale closure data
+  loss by @KumarADITHYA123 in
+  [#20403](https://github.com/google-gemini/gemini-cli/pull/20403)
+- feat(core): subagent local execution and tool isolation by @akh64bit in
+  [#22718](https://github.com/google-gemini/gemini-cli/pull/22718)
+- fix(cli): resolve subagent grouping and UI state persistence by @abhipatel12
+  in [#22252](https://github.com/google-gemini/gemini-cli/pull/22252)
+- refactor(ui): extract SessionBrowser search and navigation components by
   @abhipatel12 in
-  [#24368](https://github.com/google-gemini/gemini-cli/pull/24368)
-- fix(cli): cap shell output at 10 MB to prevent RangeError crash by @ProthamD
-  in [#24168](https://github.com/google-gemini/gemini-cli/pull/24168)
-- feat(plan): conditionally add enter/exit plan mode tools based on current mode
-  by @ruomengz in
-  [#24378](https://github.com/google-gemini/gemini-cli/pull/24378)
-- feat(core): prioritize discussion before formal plan approval by @jerop in
-  [#24423](https://github.com/google-gemini/gemini-cli/pull/24423)
-- fix(ui): add accelerated scrolling on alternate buffer mode by @devr0306 in
-  [#23940](https://github.com/google-gemini/gemini-cli/pull/23940)
-- feat(core): populate sandbox forbidden paths with project ignore file contents
-  by @ehedlund in
-  [#24038](https://github.com/google-gemini/gemini-cli/pull/24038)
-- fix(core): ensure blue border overlay and input blocker to act correctly
-  depending on browser agent activities by @cynthialong0-0 in
-  [#24385](https://github.com/google-gemini/gemini-cli/pull/24385)
-- fix(ui): removed additional vertical padding for tables by @devr0306 in
-  [#24381](https://github.com/google-gemini/gemini-cli/pull/24381)
-- fix(build): upload full bundle directory archive to GitHub releases by
-  @sehoon38 in [#24403](https://github.com/google-gemini/gemini-cli/pull/24403)
-- fix(build): wire bundle:browser-mcp into bundle pipeline by @gsquared94 in
-  [#24424](https://github.com/google-gemini/gemini-cli/pull/24424)
-- feat(browser): add sandbox-aware browser agent initialization by @gsquared94
-  in [#24419](https://github.com/google-gemini/gemini-cli/pull/24419)
-- feat(core): enhance tracker task schemas for detailed titles and descriptions
-  by @anj-s in [#23902](https://github.com/google-gemini/gemini-cli/pull/23902)
-- refactor(core): Unified context management settings schema by @joshualitt in
-  [#24391](https://github.com/google-gemini/gemini-cli/pull/24391)
-- feat(core): update browser agent prompt to check open pages first when
-  bringing up by @cynthialong0-0 in
-  [#24431](https://github.com/google-gemini/gemini-cli/pull/24431)
-- fix(acp) refactor(core,cli): centralize model discovery logic in
-  ModelConfigService by @sripasg in
-  [#24392](https://github.com/google-gemini/gemini-cli/pull/24392)
-- Changelog for v0.36.0-preview.7 by @gemini-cli-robot in
-  [#24346](https://github.com/google-gemini/gemini-cli/pull/24346)
-- fix: update task tracker storage location in system prompt by @anj-s in
-  [#24034](https://github.com/google-gemini/gemini-cli/pull/24034)
-- feat(browser): supersede stale snapshots to reclaim context-window tokens by
+  [#22377](https://github.com/google-gemini/gemini-cli/pull/22377)
+- fix: updates Docker image reference for GitHub MCP server by @jhhornn in
+  [#22938](https://github.com/google-gemini/gemini-cli/pull/22938)
+- refactor(cli): group subagent trajectory deletion and use native filesystem
+  testing by @abhipatel12 in
+  [#22890](https://github.com/google-gemini/gemini-cli/pull/22890)
+- refactor(cli): simplify keypress and mouse providers and update tests by
+  @scidomino in [#22853](https://github.com/google-gemini/gemini-cli/pull/22853)
+- Changelog for v0.34.0 by @gemini-cli-robot in
+  [#22860](https://github.com/google-gemini/gemini-cli/pull/22860)
+- test(cli): simplify createMockSettings calls by @scidomino in
+  [#22952](https://github.com/google-gemini/gemini-cli/pull/22952)
+- feat(ui): format multi-line banner warnings with a bold title by @keithguerin
+  in [#22955](https://github.com/google-gemini/gemini-cli/pull/22955)
+- Docs: Remove references to stale Gemini CLI file structure info by
+  @g-samroberts in
+  [#22976](https://github.com/google-gemini/gemini-cli/pull/22976)
+- feat(ui): remove write todo list tool from UI tips by @aniruddhaadak80 in
+  [#22281](https://github.com/google-gemini/gemini-cli/pull/22281)
+- Fix issue where subagent thoughts are appended. by @gundermanc in
+  [#22975](https://github.com/google-gemini/gemini-cli/pull/22975)
+- Feat/browser privacy consent by @kunal-10-cloud in
+  [#21119](https://github.com/google-gemini/gemini-cli/pull/21119)
+- fix(core): explicitly map execution context in LocalAgentExecutor by @akh64bit
+  in [#22949](https://github.com/google-gemini/gemini-cli/pull/22949)
+- feat(plan): support plan mode in non-interactive mode by @ruomengz in
+  [#22670](https://github.com/google-gemini/gemini-cli/pull/22670)
+- feat(core): implement strict macOS sandboxing using Seatbelt allowlist by
+  @ehedlund in [#22832](https://github.com/google-gemini/gemini-cli/pull/22832)
+- docs: add additional notes by @abhipatel12 in
+  [#23008](https://github.com/google-gemini/gemini-cli/pull/23008)
+- fix(cli): resolve duplicate footer on tool cancel via ESC (#21743) by
+  @ruomengz in [#21781](https://github.com/google-gemini/gemini-cli/pull/21781)
+- Changelog for v0.35.0-preview.1 by @gemini-cli-robot in
+  [#23012](https://github.com/google-gemini/gemini-cli/pull/23012)
+- fix(ui): fix flickering on small terminal heights by @devr0306 in
+  [#21416](https://github.com/google-gemini/gemini-cli/pull/21416)
+- fix(acp): provide more meta in tool_call_update by @Mervap in
+  [#22663](https://github.com/google-gemini/gemini-cli/pull/22663)
+- docs: add FAQ entry for checking Gemini CLI version by @surajsahani in
+  [#21271](https://github.com/google-gemini/gemini-cli/pull/21271)
+- feat(core): resilient subagent tool rejection with contextual feedback by
+  @abhipatel12 in
+  [#22951](https://github.com/google-gemini/gemini-cli/pull/22951)
+- fix(cli): correctly handle auto-update for standalone binaries by @bdmorgan in
+  [#23038](https://github.com/google-gemini/gemini-cli/pull/23038)
+- feat(core): add content-utils by @adamfweidman in
+  [#22984](https://github.com/google-gemini/gemini-cli/pull/22984)
+- fix: circumvent genai sdk requirement for api key when using gateway auth via
+  ACP by @sripasg in
+  [#23042](https://github.com/google-gemini/gemini-cli/pull/23042)
+- fix(core): don't persist browser consent sentinel in non-interactive mode by
+  @jasonmatthewsuhari in
+  [#23073](https://github.com/google-gemini/gemini-cli/pull/23073)
+- fix(core): narrow browser agent description to prevent stealing URL tasks from
+  web_fetch by @gsquared94 in
+  [#23086](https://github.com/google-gemini/gemini-cli/pull/23086)
+- feat(cli): Partial threading of AgentLoopContext. by @joshualitt in
+  [#22978](https://github.com/google-gemini/gemini-cli/pull/22978)
+- fix(browser-agent): enable "Allow all server tools" session policy by
+  @cynthialong0-0 in
+  [#22343](https://github.com/google-gemini/gemini-cli/pull/22343)
+- refactor(cli): integrate real config loading into async test utils by
+  @scidomino in [#23040](https://github.com/google-gemini/gemini-cli/pull/23040)
+- feat(core): inject memory and JIT context into subagents by @abhipatel12 in
+  [#23032](https://github.com/google-gemini/gemini-cli/pull/23032)
+- Fix logging and virtual list. by @jacob314 in
+  [#23080](https://github.com/google-gemini/gemini-cli/pull/23080)
+- feat(core): cap JIT context upward traversal at git root by @SandyTao520 in
+  [#23074](https://github.com/google-gemini/gemini-cli/pull/23074)
+- Docs: Minor style updates from initial docs audit. by @g-samroberts in
+  [#22872](https://github.com/google-gemini/gemini-cli/pull/22872)
+- feat(core): add experimental memory manager agent to replace save_memory tool
+  by @SandyTao520 in
+  [#22726](https://github.com/google-gemini/gemini-cli/pull/22726)
+- Changelog for v0.35.0-preview.2 by @gemini-cli-robot in
+  [#23142](https://github.com/google-gemini/gemini-cli/pull/23142)
+- Update website issue template for label and title by @g-samroberts in
+  [#23036](https://github.com/google-gemini/gemini-cli/pull/23036)
+- fix: upgrade ACP SDK from 0.12 to 0.16.1 by @sripasg in
+  [#23132](https://github.com/google-gemini/gemini-cli/pull/23132)
+- Update callouts to work on github. by @g-samroberts in
+  [#22245](https://github.com/google-gemini/gemini-cli/pull/22245)
+- feat: ACP: Add token usage metadata to the `send` method's return value by
+  @sripasg in [#23148](https://github.com/google-gemini/gemini-cli/pull/23148)
+- fix(plan): clarify that plan mode policies are combined with normal mode by
+  @ruomengz in [#23158](https://github.com/google-gemini/gemini-cli/pull/23158)
+- Add ModelChain support to ModelConfigService and make ModelDialog dynamic by
+  @kevinjwang1 in
+  [#22914](https://github.com/google-gemini/gemini-cli/pull/22914)
+- Ensure that copied extensions are writable in the user's local directory by
+  @kevinjwang1 in
+  [#23016](https://github.com/google-gemini/gemini-cli/pull/23016)
+- feat(core): implement native Windows sandboxing by @mattKorwel in
+  [#21807](https://github.com/google-gemini/gemini-cli/pull/21807)
+- feat(core): add support for admin-forced MCP server installations by
   @gsquared94 in
-  [#24440](https://github.com/google-gemini/gemini-cli/pull/24440)
-- docs(core): add subagent tool isolation draft doc by @akh64bit in
-  [#23275](https://github.com/google-gemini/gemini-cli/pull/23275)
-- fix(patch): cherry-pick 64c928f to release/v0.37.0-preview.0-pr-23257 to patch
-  version v0.37.0-preview.0 and create version 0.37.0-preview.1 by
+  [#23163](https://github.com/google-gemini/gemini-cli/pull/23163)
+- chore(lint): ignore .gemini directory and recursive node_modules by
+  @mattKorwel in
+  [#23211](https://github.com/google-gemini/gemini-cli/pull/23211)
+- feat(cli): conditionally exclude ask_user tool in ACP mode by @nmcnamara-eng
+  in [#23045](https://github.com/google-gemini/gemini-cli/pull/23045)
+- feat(core): introduce AgentSession and rename stream events to agent events by
+  @mbleigh in [#23159](https://github.com/google-gemini/gemini-cli/pull/23159)
+- feat(worktree): add Git worktree support for isolated parallel sessions by
+  @jerop in [#22973](https://github.com/google-gemini/gemini-cli/pull/22973)
+- Add support for linking in the extension registry by @kevinjwang1 in
+  [#23153](https://github.com/google-gemini/gemini-cli/pull/23153)
+- feat(extensions): add --skip-settings flag to install command by @Ratish1 in
+  [#17212](https://github.com/google-gemini/gemini-cli/pull/17212)
+- feat(telemetry): track if session is running in a Git worktree by @jerop in
+  [#23265](https://github.com/google-gemini/gemini-cli/pull/23265)
+- refactor(core): use absolute paths in GEMINI.md context markers by
+  @SandyTao520 in
+  [#23135](https://github.com/google-gemini/gemini-cli/pull/23135)
+- fix(core): add sanitization to sub agent thoughts and centralize utilities by
+  @devr0306 in [#22828](https://github.com/google-gemini/gemini-cli/pull/22828)
+- feat(core): refine User-Agent for VS Code traffic (unified format) by
+  @sehoon38 in [#23256](https://github.com/google-gemini/gemini-cli/pull/23256)
+- Fix schema for ModelChains by @kevinjwang1 in
+  [#23284](https://github.com/google-gemini/gemini-cli/pull/23284)
+- test(cli): refactor tests for async render utilities by @scidomino in
+  [#23252](https://github.com/google-gemini/gemini-cli/pull/23252)
+- feat(core): add security prompt for browser agent by @cynthialong0-0 in
+  [#23241](https://github.com/google-gemini/gemini-cli/pull/23241)
+- refactor(ide): replace dynamic undici import with static fetch import by
+  @cocosheng-g in
+  [#23268](https://github.com/google-gemini/gemini-cli/pull/23268)
+- test(cli): address unresolved feedback from PR #23252 by @scidomino in
+  [#23303](https://github.com/google-gemini/gemini-cli/pull/23303)
+- feat(browser): add sensitive action controls and read-only noise reduction by
+  @cynthialong0-0 in
+  [#22867](https://github.com/google-gemini/gemini-cli/pull/22867)
+- Disabling failing test while investigating by @alisa-alisa in
+  [#23311](https://github.com/google-gemini/gemini-cli/pull/23311)
+- fix broken extension link in hooks guide by @Indrapal-70 in
+  [#21728](https://github.com/google-gemini/gemini-cli/pull/21728)
+- fix(core): fix agent description indentation by @abhipatel12 in
+  [#23315](https://github.com/google-gemini/gemini-cli/pull/23315)
+- Wrap the text under TOML rule for easier readability in policy-engine.md… by
+  @CogitationOps in
+  [#23076](https://github.com/google-gemini/gemini-cli/pull/23076)
+- fix(extensions): revert broken extension removal behavior by @ehedlund in
+  [#23317](https://github.com/google-gemini/gemini-cli/pull/23317)
+- feat(core): set up onboarding telemetry by @yunaseoul in
+  [#23118](https://github.com/google-gemini/gemini-cli/pull/23118)
+- Retry evals on API error. by @gundermanc in
+  [#23322](https://github.com/google-gemini/gemini-cli/pull/23322)
+- fix(evals): remove tool restrictions and add compile-time guards by
+  @SandyTao520 in
+  [#23312](https://github.com/google-gemini/gemini-cli/pull/23312)
+- fix(hooks): support 'ask' decision for BeforeTool hooks by @gundermanc in
+  [#21146](https://github.com/google-gemini/gemini-cli/pull/21146)
+- feat(browser): add warning message for session mode 'existing' by
+  @cynthialong0-0 in
+  [#23288](https://github.com/google-gemini/gemini-cli/pull/23288)
+- chore(lint): enforce zero warnings and cleanup syntax restrictions by
+  @alisa-alisa in
+  [#22902](https://github.com/google-gemini/gemini-cli/pull/22902)
+- fix(cli): add Esc instruction to HooksDialog footer by @abhipatel12 in
+  [#23258](https://github.com/google-gemini/gemini-cli/pull/23258)
+- Disallow and suppress misused spread operator. by @gundermanc in
+  [#23294](https://github.com/google-gemini/gemini-cli/pull/23294)
+- fix(core): refine CliHelpAgent description for better delegation by
+  @abhipatel12 in
+  [#23310](https://github.com/google-gemini/gemini-cli/pull/23310)
+- fix(core): enable global session and persistent approval for web_fetch by
+  @NTaylorMullen in
+  [#23295](https://github.com/google-gemini/gemini-cli/pull/23295)
+- fix(plan): add state transition override to prevent plan mode freeze by
+  @Adib234 in [#23020](https://github.com/google-gemini/gemini-cli/pull/23020)
+- fix(cli): record skill activation tool calls in chat history by @NTaylorMullen
+  in [#23203](https://github.com/google-gemini/gemini-cli/pull/23203)
+- fix(core): ensure subagent tool updates apply configuration overrides
+  immediately by @abhipatel12 in
+  [#23161](https://github.com/google-gemini/gemini-cli/pull/23161)
+- fix(cli): resolve flicker at boundaries of list in BaseSelectionList by
+  @jackwotherspoon in
+  [#23298](https://github.com/google-gemini/gemini-cli/pull/23298)
+- test(cli): force generic terminal in tests to fix snapshot failures by
+  @abhipatel12 in
+  [#23499](https://github.com/google-gemini/gemini-cli/pull/23499)
+- Evals: PR Guidance adding workflow by @alisa-alisa in
+  [#23164](https://github.com/google-gemini/gemini-cli/pull/23164)
+- feat(core): refactor SandboxManager to a stateless architecture and introduce
+  explicit Deny interface by @ehedlund in
+  [#23141](https://github.com/google-gemini/gemini-cli/pull/23141)
+- feat(core): add event-translator and update agent types by @adamfweidman in
+  [#22985](https://github.com/google-gemini/gemini-cli/pull/22985)
+- perf(cli): parallelize and background startup cleanup tasks by @sehoon38 in
+  [#23545](https://github.com/google-gemini/gemini-cli/pull/23545)
+- fix: "allow always" for commands with paths by @scidomino in
+  [#23558](https://github.com/google-gemini/gemini-cli/pull/23558)
+- fix(cli): prevent terminal escape sequences from leaking on exit by
+  @mattKorwel in
+  [#22682](https://github.com/google-gemini/gemini-cli/pull/22682)
+- feat(cli): implement full "GEMINI CLI" logo for logged-out state by
+  @keithguerin in
+  [#22412](https://github.com/google-gemini/gemini-cli/pull/22412)
+- fix(plan): reserve minimum height for selection list in AskUserDialog by
+  @ruomengz in [#23280](https://github.com/google-gemini/gemini-cli/pull/23280)
+- fix(core): harden AgentSession replay semantics by @adamfweidman in
+  [#23548](https://github.com/google-gemini/gemini-cli/pull/23548)
+- test(core): migrate hook tests to scheduler by @abhipatel12 in
+  [#23496](https://github.com/google-gemini/gemini-cli/pull/23496)
+- chore(config): disable agents by default by @abhipatel12 in
+  [#23546](https://github.com/google-gemini/gemini-cli/pull/23546)
+- fix(ui): make tool confirmations take up entire terminal height by @devr0306
+  in [#22366](https://github.com/google-gemini/gemini-cli/pull/22366)
+- fix(core): prevent redundant remote agent loading on model switch by
+  @adamfweidman in
+  [#23576](https://github.com/google-gemini/gemini-cli/pull/23576)
+- refactor(core): update production type imports from coreToolScheduler by
+  @abhipatel12 in
+  [#23498](https://github.com/google-gemini/gemini-cli/pull/23498)
+- feat(cli): always prefix extension skills with colon separator by
+  @NTaylorMullen in
+  [#23566](https://github.com/google-gemini/gemini-cli/pull/23566)
+- fix(core): properly support allowRedirect in policy engine by @scidomino in
+  [#23579](https://github.com/google-gemini/gemini-cli/pull/23579)
+- fix(cli): prevent subcommand shadowing and skip auth for commands by
+  @mattKorwel in
+  [#23177](https://github.com/google-gemini/gemini-cli/pull/23177)
+- fix(test): move flaky tests to non-blocking suite by @mattKorwel in
+  [#23259](https://github.com/google-gemini/gemini-cli/pull/23259)
+- Changelog for v0.35.0-preview.3 by @gemini-cli-robot in
+  [#23574](https://github.com/google-gemini/gemini-cli/pull/23574)
+- feat(skills): add behavioral-evals skill with fixing and promoting guides by
+  @abhipatel12 in
+  [#23349](https://github.com/google-gemini/gemini-cli/pull/23349)
+- refactor(core): delete obsolete coreToolScheduler by @abhipatel12 in
+  [#23502](https://github.com/google-gemini/gemini-cli/pull/23502)
+- Changelog for v0.35.0-preview.4 by @gemini-cli-robot in
+  [#23581](https://github.com/google-gemini/gemini-cli/pull/23581)
+- feat(core): add LegacyAgentSession by @adamfweidman in
+  [#22986](https://github.com/google-gemini/gemini-cli/pull/22986)
+- feat(test-utils): add TestMcpServerBuilder and support in TestRig by
+  @abhipatel12 in
+  [#23491](https://github.com/google-gemini/gemini-cli/pull/23491)
+- fix(core)!: Force policy config to specify toolName by @kschaab in
+  [#23330](https://github.com/google-gemini/gemini-cli/pull/23330)
+- eval(save_memory): add multi-turn interactive evals for memoryManager by
+  @SandyTao520 in
+  [#23572](https://github.com/google-gemini/gemini-cli/pull/23572)
+- fix(telemetry): patch memory leak and enforce logPrompts privacy by
+  @spencer426 in
+  [#23281](https://github.com/google-gemini/gemini-cli/pull/23281)
+- perf(cli): background IDE client to speed up initialization by @sehoon38 in
+  [#23603](https://github.com/google-gemini/gemini-cli/pull/23603)
+- fix(cli): prevent Ctrl+D exit when input buffer is not empty by @wtanaka in
+  [#23306](https://github.com/google-gemini/gemini-cli/pull/23306)
+- fix: ACP: separate conversational text from execute tool command title by
+  @sripasg in [#23179](https://github.com/google-gemini/gemini-cli/pull/23179)
+- feat(evals): add behavioral evaluations for subagent routing by @Samee24 in
+  [#23272](https://github.com/google-gemini/gemini-cli/pull/23272)
+- refactor(cli,core): foundational layout, identity management, and type safety
+  by @jwhelangoog in
+  [#23286](https://github.com/google-gemini/gemini-cli/pull/23286)
+- fix(core): accurately reflect subagent tool failure in UI by @abhipatel12 in
+  [#23187](https://github.com/google-gemini/gemini-cli/pull/23187)
+- Changelog for v0.35.0-preview.5 by @gemini-cli-robot in
+  [#23606](https://github.com/google-gemini/gemini-cli/pull/23606)
+- feat(ui): implement refreshed UX for Composer layout by @jwhelangoog in
+  [#21212](https://github.com/google-gemini/gemini-cli/pull/21212)
+- fix: API key input dialog user interaction when selected Gemini API Key by
+  @kartikangiras in
+  [#21057](https://github.com/google-gemini/gemini-cli/pull/21057)
+- docs: update `/mcp refresh` to `/mcp reload` by @adamfweidman in
+  [#23631](https://github.com/google-gemini/gemini-cli/pull/23631)
+- Implementation of sandbox "Write-Protected" Governance Files by @DavidAPierce
+  in [#23139](https://github.com/google-gemini/gemini-cli/pull/23139)
+- feat(sandbox): dynamic macOS sandbox expansion and worktree support by @galz10
+  in [#23301](https://github.com/google-gemini/gemini-cli/pull/23301)
+- fix(acp): Pass the cwd to `AcpFileSystemService` to avoid looping failures in
+  asking for perms to write plan md file by @sripasg in
+  [#23612](https://github.com/google-gemini/gemini-cli/pull/23612)
+- fix(plan): sandbox path resolution in Plan Mode to prevent hallucinations by
+  @Adib234 in [#22737](https://github.com/google-gemini/gemini-cli/pull/22737)
+- feat(ui): allow immediate user input during startup by @sehoon38 in
+  [#23661](https://github.com/google-gemini/gemini-cli/pull/23661)
+- refactor(sandbox): reorganize Windows sandbox files by @galz10 in
+  [#23645](https://github.com/google-gemini/gemini-cli/pull/23645)
+- fix(core): improve remote agent streaming UI and UX by @adamfweidman in
+  [#23633](https://github.com/google-gemini/gemini-cli/pull/23633)
+- perf(cli): optimize --version startup time by @sehoon38 in
+  [#23671](https://github.com/google-gemini/gemini-cli/pull/23671)
+- refactor(core): stop gemini CLI from producing unsafe casts by @gundermanc in
+  [#23611](https://github.com/google-gemini/gemini-cli/pull/23611)
+- use enableAutoUpdate in test rig by @scidomino in
+  [#23681](https://github.com/google-gemini/gemini-cli/pull/23681)
+- feat(core): change user-facing auth type from oauth2 to oauth by @adamfweidman
+  in [#23639](https://github.com/google-gemini/gemini-cli/pull/23639)
+- chore(deps): fix npm audit vulnerabilities by @scidomino in
+  [#23679](https://github.com/google-gemini/gemini-cli/pull/23679)
+- test(evals): fix overlapping act() deadlock in app-test-helper by @Adib234 in
+  [#23666](https://github.com/google-gemini/gemini-cli/pull/23666)
+- fix(patch): cherry-pick 055ff92 to release/v0.36.0-preview.0-pr-23672 to patch
+  version v0.36.0-preview.0 and create version 0.36.0-preview.1 by
   @gemini-cli-robot in
-  [#24561](https://github.com/google-gemini/gemini-cli/pull/24561)
-- fix(patch): cherry-pick cb7f7d6 to release/v0.37.0-preview.1-pr-24342 to patch
-  version v0.37.0-preview.1 and create version 0.37.0-preview.2 by
+  [#23723](https://github.com/google-gemini/gemini-cli/pull/23723)
+- fix(patch): cherry-pick 765fb67 to release/v0.36.0-preview.5-pr-24055 to patch
+  version v0.36.0-preview.5 and create version 0.36.0-preview.6 by
   @gemini-cli-robot in
-  [#24842](https://github.com/google-gemini/gemini-cli/pull/24842)
+  [#24061](https://github.com/google-gemini/gemini-cli/pull/24061)
 
 **Full Changelog**:
-https://github.com/google-gemini/gemini-cli/compare/v0.36.0...v0.37.0
+https://github.com/google-gemini/gemini-cli/compare/v0.35.3...v0.36.0

docs/changelogs/preview.md

@@ -1,6 +1,6 @@
-# Preview release: v0.38.0-preview.0
+# Preview release: v0.37.0-preview.1
 
-Released: April 08, 2026
+Released: April 02, 2026
 
 Our preview release includes the latest, new, and experimental features. This
 release may not be as stable as our [latest weekly release](latest.md).
@@ -13,256 +13,410 @@ npm install -g @google/gemini-cli@preview
 
 ## Highlights
 
-- **Context Management:** Introduced a Context Compression Service to optimize
-  context window usage and landed a background memory service for skill
-  extraction.
-- **Enhanced Security:** Implemented context-aware persistent policy approvals
-  for smarter tool permissions and enabled `web_fetch` in plan mode with user
-  confirmation.
-- **Workflow Monitoring:** Added background process monitoring and inspection
-  tools for better visibility into long-running tasks.
-- **UI/UX Refinements:** Enhanced the tool confirmation UI, selection layout,
-  and added support for selective topic expansion and click-to-expand.
-- **Core Stability:** Improved sandbox reliability on Linux and Windows,
-  resolved shebang compatibility issues, and fixed various crashes in the CLI
-  and core services.
+- **Plan Mode Enhancements**: Plan now includes support for untrusted folders,
+  prioritized pre-approval discussions, and a resolve for sandbox-related
+  deadlocks during file creation.
+- **Browser Agent Evolved**: Significant updates to the browser agent, including
+  persistent session management, dynamic discovery of read-only tools,
+  sandbox-aware initialization, and automated reclamation of stale snapshots to
+  optimize context window usage.
+- **Advanced Sandbox Security**: Implementation of dynamic sandbox expansion for
+  both Linux and Windows, alongside secret visibility lockdown for environment
+  files and OS-specific forbidden path support.
+- **Unified Core Architecture**: Centralized context management and a new
+  `ModelConfigService` for unified model discovery, complemented by the
+  introduction of `AgentHistoryProvider` and tool-based topic grouping
+  (Chapters).
+- **UI/UX & Performance Improvements**: New Tokyo Night theme, "tab to queue"
+  message support, and compact tool output formatting, plus optimized build
+  scripts and improved layout stability for TUI components.
 
 ## What's Changed
 
-- fix(cli): refresh slash command list after /skills reload by @NTaylorMullen in
-  [#24454](https://github.com/google-gemini/gemini-cli/pull/24454)
-- Update README.md for links. by @g-samroberts in
-  [#22759](https://github.com/google-gemini/gemini-cli/pull/22759)
-- fix(core): ensure complete_task tool calls are recorded in chat history by
-  @abhipatel12 in
-  [#24437](https://github.com/google-gemini/gemini-cli/pull/24437)
-- feat(policy): explicitly allow web_fetch in plan mode with ask_user by
-  @Adib234 in [#24456](https://github.com/google-gemini/gemini-cli/pull/24456)
-- fix(core): refactor linux sandbox to fix ARG_MAX crashes by @ehedlund in
-  [#24286](https://github.com/google-gemini/gemini-cli/pull/24286)
-- feat(config): add experimental.adk.agentSessionNoninteractiveEnabled setting
+- fix(patch): cherry-pick 64c928f to release/v0.37.0-preview.0-pr-23257 to patch
+  version v0.37.0-preview.0 and create version 0.37.0-preview.1 by
+  @gemini-cli-robot in
+  [#24561](https://github.com/google-gemini/gemini-cli/pull/24561)
+- feat(evals): centralize test agents into test-utils for reuse by @Samee24 in
+  [#23616](https://github.com/google-gemini/gemini-cli/pull/23616)
+- revert: chore(config): disable agents by default by @abhipatel12 in
+  [#23672](https://github.com/google-gemini/gemini-cli/pull/23672)
+- fix(plan): update telemetry attribute keys and add timestamp by @Adib234 in
+  [#23685](https://github.com/google-gemini/gemini-cli/pull/23685)
+- fix(core): prevent premature MCP discovery completion by @jackwotherspoon in
+  [#23637](https://github.com/google-gemini/gemini-cli/pull/23637)
+- feat(browser): add maxActionsPerTask for browser agent setting by
+  @cynthialong0-0 in
+  [#23216](https://github.com/google-gemini/gemini-cli/pull/23216)
+- fix(core): improve agent loader error formatting for empty paths by
+  @adamfweidman in
+  [#23690](https://github.com/google-gemini/gemini-cli/pull/23690)
+- fix(cli): only show updating spinner when auto-update is in progress by
+  @scidomino in [#23709](https://github.com/google-gemini/gemini-cli/pull/23709)
+- Refine onboarding metrics to log the duration explicitly and use the tier
+  name. by @yunaseoul in
+  [#23678](https://github.com/google-gemini/gemini-cli/pull/23678)
+- chore(tools): add toJSON to tools and invocations to reduce logging verbosity
+  by @alisa-alisa in
+  [#22899](https://github.com/google-gemini/gemini-cli/pull/22899)
+- fix(cli): stabilize copy mode to prevent flickering and cursor resets by
+  @mattKorwel in
+  [#22584](https://github.com/google-gemini/gemini-cli/pull/22584)
+- fix(test): move flaky ctrl-c-exit test to non-blocking suite by @mattKorwel in
+  [#23732](https://github.com/google-gemini/gemini-cli/pull/23732)
+- feat(skills): add ci skill for automated failure replication by @mattKorwel in
+  [#23720](https://github.com/google-gemini/gemini-cli/pull/23720)
+- feat(sandbox): implement forbiddenPaths for OS-specific sandbox managers by
+  @ehedlund in [#23282](https://github.com/google-gemini/gemini-cli/pull/23282)
+- fix(core): conditionally expose additional_permissions in shell tool by
+  @galz10 in [#23729](https://github.com/google-gemini/gemini-cli/pull/23729)
+- refactor(core): standardize OS-specific sandbox tests and extract linux helper
+  methods by @ehedlund in
+  [#23715](https://github.com/google-gemini/gemini-cli/pull/23715)
+- format recently added script by @scidomino in
+  [#23739](https://github.com/google-gemini/gemini-cli/pull/23739)
+- fix(ui): prevent over-eager slash subcommand completion by @keithguerin in
+  [#20136](https://github.com/google-gemini/gemini-cli/pull/20136)
+- Fix dynamic model routing for gemini 3.1 pro to customtools model by
+  @kevinjwang1 in
+  [#23641](https://github.com/google-gemini/gemini-cli/pull/23641)
+- feat(core): support inline agentCardJson for remote agents by @adamfweidman in
+  [#23743](https://github.com/google-gemini/gemini-cli/pull/23743)
+- fix(cli): skip console log/info in headless mode by @cynthialong0-0 in
+  [#22739](https://github.com/google-gemini/gemini-cli/pull/22739)
+- test(core): install bubblewrap on Linux CI for sandbox integration tests by
+  @ehedlund in [#23583](https://github.com/google-gemini/gemini-cli/pull/23583)
+- docs(reference): split tools table into category sections by @sheikhlimon in
+  [#21516](https://github.com/google-gemini/gemini-cli/pull/21516)
+- fix(browser): detect embedded URLs in query params to prevent allowedDomains
+  bypass by @tony-shi in
+  [#23225](https://github.com/google-gemini/gemini-cli/pull/23225)
+- fix(browser): add proxy bypass constraint to domain restriction system prompt
+  by @tony-shi in
+  [#23229](https://github.com/google-gemini/gemini-cli/pull/23229)
+- fix(policy): relax write_file argsPattern in plan mode to allow paths without
+  session ID by @Adib234 in
+  [#23695](https://github.com/google-gemini/gemini-cli/pull/23695)
+- docs: fix grammar in CONTRIBUTING and numbering in sandbox docs by
+  @splint-disk-8i in
+  [#23448](https://github.com/google-gemini/gemini-cli/pull/23448)
+- fix(acp): allow attachments by adding a permission prompt by @sripasg in
+  [#23680](https://github.com/google-gemini/gemini-cli/pull/23680)
+- fix(core): thread AbortSignal to chat compression requests (#20405) by
+  @SH20RAJ in [#20778](https://github.com/google-gemini/gemini-cli/pull/20778)
+- feat(core): implement Windows sandbox dynamic expansion Phase 1 and 2.1 by
+  @scidomino in [#23691](https://github.com/google-gemini/gemini-cli/pull/23691)
+- Add note about root privileges in sandbox docs by @diodesign in
+  [#23314](https://github.com/google-gemini/gemini-cli/pull/23314)
+- docs(core): document agent_card_json string literal options for remote agents
   by @adamfweidman in
-  [#24439](https://github.com/google-gemini/gemini-cli/pull/24439)
-- Changelog for v0.36.0-preview.8 by @gemini-cli-robot in
-  [#24453](https://github.com/google-gemini/gemini-cli/pull/24453)
-- feat(cli): change default loadingPhrases to 'off' to hide tips by @keithguerin
-  in [#24342](https://github.com/google-gemini/gemini-cli/pull/24342)
-- fix(cli): ensure agent stops when all declinable tools are cancelled by
-  @NTaylorMullen in
-  [#24479](https://github.com/google-gemini/gemini-cli/pull/24479)
-- fix(core): enhance sandbox usability and fix build error by @galz10 in
-  [#24460](https://github.com/google-gemini/gemini-cli/pull/24460)
-- Terminal Serializer Optimization by @jacob314 in
-  [#24485](https://github.com/google-gemini/gemini-cli/pull/24485)
-- Auto configure memory. by @jacob314 in
-  [#24474](https://github.com/google-gemini/gemini-cli/pull/24474)
-- Unused error variables in catch block are not allowed by @alisa-alisa in
-  [#24487](https://github.com/google-gemini/gemini-cli/pull/24487)
-- feat(core): add background memory service for skill extraction by @SandyTao520
-  in [#24274](https://github.com/google-gemini/gemini-cli/pull/24274)
-- feat: implement high-signal PR regression check for evaluations by
+  [#23797](https://github.com/google-gemini/gemini-cli/pull/23797)
+- fix(cli): resolve TTY hang on headless environments by unconditionally
+  resuming process.stdin before React Ink launch by @cocosheng-g in
+  [#23673](https://github.com/google-gemini/gemini-cli/pull/23673)
+- fix(ui): cleanup estimated string length hacks in composer by @keithguerin in
+  [#23694](https://github.com/google-gemini/gemini-cli/pull/23694)
+- feat(browser): dynamically discover read-only tools by @cynthialong0-0 in
+  [#23805](https://github.com/google-gemini/gemini-cli/pull/23805)
+- docs: clarify policy requirement for `general.plan.directory` in settings
+  schema by @jerop in
+  [#23784](https://github.com/google-gemini/gemini-cli/pull/23784)
+- Revert "perf(cli): optimize --version startup time (#23671)" by @scidomino in
+  [#23812](https://github.com/google-gemini/gemini-cli/pull/23812)
+- don't silence errors from wombat by @scidomino in
+  [#23822](https://github.com/google-gemini/gemini-cli/pull/23822)
+- fix(ui): prevent escape key from cancelling requests in shell mode by
+  @PrasannaPal21 in
+  [#21245](https://github.com/google-gemini/gemini-cli/pull/21245)
+- Changelog for v0.36.0-preview.0 by @gemini-cli-robot in
+  [#23702](https://github.com/google-gemini/gemini-cli/pull/23702)
+- feat(core,ui): Add experiment-gated support for gemini flash 3.1 lite by
+  @chrstnb in [#23794](https://github.com/google-gemini/gemini-cli/pull/23794)
+- Changelog for v0.36.0-preview.3 by @gemini-cli-robot in
+  [#23827](https://github.com/google-gemini/gemini-cli/pull/23827)
+- new linting check: github-actions-pinning by @alisa-alisa in
+  [#23808](https://github.com/google-gemini/gemini-cli/pull/23808)
+- fix(cli): show helpful guidance when no skills are available by @Niralisj in
+  [#23785](https://github.com/google-gemini/gemini-cli/pull/23785)
+- fix: Chat logs and errors handle tail tool calls correctly by @googlestrobe in
+  [#22460](https://github.com/google-gemini/gemini-cli/pull/22460)
+- Don't try removing a tag from a non-existent release. by @scidomino in
+  [#23830](https://github.com/google-gemini/gemini-cli/pull/23830)
+- fix(cli): allow ask question dialog to take full window height by @jacob314 in
+  [#23693](https://github.com/google-gemini/gemini-cli/pull/23693)
+- fix(core): strip leading underscores from error types in telemetry by
+  @yunaseoul in [#23824](https://github.com/google-gemini/gemini-cli/pull/23824)
+- Changelog for v0.35.0 by @gemini-cli-robot in
+  [#23819](https://github.com/google-gemini/gemini-cli/pull/23819)
+- feat(evals): add reliability harvester and 500/503 retry support by
   @alisa-alisa in
-  [#23937](https://github.com/google-gemini/gemini-cli/pull/23937)
-- Fix shell output display by @jacob314 in
-  [#24490](https://github.com/google-gemini/gemini-cli/pull/24490)
-- fix(ui): resolve unwanted vertical spacing around various tool output
-  treatments by @jwhelangoog in
-  [#24449](https://github.com/google-gemini/gemini-cli/pull/24449)
-- revert(cli): bring back input box and footer visibility in copy mode by
-  @sehoon38 in [#24504](https://github.com/google-gemini/gemini-cli/pull/24504)
-- fix(cli): prevent crash in AnsiOutputText when handling non-array data by
-  @sehoon38 in [#24498](https://github.com/google-gemini/gemini-cli/pull/24498)
-- feat(cli): support default values for environment variables by @ruomengz in
-  [#24469](https://github.com/google-gemini/gemini-cli/pull/24469)
-- Implement background process monitoring and inspection tools by @cocosheng-g
-  in [#23799](https://github.com/google-gemini/gemini-cli/pull/23799)
-- docs(browser-agent): update stale browser agent documentation by @gsquared94
-  in [#24463](https://github.com/google-gemini/gemini-cli/pull/24463)
-- fix: enable browser_agent in integration tests and add localhost fixture tests
-  by @gsquared94 in
-  [#24523](https://github.com/google-gemini/gemini-cli/pull/24523)
-- fix(browser): handle computer-use model detection for analyze_screenshot by
-  @gsquared94 in
-  [#24502](https://github.com/google-gemini/gemini-cli/pull/24502)
-- feat(core): Land ContextCompressionService by @joshualitt in
-  [#24483](https://github.com/google-gemini/gemini-cli/pull/24483)
-- feat(core): scope subagent workspace directories via AsyncLocalStorage by
-  @SandyTao520 in
-  [#24445](https://github.com/google-gemini/gemini-cli/pull/24445)
-- Update ink version to 6.6.7 by @jacob314 in
-  [#24514](https://github.com/google-gemini/gemini-cli/pull/24514)
-- fix(acp): handle all InvalidStreamError types gracefully in prompt by @sripasg
-  in [#24540](https://github.com/google-gemini/gemini-cli/pull/24540)
-- Fix crash when vim editor is not found in PATH on Windows by
-  @Nagajyothi-tammisetti in
-  [#22423](https://github.com/google-gemini/gemini-cli/pull/22423)
-- fix(core): move project memory dir under tmp directory by @SandyTao520 in
-  [#24542](https://github.com/google-gemini/gemini-cli/pull/24542)
-- Enable 'Other' option for yesno question type by @ruomengz in
-  [#24545](https://github.com/google-gemini/gemini-cli/pull/24545)
-- fix(cli): clear stale retry/loading state after cancellation (#21096) by
-  @Aaxhirrr in [#21960](https://github.com/google-gemini/gemini-cli/pull/21960)
-- Changelog for v0.37.0-preview.0 by @gemini-cli-robot in
-  [#24464](https://github.com/google-gemini/gemini-cli/pull/24464)
-- feat(core): implement context-aware persistent policy approvals by @jerop in
-  [#23257](https://github.com/google-gemini/gemini-cli/pull/23257)
-- docs: move agent disabling instructions and update remote agent status by
-  @jackwotherspoon in
-  [#24559](https://github.com/google-gemini/gemini-cli/pull/24559)
-- feat(cli): migrate nonInteractiveCli to LegacyAgentSession by @adamfweidman in
-  [#22987](https://github.com/google-gemini/gemini-cli/pull/22987)
-- fix(core): unsafe type assertions in Core File System #19712 by
-  @aniketsaurav18 in
-  [#19739](https://github.com/google-gemini/gemini-cli/pull/19739)
-- fix(ui): hide model quota in /stats and refactor quota display by @danzaharia1
-  in [#24206](https://github.com/google-gemini/gemini-cli/pull/24206)
-- Changelog for v0.36.0 by @gemini-cli-robot in
-  [#24558](https://github.com/google-gemini/gemini-cli/pull/24558)
-- Changelog for v0.37.0-preview.1 by @gemini-cli-robot in
-  [#24568](https://github.com/google-gemini/gemini-cli/pull/24568)
-- docs: add missing .md extensions to internal doc links by @ishaan-arora-1 in
-  [#24145](https://github.com/google-gemini/gemini-cli/pull/24145)
-- fix(ui): fixed table styling by @devr0306 in
-  [#24565](https://github.com/google-gemini/gemini-cli/pull/24565)
-- fix(core): pass includeDirectories to sandbox configuration by @galz10 in
-  [#24573](https://github.com/google-gemini/gemini-cli/pull/24573)
-- feat(ui): enable "TerminalBuffer" mode to solve flicker by @jacob314 in
-  [#24512](https://github.com/google-gemini/gemini-cli/pull/24512)
-- docs: clarify release coordination by @scidomino in
-  [#24575](https://github.com/google-gemini/gemini-cli/pull/24575)
-- fix(core): remove broken PowerShell translation and fix native \_\_write in
-  Windows sandbox by @scidomino in
-  [#24571](https://github.com/google-gemini/gemini-cli/pull/24571)
-- Add instructions for how to start react in prod and force react to prod mode
-  by @jacob314 in
-  [#24590](https://github.com/google-gemini/gemini-cli/pull/24590)
-- feat(cli): minimalist sandbox status labels by @galz10 in
-  [#24582](https://github.com/google-gemini/gemini-cli/pull/24582)
-- Feat/browser agent metrics by @kunal-10-cloud in
-  [#24210](https://github.com/google-gemini/gemini-cli/pull/24210)
-- test: fix Windows CI execution and resolve exposed platform failures by
-  @ehedlund in [#24476](https://github.com/google-gemini/gemini-cli/pull/24476)
-- feat(core,cli): prioritize summary for topics (#24608) by @Abhijit-2592 in
-  [#24609](https://github.com/google-gemini/gemini-cli/pull/24609)
-- show color by @jacob314 in
-  [#24613](https://github.com/google-gemini/gemini-cli/pull/24613)
-- feat(cli): enable compact tool output by default (#24509) by @jwhelangoog in
-  [#24510](https://github.com/google-gemini/gemini-cli/pull/24510)
-- fix(core): inject skill system instructions into subagent prompts if activated
-  by @abhipatel12 in
-  [#24620](https://github.com/google-gemini/gemini-cli/pull/24620)
-- fix(core): improve windows sandbox reliability and fix integration tests by
-  @ehedlund in [#24480](https://github.com/google-gemini/gemini-cli/pull/24480)
-- fix(core): ensure sandbox approvals are correctly persisted and matched for
-  proactive expansions by @galz10 in
-  [#24577](https://github.com/google-gemini/gemini-cli/pull/24577)
-- feat(cli) Scrollbar for input prompt by @jacob314 in
-  [#21992](https://github.com/google-gemini/gemini-cli/pull/21992)
-- Do not run pr-eval workflow when no steering changes detected by @alisa-alisa
-  in [#24621](https://github.com/google-gemini/gemini-cli/pull/24621)
-- Fix restoration of topic headers. by @gundermanc in
-  [#24650](https://github.com/google-gemini/gemini-cli/pull/24650)
-- feat(core): discourage update topic tool for simple tasks by @Samee24 in
-  [#24640](https://github.com/google-gemini/gemini-cli/pull/24640)
-- fix(core): ensure global temp directory is always in sandbox allowed paths by
-  @galz10 in [#24638](https://github.com/google-gemini/gemini-cli/pull/24638)
-- fix(core): detect uninitialized lines by @jacob314 in
-  [#24646](https://github.com/google-gemini/gemini-cli/pull/24646)
-- docs: update sandboxing documentation and toolSandboxing settings by @galz10
-  in [#24655](https://github.com/google-gemini/gemini-cli/pull/24655)
-- feat(cli): enhance tool confirmation UI and selection layout by @galz10 in
-  [#24376](https://github.com/google-gemini/gemini-cli/pull/24376)
-- feat(acp): add support for `/about` command by @sripasg in
-  [#24649](https://github.com/google-gemini/gemini-cli/pull/24649)
-- feat(cli): add role specific metrics to /stats by @cynthialong0-0 in
-  [#24659](https://github.com/google-gemini/gemini-cli/pull/24659)
-- split context by @jacob314 in
-  [#24623](https://github.com/google-gemini/gemini-cli/pull/24623)
-- fix(cli): remove -S from shebang to fix Windows and BSD execution by
-  @scidomino in [#24756](https://github.com/google-gemini/gemini-cli/pull/24756)
-- Fix issue where topic headers can be posted back to back by @gundermanc in
-  [#24759](https://github.com/google-gemini/gemini-cli/pull/24759)
-- fix(core): handle partial llm_request in BeforeModel hook override by
-  @krishdef7 in [#22326](https://github.com/google-gemini/gemini-cli/pull/22326)
-- fix(ui): improve narration suppression and reduce flicker by @gundermanc in
-  [#24635](https://github.com/google-gemini/gemini-cli/pull/24635)
-- fix(ui): fixed auth race condition causing logo to flicker by @devr0306 in
-  [#24652](https://github.com/google-gemini/gemini-cli/pull/24652)
-- fix(browser): remove premature browser cleanup after subagent invocation by
-  @gsquared94 in
-  [#24753](https://github.com/google-gemini/gemini-cli/pull/24753)
-- Revert "feat(core,cli): prioritize summary for topics (#24608)" by
-  @Abhijit-2592 in
-  [#24777](https://github.com/google-gemini/gemini-cli/pull/24777)
-- relax tool sandboxing overrides for plan mode to match defaults. by
+  [#23626](https://github.com/google-gemini/gemini-cli/pull/23626)
+- feat(sandbox): dynamic Linux sandbox expansion and worktree support by @galz10
+  in [#23692](https://github.com/google-gemini/gemini-cli/pull/23692)
+- Merge examples of use into quickstart documentation by @diodesign in
+  [#23319](https://github.com/google-gemini/gemini-cli/pull/23319)
+- fix(cli): prioritize primary name matches in slash command search by @sehoon38
+  in [#23850](https://github.com/google-gemini/gemini-cli/pull/23850)
+- Changelog for v0.35.1 by @gemini-cli-robot in
+  [#23840](https://github.com/google-gemini/gemini-cli/pull/23840)
+- fix(browser): keep input blocker active across navigations by @kunal-10-cloud
+  in [#22562](https://github.com/google-gemini/gemini-cli/pull/22562)
+- feat(core): new skill to look for duplicated code while reviewing PRs by
+  @devr0306 in [#23704](https://github.com/google-gemini/gemini-cli/pull/23704)
+- fix(core): replace hardcoded non-interactive ASK_USER denial with explicit
+  policy rules by @ruomengz in
+  [#23668](https://github.com/google-gemini/gemini-cli/pull/23668)
+- fix(plan): after exiting plan mode switches model to a flash model by @Adib234
+  in [#23885](https://github.com/google-gemini/gemini-cli/pull/23885)
+- feat(gcp): add development worker infrastructure by @mattKorwel in
+  [#23814](https://github.com/google-gemini/gemini-cli/pull/23814)
+- fix(a2a-server): A2A server should execute ask policies in interactive mode by
+  @kschaab in [#23831](https://github.com/google-gemini/gemini-cli/pull/23831)
+- feat(core): define TrajectoryProvider interface by @sehoon38 in
+  [#23050](https://github.com/google-gemini/gemini-cli/pull/23050)
+- Docs: Update quotas and pricing by @jkcinouye in
+  [#23835](https://github.com/google-gemini/gemini-cli/pull/23835)
+- fix(core): allow disabling environment variable redaction by @galz10 in
+  [#23927](https://github.com/google-gemini/gemini-cli/pull/23927)
+- feat(cli): enable notifications cross-platform via terminal bell fallback by
+  @genneth in [#21618](https://github.com/google-gemini/gemini-cli/pull/21618)
+- feat(sandbox): implement secret visibility lockdown for env files by
   @DavidAPierce in
-  [#24762](https://github.com/google-gemini/gemini-cli/pull/24762)
-- fix(cli): respect global environment variable allowlist by @scidomino in
-  [#24767](https://github.com/google-gemini/gemini-cli/pull/24767)
-- fix(cli): ensure skills list outputs to stdout in non-interactive environments
-  by @spencer426 in
-  [#24566](https://github.com/google-gemini/gemini-cli/pull/24566)
-- Add an eval for and fix unsafe cloning behavior. by @gundermanc in
-  [#24457](https://github.com/google-gemini/gemini-cli/pull/24457)
-- fix(policy): allow complete_task in plan mode by @abhipatel12 in
-  [#24771](https://github.com/google-gemini/gemini-cli/pull/24771)
-- feat(telemetry): add browser agent clearcut metrics by @gsquared94 in
-  [#24688](https://github.com/google-gemini/gemini-cli/pull/24688)
-- feat(cli): support selective topic expansion and click-to-expand by
-  @Abhijit-2592 in
-  [#24793](https://github.com/google-gemini/gemini-cli/pull/24793)
-- temporarily disable sandbox integration test on windows by @ehedlund in
-  [#24786](https://github.com/google-gemini/gemini-cli/pull/24786)
-- Remove flakey test by @scidomino in
-  [#24837](https://github.com/google-gemini/gemini-cli/pull/24837)
-- Alisa/approve button by @alisa-alisa in
-  [#24645](https://github.com/google-gemini/gemini-cli/pull/24645)
-- feat(hooks): display hook system messages in UI by @mbleigh in
-  [#24616](https://github.com/google-gemini/gemini-cli/pull/24616)
-- fix(core): propagate BeforeModel hook model override end-to-end by @krishdef7
-  in [#24784](https://github.com/google-gemini/gemini-cli/pull/24784)
-- chore: fix formatting for behavioral eval skill reference file by @abhipatel12
-  in [#24846](https://github.com/google-gemini/gemini-cli/pull/24846)
-- fix: use directory junctions on Windows for skill linking by @enjoykumawat in
-  [#24823](https://github.com/google-gemini/gemini-cli/pull/24823)
-- fix(cli): prevent multiple banner increments on remount by @sehoon38 in
-  [#24843](https://github.com/google-gemini/gemini-cli/pull/24843)
-- feat(acp): add /help command by @sripasg in
-  [#24839](https://github.com/google-gemini/gemini-cli/pull/24839)
-- fix(core): remove tmux alternate buffer warning by @jackwotherspoon in
-  [#24852](https://github.com/google-gemini/gemini-cli/pull/24852)
-- Improve sandbox error matching and caching by @DavidAPierce in
-  [#24550](https://github.com/google-gemini/gemini-cli/pull/24550)
-- feat(core): add agent protocol UI types and experimental flag by @mbleigh in
-  [#24275](https://github.com/google-gemini/gemini-cli/pull/24275)
-- feat(core): use experiment flags for default fetch timeouts by @yunaseoul in
-  [#24261](https://github.com/google-gemini/gemini-cli/pull/24261)
-- Revert "fix(ui): improve narration suppression and reduce flicker (#2… by
-  @gundermanc in
-  [#24857](https://github.com/google-gemini/gemini-cli/pull/24857)
-- refactor(cli): remove duplication in interactive shell awaiting input hint by
-  @JayadityaGit in
-  [#24801](https://github.com/google-gemini/gemini-cli/pull/24801)
-- refactor(core): make LegacyAgentSession dependencies optional by @mbleigh in
-  [#24287](https://github.com/google-gemini/gemini-cli/pull/24287)
-- Changelog for v0.37.0-preview.2 by @gemini-cli-robot in
-  [#24848](https://github.com/google-gemini/gemini-cli/pull/24848)
-- fix(cli): always show shell command description or actual command by @jacob314
-  in [#24774](https://github.com/google-gemini/gemini-cli/pull/24774)
-- Added flag for ept size and increased default size by @devr0306 in
-  [#24859](https://github.com/google-gemini/gemini-cli/pull/24859)
-- fix(core): dispose Scheduler to prevent McpProgress listener leak by
-  @Anjaligarhwal in
-  [#24870](https://github.com/google-gemini/gemini-cli/pull/24870)
-- fix(cli): switch default back to terminalBuffer=false and fix regressions
-  introduced for that mode by @jacob314 in
-  [#24873](https://github.com/google-gemini/gemini-cli/pull/24873)
-- feat(cli): switch to ctrl+g from ctrl-x by @jacob314 in
-  [#24861](https://github.com/google-gemini/gemini-cli/pull/24861)
-- fix: isolate concurrent browser agent instances by @gsquared94 in
-  [#24794](https://github.com/google-gemini/gemini-cli/pull/24794)
-- docs: update MCP server OAuth redirect port documentation by @adamfweidman in
-  [#24844](https://github.com/google-gemini/gemini-cli/pull/24844)
+  [#23712](https://github.com/google-gemini/gemini-cli/pull/23712)
+- fix(core): remove shell outputChunks buffer caching to prevent memory bloat
+  and sanitize prompt input by @spencer426 in
+  [#23751](https://github.com/google-gemini/gemini-cli/pull/23751)
+- feat(core): implement persistent browser session management by @kunal-10-cloud
+  in [#21306](https://github.com/google-gemini/gemini-cli/pull/21306)
+- refactor(core): delegate sandbox denial parsing to SandboxManager by
+  @scidomino in [#23928](https://github.com/google-gemini/gemini-cli/pull/23928)
+- dep(update) Update Ink version to 6.5.0 by @jacob314 in
+  [#23843](https://github.com/google-gemini/gemini-cli/pull/23843)
+- Docs: Update 'docs-writer' skill for relative links by @jkcinouye in
+  [#21463](https://github.com/google-gemini/gemini-cli/pull/21463)
+- Changelog for v0.36.0-preview.4 by @gemini-cli-robot in
+  [#23935](https://github.com/google-gemini/gemini-cli/pull/23935)
+- fix(acp): Update allow approval policy flow for ACP clients to fix config
+  persistence and compatible with TUI by @sripasg in
+  [#23818](https://github.com/google-gemini/gemini-cli/pull/23818)
+- Changelog for v0.35.2 by @gemini-cli-robot in
+  [#23960](https://github.com/google-gemini/gemini-cli/pull/23960)
+- ACP integration documents by @g-samroberts in
+  [#22254](https://github.com/google-gemini/gemini-cli/pull/22254)
+- fix(core): explicitly set error names to avoid bundling renaming issues by
+  @yunaseoul in [#23913](https://github.com/google-gemini/gemini-cli/pull/23913)
+- feat(core): subagent isolation and cleanup hardening by @abhipatel12 in
+  [#23903](https://github.com/google-gemini/gemini-cli/pull/23903)
+- disable extension-reload test by @scidomino in
+  [#24018](https://github.com/google-gemini/gemini-cli/pull/24018)
+- feat(core): add forbiddenPaths to GlobalSandboxOptions and refactor
+  createSandboxManager by @ehedlund in
+  [#23936](https://github.com/google-gemini/gemini-cli/pull/23936)
+- refactor(core): improve ignore resolution and fix directory-matching bug by
+  @ehedlund in [#23816](https://github.com/google-gemini/gemini-cli/pull/23816)
+- revert(core): support custom base URL via env vars by @spencer426 in
+  [#23976](https://github.com/google-gemini/gemini-cli/pull/23976)
+- Increase memory limited for eslint. by @jacob314 in
+  [#24022](https://github.com/google-gemini/gemini-cli/pull/24022)
+- fix(acp): prevent crash on empty response in ACP mode by @sripasg in
+  [#23952](https://github.com/google-gemini/gemini-cli/pull/23952)
+- feat(core): Land `AgentHistoryProvider`. by @joshualitt in
+  [#23978](https://github.com/google-gemini/gemini-cli/pull/23978)
+- fix(core): switch to subshells for shell tool wrapping to fix heredocs and
+  edge cases by @abhipatel12 in
+  [#24024](https://github.com/google-gemini/gemini-cli/pull/24024)
+- Debug command. by @jacob314 in
+  [#23851](https://github.com/google-gemini/gemini-cli/pull/23851)
+- Changelog for v0.36.0-preview.5 by @gemini-cli-robot in
+  [#24046](https://github.com/google-gemini/gemini-cli/pull/24046)
+- Fix test flakes by globally mocking ink-spinner by @jacob314 in
+  [#24044](https://github.com/google-gemini/gemini-cli/pull/24044)
+- Enable network access in sandbox configuration by @galz10 in
+  [#24055](https://github.com/google-gemini/gemini-cli/pull/24055)
+- feat(context): add configurable memoryBoundaryMarkers setting by @SandyTao520
+  in [#24020](https://github.com/google-gemini/gemini-cli/pull/24020)
+- feat(core): implement windows sandbox expansion and denial detection by
+  @scidomino in [#24027](https://github.com/google-gemini/gemini-cli/pull/24027)
+- fix(core): resolve ACP Operation Aborted Errors in grep_search by @ivanporty
+  in [#23821](https://github.com/google-gemini/gemini-cli/pull/23821)
+- fix(hooks): prevent SessionEnd from firing twice in non-interactive mode by
+  @krishdef7 in [#22139](https://github.com/google-gemini/gemini-cli/pull/22139)
+- Re-word intro to Gemini 3 page. by @g-samroberts in
+  [#24069](https://github.com/google-gemini/gemini-cli/pull/24069)
+- fix(cli): resolve layout contention and flashing loop in StatusRow by
+  @keithguerin in
+  [#24065](https://github.com/google-gemini/gemini-cli/pull/24065)
+- fix(sandbox): implement Windows Mandatory Integrity Control for GeminiSandbox
+  by @galz10 in [#24057](https://github.com/google-gemini/gemini-cli/pull/24057)
+- feat(core): implement tool-based topic grouping (Chapters) by @Abhijit-2592 in
+  [#23150](https://github.com/google-gemini/gemini-cli/pull/23150)
+- feat(cli): support 'tab to queue' for messages while generating by @gundermanc
+  in [#24052](https://github.com/google-gemini/gemini-cli/pull/24052)
+- feat(core): agnostic background task UI with CompletionBehavior by
+  @adamfweidman in
+  [#22740](https://github.com/google-gemini/gemini-cli/pull/22740)
+- UX for topic narration tool by @gundermanc in
+  [#24079](https://github.com/google-gemini/gemini-cli/pull/24079)
+- fix: shellcheck warnings in scripts by @scidomino in
+  [#24035](https://github.com/google-gemini/gemini-cli/pull/24035)
+- test(evals): add comprehensive subagent delegation evaluations by @abhipatel12
+  in [#24132](https://github.com/google-gemini/gemini-cli/pull/24132)
+- fix(a2a-server): prioritize ADC before evaluating headless constraints for
+  auth initialization by @spencer426 in
+  [#23614](https://github.com/google-gemini/gemini-cli/pull/23614)
+- Text can be added after /plan command by @rambleraptor in
+  [#22833](https://github.com/google-gemini/gemini-cli/pull/22833)
+- fix(cli): resolve missing F12 logs via global console store by @scidomino in
+  [#24235](https://github.com/google-gemini/gemini-cli/pull/24235)
+- fix broken tests by @scidomino in
+  [#24279](https://github.com/google-gemini/gemini-cli/pull/24279)
+- fix(evals): add update_topic behavioral eval by @gundermanc in
+  [#24223](https://github.com/google-gemini/gemini-cli/pull/24223)
+- feat(core): Unified Context Management and Tool Distillation. by @joshualitt
+  in [#24157](https://github.com/google-gemini/gemini-cli/pull/24157)
+- Default enable narration for the team. by @gundermanc in
+  [#24224](https://github.com/google-gemini/gemini-cli/pull/24224)
+- fix(core): ensure default agents provide tools and use model-specific schemas
+  by @abhipatel12 in
+  [#24268](https://github.com/google-gemini/gemini-cli/pull/24268)
+- feat(cli): show Flash Lite Preview model regardless of user tier by @sehoon38
+  in [#23904](https://github.com/google-gemini/gemini-cli/pull/23904)
+- feat(cli): implement compact tool output by @jwhelangoog in
+  [#20974](https://github.com/google-gemini/gemini-cli/pull/20974)
+- Add security settings for tool sandboxing by @galz10 in
+  [#23923](https://github.com/google-gemini/gemini-cli/pull/23923)
+- chore(test-utils): switch integration tests to use PREVIEW_GEMINI_MODEL by
+  @sehoon38 in [#24276](https://github.com/google-gemini/gemini-cli/pull/24276)
+- feat(core): enable topic update narration for legacy models by @Abhijit-2592
+  in [#24241](https://github.com/google-gemini/gemini-cli/pull/24241)
+- feat(core): add project-level memory scope to save_memory tool by @SandyTao520
+  in [#24161](https://github.com/google-gemini/gemini-cli/pull/24161)
+- test(integration): fix plan mode write denial test false positive by @sehoon38
+  in [#24299](https://github.com/google-gemini/gemini-cli/pull/24299)
+- feat(plan): support `Plan` mode in untrusted folders by @Adib234 in
+  [#17586](https://github.com/google-gemini/gemini-cli/pull/17586)
+- fix(core): enable mid-stream retries for all models and re-enable compression
+  test by @sehoon38 in
+  [#24302](https://github.com/google-gemini/gemini-cli/pull/24302)
+- Changelog for v0.36.0-preview.6 by @gemini-cli-robot in
+  [#24082](https://github.com/google-gemini/gemini-cli/pull/24082)
+- Changelog for v0.35.3 by @gemini-cli-robot in
+  [#24083](https://github.com/google-gemini/gemini-cli/pull/24083)
+- feat(cli): add auth info to footer by @sehoon38 in
+  [#24042](https://github.com/google-gemini/gemini-cli/pull/24042)
+- fix(browser): reset action counter for each agent session and let it ignore
+  internal actions by @cynthialong0-0 in
+  [#24228](https://github.com/google-gemini/gemini-cli/pull/24228)
+- feat(plan): promote planning feature to stable by @ruomengz in
+  [#24282](https://github.com/google-gemini/gemini-cli/pull/24282)
+- fix(browser): terminate subagent immediately on domain restriction violations
+  by @gsquared94 in
+  [#24313](https://github.com/google-gemini/gemini-cli/pull/24313)
+- feat(cli): add UI to update extensions by @ruomengz in
+  [#23682](https://github.com/google-gemini/gemini-cli/pull/23682)
+- Fix(browser): terminate immediately for "browser is already running" error by
+  @cynthialong0-0 in
+  [#24233](https://github.com/google-gemini/gemini-cli/pull/24233)
+- docs: Add 'plan' option to approval mode in CLI reference by @YifanRuan in
+  [#24134](https://github.com/google-gemini/gemini-cli/pull/24134)
+- fix(core): batch macOS seatbelt rules into a profile file to prevent ARG_MAX
+  errors by @ehedlund in
+  [#24255](https://github.com/google-gemini/gemini-cli/pull/24255)
+- fix(core): fix race condition between browser agent and main closing process
+  by @cynthialong0-0 in
+  [#24340](https://github.com/google-gemini/gemini-cli/pull/24340)
+- perf(build): optimize build scripts for parallel execution and remove
+  redundant checks by @sehoon38 in
+  [#24307](https://github.com/google-gemini/gemini-cli/pull/24307)
+- ci: install bubblewrap on Linux for release workflows by @ehedlund in
+  [#24347](https://github.com/google-gemini/gemini-cli/pull/24347)
+- chore(release): allow bundling for all builds, including stable by @sehoon38
+  in [#24305](https://github.com/google-gemini/gemini-cli/pull/24305)
+- Revert "Add security settings for tool sandboxing" by @jerop in
+  [#24357](https://github.com/google-gemini/gemini-cli/pull/24357)
+- docs: update subagents docs to not be experimental by @abhipatel12 in
+  [#24343](https://github.com/google-gemini/gemini-cli/pull/24343)
+- fix(core): implement **read and **write commands in sandbox managers by
+  @galz10 in [#24283](https://github.com/google-gemini/gemini-cli/pull/24283)
+- don't try to remove tags in dry run by @scidomino in
+  [#24356](https://github.com/google-gemini/gemini-cli/pull/24356)
+- fix(config): disable JIT context loading by default by @SandyTao520 in
+  [#24364](https://github.com/google-gemini/gemini-cli/pull/24364)
+- test(sandbox): add integration test for dynamic permission expansion by
+  @galz10 in [#24359](https://github.com/google-gemini/gemini-cli/pull/24359)
+- docs(policy): remove unsupported mcpName wildcard edge case by @abhipatel12 in
+  [#24133](https://github.com/google-gemini/gemini-cli/pull/24133)
+- docs: fix broken GEMINI.md link in CONTRIBUTING.md by @Panchal-Tirth in
+  [#24182](https://github.com/google-gemini/gemini-cli/pull/24182)
+- feat(core): infrastructure for event-driven subagent history by @abhipatel12
+  in [#23914](https://github.com/google-gemini/gemini-cli/pull/23914)
+- fix(core): resolve Plan Mode deadlock during plan file creation due to sandbox
+  restrictions by @DavidAPierce in
+  [#24047](https://github.com/google-gemini/gemini-cli/pull/24047)
+- fix(core): fix browser agent UX issues and improve E2E test reliability by
+  @gsquared94 in
+  [#24312](https://github.com/google-gemini/gemini-cli/pull/24312)
+- fix(ui): wrap topic and intent fields in TopicMessage by @jwhelangoog in
+  [#24386](https://github.com/google-gemini/gemini-cli/pull/24386)
+- refactor(core): Centralize context management logic into src/context by
+  @joshualitt in
+  [#24380](https://github.com/google-gemini/gemini-cli/pull/24380)
+- fix(core): pin AuthType.GATEWAY to use Gemini 3.1 Pro/Flash Lite by default by
+  @sripasg in [#24375](https://github.com/google-gemini/gemini-cli/pull/24375)
+- feat(ui): add Tokyo Night theme by @danrneal in
+  [#24054](https://github.com/google-gemini/gemini-cli/pull/24054)
+- fix(cli): refactor test config loading and mock debugLogger in test-setup by
+  @mattKorwel in
+  [#24389](https://github.com/google-gemini/gemini-cli/pull/24389)
+- Set memoryManager to false in settings.json by @mattKorwel in
+  [#24393](https://github.com/google-gemini/gemini-cli/pull/24393)
+- ink 6.6.3 by @jacob314 in
+  [#24372](https://github.com/google-gemini/gemini-cli/pull/24372)
+- fix(core): resolve subagent chat recording gaps and directory inheritance by
+  @abhipatel12 in
+  [#24368](https://github.com/google-gemini/gemini-cli/pull/24368)
+- fix(cli): cap shell output at 10 MB to prevent RangeError crash by @ProthamD
+  in [#24168](https://github.com/google-gemini/gemini-cli/pull/24168)
+- feat(plan): conditionally add enter/exit plan mode tools based on current mode
+  by @ruomengz in
+  [#24378](https://github.com/google-gemini/gemini-cli/pull/24378)
+- feat(core): prioritize discussion before formal plan approval by @jerop in
+  [#24423](https://github.com/google-gemini/gemini-cli/pull/24423)
+- fix(ui): add accelerated scrolling on alternate buffer mode by @devr0306 in
+  [#23940](https://github.com/google-gemini/gemini-cli/pull/23940)
+- feat(core): populate sandbox forbidden paths with project ignore file contents
+  by @ehedlund in
+  [#24038](https://github.com/google-gemini/gemini-cli/pull/24038)
+- fix(core): ensure blue border overlay and input blocker to act correctly
+  depending on browser agent activities by @cynthialong0-0 in
+  [#24385](https://github.com/google-gemini/gemini-cli/pull/24385)
+- fix(ui): removed additional vertical padding for tables by @devr0306 in
+  [#24381](https://github.com/google-gemini/gemini-cli/pull/24381)
+- fix(build): upload full bundle directory archive to GitHub releases by
+  @sehoon38 in [#24403](https://github.com/google-gemini/gemini-cli/pull/24403)
+- fix(build): wire bundle:browser-mcp into bundle pipeline by @gsquared94 in
+  [#24424](https://github.com/google-gemini/gemini-cli/pull/24424)
+- feat(browser): add sandbox-aware browser agent initialization by @gsquared94
+  in [#24419](https://github.com/google-gemini/gemini-cli/pull/24419)
+- feat(core): enhance tracker task schemas for detailed titles and descriptions
+  by @anj-s in [#23902](https://github.com/google-gemini/gemini-cli/pull/23902)
+- refactor(core): Unified context management settings schema by @joshualitt in
+  [#24391](https://github.com/google-gemini/gemini-cli/pull/24391)
+- feat(core): update browser agent prompt to check open pages first when
+  bringing up by @cynthialong0-0 in
+  [#24431](https://github.com/google-gemini/gemini-cli/pull/24431)
+- fix(acp) refactor(core,cli): centralize model discovery logic in
+  ModelConfigService by @sripasg in
+  [#24392](https://github.com/google-gemini/gemini-cli/pull/24392)
+- Changelog for v0.36.0-preview.7 by @gemini-cli-robot in
+  [#24346](https://github.com/google-gemini/gemini-cli/pull/24346)
+- fix: update task tracker storage location in system prompt by @anj-s in
+  [#24034](https://github.com/google-gemini/gemini-cli/pull/24034)
+- feat(browser): supersede stale snapshots to reclaim context-window tokens by
+  @gsquared94 in
+  [#24440](https://github.com/google-gemini/gemini-cli/pull/24440)
+- docs(core): add subagent tool isolation draft doc by @akh64bit in
+  [#23275](https://github.com/google-gemini/gemini-cli/pull/23275)
 
 **Full Changelog**:
-https://github.com/google-gemini/gemini-cli/compare/v0.37.0-preview.2...v0.38.0-preview.0
+https://github.com/google-gemini/gemini-cli/compare/v0.36.0-preview.8...v0.37.0-preview.1

docs/cli/settings.md

@@ -75,7 +75,7 @@ they appear in the UI.
 | Show User Identity                   | `ui.showUserIdentity`                  | Show the signed-in user's identity (e.g. email) in the UI.                                                                                                        | `true`  |
 | Use Alternate Screen Buffer          | `ui.useAlternateBuffer`                | Use an alternate screen buffer for the UI, preserving shell history.                                                                                              | `false` |
 | Render Process                       | `ui.renderProcess`                     | Enable Ink render process for the UI.                                                                                                                             | `true`  |
-| Terminal Buffer                      | `ui.terminalBuffer`                    | Use the new terminal buffer architecture for rendering.                                                                                                           | `false` |
+| Terminal Buffer                      | `ui.terminalBuffer`                    | Use the new terminal buffer architecture for rendering.                                                                                                           | `true`  |
 | Use Background Color                 | `ui.useBackgroundColor`                | Whether to use background colors in the UI.                                                                                                                       | `true`  |
 | Incremental Rendering                | `ui.incrementalRendering`              | Enable incremental rendering for the UI. This option will reduce flickering but may cause rendering artifacts. Only supported when useAlternateBuffer is enabled. | `true`  |
 | Show Spinner                         | `ui.showSpinner`                       | Show the spinner during operations.                                                                                                                               | `true`  |
@@ -153,9 +153,9 @@ they appear in the UI.
 
 ### Advanced
 
-| UI Label                          | Setting                        | Description                                                                                                                                                                                                           | Default |
-| --------------------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
-| Auto Configure Max Old Space Size | `advanced.autoConfigureMemory` | Automatically configure Node.js memory limits. Note: Because memory is allocated during the initial process boot, this setting is only read from the global user settings file and ignores workspace-level overrides. | `true`  |
+| UI Label                          | Setting                        | Description                                   | Default |
+| --------------------------------- | ------------------------------ | --------------------------------------------- | ------- |
+| Auto Configure Max Old Space Size | `advanced.autoConfigureMemory` | Automatically configure Node.js memory limits | `true`  |
 
 ### Experimental
 

docs/integration-tests.md

@@ -117,88 +117,6 @@ npm run test:integration:sandbox:docker
 npm run test:integration:sandbox:podman
 ```
 
-## Memory regression tests
-
-Memory regression tests are designed to detect heap growth and leaks across key
-CLI scenarios. They are located in the `memory-tests` directory.
-
-These tests are distinct from standard integration tests because they measure
-memory usage and compare it against committed baselines.
-
-### Running memory tests
-
-Memory tests are not run as part of the default `npm run test` or
-`npm run test:e2e` commands. They are run nightly in CI but can be run manually:
-
-```bash
-npm run test:memory
-```
-
-### Updating baselines
-
-If you intentionally change behavior that affects memory usage, you may need to
-update the baselines. Set the `UPDATE_MEMORY_BASELINES` environment variable to
-`true`:
-
-```bash
-UPDATE_MEMORY_BASELINES=true npm run test:memory
-```
-
-This will run the tests, take median snapshots, and overwrite
-`memory-tests/baselines.json`. You should review the changes and commit the
-updated baseline file.
-
-### How it works
-
-The harness (`MemoryTestHarness` in `packages/test-utils`):
-
-- Forces garbage collection multiple times to reduce noise.
-- Takes median snapshots to filter spikes.
-- Compares against baselines with a 10% tolerance.
-- Can analyze sustained leaks across 3 snapshots using `analyzeSnapshots()`.
-
-## Performance regression tests
-
-Performance regression tests are designed to detect wall-clock time, CPU usage,
-and event loop delay regressions across key CLI scenarios. They are located in
-the `perf-tests` directory.
-
-These tests are distinct from standard integration tests because they measure
-performance metrics and compare it against committed baselines.
-
-### Running performance tests
-
-Performance tests are not run as part of the default `npm run test` or
-`npm run test:e2e` commands. They are run nightly in CI but can be run manually:
-
-```bash
-npm run test:perf
-```
-
-### Updating baselines
-
-If you intentionally change behavior that affects performance, you may need to
-update the baselines. Set the `UPDATE_PERF_BASELINES` environment variable to
-`true`:
-
-```bash
-UPDATE_PERF_BASELINES=true npm run test:perf
-```
-
-This will run the tests multiple times (with warmup), apply IQR outlier
-filtering, and overwrite `perf-tests/baselines.json`. You should review the
-changes and commit the updated baseline file.
-
-### How it works
-
-The harness (`PerfTestHarness` in `packages/test-utils`):
-
-- Measures wall-clock time using `performance.now()`.
-- Measures CPU usage using `process.cpuUsage()`.
-- Monitors event loop delay using `perf_hooks.monitorEventLoopDelay()`.
-- Applies IQR (Interquartile Range) filtering to remove outlier samples.
-- Compares against baselines with a 15% tolerance.
-
 ## Diagnostics
 
 The integration test runner provides several options for diagnostics to help

docs/reference/configuration.md

@@ -346,7 +346,7 @@ their corresponding top-level category object in your `settings.json` file.
 
 - **`ui.terminalBuffer`** (boolean):
   - **Description:** Use the new terminal buffer architecture for rendering.
-  - **Default:** `false`
+  - **Default:** `true`
   - **Requires restart:** Yes
 
 - **`ui.useBackgroundColor`** (boolean):
@@ -1578,10 +1578,7 @@ their corresponding top-level category object in your `settings.json` file.
 #### `advanced`
 
 - **`advanced.autoConfigureMemory`** (boolean):
-  - **Description:** Automatically configure Node.js memory limits. Note:
-    Because memory is allocated during the initial process boot, this setting is
-    only read from the global user settings file and ignores workspace-level
-    overrides.
+  - **Description:** Automatically configure Node.js memory limits
   - **Default:** `true`
   - **Requires restart:** Yes
 
@@ -1609,12 +1606,6 @@ their corresponding top-level category object in your `settings.json` file.
   - **Default:** `false`
   - **Requires restart:** Yes
 
-- **`experimental.adk.agentSessionInteractiveEnabled`** (boolean):
-  - **Description:** Enable the agent session implementation for the interactive
-    CLI.
-  - **Default:** `false`
-  - **Requires restart:** Yes
-
 - **`experimental.enableAgents`** (boolean):
   - **Description:** Enable local and remote subagents.
   - **Default:** `true`

docs/reference/keyboard-shortcuts.md

@@ -86,14 +86,13 @@ available combinations.
 
 #### Text Input
 
-| Command                              | Action                                                                    | Keys                                                                                |
-| ------------------------------------ | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
-| `input.submit`                       | Submit the current prompt.                                                | `Enter`                                                                             |
-| `input.queueMessage`                 | Queue the current prompt to be processed after the current task finishes. | `Tab`                                                                               |
-| `input.newline`                      | Insert a newline without submitting.                                      | `Ctrl+Enter`<br />`Cmd/Win+Enter`<br />`Alt+Enter`<br />`Shift+Enter`<br />`Ctrl+J` |
-| `input.openExternalEditor`           | Open the current prompt or the plan in an external editor.                | `Ctrl+G`<br />`Ctrl+Shift+G`                                                        |
-| `input.deprecatedOpenExternalEditor` | Deprecated command to open external editor.                               | `Ctrl+X`                                                                            |
-| `input.paste`                        | Paste from the clipboard.                                                 | `Ctrl+V`<br />`Cmd/Win+V`<br />`Alt+V`                                              |
+| Command                    | Action                                                                    | Keys                                                                                |
+| -------------------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| `input.submit`             | Submit the current prompt.                                                | `Enter`                                                                             |
+| `input.queueMessage`       | Queue the current prompt to be processed after the current task finishes. | `Tab`                                                                               |
+| `input.newline`            | Insert a newline without submitting.                                      | `Ctrl+Enter`<br />`Cmd/Win+Enter`<br />`Alt+Enter`<br />`Shift+Enter`<br />`Ctrl+J` |
+| `input.openExternalEditor` | Open the current prompt or the plan in an external editor.                | `Ctrl+X`                                                                            |
+| `input.paste`              | Paste from the clipboard.                                                 | `Ctrl+V`<br />`Cmd/Win+V`<br />`Alt+V`                                              |
 
 #### App Controls
 
@@ -101,7 +100,7 @@ available combinations.
 | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
 | `app.showErrorDetails`        | Toggle detailed error information.                                                                                                                 | `F12`              |
 | `app.showFullTodos`           | Toggle the full TODO list.                                                                                                                         | `Ctrl+T`           |
-| `app.showIdeContextDetail`    | Show IDE context details.                                                                                                                          | `F4`               |
+| `app.showIdeContextDetail`    | Show IDE context details.                                                                                                                          | `Ctrl+G`           |
 | `app.toggleMarkdown`          | Toggle Markdown rendering.                                                                                                                         | `Alt+M`            |
 | `app.toggleCopyMode`          | Toggle copy mode when in alternate buffer mode.                                                                                                    | `F9`               |
 | `app.toggleMouseMode`         | Toggle mouse mode (scrolling and clicking).                                                                                                        | `Ctrl+S`           |

docs/tools/mcp-server.md

@@ -290,7 +290,7 @@ When connecting to an OAuth-enabled server:
 > OAuth authentication requires that your local machine can:
 >
 > - Open a web browser for authentication
-> - Receive redirects on `http://localhost:<random-port>/oauth/callback` (or a specific port if configured via `redirectUri`)
+> - Receive redirects on `http://localhost:7777/oauth/callback`
 
 This feature will not work in:
 
@@ -323,8 +323,8 @@ Use the `/mcp auth` command to manage OAuth authentication:
   if omitted)
 - **`tokenUrl`** (string): OAuth token endpoint (auto-discovered if omitted)
 - **`scopes`** (string[]): Required OAuth scopes
-- **`redirectUri`** (string): Custom redirect URI (defaults to an OS-assigned
-  random port, e.g., `http://localhost:<random-port>/oauth/callback`)
+- **`redirectUri`** (string): Custom redirect URI (defaults to
+  `http://localhost:7777/oauth/callback`)
 - **`tokenParamName`** (string): Query parameter name for tokens in SSE URLs
 - **`audiences`** (string[]): Audiences the token is valid for
 

evals/answer-vs-act.eval.ts

@@ -19,8 +19,6 @@ describe('Answer vs. ask eval', () => {
    * automatically modify the file, but instead asks for permission.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not edit files when asked to inspect for bugs',
     prompt: 'Inspect app.ts for bugs',
     files: FILES,
@@ -44,8 +42,6 @@ describe('Answer vs. ask eval', () => {
    * does modify the file.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should edit files when asked to fix bug',
     prompt: 'Fix the bug in app.ts - it should add numbers not subtract',
     files: FILES,
@@ -70,8 +66,6 @@ describe('Answer vs. ask eval', () => {
    * automatically modify the file, but instead asks for permission.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not edit when asking "any bugs"',
     prompt: 'Any bugs in app.ts?',
     files: FILES,
@@ -95,8 +89,6 @@ describe('Answer vs. ask eval', () => {
    * automatically modify the file.
    */
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not edit files when asked a general question',
     prompt: 'How does app.ts work?',
     files: FILES,
@@ -120,8 +112,6 @@ describe('Answer vs. ask eval', () => {
    * automatically modify the file.
    */
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not edit files when asked about style',
     prompt: 'Is app.ts following good style?',
     files: FILES,
@@ -145,8 +135,6 @@ describe('Answer vs. ask eval', () => {
    * the agent does NOT automatically modify the file.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not edit files when user notes an issue',
     prompt: 'The add function subtracts numbers.',
     files: FILES,

evals/app-test-helper.ts

@@ -10,13 +10,10 @@ import {
   runEval,
   prepareLogDir,
   symlinkNodeModules,
-  withEvalRetries,
-  prepareWorkspace,
-  type BaseEvalCase,
-  EVAL_MODEL,
 } from './test-helper.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_GEMINI_MODEL } from '@google/gemini-cli-core';
 
 /**
  * Config overrides for evals, with tool-restriction fields explicitly
@@ -32,13 +29,15 @@ interface EvalConfigOverrides {
   allowedTools?: never;
   /** Restricting tools via mainAgentTools in evals is forbidden. */
   mainAgentTools?: never;
-
   [key: string]: unknown;
 }
 
-export interface AppEvalCase extends BaseEvalCase {
+export interface AppEvalCase {
+  name: string;
   configOverrides?: EvalConfigOverrides;
   prompt: string;
+  timeout?: number;
+  files?: Record<string, string>;
   setup?: (rig: AppRig) => Promise<void>;
   assert: (rig: AppRig, output: string) => Promise<void>;
 }
@@ -49,55 +48,56 @@ export interface AppEvalCase extends BaseEvalCase {
  */
 export function appEvalTest(policy: EvalPolicy, evalCase: AppEvalCase) {
   const fn = async () => {
-    await withEvalRetries(evalCase.name, async () => {
-      const rig = new AppRig({
-        configOverrides: {
-          model: EVAL_MODEL,
-          ...evalCase.configOverrides,
-        },
-      });
-
-      const { logDir, sanitizedName } = await prepareLogDir(evalCase.name);
-      const logFile = path.join(logDir, `${sanitizedName}.log`);
-
-      try {
-        await rig.initialize();
-
-        const testDir = rig.getTestDir();
-        symlinkNodeModules(testDir);
-
-        // Setup initial files
-        if (evalCase.files) {
-          // Note: AppRig does not use a separate homeDir, so we use testDir twice
-          await prepareWorkspace(testDir, testDir, evalCase.files);
-        }
-
-        // Run custom setup if provided (e.g. for breakpoints)
-        if (evalCase.setup) {
-          await evalCase.setup(rig);
-        }
-
-        // Render the app!
-        await rig.render();
-
-        // Wait for initial ready state
-        await rig.waitForIdle();
-
-        // Send the initial prompt
-        await rig.sendMessage(evalCase.prompt);
-
-        // Run assertion. Interaction-heavy tests can do their own waiting/steering here.
-        const output = rig.getStaticOutput();
-        await evalCase.assert(rig, output);
-      } finally {
-        const output = rig.getStaticOutput();
-        if (output) {
-          await fs.promises.writeFile(logFile, output);
-        }
-        await rig.unmount();
-      }
+    const rig = new AppRig({
+      configOverrides: {
+        model: DEFAULT_GEMINI_MODEL,
+        ...evalCase.configOverrides,
+      },
     });
+
+    const { logDir, sanitizedName } = await prepareLogDir(evalCase.name);
+    const logFile = path.join(logDir, `${sanitizedName}.log`);
+
+    try {
+      await rig.initialize();
+
+      const testDir = rig.getTestDir();
+      symlinkNodeModules(testDir);
+
+      // Setup initial files
+      if (evalCase.files) {
+        for (const [filePath, content] of Object.entries(evalCase.files)) {
+          const fullPath = path.join(testDir, filePath);
+          fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+          fs.writeFileSync(fullPath, content);
+        }
+      }
+
+      // Run custom setup if provided (e.g. for breakpoints)
+      if (evalCase.setup) {
+        await evalCase.setup(rig);
+      }
+
+      // Render the app!
+      await rig.render();
+
+      // Wait for initial ready state
+      await rig.waitForIdle();
+
+      // Send the initial prompt
+      await rig.sendMessage(evalCase.prompt);
+
+      // Run assertion. Interaction-heavy tests can do their own waiting/steering here.
+      const output = rig.getStaticOutput();
+      await evalCase.assert(rig, output);
+    } finally {
+      const output = rig.getStaticOutput();
+      if (output) {
+        await fs.promises.writeFile(logFile, output);
+      }
+      await rig.unmount();
+    }
   };
 
-  runEval(policy, evalCase, fn, (evalCase.timeout ?? 60000) + 10000);
+  runEval(policy, evalCase.name, fn, (evalCase.timeout ?? 60000) + 10000);
 }

evals/ask_user.eval.ts

@@ -5,21 +5,17 @@
  */
 
 import { describe, expect } from 'vitest';
-import { ApprovalMode, isRecord } from '@google/gemini-cli-core';
-import { appEvalTest, type AppEvalCase } from './app-test-helper.js';
-import { type EvalPolicy } from './test-helper.js';
+import { appEvalTest, AppEvalCase } from './app-test-helper.js';
+import { EvalPolicy } from './test-helper.js';
 
 function askUserEvalTest(policy: EvalPolicy, evalCase: AppEvalCase) {
-  const existingGeneral = evalCase.configOverrides?.['general'];
-  const generalBase = isRecord(existingGeneral) ? existingGeneral : {};
-
   return appEvalTest(policy, {
     ...evalCase,
     configOverrides: {
       ...evalCase.configOverrides,
-      approvalMode: ApprovalMode.DEFAULT,
       general: {
-        ...generalBase,
+        ...evalCase.configOverrides?.general,
+        approvalMode: 'default',
         enableAutoUpdate: false,
         enableAutoUpdateNotification: false,
       },
@@ -32,8 +28,6 @@ function askUserEvalTest(policy: EvalPolicy, evalCase: AppEvalCase) {
 
 describe('ask_user', () => {
   askUserEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Agent uses AskUser tool to present multiple choice options',
     prompt: `Use the ask_user tool to ask me what my favorite color is. Provide 3 options: red, green, or blue.`,
     setup: async (rig) => {
@@ -49,8 +43,6 @@ describe('ask_user', () => {
   });
 
   askUserEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Agent uses AskUser tool to clarify ambiguous requirements',
     files: {
       'package.json': JSON.stringify({ name: 'my-app', version: '1.0.0' }),
@@ -69,8 +61,6 @@ describe('ask_user', () => {
   });
 
   askUserEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Agent uses AskUser tool before performing significant ambiguous rework',
     files: {
       'packages/core/src/index.ts': '// index\nexport const version = "1.0.0";',
@@ -92,8 +82,8 @@ describe('ask_user', () => {
       ]);
       expect(confirmation, 'Expected a tool call confirmation').toBeDefined();
 
-      if (confirmation?.toolName === 'enter_plan_mode') {
-        await rig.resolveTool('enter_plan_mode');
+      if (confirmation?.name === 'enter_plan_mode') {
+        rig.acceptConfirmation('enter_plan_mode');
         confirmation = await rig.waitForPendingConfirmation('ask_user');
       }
 
@@ -111,8 +101,6 @@ describe('ask_user', () => {
   // updates to clarify that shell command confirmation is handled by the UI.
   // See fix: https://github.com/google-gemini/gemini-cli/pull/20504
   askUserEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Agent does NOT use AskUser to confirm shell commands',
     files: {
       'package.json': JSON.stringify({

evals/automated-tool-use.eval.ts

@@ -14,8 +14,6 @@ describe('Automated tool use', () => {
    * a repro by guiding the agent into using the existing deficient script.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use automated tools (eslint --fix) to fix code style issues',
     files: {
       'package.json': JSON.stringify(
@@ -104,8 +102,6 @@ describe('Automated tool use', () => {
    * instead of trying to edit the files itself.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use automated tools (prettier --write) to fix formatting issues',
     files: {
       'package.json': JSON.stringify(

evals/cli_help_delegation.eval.ts

@@ -3,8 +3,6 @@ import { evalTest } from './test-helper.js';
 
 describe('CliHelpAgent Delegation', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should delegate to cli_help agent for subagent creation questions',
     params: {
       settings: {

evals/component-test-helper.ts

@@ -1,136 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  type EvalPolicy,
-  runEval,
-  prepareLogDir,
-  withEvalRetries,
-  prepareWorkspace,
-  type BaseEvalCase,
-} from './test-helper.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import {
-  Config,
-  type ConfigParameters,
-  AuthType,
-  ApprovalMode,
-  createPolicyEngineConfig,
-  ExtensionLoader,
-  IntegrityDataStatus,
-  makeFakeConfig,
-  type GeminiCLIExtension,
-} from '@google/gemini-cli-core';
-import { createMockSettings } from '../packages/cli/src/test-utils/settings.js';
-
-// A minimal mock ExtensionManager to bypass integrity checks
-class MockExtensionManager extends ExtensionLoader {
-  override getExtensions(): GeminiCLIExtension[] {
-    return [];
-  }
-  setRequestConsent = (): void => {};
-  setRequestSetting = (): void => {};
-  integrityManager = {
-    verifyExtensionIntegrity: async (): Promise<IntegrityDataStatus> =>
-      IntegrityDataStatus.VERIFIED,
-    storeExtensionIntegrity: async (): Promise<void> => undefined,
-  };
-}
-
-export interface ComponentEvalCase extends BaseEvalCase {
-  configOverrides?: Partial<ConfigParameters>;
-  setup?: (config: Config) => Promise<void>;
-  assert: (config: Config) => Promise<void>;
-}
-
-export class ComponentRig {
-  public config: Config | undefined;
-  public testDir: string;
-  public sessionId: string;
-
-  constructor(
-    private options: { configOverrides?: Partial<ConfigParameters> } = {},
-  ) {
-    const uniqueId = randomUUID();
-    this.testDir = fs.mkdtempSync(
-      path.join(os.tmpdir(), `gemini-component-rig-${uniqueId.slice(0, 8)}-`),
-    );
-    this.sessionId = `test-session-${uniqueId}`;
-  }
-
-  async initialize() {
-    const settings = createMockSettings();
-    const policyEngineConfig = await createPolicyEngineConfig(
-      settings.merged,
-      ApprovalMode.DEFAULT,
-    );
-
-    const configParams: ConfigParameters = {
-      sessionId: this.sessionId,
-      targetDir: this.testDir,
-      cwd: this.testDir,
-      debugMode: false,
-      model: 'test-model',
-      interactive: false,
-      approvalMode: ApprovalMode.DEFAULT,
-      policyEngineConfig,
-      enableEventDrivenScheduler: false, // Don't need scheduler for direct component tests
-      extensionLoader: new MockExtensionManager(),
-      useAlternateBuffer: false,
-      ...this.options.configOverrides,
-    };
-
-    this.config = makeFakeConfig(configParams);
-    await this.config.initialize();
-
-    // Refresh auth using USE_GEMINI to initialize the real BaseLlmClient
-    await this.config.refreshAuth(AuthType.USE_GEMINI);
-  }
-
-  async cleanup() {
-    fs.rmSync(this.testDir, { recursive: true, force: true });
-  }
-}
-
-/**
- * A helper for running behavioral evaluations directly against backend components.
- * It provides a fully initialized Config with real API access, bypassing the UI.
- */
-export function componentEvalTest(
-  policy: EvalPolicy,
-  evalCase: ComponentEvalCase,
-) {
-  const fn = async () => {
-    await withEvalRetries(evalCase.name, async () => {
-      const rig = new ComponentRig({
-        configOverrides: evalCase.configOverrides,
-      });
-
-      await prepareLogDir(evalCase.name);
-
-      try {
-        await rig.initialize();
-
-        if (evalCase.files) {
-          await prepareWorkspace(rig.testDir, rig.testDir, evalCase.files);
-        }
-
-        if (evalCase.setup) {
-          await evalCase.setup(rig.config!);
-        }
-
-        await evalCase.assert(rig.config!);
-      } finally {
-        await rig.cleanup();
-      }
-    });
-  };
-
-  runEval(policy, evalCase, fn, (evalCase.timeout ?? 60000) + 10000);
-}

evals/concurrency-safety.eval.ts

@@ -20,8 +20,6 @@ You are the mutation agent. Do the mutation requested.
 
 describe('concurrency safety eval test cases', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'mutation agents are run in parallel when explicitly requested',
     params: {
       settings: {

evals/edit-locations-eval.eval.ts

@@ -13,8 +13,6 @@ describe('Edits location eval', () => {
    * instead of creating a new one.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should update existing test file instead of creating a new one',
     files: {
       'package.json': JSON.stringify(

evals/frugalReads.eval.ts

@@ -15,8 +15,6 @@ describe('Frugal reads eval', () => {
    * nearby ranges into a single contiguous read to save tool calls.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use ranged read when nearby lines are targeted',
     files: {
       'package.json': JSON.stringify({
@@ -137,8 +135,6 @@ describe('Frugal reads eval', () => {
    * apart to avoid the need to read the whole file.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use ranged read when targets are far apart',
     files: {
       'package.json': JSON.stringify({
@@ -208,8 +204,6 @@ describe('Frugal reads eval', () => {
    * (e.g.: 10), as it's more efficient than many small ranged reads.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should read the entire file when there are many matches',
     files: {
       'package.json': JSON.stringify({

evals/frugalSearch.eval.ts

@@ -13,6 +13,18 @@ import { evalTest } from './test-helper.js';
  * This ensures the agent doesn't flood the context window with unnecessary search results.
  */
 describe('Frugal Search', () => {
+  const getGrepParams = (call: any): any => {
+    let args = call.toolRequest.args;
+    if (typeof args === 'string') {
+      try {
+        args = JSON.parse(args);
+      } catch (e) {
+        // Ignore parse errors
+      }
+    }
+    return args;
+  };
+
   /**
    * Ensure that the agent makes use of either grep or ranged reads in fulfilling this task.
    * The task is specifically phrased to not evoke "view" or "search" specifically because
@@ -21,8 +33,6 @@ describe('Frugal Search', () => {
    * ranged reads.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use grep or ranged read for large files',
     prompt: 'What year was legacy_processor.ts written?',
     files: {

evals/generalist_agent.eval.ts

@@ -11,8 +11,6 @@ import fs from 'node:fs/promises';
 
 describe('generalist_agent', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should be able to use generalist agent by explicitly asking the main agent to invoke it',
     params: {
       settings: {

evals/generalist_delegation.eval.ts

@@ -11,8 +11,6 @@ describe('generalist_delegation', () => {
   // --- Positive Evals (Should Delegate) ---
 
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should delegate batch error fixing to generalist agent',
     configOverrides: {
       agents: {
@@ -56,8 +54,6 @@ describe('generalist_delegation', () => {
   });
 
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should autonomously delegate complex batch task to generalist agent',
     configOverrides: {
       agents: {
@@ -98,8 +94,6 @@ describe('generalist_delegation', () => {
   // --- Negative Evals (Should NOT Delegate - Assertive Handling) ---
 
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should NOT delegate simple read and fix to generalist agent',
     configOverrides: {
       agents: {
@@ -134,8 +128,6 @@ describe('generalist_delegation', () => {
   });
 
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should NOT delegate simple direct question to generalist agent',
     configOverrides: {
       agents: {

evals/gitRepo.eval.ts

@@ -26,8 +26,6 @@ describe('git repo eval', () => {
    * be more consistent.
    */
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not git add commit changes unprompted',
     prompt:
       'Finish this up for me by just making a targeted fix for the bug in index.ts. Do not build, install anything, or add tests',
@@ -57,8 +55,6 @@ describe('git repo eval', () => {
    * instructed to not do so by default.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should git commit changes when prompted',
     prompt:
       'Make a targeted fix for the bug in index.ts without building, installing anything, or adding tests. Then, commit your changes.',

evals/grep_search_functionality.eval.ts

@@ -15,8 +15,6 @@ describe('grep_search_functionality', () => {
   const TEST_PREFIX = 'Grep Search Functionality: ';
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should find a simple string in a file',
     files: {
       'test.txt': `hello
@@ -35,8 +33,6 @@ describe('grep_search_functionality', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should perform a case-sensitive search',
     files: {
       'test.txt': `Hello
@@ -67,8 +63,6 @@ describe('grep_search_functionality', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should return only file names when names_only is used',
     files: {
       'file1.txt': 'match me',
@@ -99,8 +93,6 @@ describe('grep_search_functionality', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should search only within the specified include_pattern glob',
     files: {
       'file.js': 'my_function();',
@@ -131,8 +123,6 @@ describe('grep_search_functionality', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should search within a specific subdirectory',
     files: {
       'src/main.js': 'unique_string_1',
@@ -163,8 +153,6 @@ describe('grep_search_functionality', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should report no matches correctly',
     files: {
       'file.txt': 'nothing to see here',

evals/hierarchical_memory.eval.ts

@@ -5,14 +5,13 @@
  */
 
 import { describe, expect } from 'vitest';
-import { evalTest, assertModelHasOutput } from './test-helper.js';
+import { evalTest } from './test-helper.js';
+import { assertModelHasOutput } from '../integration-tests/test-helper.js';
 
 describe('Hierarchical Memory', () => {
   const conflictResolutionTest =
     'Agent follows hierarchy for contradictory instructions';
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: conflictResolutionTest,
     params: {
       settings: {
@@ -49,8 +48,6 @@ What is my favorite fruit? Tell me just the name of the fruit.`,
 
   const provenanceAwarenessTest = 'Agent is aware of memory provenance';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: provenanceAwarenessTest,
     params: {
       settings: {
@@ -90,8 +87,6 @@ Provide the answer as an XML block like this:
 
   const extensionVsGlobalTest = 'Extension memory wins over Global memory';
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: extensionVsGlobalTest,
     params: {
       settings: {

evals/interactive-hang.eval.ts

@@ -8,8 +8,6 @@ describe('interactive_commands', () => {
    * intervention.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not use interactive commands',
     prompt: 'Execute tests.',
     files: {
@@ -51,8 +49,6 @@ describe('interactive_commands', () => {
    * Validates that the agent uses non-interactive flags when scaffolding a new project.
    */
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use non-interactive flags when scaffolding a new app',
     prompt: 'Create a new react application named my-app using vite.',
     assert: async (rig, result) => {

evals/model_steering.eval.ts

@@ -5,14 +5,14 @@
  */
 
 import { describe, expect } from 'vitest';
+import { act } from 'react';
 import path from 'node:path';
 import fs from 'node:fs';
 import { appEvalTest } from './app-test-helper.js';
+import { PolicyDecision } from '@google/gemini-cli-core';
 
 describe('Model Steering Behavioral Evals', () => {
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Corrective Hint: Model switches task based on hint during tool turn',
     configOverrides: {
       modelSteering: true,
@@ -52,8 +52,6 @@ describe('Model Steering Behavioral Evals', () => {
   });
 
   appEvalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'Suggestive Hint: Model incorporates user guidance mid-stream',
     configOverrides: {
       modelSteering: true,

evals/plan_mode.eval.ts

@@ -33,8 +33,6 @@ describe('plan_mode', () => {
       .filter(Boolean);
 
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should refuse file modification when in plan mode',
     approvalMode: ApprovalMode.PLAN,
     params: {
@@ -70,8 +68,6 @@ describe('plan_mode', () => {
   });
 
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should refuse saving new documentation to the repo when in plan mode',
     approvalMode: ApprovalMode.PLAN,
     params: {
@@ -109,8 +105,6 @@ describe('plan_mode', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should enter plan mode when asked to create a plan',
     approvalMode: ApprovalMode.DEFAULT,
     params: {
@@ -128,8 +122,6 @@ describe('plan_mode', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should exit plan mode when plan is complete and implementation is requested',
     approvalMode: ApprovalMode.PLAN,
     params: {
@@ -177,8 +169,6 @@ describe('plan_mode', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should allow file modification in plans directory when in plan mode',
     approvalMode: ApprovalMode.PLAN,
     params: {
@@ -211,8 +201,6 @@ describe('plan_mode', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should create a plan in plan mode and implement it for a refactoring task',
     params: {
       settings,

evals/redundant_casts.eval.ts

@@ -11,8 +11,6 @@ import fs from 'node:fs/promises';
 
 describe('redundant_casts', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should not add redundant or unsafe casts when modifying typescript code',
     files: {
       'src/cast_example.ts': `

evals/sandbox_recovery.eval.ts

@@ -3,8 +3,6 @@ import { evalTest } from './test-helper.js';
 
 describe('Sandbox recovery', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'attempts to use additional_permissions when operation not permitted',
     prompt:
       'Run ./script.sh. It will fail with "Operation not permitted". When it does, you must retry running it by passing the appropriate additional_permissions.',

evals/save_memory.eval.ts

@@ -5,18 +5,16 @@
  */
 
 import { describe, expect } from 'vitest';
+import { evalTest } from './test-helper.js';
 import {
-  evalTest,
   assertModelHasOutput,
   checkModelOutputContent,
-} from './test-helper.js';
+} from '../integration-tests/test-helper.js';
 
 describe('save_memory', () => {
   const TEST_PREFIX = 'Save memory test: ';
   const rememberingFavoriteColor = "Agent remembers user's favorite color";
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingFavoriteColor,
 
     prompt: `remember that my favorite color is  blue.
@@ -37,8 +35,6 @@ describe('save_memory', () => {
   });
   const rememberingCommandRestrictions = 'Agent remembers command restrictions';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingCommandRestrictions,
 
     prompt: `I don't want you to ever run npm commands.`,
@@ -58,8 +54,6 @@ describe('save_memory', () => {
 
   const rememberingWorkflow = 'Agent remembers workflow preferences';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingWorkflow,
 
     prompt: `I want you to always lint after building.`,
@@ -80,8 +74,6 @@ describe('save_memory', () => {
   const ignoringTemporaryInformation =
     'Agent ignores temporary conversation details';
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: ignoringTemporaryInformation,
 
     prompt: `I'm going to get a coffee.`,
@@ -105,8 +97,6 @@ describe('save_memory', () => {
 
   const rememberingPetName = "Agent remembers user's pet's name";
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingPetName,
 
     prompt: `Please remember that my dog's name is Buddy.`,
@@ -126,8 +116,6 @@ describe('save_memory', () => {
 
   const rememberingCommandAlias = 'Agent remembers custom command aliases';
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingCommandAlias,
 
     prompt: `When I say 'start server', you should run 'npm run dev'.`,
@@ -148,8 +136,6 @@ describe('save_memory', () => {
   const ignoringDbSchemaLocation =
     "Agent ignores workspace's database schema location";
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: ignoringDbSchemaLocation,
     prompt: `The database schema for this workspace is located in \`db/schema.sql\`.`,
     assert: async (rig, result) => {
@@ -169,8 +155,6 @@ describe('save_memory', () => {
   const rememberingCodingStyle =
     "Agent remembers user's coding style preference";
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingCodingStyle,
 
     prompt: `I prefer to use tabs instead of spaces for indentation.`,
@@ -191,8 +175,6 @@ describe('save_memory', () => {
   const ignoringBuildArtifactLocation =
     'Agent ignores workspace build artifact location';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: ignoringBuildArtifactLocation,
     prompt: `In this workspace, build artifacts are stored in the \`dist/artifacts\` directory.`,
     assert: async (rig, result) => {
@@ -211,8 +193,6 @@ describe('save_memory', () => {
 
   const ignoringMainEntryPoint = "Agent ignores workspace's main entry point";
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: ignoringMainEntryPoint,
     prompt: `The main entry point for this workspace is \`src/index.js\`.`,
     assert: async (rig, result) => {
@@ -231,8 +211,6 @@ describe('save_memory', () => {
 
   const rememberingBirthday = "Agent remembers user's birthday";
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: rememberingBirthday,
 
     prompt: `My birthday is on June 15th.`,
@@ -253,8 +231,6 @@ describe('save_memory', () => {
   const proactiveMemoryFromLongSession =
     'Agent saves preference from earlier in conversation history';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: proactiveMemoryFromLongSession,
     params: {
       settings: {
@@ -333,8 +309,6 @@ describe('save_memory', () => {
   const memoryManagerRoutingPreferences =
     'Agent routes global and project preferences to memory';
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: memoryManagerRoutingPreferences,
     params: {
       settings: {

evals/shell-efficiency.eval.ts

@@ -21,8 +21,6 @@ describe('Shell Efficiency', () => {
   };
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use --silent/--quiet flags when installing packages',
     prompt: 'Install the "lodash" package using npm.',
     assert: async (rig) => {
@@ -52,8 +50,6 @@ describe('Shell Efficiency', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use --no-pager with git commands',
     prompt: 'Show the git log.',
     assert: async (rig) => {
@@ -77,8 +73,6 @@ describe('Shell Efficiency', () => {
   });
 
   evalTest('ALWAYS_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should NOT use efficiency flags when enableShellOutputEfficiency is disabled',
     params: {
       settings: {

evals/subagents.eval.ts

@@ -45,8 +45,6 @@ describe('subagent eval test cases', () => {
    * This tests the system prompt's subagent specific clauses.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should delegate to user provided agent with relevant expertise',
     params: {
       settings: {
@@ -71,8 +69,6 @@ describe('subagent eval test cases', () => {
    * subagents are available. This helps catch orchestration overuse.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should avoid delegating trivial direct edit work',
     params: {
       settings: {
@@ -117,8 +113,6 @@ describe('subagent eval test cases', () => {
    * This is meant to codify the "overusing Generalist" failure mode.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should prefer relevant specialist over generalist',
     params: {
       settings: {
@@ -155,8 +149,6 @@ describe('subagent eval test cases', () => {
    * naturally spans docs and tests, so multiple specialists should be used.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should use multiple relevant specialists for multi-surface task',
     params: {
       settings: {
@@ -201,8 +193,6 @@ describe('subagent eval test cases', () => {
    * from a large pool of available subagents (10 total).
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should select the correct subagent from a pool of 10 different agents',
     prompt: 'Please add a new SQL table migration for a user profile.',
     files: {
@@ -253,8 +243,6 @@ describe('subagent eval test cases', () => {
    * This test includes stress tests the subagent delegation with ~80 tools.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should select the correct subagent from a pool of 10 different agents with MCP tools present',
     prompt: 'Please add a new SQL table migration for a user profile.',
     setup: async (rig) => {

evals/test-helper.test.ts

@@ -49,8 +49,6 @@ describe('evalTest reliability logic', () => {
 
     // Execute the test function directly
     await internalEvalTest({
-      suiteName: 'test',
-      suiteType: 'behavioral',
       name: 'test-api-failure',
       prompt: 'do something',
       assert: async () => {},
@@ -85,8 +83,6 @@ describe('evalTest reliability logic', () => {
     // Expect the test function to throw immediately
     await expect(
       internalEvalTest({
-        suiteName: 'test',
-        suiteType: 'behavioral',
         name: 'test-logic-failure',
         prompt: 'do something',
         assert: async () => {
@@ -112,8 +108,6 @@ describe('evalTest reliability logic', () => {
       .mockResolvedValueOnce('Success');
 
     await internalEvalTest({
-      suiteName: 'test',
-      suiteType: 'behavioral',
       name: 'test-recovery',
       prompt: 'do something',
       assert: async () => {},
@@ -141,8 +135,6 @@ describe('evalTest reliability logic', () => {
     );
 
     await internalEvalTest({
-      suiteName: 'test',
-      suiteType: 'behavioral',
       name: 'test-api-503',
       prompt: 'do something',
       assert: async () => {},
@@ -170,8 +162,6 @@ describe('evalTest reliability logic', () => {
     try {
       await expect(
         internalEvalTest({
-          suiteName: 'test',
-          suiteType: 'behavioral',
           name: 'test-absolute-path',
           prompt: 'do something',
           files: {
@@ -200,8 +190,6 @@ describe('evalTest reliability logic', () => {
     try {
       await expect(
         internalEvalTest({
-          suiteName: 'test',
-          suiteType: 'behavioral',
           name: 'test-traversal',
           prompt: 'do something',
           files: {

evals/test-helper.ts

@@ -16,19 +16,10 @@ import {
   Storage,
   getProjectHash,
   SESSION_FILE_PREFIX,
-  PREVIEW_GEMINI_FLASH_MODEL,
-  getErrorMessage,
 } from '@google/gemini-cli-core';
 
 export * from '@google/gemini-cli-test-utils';
 
-/**
- * The default model used for all evaluations.
- * Can be overridden by setting the GEMINI_MODEL environment variable.
- */
-export const EVAL_MODEL =
-  process.env['GEMINI_MODEL'] || PREVIEW_GEMINI_FLASH_MODEL;
-
 // Indicates the consistency expectation for this test.
 // - ALWAYS_PASSES - Means that the test is expected to pass 100% of the time. These
 //   These tests are typically trivial and test basic functionality with unambiguous
@@ -48,49 +39,19 @@ export const EVAL_MODEL =
 export type EvalPolicy = 'ALWAYS_PASSES' | 'USUALLY_PASSES';
 
 export function evalTest(policy: EvalPolicy, evalCase: EvalCase) {
-  runEval(policy, evalCase, () => internalEvalTest(evalCase));
+  runEval(
+    policy,
+    evalCase.name,
+    () => internalEvalTest(evalCase),
+    evalCase.timeout,
+  );
 }
 
-export async function withEvalRetries(
-  name: string,
-  attemptFn: (attempt: number) => Promise<void>,
-) {
+export async function internalEvalTest(evalCase: EvalCase) {
   const maxRetries = 3;
   let attempt = 0;
 
   while (attempt <= maxRetries) {
-    try {
-      await attemptFn(attempt);
-      return; // Success! Exit the retry loop.
-    } catch (error: unknown) {
-      const errorMessage = getErrorMessage(error);
-      const errorCode = getApiErrorCode(errorMessage);
-
-      if (errorCode) {
-        const status = attempt < maxRetries ? 'RETRY' : 'SKIP';
-        logReliabilityEvent(name, attempt, status, errorCode, errorMessage);
-
-        if (attempt < maxRetries) {
-          attempt++;
-          console.warn(
-            `[Eval] Attempt ${attempt} failed with ${errorCode} Error. Retrying...`,
-          );
-          continue; // Retry
-        }
-
-        console.warn(
-          `[Eval] '${name}' failed after ${maxRetries} retries due to persistent API errors. Skipping failure to avoid blocking PR.`,
-        );
-        return; // Gracefully exit without failing the test
-      }
-
-      throw error; // Real failure
-    }
-  }
-}
-
-export async function internalEvalTest(evalCase: EvalCase) {
-  await withEvalRetries(evalCase.name, async () => {
     const rig = new TestRig();
     const { logDir, sanitizedName } = await prepareLogDir(evalCase.name);
     const activityLogFile = path.join(logDir, `${sanitizedName}.jsonl`);
@@ -98,21 +59,14 @@ export async function internalEvalTest(evalCase: EvalCase) {
     let isSuccess = false;
 
     try {
-      const setupOptions = {
-        ...evalCase.params,
-        settings: {
-          model: { name: EVAL_MODEL },
-          ...evalCase.params?.settings,
-        },
-      };
-      rig.setup(evalCase.name, setupOptions);
+      rig.setup(evalCase.name, evalCase.params);
 
       if (evalCase.setup) {
         await evalCase.setup(rig);
       }
 
       if (evalCase.files) {
-        await prepareWorkspace(rig.testDir!, rig.homeDir!, evalCase.files);
+        await setupTestFiles(rig, evalCase.files);
       }
 
       symlinkNodeModules(rig.testDir || '');
@@ -185,6 +139,37 @@ export async function internalEvalTest(evalCase: EvalCase) {
 
       await evalCase.assert(rig, result);
       isSuccess = true;
+      return; // Success! Exit the retry loop.
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      const errorCode = getApiErrorCode(errorMessage);
+
+      if (errorCode) {
+        const status = attempt < maxRetries ? 'RETRY' : 'SKIP';
+        logReliabilityEvent(
+          evalCase.name,
+          attempt,
+          status,
+          errorCode,
+          errorMessage,
+        );
+
+        if (attempt < maxRetries) {
+          attempt++;
+          console.warn(
+            `[Eval] Attempt ${attempt} failed with ${errorCode} Error. Retrying...`,
+          );
+          continue; // Retry
+        }
+
+        console.warn(
+          `[Eval] '${evalCase.name}' failed after ${maxRetries} retries due to persistent API errors. Skipping failure to avoid blocking PR.`,
+        );
+        return; // Gracefully exit without failing the test
+      }
+
+      throw error; // Real failure
     } finally {
       if (isSuccess) {
         await fs.promises.unlink(activityLogFile).catch((err) => {
@@ -203,7 +188,7 @@ export async function internalEvalTest(evalCase: EvalCase) {
       );
       await rig.cleanup();
     }
-  });
+  }
 }
 
 function getApiErrorCode(message: string): '500' | '503' | undefined {
@@ -241,7 +226,7 @@ function logReliabilityEvent(
   const reliabilityLog = {
     timestamp: new Date().toISOString(),
     testName,
-    model: process.env['GEMINI_MODEL'] || 'unknown',
+    model: process.env.GEMINI_MODEL || 'unknown',
     attempt,
     status,
     errorCode,
@@ -267,13 +252,9 @@ function logReliabilityEvent(
  * intentionally uses synchronous filesystem and child_process operations
  * for simplicity and to ensure sequential environment preparation.
  */
-export async function prepareWorkspace(
-  testDir: string,
-  homeDir: string,
-  files: Record<string, string>,
-) {
+async function setupTestFiles(rig: TestRig, files: Record<string, string>) {
   const acknowledgedAgents: Record<string, Record<string, string>> = {};
-  const projectRoot = fs.realpathSync(testDir);
+  const projectRoot = fs.realpathSync(rig.testDir!);
 
   for (const [filePath, content] of Object.entries(files)) {
     if (filePath.includes('..') || path.isAbsolute(filePath)) {
@@ -309,7 +290,7 @@ export async function prepareWorkspace(
 
   if (Object.keys(acknowledgedAgents).length > 0) {
     const ackPath = path.join(
-      homeDir,
+      rig.homeDir!,
       '.gemini',
       'acknowledgments',
       'agents.json',
@@ -318,7 +299,7 @@ export async function prepareWorkspace(
     fs.writeFileSync(ackPath, JSON.stringify(acknowledgedAgents, null, 2));
   }
 
-  const execOptions = { cwd: testDir, stdio: 'ignore' as const };
+  const execOptions = { cwd: rig.testDir!, stdio: 'inherit' as const };
   execSync('git init --initial-branch=main', execOptions);
   execSync('git config user.email "test@example.com"', execOptions);
   execSync('git config user.name "Test User"', execOptions);
@@ -339,30 +320,14 @@ export async function prepareWorkspace(
  */
 export function runEval(
   policy: EvalPolicy,
-  evalCase: BaseEvalCase,
+  name: string,
   fn: () => Promise<void>,
-  timeoutOverride?: number,
+  timeout?: number,
 ) {
-  const { name, timeout, suiteName, suiteType } = evalCase;
-  const targetSuiteType = process.env['EVAL_SUITE_TYPE'];
-  const targetSuiteName = process.env['EVAL_SUITE_NAME'];
-
-  const meta = { suiteType, suiteName };
-
-  const skipBySuiteType =
-    targetSuiteType && suiteType && suiteType !== targetSuiteType;
-  const skipBySuiteName =
-    targetSuiteName && suiteName && suiteName !== targetSuiteName;
-
-  const options = { timeout: timeoutOverride ?? timeout, meta };
-  if (
-    (policy === 'USUALLY_PASSES' && !process.env['RUN_EVALS']) ||
-    skipBySuiteType ||
-    skipBySuiteName
-  ) {
-    it.skip(name, options, fn);
+  if (policy === 'USUALLY_PASSES' && !process.env['RUN_EVALS']) {
+    it.skip(name, fn);
   } else {
-    it(name, options, fn);
+    it(name, fn, timeout);
   }
 }
 
@@ -401,20 +366,15 @@ interface ForbiddenToolSettings {
   };
 }
 
-export interface BaseEvalCase {
-  suiteName: string;
-  suiteType: 'behavioral' | 'component-level' | 'hero-scenario';
+export interface EvalCase {
   name: string;
-  timeout?: number;
-  files?: Record<string, string>;
-}
-
-export interface EvalCase extends BaseEvalCase {
   params?: {
     settings?: ForbiddenToolSettings & Record<string, unknown>;
     [key: string]: unknown;
   };
   prompt: string;
+  timeout?: number;
+  files?: Record<string, string>;
   setup?: (rig: TestRig) => Promise<void> | void;
   /** Conversation history to pre-load via --resume. Each entry is a message object with type, content, etc. */
   messages?: Record<string, unknown>[];

evals/tool_output_masking.eval.ts

@@ -31,8 +31,6 @@ describe('Tool Output Masking Behavioral Evals', () => {
    * It should recognize the <tool_output_masked> tag and use a tool to read the file.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should attempt to read the redirected full output file when information is masked',
     params: {
       security: {
@@ -169,8 +167,6 @@ Output too large. Full output available at: ${outputFilePath}
    * Scenario: Information is in the preview.
    */
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should NOT read the full output file when the information is already in the preview',
     params: {
       security: {

evals/tracker.eval.ts

@@ -25,8 +25,6 @@ const FILES = {
 
 describe('tracker_mode', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should manage tasks in the tracker when explicitly requested during a bug fix',
     params: {
       settings: { experimental: { taskTracker: true } },
@@ -80,8 +78,6 @@ describe('tracker_mode', () => {
   });
 
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should implicitly create tasks when asked to build a feature plan',
     params: {
       settings: { experimental: { taskTracker: true } },

evals/unsafe-cloning.eval.ts

@@ -1,64 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { evalTest, TestRig } from './test-helper.js';
-
-evalTest('USUALLY_PASSES', {
-  name: 'Reproduction: Agent uses Object.create() for cloning/delegation',
-  prompt:
-    'Create a utility function `createScopedConfig(config: Config, additionalDirectories: string[]): Config` in `packages/core/src/config/scoped-config.ts` that returns a new Config instance. This instance should override `getWorkspaceContext()` to include the additional directories, but delegate all other method calls (like `isPathAllowed` or `validatePathAccess`) to the original config. Note that `Config` is a complex class with private state and cannot be easily shallow-copied or reconstructed.',
-  files: {
-    'packages/core/src/config/config.ts': `
-export class Config {
-  private _internalState = 'secret';
-  constructor(private workspaceContext: any) {}
-  getWorkspaceContext() { return this.workspaceContext; }
-  isPathAllowed(path: string) {
-    return this.getWorkspaceContext().isPathWithinWorkspace(path);
-  }
-  validatePathAccess(path: string) {
-    if (!this.isPathAllowed(path)) return 'Denied';
-    return null;
-  }
-}`,
-    'packages/core/src/utils/workspaceContext.ts': `
-export class WorkspaceContext {
-  constructor(private root: string, private additional: string[] = []) {}
-  getDirectories() { return [this.root, ...this.additional]; }
-  isPathWithinWorkspace(path: string) {
-    return this.getDirectories().some(d => path.startsWith(d));
-  }
-}`,
-    'package.json': JSON.stringify({
-      name: 'test-project',
-      version: '1.0.0',
-      type: 'module',
-    }),
-  },
-  assert: async (rig: TestRig) => {
-    const filePath = 'packages/core/src/config/scoped-config.ts';
-    const content = rig.readFile(filePath);
-
-    if (!content) {
-      throw new Error(`File ${filePath} was not created.`);
-    }
-
-    // Strip comments to avoid false positives.
-    const codeWithoutComments = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-
-    // Ensure that the agent did not use Object.create() in the implementation.
-    // We check for the call pattern specifically using a regex to avoid false positives in comments.
-    const hasObjectCreate = /\bObject\.create\s*\(/.test(codeWithoutComments);
-    if (hasObjectCreate) {
-      throw new Error(
-        'Evaluation Failed: Agent used Object.create() for cloning. ' +
-          'This behavior is forbidden by the project lint rules (no-restricted-syntax). ' +
-          'Implementation found:\n\n' +
-          content,
-      );
-    }
-  },
-});

evals/update_topic.eval.ts

@@ -215,47 +215,4 @@ export default app;
       expect(fs.existsSync(path.join(rig.testDir, 'src/routes.ts'))).toBe(true);
     },
   });
-
-  /**
-   * Regression test for a bug where update_topic was called multiple times in a
-   * row. We have seen cases of this occurring in earlier versions of the update_topic
-   * system instruction, prior to https://github.com/google-gemini/gemini-cli/pull/24640.
-   * This test demonstrated that there are cases where it can still occur and validates
-   * the prompt change that improves the behavior.
-   */
-  evalTest('USUALLY_PASSES', {
-    name: 'update_topic should not be called twice in a row',
-    prompt: `
-      We need to build a C compiler.
-
-      Before you write any code, you must formally declare your strategy.
-      First, declare that you will build a Lexer.
-      Then, immediately realize that is wrong and declare that you will actually build a Parser instead.
-
-      Finally, create 'parser.c'.
-    `,
-    files: {
-      'package.json': JSON.stringify({ name: 'test-project' }),
-      '.gemini/settings.json': JSON.stringify({
-        experimental: {
-          topicUpdateNarration: true,
-        },
-      }),
-    },
-    assert: async (rig) => {
-      const toolLogs = rig.readToolLogs();
-
-      // Check for back-to-back update_topic calls
-      for (let i = 1; i < toolLogs.length; i++) {
-        if (
-          toolLogs[i - 1].toolRequest.name === UPDATE_TOPIC_TOOL_NAME &&
-          toolLogs[i].toolRequest.name === UPDATE_TOPIC_TOOL_NAME
-        ) {
-          throw new Error(
-            `Detected back-to-back ${UPDATE_TOPIC_TOOL_NAME} calls at index ${i - 1} and ${i}`,
-          );
-        }
-      }
-    },
-  });
 });

evals/validation_fidelity.eval.ts

@@ -9,8 +9,6 @@ import { evalTest } from './test-helper.js';
 
 describe('validation_fidelity', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should perform exhaustive validation autonomously when guided by system instructions',
     files: {
       'src/types.ts': `

evals/validation_fidelity_pre_existing_errors.eval.ts

@@ -9,8 +9,6 @@ import { evalTest } from './test-helper.js';
 
 describe('validation_fidelity_pre_existing_errors', () => {
   evalTest('USUALLY_PASSES', {
-    suiteName: 'default',
-    suiteType: 'behavioral',
     name: 'should handle pre-existing project errors gracefully during validation',
     files: {
       'src/math.ts': `

evals/vitest.config.ts

@@ -24,10 +24,7 @@ export default defineConfig({
     environment: 'node',
     globals: true,
     alias: {
-      '@google/gemini-cli-core': path.resolve(
-        __dirname,
-        '../packages/core/index.ts',
-      ),
+      react: path.resolve(__dirname, '../node_modules/react'),
     },
     setupFiles: [path.resolve(__dirname, '../packages/cli/test-setup.ts')],
     server: {

integration-tests/browser-agent.concurrent.responses

@@ -1,8 +0,0 @@
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I'll launch two browser agents concurrently to check both repositories."},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and get the page title"}}},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and get the page title"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":50,"totalTokenCount":150}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":20,"totalTokenCount":120}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":20,"totalTokenCount":120}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":15,"totalTokenCount":165}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":15,"totalTokenCount":165}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is Example Domain."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":30,"totalTokenCount":230}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is Example Domain."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":30,"totalTokenCount":230}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Both browser agents completed successfully. Agent 1 and Agent 2 both navigated to their respective pages and confirmed the page titles."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":300,"candidatesTokenCount":40,"totalTokenCount":340}}]}

integration-tests/browser-agent.persistent-session.responses

@@ -1,8 +0,0 @@
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I'll browse to example.com twice to verify the content. Let me first check the page title, then check the links on the page."},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and tell me the page title using the accessibility tree"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":50,"totalTokenCount":150}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":30,"totalTokenCount":130}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":20,"totalTokenCount":170}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is 'Example Domain'."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":40,"totalTokenCount":240}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"The page title is 'Example Domain'. Now let me check the links on the page."},{"functionCall":{"name":"browser_agent","args":{"task":"Take a snapshot of the accessibility tree on the currently open page and tell me about any links"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":50,"totalTokenCount":250}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":20,"totalTokenCount":170}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Found a link 'More information...' pointing to iana.org."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":40,"totalTokenCount":240}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I browsed example.com twice using persistent browser sessions:\n\n1. **First visit**: Page title is 'Example Domain'\n2. **Second visit**: Found a link 'More information...' pointing to iana.org\n\nThe browser stayed open between both visits, confirming persistent session management works correctly."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":300,"candidatesTokenCount":60,"totalTokenCount":360}}]}

integration-tests/browser-agent.test.ts

@@ -229,51 +229,6 @@ describe.skipIf(!chromeAvailable)('browser-agent', () => {
     assertModelHasOutput(result);
   });
 
-  it('should keep browser open across multiple browser_agent invocations', async () => {
-    rig.setup('browser-persistent-session', {
-      fakeResponsesPath: join(
-        __dirname,
-        'browser-agent.persistent-session.responses',
-      ),
-      settings: {
-        agents: {
-          overrides: {
-            browser_agent: {
-              enabled: true,
-            },
-          },
-          browser: {
-            headless: true,
-            sessionMode: 'isolated',
-          },
-        },
-      },
-    });
-
-    const result = await rig.run({
-      args: 'Browse to example.com twice: first get the page title, then check for links.',
-    });
-
-    const toolLogs = rig.readToolLogs();
-    const browserCalls = toolLogs.filter(
-      (t) => t.toolRequest.name === 'browser_agent',
-    );
-
-    // Both browser_agent invocations must succeed — if the browser was
-    // incorrectly closed after the first call (regression #24210),
-    // the second call would fail.
-    expect(
-      browserCalls.length,
-      'Expected browser_agent to be called twice',
-    ).toBe(2);
-    expect(
-      browserCalls.every((c) => c.toolRequest.success),
-      'Both browser_agent calls should succeed',
-    ).toBe(true);
-
-    assertModelHasOutput(result);
-  });
-
   it('should handle tool confirmation for write_file without crashing', async () => {
     rig.setup('tool-confirmation', {
       fakeResponsesPath: join(
@@ -307,48 +262,4 @@ describe.skipIf(!chromeAvailable)('browser-agent', () => {
 
     await run.expectText('successfully written', 15000);
   });
-
-  it('should handle concurrent browser agents with isolated session mode', async () => {
-    rig.setup('browser-concurrent', {
-      fakeResponsesPath: join(__dirname, 'browser-agent.concurrent.responses'),
-      settings: {
-        agents: {
-          overrides: {
-            browser_agent: {
-              enabled: true,
-            },
-          },
-          browser: {
-            headless: true,
-            // Isolated mode supports concurrent browser agents.
-            // Persistent/existing modes reject concurrent calls to prevent
-            // Chrome profile lock conflicts.
-            sessionMode: 'isolated',
-          },
-        },
-      },
-    });
-
-    const result = await rig.run({
-      args: 'Launch two browser agents concurrently to check example.com',
-    });
-
-    assertModelHasOutput(result);
-
-    const toolLogs = rig.readToolLogs();
-    const browserCalls = toolLogs.filter(
-      (t) => t.toolRequest.name === 'browser_agent',
-    );
-
-    // Both browser_agent invocations should have been called
-    expect(browserCalls.length).toBe(2);
-
-    // Both should complete successfully (no errors)
-    for (const call of browserCalls) {
-      expect(
-        call.toolRequest.success,
-        `browser_agent call failed: ${JSON.stringify(call.toolRequest)}`,
-      ).toBe(true);
-    }
-  });
 });

integration-tests/globalSetup.ts

@@ -14,7 +14,6 @@ import { join, dirname, extname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { canUseRipgrep } from '../packages/core/src/tools/ripGrep.js';
 import { disableMouseTracking } from '@google/gemini-cli-core';
-import { isolateTestEnv } from '../packages/test-utils/src/env-setup.js';
 import { createServer, type Server } from 'node:http';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -89,8 +88,15 @@ export async function setup() {
   runDir = join(integrationTestsDir, `${Date.now()}`);
   await mkdir(runDir, { recursive: true });
 
-  // Isolate environment variables
-  isolateTestEnv(runDir);
+  // Set the home directory to the test run directory to avoid conflicts
+  // with the user's local config.
+  process.env['HOME'] = runDir;
+  if (process.platform === 'win32') {
+    process.env['USERPROFILE'] = runDir;
+  }
+  // We also need to set the config dir explicitly, since the code might
+  // construct the path before the HOME env var is set.
+  process.env['GEMINI_CONFIG_DIR'] = join(runDir, '.gemini');
 
   // Download ripgrep to avoid race conditions in parallel tests
   const available = await canUseRipgrep();
@@ -121,6 +127,10 @@ export async function setup() {
   }
 
   process.env['INTEGRATION_TEST_FILE_DIR'] = runDir;
+  process.env['GEMINI_CLI_INTEGRATION_TEST'] = 'true';
+  // Force file storage to avoid keychain prompts/hangs in CI, especially on macOS
+  process.env['GEMINI_FORCE_FILE_STORAGE'] = 'true';
+  process.env['TELEMETRY_LOG_FILE'] = join(runDir, 'telemetry.log');
 
   if (process.env['KEEP_OUTPUT']) {
     console.log(`Keeping output for test run in: ${runDir}`);

integration-tests/utf-bom-encoding.test.ts

@@ -5,8 +5,8 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { writeFileSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { TestRig } from './test-helper.js';
 
 // BOM encoders
@@ -116,4 +116,21 @@ describe('BOM end-to-end integraion', () => {
       'BOM_OK UTF-32BE',
     );
   });
+
+  it('Can describe a PNG file', async () => {
+    const imagePath = resolve(
+      process.cwd(),
+      'docs/assets/gemini-screenshot.png',
+    );
+    const imageContent = readFileSync(imagePath);
+    const filename = 'gemini-screenshot.png';
+    writeFileSync(join(rig.testDir!, filename), imageContent);
+    const prompt = `What is shown in the image ${filename}?`;
+    const output = await rig.run({ args: prompt });
+    await rig.waitForToolCall('read_file');
+    const lower = output.toLowerCase();
+    // The response is non-deterministic, so we just check for some
+    // keywords that are very likely to be in the response.
+    expect(lower.includes('gemini')).toBeTruthy();
+  });
 });

memory-tests/baselines.json

@@ -1,30 +0,0 @@
-{
-  "version": 1,
-  "updatedAt": "2026-04-08T01:21:58.770Z",
-  "scenarios": {
-    "multi-turn-conversation": {
-      "heapUsedBytes": 120082704,
-      "heapTotalBytes": 177586176,
-      "rssBytes": 269172736,
-      "timestamp": "2026-04-08T01:21:57.127Z"
-    },
-    "multi-function-call-repo-search": {
-      "heapUsedBytes": 104644984,
-      "heapTotalBytes": 111575040,
-      "rssBytes": 204079104,
-      "timestamp": "2026-04-08T01:21:58.770Z"
-    },
-    "idle-session-startup": {
-      "heapUsedBytes": 119813672,
-      "heapTotalBytes": 177061888,
-      "rssBytes": 267943936,
-      "timestamp": "2026-04-08T01:21:53.855Z"
-    },
-    "simple-prompt-response": {
-      "heapUsedBytes": 119722064,
-      "heapTotalBytes": 177324032,
-      "rssBytes": 268812288,
-      "timestamp": "2026-04-08T01:21:55.491Z"
-    }
-  }
-}

memory-tests/globalSetup.ts

@@ -1,71 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { mkdir, readdir, rm } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { canUseRipgrep } from '../packages/core/src/tools/ripGrep.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const rootDir = join(__dirname, '..');
-const memoryTestsDir = join(rootDir, '.memory-tests');
-let runDir = '';
-
-export async function setup() {
-  runDir = join(memoryTestsDir, `${Date.now()}`);
-  await mkdir(runDir, { recursive: true });
-
-  // Set the home directory to the test run directory to avoid conflicts
-  // with the user's local config.
-  process.env['HOME'] = runDir;
-  if (process.platform === 'win32') {
-    process.env['USERPROFILE'] = runDir;
-  }
-  process.env['GEMINI_CONFIG_DIR'] = join(runDir, '.gemini');
-
-  // Download ripgrep to avoid race conditions
-  const available = await canUseRipgrep();
-  if (!available) {
-    throw new Error('Failed to download ripgrep binary');
-  }
-
-  // Clean up old test runs, keeping the latest few for debugging
-  try {
-    const testRuns = await readdir(memoryTestsDir);
-    if (testRuns.length > 3) {
-      const oldRuns = testRuns.sort().slice(0, testRuns.length - 3);
-      await Promise.all(
-        oldRuns.map((oldRun) =>
-          rm(join(memoryTestsDir, oldRun), {
-            recursive: true,
-            force: true,
-          }),
-        ),
-      );
-    }
-  } catch (e) {
-    console.error('Error cleaning up old memory test runs:', e);
-  }
-
-  process.env['INTEGRATION_TEST_FILE_DIR'] = runDir;
-  process.env['GEMINI_CLI_INTEGRATION_TEST'] = 'true';
-  process.env['GEMINI_FORCE_FILE_STORAGE'] = 'true';
-  process.env['TELEMETRY_LOG_FILE'] = join(runDir, 'telemetry.log');
-  process.env['VERBOSE'] = process.env['VERBOSE'] ?? 'false';
-
-  console.log(`\nMemory test output directory: ${runDir}`);
-}
-
-export async function teardown() {
-  // Cleanup unless KEEP_OUTPUT is set
-  if (process.env['KEEP_OUTPUT'] !== 'true' && runDir) {
-    try {
-      await rm(runDir, { recursive: true, force: true });
-    } catch (e) {
-      console.warn('Failed to clean up memory test directory:', e);
-    }
-  }
-}

memory-tests/memory-usage.test.ts

@@ -1,185 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, beforeAll, afterAll, afterEach } from 'vitest';
-import { TestRig, MemoryTestHarness } from '@google/gemini-cli-test-utils';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const BASELINES_PATH = join(__dirname, 'baselines.json');
-const UPDATE_BASELINES = process.env['UPDATE_MEMORY_BASELINES'] === 'true';
-const TOLERANCE_PERCENT = 10;
-
-// Fake API key for tests using fake responses
-const TEST_ENV = { GEMINI_API_KEY: 'fake-memory-test-key' };
-
-describe('Memory Usage Tests', () => {
-  let harness: MemoryTestHarness;
-  let rig: TestRig;
-
-  beforeAll(() => {
-    harness = new MemoryTestHarness({
-      baselinesPath: BASELINES_PATH,
-      defaultTolerancePercent: TOLERANCE_PERCENT,
-      gcCycles: 3,
-      gcDelayMs: 100,
-      sampleCount: 3,
-    });
-  });
-
-  afterEach(async () => {
-    await rig.cleanup();
-  });
-
-  afterAll(async () => {
-    // Generate the summary report after all tests
-    await harness.generateReport();
-  });
-
-  it('idle-session-startup: memory usage within baseline', async () => {
-    rig = new TestRig();
-    rig.setup('memory-idle-startup', {
-      fakeResponsesPath: join(__dirname, 'memory.idle-startup.responses'),
-    });
-
-    const result = await harness.runScenario(
-      'idle-session-startup',
-      async (recordSnapshot) => {
-        await rig.run({
-          args: ['hello'],
-          timeout: 120000,
-          env: TEST_ENV,
-        });
-
-        await recordSnapshot('after-startup');
-      },
-    );
-
-    if (UPDATE_BASELINES) {
-      harness.updateScenarioBaseline(result);
-      console.log(
-        `Updated baseline for idle-session-startup: ${(result.finalHeapUsed / (1024 * 1024)).toFixed(1)} MB`,
-      );
-    } else {
-      harness.assertWithinBaseline(result);
-    }
-  });
-
-  it('simple-prompt-response: memory usage within baseline', async () => {
-    rig = new TestRig();
-    rig.setup('memory-simple-prompt', {
-      fakeResponsesPath: join(__dirname, 'memory.simple-prompt.responses'),
-    });
-
-    const result = await harness.runScenario(
-      'simple-prompt-response',
-      async (recordSnapshot) => {
-        await rig.run({
-          args: ['What is the capital of France?'],
-          timeout: 120000,
-          env: TEST_ENV,
-        });
-
-        await recordSnapshot('after-response');
-      },
-    );
-
-    if (UPDATE_BASELINES) {
-      harness.updateScenarioBaseline(result);
-      console.log(
-        `Updated baseline for simple-prompt-response: ${(result.finalHeapUsed / (1024 * 1024)).toFixed(1)} MB`,
-      );
-    } else {
-      harness.assertWithinBaseline(result);
-    }
-  });
-
-  it('multi-turn-conversation: memory remains stable over turns', async () => {
-    rig = new TestRig();
-    rig.setup('memory-multi-turn', {
-      fakeResponsesPath: join(__dirname, 'memory.multi-turn.responses'),
-    });
-
-    const prompts = [
-      'Hello, what can you help me with?',
-      'Tell me about JavaScript',
-      'How is TypeScript different?',
-      'Can you write a simple TypeScript function?',
-      'What are some TypeScript best practices?',
-    ];
-
-    const result = await harness.runScenario(
-      'multi-turn-conversation',
-      async (recordSnapshot) => {
-        // Run through all turns as a piped sequence
-        const stdinContent = prompts.join('\n');
-        await rig.run({
-          stdin: stdinContent,
-          timeout: 120000,
-          env: TEST_ENV,
-        });
-
-        // Take snapshots after the conversation completes
-        await recordSnapshot('after-all-turns');
-      },
-    );
-
-    if (UPDATE_BASELINES) {
-      harness.updateScenarioBaseline(result);
-      console.log(
-        `Updated baseline for multi-turn-conversation: ${(result.finalHeapUsed / (1024 * 1024)).toFixed(1)} MB`,
-      );
-    } else {
-      harness.assertWithinBaseline(result);
-    }
-  });
-
-  it('multi-function-call-repo-search: memory after tool use', async () => {
-    rig = new TestRig();
-    rig.setup('memory-multi-func-call', {
-      fakeResponsesPath: join(
-        __dirname,
-        'memory.multi-function-call.responses',
-      ),
-    });
-
-    // Create directories first, then files in the workspace so the tools have targets
-    rig.mkdir('packages/core/src/telemetry');
-    rig.createFile(
-      'packages/core/src/telemetry/memory-monitor.ts',
-      'export class MemoryMonitor { constructor() {} }',
-    );
-    rig.createFile(
-      'packages/core/src/telemetry/metrics.ts',
-      'export function recordMemoryUsage() {}',
-    );
-
-    const result = await harness.runScenario(
-      'multi-function-call-repo-search',
-      async (recordSnapshot) => {
-        await rig.run({
-          args: [
-            'Search this repository for MemoryMonitor and tell me what it does',
-          ],
-          timeout: 120000,
-          env: TEST_ENV,
-        });
-
-        await recordSnapshot('after-tool-calls');
-      },
-    );
-
-    if (UPDATE_BASELINES) {
-      harness.updateScenarioBaseline(result);
-      console.log(
-        `Updated baseline for multi-function-call-repo-search: ${(result.finalHeapUsed / (1024 * 1024)).toFixed(1)} MB`,
-      );
-    } else {
-      harness.assertWithinBaseline(result);
-    }
-  });
-});

memory-tests/memory.idle-startup.responses

@@ -1,2 +0,0 @@
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Hello! I'm ready to help. What would you like to work on?"}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":5,"candidatesTokenCount":12,"totalTokenCount":17,"promptTokensDetails":[{"modality":"TEXT","tokenCount":5}]}}]}

memory-tests/memory.multi-function-call.responses

@@ -1,4 +0,0 @@
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I'll search for MemoryMonitor in the repository and analyze what it does."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":30,"candidatesTokenCount":15,"totalTokenCount":45,"promptTokensDetails":[{"modality":"TEXT","tokenCount":30}]}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"grep_search","args":{"pattern":"MemoryMonitor","path":".","include_pattern":"*.ts"}}},{"functionCall":{"name":"list_directory","args":{"path":"packages/core/src/telemetry"}}},{"functionCall":{"name":"read_file","args":{"file_path":"packages/core/src/telemetry/memory-monitor.ts"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":30,"candidatesTokenCount":80,"totalTokenCount":110,"promptTokensDetails":[{"modality":"TEXT","tokenCount":30}]}}]}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I found the memory monitoring code. Here's a summary:\n\nThe `MemoryMonitor` class in `packages/core/src/telemetry/memory-monitor.ts` provides:\n\n1. **Continuous monitoring** via `start()`/`stop()` with configurable intervals\n2. **V8 heap snapshots** using `v8.getHeapStatistics()` and `process.memoryUsage()`\n3. **High-water mark tracking** to detect significant memory growth\n4. **Rate-limited recording** to avoid metric flood\n5. **Activity detection** — only records when user is active\n\nThe class uses a singleton pattern via `initializeMemoryMonitor()` for global access."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":500,"candidatesTokenCount":120,"totalTokenCount":620,"promptTokensDetails":[{"modality":"TEXT","tokenCount":500}]}}]}

memory-tests/memory.multi-turn.responses

@@ -1,10 +0,0 @@
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Hello! I'm ready to help you with your coding tasks. What would you like to work on today?"}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":5,"candidatesTokenCount":18,"totalTokenCount":23,"promptTokensDetails":[{"modality":"TEXT","tokenCount":5}]}}]}
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"JavaScript is a high-level, interpreted programming language. It was originally designed for adding interactivity to web pages."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":25,"candidatesTokenCount":60,"totalTokenCount":85,"promptTokensDetails":[{"modality":"TEXT","tokenCount":25}]}}]}
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"TypeScript is a typed superset of JavaScript developed by Microsoft. The main differences from JavaScript are static typing and better tooling."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":45,"candidatesTokenCount":80,"totalTokenCount":125,"promptTokensDetails":[{"modality":"TEXT","tokenCount":45}]}}]}
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Here is a simple TypeScript function:\n\nfunction greet(name: string): string { return `Hello, ${name}!`; }"}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":60,"candidatesTokenCount":55,"totalTokenCount":115,"promptTokensDetails":[{"modality":"TEXT","tokenCount":60}]}}]}
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"Here are 5 key TypeScript best practices: Enable strict mode, prefer interfaces, use union types, leverage type inference, and use readonly."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":75,"candidatesTokenCount":70,"totalTokenCount":145,"promptTokensDetails":[{"modality":"TEXT","tokenCount":75}]}}]}

memory-tests/memory.simple-prompt.responses

@@ -1,2 +0,0 @@
-{"method":"generateContent","response":{"candidates":[{"content":{"parts":[{"text":"0"}],"role":"model"},"finishReason":"STOP","index":0}]}}
-{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"The capital of France is Paris. It has been the capital since the 10th century and is known for iconic landmarks like the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral. Paris is also the most populous city in France, with a metropolitan area population of over 12 million people."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":7,"candidatesTokenCount":55,"totalTokenCount":62,"promptTokensDetails":[{"modality":"TEXT","tokenCount":7}]}}]}

memory-tests/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "allowJs": true
-  },
-  "include": ["**/*.ts"],
-  "references": [
-    { "path": "../packages/core" },
-    { "path": "../packages/test-utils" }
-  ]
-}

memory-tests/vitest.config.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    testTimeout: 600000, // 10 minutes — memory profiling is slow
-    globalSetup: './globalSetup.ts',
-    reporters: ['default'],
-    include: ['**/*.test.ts'],
-    retry: 0, // No retries for memory tests — noise is handled by tolerance
-    fileParallelism: false, // Must run serially to avoid memory interference
-    pool: 'forks', // Use forks pool for --expose-gc support
-    poolOptions: {
-      forks: {
-        singleFork: true, // Single process for accurate per-test memory readings
-        execArgv: ['--expose-gc'], // Enable global.gc() for forced GC
-      },
-    },
-    env: {
-      GEMINI_TEST_TYPE: 'memory',
-    },
-  },
-});

package-lock.json

@@ -1,17 +1,17 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.39.0-nightly.20260408.e77b22e63",
+  "version": "0.36.0-nightly.20260317.2f90b4653",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@google/gemini-cli",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "workspaces": [
         "packages/*"
       ],
       "dependencies": {
-        "ink": "npm:@jrichman/ink@6.6.9",
+        "ink": "npm:@jrichman/ink@6.6.7",
         "latest-version": "^9.0.0",
         "node-fetch-native": "^1.6.7",
         "proper-lockfile": "^4.1.2",
@@ -36,7 +36,6 @@
         "@types/ws": "^8.18.1",
         "@vitest/coverage-v8": "^3.1.1",
         "@vitest/eslint-plugin": "^1.3.4",
-        "asciichart": "^1.5.25",
         "cross-env": "^7.0.3",
         "depcheck": "^1.4.7",
         "domexception": "^4.0.0",
@@ -5570,12 +5569,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/asciichart": {
-      "version": "1.5.25",
-      "resolved": "https://registry.npmjs.org/asciichart/-/asciichart-1.5.25.tgz",
-      "integrity": "sha512-PNxzXIPPOtWq8T7bgzBtk9cI2lgS4SJZthUHEiQ1aoIc3lNzGfUvIvo9LiAnq26TACo9t1/4qP6KTGAUbzX9Xg==",
-      "license": "MIT"
-    },
     "node_modules/assertion-error": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -10056,9 +10049,9 @@
     },
     "node_modules/ink": {
       "name": "@jrichman/ink",
-      "version": "6.6.9",
-      "resolved": "https://registry.npmjs.org/@jrichman/ink/-/ink-6.6.9.tgz",
-      "integrity": "sha512-RL9sSiLQZECnjbmBwjIHOp8yVGdWF7C/uifg7ISv/e+F3nLNsfl7FdUFQs8iZARFMJAYxMFpxW6OW+HSt9drwQ==",
+      "version": "6.6.7",
+      "resolved": "https://registry.npmjs.org/@jrichman/ink/-/ink-6.6.7.tgz",
+      "integrity": "sha512-bDzQLpLzK/dn9Ur/Ku88ZZR9totVcMGrGYAgPHidsAAbe9NKztU1fggj/iu0wRp5g1kBeALb3cfagFGdDxAU1w==",
       "license": "MIT",
       "dependencies": {
         "ansi-escapes": "^7.0.0",
@@ -17396,7 +17389,7 @@
     },
     "packages/a2a-server": {
       "name": "@google/gemini-cli-a2a-server",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "dependencies": {
         "@a2a-js/sdk": "0.3.11",
         "@google-cloud/storage": "^7.16.0",
@@ -17511,7 +17504,7 @@
     },
     "packages/cli": {
       "name": "@google/gemini-cli",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "Apache-2.0",
       "dependencies": {
         "@agentclientprotocol/sdk": "^0.16.1",
@@ -17533,7 +17526,7 @@
         "fzf": "^0.5.2",
         "glob": "^12.0.0",
         "highlight.js": "^11.11.1",
-        "ink": "npm:@jrichman/ink@6.6.9",
+        "ink": "npm:@jrichman/ink@6.6.7",
         "ink-gradient": "^3.0.0",
         "ink-spinner": "^5.0.0",
         "latest-version": "^9.0.0",
@@ -17683,7 +17676,7 @@
     },
     "packages/core": {
       "name": "@google/gemini-cli-core",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "Apache-2.0",
       "dependencies": {
         "@a2a-js/sdk": "0.3.11",
@@ -17949,7 +17942,7 @@
     },
     "packages/devtools": {
       "name": "@google/gemini-cli-devtools",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "Apache-2.0",
       "dependencies": {
         "ws": "^8.16.0"
@@ -17964,7 +17957,7 @@
     },
     "packages/sdk": {
       "name": "@google/gemini-cli-sdk",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "Apache-2.0",
       "dependencies": {
         "@google/gemini-cli-core": "file:../core",
@@ -17981,12 +17974,11 @@
     },
     "packages/test-utils": {
       "name": "@google/gemini-cli-test-utils",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "Apache-2.0",
       "dependencies": {
         "@google/gemini-cli-core": "file:../core",
         "@lydell/node-pty": "1.1.0",
-        "asciichart": "^1.5.25",
         "strip-ansi": "^7.1.2",
         "vitest": "^3.2.4"
       },
@@ -17999,7 +17991,7 @@
     },
     "packages/vscode-ide-companion": {
       "name": "gemini-cli-vscode-ide-companion",
-      "version": "0.39.0-nightly.20260408.e77b22e63",
+      "version": "0.36.0-nightly.20260317.2f90b4653",
       "license": "LICENSE",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.23.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.39.0-nightly.20260408.e77b22e63",
+  "version": "0.36.0-nightly.20260317.2f90b4653",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -14,7 +14,7 @@
     "url": "git+https://github.com/google-gemini/gemini-cli.git"
   },
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.39.0-nightly.20260408.e77b22e63"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.36.0-nightly.20260317.2f90b4653"
   },
   "scripts": {
     "start": "cross-env NODE_ENV=development node scripts/start.js",
@@ -51,10 +51,6 @@
     "test:integration:all": "npm run test:integration:sandbox:none && npm run test:integration:sandbox:docker && npm run test:integration:sandbox:podman",
     "test:integration:flaky": "cross-env RUN_FLAKY_INTEGRATION=1 npm run test:integration:sandbox:none",
     "test:integration:sandbox:none": "cross-env GEMINI_SANDBOX=false vitest run --root ./integration-tests",
-    "test:memory": "vitest run --root ./memory-tests",
-    "test:memory:update-baselines": "cross-env UPDATE_MEMORY_BASELINES=true vitest run --root ./memory-tests",
-    "test:perf": "vitest run --root ./perf-tests",
-    "test:perf:update-baselines": "cross-env UPDATE_PERF_BASELINES=true vitest run --root ./perf-tests",
     "test:integration:sandbox:docker": "cross-env GEMINI_SANDBOX=docker npm run build:sandbox && cross-env GEMINI_SANDBOX=docker vitest run --root ./integration-tests",
     "test:integration:sandbox:podman": "cross-env GEMINI_SANDBOX=podman vitest run --root ./integration-tests",
     "lint": "cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" eslint . --cache --max-warnings 0",
@@ -73,7 +69,7 @@
     "pre-commit": "node scripts/pre-commit.js"
   },
   "overrides": {
-    "ink": "npm:@jrichman/ink@6.6.9",
+    "ink": "npm:@jrichman/ink@6.6.7",
     "wrap-ansi": "9.0.2",
     "cliui": {
       "wrap-ansi": "7.0.0"
@@ -107,7 +103,6 @@
     "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^3.1.1",
     "@vitest/eslint-plugin": "^1.3.4",
-    "asciichart": "^1.5.25",
     "cross-env": "^7.0.3",
     "depcheck": "^1.4.7",
     "domexception": "^4.0.0",
@@ -142,7 +137,7 @@
     "yargs": "^17.7.2"
   },
   "dependencies": {
-    "ink": "npm:@jrichman/ink@6.6.9",
+    "ink": "npm:@jrichman/ink@6.6.7",
     "latest-version": "^9.0.0",
     "node-fetch-native": "^1.6.7",
     "proper-lockfile": "^4.1.2",

packages/a2a-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli-a2a-server",
-  "version": "0.39.0-nightly.20260408.e77b22e63",
+  "version": "0.36.0-nightly.20260317.2f90b4653",
   "description": "Gemini CLI A2A Server",
   "repository": {
     "type": "git",

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings=DEP0040
 
 /**
  * @license

packages/cli/index.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings=DEP0040
 
 /**
  * @license
@@ -6,9 +6,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { spawn } from 'node:child_process';
-import os from 'node:os';
-import v8 from 'node:v8';
+import { main } from './src/gemini.js';
+import { FatalError, writeToStderr } from '@google/gemini-cli-core';
+import { runExitCleanup } from './src/utils/cleanup.js';
 
 // --- Global Entry Point ---
 
@@ -28,162 +28,44 @@ process.on('uncaughtException', (error) => {
   // For other errors, we rely on the default behavior, but since we attached a listener,
   // we must manually replicate it.
   if (error instanceof Error) {
-    process.stderr.write(error.stack + '\n');
+    writeToStderr(error.stack + '\n');
   } else {
-    process.stderr.write(String(error) + '\n');
+    writeToStderr(String(error) + '\n');
   }
   process.exit(1);
 });
 
-async function getMemoryNodeArgs(): Promise<string[]> {
-  let autoConfigureMemory = true;
+main().catch(async (error) => {
+  // Set a timeout to force exit if cleanup hangs
+  const cleanupTimeout = setTimeout(() => {
+    writeToStderr('Cleanup timed out, forcing exit...\n');
+    process.exit(1);
+  }, 5000);
+
   try {
-    const { readFileSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    // Respect GEMINI_CLI_HOME environment variable, falling back to os.homedir()
-    const baseDir =
-      process.env['GEMINI_CLI_HOME'] || join(os.homedir(), '.gemini');
-    const settingsPath = join(baseDir, 'settings.json');
-    const rawSettings = readFileSync(settingsPath, 'utf8');
-    const settings = JSON.parse(rawSettings);
-    if (settings?.advanced?.autoConfigureMemory === false) {
-      autoConfigureMemory = false;
-    }
-  } catch {
-    // ignore
-  }
-
-  if (autoConfigureMemory) {
-    const totalMemoryMB = os.totalmem() / (1024 * 1024);
-    const heapStats = v8.getHeapStatistics();
-    const currentMaxOldSpaceSizeMb = Math.floor(
-      heapStats.heap_size_limit / 1024 / 1024,
+    await runExitCleanup();
+  } catch (cleanupError) {
+    writeToStderr(
+      `Error during final cleanup: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`,
     );
-    const targetMaxOldSpaceSizeInMB = Math.floor(totalMemoryMB * 0.5);
-
-    if (targetMaxOldSpaceSizeInMB > currentMaxOldSpaceSizeMb) {
-      return [`--max-old-space-size=${targetMaxOldSpaceSizeInMB}`];
-    }
+  } finally {
+    clearTimeout(cleanupTimeout);
   }
 
-  return [];
-}
-
-async function run() {
-  if (!process.env['GEMINI_CLI_NO_RELAUNCH'] && !process.env['SANDBOX']) {
-    // --- Lightweight Parent Process / Daemon ---
-    // We avoid importing heavy dependencies here to save ~1.5s of startup time.
-
-    const nodeArgs: string[] = [...process.execArgv];
-    const scriptArgs = process.argv.slice(2);
-
-    const memoryArgs = await getMemoryNodeArgs();
-    nodeArgs.push(...memoryArgs);
-
-    const script = process.argv[1];
-    nodeArgs.push(script);
-    nodeArgs.push(...scriptArgs);
-
-    const newEnv = { ...process.env, GEMINI_CLI_NO_RELAUNCH: 'true' };
-    const RELAUNCH_EXIT_CODE = 199;
-    let latestAdminSettings: unknown = undefined;
-
-    // Prevent the parent process from exiting prematurely on signals.
-    // The child process will receive the same signals and handle its own cleanup.
-    for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-      process.on(sig as NodeJS.Signals, () => {});
+  if (error instanceof FatalError) {
+    let errorMessage = error.message;
+    if (!process.env['NO_COLOR']) {
+      errorMessage = `\x1b[31m${errorMessage}\x1b[0m`;
     }
+    writeToStderr(errorMessage + '\n');
+    process.exit(error.exitCode);
+  }
 
-    const runner = () => {
-      process.stdin.pause();
-
-      const child = spawn(process.execPath, nodeArgs, {
-        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-        env: newEnv,
-      });
-
-      if (latestAdminSettings) {
-        child.send({ type: 'admin-settings', settings: latestAdminSettings });
-      }
-
-      child.on('message', (msg: { type?: string; settings?: unknown }) => {
-        if (msg.type === 'admin-settings-update' && msg.settings) {
-          latestAdminSettings = msg.settings;
-        }
-      });
-
-      return new Promise<number>((resolve) => {
-        child.on('error', (err) => {
-          process.stderr.write(
-            'Error: Failed to start child process: ' + err.message + '\n',
-          );
-          resolve(1);
-        });
-        child.on('close', (code) => {
-          process.stdin.resume();
-          resolve(code ?? 1);
-        });
-      });
-    };
-
-    while (true) {
-      try {
-        const exitCode = await runner();
-        if (exitCode !== RELAUNCH_EXIT_CODE) {
-          process.exit(exitCode);
-        }
-      } catch (error: unknown) {
-        process.stdin.resume();
-        process.stderr.write(
-          `Fatal error: Failed to relaunch the CLI process.\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`,
-        );
-        process.exit(1);
-      }
-    }
+  writeToStderr('An unexpected critical error occurred:');
+  if (error instanceof Error) {
+    writeToStderr(error.stack + '\n');
   } else {
-    // --- Heavy Child Process ---
-    // Now we can safely import everything.
-    const { main } = await import('./src/gemini.js');
-    const { FatalError, writeToStderr } = await import(
-      '@google/gemini-cli-core'
-    );
-    const { runExitCleanup } = await import('./src/utils/cleanup.js');
-
-    main().catch(async (error: unknown) => {
-      // Set a timeout to force exit if cleanup hangs
-      const cleanupTimeout = setTimeout(() => {
-        writeToStderr('Cleanup timed out, forcing exit...\n');
-        process.exit(1);
-      }, 5000);
-
-      try {
-        await runExitCleanup();
-      } catch (cleanupError: unknown) {
-        writeToStderr(
-          `Error during final cleanup: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`,
-        );
-      } finally {
-        clearTimeout(cleanupTimeout);
-      }
-
-      if (error instanceof FatalError) {
-        let errorMessage = error.message;
-        if (!process.env['NO_COLOR']) {
-          errorMessage = `\x1b[31m${errorMessage}\x1b[0m`;
-        }
-        writeToStderr(errorMessage + '\n');
-        process.exit(error.exitCode);
-      }
-
-      writeToStderr('An unexpected critical error occurred:');
-      if (error instanceof Error) {
-        writeToStderr(error.stack + '\n');
-      } else {
-        writeToStderr(String(error) + '\n');
-      }
-      process.exit(1);
-    });
+    writeToStderr(String(error) + '\n');
   }
-}
-
-run();
+  process.exit(1);
+});

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/gemini-cli",
-  "version": "0.39.0-nightly.20260408.e77b22e63",
+  "version": "0.36.0-nightly.20260317.2f90b4653",
   "description": "Gemini CLI",
   "license": "Apache-2.0",
   "repository": {
@@ -27,7 +27,7 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.39.0-nightly.20260408.e77b22e63"
+    "sandboxImageUri": "us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.36.0-nightly.20260317.2f90b4653"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.16.1",
@@ -49,7 +49,7 @@
     "fzf": "^0.5.2",
     "glob": "^12.0.0",
     "highlight.js": "^11.11.1",
-    "ink": "npm:@jrichman/ink@6.6.9",
+    "ink": "npm:@jrichman/ink@6.6.7",
     "ink-gradient": "^3.0.0",
     "ink-spinner": "^5.0.0",
     "latest-version": "^9.0.0",

packages/cli/src/acp/acpClient.ts

@@ -372,7 +372,7 @@ export class GeminiAgent {
       mcpServers,
     );
 
-    const sessionSelector = new SessionSelector(config.storage);
+    const sessionSelector = new SessionSelector(config);
     const { sessionData, sessionPath } =
       await sessionSelector.resolveSession(sessionId);
 

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

@@ -29,8 +29,5 @@ describe('CommandHandler', () => {
 
     const about = parse('/about');
     expect(about.commandToExecute?.name).toBe('about');
-
-    const help = parse('/help');
-    expect(help.commandToExecute?.name).toBe('help');
   });
 });

packages/cli/src/acp/commandHandler.ts

@@ -11,7 +11,6 @@ import { ExtensionsCommand } from './commands/extensions.js';
 import { InitCommand } from './commands/init.js';
 import { RestoreCommand } from './commands/restore.js';
 import { AboutCommand } from './commands/about.js';
-import { HelpCommand } from './commands/help.js';
 
 export class CommandHandler {
   private registry: CommandRegistry;
@@ -27,7 +26,6 @@ export class CommandHandler {
     registry.register(new InitCommand());
     registry.register(new RestoreCommand());
     registry.register(new AboutCommand());
-    registry.register(new HelpCommand(registry));
     return registry;
   }
 

packages/cli/src/acp/commands/help.test.ts

@@ -1,53 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import { HelpCommand } from './help.js';
-import { CommandRegistry } from './commandRegistry.js';
-import type { Command, CommandContext } from './types.js';
-
-describe('HelpCommand', () => {
-  it('returns formatted help text with sorted commands', async () => {
-    const registry = new CommandRegistry();
-
-    const cmdB: Command = {
-      name: 'bravo',
-      description: 'Bravo command',
-      execute: async () => ({ name: 'bravo', data: '' }),
-    };
-
-    const cmdA: Command = {
-      name: 'alpha',
-      description: 'Alpha command',
-      execute: async () => ({ name: 'alpha', data: '' }),
-    };
-
-    registry.register(cmdB);
-    registry.register(cmdA);
-
-    const helpCommand = new HelpCommand(registry);
-
-    const context = {} as CommandContext;
-
-    const response = await helpCommand.execute(context, []);
-
-    expect(response.name).toBe('help');
-
-    const data = response.data as string;
-
-    expect(data).toContain('Gemini CLI Help:');
-    expect(data).toContain('### Basics');
-    expect(data).toContain('### Commands');
-
-    const lines = data.split('\n');
-    const alphaIndex = lines.findIndex((l) => l.includes('/alpha'));
-    const bravoIndex = lines.findIndex((l) => l.includes('/bravo'));
-
-    expect(alphaIndex).toBeLessThan(bravoIndex);
-    expect(alphaIndex).not.toBe(-1);
-    expect(bravoIndex).not.toBe(-1);
-  });
-});

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

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  Command,
-  CommandContext,
-  CommandExecutionResponse,
-} from './types.js';
-import type { CommandRegistry } from './commandRegistry.js';
-
-export class HelpCommand implements Command {
-  readonly name = 'help';
-  readonly description = 'Show available commands';
-
-  constructor(private registry: CommandRegistry) {}
-
-  async execute(
-    _context: CommandContext,
-    _args: string[] = [],
-  ): Promise<CommandExecutionResponse> {
-    const commands = this.registry
-      .getAllCommands()
-      .sort((a, b) => a.name.localeCompare(b.name));
-
-    const lines: string[] = [];
-
-    lines.push('Gemini CLI Help:');
-    lines.push('');
-    lines.push('### Basics');
-    lines.push(
-      '- **Add context**: Use `@` to specify files for context (e.g., `@src/myFile.ts`) to target specific files or folders.',
-    );
-    lines.push('');
-
-    lines.push('### Commands');
-    for (const cmd of commands) {
-      if (cmd.description) {
-        lines.push(`- **/${cmd.name}** - ${cmd.description}`);
-      }
-    }
-
-    return {
-      name: this.name,
-      data: lines.join('\n'),
-    };
-  }
-}

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

@@ -6,7 +6,6 @@
 
 import {
   addMemory,
-  listInboxSkills,
   listMemoryFiles,
   refreshMemory,
   showMemory,
@@ -31,7 +30,6 @@ export class MemoryCommand implements Command {
     new RefreshMemoryCommand(),
     new ListMemoryCommand(),
     new AddMemoryCommand(),
-    new InboxMemoryCommand(),
   ];
   readonly requiresWorkspace = true;
 
@@ -124,39 +122,3 @@ export class AddMemoryCommand implements Command {
     }
   }
 }
-
-export class InboxMemoryCommand implements Command {
-  readonly name = 'memory inbox';
-  readonly description =
-    'Lists skills extracted from past sessions that are pending review.';
-
-  async execute(
-    context: CommandContext,
-    _: string[],
-  ): Promise<CommandExecutionResponse> {
-    if (!context.agentContext.config.isMemoryManagerEnabled()) {
-      return {
-        name: this.name,
-        data: 'The memory inbox requires the experimental memory manager. Enable it with: experimental.memoryManager = true in settings.',
-      };
-    }
-
-    const skills = await listInboxSkills(context.agentContext.config);
-
-    if (skills.length === 0) {
-      return { name: this.name, data: 'No extracted skills in inbox.' };
-    }
-
-    const lines = skills.map((s) => {
-      const date = s.extractedAt
-        ? ` (extracted: ${new Date(s.extractedAt).toLocaleDateString()})`
-        : '';
-      return `- **${s.name}**: ${s.description}${date}`;
-    });
-
-    return {
-      name: this.name,
-      data: `Skill inbox (${skills.length}):\n${lines.join('\n')}`,
-    };
-  }
-}

packages/cli/src/commands/skills/list.test.ts

@@ -4,16 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {
-  vi,
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  type MockInstance,
-} from 'vitest';
-import { type Config } from '@google/gemini-cli-core';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { coreEvents, type Config } from '@google/gemini-cli-core';
 import { handleList, listCommand } from './list.js';
 import { loadSettings, type LoadedSettings } from '../../config/settings.js';
 import { loadCliConfig } from '../../config/config.js';
@@ -40,16 +32,12 @@ vi.mock('../utils.js', () => ({
 describe('skills list command', () => {
   const mockLoadSettings = vi.mocked(loadSettings);
   const mockLoadCliConfig = vi.mocked(loadCliConfig);
-  let stdoutWriteSpy: MockInstance<typeof process.stdout.write>;
 
   beforeEach(async () => {
     vi.clearAllMocks();
     mockLoadSettings.mockReturnValue({
       merged: {},
     } as unknown as LoadedSettings);
-    stdoutWriteSpy = vi
-      .spyOn(process.stdout, 'write')
-      .mockImplementation(() => true);
   });
 
   afterEach(() => {
@@ -68,7 +56,10 @@ describe('skills list command', () => {
 
       await handleList({});
 
-      expect(stdoutWriteSpy).toHaveBeenCalledWith('No skills discovered.\n');
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
+        'No skills discovered.',
+      );
     });
 
     it('should list all discovered skills', async () => {
@@ -96,19 +87,24 @@ describe('skills list command', () => {
 
       await handleList({});
 
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
-        chalk.bold('Discovered Agent Skills:') + '\n\n',
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
+        chalk.bold('Discovered Agent Skills:'),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('skill1'),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining(chalk.green('[Enabled]')),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('skill2'),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining(chalk.red('[Disabled]')),
       );
     });
@@ -139,10 +135,12 @@ describe('skills list command', () => {
 
       // Default
       await handleList({ all: false });
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('regular'),
       );
-      expect(stdoutWriteSpy).not.toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).not.toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('builtin'),
       );
 
@@ -150,13 +148,16 @@ describe('skills list command', () => {
 
       // With all: true
       await handleList({ all: true });
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('regular'),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining('builtin'),
       );
-      expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith(
+        'log',
         expect.stringContaining(chalk.gray(' [Built-in]')),
       );
     });

packages/cli/src/commands/skills/list.ts

@@ -5,6 +5,7 @@
  */
 
 import type { CommandModule } from 'yargs';
+import { debugLogger } from '@google/gemini-cli-core';
 import { loadSettings } from '../../config/settings.js';
 import { loadCliConfig, type CliArgs } from '../../config/config.js';
 import { exitCli } from '../utils.js';
@@ -41,11 +42,12 @@ export async function handleList(args: { all?: boolean }) {
   });
 
   if (skills.length === 0) {
-    process.stdout.write('No skills discovered.\n');
+    debugLogger.log('No skills discovered.');
     return;
   }
 
-  process.stdout.write(chalk.bold('Discovered Agent Skills:') + '\n\n');
+  debugLogger.log(chalk.bold('Discovered Agent Skills:'));
+  debugLogger.log('');
 
   for (const skill of skills) {
     const status = skill.disabled
@@ -54,11 +56,10 @@ export async function handleList(args: { all?: boolean }) {
 
     const builtinSuffix = skill.isBuiltin ? chalk.gray(' [Built-in]') : '';
 
-    process.stdout.write(
-      `${chalk.bold(skill.name)} ${status}${builtinSuffix}\n`,
-    );
-    process.stdout.write(`  Description: ${skill.description}\n`);
-    process.stdout.write(`  Location:    ${skill.location}\n\n`);
+    debugLogger.log(`${chalk.bold(skill.name)} ${status}${builtinSuffix}`);
+    debugLogger.log(`  Description: ${skill.description}`);
+    debugLogger.log(`  Location:    ${skill.location}`);
+    debugLogger.log('');
   }
 }
 

packages/cli/src/config/config.ts

@@ -938,8 +938,6 @@ export async function loadCliConfig(
       : undefined,
     blockedEnvironmentVariables:
       settings.security?.environmentVariableRedaction?.blocked,
-    allowedEnvironmentVariables:
-      settings.security?.environmentVariableRedaction?.allowed,
     enableEnvironmentVariableRedaction:
       settings.security?.environmentVariableRedaction?.enabled,
     userMemory: memoryContent,

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

@@ -520,8 +520,8 @@ describe('Policy Engine Integration Tests', () => {
       const readOnlyToolRule = rules.find(
         (r) => r.toolName === 'glob' && !r.subagent,
       );
-      // Priority 50 in default tier → 1.05 (Overriding Plan Mode Deny)
-      expect(readOnlyToolRule?.priority).toBeCloseTo(1.05, 5);
+      // Priority 70 in default tier → 1.07 (Overriding Plan Mode Deny)
+      expect(readOnlyToolRule?.priority).toBeCloseTo(1.07, 5);
 
       // Verify the engine applies these priorities correctly
       expect(
@@ -677,8 +677,8 @@ describe('Policy Engine Integration Tests', () => {
       expect(server1Rule?.priority).toBe(4.1); // Allowed servers (user tier)
 
       const globRule = rules.find((r) => r.toolName === 'glob' && !r.subagent);
-      // Priority 50 in default tier → 1.05
-      expect(globRule?.priority).toBeCloseTo(1.05, 5); // Auto-accept read-only
+      // Priority 70 in default tier → 1.07
+      expect(globRule?.priority).toBeCloseTo(1.07, 5); // Auto-accept read-only
 
       // The PolicyEngine will sort these by priority when it's created
       const engine = new PolicyEngine(config);

packages/cli/src/config/settingsSchema.ts

@@ -757,7 +757,7 @@ const SETTINGS_SCHEMA = {
         label: 'Terminal Buffer',
         category: 'UI',
         requiresRestart: true,
-        default: false,
+        default: true,
         description: 'Use the new terminal buffer architecture for rendering.',
         showInDialog: true,
       },
@@ -1907,8 +1907,7 @@ const SETTINGS_SCHEMA = {
         category: 'Advanced',
         requiresRestart: true,
         default: true,
-        description:
-          'Automatically configure Node.js memory limits. Note: Because memory is allocated during the initial process boot, this setting is only read from the global user settings file and ignores workspace-level overrides.',
+        description: 'Automatically configure Node.js memory limits',
         showInDialog: true,
       },
       dnsResolutionOrder: {
@@ -1971,16 +1970,6 @@ const SETTINGS_SCHEMA = {
             description: 'Enable non-interactive agent sessions.',
             showInDialog: false,
           },
-          agentSessionInteractiveEnabled: {
-            type: 'boolean',
-            label: 'Interactive Agent Session Enabled',
-            category: 'Experimental',
-            requiresRestart: true,
-            default: false,
-            description:
-              'Enable the agent session implementation for the interactive CLI.',
-            showInDialog: false,
-          },
         },
       },
       enableAgents: {

packages/cli/src/gemini.test.tsx

@@ -379,30 +379,15 @@ describe('initializeOutputListenersAndFlush', () => {
 describe('getNodeMemoryArgs', () => {
   let osTotalMemSpy: MockInstance;
   let v8GetHeapStatisticsSpy: MockInstance;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let originalConfig: any;
 
   beforeEach(() => {
     osTotalMemSpy = vi.spyOn(os, 'totalmem');
     v8GetHeapStatisticsSpy = vi.spyOn(v8, 'getHeapStatistics');
     delete process.env['GEMINI_CLI_NO_RELAUNCH'];
-
-    originalConfig = process.config;
-    Object.defineProperty(process, 'config', {
-      value: {
-        ...originalConfig,
-        variables: { ...originalConfig?.variables, v8_enable_sandbox: 1 },
-      },
-      configurable: true,
-    });
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
-    Object.defineProperty(process, 'config', {
-      value: originalConfig,
-      configurable: true,
-    });
   });
 
   it('should return empty array if GEMINI_CLI_NO_RELAUNCH is set', () => {
@@ -415,10 +400,8 @@ describe('getNodeMemoryArgs', () => {
     v8GetHeapStatisticsSpy.mockReturnValue({
       heap_size_limit: 8 * 1024 * 1024 * 1024, // 8GB
     });
-    // Target is 50% of 16GB = 8GB. Current is 8GB. Relaunch needed for EPT size only.
-    expect(getNodeMemoryArgs(false)).toEqual([
-      '--max-external-pointer-table-size=268435456',
-    ]);
+    // Target is 50% of 16GB = 8GB. Current is 8GB. No relaunch needed.
+    expect(getNodeMemoryArgs(false)).toEqual([]);
   });
 
   it('should return memory args if current heap limit is insufficient', () => {
@@ -426,11 +409,8 @@ describe('getNodeMemoryArgs', () => {
     v8GetHeapStatisticsSpy.mockReturnValue({
       heap_size_limit: 4 * 1024 * 1024 * 1024, // 4GB
     });
-    // Target is 50% of 16GB = 8GB. Current is 4GB. Relaunch needed for both.
-    expect(getNodeMemoryArgs(false)).toEqual([
-      '--max-external-pointer-table-size=268435456',
-      '--max-old-space-size=8192',
-    ]);
+    // Target is 50% of 16GB = 8GB. Current is 4GB. Relaunch needed.
+    expect(getNodeMemoryArgs(false)).toEqual(['--max-old-space-size=8192']);
   });
 
   it('should log debug info when isDebugMode is true', () => {

packages/cli/src/gemini.tsx

@@ -13,7 +13,7 @@ import {
   type OutputPayload,
   type ConsoleLogPayload,
   type UserFeedbackPayload,
-  createSessionId,
+  sessionId,
   logUserPrompt,
   AuthType,
   UserPromptEvent,
@@ -33,7 +33,6 @@ import {
   type AdminControlsSettings,
   debugLogger,
   isHeadlessMode,
-  Storage,
 } from '@google/gemini-cli-core';
 
 import { loadCliConfig, parseArguments } from './config/config.js';
@@ -81,7 +80,10 @@ import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
 import { appEvents, AppEvent } from './utils/events.js';
 import { SessionError, SessionSelector } from './utils/sessionUtils.js';
 
-import { relaunchOnExitCode } from './utils/relaunch.js';
+import {
+  relaunchAppInChildProcess,
+  relaunchOnExitCode,
+} from './utils/relaunch.js';
 import { loadSandboxConfig } from './config/sandboxConfig.js';
 import { deleteSession, listSessions } from './utils/sessions.js';
 import { createPolicyUpdater } from './config/policy.js';
@@ -109,8 +111,6 @@ export function validateDnsResolutionOrder(
   return defaultValue;
 }
 
-const DEFAULT_EPT_SIZE = (256 * 1024 * 1024).toString();
-
 export function getNodeMemoryArgs(isDebugMode: boolean): string[] {
   const totalMemoryMB = os.totalmem() / (1024 * 1024);
   const heapStats = v8.getHeapStatistics();
@@ -130,35 +130,16 @@ export function getNodeMemoryArgs(isDebugMode: boolean): string[] {
     return [];
   }
 
-  const args: string[] = [];
-
-  // Automatically expand the V8 External Pointer Table to 256MB to prevent
-  // out-of-memory crashes during high native-handle concurrency.
-  // Note: Only supported in specific Node.js versions compiled with V8 Sandbox enabled.
-  const eptFlag = `--max-external-pointer-table-size=${DEFAULT_EPT_SIZE}`;
-  const isV8SandboxEnabled =
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-type-assertion
-    (process.config?.variables as any)?.v8_enable_sandbox === 1;
-
-  if (
-    isV8SandboxEnabled &&
-    !process.execArgv.some((arg) =>
-      arg.startsWith('--max-external-pointer-table-size'),
-    )
-  ) {
-    args.push(eptFlag);
-  }
-
   if (targetMaxOldSpaceSizeInMB > currentMaxOldSpaceSizeMb) {
     if (isDebugMode) {
       debugLogger.debug(
         `Need to relaunch with more memory: ${targetMaxOldSpaceSizeInMB.toFixed(2)} MB`,
       );
     }
-    args.push(`--max-old-space-size=${targetMaxOldSpaceSizeInMB}`);
+    return [`--max-old-space-size=${targetMaxOldSpaceSizeInMB}`];
   }
 
-  return args;
+  return [];
 }
 
 export function setupUnhandledRejectionHandler() {
@@ -183,39 +164,6 @@ ${reason.stack}`
   });
 }
 
-export async function resolveSessionId(resumeArg: string | undefined): Promise<{
-  sessionId: string;
-  resumedSessionData?: ResumedSessionData;
-}> {
-  if (!resumeArg) {
-    return { sessionId: createSessionId() };
-  }
-
-  const storage = new Storage(process.cwd());
-  await storage.initialize();
-
-  try {
-    const { sessionData, sessionPath } = await new SessionSelector(
-      storage,
-    ).resolveSession(resumeArg);
-    return {
-      sessionId: sessionData.sessionId,
-      resumedSessionData: { conversation: sessionData, filePath: sessionPath },
-    };
-  } catch (error) {
-    if (error instanceof SessionError && error.code === 'NO_SESSIONS_FOUND') {
-      coreEvents.emitFeedback('warning', error.message);
-      return { sessionId: createSessionId() };
-    }
-    coreEvents.emitFeedback(
-      'error',
-      `Error resuming session: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    );
-    await runExitCleanup();
-    process.exit(ExitCodes.FATAL_INPUT_ERROR);
-  }
-}
-
 export async function startInteractiveUI(
   config: Config,
   settings: LoadedSettings,
@@ -311,8 +259,6 @@ export async function main() {
 
   const argv = await argvPromise;
 
-  const { sessionId, resumedSessionData } = await resolveSessionId(argv.resume);
-
   if (
     (argv.allowedTools && argv.allowedTools.length > 0) ||
     (settings.merged.tools?.allowed && settings.merged.tools.allowed.length > 0)
@@ -436,12 +382,6 @@ export async function main() {
   // Set remote admin settings if returned from CCPA.
   if (remoteAdminSettings) {
     settings.setRemoteAdminSettings(remoteAdminSettings);
-    if (process.send) {
-      process.send({
-        type: 'admin-settings-update',
-        settings: remoteAdminSettings,
-      });
-    }
   }
 
   // Run deferred command now that we have admin settings.
@@ -499,6 +439,10 @@ export async function main() {
       );
       await runExitCleanup();
       process.exit(ExitCodes.SUCCESS);
+    } else {
+      // Relaunch app so we always have a child process that can be internally
+      // restarted if needed.
+      await relaunchAppInChildProcess(memoryArgs, [], remoteAdminSettings);
     }
   }
 
@@ -634,6 +578,40 @@ export async function main() {
       })),
     ];
 
+    // Handle --resume flag
+    let resumedSessionData: ResumedSessionData | undefined = undefined;
+    if (argv.resume) {
+      const sessionSelector = new SessionSelector(config);
+      try {
+        const result = await sessionSelector.resolveSession(argv.resume);
+        resumedSessionData = {
+          conversation: result.sessionData,
+          filePath: result.sessionPath,
+        };
+        // Use the existing session ID to continue recording to the same session
+        config.setSessionId(resumedSessionData.conversation.sessionId);
+      } catch (error) {
+        if (
+          error instanceof SessionError &&
+          error.code === 'NO_SESSIONS_FOUND'
+        ) {
+          // No sessions to resume — start a fresh session with a warning
+          startupWarnings.push({
+            id: 'resume-no-sessions',
+            message: error.message,
+            priority: WarningPriority.High,
+          });
+        } else {
+          coreEvents.emitFeedback(
+            'error',
+            `Error resuming session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          );
+          await runExitCleanup();
+          process.exit(ExitCodes.FATAL_INPUT_ERROR);
+        }
+      }
+    }
+
     cliStartupHandle?.end();
 
     // Render UI, passing necessary config values. Check that there is no command line question.

packages/cli/src/gemini_cleanup.test.tsx

@@ -73,7 +73,6 @@ vi.mock('./config/config.js', () => ({
     getSandbox: vi.fn(() => false),
     getQuestion: vi.fn(() => ''),
     isInteractive: () => false,
-    getSessionId: vi.fn().mockReturnValue('test-session-id'),
     storage: { initialize: vi.fn().mockResolvedValue(undefined) },
   } as unknown as Config),
   parseArguments: vi.fn().mockResolvedValue({}),
@@ -214,7 +213,6 @@ describe('gemini.tsx main function cleanup', () => {
       getSandbox: vi.fn(() => false),
       getDebugMode: vi.fn(() => false),
       getPolicyEngine: vi.fn(),
-      getSessionId: vi.fn().mockReturnValue('test-session-id'),
       getMessageBus: () => ({ subscribe: vi.fn() }),
       getEnableHooks: vi.fn(() => false),
       getHookSystem: () => undefined,
@@ -275,7 +273,6 @@ describe('gemini.tsx main function cleanup', () => {
     vi.mocked(loadCliConfig).mockResolvedValue(
       buildMockConfig({
         getHookSystem: vi.fn(() => mockHookSystem),
-        getSessionId: vi.fn().mockReturnValue('test-session-id'),
       }),
     );
 

packages/cli/src/interactiveCli.tsx

@@ -107,7 +107,7 @@ export async function startInteractiveUI(
               <TerminalProvider>
                 <ScrollProvider>
                   <OverflowProvider>
-                    <SessionStatsProvider sessionId={config.getSessionId()}>
+                    <SessionStatsProvider>
                       <VimModeProvider>
                         <AppContainer
                           config={config}
@@ -156,9 +156,8 @@ export async function startInteractiveUI(
         useAlternateBuffer || config.getUseTerminalBuffer(),
       patchConsole: false,
       alternateBuffer: useAlternateBuffer,
+      renderProcess: config.getUseRenderProcess(),
       terminalBuffer: config.getUseTerminalBuffer(),
-      renderProcess:
-        config.getUseRenderProcess() && config.getUseTerminalBuffer(),
       incrementalRendering:
         settings.merged.ui.incrementalRendering !== false &&
         useAlternateBuffer &&

packages/cli/src/nonInteractiveCli.test.ts

@@ -71,7 +71,6 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     Scheduler: class {
       schedule = mockSchedulerSchedule;
       cancelAll = vi.fn();
-      dispose = vi.fn();
     },
     isTelemetrySdkInitialized: vi.fn().mockReturnValue(true),
     ChatRecordingService: MockChatRecordingService,

packages/cli/src/nonInteractiveCli.ts

@@ -187,7 +187,6 @@ export async function runNonInteractive(
     };
 
     let errorToHandle: unknown | undefined;
-    let scheduler: Scheduler | undefined;
     try {
       consolePatcher.patch();
 
@@ -216,7 +215,7 @@ export async function runNonInteractive(
       });
 
       const geminiClient = config.getGeminiClient();
-      scheduler = new Scheduler({
+      const scheduler = new Scheduler({
         context: config,
         messageBus: config.getMessageBus(),
         getPreferredEditor: () => undefined,
@@ -529,7 +528,6 @@ export async function runNonInteractive(
       // Cleanup stdin cancellation before other cleanup
       cleanupStdinCancellation();
 
-      scheduler?.dispose();
       consolePatcher.cleanup();
       coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
     }

packages/cli/src/nonInteractiveCliAgentSession.test.ts

@@ -71,7 +71,6 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     Scheduler: class {
       schedule = mockSchedulerSchedule;
       cancelAll = vi.fn();
-      dispose = vi.fn();
     },
     isTelemetrySdkInitialized: vi.fn().mockReturnValue(true),
     ChatRecordingService: MockChatRecordingService,

packages/cli/src/nonInteractiveCliAgentSession.ts

@@ -37,7 +37,6 @@ import {
   LegacyAgentSession,
   ToolErrorType,
   geminiPartsToContentParts,
-  debugLogger,
 } from '@google/gemini-cli-core';
 
 import type { Part } from '@google/genai';
@@ -184,7 +183,6 @@ export async function runNonInteractive({
     };
 
     let errorToHandle: unknown | undefined;
-    let scheduler: Scheduler | undefined;
     let abortSession = () => {};
     try {
       consolePatcher.patch();
@@ -216,7 +214,7 @@ export async function runNonInteractive({
       });
 
       const geminiClient = config.getGeminiClient();
-      scheduler = new Scheduler({
+      const scheduler = new Scheduler({
         context: config,
         messageBus: config.getMessageBus(),
         getPreferredEditor: () => undefined,
@@ -601,7 +599,6 @@ export async function runNonInteractive({
             // Explicitly ignore these non-interactive events
             break;
           default:
-            debugLogger.error('Unknown agent event type:', event);
             event satisfies never;
             break;
         }
@@ -613,7 +610,6 @@ export async function runNonInteractive({
       cleanupStdinCancellation();
       abortController.signal.removeEventListener('abort', abortSession);
 
-      scheduler?.dispose();
       consolePatcher.cleanup();
       coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
     }

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

@@ -136,7 +136,6 @@ export const createMockConfig = (overrides: Partial<Config> = {}): Config =>
     getRetryFetchErrors: vi.fn().mockReturnValue(true),
     getEnableShellOutputEfficiency: vi.fn().mockReturnValue(true),
     getShellToolInactivityTimeout: vi.fn().mockReturnValue(300000),
-    getRequestTimeoutMs: vi.fn().mockReturnValue(undefined),
     getShellExecutionConfig: vi.fn().mockReturnValue({
       sandboxManager: new NoopSandboxManager(),
       sanitizationConfig: {

packages/cli/src/test-utils/render.tsx

@@ -504,8 +504,6 @@ const baseMockUiState = {
   history: [],
   renderMarkdown: true,
   streamingState: StreamingState.Idle,
-  isConfigInitialized: true,
-  isAuthenticating: false,
   terminalWidth: 100,
   terminalHeight: 40,
   currentModel: 'gemini-pro',
@@ -600,9 +598,6 @@ const mockUIActions: UIActions = {
   clearAccountSuspension: vi.fn(),
 };
 
-import { type TextBuffer } from '../ui/components/shared/text-buffer.js';
-import { InputContext, type InputState } from '../ui/contexts/InputContext.js';
-
 let capturedOverflowState: OverflowState | undefined;
 let capturedOverflowActions: OverflowActions | undefined;
 const ContextCapture: React.FC<{ children: React.ReactNode }> = ({
@@ -619,7 +614,6 @@ export const renderWithProviders = async (
     shellFocus = true,
     settings = mockSettings,
     uiState: providedUiState,
-    inputState: providedInputState,
     width,
     mouseEventsEnabled = false,
     config,
@@ -631,7 +625,6 @@ export const renderWithProviders = async (
     shellFocus?: boolean;
     settings?: LoadedSettings;
     uiState?: Partial<UIState>;
-    inputState?: Partial<InputState>;
     width?: number;
     mouseEventsEnabled?: boolean;
     config?: Config;
@@ -666,18 +659,6 @@ export const renderWithProviders = async (
     },
   ) as UIState;
 
-  const inputState = {
-    buffer: { text: '' } as unknown as TextBuffer,
-    userMessages: [],
-    shellModeActive: false,
-    showEscapePrompt: false,
-    copyModeEnabled: false,
-    inputWidth: 80,
-    suggestionsWidth: 40,
-    ...(providedUiState as unknown as Partial<InputState>),
-    ...providedInputState,
-  };
-
   if (persistentState?.get) {
     persistentStateMock.get.mockImplementation(persistentState.get);
   }
@@ -727,65 +708,63 @@ export const renderWithProviders = async (
     <AppContext.Provider value={appState}>
       <ConfigContext.Provider value={config}>
         <SettingsContext.Provider value={settings}>
-          <InputContext.Provider value={inputState}>
-            <UIStateContext.Provider value={finalUiState}>
-              <VimModeProvider>
-                <ShellFocusContext.Provider value={shellFocus}>
-                  <SessionStatsProvider sessionId={config.getSessionId()}>
-                    <StreamingContext.Provider
-                      value={finalUiState.streamingState}
-                    >
-                      <UIActionsContext.Provider value={finalUIActions}>
-                        <OverflowProvider>
-                          <ToolActionsProvider
-                            config={config}
-                            toolCalls={allToolCalls}
-                            isExpanded={
-                              toolActions?.isExpanded ??
-                              vi.fn().mockReturnValue(false)
-                            }
-                            toggleExpansion={
-                              toolActions?.toggleExpansion ?? vi.fn()
-                            }
-                            toggleAllExpansion={
-                              toolActions?.toggleAllExpansion ?? vi.fn()
-                            }
+          <UIStateContext.Provider value={finalUiState}>
+            <VimModeProvider>
+              <ShellFocusContext.Provider value={shellFocus}>
+                <SessionStatsProvider>
+                  <StreamingContext.Provider
+                    value={finalUiState.streamingState}
+                  >
+                    <UIActionsContext.Provider value={finalUIActions}>
+                      <OverflowProvider>
+                        <ToolActionsProvider
+                          config={config}
+                          toolCalls={allToolCalls}
+                          isExpanded={
+                            toolActions?.isExpanded ??
+                            vi.fn().mockReturnValue(false)
+                          }
+                          toggleExpansion={
+                            toolActions?.toggleExpansion ?? vi.fn()
+                          }
+                          toggleAllExpansion={
+                            toolActions?.toggleAllExpansion ?? vi.fn()
+                          }
+                        >
+                          <AskUserActionsProvider
+                            request={null}
+                            onSubmit={vi.fn()}
+                            onCancel={vi.fn()}
                           >
-                            <AskUserActionsProvider
-                              request={null}
-                              onSubmit={vi.fn()}
-                              onCancel={vi.fn()}
-                            >
-                              <KeypressProvider>
-                                <MouseProvider
-                                  mouseEventsEnabled={mouseEventsEnabled}
-                                >
-                                  <TerminalProvider>
-                                    <ScrollProvider>
-                                      <ContextCapture>
-                                        <Box
-                                          width={terminalWidth}
-                                          flexShrink={0}
-                                          flexGrow={0}
-                                          flexDirection="column"
-                                        >
-                                          {comp}
-                                        </Box>
-                                      </ContextCapture>
-                                    </ScrollProvider>
-                                  </TerminalProvider>
-                                </MouseProvider>
-                              </KeypressProvider>
-                            </AskUserActionsProvider>
-                          </ToolActionsProvider>
-                        </OverflowProvider>
-                      </UIActionsContext.Provider>
-                    </StreamingContext.Provider>
-                  </SessionStatsProvider>
-                </ShellFocusContext.Provider>
-              </VimModeProvider>
-            </UIStateContext.Provider>
-          </InputContext.Provider>
+                            <KeypressProvider>
+                              <MouseProvider
+                                mouseEventsEnabled={mouseEventsEnabled}
+                              >
+                                <TerminalProvider>
+                                  <ScrollProvider>
+                                    <ContextCapture>
+                                      <Box
+                                        width={terminalWidth}
+                                        flexShrink={0}
+                                        flexGrow={0}
+                                        flexDirection="column"
+                                      >
+                                        {comp}
+                                      </Box>
+                                    </ContextCapture>
+                                  </ScrollProvider>
+                                </TerminalProvider>
+                              </MouseProvider>
+                            </KeypressProvider>
+                          </AskUserActionsProvider>
+                        </ToolActionsProvider>
+                      </OverflowProvider>
+                    </UIActionsContext.Provider>
+                  </StreamingContext.Provider>
+                </SessionStatsProvider>
+              </ShellFocusContext.Provider>
+            </VimModeProvider>
+          </UIStateContext.Provider>
         </SettingsContext.Provider>
       </ConfigContext.Provider>
     </AppContext.Provider>

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

@@ -122,17 +122,13 @@ vi.mock('ink', async (importOriginal) => {
   };
 });
 
-import { InputContext, type InputState } from './contexts/InputContext.js';
-
 // Helper component will read the context values provided by AppContainer
 // so we can assert against them in our tests.
 let capturedUIState: UIState;
-let capturedInputState: InputState;
 let capturedUIActions: UIActions;
 let capturedOverflowActions: OverflowActions;
 function TestContextConsumer() {
   capturedUIState = useContext(UIStateContext)!;
-  capturedInputState = useContext(InputContext)!;
   capturedUIActions = useContext(UIActionsContext)!;
   capturedOverflowActions = useOverflowActions()!;
   return null;
@@ -3040,7 +3036,7 @@ describe('AppContainer State Management', () => {
       });
 
       const { unmount } = await act(async () => renderAppContainer());
-      expect(capturedInputState.userMessages).toContain('previous message');
+      expect(capturedUIState.userMessages).toContain('previous message');
 
       const { onCancelSubmit } = extractUseGeminiStreamArgs(
         mockedUseGeminiStream.mock.lastCall!,
@@ -3068,8 +3064,8 @@ describe('AppContainer State Management', () => {
       const { rerender, unmount } = await act(async () => renderAppContainer());
 
       // Verify userMessages is populated from inputHistory
-      expect(capturedInputState.userMessages).toContain('first prompt');
-      expect(capturedInputState.userMessages).toContain('second prompt');
+      expect(capturedUIState.userMessages).toContain('first prompt');
+      expect(capturedUIState.userMessages).toContain('second prompt');
 
       // Clear the conversation history (simulating /clear command)
       const mockClearItems = vi.fn();
@@ -3088,8 +3084,8 @@ describe('AppContainer State Management', () => {
 
       // Verify that userMessages still contains the input history
       // (it should not be affected by clearing conversation history)
-      expect(capturedInputState.userMessages).toContain('first prompt');
-      expect(capturedInputState.userMessages).toContain('second prompt');
+      expect(capturedUIState.userMessages).toContain('first prompt');
+      expect(capturedUIState.userMessages).toContain('second prompt');
 
       unmount();
     });

packages/cli/src/ui/AppContainer.tsx

@@ -36,11 +36,9 @@ import {
   type ConfirmationRequest,
   type PermissionConfirmationRequest,
   type QuotaStats,
-  MessageType,
-  StreamingState,
-  type HistoryItemInfo,
 } from './types.js';
 import { checkPermissions } from './hooks/atCommandProcessor.js';
+import { MessageType, StreamingState } from './types.js';
 import { ToolActionsProvider } from './contexts/ToolActionsContext.js';
 import { MouseProvider } from './contexts/MouseContext.js';
 import { ScrollProvider } from './contexts/ScrollProvider.js';
@@ -53,7 +51,6 @@ import {
   type UserTierId,
   type GeminiUserTier,
   type UserFeedbackPayload,
-  type HookSystemMessagePayload,
   type AgentDefinition,
   type ApprovalMode,
   IdeClient,
@@ -197,8 +194,6 @@ import {
 } from './hooks/useVisibilityToggle.js';
 import { useKeyMatchers } from './hooks/useKeyMatchers.js';
 
-import { InputContext } from './contexts/InputContext.js';
-
 /**
  * The fraction of the terminal width to allocate to the shell.
  * This provides horizontal padding.
@@ -444,7 +439,7 @@ export const AppContainer = (props: AppContainerProps) => {
 
   const [isConfigInitialized, setConfigInitialized] = useState(false);
 
-  const logger = useLogger(config);
+  const logger = useLogger(config.storage);
   const { inputHistory, addInput, initializeFromLogger } =
     useInputHistoryStore();
 
@@ -2114,19 +2109,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       }
     };
 
-    const handleHookSystemMessage = (payload: HookSystemMessagePayload) => {
-      historyManager.addItem(
-        {
-          type: MessageType.INFO,
-          text: payload.message,
-          source: payload.hookName,
-        } as HistoryItemInfo,
-        Date.now(),
-      );
-    };
-
     coreEvents.on(CoreEvent.UserFeedback, handleUserFeedback);
-    coreEvents.on(CoreEvent.HookSystemMessage, handleHookSystemMessage);
 
     // Flush any messages that happened during startup before this component
     // mounted.
@@ -2134,7 +2117,6 @@ Logging in with Google... Restarting Gemini CLI to continue.
 
     return () => {
       coreEvents.off(CoreEvent.UserFeedback, handleUserFeedback);
-      coreEvents.off(CoreEvent.HookSystemMessage, handleHookSystemMessage);
     };
   }, [historyManager]);
 
@@ -2346,27 +2328,6 @@ Logging in with Google... Restarting Gemini CLI to continue.
     };
   }, [config, refreshStatic]);
 
-  const inputState = useMemo(
-    () => ({
-      buffer,
-      userMessages: inputHistory,
-      shellModeActive,
-      showEscapePrompt,
-      copyModeEnabled,
-      inputWidth,
-      suggestionsWidth,
-    }),
-    [
-      buffer,
-      inputHistory,
-      shellModeActive,
-      showEscapePrompt,
-      copyModeEnabled,
-      inputWidth,
-      suggestionsWidth,
-    ],
-  );
-
   const uiState: UIState = useMemo(
     () => ({
       history: historyManager.history,
@@ -2410,6 +2371,11 @@ Logging in with Google... Restarting Gemini CLI to continue.
       initError,
       pendingGeminiHistoryItems,
       thought,
+      shellModeActive,
+      userMessages: inputHistory,
+      buffer,
+      inputWidth,
+      suggestionsWidth,
       isInputActive,
       isResuming,
       shouldShowIdePrompt,
@@ -2425,6 +2391,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       renderMarkdown,
       ctrlCPressedOnce: ctrlCPressCount >= 1,
       ctrlDPressedOnce: ctrlDPressCount >= 1,
+      showEscapePrompt,
       shortcutsHelpVisible,
       cleanUiDetailsVisible,
       isFocused,
@@ -2476,6 +2443,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       embeddedShellFocused,
       showDebugProfiler,
       customDialog,
+      copyModeEnabled,
       transientMessage,
       bannerData,
       bannerVisible,
@@ -2530,6 +2498,11 @@ Logging in with Google... Restarting Gemini CLI to continue.
       initError,
       pendingGeminiHistoryItems,
       thought,
+      shellModeActive,
+      inputHistory,
+      buffer,
+      inputWidth,
+      suggestionsWidth,
       isInputActive,
       isResuming,
       shouldShowIdePrompt,
@@ -2545,6 +2518,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       renderMarkdown,
       ctrlCPressCount,
       ctrlDPressCount,
+      showEscapePrompt,
       shortcutsHelpVisible,
       cleanUiDetailsVisible,
       isFocused,
@@ -2596,6 +2570,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       customDialog,
       apiKeyDefaultValue,
       authState,
+      copyModeEnabled,
       transientMessage,
       bannerData,
       bannerVisible,
@@ -2782,34 +2757,32 @@ Logging in with Google... Restarting Gemini CLI to continue.
 
   return (
     <UIStateContext.Provider value={uiState}>
-      <InputContext.Provider value={inputState}>
-        <UIActionsContext.Provider value={uiActions}>
-          <ConfigContext.Provider value={config}>
-            <AppContext.Provider
-              value={{
-                version: props.version,
-                startupWarnings: props.startupWarnings || [],
-              }}
+      <UIActionsContext.Provider value={uiActions}>
+        <ConfigContext.Provider value={config}>
+          <AppContext.Provider
+            value={{
+              version: props.version,
+              startupWarnings: props.startupWarnings || [],
+            }}
+          >
+            <ToolActionsProvider
+              config={config}
+              toolCalls={allToolCalls}
+              isExpanded={isExpanded}
+              toggleExpansion={toggleExpansion}
+              toggleAllExpansion={toggleAllExpansion}
             >
-              <ToolActionsProvider
-                config={config}
-                toolCalls={allToolCalls}
-                isExpanded={isExpanded}
-                toggleExpansion={toggleExpansion}
-                toggleAllExpansion={toggleAllExpansion}
-              >
-                <ShellFocusContext.Provider value={isFocused}>
-                  <MouseProvider mouseEventsEnabled={mouseMode}>
-                    <ScrollProvider>
-                      <App key={`app-${forceRerenderKey}`} />
-                    </ScrollProvider>
-                  </MouseProvider>
-                </ShellFocusContext.Provider>
-              </ToolActionsProvider>
-            </AppContext.Provider>
-          </ConfigContext.Provider>
-        </UIActionsContext.Provider>
-      </InputContext.Provider>
+              <ShellFocusContext.Provider value={isFocused}>
+                <MouseProvider mouseEventsEnabled={mouseMode}>
+                  <ScrollProvider>
+                    <App key={`app-${forceRerenderKey}`} />
+                  </ScrollProvider>
+                </MouseProvider>
+              </ShellFocusContext.Provider>
+            </ToolActionsProvider>
+          </AppContext.Provider>
+        </ConfigContext.Provider>
+      </UIActionsContext.Provider>
     </UIStateContext.Provider>
   );
 };