diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index 1b2bba1b..34580f4d 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -12,15 +12,15 @@ jobs:
 
     steps:
       - name: Check out repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: 22
 
       - name: Set up Bun
-        uses: oven-sh/setup-bun@v2
+        uses: oven-sh/setup-bun@4bc047ad259df6fc24a6c9b0f9a0cb08cf17fbe5 # v2.0.1
         with:
           bun-version: 1.3.11
 
diff --git a/README.md b/README.md
index d354ea3a..0a8e0d2a 100644
--- a/README.md
+++ b/README.md
@@ -2,290 +2,105 @@
 
 Use Claude Code with **any LLM** — not just Claude.
 
-OpenClaude is a fork of the [Claude Code source leak](https://gitlawb.com/node/repos/z6MkgKkb/instructkr-claude-code) (exposed via npm source maps on March 31, 2026). We added an OpenAI-compatible provider shim so you can plug in GPT-4o, DeepSeek, Gemini, Llama, Mistral, or any model that speaks the OpenAI chat completions API. It now also supports the ChatGPT Codex backend for `codexplan` and `codexspark`.
+OpenClaude is a fork of the [Claude Code source leak](https://gitlawb.com/node/repos/z6MkgKkb/instructkr-claude-code) (exposed via npm source maps on March 31, 2026). We added an OpenAI-compatible provider shim so you can plug in GPT-4o, DeepSeek, Gemini, Llama, Mistral, or any model that speaks the OpenAI chat completions API. It now also supports the ChatGPT Codex backend for `codexplan` and `codexspark`, and local inference via [Atomic Chat](https://atomic.chat/) on Apple Silicon.
 
 All of Claude Code's tools work — bash, file read/write/edit, grep, glob, agents, tasks, MCP — just powered by whatever model you choose.
 
 ---
 
-## Install
+## Start Here
 
-### Option A: npm (recommended)
+If you are new to terminals or just want the easiest path, start with the beginner guides:
+
+- [Non-Technical Setup](docs/non-technical-setup.md)
+- [Windows Quick Start](docs/quick-start-windows.md)
+- [macOS / Linux Quick Start](docs/quick-start-mac-linux.md)
+
+If you want source builds, Bun workflows, profile launchers, or full provider examples, use:
+
+- [Advanced Setup](docs/advanced-setup.md)
+
+---
+
+## Beginner Install
+
+For most users, install the npm package:
 
 ```bash
 npm install -g @gitlawb/openclaude
 ```
 
-If you install via npm and later see `ripgrep not found`, install ripgrep
-system-wide and confirm `rg --version` works in the same terminal before
-starting OpenClaude.
-
-### Option B: From source (requires Bun)
-
-Use Bun `1.3.11` or newer for source builds on Windows. Older Bun versions such as `1.3.4` can fail with a large batch of unresolved module errors during `bun run build`.
+The package name is `@gitlawb/openclaude`, but the command you run is:
 
 ```bash
-# Clone from gitlawb
-git clone https://node.gitlawb.com/z6MkqDnb7Siv3Cwj7pGJq4T5EsUisECqR8KpnDLwcaZq5TPr/openclaude.git
-cd openclaude
-
-# Install dependencies
-bun install
-
-# Build
-bun run build
-
-# Link globally (optional)
-npm link
+openclaude
 ```
 
-### Option C: Run directly with Bun (no build step)
-
-```bash
-git clone https://node.gitlawb.com/z6MkqDnb7Siv3Cwj7pGJq4T5EsUisECqR8KpnDLwcaZq5TPr/openclaude.git
-cd openclaude
-bun install
-bun run dev
-```
+If you install via npm and later see `ripgrep not found`, install ripgrep system-wide and confirm `rg --version` works in the same terminal before starting OpenClaude.
 
 ---
 
-## Quick Start
+## Fastest Setup
 
-### 1. Set 3 environment variables
+### Windows PowerShell
+
+```powershell
+npm install -g @gitlawb/openclaude
+
+$env:CLAUDE_CODE_USE_OPENAI="1"
+$env:OPENAI_API_KEY="sk-your-key-here"
+$env:OPENAI_MODEL="gpt-4o"
+
+openclaude
+```
+
+### macOS / Linux
 
 ```bash
+npm install -g @gitlawb/openclaude
+
 export CLAUDE_CODE_USE_OPENAI=1
 export OPENAI_API_KEY=sk-your-key-here
 export OPENAI_MODEL=gpt-4o
-```
 
-### 2. Run it
-
-```bash
-# If installed via npm
 openclaude
-
-# If built from source
-bun run dev
-# or after build:
-node dist/cli.mjs
 ```
 
-That's it. The tool system, streaming, file editing, multi-step reasoning — everything works through the model you picked.
-
-The npm package name is `@gitlawb/openclaude`, but the installed CLI command is still `openclaude`.
+That is enough to start with OpenAI.
 
 ---
 
-## Provider Examples
+## Choose Your Guide
+
+### Beginner
+
+- Want the easiest setup with copy-paste steps: [Non-Technical Setup](docs/non-technical-setup.md)
+- On Windows: [Windows Quick Start](docs/quick-start-windows.md)
+- On macOS or Linux: [macOS / Linux Quick Start](docs/quick-start-mac-linux.md)
+
+### Advanced
+
+- Want source builds, Bun, local profiles, runtime checks, or more provider choices: [Advanced Setup](docs/advanced-setup.md)
+
+---
+
+## Common Beginner Choices
 
 ### OpenAI
 
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=sk-...
-export OPENAI_MODEL=gpt-4o
-```
+Best default if you already have an OpenAI API key.
 
-### Codex via ChatGPT auth
+### Ollama
 
-`codexplan` maps to GPT-5.4 on the Codex backend with high reasoning.
-`codexspark` maps to GPT-5.3 Codex Spark for faster loops.
+Best if you want to run models locally on your own machine.
 
-If you already use the Codex CLI, OpenClaude will read `~/.codex/auth.json`
-automatically. You can also point it elsewhere with `CODEX_AUTH_JSON_PATH` or
-override the token directly with `CODEX_API_KEY`.
+### Codex
 
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_MODEL=codexplan
+Best if you already use the Codex CLI or ChatGPT Codex backend.
 
-# optional if you do not already have ~/.codex/auth.json
-export CODEX_API_KEY=...
+### Atomic Chat
 
-openclaude
-```
-
-### DeepSeek
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=sk-...
-export OPENAI_BASE_URL=https://api.deepseek.com/v1
-export OPENAI_MODEL=deepseek-chat
-```
-
-### Google Gemini (via OpenRouter)
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=sk-or-...
-export OPENAI_BASE_URL=https://openrouter.ai/api/v1
-export OPENAI_MODEL=google/gemini-2.0-flash-001
-```
-
-OpenRouter model availability changes over time. If a model stops working,
-pick another currently available OpenRouter model before assuming the
-OpenAI-compatible setup is broken.
-
-### Ollama (local, free)
-
-```bash
-ollama pull llama3.3:70b
-
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_BASE_URL=http://localhost:11434/v1
-export OPENAI_MODEL=llama3.3:70b
-# no API key needed for local models
-```
-
-### LM Studio (local)
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_BASE_URL=http://localhost:1234/v1
-export OPENAI_MODEL=your-model-name
-```
-
-### Together AI
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=...
-export OPENAI_BASE_URL=https://api.together.xyz/v1
-export OPENAI_MODEL=meta-llama/Llama-3.3-70B-Instruct-Turbo
-```
-
-### Groq
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=gsk_...
-export OPENAI_BASE_URL=https://api.groq.com/openai/v1
-export OPENAI_MODEL=llama-3.3-70b-versatile
-```
-
-### Mistral
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=...
-export OPENAI_BASE_URL=https://api.mistral.ai/v1
-export OPENAI_MODEL=mistral-large-latest
-```
-
-### Azure OpenAI
-
-```bash
-export CLAUDE_CODE_USE_OPENAI=1
-export OPENAI_API_KEY=your-azure-key
-export OPENAI_BASE_URL=https://your-resource.openai.azure.com/openai/deployments/your-deployment/v1
-export OPENAI_MODEL=gpt-4o
-```
-
----
-
-## Environment Variables
-
-| Variable | Required | Description |
-|----------|----------|-------------|
-| `CLAUDE_CODE_USE_OPENAI` | Yes | Set to `1` to enable the OpenAI provider |
-| `OPENAI_API_KEY` | Yes* | Your API key (*not needed for local models like Ollama) |
-| `OPENAI_MODEL` | Yes | Model name (e.g. `gpt-4o`, `deepseek-chat`, `llama3.3:70b`) |
-| `OPENAI_BASE_URL` | No | API endpoint (defaults to `https://api.openai.com/v1`) |
-| `CODEX_API_KEY` | Codex only | Codex/ChatGPT access token override |
-| `CODEX_AUTH_JSON_PATH` | Codex only | Path to a Codex CLI `auth.json` file |
-| `CODEX_HOME` | Codex only | Alternative Codex home directory (`auth.json` will be read from here) |
-| `OPENCLAUDE_DISABLE_CO_AUTHORED_BY` | No | Set to `1` to suppress the default `Co-Authored-By` trailer in generated git commit messages |
-
-You can also use `ANTHROPIC_MODEL` to override the model name. `OPENAI_MODEL` takes priority.
-
-OpenClaude PR bodies use OpenClaude branding by default. `OPENCLAUDE_DISABLE_CO_AUTHORED_BY` only affects the commit trailer, not PR attribution text.
-
----
-
-## Runtime Hardening
-
-Use these commands to keep the CLI stable and catch environment mistakes early:
-
-```bash
-# quick startup sanity check
-bun run smoke
-
-# validate provider env + reachability
-bun run doctor:runtime
-
-# print machine-readable runtime diagnostics
-bun run doctor:runtime:json
-
-# persist a diagnostics report to reports/doctor-runtime.json
-bun run doctor:report
-
-# full local hardening check (smoke + runtime doctor)
-bun run hardening:check
-
-# strict hardening (includes project-wide typecheck)
-bun run hardening:strict
-```
-
-Notes:
-- `doctor:runtime` fails fast if `CLAUDE_CODE_USE_OPENAI=1` with a placeholder key (`SUA_CHAVE`) or a missing key for non-local providers.
-- Local providers (for example `http://localhost:11434/v1`) can run without `OPENAI_API_KEY`.
-- Codex profiles validate `CODEX_API_KEY` or the Codex CLI auth file and probe `POST /responses` instead of `GET /models`.
-
-### Provider Launch Profiles
-
-Use profile launchers to avoid repeated environment setup:
-
-```bash
-# one-time profile bootstrap (prefer viable local Ollama, otherwise OpenAI)
-bun run profile:init
-
-# preview the best provider/model for your goal
-bun run profile:recommend -- --goal coding --benchmark
-
-# auto-apply the best available local/openai provider/model for your goal
-bun run profile:auto -- --goal latency
-
-# codex bootstrap (defaults to codexplan and ~/.codex/auth.json)
-bun run profile:codex
-
-# openai bootstrap with explicit key
-bun run profile:init -- --provider openai --api-key sk-...
-
-# ollama bootstrap with custom model
-bun run profile:init -- --provider ollama --model llama3.1:8b
-
-# ollama bootstrap with intelligent model auto-selection
-bun run profile:init -- --provider ollama --goal coding
-
-# codex bootstrap with a fast model alias
-bun run profile:init -- --provider codex --model codexspark
-
-# launch using persisted profile (.openclaude-profile.json)
-bun run dev:profile
-
-# codex profile (uses CODEX_API_KEY or ~/.codex/auth.json)
-bun run dev:codex
-
-# OpenAI profile (requires OPENAI_API_KEY in your shell)
-bun run dev:openai
-
-# Ollama profile (defaults: localhost:11434, llama3.1:8b)
-bun run dev:ollama
-```
-
-`profile:recommend` ranks installed Ollama models for `latency`, `balanced`, or `coding`, and `profile:auto` can persist the recommendation directly.
-If no profile exists yet, `dev:profile` now uses the same goal-aware defaults when picking the initial model.
-
-Use `--provider ollama` when you want a local-only path. Auto mode falls back to OpenAI when no viable local chat model is installed.
-Goal-based Ollama selection only recommends among models that are already installed and reachable from Ollama.
-
-Use `profile:codex` or `--provider codex` when you want the ChatGPT Codex backend.
-
-`dev:openai`, `dev:ollama`, and `dev:codex` run `doctor:runtime` first and only launch the app if checks pass.
-For `dev:ollama`, make sure Ollama is running locally before launch.
+Best if you want local inference on Apple Silicon with Atomic Chat. See [Advanced Setup](docs/advanced-setup.md).
 
 ---
 
diff --git a/atomic_chat_provider.py b/atomic_chat_provider.py
new file mode 100644
index 00000000..bf55155f
--- /dev/null
+++ b/atomic_chat_provider.py
@@ -0,0 +1,146 @@
+"""
+atomic_chat_provider.py
+-----------------------
+Adds native Atomic Chat support to openclaude.
+Lets Claude Code route requests to any locally-running model via
+Atomic Chat (Apple Silicon only) at 127.0.0.1:1337.
+
+Atomic Chat exposes an OpenAI-compatible API, so messages are forwarded
+directly without translation.
+
+Usage (.env):
+    PREFERRED_PROVIDER=atomic-chat
+    ATOMIC_CHAT_BASE_URL=http://127.0.0.1:1337
+"""
+
+import httpx
+import json
+import logging
+import os
+from typing import AsyncIterator
+
+logger = logging.getLogger(__name__)
+ATOMIC_CHAT_BASE_URL = os.getenv("ATOMIC_CHAT_BASE_URL", "http://127.0.0.1:1337")
+
+
+def _api_url(path: str) -> str:
+    return f"{ATOMIC_CHAT_BASE_URL}/v1{path}"
+
+
+async def check_atomic_chat_running() -> bool:
+    try:
+        async with httpx.AsyncClient(timeout=3.0) as client:
+            resp = await client.get(_api_url("/models"))
+            return resp.status_code == 200
+    except Exception:
+        return False
+
+
+async def list_atomic_chat_models() -> list[str]:
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            resp = await client.get(_api_url("/models"))
+            resp.raise_for_status()
+            data = resp.json()
+            return [m["id"] for m in data.get("data", [])]
+    except Exception as e:
+        logger.warning(f"Could not list Atomic Chat models: {e}")
+        return []
+
+
+async def atomic_chat(
+    model: str,
+    messages: list[dict],
+    system: str | None = None,
+    max_tokens: int = 4096,
+    temperature: float = 1.0,
+) -> dict:
+    chat_messages = list(messages)
+    if system:
+        chat_messages.insert(0, {"role": "system", "content": system})
+
+    payload = {
+        "model": model,
+        "messages": chat_messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "stream": False,
+    }
+
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        resp = await client.post(_api_url("/chat/completions"), json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+
+    choice = data.get("choices", [{}])[0]
+    assistant_text = choice.get("message", {}).get("content", "")
+    usage = data.get("usage", {})
+
+    return {
+        "id": data.get("id", "msg_atomic_chat"),
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "text", "text": assistant_text}],
+        "model": model,
+        "stop_reason": "end_turn",
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": usage.get("prompt_tokens", 0),
+            "output_tokens": usage.get("completion_tokens", 0),
+        },
+    }
+
+
+async def atomic_chat_stream(
+    model: str,
+    messages: list[dict],
+    system: str | None = None,
+    max_tokens: int = 4096,
+    temperature: float = 1.0,
+) -> AsyncIterator[str]:
+    chat_messages = list(messages)
+    if system:
+        chat_messages.insert(0, {"role": "system", "content": system})
+
+    payload = {
+        "model": model,
+        "messages": chat_messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "stream": True,
+    }
+
+    yield "event: message_start\n"
+    yield f'data: {json.dumps({"type": "message_start", "message": {"id": "msg_atomic_chat_stream", "type": "message", "role": "assistant", "content": [], "model": model, "stop_reason": None, "usage": {"input_tokens": 0, "output_tokens": 0}}})}\n\n'
+    yield "event: content_block_start\n"
+    yield f'data: {json.dumps({"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}})}\n\n'
+
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        async with client.stream("POST", _api_url("/chat/completions"), json=payload) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                raw = line[len("data: "):]
+                if raw.strip() == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(raw)
+                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                    delta_text = delta.get("content", "")
+                    if delta_text:
+                        yield "event: content_block_delta\n"
+                        yield f'data: {json.dumps({"type": "content_block_delta", "index": 0, "delta": {"type": "text_delta", "text": delta_text}})}\n\n'
+
+                    finish_reason = chunk.get("choices", [{}])[0].get("finish_reason")
+                    if finish_reason:
+                        usage = chunk.get("usage", {})
+                        yield "event: content_block_stop\n"
+                        yield f'data: {json.dumps({"type": "content_block_stop", "index": 0})}\n\n'
+                        yield "event: message_delta\n"
+                        yield f'data: {json.dumps({"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": None}, "usage": {"output_tokens": usage.get("completion_tokens", 0)}})}\n\n'
+                        yield "event: message_stop\n"
+                        yield f'data: {json.dumps({"type": "message_stop"})}\n\n'
+                        break
+                except json.JSONDecodeError:
+                    continue
diff --git a/docs/advanced-setup.md b/docs/advanced-setup.md
new file mode 100644
index 00000000..42495fe3
--- /dev/null
+++ b/docs/advanced-setup.md
@@ -0,0 +1,262 @@
+# OpenClaude Advanced Setup
+
+This guide is for users who want source builds, Bun workflows, provider profiles, diagnostics, or more control over runtime behavior.
+
+## Install Options
+
+### Option A: npm
+
+```bash
+npm install -g @gitlawb/openclaude
+```
+
+### Option B: From source with Bun
+
+Use Bun `1.3.11` or newer for source builds on Windows. Older Bun versions can fail during `bun run build`.
+
+```bash
+git clone https://node.gitlawb.com/z6MkqDnb7Siv3Cwj7pGJq4T5EsUisECqR8KpnDLwcaZq5TPr/openclaude.git
+cd openclaude
+
+bun install
+bun run build
+npm link
+```
+
+### Option C: Run directly with Bun
+
+```bash
+git clone https://node.gitlawb.com/z6MkqDnb7Siv3Cwj7pGJq4T5EsUisECqR8KpnDLwcaZq5TPr/openclaude.git
+cd openclaude
+
+bun install
+bun run dev
+```
+
+## Provider Examples
+
+### OpenAI
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=sk-...
+export OPENAI_MODEL=gpt-4o
+```
+
+### Codex via ChatGPT auth
+
+`codexplan` maps to GPT-5.4 on the Codex backend with high reasoning.
+`codexspark` maps to GPT-5.3 Codex Spark for faster loops.
+
+If you already use the Codex CLI, OpenClaude reads `~/.codex/auth.json` automatically. You can also point it elsewhere with `CODEX_AUTH_JSON_PATH` or override the token directly with `CODEX_API_KEY`.
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_MODEL=codexplan
+
+# optional if you do not already have ~/.codex/auth.json
+export CODEX_API_KEY=...
+
+openclaude
+```
+
+### DeepSeek
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=sk-...
+export OPENAI_BASE_URL=https://api.deepseek.com/v1
+export OPENAI_MODEL=deepseek-chat
+```
+
+### Google Gemini via OpenRouter
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=sk-or-...
+export OPENAI_BASE_URL=https://openrouter.ai/api/v1
+export OPENAI_MODEL=google/gemini-2.0-flash-001
+```
+
+OpenRouter model availability changes over time. If a model stops working, try another current OpenRouter model before assuming the integration is broken.
+
+### Ollama
+
+```bash
+ollama pull llama3.3:70b
+
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_BASE_URL=http://localhost:11434/v1
+export OPENAI_MODEL=llama3.3:70b
+```
+
+### Atomic Chat (local, Apple Silicon)
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_BASE_URL=http://127.0.0.1:1337/v1
+export OPENAI_MODEL=your-model-name
+```
+
+No API key is needed for Atomic Chat local models.
+
+Or use the profile launcher:
+
+```bash
+bun run dev:atomic-chat
+```
+
+Download Atomic Chat from [atomic.chat](https://atomic.chat/). The app must be running with a model loaded before launching.
+
+### LM Studio
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_BASE_URL=http://localhost:1234/v1
+export OPENAI_MODEL=your-model-name
+```
+
+### Together AI
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=...
+export OPENAI_BASE_URL=https://api.together.xyz/v1
+export OPENAI_MODEL=meta-llama/Llama-3.3-70B-Instruct-Turbo
+```
+
+### Groq
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=gsk_...
+export OPENAI_BASE_URL=https://api.groq.com/openai/v1
+export OPENAI_MODEL=llama-3.3-70b-versatile
+```
+
+### Mistral
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=...
+export OPENAI_BASE_URL=https://api.mistral.ai/v1
+export OPENAI_MODEL=mistral-large-latest
+```
+
+### Azure OpenAI
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=your-azure-key
+export OPENAI_BASE_URL=https://your-resource.openai.azure.com/openai/deployments/your-deployment/v1
+export OPENAI_MODEL=gpt-4o
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `CLAUDE_CODE_USE_OPENAI` | Yes | Set to `1` to enable the OpenAI provider |
+| `OPENAI_API_KEY` | Yes* | Your API key (`*` not needed for local models like Ollama or Atomic Chat) |
+| `OPENAI_MODEL` | Yes | Model name such as `gpt-4o`, `deepseek-chat`, or `llama3.3:70b` |
+| `OPENAI_BASE_URL` | No | API endpoint, defaulting to `https://api.openai.com/v1` |
+| `CODEX_API_KEY` | Codex only | Codex or ChatGPT access token override |
+| `CODEX_AUTH_JSON_PATH` | Codex only | Path to a Codex CLI `auth.json` file |
+| `CODEX_HOME` | Codex only | Alternative Codex home directory |
+| `OPENCLAUDE_DISABLE_CO_AUTHORED_BY` | No | Suppress the default `Co-Authored-By` trailer in generated git commits |
+
+You can also use `ANTHROPIC_MODEL` to override the model name. `OPENAI_MODEL` takes priority.
+
+## Runtime Hardening
+
+Use these commands to validate your setup and catch mistakes early:
+
+```bash
+# quick startup sanity check
+bun run smoke
+
+# validate provider env + reachability
+bun run doctor:runtime
+
+# print machine-readable runtime diagnostics
+bun run doctor:runtime:json
+
+# persist a diagnostics report to reports/doctor-runtime.json
+bun run doctor:report
+
+# full local hardening check (smoke + runtime doctor)
+bun run hardening:check
+
+# strict hardening (includes project-wide typecheck)
+bun run hardening:strict
+```
+
+Notes:
+
+- `doctor:runtime` fails fast if `CLAUDE_CODE_USE_OPENAI=1` with a placeholder key or a missing key for non-local providers.
+- Local providers such as `http://localhost:11434/v1` and `http://127.0.0.1:1337/v1` can run without `OPENAI_API_KEY`.
+- Codex profiles validate `CODEX_API_KEY` or the Codex CLI auth file and probe `POST /responses` instead of `GET /models`.
+
+## Provider Launch Profiles
+
+Use profile launchers to avoid repeated environment setup:
+
+```bash
+# one-time profile bootstrap (prefer viable local Ollama, otherwise OpenAI)
+bun run profile:init
+
+# preview the best provider/model for your goal
+bun run profile:recommend -- --goal coding --benchmark
+
+# auto-apply the best available local/openai provider/model for your goal
+bun run profile:auto -- --goal latency
+
+# codex bootstrap (defaults to codexplan and ~/.codex/auth.json)
+bun run profile:codex
+
+# openai bootstrap with explicit key
+bun run profile:init -- --provider openai --api-key sk-...
+
+# ollama bootstrap with custom model
+bun run profile:init -- --provider ollama --model llama3.1:8b
+
+# ollama bootstrap with intelligent model auto-selection
+bun run profile:init -- --provider ollama --goal coding
+
+# atomic-chat bootstrap (auto-detects running model)
+bun run profile:init -- --provider atomic-chat
+
+# codex bootstrap with a fast model alias
+bun run profile:init -- --provider codex --model codexspark
+
+# launch using persisted profile (.openclaude-profile.json)
+bun run dev:profile
+
+# codex profile (uses CODEX_API_KEY or ~/.codex/auth.json)
+bun run dev:codex
+
+# OpenAI profile (requires OPENAI_API_KEY in your shell)
+bun run dev:openai
+
+# Ollama profile (defaults: localhost:11434, llama3.1:8b)
+bun run dev:ollama
+
+# Atomic Chat profile (Apple Silicon local LLMs at 127.0.0.1:1337)
+bun run dev:atomic-chat
+```
+
+`profile:recommend` ranks installed Ollama models for `latency`, `balanced`, or `coding`, and `profile:auto` can persist the recommendation directly.
+
+If no profile exists yet, `dev:profile` uses the same goal-aware defaults when picking the initial model.
+
+Use `--provider ollama` when you want a local-only path. Auto mode falls back to OpenAI when no viable local chat model is installed.
+
+Use `--provider atomic-chat` when you want Atomic Chat as the local Apple Silicon provider.
+
+Use `profile:codex` or `--provider codex` when you want the ChatGPT Codex backend.
+
+`dev:openai`, `dev:ollama`, `dev:atomic-chat`, and `dev:codex` run `doctor:runtime` first and only launch the app if checks pass.
+
+For `dev:ollama`, make sure Ollama is running locally before launch.
+
+For `dev:atomic-chat`, make sure Atomic Chat is running with a model loaded before launch.
diff --git a/docs/non-technical-setup.md b/docs/non-technical-setup.md
new file mode 100644
index 00000000..9efca0f6
--- /dev/null
+++ b/docs/non-technical-setup.md
@@ -0,0 +1,116 @@
+# OpenClaude for Non-Technical Users
+
+This guide is for people who want the easiest setup path.
+
+You do not need to build from source. You do not need Bun. You do not need to understand the full codebase.
+
+If you can copy and paste commands into a terminal, you can set this up.
+
+## What OpenClaude Does
+
+OpenClaude lets you use an AI coding assistant with different model providers such as:
+
+- OpenAI
+- DeepSeek
+- Gemini
+- Ollama
+- Codex
+
+For most first-time users, OpenAI is the easiest option.
+
+## Before You Start
+
+You need:
+
+1. Node.js 20 or newer installed
+2. A terminal window
+3. An API key from your provider, unless you are using a local model like Ollama
+
+## Fastest Path
+
+1. Install OpenClaude with npm
+2. Set 3 environment variables
+3. Run `openclaude`
+
+## Choose Your Operating System
+
+- Windows: [Windows Quick Start](quick-start-windows.md)
+- macOS / Linux: [macOS / Linux Quick Start](quick-start-mac-linux.md)
+
+## Which Provider Should You Choose?
+
+### OpenAI
+
+Choose this if:
+
+- you want the easiest setup
+- you already have an OpenAI API key
+
+### Ollama
+
+Choose this if:
+
+- you want to run models locally
+- you do not want to depend on a cloud API for testing
+
+### Codex
+
+Choose this if:
+
+- you already use the Codex CLI
+- you already have Codex or ChatGPT auth configured
+
+## What Success Looks Like
+
+After you run `openclaude`, the CLI should start and wait for your prompt.
+
+At that point, you can ask it to:
+
+- explain code
+- edit files
+- run commands
+- review changes
+
+## Common Problems
+
+### `openclaude` command not found
+
+Cause:
+
+- npm installed the package, but your terminal has not refreshed yet
+
+Fix:
+
+1. Close the terminal
+2. Open a new terminal
+3. Run `openclaude` again
+
+### Invalid API key
+
+Cause:
+
+- the key is wrong, expired, or copied incorrectly
+
+Fix:
+
+1. Get a fresh key from your provider
+2. Paste it again carefully
+3. Re-run `openclaude`
+
+### Ollama not working
+
+Cause:
+
+- Ollama is not installed or not running
+
+Fix:
+
+1. Install Ollama from `https://ollama.com/download`
+2. Start Ollama
+3. Try again
+
+## Want More Control?
+
+If you want source builds, advanced provider profiles, diagnostics, or Bun-based workflows, use:
+
+- [Advanced Setup](advanced-setup.md)
diff --git a/docs/quick-start-mac-linux.md b/docs/quick-start-mac-linux.md
new file mode 100644
index 00000000..7e8cb96e
--- /dev/null
+++ b/docs/quick-start-mac-linux.md
@@ -0,0 +1,108 @@
+# OpenClaude Quick Start for macOS and Linux
+
+This guide uses a standard shell such as Terminal, iTerm, bash, or zsh.
+
+## 1. Install Node.js
+
+Install Node.js 20 or newer from:
+
+- `https://nodejs.org/`
+
+Then check it:
+
+```bash
+node --version
+npm --version
+```
+
+## 2. Install OpenClaude
+
+```bash
+npm install -g @gitlawb/openclaude
+```
+
+## 3. Pick One Provider
+
+### Option A: OpenAI
+
+Replace `sk-your-key-here` with your real key.
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=sk-your-key-here
+export OPENAI_MODEL=gpt-4o
+
+openclaude
+```
+
+### Option B: DeepSeek
+
+```bash
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_API_KEY=sk-your-key-here
+export OPENAI_BASE_URL=https://api.deepseek.com/v1
+export OPENAI_MODEL=deepseek-chat
+
+openclaude
+```
+
+### Option C: Ollama
+
+Install Ollama first from:
+
+- `https://ollama.com/download`
+
+Then run:
+
+```bash
+ollama pull llama3.1:8b
+
+export CLAUDE_CODE_USE_OPENAI=1
+export OPENAI_BASE_URL=http://localhost:11434/v1
+export OPENAI_MODEL=llama3.1:8b
+
+openclaude
+```
+
+No API key is needed for Ollama local models.
+
+## 4. If `openclaude` Is Not Found
+
+Close the terminal, open a new one, and try again:
+
+```bash
+openclaude
+```
+
+## 5. If Your Provider Fails
+
+Check the basics:
+
+### For OpenAI or DeepSeek
+
+- make sure the key is real
+- make sure you copied it fully
+
+### For Ollama
+
+- make sure Ollama is installed
+- make sure Ollama is running
+- make sure the model was pulled successfully
+
+## 6. Updating OpenClaude
+
+```bash
+npm install -g @gitlawb/openclaude@latest
+```
+
+## 7. Uninstalling OpenClaude
+
+```bash
+npm uninstall -g @gitlawb/openclaude
+```
+
+## Need Advanced Setup?
+
+Use:
+
+- [Advanced Setup](advanced-setup.md)
diff --git a/docs/quick-start-windows.md b/docs/quick-start-windows.md
new file mode 100644
index 00000000..dfac8782
--- /dev/null
+++ b/docs/quick-start-windows.md
@@ -0,0 +1,108 @@
+# OpenClaude Quick Start for Windows
+
+This guide uses Windows PowerShell.
+
+## 1. Install Node.js
+
+Install Node.js 20 or newer from:
+
+- `https://nodejs.org/`
+
+Then open PowerShell and check it:
+
+```powershell
+node --version
+npm --version
+```
+
+## 2. Install OpenClaude
+
+```powershell
+npm install -g @gitlawb/openclaude
+```
+
+## 3. Pick One Provider
+
+### Option A: OpenAI
+
+Replace `sk-your-key-here` with your real key.
+
+```powershell
+$env:CLAUDE_CODE_USE_OPENAI="1"
+$env:OPENAI_API_KEY="sk-your-key-here"
+$env:OPENAI_MODEL="gpt-4o"
+
+openclaude
+```
+
+### Option B: DeepSeek
+
+```powershell
+$env:CLAUDE_CODE_USE_OPENAI="1"
+$env:OPENAI_API_KEY="sk-your-key-here"
+$env:OPENAI_BASE_URL="https://api.deepseek.com/v1"
+$env:OPENAI_MODEL="deepseek-chat"
+
+openclaude
+```
+
+### Option C: Ollama
+
+Install Ollama first from:
+
+- `https://ollama.com/download/windows`
+
+Then run:
+
+```powershell
+ollama pull llama3.1:8b
+
+$env:CLAUDE_CODE_USE_OPENAI="1"
+$env:OPENAI_BASE_URL="http://localhost:11434/v1"
+$env:OPENAI_MODEL="llama3.1:8b"
+
+openclaude
+```
+
+No API key is needed for Ollama local models.
+
+## 4. If `openclaude` Is Not Found
+
+Close PowerShell, open a new one, and try again:
+
+```powershell
+openclaude
+```
+
+## 5. If Your Provider Fails
+
+Check the basics:
+
+### For OpenAI or DeepSeek
+
+- make sure the key is real
+- make sure you copied it fully
+
+### For Ollama
+
+- make sure Ollama is installed
+- make sure Ollama is running
+- make sure the model was pulled successfully
+
+## 6. Updating OpenClaude
+
+```powershell
+npm install -g @gitlawb/openclaude@latest
+```
+
+## 7. Uninstalling OpenClaude
+
+```powershell
+npm uninstall -g @gitlawb/openclaude
+```
+
+## Need Advanced Setup?
+
+Use:
+
+- [Advanced Setup](advanced-setup.md)
diff --git a/package.json b/package.json
index 5f5351b8..ceab906a 100644
--- a/package.json
+++ b/package.json
@@ -21,6 +21,7 @@
     "dev:gemini": "bun run scripts/provider-launch.ts gemini",
     "dev:ollama": "bun run scripts/provider-launch.ts ollama",
     "dev:ollama:fast": "bun run scripts/provider-launch.ts ollama --fast --bare",
+    "dev:atomic-chat": "bun run scripts/provider-launch.ts atomic-chat",
     "profile:init": "bun run scripts/provider-bootstrap.ts",
     "profile:recommend": "bun run scripts/provider-recommend.ts",
     "profile:auto": "bun run scripts/provider-recommend.ts --apply",
@@ -30,7 +31,7 @@
     "dev:fast": "bun run profile:fast && bun run dev:ollama:fast",
     "dev:code": "bun run profile:code && bun run dev:profile",
     "start": "node dist/cli.mjs",
-    "test:provider-recommendation": "node --test --experimental-strip-types src/utils/providerRecommendation.test.ts src/utils/providerProfile.test.ts",
+    "test:provider-recommendation": "bun test src/utils/providerRecommendation.test.ts src/utils/providerProfile.test.ts",
     "typecheck": "tsc --noEmit",
     "smoke": "bun run build && node dist/cli.mjs --version",
     "test:provider": "bun test src/services/api/*.test.ts src/utils/context.test.ts",
diff --git a/scripts/provider-bootstrap.ts b/scripts/provider-bootstrap.ts
index ad3f9bd3..578c7267 100644
--- a/scripts/provider-bootstrap.ts
+++ b/scripts/provider-bootstrap.ts
@@ -1,6 +1,4 @@
 // @ts-nocheck
-import { writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
 import {
   resolveCodexApiCredentials,
 } from '../src/services/api/providerConfig.js'
@@ -10,18 +8,23 @@ import {
   recommendOllamaModel,
 } from '../src/utils/providerRecommendation.ts'
 import {
+  buildAtomicChatProfileEnv,
   buildCodexProfileEnv,
   buildGeminiProfileEnv,
   buildOllamaProfileEnv,
   buildOpenAIProfileEnv,
   createProfileFile,
+  saveProfileFile,
   selectAutoProfile,
   type ProfileFile,
   type ProviderProfile,
 } from '../src/utils/providerProfile.ts'
 import {
+  getAtomicChatChatBaseUrl,
   getOllamaChatBaseUrl,
+  hasLocalAtomicChat,
   hasLocalOllama,
+  listAtomicChatModels,
   listOllamaModels,
 } from './provider-discovery.ts'
 
@@ -34,7 +37,7 @@ function parseArg(name: string): string | null {
 
 function parseProviderArg(): ProviderProfile | 'auto' {
   const p = parseArg('--provider')?.toLowerCase()
-  if (p === 'openai' || p === 'ollama' || p === 'codex' || p === 'gemini') return p
+  if (p === 'openai' || p === 'ollama' || p === 'codex' || p === 'gemini' || p === 'atomic-chat') return p
   return 'auto'
 }
 
@@ -102,6 +105,21 @@ async function main(): Promise<void> {
         getOllamaChatBaseUrl,
       },
     )
+  } else if (selected === 'atomic-chat') {
+    const model = argModel || (await listAtomicChatModels(argBaseUrl || undefined))[0]
+    if (!model) {
+      if (!(await hasLocalAtomicChat(argBaseUrl || undefined))) {
+        console.error('Atomic Chat is not running (could not connect to 127.0.0.1:1337).\n  Download from https://atomic.chat/ and launch the application.')
+      } else {
+        console.error('Atomic Chat is running but no model is loaded. Open Atomic Chat and download or start a model first.')
+      }
+      process.exit(1)
+    }
+
+    env = buildAtomicChatProfileEnv(model, {
+      baseUrl: argBaseUrl,
+      getAtomicChatChatBaseUrl,
+    })
   } else if (selected === 'codex') {
     const builtEnv = buildCodexProfileEnv({
       model: argModel,
@@ -147,8 +165,7 @@ async function main(): Promise<void> {
 
   const profile = createProfileFile(selected, env)
 
-  const outputPath = resolve(process.cwd(), '.openclaude-profile.json')
-  writeFileSync(outputPath, JSON.stringify(profile, null, 2), { encoding: 'utf8', mode: 0o600 })
+  const outputPath = saveProfileFile(profile)
 
   console.log(`Saved profile: ${selected}`)
   console.log(`Goal: ${goal}`)
diff --git a/scripts/provider-discovery.ts b/scripts/provider-discovery.ts
index 9e3aacda..fae4342d 100644
--- a/scripts/provider-discovery.ts
+++ b/scripts/provider-discovery.ts
@@ -1,129 +1,13 @@
-import type { OllamaModelDescriptor } from '../src/utils/providerRecommendation.ts'
-
-export const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434'
-
-function withTimeoutSignal(timeoutMs: number): {
-  signal: AbortSignal
-  clear: () => void
-} {
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), timeoutMs)
-  return {
-    signal: controller.signal,
-    clear: () => clearTimeout(timeout),
-  }
-}
-
-function trimTrailingSlash(value: string): string {
-  return value.replace(/\/+$/, '')
-}
-
-export function getOllamaApiBaseUrl(baseUrl?: string): string {
-  const parsed = new URL(
-    baseUrl || process.env.OLLAMA_BASE_URL || DEFAULT_OLLAMA_BASE_URL,
-  )
-  const pathname = trimTrailingSlash(parsed.pathname)
-  parsed.pathname = pathname.endsWith('/v1')
-    ? pathname.slice(0, -3) || '/'
-    : pathname || '/'
-  parsed.search = ''
-  parsed.hash = ''
-  return trimTrailingSlash(parsed.toString())
-}
-
-export function getOllamaChatBaseUrl(baseUrl?: string): string {
-  return `${getOllamaApiBaseUrl(baseUrl)}/v1`
-}
-
-export async function hasLocalOllama(baseUrl?: string): Promise<boolean> {
-  const { signal, clear } = withTimeoutSignal(1200)
-  try {
-    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/tags`, {
-      method: 'GET',
-      signal,
-    })
-    return response.ok
-  } catch {
-    return false
-  } finally {
-    clear()
-  }
-}
-
-export async function listOllamaModels(
-  baseUrl?: string,
-): Promise<OllamaModelDescriptor[]> {
-  const { signal, clear } = withTimeoutSignal(5000)
-  try {
-    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/tags`, {
-      method: 'GET',
-      signal,
-    })
-    if (!response.ok) {
-      return []
-    }
-
-    const data = await response.json() as {
-      models?: Array<{
-        name?: string
-        size?: number
-        details?: {
-          family?: string
-          families?: string[]
-          parameter_size?: string
-          quantization_level?: string
-        }
-      }>
-    }
-
-    return (data.models ?? [])
-      .filter(model => Boolean(model.name))
-      .map(model => ({
-        name: model.name!,
-        sizeBytes: typeof model.size === 'number' ? model.size : null,
-        family: model.details?.family ?? null,
-        families: model.details?.families ?? [],
-        parameterSize: model.details?.parameter_size ?? null,
-        quantizationLevel: model.details?.quantization_level ?? null,
-      }))
-  } catch {
-    return []
-  } finally {
-    clear()
-  }
-}
-
-export async function benchmarkOllamaModel(
-  modelName: string,
-  baseUrl?: string,
-): Promise<number | null> {
-  const start = Date.now()
-  const { signal, clear } = withTimeoutSignal(20000)
-  try {
-    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/chat`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      signal,
-      body: JSON.stringify({
-        model: modelName,
-        stream: false,
-        messages: [{ role: 'user', content: 'Reply with OK.' }],
-        options: {
-          temperature: 0,
-          num_predict: 8,
-        },
-      }),
-    })
-    if (!response.ok) {
-      return null
-    }
-    await response.json()
-    return Date.now() - start
-  } catch {
-    return null
-  } finally {
-    clear()
-  }
-}
+export {
+  benchmarkOllamaModel,
+  DEFAULT_ATOMIC_CHAT_BASE_URL,
+  DEFAULT_OLLAMA_BASE_URL,
+  getAtomicChatApiBaseUrl,
+  getAtomicChatChatBaseUrl,
+  getOllamaApiBaseUrl,
+  getOllamaChatBaseUrl,
+  hasLocalAtomicChat,
+  hasLocalOllama,
+  listAtomicChatModels,
+  listOllamaModels,
+} from '../src/utils/providerDiscovery.ts'
diff --git a/scripts/provider-launch.ts b/scripts/provider-launch.ts
index 2859e9e8..106a42fb 100644
--- a/scripts/provider-launch.ts
+++ b/scripts/provider-launch.ts
@@ -1,7 +1,5 @@
 // @ts-nocheck
 import { spawn } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
 import {
   resolveCodexApiCredentials,
 } from '../src/services/api/providerConfig.js'
@@ -11,13 +9,17 @@ import {
 } from '../src/utils/providerRecommendation.ts'
 import {
   buildLaunchEnv,
+  loadProfileFile,
   selectAutoProfile,
   type ProfileFile,
   type ProviderProfile,
 } from '../src/utils/providerProfile.ts'
 import {
+  getAtomicChatChatBaseUrl,
   getOllamaChatBaseUrl,
+  hasLocalAtomicChat,
   hasLocalOllama,
+  listAtomicChatModels,
   listOllamaModels,
 } from './provider-discovery.ts'
 
@@ -48,7 +50,7 @@ function parseLaunchOptions(argv: string[]): LaunchOptions {
       continue
     }
 
-    if ((lower === 'auto' || lower === 'openai' || lower === 'ollama' || lower === 'codex' || lower === 'gemini') && requestedProfile === 'auto') {
+    if ((lower === 'auto' || lower === 'openai' || lower === 'ollama' || lower === 'codex' || lower === 'gemini' || lower === 'atomic-chat') && requestedProfile === 'auto') {
       requestedProfile = lower as ProviderProfile | 'auto'
       continue
     }
@@ -75,17 +77,7 @@ function parseLaunchOptions(argv: string[]): LaunchOptions {
 }
 
 function loadPersistedProfile(): ProfileFile | null {
-  const path = resolve(process.cwd(), '.openclaude-profile.json')
-  if (!existsSync(path)) return null
-  try {
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as ProfileFile
-    if (parsed.profile === 'openai' || parsed.profile === 'ollama' || parsed.profile === 'codex' || parsed.profile === 'gemini') {
-      return parsed
-    }
-    return null
-  } catch {
-    return null
-  }
+  return loadProfileFile()
 }
 
 async function resolveOllamaDefaultModel(
@@ -96,6 +88,11 @@ async function resolveOllamaDefaultModel(
   return recommended?.name ?? null
 }
 
+async function resolveAtomicChatDefaultModel(): Promise<string | null> {
+  const models = await listAtomicChatModels()
+  return models[0] ?? null
+}
+
 function runCommand(command: string, env: NodeJS.ProcessEnv): Promise<number> {
   return runProcess(command, [], env)
 }
@@ -132,6 +129,10 @@ function printSummary(profile: ProviderProfile, env: NodeJS.ProcessEnv): void {
     console.log(`OPENAI_BASE_URL=${env.OPENAI_BASE_URL}`)
     console.log(`OPENAI_MODEL=${env.OPENAI_MODEL}`)
     console.log(`CODEX_API_KEY_SET=${Boolean(resolveCodexApiCredentials(env).apiKey)}`)
+  } else if (profile === 'atomic-chat') {
+    console.log(`OPENAI_BASE_URL=${env.OPENAI_BASE_URL}`)
+    console.log(`OPENAI_MODEL=${env.OPENAI_MODEL}`)
+    console.log('OPENAI_API_KEY_SET=false (local provider, no key required)')
   } else {
     console.log(`OPENAI_BASE_URL=${env.OPENAI_BASE_URL}`)
     console.log(`OPENAI_MODEL=${env.OPENAI_MODEL}`)
@@ -143,7 +144,7 @@ async function main(): Promise<void> {
   const options = parseLaunchOptions(process.argv.slice(2))
   const requestedProfile = options.requestedProfile
   if (!requestedProfile) {
-    console.error('Usage: bun run scripts/provider-launch.ts [openai|ollama|codex|gemini|auto] [--fast] [--goal <latency|balanced|coding>] [-- <cli args>]')
+    console.error('Usage: bun run scripts/provider-launch.ts [openai|ollama|codex|gemini|atomic-chat|auto] [--fast] [--goal <latency|balanced|coding>] [-- <cli args>]')
     process.exit(1)
   }
 
@@ -175,12 +176,30 @@ async function main(): Promise<void> {
     }
   }
 
+  let resolvedAtomicChatModel: string | null = null
+  if (
+    profile === 'atomic-chat' &&
+    (persisted?.profile !== 'atomic-chat' || !persisted?.env?.OPENAI_MODEL)
+  ) {
+    if (!(await hasLocalAtomicChat())) {
+      console.error('Atomic Chat is not running (could not connect to 127.0.0.1:1337).\n  Download from https://atomic.chat/ and launch the application.')
+      process.exit(1)
+    }
+    resolvedAtomicChatModel = await resolveAtomicChatDefaultModel()
+    if (!resolvedAtomicChatModel) {
+      console.error('Atomic Chat is running but no model is loaded. Open Atomic Chat and download or start a model first.')
+      process.exit(1)
+    }
+  }
+
   const env = await buildLaunchEnv({
     profile,
     persisted,
     goal: options.goal,
     getOllamaChatBaseUrl,
     resolveOllamaDefaultModel: async () => resolvedOllamaModel || 'llama3.1:8b',
+    getAtomicChatChatBaseUrl,
+    resolveAtomicChatDefaultModel: async () => resolvedAtomicChatModel,
   })
   if (options.fast) {
     applyFastFlags(env)
diff --git a/scripts/provider-recommend.ts b/scripts/provider-recommend.ts
index eca811e6..8dc23835 100644
--- a/scripts/provider-recommend.ts
+++ b/scripts/provider-recommend.ts
@@ -1,6 +1,4 @@
 // @ts-nocheck
-import { writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
 
 import {
   applyBenchmarkLatency,
@@ -16,6 +14,7 @@ import {
   buildOllamaProfileEnv,
   buildOpenAIProfileEnv,
   createProfileFile,
+  saveProfileFile,
   sanitizeApiKey,
   type ProfileFile,
   type ProviderProfile,
@@ -153,11 +152,7 @@ async function maybeApplyProfile(
 
   const profileFile = createProfileFile(profile, env)
 
-  writeFileSync(
-    resolve(process.cwd(), '.openclaude-profile.json'),
-    JSON.stringify(profileFile, null, 2),
-    'utf8',
-  )
+  saveProfileFile(profileFile)
   return true
 }
 
diff --git a/scripts/system-check.ts b/scripts/system-check.ts
index 2e12da5a..af39aa4e 100644
--- a/scripts/system-check.ts
+++ b/scripts/system-check.ts
@@ -93,11 +93,15 @@ function isLocalBaseUrl(baseUrl: string): boolean {
 }
 
 const GEMINI_DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/openai'
+const GITHUB_MODELS_DEFAULT_BASE = 'https://models.github.ai/inference'
 
 function currentBaseUrl(): string {
   if (isTruthy(process.env.CLAUDE_CODE_USE_GEMINI)) {
     return process.env.GEMINI_BASE_URL ?? GEMINI_DEFAULT_BASE_URL
   }
+  if (isTruthy(process.env.CLAUDE_CODE_USE_GITHUB)) {
+    return process.env.OPENAI_BASE_URL ?? GITHUB_MODELS_DEFAULT_BASE
+  }
   return process.env.OPENAI_BASE_URL ?? 'https://api.openai.com/v1'
 }
 
@@ -126,15 +130,47 @@ function checkGeminiEnv(): CheckResult[] {
   return results
 }
 
+function checkGithubEnv(): CheckResult[] {
+  const results: CheckResult[] = []
+  const baseUrl = process.env.OPENAI_BASE_URL ?? GITHUB_MODELS_DEFAULT_BASE
+  results.push(pass('Provider mode', 'GitHub Models provider enabled.'))
+
+  const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN
+  if (!token?.trim()) {
+    results.push(fail('GITHUB_TOKEN', 'Missing. Set GITHUB_TOKEN or GH_TOKEN.'))
+  } else {
+    results.push(pass('GITHUB_TOKEN', 'Configured.'))
+  }
+
+  if (!process.env.OPENAI_MODEL) {
+    results.push(
+      pass(
+        'OPENAI_MODEL',
+        'Not set. Default github:copilot → openai/gpt-4.1 at runtime.',
+      ),
+    )
+  } else {
+    results.push(pass('OPENAI_MODEL', process.env.OPENAI_MODEL))
+  }
+
+  results.push(pass('OPENAI_BASE_URL', baseUrl))
+  return results
+}
+
 function checkOpenAIEnv(): CheckResult[] {
   const results: CheckResult[] = []
   const useGemini = isTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
+  const useGithub = isTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
   const useOpenAI = isTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
 
   if (useGemini) {
     return checkGeminiEnv()
   }
 
+  if (useGithub && !useOpenAI) {
+    return checkGithubEnv()
+  }
+
   if (!useOpenAI) {
     results.push(pass('Provider mode', 'Anthropic login flow enabled (CLAUDE_CODE_USE_OPENAI is off).'))
     return results
@@ -181,12 +217,21 @@ function checkOpenAIEnv(): CheckResult[] {
   }
 
   const key = process.env.OPENAI_API_KEY
+  const githubToken = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN
   if (key === 'SUA_CHAVE') {
     results.push(fail('OPENAI_API_KEY', 'Placeholder value detected: SUA_CHAVE.'))
-  } else if (!key && !isLocalBaseUrl(request.baseUrl)) {
+  } else if (
+    !key &&
+    !isLocalBaseUrl(request.baseUrl) &&
+    !(useGithub && githubToken?.trim())
+  ) {
     results.push(fail('OPENAI_API_KEY', 'Missing key for non-local provider URL.'))
+  } else if (!key && useGithub && githubToken?.trim()) {
+    results.push(
+      pass('OPENAI_API_KEY', 'Not set; GITHUB_TOKEN/GH_TOKEN will be used for GitHub Models.'),
+    )
   } else if (!key) {
-    results.push(pass('OPENAI_API_KEY', 'Not set (allowed for local providers like Ollama/LM Studio).'))
+    results.push(pass('OPENAI_API_KEY', 'Not set (allowed for local providers like Atomic Chat/Ollama/LM Studio).'))
   } else {
     results.push(pass('OPENAI_API_KEY', 'Configured.'))
   }
@@ -197,11 +242,19 @@ function checkOpenAIEnv(): CheckResult[] {
 async function checkBaseUrlReachability(): Promise<CheckResult> {
   const useGemini = isTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
   const useOpenAI = isTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
+  const useGithub = isTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
 
-  if (!useGemini && !useOpenAI) {
+  if (!useGemini && !useOpenAI && !useGithub) {
     return pass('Provider reachability', 'Skipped (OpenAI-compatible mode disabled).')
   }
 
+  if (useGithub) {
+    return pass(
+      'Provider reachability',
+      'Skipped for GitHub Models (inference endpoint differs from OpenAI /models probe).',
+    )
+  }
+
   const geminiBaseUrl = 'https://generativelanguage.googleapis.com/v1beta/openai'
   const resolvedBaseUrl = useGemini
     ? (process.env.GEMINI_BASE_URL ?? geminiBaseUrl)
@@ -271,8 +324,21 @@ async function checkBaseUrlReachability(): Promise<CheckResult> {
   }
 }
 
+function isAtomicChatUrl(baseUrl: string): boolean {
+  try {
+    const parsed = new URL(baseUrl)
+    return parsed.port === '1337' && isLocalBaseUrl(baseUrl)
+  } catch {
+    return false
+  }
+}
+
 function checkOllamaProcessorMode(): CheckResult {
-  if (!isTruthy(process.env.CLAUDE_CODE_USE_OPENAI) || isTruthy(process.env.CLAUDE_CODE_USE_GEMINI)) {
+  if (
+    !isTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
+    isTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    isTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+  ) {
     return pass('Ollama processor mode', 'Skipped (OpenAI-compatible mode disabled).')
   }
 
@@ -281,6 +347,10 @@ function checkOllamaProcessorMode(): CheckResult {
     return pass('Ollama processor mode', 'Skipped (provider URL is not local).')
   }
 
+  if (isAtomicChatUrl(baseUrl)) {
+    return pass('Ollama processor mode', 'Skipped (Atomic Chat local provider detected, not Ollama).')
+  }
+
   const result = spawnSync('ollama', ['ps'], {
     cwd: process.cwd(),
     encoding: 'utf8',
@@ -319,6 +389,22 @@ function serializeSafeEnvSummary(): Record<string, string | boolean> {
       GEMINI_API_KEY_SET: Boolean(process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY),
     }
   }
+  if (
+    isTruthy(process.env.CLAUDE_CODE_USE_GITHUB) &&
+    !isTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
+  ) {
+    return {
+      CLAUDE_CODE_USE_GITHUB: true,
+      OPENAI_MODEL:
+        process.env.OPENAI_MODEL ??
+        '(unset, default: github:copilot → openai/gpt-4.1)',
+      OPENAI_BASE_URL:
+        process.env.OPENAI_BASE_URL ?? GITHUB_MODELS_DEFAULT_BASE,
+      GITHUB_TOKEN_SET: Boolean(
+        process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN,
+      ),
+    }
+  }
   const request = resolveProviderRequest({
     model: process.env.OPENAI_MODEL,
     baseUrl: process.env.OPENAI_BASE_URL,
@@ -374,6 +460,13 @@ async function main(): Promise<void> {
   const options = parseOptions(process.argv.slice(2))
   const results: CheckResult[] = []
 
+  const { enableConfigs } = await import('../src/utils/config.js')
+  enableConfigs()
+  const { applySafeConfigEnvironmentVariables } = await import('../src/utils/managedEnv.js')
+  applySafeConfigEnvironmentVariables()
+  const { hydrateGithubModelsTokenFromSecureStorage } = await import('../src/utils/githubModelsCredentials.js')
+  hydrateGithubModelsTokenFromSecureStorage()
+
   results.push(checkNodeVersion())
   results.push(checkBunRuntime())
   results.push(checkBuildArtifacts())
diff --git a/smart_router.py b/smart_router.py
index 0a54a791..14b90c03 100644
--- a/smart_router.py
+++ b/smart_router.py
@@ -57,8 +57,8 @@ class Provider:
     @property
     def is_configured(self) -> bool:
         """True if the provider has an API key set."""
-        if self.name == "ollama":
-            return True  # Ollama needs no API key
+        if self.name in ("ollama", "atomic-chat"):
+            return True  # Local providers need no API key
         return bool(self.api_key)
 
     @property
@@ -93,6 +93,7 @@ def build_default_providers() -> list[Provider]:
     big = os.getenv("BIG_MODEL", "gpt-4.1")
     small = os.getenv("SMALL_MODEL", "gpt-4.1-mini")
     ollama_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+    atomic_chat_url = os.getenv("ATOMIC_CHAT_BASE_URL", "http://127.0.0.1:1337")
 
     return [
         Provider(
@@ -119,6 +120,14 @@ def build_default_providers() -> list[Provider]:
             big_model=big if "gemini" not in big and "gpt" not in big else "llama3:8b",
             small_model=small if "gemini" not in small and "gpt" not in small else "llama3:8b",
         ),
+        Provider(
+            name="atomic-chat",
+            ping_url=f"{atomic_chat_url}/v1/models",
+            api_key_env="",
+            cost_per_1k_tokens=0.0,   # free — local (Apple Silicon)
+            big_model=big if "gemini" not in big and "gpt" not in big else "llama3:8b",
+            small_model=small if "gemini" not in small and "gpt" not in small else "llama3:8b",
+        ),
     ]
 
 
diff --git a/src/cli/handlers/mcp.tsx b/src/cli/handlers/mcp.tsx
index e530c268..bf43d490 100644
--- a/src/cli/handlers/mcp.tsx
+++ b/src/cli/handlers/mcp.tsx
@@ -12,6 +12,7 @@ import { render } from '../../ink.js';
 import { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js';
 import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
 import { clearMcpClientConfig, clearServerTokensFromLocalStorage, getMcpClientConfig, readClientSecret, saveMcpClientSecret } from '../../services/mcp/auth.js';
+import { doctorAllServers, doctorServer, type McpDoctorReport, type McpDoctorScopeFilter } from '../../services/mcp/doctor.js';
 import { connectToServer, getMcpServerConnectionBatchSize } from '../../services/mcp/client.js';
 import { addMcpConfig, getAllMcpConfigs, getMcpConfigByName, getMcpConfigsByScope, removeMcpConfig } from '../../services/mcp/config.js';
 import type { ConfigScope, ScopedMcpServerConfig } from '../../services/mcp/types.js';
@@ -23,6 +24,102 @@ import { gracefulShutdown } from '../../utils/gracefulShutdown.js';
 import { safeParseJSON } from '../../utils/json.js';
 import { getPlatform } from '../../utils/platform.js';
 import { cliError, cliOk } from '../exit.js';
+
+function formatDoctorReport(report: McpDoctorReport): string {
+  const lines: string[] = []
+  lines.push('MCP Doctor')
+  lines.push('')
+  lines.push('Summary')
+  lines.push(`- ${report.summary.totalReports} server reports generated`)
+  lines.push(`- ${report.summary.healthy} healthy`)
+  lines.push(`- ${report.summary.warnings} warnings`)
+  lines.push(`- ${report.summary.blocking} blocking issues`)
+
+  if (report.targetName) {
+    lines.push(`- target: ${report.targetName}`)
+  }
+
+  for (const server of report.servers) {
+    lines.push('')
+    lines.push(server.serverName)
+
+    const activeDefinition = server.definitions.find(definition => definition.runtimeActive)
+    if (activeDefinition) {
+      lines.push(`- Active source: ${activeDefinition.sourceType}`)
+      lines.push(`- Transport: ${activeDefinition.transport ?? 'unknown'}`)
+    }
+
+    if (server.definitions.length > 1) {
+      const extraDefinitions = server.definitions
+        .filter(definition => !definition.runtimeActive)
+        .map(definition => definition.sourceType)
+      if (extraDefinitions.length > 0) {
+        lines.push(`- Additional definitions: ${extraDefinitions.join(', ')}`)
+      }
+    }
+
+    if (server.liveCheck.result) {
+      const stateLikeResults = new Set(['disabled', 'pending', 'skipped'])
+      const label = stateLikeResults.has(server.liveCheck.result)
+        ? 'State'
+        : 'Live check'
+      lines.push(`- ${label}: ${server.liveCheck.result}`)
+    }
+
+    if (server.liveCheck.error) {
+      lines.push(`- Error: ${server.liveCheck.error}`)
+    }
+
+    for (const finding of server.findings) {
+      lines.push(`- ${finding.message}`)
+      if (finding.remediation) {
+        lines.push(`- Fix: ${finding.remediation}`)
+      }
+    }
+  }
+
+  if (report.findings.length > 0) {
+    lines.push('')
+    lines.push('Global findings')
+    for (const finding of report.findings) {
+      lines.push(`- ${finding.message}`)
+      if (finding.remediation) {
+        lines.push(`- Fix: ${finding.remediation}`)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+
+export async function mcpDoctorHandler(name: string | undefined, options: {
+  scope?: string;
+  configOnly?: boolean;
+  json?: boolean;
+}): Promise<void> {
+  try {
+    const scopeFilter = options.scope ? ensureConfigScope(options.scope) as McpDoctorScopeFilter : undefined
+    const configOnly = !!options.configOnly
+    const report = name
+      ? await doctorServer(name, { configOnly, scopeFilter })
+      : await doctorAllServers({ configOnly, scopeFilter })
+
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
+    } else {
+      process.stdout.write(`${formatDoctorReport(report)}\n`)
+    }
+
+    // On Windows, exiting immediately after a single failed HTTP MCP health check
+    // can trip a libuv assertion while async handle shutdown is still settling.
+    // Let the event loop drain briefly before exiting this one-shot command.
+    await new Promise(resolve => setTimeout(resolve, 50))
+    process.exit(report.summary.blocking > 0 ? 1 : 0)
+    return
+  } catch (error) {
+    cliError((error as Error).message)
+  }
+}
 async function checkMcpServerHealth(name: string, server: ScopedMcpServerConfig): Promise<string> {
   try {
     const result = await connectToServer(name, server);
@@ -359,4 +456,4 @@ export async function mcpResetChoicesHandler(): Promise<void> {
   }));
   cliOk('All project-scoped (.mcp.json) server approvals and rejections have been reset.\n' + 'You will be prompted for approval next time you start Claude Code.');
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stat","pMap","cwd","React","MCPServerDesktopImportDialog","render","KeybindingSetup","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearMcpClientConfig","clearServerTokensFromLocalStorage","getMcpClientConfig","readClientSecret","saveMcpClientSecret","connectToServer","getMcpServerConnectionBatchSize","addMcpConfig","getAllMcpConfigs","getMcpConfigByName","getMcpConfigsByScope","removeMcpConfig","ConfigScope","ScopedMcpServerConfig","describeMcpConfigFilePath","ensureConfigScope","getScopeLabel","AppStateProvider","getCurrentProjectConfig","getGlobalConfig","saveCurrentProjectConfig","isFsInaccessible","gracefulShutdown","safeParseJSON","getPlatform","cliError","cliOk","checkMcpServerHealth","name","server","Promise","result","type","_error","mcpServeHandler","debug","verbose","providedCwd","error","setup","undefined","startMCPServer","mcpRemoveHandler","options","scope","serverBeforeRemoval","cleanupSecureStorage","process","stdout","write","projectConfig","globalConfig","servers","projectServers","mcpJsonExists","scopes","Array","Exclude","mcpServers","push","length","stderr","forEach","Error","message","mcpListHandler","configs","Object","keys","console","log","entries","results","status","concurrency","url","args","isArray","command","join","mcpGetHandler","headers","key","value","oauth","clientId","callbackPort","parts","clientConfig","clientSecret","env","mcpAddJsonHandler","json","parsedJson","needsSecret","transportType","String","source","mcpAddFromDesktopHandler","platform","readClaudeDesktopMcpServers","unmount","exitOnCtrlC","mcpResetChoicesHandler","current","enabledMcpjsonServers","disabledMcpjsonServers","enableAllProjectMcpServers"],"sources":["mcp.tsx"],"sourcesContent":["/**\n * MCP subcommand handlers — extracted from main.tsx for lazy loading.\n * These are dynamically imported only when the corresponding `claude mcp *` command runs.\n */\n\nimport { stat } from 'fs/promises'\nimport pMap from 'p-map'\nimport { cwd } from 'process'\nimport React from 'react'\nimport { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js'\nimport { render } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  clearMcpClientConfig,\n  clearServerTokensFromLocalStorage,\n  getMcpClientConfig,\n  readClientSecret,\n  saveMcpClientSecret,\n} from '../../services/mcp/auth.js'\nimport {\n  connectToServer,\n  getMcpServerConnectionBatchSize,\n} from '../../services/mcp/client.js'\nimport {\n  addMcpConfig,\n  getAllMcpConfigs,\n  getMcpConfigByName,\n  getMcpConfigsByScope,\n  removeMcpConfig,\n} from '../../services/mcp/config.js'\nimport type {\n  ConfigScope,\n  ScopedMcpServerConfig,\n} from '../../services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  ensureConfigScope,\n  getScopeLabel,\n} from '../../services/mcp/utils.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport {\n  getCurrentProjectConfig,\n  getGlobalConfig,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { gracefulShutdown } from '../../utils/gracefulShutdown.js'\nimport { safeParseJSON } from '../../utils/json.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { cliError, cliOk } from '../exit.js'\n\nasync function checkMcpServerHealth(\n  name: string,\n  server: ScopedMcpServerConfig,\n): Promise<string> {\n  try {\n    const result = await connectToServer(name, server)\n    if (result.type === 'connected') {\n      return '✓ Connected'\n    } else if (result.type === 'needs-auth') {\n      return '! Needs authentication'\n    } else {\n      return '✗ Failed to connect'\n    }\n  } catch (_error) {\n    return '✗ Connection error'\n  }\n}\n\n// mcp serve (lines 4512–4532)\nexport async function mcpServeHandler({\n  debug,\n  verbose,\n}: {\n  debug?: boolean\n  verbose?: boolean\n}): Promise<void> {\n  const providedCwd = cwd()\n  logEvent('tengu_mcp_start', {})\n\n  try {\n    await stat(providedCwd)\n  } catch (error) {\n    if (isFsInaccessible(error)) {\n      cliError(`Error: Directory ${providedCwd} does not exist`)\n    }\n    throw error\n  }\n\n  try {\n    const { setup } = await import('../../setup.js')\n    await setup(providedCwd, 'default', false, false, undefined, false)\n    const { startMCPServer } = await import('../../entrypoints/mcp.js')\n    await startMCPServer(providedCwd, debug ?? false, verbose ?? false)\n  } catch (error) {\n    cliError(`Error: Failed to start MCP server: ${error}`)\n  }\n}\n\n// mcp remove (lines 4545–4635)\nexport async function mcpRemoveHandler(\n  name: string,\n  options: { scope?: string },\n): Promise<void> {\n  // Look up config before removing so we can clean up secure storage\n  const serverBeforeRemoval = getMcpConfigByName(name)\n\n  const cleanupSecureStorage = () => {\n    if (\n      serverBeforeRemoval &&\n      (serverBeforeRemoval.type === 'sse' ||\n        serverBeforeRemoval.type === 'http')\n    ) {\n      clearServerTokensFromLocalStorage(name, serverBeforeRemoval)\n      clearMcpClientConfig(name, serverBeforeRemoval)\n    }\n  }\n\n  try {\n    if (options.scope) {\n      const scope = ensureConfigScope(options.scope)\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(`Removed MCP server ${name} from ${scope} config\\n`)\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    }\n\n    // If no scope specified, check where the server exists\n    const projectConfig = getCurrentProjectConfig()\n    const globalConfig = getGlobalConfig()\n\n    // Check if server exists in project scope (.mcp.json)\n    const { servers: projectServers } = getMcpConfigsByScope('project')\n    const mcpJsonExists = !!projectServers[name]\n\n    // Count how many scopes contain this server\n    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = []\n    if (projectConfig.mcpServers?.[name]) scopes.push('local')\n    if (mcpJsonExists) scopes.push('project')\n    if (globalConfig.mcpServers?.[name]) scopes.push('user')\n\n    if (scopes.length === 0) {\n      cliError(`No MCP server found with name: \"${name}\"`)\n    } else if (scopes.length === 1) {\n      // Server exists in only one scope, remove it\n      const scope = scopes[0]!\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(\n        `Removed MCP server \"${name}\" from ${scope} config\\n`,\n      )\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    } else {\n      // Server exists in multiple scopes\n      process.stderr.write(`MCP server \"${name}\" exists in multiple scopes:\\n`)\n      scopes.forEach(scope => {\n        process.stderr.write(\n          `  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\\n`,\n        )\n      })\n      process.stderr.write('\\nTo remove from a specific scope, use:\\n')\n      scopes.forEach(scope => {\n        process.stderr.write(`  claude mcp remove \"${name}\" -s ${scope}\\n`)\n      })\n      cliError()\n    }\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp list (lines 4641–4688)\nexport async function mcpListHandler(): Promise<void> {\n  logEvent('tengu_mcp_list', {})\n  const { servers: configs } = await getAllMcpConfigs()\n  if (Object.keys(configs).length === 0) {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(\n      'No MCP servers configured. Use `claude mcp add` to add a server.',\n    )\n  } else {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log('Checking MCP server health...\\n')\n\n    // Check servers concurrently\n    const entries = Object.entries(configs)\n    const results = await pMap(\n      entries,\n      async ([name, server]) => ({\n        name,\n        server,\n        status: await checkMcpServerHealth(name, server),\n      }),\n      { concurrency: getMcpServerConnectionBatchSize() },\n    )\n\n    for (const { name, server, status } of results) {\n      // Intentionally excluding sse-ide servers here since they're internal\n      if (server.type === 'sse') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (SSE) - ${status}`)\n      } else if (server.type === 'http') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (HTTP) - ${status}`)\n      } else if (server.type === 'claudeai-proxy') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} - ${status}`)\n      } else if (!server.type || server.type === 'stdio') {\n        const args = Array.isArray(server.args) ? server.args : []\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`)\n      }\n    }\n  }\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp get (lines 4694–4786)\nexport async function mcpGetHandler(name: string): Promise<void> {\n  logEvent('tengu_mcp_get', {\n    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  const server = getMcpConfigByName(name)\n  if (!server) {\n    cliError(`No MCP server found with name: ${name}`)\n  }\n\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`${name}:`)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Scope: ${getScopeLabel(server.scope)}`)\n\n  // Check server health\n  const status = await checkMcpServerHealth(name, server)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Status: ${status}`)\n\n  // Intentionally excluding sse-ide servers here since they're internal\n  if (server.type === 'sse') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: sse`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'http') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: http`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'stdio') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: stdio`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Command: ${server.command}`)\n    const args = Array.isArray(server.args) ? server.args : []\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Args: ${args.join(' ')}`)\n    if (server.env) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Environment:')\n      for (const [key, value] of Object.entries(server.env)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}=${value}`)\n      }\n    }\n  }\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(\n    `\\nTo remove this server, run: claude mcp remove \"${name}\" -s ${server.scope}`,\n  )\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp add-json (lines 4801–4870)\nexport async function mcpAddJsonHandler(\n  name: string,\n  json: string,\n  options: { scope?: string; clientSecret?: true },\n): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const parsedJson = safeParseJSON(json)\n\n    // Read secret before writing config so cancellation doesn't leave partial state\n    const needsSecret =\n      options.clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string' &&\n      'oauth' in parsedJson &&\n      parsedJson.oauth &&\n      typeof parsedJson.oauth === 'object' &&\n      'clientId' in parsedJson.oauth\n    const clientSecret = needsSecret ? await readClientSecret() : undefined\n\n    await addMcpConfig(name, parsedJson, scope)\n\n    const transportType =\n      parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson\n        ? String(parsedJson.type || 'stdio')\n        : 'stdio'\n\n    if (\n      clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string'\n    ) {\n      saveMcpClientSecret(\n        name,\n        { type: parsedJson.type, url: parsedJson.url },\n        clientSecret,\n      )\n    }\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`)\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp add-from-claude-desktop (lines 4881–4927)\nexport async function mcpAddFromDesktopHandler(options: {\n  scope?: string\n}): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const platform = getPlatform()\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      platform:\n        platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    const { readClaudeDesktopMcpServers } = await import(\n      '../../utils/claudeDesktop.js'\n    )\n    const servers = await readClaudeDesktopMcpServers()\n\n    if (Object.keys(servers).length === 0) {\n      cliOk(\n        'No MCP servers found in Claude Desktop configuration or configuration file does not exist.',\n      )\n    }\n\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPServerDesktopImportDialog\n            servers={servers}\n            scope={scope}\n            onDone={() => {\n              unmount()\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      { exitOnCtrlC: true },\n    )\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp reset-project-choices (lines 4935–4952)\nexport async function mcpResetChoicesHandler(): Promise<void> {\n  logEvent('tengu_mcp_reset_mcpjson_choices', {})\n  saveCurrentProjectConfig(current => ({\n    ...current,\n    enabledMcpjsonServers: [],\n    disabledMcpjsonServers: [],\n    enableAllProjectMcpServers: false,\n  }))\n  cliOk(\n    'All project-scoped (.mcp.json) server approvals and rejections have been reset.\\n' +\n      'You will be prompted for approval next time you start Claude Code.',\n  )\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stat","pMap","cwd","React","MCPServerDesktopImportDialog","render","KeybindingSetup","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearMcpClientConfig","clearServerTokensFromLocalStorage","getMcpClientConfig","readClientSecret","saveMcpClientSecret","connectToServer","getMcpServerConnectionBatchSize","addMcpConfig","getAllMcpConfigs","getMcpConfigByName","getMcpConfigsByScope","removeMcpConfig","ConfigScope","ScopedMcpServerConfig","describeMcpConfigFilePath","ensureConfigScope","getScopeLabel","AppStateProvider","getCurrentProjectConfig","getGlobalConfig","saveCurrentProjectConfig","isFsInaccessible","gracefulShutdown","safeParseJSON","getPlatform","cliError","cliOk","checkMcpServerHealth","name","server","Promise","result","type","_error","mcpServeHandler","debug","verbose","providedCwd","error","setup","undefined","startMCPServer","mcpRemoveHandler","options","scope","serverBeforeRemoval","cleanupSecureStorage","process","stdout","write","projectConfig","globalConfig","servers","projectServers","mcpJsonExists","scopes","Array","Exclude","mcpServers","push","length","stderr","forEach","Error","message","mcpListHandler","configs","Object","keys","console","log","entries","results","status","concurrency","url","args","isArray","command","join","mcpGetHandler","headers","key","value","oauth","clientId","callbackPort","parts","clientConfig","clientSecret","env","mcpAddJsonHandler","json","parsedJson","needsSecret","transportType","String","source","mcpAddFromDesktopHandler","platform","readClaudeDesktopMcpServers","unmount","exitOnCtrlC","mcpResetChoicesHandler","current","enabledMcpjsonServers","disabledMcpjsonServers","enableAllProjectMcpServers"],"sources":["mcp.tsx"],"sourcesContent":["/**\n * MCP subcommand handlers — extracted from main.tsx for lazy loading.\n * These are dynamically imported only when the corresponding `claude mcp *` command runs.\n */\n\nimport { stat } from 'fs/promises'\nimport pMap from 'p-map'\nimport { cwd } from 'process'\nimport React from 'react'\nimport { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js'\nimport { render } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  clearMcpClientConfig,\n  clearServerTokensFromLocalStorage,\n  getMcpClientConfig,\n  readClientSecret,\n  saveMcpClientSecret,\n} from '../../services/mcp/auth.js'\nimport {\n  connectToServer,\n  getMcpServerConnectionBatchSize,\n} from '../../services/mcp/client.js'\nimport {\n  addMcpConfig,\n  getAllMcpConfigs,\n  getMcpConfigByName,\n  getMcpConfigsByScope,\n  removeMcpConfig,\n} from '../../services/mcp/config.js'\nimport type {\n  ConfigScope,\n  ScopedMcpServerConfig,\n} from '../../services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  ensureConfigScope,\n  getScopeLabel,\n} from '../../services/mcp/utils.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport {\n  getCurrentProjectConfig,\n  getGlobalConfig,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { gracefulShutdown } from '../../utils/gracefulShutdown.js'\nimport { safeParseJSON } from '../../utils/json.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { cliError, cliOk } from '../exit.js'\n\nasync function checkMcpServerHealth(\n  name: string,\n  server: ScopedMcpServerConfig,\n): Promise<string> {\n  try {\n    const result = await connectToServer(name, server)\n    if (result.type === 'connected') {\n      return '✓ Connected'\n    } else if (result.type === 'needs-auth') {\n      return '! Needs authentication'\n    } else {\n      return '✗ Failed to connect'\n    }\n  } catch (_error) {\n    return '✗ Connection error'\n  }\n}\n\n// mcp serve (lines 4512–4532)\nexport async function mcpServeHandler({\n  debug,\n  verbose,\n}: {\n  debug?: boolean\n  verbose?: boolean\n}): Promise<void> {\n  const providedCwd = cwd()\n  logEvent('tengu_mcp_start', {})\n\n  try {\n    await stat(providedCwd)\n  } catch (error) {\n    if (isFsInaccessible(error)) {\n      cliError(`Error: Directory ${providedCwd} does not exist`)\n    }\n    throw error\n  }\n\n  try {\n    const { setup } = await import('../../setup.js')\n    await setup(providedCwd, 'default', false, false, undefined, false)\n    const { startMCPServer } = await import('../../entrypoints/mcp.js')\n    await startMCPServer(providedCwd, debug ?? false, verbose ?? false)\n  } catch (error) {\n    cliError(`Error: Failed to start MCP server: ${error}`)\n  }\n}\n\n// mcp remove (lines 4545–4635)\nexport async function mcpRemoveHandler(\n  name: string,\n  options: { scope?: string },\n): Promise<void> {\n  // Look up config before removing so we can clean up secure storage\n  const serverBeforeRemoval = getMcpConfigByName(name)\n\n  const cleanupSecureStorage = () => {\n    if (\n      serverBeforeRemoval &&\n      (serverBeforeRemoval.type === 'sse' ||\n        serverBeforeRemoval.type === 'http')\n    ) {\n      clearServerTokensFromLocalStorage(name, serverBeforeRemoval)\n      clearMcpClientConfig(name, serverBeforeRemoval)\n    }\n  }\n\n  try {\n    if (options.scope) {\n      const scope = ensureConfigScope(options.scope)\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(`Removed MCP server ${name} from ${scope} config\\n`)\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    }\n\n    // If no scope specified, check where the server exists\n    const projectConfig = getCurrentProjectConfig()\n    const globalConfig = getGlobalConfig()\n\n    // Check if server exists in project scope (.mcp.json)\n    const { servers: projectServers } = getMcpConfigsByScope('project')\n    const mcpJsonExists = !!projectServers[name]\n\n    // Count how many scopes contain this server\n    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = []\n    if (projectConfig.mcpServers?.[name]) scopes.push('local')\n    if (mcpJsonExists) scopes.push('project')\n    if (globalConfig.mcpServers?.[name]) scopes.push('user')\n\n    if (scopes.length === 0) {\n      cliError(`No MCP server found with name: \"${name}\"`)\n    } else if (scopes.length === 1) {\n      // Server exists in only one scope, remove it\n      const scope = scopes[0]!\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(\n        `Removed MCP server \"${name}\" from ${scope} config\\n`,\n      )\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    } else {\n      // Server exists in multiple scopes\n      process.stderr.write(`MCP server \"${name}\" exists in multiple scopes:\\n`)\n      scopes.forEach(scope => {\n        process.stderr.write(\n          `  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\\n`,\n        )\n      })\n      process.stderr.write('\\nTo remove from a specific scope, use:\\n')\n      scopes.forEach(scope => {\n        process.stderr.write(`  claude mcp remove \"${name}\" -s ${scope}\\n`)\n      })\n      cliError()\n    }\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp list (lines 4641–4688)\nexport async function mcpListHandler(): Promise<void> {\n  logEvent('tengu_mcp_list', {})\n  const { servers: configs } = await getAllMcpConfigs()\n  if (Object.keys(configs).length === 0) {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(\n      'No MCP servers configured. Use `claude mcp add` to add a server.',\n    )\n  } else {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log('Checking MCP server health...\\n')\n\n    // Check servers concurrently\n    const entries = Object.entries(configs)\n    const results = await pMap(\n      entries,\n      async ([name, server]) => ({\n        name,\n        server,\n        status: await checkMcpServerHealth(name, server),\n      }),\n      { concurrency: getMcpServerConnectionBatchSize() },\n    )\n\n    for (const { name, server, status } of results) {\n      // Intentionally excluding sse-ide servers here since they're internal\n      if (server.type === 'sse') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (SSE) - ${status}`)\n      } else if (server.type === 'http') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (HTTP) - ${status}`)\n      } else if (server.type === 'claudeai-proxy') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} - ${status}`)\n      } else if (!server.type || server.type === 'stdio') {\n        const args = Array.isArray(server.args) ? server.args : []\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`)\n      }\n    }\n  }\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp get (lines 4694–4786)\nexport async function mcpGetHandler(name: string): Promise<void> {\n  logEvent('tengu_mcp_get', {\n    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  const server = getMcpConfigByName(name)\n  if (!server) {\n    cliError(`No MCP server found with name: ${name}`)\n  }\n\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`${name}:`)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Scope: ${getScopeLabel(server.scope)}`)\n\n  // Check server health\n  const status = await checkMcpServerHealth(name, server)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Status: ${status}`)\n\n  // Intentionally excluding sse-ide servers here since they're internal\n  if (server.type === 'sse') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: sse`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'http') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: http`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'stdio') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: stdio`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Command: ${server.command}`)\n    const args = Array.isArray(server.args) ? server.args : []\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Args: ${args.join(' ')}`)\n    if (server.env) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Environment:')\n      for (const [key, value] of Object.entries(server.env)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}=${value}`)\n      }\n    }\n  }\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(\n    `\\nTo remove this server, run: claude mcp remove \"${name}\" -s ${server.scope}`,\n  )\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp add-json (lines 4801–4870)\nexport async function mcpAddJsonHandler(\n  name: string,\n  json: string,\n  options: { scope?: string; clientSecret?: true },\n): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const parsedJson = safeParseJSON(json)\n\n    // Read secret before writing config so cancellation doesn't leave partial state\n    const needsSecret =\n      options.clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string' &&\n      'oauth' in parsedJson &&\n      parsedJson.oauth &&\n      typeof parsedJson.oauth === 'object' &&\n      'clientId' in parsedJson.oauth\n    const clientSecret = needsSecret ? await readClientSecret() : undefined\n\n    await addMcpConfig(name, parsedJson, scope)\n\n    const transportType =\n      parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson\n        ? String(parsedJson.type || 'stdio')\n        : 'stdio'\n\n    if (\n      clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string'\n    ) {\n      saveMcpClientSecret(\n        name,\n        { type: parsedJson.type, url: parsedJson.url },\n        clientSecret,\n      )\n    }\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`)\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp add-from-claude-desktop (lines 4881–4927)\nexport async function mcpAddFromDesktopHandler(options: {\n  scope?: string\n}): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const platform = getPlatform()\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      platform:\n        platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    const { readClaudeDesktopMcpServers } = await import(\n      '../../utils/claudeDesktop.js'\n    )\n    const servers = await readClaudeDesktopMcpServers()\n\n    if (Object.keys(servers).length === 0) {\n      cliOk(\n        'No MCP servers found in Claude Desktop configuration or configuration file does not exist.',\n      )\n    }\n\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPServerDesktopImportDialog\n            servers={servers}\n            scope={scope}\n            onDone={() => {\n              unmount()\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      { exitOnCtrlC: true },\n    )\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp reset-project-choices (lines 4935–4952)\nexport async function mcpResetChoicesHandler(): Promise<void> {\n  logEvent('tengu_mcp_reset_mcpjson_choices', {})\n  saveCurrentProjectConfig(current => ({\n    ...current,\n    enabledMcpjsonServers: [],\n    disabledMcpjsonServers: [],\n    enableAllProjectMcpServers: false,\n  }))\n  cliOk(\n    'All project-scoped (.mcp.json) server approvals and rejections have been reset.\\n' +\n      'You will be prompted for approval next time you start Claude Code.',\n  )\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/commands.ts b/src/commands.ts
index 10f03b22..a11f3be2 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -19,6 +19,7 @@ import cost from './commands/cost/index.js'
 import diff from './commands/diff/index.js'
 import ctx_viz from './commands/ctx_viz/index.js'
 import doctor from './commands/doctor/index.js'
+import onboardGithub from './commands/onboard-github/index.js'
 import memory from './commands/memory/index.js'
 import help from './commands/help/index.js'
 import ide from './commands/ide/index.js'
@@ -128,6 +129,7 @@ import plan from './commands/plan/index.js'
 import fast from './commands/fast/index.js'
 import passes from './commands/passes/index.js'
 import privacySettings from './commands/privacy-settings/index.js'
+import provider from './commands/provider/index.js'
 import hooks from './commands/hooks/index.js'
 import files from './commands/files/index.js'
 import branch from './commands/branch/index.js'
@@ -288,9 +290,11 @@ const COMMANDS = memoize((): Command[] => [
   memory,
   mobile,
   model,
+  onboardGithub,
   outputStyle,
   remoteEnv,
   plugin,
+  provider,
   pr_comments,
   releaseNotes,
   reloadPlugins,
diff --git a/src/commands/effort/effort.tsx b/src/commands/effort/effort.tsx
index 0dadd606..1cbc83d1 100644
--- a/src/commands/effort/effort.tsx
+++ b/src/commands/effort/effort.tsx
@@ -4,7 +4,8 @@ import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
 import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
 import { useAppState, useSetAppState } from '../../state/AppState.js';
 import type { LocalJSXCommandOnDone } from '../../types/command.js';
-import { type EffortValue, getDisplayedEffortLevel, getEffortEnvOverride, getEffortValueDescription, isEffortLevel, toPersistableEffort } from '../../utils/effort.js';
+import { type EffortValue, getDisplayedEffortLevel, getEffortEnvOverride, getEffortValueDescription, isEffortLevel, isOpenAIEffortLevel, modelUsesOpenAIEffort, toPersistableEffort } from '../../utils/effort.js';
+import { EffortPicker } from '../../components/EffortPicker.js';
 import { updateSettingsForSource } from '../../utils/settings/settings.js';
 const COMMON_HELP_ARGS = ['help', '-h', '--help'];
 type EffortCommandResult = {
@@ -109,12 +110,15 @@ export function executeEffort(args: string): EffortCommandResult {
   if (normalized === 'auto' || normalized === 'unset') {
     return unsetEffortLevel();
   }
-  if (!isEffortLevel(normalized)) {
-    return {
-      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`
-    };
+  if (isEffortLevel(normalized)) {
+    return setEffortValue(normalized);
   }
-  return setEffortValue(normalized);
+  if (isOpenAIEffortLevel(normalized)) {
+    return setEffortValue(normalized);
+  }
+  return {
+    message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, xhigh, auto`
+  };
 }
 function ShowCurrentEffort(t0) {
   const {
@@ -174,10 +178,44 @@ export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, arg
     onDone('Usage: /effort [low|medium|high|max|auto]\n\nEffort levels:\n- low: Quick, straightforward implementation\n- medium: Balanced approach with standard testing\n- high: Comprehensive implementation with extensive testing\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\n- auto: Use the default effort level for your model');
     return;
   }
-  if (!args || args === 'current' || args === 'status') {
+  if (args === 'current' || args === 'status') {
     return <ShowCurrentEffort onDone={onDone} />;
   }
+  if (!args) {
+    return <EffortPickerWrapper onDone={onDone} />;
+  }
   const result = executeEffort(args);
   return <ApplyEffortAndClose result={result} onDone={onDone} />;
 }
+
+function EffortPickerWrapper({ onDone }: { onDone: LocalJSXCommandOnDone }) {
+  const setAppState = useSetAppState();
+  const model = useMainLoopModel();
+  const usesOpenAIEffort = modelUsesOpenAIEffort(model);
+
+  function handleSelect(effort: EffortValue | undefined) {
+    const persistable = toPersistableEffort(effort);
+    if (persistable !== undefined) {
+      updateSettingsForSource('userSettings', {
+        effortLevel: persistable
+      });
+    }
+    logEvent('tengu_effort_command', {
+      effort: (effort ?? 'auto') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+    });
+    setAppState(prev => ({
+      ...prev,
+      effortValue: effort
+    }));
+    const description = effort ? getEffortValueDescription(effort) : 'Use default effort level for your model';
+    const suffix = persistable !== undefined ? '' : ' (this session only)';
+    onDone(`Set effort level to ${effort ?? 'auto'}${suffix}: ${description}`);
+  }
+
+  function handleCancel() {
+    onDone('Cancelled');
+  }
+
+  return <EffortPicker onSelect={handleSelect} onCancel={handleCancel} />;
+}
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMainLoopModel","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useSetAppState","LocalJSXCommandOnDone","EffortValue","getDisplayedEffortLevel","getEffortEnvOverride","getEffortValueDescription","isEffortLevel","toPersistableEffort","updateSettingsForSource","COMMON_HELP_ARGS","EffortCommandResult","message","effortUpdate","value","setEffortValue","effortValue","persistable","undefined","result","effortLevel","error","effort","envOverride","envRaw","process","env","CLAUDE_CODE_EFFORT_LEVEL","description","suffix","showCurrentEffort","appStateEffort","model","effectiveValue","level","unsetEffortLevel","executeEffort","args","normalized","toLowerCase","ShowCurrentEffort","t0","onDone","_temp","s","ApplyEffortAndClose","$","_c","setAppState","t1","t2","prev","useEffect","call","_context","Promise","ReactNode","trim","includes"],"sources":["effort.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { useAppState, useSetAppState } from '../../state/AppState.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  type EffortValue,\n  getDisplayedEffortLevel,\n  getEffortEnvOverride,\n  getEffortValueDescription,\n  isEffortLevel,\n  toPersistableEffort,\n} from '../../utils/effort.js'\nimport { updateSettingsForSource } from '../../utils/settings/settings.js'\n\nconst COMMON_HELP_ARGS = ['help', '-h', '--help']\n\ntype EffortCommandResult = {\n  message: string\n  effortUpdate?: { value: EffortValue | undefined }\n}\n\nfunction setEffortValue(effortValue: EffortValue): EffortCommandResult {\n  const persistable = toPersistableEffort(effortValue)\n  if (persistable !== undefined) {\n    const result = updateSettingsForSource('userSettings', {\n      effortLevel: persistable,\n    })\n    if (result.error) {\n      return {\n        message: `Failed to set effort level: ${result.error.message}`,\n      }\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      effortValue as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n\n  // Env var wins at resolveAppliedEffort time. Only flag it when it actually\n  // conflicts — if env matches what the user just asked for, the outcome is\n  // the same, so \"Set effort to X\" is true and the note is noise.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== effortValue) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    if (persistable === undefined) {\n      return {\n        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,\n        effortUpdate: { value: effortValue },\n      }\n    }\n    return {\n      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session — clear it and ${effortValue} takes over`,\n      effortUpdate: { value: effortValue },\n    }\n  }\n\n  const description = getEffortValueDescription(effortValue)\n  const suffix = persistable !== undefined ? '' : ' (this session only)'\n  return {\n    message: `Set effort level to ${effortValue}${suffix}: ${description}`,\n    effortUpdate: { value: effortValue },\n  }\n}\n\nexport function showCurrentEffort(\n  appStateEffort: EffortValue | undefined,\n  model: string,\n): EffortCommandResult {\n  const envOverride = getEffortEnvOverride()\n  const effectiveValue =\n    envOverride === null ? undefined : (envOverride ?? appStateEffort)\n  if (effectiveValue === undefined) {\n    const level = getDisplayedEffortLevel(model, appStateEffort)\n    return { message: `Effort level: auto (currently ${level})` }\n  }\n  const description = getEffortValueDescription(effectiveValue)\n  return {\n    message: `Current effort level: ${effectiveValue} (${description})`,\n  }\n}\n\nfunction unsetEffortLevel(): EffortCommandResult {\n  const result = updateSettingsForSource('userSettings', {\n    effortLevel: undefined,\n  })\n  if (result.error) {\n    return {\n      message: `Failed to set effort level: ${result.error.message}`,\n    }\n  }\n  logEvent('tengu_effort_command', {\n    effort:\n      'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  // env=auto/unset (null) matches what /effort auto asks for, so only warn\n  // when env is pinning a specific level that will keep overriding.\n  const envOverride = getEffortEnvOverride()\n  if (envOverride !== undefined && envOverride !== null) {\n    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL\n    return {\n      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,\n      effortUpdate: { value: undefined },\n    }\n  }\n  return {\n    message: 'Effort level set to auto',\n    effortUpdate: { value: undefined },\n  }\n}\n\nexport function executeEffort(args: string): EffortCommandResult {\n  const normalized = args.toLowerCase()\n  if (normalized === 'auto' || normalized === 'unset') {\n    return unsetEffortLevel()\n  }\n\n  if (!isEffortLevel(normalized)) {\n    return {\n      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`,\n    }\n  }\n\n  return setEffortValue(normalized)\n}\n\nfunction ShowCurrentEffort({\n  onDone,\n}: {\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const effortValue = useAppState(s => s.effortValue)\n  const model = useMainLoopModel()\n  const { message } = showCurrentEffort(effortValue, model)\n  onDone(message)\n  return null\n}\n\nfunction ApplyEffortAndClose({\n  result,\n  onDone,\n}: {\n  result: EffortCommandResult\n  onDone: (result: string) => void\n}): React.ReactNode {\n  const setAppState = useSetAppState()\n  const { effortUpdate, message } = result\n  React.useEffect(() => {\n    if (effortUpdate) {\n      setAppState(prev => ({\n        ...prev,\n        effortValue: effortUpdate.value,\n      }))\n    }\n    onDone(message)\n  }, [setAppState, effortUpdate, message, onDone])\n  return null\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  _context: unknown,\n  args?: string,\n): Promise<React.ReactNode> {\n  args = args?.trim() || ''\n\n  if (COMMON_HELP_ARGS.includes(args)) {\n    onDone(\n      'Usage: /effort [low|medium|high|max|auto]\\n\\nEffort levels:\\n- low: Quick, straightforward implementation\\n- medium: Balanced approach with standard testing\\n- high: Comprehensive implementation with extensive testing\\n- max: Maximum capability with deepest reasoning (Opus 4.6 only)\\n- auto: Use the default effort level for your model',\n    )\n    return\n  }\n\n  if (!args || args === 'current' || args === 'status') {\n    return <ShowCurrentEffort onDone={onDone} />\n  }\n\n  const result = executeEffort(args)\n  return <ApplyEffortAndClose result={result} onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/src/commands/mcp/doctorCommand.test.ts b/src/commands/mcp/doctorCommand.test.ts
new file mode 100644
index 00000000..8e4754c4
--- /dev/null
+++ b/src/commands/mcp/doctorCommand.test.ts
@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { Command } from '@commander-js/extra-typings'
+
+import { registerMcpDoctorCommand } from './doctorCommand.js'
+
+test('registerMcpDoctorCommand adds the doctor subcommand with expected options', () => {
+  const mcp = new Command('mcp')
+
+  registerMcpDoctorCommand(mcp)
+
+  const doctor = mcp.commands.find(command => command.name() === 'doctor')
+  assert.ok(doctor)
+  assert.equal(doctor?.usage(), '[options] [name]')
+
+  const optionFlags = doctor?.options.map(option => option.long)
+  assert.deepEqual(optionFlags, ['--scope', '--config-only', '--json'])
+})
diff --git a/src/commands/mcp/doctorCommand.ts b/src/commands/mcp/doctorCommand.ts
new file mode 100644
index 00000000..75ed6a10
--- /dev/null
+++ b/src/commands/mcp/doctorCommand.ts
@@ -0,0 +1,25 @@
+/**
+ * MCP doctor CLI subcommand.
+ */
+import { type Command } from '@commander-js/extra-typings'
+
+export function registerMcpDoctorCommand(mcp: Command): void {
+  mcp
+    .command('doctor [name]')
+    .description(
+      'Diagnose MCP configuration, precedence, disabled/pending state, and connection health. ' +
+        'Note: unless --config-only is used, stdio servers may be spawned and remote servers may be contacted. ' +
+        'Only use this command in directories you trust.',
+    )
+    .option('-s, --scope <scope>', 'Restrict config analysis to a specific scope (local, project, user, or enterprise)')
+    .option('--config-only', 'Skip live connection checks and only analyze configuration state')
+    .option('--json', 'Output the diagnostics report as JSON')
+    .action(async (name: string | undefined, options: {
+      scope?: string
+      configOnly?: boolean
+      json?: boolean
+    }) => {
+      const { mcpDoctorHandler } = await import('../../cli/handlers/mcp.js')
+      await mcpDoctorHandler(name, options)
+    })
+}
diff --git a/src/commands/onboard-github/index.ts b/src/commands/onboard-github/index.ts
new file mode 100644
index 00000000..91d67247
--- /dev/null
+++ b/src/commands/onboard-github/index.ts
@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const onboardGithub: Command = {
+  name: 'onboard-github',
+  description:
+    'Interactive setup for GitHub Models: device login or PAT, saved to secure storage',
+  type: 'local-jsx',
+  load: () => import('./onboard-github.js'),
+}
+
+export default onboardGithub
diff --git a/src/commands/onboard-github/onboard-github.tsx b/src/commands/onboard-github/onboard-github.tsx
new file mode 100644
index 00000000..66326957
--- /dev/null
+++ b/src/commands/onboard-github/onboard-github.tsx
@@ -0,0 +1,237 @@
+import * as React from 'react'
+import { useCallback, useState } from 'react'
+import { Select } from '../../components/CustomSelect/select.js'
+import { Spinner } from '../../components/Spinner.js'
+import TextInput from '../../components/TextInput.js'
+import { Box, Text } from '../../ink.js'
+import {
+  openVerificationUri,
+  pollAccessToken,
+  requestDeviceCode,
+} from '../../services/github/deviceFlow.js'
+import type { LocalJSXCommandCall } from '../../types/command.js'
+import {
+  hydrateGithubModelsTokenFromSecureStorage,
+  saveGithubModelsToken,
+} from '../../utils/githubModelsCredentials.js'
+import { updateSettingsForSource } from '../../utils/settings/settings.js'
+
+const DEFAULT_MODEL = 'github:copilot'
+
+type Step =
+  | 'menu'
+  | 'device-busy'
+  | 'pat'
+  | 'error'
+
+function mergeUserSettingsEnv(model: string): { ok: boolean; detail?: string } {
+  const { error } = updateSettingsForSource('userSettings', {
+    env: {
+      CLAUDE_CODE_USE_GITHUB: '1',
+      OPENAI_MODEL: model,
+      CLAUDE_CODE_USE_OPENAI: undefined as any,
+      CLAUDE_CODE_USE_GEMINI: undefined as any,
+      CLAUDE_CODE_USE_BEDROCK: undefined as any,
+      CLAUDE_CODE_USE_VERTEX: undefined as any,
+      CLAUDE_CODE_USE_FOUNDRY: undefined as any,
+    },
+  })
+  if (error) {
+    return { ok: false, detail: error.message }
+  }
+  return { ok: true }
+}
+
+function OnboardGithub(props: {
+  onDone: Parameters<LocalJSXCommandCall>[0]
+  onChangeAPIKey: () => void
+}): React.ReactNode {
+  const { onDone, onChangeAPIKey } = props
+  const [step, setStep] = useState<Step>('menu')
+  const [errorMsg, setErrorMsg] = useState<string | null>(null)
+  const [deviceHint, setDeviceHint] = useState<{
+    user_code: string
+    verification_uri: string
+  } | null>(null)
+  const [patDraft, setPatDraft] = useState('')
+  const [cursorOffset, setCursorOffset] = useState(0)
+
+  const finalize = useCallback(
+    async (token: string, model: string = DEFAULT_MODEL) => {
+      const saved = saveGithubModelsToken(token)
+      if (!saved.success) {
+        setErrorMsg(saved.warning ?? 'Could not save token to secure storage.')
+        setStep('error')
+        return
+      }
+      const merged = mergeUserSettingsEnv(model.trim() || DEFAULT_MODEL)
+      if (!merged.ok) {
+        setErrorMsg(
+          `Token saved, but settings were not updated: ${merged.detail ?? 'unknown error'}. ` +
+            `Add env CLAUDE_CODE_USE_GITHUB=1 and OPENAI_MODEL to ~/.claude/settings.json manually.`,
+        )
+        setStep('error')
+        return
+      }
+      process.env.CLAUDE_CODE_USE_GITHUB = '1'
+      process.env.OPENAI_MODEL = model.trim() || DEFAULT_MODEL
+      hydrateGithubModelsTokenFromSecureStorage()
+      onChangeAPIKey()
+      onDone(
+        'GitHub Models onboard complete. Token stored in secure storage; user settings updated. Restart if the model does not switch.',
+        { display: 'user' },
+      )
+    },
+    [onChangeAPIKey, onDone],
+  )
+
+  const runDeviceFlow = useCallback(async () => {
+    setStep('device-busy')
+    setErrorMsg(null)
+    setDeviceHint(null)
+    try {
+      const device = await requestDeviceCode()
+      setDeviceHint({
+        user_code: device.user_code,
+        verification_uri: device.verification_uri,
+      })
+      await openVerificationUri(device.verification_uri)
+      const token = await pollAccessToken(device.device_code, {
+        initialInterval: device.interval,
+        timeoutSeconds: device.expires_in,
+      })
+      await finalize(token, DEFAULT_MODEL)
+    } catch (e) {
+      setErrorMsg(e instanceof Error ? e.message : String(e))
+      setStep('error')
+    }
+  }, [finalize])
+
+  if (step === 'error' && errorMsg) {
+    const options = [
+      {
+        label: 'Back to menu',
+        value: 'back' as const,
+      },
+      {
+        label: 'Exit',
+        value: 'exit' as const,
+      },
+    ]
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Text color="red">{errorMsg}</Text>
+        <Select
+          options={options}
+          onChange={(v: string) => {
+            if (v === 'back') {
+              setStep('menu')
+              setErrorMsg(null)
+            } else {
+              onDone('GitHub onboard cancelled', { display: 'system' })
+            }
+          }}
+        />
+      </Box>
+    )
+  }
+
+  if (step === 'device-busy') {
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Text>GitHub device login</Text>
+        {deviceHint ? (
+          <>
+            <Text>
+              Enter code <Text bold>{deviceHint.user_code}</Text> at{' '}
+              {deviceHint.verification_uri}
+            </Text>
+            <Text dimColor>
+              A browser window may have opened. Waiting for authorization…
+            </Text>
+          </>
+        ) : (
+          <Text dimColor>Requesting device code from GitHub…</Text>
+        )}
+        <Spinner />
+      </Box>
+    )
+  }
+
+  if (step === 'pat') {
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Text>Paste a GitHub personal access token with access to GitHub Models.</Text>
+        <Text dimColor>Input is masked. Enter to submit; Esc to go back.</Text>
+        <TextInput
+          value={patDraft}
+          mask="*"
+          onChange={setPatDraft}
+          onSubmit={async (value: string) => {
+            const t = value.trim()
+            if (!t) {
+              return
+            }
+            await finalize(t, DEFAULT_MODEL)
+          }}
+          onExit={() => {
+            setStep('menu')
+            setPatDraft('')
+          }}
+          columns={80}
+          cursorOffset={cursorOffset}
+          onChangeCursorOffset={setCursorOffset}
+        />
+      </Box>
+    )
+  }
+
+  const menuOptions = [
+    {
+      label: 'Sign in with browser (device code)',
+      value: 'device' as const,
+    },
+    {
+      label: 'Paste personal access token',
+      value: 'pat' as const,
+    },
+    {
+      label: 'Cancel',
+      value: 'cancel' as const,
+    },
+  ]
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <Text bold>GitHub Models setup</Text>
+      <Text dimColor>
+        Stores your token in the OS credential store (macOS Keychain when available)
+        and enables CLAUDE_CODE_USE_GITHUB in your user settings — no export
+        GITHUB_TOKEN needed for future runs.
+      </Text>
+      <Select
+        options={menuOptions}
+        onChange={(v: string) => {
+          if (v === 'cancel') {
+            onDone('GitHub onboard cancelled', { display: 'system' })
+            return
+          }
+          if (v === 'pat') {
+            setStep('pat')
+            return
+          }
+          void runDeviceFlow()
+        }}
+      />
+    </Box>
+  )
+}
+
+export const call: LocalJSXCommandCall = async (onDone, context) => {
+  return (
+    <OnboardGithub
+      onDone={onDone}
+      onChangeAPIKey={context.onChangeAPIKey}
+    />
+  )
+}
diff --git a/src/commands/provider/index.ts b/src/commands/provider/index.ts
new file mode 100644
index 00000000..9cd14daa
--- /dev/null
+++ b/src/commands/provider/index.ts
@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+import { shouldInferenceConfigCommandBeImmediate } from '../../utils/immediateCommand.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'provider',
+  description: 'Set up and save a third-party provider profile for OpenClaude',
+  get immediate() {
+    return shouldInferenceConfigCommandBeImmediate()
+  },
+  load: () => import('./provider.js'),
+} satisfies Command
diff --git a/src/commands/provider/provider.test.tsx b/src/commands/provider/provider.test.tsx
new file mode 100644
index 00000000..7f5560dc
--- /dev/null
+++ b/src/commands/provider/provider.test.tsx
@@ -0,0 +1,228 @@
+import { PassThrough } from 'node:stream'
+
+import { expect, test } from 'bun:test'
+import React from 'react'
+import stripAnsi from 'strip-ansi'
+
+import { createRoot, render, useApp } from '../../ink.js'
+import { AppStateProvider } from '../../state/AppState.js'
+import {
+  buildCurrentProviderSummary,
+  buildProfileSaveMessage,
+  getProviderWizardDefaults,
+  TextEntryDialog,
+} from './provider.js'
+
+const SYNC_START = '\x1B[?2026h'
+const SYNC_END = '\x1B[?2026l'
+
+function extractLastFrame(output: string): string {
+  let lastFrame: string | null = null
+  let cursor = 0
+
+  while (cursor < output.length) {
+    const start = output.indexOf(SYNC_START, cursor)
+    if (start === -1) {
+      break
+    }
+
+    const contentStart = start + SYNC_START.length
+    const end = output.indexOf(SYNC_END, contentStart)
+    if (end === -1) {
+      break
+    }
+
+    const frame = output.slice(contentStart, end)
+    if (frame.trim().length > 0) {
+      lastFrame = frame
+    }
+    cursor = end + SYNC_END.length
+  }
+
+  return lastFrame ?? output
+}
+
+async function renderFinalFrame(node: React.ReactNode): Promise<string> {
+  let output = ''
+  const { stdout, stdin, getOutput } = createTestStreams()
+
+  const instance = await render(node, {
+    stdout: stdout as unknown as NodeJS.WriteStream,
+    stdin: stdin as unknown as NodeJS.ReadStream,
+    patchConsole: false,
+  })
+
+  await instance.waitUntilExit()
+  return stripAnsi(extractLastFrame(getOutput()))
+}
+
+function createTestStreams(): {
+  stdout: PassThrough
+  stdin: PassThrough & {
+    isTTY: boolean
+    setRawMode: (mode: boolean) => void
+    ref: () => void
+    unref: () => void
+  }
+  getOutput: () => string
+} {
+  let output = ''
+  const stdout = new PassThrough()
+  const stdin = new PassThrough() as PassThrough & {
+    isTTY: boolean
+    setRawMode: (mode: boolean) => void
+    ref: () => void
+    unref: () => void
+  }
+  stdin.isTTY = true
+  stdin.setRawMode = () => {}
+  stdin.ref = () => {}
+  stdin.unref = () => {}
+  ;(stdout as unknown as { columns: number }).columns = 120
+  stdout.on('data', chunk => {
+    output += chunk.toString()
+  })
+
+  return {
+    stdout,
+    stdin,
+    getOutput: () => output,
+  }
+}
+
+function StepChangeHarness(): React.ReactNode {
+  const { exit } = useApp()
+  const [step, setStep] = React.useState<'api' | 'model'>('api')
+
+  React.useLayoutEffect(() => {
+    if (step === 'api') {
+      setStep('model')
+      return
+    }
+
+    const timer = setTimeout(exit, 0)
+    return () => clearTimeout(timer)
+  }, [exit, step])
+
+  return (
+    <AppStateProvider>
+      <TextEntryDialog
+        title="Provider"
+        subtitle={step === 'api' ? 'API key step' : 'Model step'}
+        description="Enter the next value"
+        initialValue={step === 'api' ? 'stale-secret-key' : 'fresh-model-name'}
+        mask={step === 'api' ? '*' : undefined}
+        onSubmit={() => {}}
+        onCancel={() => {}}
+      />
+    </AppStateProvider>
+  )
+}
+
+test('TextEntryDialog resets its input state when initialValue changes', async () => {
+  const output = await renderFinalFrame(<StepChangeHarness />)
+
+  expect(output).toContain('Model step')
+  expect(output).toContain('fresh-model-name')
+  expect(output).not.toContain('stale-secret-key')
+})
+
+test('wizard step remount prevents a typed API key from leaking into the next field', async () => {
+  const { stdout, stdin, getOutput } = createTestStreams()
+  const root = await createRoot({
+    stdout: stdout as unknown as NodeJS.WriteStream,
+    stdin: stdin as unknown as NodeJS.ReadStream,
+    patchConsole: false,
+  })
+
+  root.render(
+    <AppStateProvider>
+      <TextEntryDialog
+        resetStateKey="api"
+        title="Provider"
+        subtitle="API key step"
+        description="Enter the API key"
+        initialValue=""
+        mask="*"
+        onSubmit={() => {}}
+        onCancel={() => {}}
+      />
+    </AppStateProvider>,
+  )
+
+  await Bun.sleep(25)
+  stdin.write('sk-secret-12345678')
+  await Bun.sleep(25)
+
+  root.render(
+    <AppStateProvider>
+      <TextEntryDialog
+        resetStateKey="model"
+        title="Provider"
+        subtitle="Model step"
+        description="Enter the model"
+        initialValue=""
+        onSubmit={() => {}}
+        onCancel={() => {}}
+      />
+    </AppStateProvider>,
+  )
+
+  await Bun.sleep(25)
+  root.unmount()
+  stdin.end()
+  stdout.end()
+  await Bun.sleep(25)
+
+  const output = stripAnsi(extractLastFrame(getOutput()))
+  expect(output).toContain('Model step')
+  expect(output).not.toContain('sk-secret-12345678')
+})
+
+test('buildProfileSaveMessage maps provider fields without echoing secrets', () => {
+  const message = buildProfileSaveMessage(
+    'openai',
+    {
+      OPENAI_API_KEY: 'sk-secret-12345678',
+      OPENAI_MODEL: 'gpt-4o',
+      OPENAI_BASE_URL: 'https://api.openai.com/v1',
+    },
+    'D:/codings/Opensource/openclaude/.openclaude-profile.json',
+  )
+
+  expect(message).toContain('Saved OpenAI-compatible profile.')
+  expect(message).toContain('Model: gpt-4o')
+  expect(message).toContain('Endpoint: https://api.openai.com/v1')
+  expect(message).toContain('Credentials: configured')
+  expect(message).not.toContain('sk-secret-12345678')
+})
+
+test('buildCurrentProviderSummary redacts poisoned model and endpoint values', () => {
+  const summary = buildCurrentProviderSummary({
+    processEnv: {
+      CLAUDE_CODE_USE_OPENAI: '1',
+      OPENAI_API_KEY: 'sk-secret-12345678',
+      OPENAI_MODEL: 'sk-secret-12345678',
+      OPENAI_BASE_URL: 'sk-secret-12345678',
+    },
+    persisted: null,
+  })
+
+  expect(summary.providerLabel).toBe('OpenAI-compatible')
+  expect(summary.modelLabel).toBe('sk-...5678')
+  expect(summary.endpointLabel).toBe('sk-...5678')
+})
+
+test('getProviderWizardDefaults ignores poisoned current provider values', () => {
+  const defaults = getProviderWizardDefaults({
+    OPENAI_API_KEY: 'sk-secret-12345678',
+    OPENAI_MODEL: 'sk-secret-12345678',
+    OPENAI_BASE_URL: 'sk-secret-12345678',
+    GEMINI_API_KEY: 'AIzaSecret12345678',
+    GEMINI_MODEL: 'AIzaSecret12345678',
+  })
+
+  expect(defaults.openAIModel).toBe('gpt-4o')
+  expect(defaults.openAIBaseUrl).toBe('https://api.openai.com/v1')
+  expect(defaults.geminiModel).toBe('gemini-2.0-flash')
+})
diff --git a/src/commands/provider/provider.tsx b/src/commands/provider/provider.tsx
new file mode 100644
index 00000000..95109e7d
--- /dev/null
+++ b/src/commands/provider/provider.tsx
@@ -0,0 +1,1148 @@
+import * as React from 'react'
+
+import type { LocalJSXCommandCall, LocalJSXCommandOnDone } from '../../types/command.js'
+import { COMMON_HELP_ARGS, COMMON_INFO_ARGS } from '../../constants/xml.js'
+import TextInput from '../../components/TextInput.js'
+import {
+  Select,
+  type OptionWithDescription,
+} from '../../components/CustomSelect/index.js'
+import { Dialog } from '../../components/design-system/Dialog.js'
+import { LoadingState } from '../../components/design-system/LoadingState.js'
+import { useTerminalSize } from '../../hooks/useTerminalSize.js'
+import { Box, Text } from '../../ink.js'
+import {
+  DEFAULT_CODEX_BASE_URL,
+  DEFAULT_OPENAI_BASE_URL,
+  resolveCodexApiCredentials,
+  resolveProviderRequest,
+} from '../../services/api/providerConfig.js'
+import {
+  buildCodexProfileEnv,
+  buildGeminiProfileEnv,
+  buildOllamaProfileEnv,
+  buildOpenAIProfileEnv,
+  createProfileFile,
+  DEFAULT_GEMINI_BASE_URL,
+  DEFAULT_GEMINI_MODEL,
+  deleteProfileFile,
+  loadProfileFile,
+  maskSecretForDisplay,
+  redactSecretValueForDisplay,
+  sanitizeApiKey,
+  sanitizeProviderConfigValue,
+  saveProfileFile,
+  type ProfileEnv,
+  type ProfileFile,
+  type ProviderProfile,
+} from '../../utils/providerProfile.js'
+import {
+  getGoalDefaultOpenAIModel,
+  normalizeRecommendationGoal,
+  rankOllamaModels,
+  recommendOllamaModel,
+  type RecommendationGoal,
+} from '../../utils/providerRecommendation.js'
+import { hasLocalOllama, listOllamaModels } from '../../utils/providerDiscovery.js'
+
+type ProviderChoice = 'auto' | ProviderProfile | 'clear'
+
+type Step =
+  | { name: 'choose' }
+  | { name: 'auto-goal' }
+  | { name: 'auto-detect'; goal: RecommendationGoal }
+  | { name: 'ollama-detect' }
+  | { name: 'openai-key'; defaultModel: string }
+  | { name: 'openai-base'; apiKey: string; defaultModel: string }
+  | {
+      name: 'openai-model'
+      apiKey: string
+      baseUrl: string | null
+      defaultModel: string
+    }
+  | { name: 'gemini-key' }
+  | { name: 'gemini-model'; apiKey: string }
+  | { name: 'codex-check' }
+
+type CurrentProviderSummary = {
+  providerLabel: string
+  modelLabel: string
+  endpointLabel: string
+  savedProfileLabel: string
+}
+
+type SavedProfileSummary = {
+  providerLabel: string
+  modelLabel: string
+  endpointLabel: string
+  credentialLabel?: string
+}
+
+type TextEntryDialogProps = {
+  title: string
+  subtitle?: string
+  resetStateKey?: string
+  description: React.ReactNode
+  initialValue: string
+  placeholder?: string
+  mask?: string
+  allowEmpty?: boolean
+  validate?: (value: string) => string | null
+  onSubmit: (value: string) => void
+  onCancel: () => void
+}
+
+type ProviderWizardDefaults = {
+  openAIModel: string
+  openAIBaseUrl: string
+  geminiModel: string
+}
+
+function isEnvTruthy(value: string | undefined): boolean {
+  if (!value) return false
+  const normalized = value.trim().toLowerCase()
+  return normalized !== '' && normalized !== '0' && normalized !== 'false' && normalized !== 'no'
+}
+
+function getSafeDisplayValue(
+  value: string | undefined,
+  processEnv: NodeJS.ProcessEnv,
+  profileEnv?: ProfileEnv,
+  fallback = '(not set)',
+): string {
+  return (
+    redactSecretValueForDisplay(value, processEnv, profileEnv) ?? fallback
+  )
+}
+
+export function getProviderWizardDefaults(
+  processEnv: NodeJS.ProcessEnv = process.env,
+): ProviderWizardDefaults {
+  const safeOpenAIModel =
+    sanitizeProviderConfigValue(processEnv.OPENAI_MODEL, processEnv) ||
+    'gpt-4o'
+  const safeOpenAIBaseUrl =
+    sanitizeProviderConfigValue(processEnv.OPENAI_BASE_URL, processEnv) ||
+    DEFAULT_OPENAI_BASE_URL
+  const safeGeminiModel =
+    sanitizeProviderConfigValue(processEnv.GEMINI_MODEL, processEnv) ||
+    DEFAULT_GEMINI_MODEL
+
+  return {
+    openAIModel: safeOpenAIModel,
+    openAIBaseUrl: safeOpenAIBaseUrl,
+    geminiModel: safeGeminiModel,
+  }
+}
+
+export function buildCurrentProviderSummary(options?: {
+  processEnv?: NodeJS.ProcessEnv
+  persisted?: ProfileFile | null
+}): CurrentProviderSummary {
+  const processEnv = options?.processEnv ?? process.env
+  const persisted = options?.persisted ?? loadProfileFile()
+  const savedProfileLabel = persisted?.profile ?? 'none'
+
+  if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_GEMINI)) {
+    return {
+      providerLabel: 'Google Gemini',
+      modelLabel: getSafeDisplayValue(
+        processEnv.GEMINI_MODEL ?? DEFAULT_GEMINI_MODEL,
+        processEnv,
+      ),
+      endpointLabel: getSafeDisplayValue(
+        processEnv.GEMINI_BASE_URL ?? DEFAULT_GEMINI_BASE_URL,
+        processEnv,
+      ),
+      savedProfileLabel,
+    }
+  }
+
+  if (isEnvTruthy(processEnv.CLAUDE_CODE_USE_OPENAI)) {
+    const request = resolveProviderRequest({
+      model: processEnv.OPENAI_MODEL,
+      baseUrl: processEnv.OPENAI_BASE_URL,
+    })
+
+    let providerLabel = 'OpenAI-compatible'
+    if (request.transport === 'codex_responses') {
+      providerLabel = 'Codex'
+    } else if (request.baseUrl.includes('localhost:11434')) {
+      providerLabel = 'Ollama'
+    } else if (request.baseUrl.includes('localhost:1234')) {
+      providerLabel = 'LM Studio'
+    }
+
+    return {
+      providerLabel,
+      modelLabel: getSafeDisplayValue(request.requestedModel, processEnv),
+      endpointLabel: getSafeDisplayValue(request.baseUrl, processEnv),
+      savedProfileLabel,
+    }
+  }
+
+  return {
+    providerLabel: 'Anthropic',
+    modelLabel: getSafeDisplayValue(
+      processEnv.ANTHROPIC_MODEL ??
+        processEnv.CLAUDE_MODEL ??
+        'claude-sonnet-4-6',
+      processEnv,
+    ),
+    endpointLabel: getSafeDisplayValue(
+      processEnv.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com',
+      processEnv,
+    ),
+    savedProfileLabel,
+  }
+}
+
+function buildSavedProfileSummary(
+  profile: ProviderProfile,
+  env: ProfileEnv,
+): SavedProfileSummary {
+  switch (profile) {
+    case 'gemini':
+      return {
+        providerLabel: 'Google Gemini',
+        modelLabel: getSafeDisplayValue(
+          env.GEMINI_MODEL ?? DEFAULT_GEMINI_MODEL,
+          process.env,
+          env,
+        ),
+        endpointLabel: getSafeDisplayValue(
+          env.GEMINI_BASE_URL ?? DEFAULT_GEMINI_BASE_URL,
+          process.env,
+          env,
+        ),
+        credentialLabel:
+          maskSecretForDisplay(env.GEMINI_API_KEY) !== undefined
+            ? 'configured'
+            : undefined,
+      }
+    case 'codex':
+      return {
+        providerLabel: 'Codex',
+        modelLabel: getSafeDisplayValue(
+          env.OPENAI_MODEL ?? 'codexplan',
+          process.env,
+          env,
+        ),
+        endpointLabel: getSafeDisplayValue(
+          env.OPENAI_BASE_URL ?? DEFAULT_CODEX_BASE_URL,
+          process.env,
+          env,
+        ),
+        credentialLabel:
+          maskSecretForDisplay(env.CODEX_API_KEY) !== undefined
+            ? 'configured'
+            : undefined,
+      }
+    case 'ollama':
+      return {
+        providerLabel: 'Ollama',
+        modelLabel: getSafeDisplayValue(
+          env.OPENAI_MODEL,
+          process.env,
+          env,
+        ),
+        endpointLabel: getSafeDisplayValue(
+          env.OPENAI_BASE_URL,
+          process.env,
+          env,
+        ),
+      }
+    case 'openai':
+    default:
+      return {
+        providerLabel: 'OpenAI-compatible',
+        modelLabel: getSafeDisplayValue(
+          env.OPENAI_MODEL ?? 'gpt-4o',
+          process.env,
+          env,
+        ),
+        endpointLabel: getSafeDisplayValue(
+          env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL,
+          process.env,
+          env,
+        ),
+        credentialLabel:
+          maskSecretForDisplay(env.OPENAI_API_KEY) !== undefined
+            ? 'configured'
+            : undefined,
+      }
+  }
+}
+
+export function buildProfileSaveMessage(
+  profile: ProviderProfile,
+  env: ProfileEnv,
+  filePath: string,
+): string {
+  const summary = buildSavedProfileSummary(profile, env)
+  const lines = [
+    `Saved ${summary.providerLabel} profile.`,
+    `Model: ${summary.modelLabel}`,
+    `Endpoint: ${summary.endpointLabel}`,
+  ]
+
+  if (summary.credentialLabel) {
+    lines.push(`Credentials: ${summary.credentialLabel}`)
+  }
+
+  lines.push(`Profile: ${filePath}`)
+  lines.push('Restart OpenClaude to use it.')
+
+  return lines.join('\n')
+}
+
+function buildUsageText(): string {
+  const summary = buildCurrentProviderSummary()
+  return [
+    'Usage: /provider',
+    '',
+    'Guided setup for saved provider profiles.',
+    '',
+    `Current provider: ${summary.providerLabel}`,
+    `Current model: ${summary.modelLabel}`,
+    `Current endpoint: ${summary.endpointLabel}`,
+    `Saved profile: ${summary.savedProfileLabel}`,
+    '',
+    'Choose Auto, Ollama, OpenAI-compatible, Gemini, or Codex, then save a profile for the next OpenClaude restart.',
+  ].join('\n')
+}
+
+function finishProfileSave(
+  onDone: LocalJSXCommandOnDone,
+  profile: ProviderProfile,
+  env: ProfileEnv,
+): void {
+  try {
+    const profileFile = createProfileFile(profile, env)
+    const filePath = saveProfileFile(profileFile)
+    onDone(buildProfileSaveMessage(profile, env, filePath), {
+      display: 'system',
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    onDone(`Failed to save provider profile: ${message}`, {
+      display: 'system',
+    })
+  }
+}
+
+export function TextEntryDialog({
+  title,
+  subtitle,
+  resetStateKey,
+  description,
+  initialValue,
+  placeholder,
+  mask,
+  allowEmpty = false,
+  validate,
+  onSubmit,
+  onCancel,
+}: TextEntryDialogProps): React.ReactNode {
+  const { columns } = useTerminalSize()
+  const [value, setValue] = React.useState(initialValue)
+  const [cursorOffset, setCursorOffset] = React.useState(initialValue.length)
+  const [error, setError] = React.useState<string | null>(null)
+
+  React.useLayoutEffect(() => {
+    setValue(initialValue)
+    setCursorOffset(initialValue.length)
+    setError(null)
+  }, [initialValue, resetStateKey])
+
+  const inputColumns = Math.max(30, columns - 6)
+
+  const handleSubmit = React.useCallback(
+    (nextValue: string) => {
+      if (!allowEmpty && nextValue.trim().length === 0) {
+        setError('A value is required for this step.')
+        return
+      }
+
+      const validationError = validate?.(nextValue)
+      if (validationError) {
+        setError(validationError)
+        return
+      }
+
+      setError(null)
+      onSubmit(nextValue)
+    },
+    [allowEmpty, onSubmit, validate],
+  )
+
+  return (
+    <Dialog title={title} subtitle={subtitle} onCancel={onCancel}>
+      <Box flexDirection="column" gap={1}>
+        <Text>{description}</Text>
+        <TextInput
+          value={value}
+          onChange={setValue}
+          onSubmit={handleSubmit}
+          placeholder={placeholder}
+          mask={mask}
+          columns={inputColumns}
+          cursorOffset={cursorOffset}
+          onChangeCursorOffset={setCursorOffset}
+          focus
+          showCursor
+        />
+        {error ? <Text color="error">{error}</Text> : null}
+      </Box>
+    </Dialog>
+  )
+}
+
+function ProviderChooser({
+  onChoose,
+  onCancel,
+}: {
+  onChoose: (value: ProviderChoice) => void
+  onCancel: () => void
+}): React.ReactNode {
+  const summary = buildCurrentProviderSummary()
+  const options: OptionWithDescription<ProviderChoice>[] = [
+    {
+      label: 'Auto',
+      value: 'auto',
+      description:
+        'Prefer local Ollama when available, otherwise guide you into OpenAI-compatible setup',
+    },
+    {
+      label: 'Ollama',
+      value: 'ollama',
+      description: 'Use a local Ollama model with no API key',
+    },
+    {
+      label: 'OpenAI-compatible',
+      value: 'openai',
+      description:
+        'GPT-4o, DeepSeek, OpenRouter, Groq, LM Studio, and similar APIs',
+    },
+    {
+      label: 'Gemini',
+      value: 'gemini',
+      description: 'Use a Google Gemini API key',
+    },
+    {
+      label: 'Codex',
+      value: 'codex',
+      description: 'Use existing ChatGPT Codex CLI auth or env credentials',
+    },
+  ]
+
+  if (summary.savedProfileLabel !== 'none') {
+    options.push({
+      label: 'Clear saved profile',
+      value: 'clear',
+      description: 'Remove .openclaude-profile.json and return to normal startup',
+    })
+  }
+
+  return (
+    <Dialog
+      title="Set up a provider profile"
+      subtitle={`Current provider: ${summary.providerLabel}`}
+      onCancel={onCancel}
+    >
+      <Box flexDirection="column" gap={1}>
+        <Text>
+          Save a provider profile for the next OpenClaude restart without
+          editing environment variables first.
+        </Text>
+        <Box flexDirection="column">
+          <Text dimColor>Current model: {summary.modelLabel}</Text>
+          <Text dimColor>Current endpoint: {summary.endpointLabel}</Text>
+          <Text dimColor>Saved profile: {summary.savedProfileLabel}</Text>
+        </Box>
+        <Select
+          options={options}
+          inlineDescriptions
+          visibleOptionCount={options.length}
+          onChange={onChoose}
+          onCancel={onCancel}
+        />
+      </Box>
+    </Dialog>
+  )
+}
+
+function AutoGoalChooser({
+  onChoose,
+  onBack,
+}: {
+  onChoose: (goal: RecommendationGoal) => void
+  onBack: () => void
+}): React.ReactNode {
+  const options: OptionWithDescription<RecommendationGoal>[] = [
+    {
+      label: 'Balanced',
+      value: 'balanced',
+      description: 'Strong everyday default for most users',
+    },
+    {
+      label: 'Coding',
+      value: 'coding',
+      description: 'Prefer coding-oriented local models or GPT-4o defaults',
+    },
+    {
+      label: 'Latency',
+      value: 'latency',
+      description: 'Prefer faster local models or gpt-4o-mini defaults',
+    },
+  ]
+
+  return (
+    <Dialog title="Auto setup goal" onCancel={onBack}>
+      <Box flexDirection="column" gap={1}>
+        <Text>Pick the goal Auto setup should optimize for.</Text>
+        <Select
+          options={options}
+          defaultValue="balanced"
+          defaultFocusValue="balanced"
+          inlineDescriptions
+          visibleOptionCount={options.length}
+          onChange={onChoose}
+          onCancel={onBack}
+        />
+      </Box>
+    </Dialog>
+  )
+}
+
+function AutoRecommendationStep({
+  goal,
+  onBack,
+  onSave,
+  onNeedOpenAI,
+  onCancel,
+}: {
+  goal: RecommendationGoal
+  onBack: () => void
+  onSave: (profile: ProviderProfile, env: ProfileEnv) => void
+  onNeedOpenAI: (defaultModel: string) => void
+  onCancel: () => void
+}): React.ReactNode {
+  const [status, setStatus] = React.useState<
+    | {
+        state: 'loading'
+      }
+    | {
+        state: 'ollama'
+        model: string
+        summary: string
+      }
+    | {
+        state: 'openai'
+        defaultModel: string
+      }
+    | {
+        state: 'error'
+        message: string
+      }
+  >({ state: 'loading' })
+
+  React.useEffect(() => {
+    let cancelled = false
+
+    void (async () => {
+      const defaultModel = getGoalDefaultOpenAIModel(goal)
+      try {
+        const ollamaAvailable = await hasLocalOllama()
+        if (!ollamaAvailable) {
+          if (!cancelled) {
+            setStatus({ state: 'openai', defaultModel })
+          }
+          return
+        }
+
+        const models = await listOllamaModels()
+        const recommended = recommendOllamaModel(models, goal)
+        if (!recommended) {
+          if (!cancelled) {
+            setStatus({ state: 'openai', defaultModel })
+          }
+          return
+        }
+
+        if (!cancelled) {
+          setStatus({
+            state: 'ollama',
+            model: recommended.name,
+            summary: recommended.summary,
+          })
+        }
+      } catch (error) {
+        if (!cancelled) {
+          setStatus({
+            state: 'error',
+            message: error instanceof Error ? error.message : String(error),
+          })
+        }
+      }
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [goal])
+
+  if (status.state === 'loading') {
+    return <LoadingState message="Checking local providers…" />
+  }
+
+  if (status.state === 'error') {
+    return (
+      <Dialog title="Auto setup failed" onCancel={onCancel} color="warning">
+        <Box flexDirection="column" gap={1}>
+          <Text>{status.message}</Text>
+          <Select
+            options={[
+              { label: 'Back', value: 'back' },
+              { label: 'Cancel', value: 'cancel' },
+            ]}
+            onChange={value => (value === 'back' ? onBack() : onCancel())}
+            onCancel={onCancel}
+          />
+        </Box>
+      </Dialog>
+    )
+  }
+
+  if (status.state === 'openai') {
+    return (
+      <Dialog title="Auto setup fallback" onCancel={onCancel}>
+        <Box flexDirection="column" gap={1}>
+          <Text>
+            No viable local Ollama chat model was detected. Auto setup can
+            continue into OpenAI-compatible setup with a default model of{' '}
+            {status.defaultModel}.
+          </Text>
+          <Select
+            options={[
+              { label: 'Continue to OpenAI-compatible setup', value: 'continue' },
+              { label: 'Back', value: 'back' },
+              { label: 'Cancel', value: 'cancel' },
+            ]}
+            onChange={value => {
+              if (value === 'continue') {
+                onNeedOpenAI(status.defaultModel)
+              } else if (value === 'back') {
+                onBack()
+              } else {
+                onCancel()
+              }
+            }}
+            onCancel={onCancel}
+          />
+        </Box>
+      </Dialog>
+    )
+  }
+
+  return (
+    <Dialog title="Save recommended profile?" onCancel={onBack}>
+      <Box flexDirection="column" gap={1}>
+        <Text>
+          Auto setup recommends a local Ollama profile for {goal} based on the
+          models currently available on this machine.
+        </Text>
+        <Text dimColor>
+          Recommended model: {status.model}
+          {status.summary ? ` · ${status.summary}` : ''}
+        </Text>
+        <Select
+          options={[
+            { label: 'Save recommended Ollama profile', value: 'save' },
+            { label: 'Back', value: 'back' },
+            { label: 'Cancel', value: 'cancel' },
+          ]}
+          onChange={value => {
+            if (value === 'save') {
+              onSave(
+                'ollama',
+                buildOllamaProfileEnv(status.model, {
+                  getOllamaChatBaseUrl,
+                }),
+              )
+            } else if (value === 'back') {
+              onBack()
+            } else {
+              onCancel()
+            }
+          }}
+          onCancel={onBack}
+        />
+      </Box>
+    </Dialog>
+  )
+}
+
+function OllamaModelStep({
+  onSave,
+  onBack,
+  onCancel,
+}: {
+  onSave: (profile: ProviderProfile, env: ProfileEnv) => void
+  onBack: () => void
+  onCancel: () => void
+}): React.ReactNode {
+  const [status, setStatus] = React.useState<
+    | { state: 'loading' }
+    | {
+        state: 'ready'
+        options: OptionWithDescription<string>[]
+        defaultValue?: string
+      }
+    | { state: 'unavailable'; message: string }
+  >({ state: 'loading' })
+
+  React.useEffect(() => {
+    let cancelled = false
+
+    void (async () => {
+      const available = await hasLocalOllama()
+      if (!available) {
+        if (!cancelled) {
+          setStatus({
+            state: 'unavailable',
+            message:
+              'Could not reach Ollama at http://localhost:11434. Start Ollama first, then run /provider again.',
+          })
+        }
+        return
+      }
+
+      const models = await listOllamaModels()
+      if (models.length === 0) {
+        if (!cancelled) {
+          setStatus({
+            state: 'unavailable',
+            message:
+              'Ollama is running, but no installed models were found. Pull a chat model such as qwen2.5-coder:7b or llama3.1:8b first.',
+          })
+        }
+        return
+      }
+
+      const ranked = rankOllamaModels(models, 'balanced')
+      const recommended = recommendOllamaModel(models, 'balanced')
+      if (!cancelled) {
+        setStatus({
+          state: 'ready',
+          defaultValue: recommended?.name ?? ranked[0]?.name,
+          options: ranked.map(model => ({
+            label: model.name,
+            value: model.name,
+            description: model.summary,
+          })),
+        })
+      }
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  if (status.state === 'loading') {
+    return <LoadingState message="Checking local Ollama models…" />
+  }
+
+  if (status.state === 'unavailable') {
+    return (
+      <Dialog title="Ollama setup" onCancel={onCancel} color="warning">
+        <Box flexDirection="column" gap={1}>
+          <Text>{status.message}</Text>
+          <Select
+            options={[
+              { label: 'Back', value: 'back' },
+              { label: 'Cancel', value: 'cancel' },
+            ]}
+            onChange={value => (value === 'back' ? onBack() : onCancel())}
+            onCancel={onCancel}
+          />
+        </Box>
+      </Dialog>
+    )
+  }
+
+  return (
+    <Dialog title="Choose an Ollama model" onCancel={onBack}>
+      <Box flexDirection="column" gap={1}>
+        <Text>
+          Pick one of the installed Ollama models to save into a local provider
+          profile.
+        </Text>
+        <Select
+          options={status.options}
+          defaultValue={status.defaultValue}
+          defaultFocusValue={status.defaultValue}
+          inlineDescriptions
+          visibleOptionCount={Math.min(8, status.options.length)}
+          onChange={value => {
+            onSave(
+              'ollama',
+              buildOllamaProfileEnv(value, {
+                getOllamaChatBaseUrl,
+              }),
+            )
+          }}
+          onCancel={onBack}
+        />
+      </Box>
+    </Dialog>
+  )
+}
+
+function CodexCredentialStep({
+  onSave,
+  onBack,
+  onCancel,
+}: {
+  onSave: (profile: ProviderProfile, env: ProfileEnv) => void
+  onBack: () => void
+  onCancel: () => void
+}): React.ReactNode {
+  const credentials = resolveCodexCredentials(process.env)
+
+  if (!credentials.ok) {
+    return (
+      <Dialog title="Codex setup" onCancel={onCancel} color="warning">
+        <Box flexDirection="column" gap={1}>
+          <Text>{credentials.message}</Text>
+          <Select
+            options={[
+              { label: 'Back', value: 'back' },
+              { label: 'Cancel', value: 'cancel' },
+            ]}
+            onChange={value => (value === 'back' ? onBack() : onCancel())}
+            onCancel={onCancel}
+          />
+        </Box>
+      </Dialog>
+    )
+  }
+
+  const options: OptionWithDescription<string>[] = [
+    {
+      label: 'codexplan',
+      value: 'codexplan',
+      description: 'GPT-5.4 with higher reasoning on the Codex backend',
+    },
+    {
+      label: 'codexspark',
+      value: 'codexspark',
+      description: 'Faster Codex Spark tool loop profile',
+    },
+  ]
+
+  return (
+    <Dialog title="Choose a Codex profile" onCancel={onBack}>
+      <Box flexDirection="column" gap={1}>
+        <Text>
+          Reuse your existing Codex credentials from{' '}
+          {credentials.sourceDescription} and save a model alias profile.
+        </Text>
+        <Select
+          options={options}
+          defaultValue="codexplan"
+          defaultFocusValue="codexplan"
+          inlineDescriptions
+          visibleOptionCount={options.length}
+          onChange={value => {
+            const env = buildCodexProfileEnv({
+              model: value,
+              processEnv: process.env,
+            })
+            if (env) {
+              onSave('codex', env)
+            }
+          }}
+          onCancel={onBack}
+        />
+      </Box>
+    </Dialog>
+  )
+}
+
+function resolveCodexCredentials(processEnv: NodeJS.ProcessEnv):
+  | { ok: true; sourceDescription: string }
+  | { ok: false; message: string } {
+  const credentials = resolveCodexApiCredentials(processEnv)
+
+  if (!credentials.apiKey) {
+    const authHint = credentials.authPath
+      ? `Expected auth file: ${credentials.authPath}.`
+      : 'Set CODEX_API_KEY or re-login with the Codex CLI.'
+    return {
+      ok: false,
+      message: `Codex setup needs existing credentials. Re-login with the Codex CLI or set CODEX_API_KEY. ${authHint}`,
+    }
+  }
+
+  if (!credentials.accountId) {
+    return {
+      ok: false,
+      message:
+        'Codex auth is missing chatgpt_account_id. Re-login with the Codex CLI or set CHATGPT_ACCOUNT_ID/CODEX_ACCOUNT_ID first.',
+    }
+  }
+
+  return {
+    ok: true,
+    sourceDescription:
+      credentials.source === 'env'
+        ? 'the current shell environment'
+        : credentials.authPath ?? DEFAULT_CODEX_BASE_URL,
+  }
+}
+
+function ProviderWizard({ onDone }: { onDone: LocalJSXCommandOnDone }): React.ReactNode {
+  const defaults = getProviderWizardDefaults()
+  const [step, setStep] = React.useState<Step>({ name: 'choose' })
+
+  switch (step.name) {
+    case 'choose':
+      return (
+        <ProviderChooser
+          onChoose={value => {
+            if (value === 'auto') {
+              setStep({ name: 'auto-goal' })
+            } else if (value === 'ollama') {
+              setStep({ name: 'ollama-detect' })
+            } else if (value === 'openai') {
+              setStep({
+                name: 'openai-key',
+                defaultModel: defaults.openAIModel,
+              })
+            } else if (value === 'gemini') {
+              setStep({ name: 'gemini-key' })
+            } else if (value === 'clear') {
+              const filePath = deleteProfileFile()
+              onDone(`Removed saved provider profile at ${filePath}. Restart OpenClaude to go back to normal startup.`, {
+                display: 'system',
+              })
+            } else {
+              setStep({ name: 'codex-check' })
+            }
+          }}
+          onCancel={() => onDone()}
+        />
+      )
+
+    case 'auto-goal':
+      return (
+        <AutoGoalChooser
+          onChoose={goal => setStep({ name: 'auto-detect', goal })}
+          onBack={() => setStep({ name: 'choose' })}
+        />
+      )
+
+    case 'auto-detect':
+      return (
+        <AutoRecommendationStep
+          goal={step.goal}
+          onBack={() => setStep({ name: 'auto-goal' })}
+          onSave={(profile, env) => finishProfileSave(onDone, profile, env)}
+          onNeedOpenAI={defaultModel =>
+            setStep({ name: 'openai-key', defaultModel })
+          }
+          onCancel={() => onDone()}
+        />
+      )
+
+    case 'ollama-detect':
+      return (
+        <OllamaModelStep
+          onSave={(profile, env) => finishProfileSave(onDone, profile, env)}
+          onBack={() => setStep({ name: 'choose' })}
+          onCancel={() => onDone()}
+        />
+      )
+
+    case 'openai-key':
+      return (
+        <TextEntryDialog
+          resetStateKey={step.name}
+          title="OpenAI-compatible setup"
+          subtitle="Step 1 of 3"
+          description={
+            process.env.OPENAI_API_KEY
+              ? 'Enter an API key, or leave this blank to reuse the current OPENAI_API_KEY from this session.'
+              : 'Enter the API key for your OpenAI-compatible provider.'
+          }
+          initialValue=""
+          placeholder="sk-..."
+          mask="*"
+          allowEmpty={Boolean(process.env.OPENAI_API_KEY)}
+          validate={value => {
+            const candidate = value.trim() || process.env.OPENAI_API_KEY || ''
+            return sanitizeApiKey(candidate)
+              ? null
+              : 'Enter a real API key. Placeholder values like SUA_CHAVE are not valid.'
+          }}
+          onSubmit={value => {
+            const apiKey = value.trim() || process.env.OPENAI_API_KEY || ''
+            setStep({
+              name: 'openai-base',
+              apiKey,
+              defaultModel: step.defaultModel,
+            })
+          }}
+          onCancel={() => setStep({ name: 'choose' })}
+        />
+      )
+
+    case 'openai-base':
+      return (
+        <TextEntryDialog
+          resetStateKey={step.name}
+          title="OpenAI-compatible setup"
+          subtitle="Step 2 of 3"
+          description={`Optionally enter a base URL. Leave blank for ${DEFAULT_OPENAI_BASE_URL}.`}
+          initialValue={
+            defaults.openAIBaseUrl === DEFAULT_OPENAI_BASE_URL
+              ? ''
+              : defaults.openAIBaseUrl
+          }
+          placeholder={DEFAULT_OPENAI_BASE_URL}
+          allowEmpty
+          onSubmit={value => {
+            setStep({
+              name: 'openai-model',
+              apiKey: step.apiKey,
+              baseUrl: value.trim() || null,
+              defaultModel: step.defaultModel,
+            })
+          }}
+          onCancel={() =>
+            setStep({
+              name: 'openai-key',
+              defaultModel: step.defaultModel,
+            })
+          }
+        />
+      )
+
+    case 'openai-model':
+      return (
+        <TextEntryDialog
+          resetStateKey={step.name}
+          title="OpenAI-compatible setup"
+          subtitle="Step 3 of 3"
+          description={`Enter a model name. Leave blank for ${step.defaultModel}.`}
+          initialValue={defaults.openAIModel ?? step.defaultModel}
+          placeholder={step.defaultModel}
+          allowEmpty
+          onSubmit={value => {
+            const env = buildOpenAIProfileEnv({
+              goal: normalizeRecommendationGoal(null),
+              apiKey: step.apiKey,
+              baseUrl: step.baseUrl,
+              model: value.trim() || step.defaultModel,
+              processEnv: {},
+            })
+            if (env) {
+              finishProfileSave(onDone, 'openai', env)
+            }
+          }}
+          onCancel={() =>
+            setStep({
+              name: 'openai-base',
+              apiKey: step.apiKey,
+              defaultModel: step.defaultModel,
+            })
+          }
+        />
+      )
+
+    case 'gemini-key':
+      return (
+        <TextEntryDialog
+          resetStateKey={step.name}
+          title="Gemini setup"
+          subtitle="Step 1 of 2"
+          description={
+            process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
+              ? 'Enter a Gemini API key, or leave this blank to reuse the current GEMINI_API_KEY/GOOGLE_API_KEY from this session.'
+              : 'Enter a Gemini API key. You can create one at https://aistudio.google.com/apikey.'
+          }
+          initialValue=""
+          placeholder="AIza..."
+          mask="*"
+          allowEmpty={Boolean(
+            process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+          )}
+          onSubmit={value => {
+            const apiKey =
+              value.trim() ||
+              process.env.GEMINI_API_KEY ||
+              process.env.GOOGLE_API_KEY ||
+              ''
+            setStep({ name: 'gemini-model', apiKey })
+          }}
+          onCancel={() => setStep({ name: 'choose' })}
+        />
+      )
+
+    case 'gemini-model':
+      return (
+        <TextEntryDialog
+          resetStateKey={step.name}
+          title="Gemini setup"
+          subtitle="Step 2 of 2"
+          description={`Enter a Gemini model name. Leave blank for ${DEFAULT_GEMINI_MODEL}.`}
+          initialValue={defaults.geminiModel}
+          placeholder={DEFAULT_GEMINI_MODEL}
+          allowEmpty
+          onSubmit={value => {
+            const env = buildGeminiProfileEnv({
+              apiKey: step.apiKey,
+              model: value.trim() || DEFAULT_GEMINI_MODEL,
+              processEnv: {},
+            })
+            if (env) {
+              finishProfileSave(onDone, 'gemini', env)
+            }
+          }}
+          onCancel={() => setStep({ name: 'gemini-key' })}
+        />
+      )
+
+    case 'codex-check':
+      return (
+        <CodexCredentialStep
+          onSave={(profile, env) => finishProfileSave(onDone, profile, env)}
+          onBack={() => setStep({ name: 'choose' })}
+          onCancel={() => onDone()}
+        />
+      )
+  }
+}
+
+export const call: LocalJSXCommandCall = async (onDone, _context, args) => {
+  const normalizedArgs = args?.trim().toLowerCase() || ''
+
+  if (COMMON_INFO_ARGS.includes(normalizedArgs)) {
+    onDone(buildUsageText(), { display: 'system' })
+    return null
+  }
+
+  if (COMMON_HELP_ARGS.includes(normalizedArgs)) {
+    onDone(buildUsageText(), { display: 'system' })
+    return null
+  }
+
+  if (normalizedArgs) {
+    onDone('Usage: /provider', { display: 'system' })
+    return null
+  }
+
+  return <ProviderWizard onDone={onDone} />
+}
diff --git a/src/components/ConsoleOAuthFlow.tsx b/src/components/ConsoleOAuthFlow.tsx
index 873caf73..c0feb587 100644
--- a/src/components/ConsoleOAuthFlow.tsx
+++ b/src/components/ConsoleOAuthFlow.tsx
@@ -460,7 +460,7 @@ function OAuthStatusMessage(t0) {
         let t2;
         let t3;
         if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
-          t2 = <Text>OpenClaude supports OpenAI-compatible providers (GPT-4o, DeepSeek, Ollama, Groq), Google Gemini, Amazon Bedrock, Microsoft Foundry, and Vertex AI. Set the required environment variables, then restart OpenClaude.</Text>;
+          t2 = <Text>OpenClaude supports OpenAI-compatible providers (GPT-4o, DeepSeek, Ollama, Groq), Google Gemini, Amazon Bedrock, Microsoft Foundry, and Vertex AI. Run <Text bold={true}>/provider</Text> to save a provider profile, or set the required environment variables manually, then restart OpenClaude.</Text>;
           t3 = <Text>If you are part of an enterprise organization, contact your administrator for setup instructions.</Text>;
           $[13] = t2;
           $[14] = t3;
@@ -491,9 +491,10 @@ function OAuthStatusMessage(t0) {
         }
         let t7;
         if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
-          t7 = <Box flexDirection="column" marginTop={1}>{t4}
-            <Text>· OpenAI / any OpenAI-compatible provider (GPT-4o, DeepSeek, Ollama, Groq):{"\n"}{"  "}CLAUDE_CODE_USE_OPENAI=1  OPENAI_API_KEY=sk-...  OPENAI_MODEL=gpt-4o</Text>
-            <Text>· Google Gemini (free key at https://aistudio.google.com/apikey):{"\n"}{"  "}CLAUDE_CODE_USE_GEMINI=1  GEMINI_API_KEY=your-key</Text>
+            t7 = <Box flexDirection="column" marginTop={1}>{t4}
+              <Text>· Guided setup inside OpenClaude:{"\n"}{"  "}/provider</Text>
+              <Text>· OpenAI / any OpenAI-compatible provider (GPT-4o, DeepSeek, Ollama, Groq):{"\n"}{"  "}CLAUDE_CODE_USE_OPENAI=1  OPENAI_API_KEY=sk-...  OPENAI_MODEL=gpt-4o</Text>
+              <Text>· Google Gemini (free key at https://aistudio.google.com/apikey):{"\n"}{"  "}CLAUDE_CODE_USE_GEMINI=1  GEMINI_API_KEY=your-key</Text>
             {t5}{t6}<Text>· Vertex AI:{" "}<Link url="https://code.claude.com/docs/en/google-vertex-ai">https://code.claude.com/docs/en/google-vertex-ai</Link></Text></Box>;
           $[18] = t7;
         } else {
@@ -631,4 +632,4 @@ function OAuthStatusMessage(t0) {
       }
   }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","installOAuthTokens","useTerminalSize","setClipboard","useTerminalNotification","Box","Link","Text","useKeybinding","getSSLErrorHint","sendNotification","OAuthService","getOauthAccountInfo","validateForceLoginOrg","logError","getSettings_DEPRECATED","Select","KeyboardShortcutHint","Spinner","TextInput","Props","onDone","startingMessage","mode","forceLoginMethod","OAuthStatus","state","url","nextState","token","message","toRetry","PASTE_HERE_MSG","ConsoleOAuthFlow","forceLoginMethodProp","ReactNode","settings","orgUUID","forceLoginOrgUUID","forcedMethodMessage","terminal","oauthStatus","setOAuthStatus","pastedCode","setPastedCode","cursorOffset","setCursorOffset","oauthService","loginWithClaudeAi","setLoginWithClaudeAi","showPastePrompt","setShowPastePrompt","urlCopied","setUrlCopied","textInputColumns","columns","length","timer","setTimeout","clearTimeout","context","isActive","then","raw","process","stdout","write","handleSubmitCode","value","authorizationCode","split","handleManualAuthCodeInput","err","Error","startOAuth","result","startOAuthFlow","inferenceOnly","expiresIn","undefined","catch","isTokenExchangeError","includes","sslHint","error","ssl_error","accessToken","orgResult","valid","notificationType","errorMessage","pendingOAuthStartRef","current","nextTick","Promise","MutableRefObject","cleanup","OAuthStatusMessageProps","offset","status","OAuthStatusMessage","t0","$","_c","t1","t2","t3","Symbol","for","t4","label","t5","t6","t7","value_0","t8","emailAddress"],"sources":["ConsoleOAuthFlow.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { installOAuthTokens } from '../cli/handlers/auth.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { setClipboard } from '../ink/termio/osc.js'\nimport { useTerminalNotification } from '../ink/useTerminalNotification.js'\nimport { Box, Link, Text } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport { getSSLErrorHint } from '../services/api/errorUtils.js'\nimport { sendNotification } from '../services/notifier.js'\nimport { OAuthService } from '../services/oauth/index.js'\nimport { getOauthAccountInfo, validateForceLoginOrg } from '../utils/auth.js'\nimport { logError } from '../utils/log.js'\nimport { getSettings_DEPRECATED } from '../utils/settings/settings.js'\nimport { Select } from './CustomSelect/select.js'\nimport { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'\nimport { Spinner } from './Spinner.js'\nimport TextInput from './TextInput.js'\n\ntype Props = {\n  onDone(): void\n  startingMessage?: string\n  mode?: 'login' | 'setup-token'\n  forceLoginMethod?: 'claudeai' | 'console'\n}\n\ntype OAuthStatus =\n  | { state: 'idle' } // Initial state, waiting to select login method\n  | { state: 'platform_setup' } // Show platform setup info (Bedrock/Vertex/Foundry)\n  | { state: 'ready_to_start' } // Flow started, waiting for browser to open\n  | { state: 'waiting_for_login'; url: string } // Browser opened, waiting for user to login\n  | { state: 'creating_api_key' } // Got access token, creating API key\n  | { state: 'about_to_retry'; nextState: OAuthStatus }\n  | { state: 'success'; token?: string }\n  | {\n      state: 'error'\n      message: string\n      toRetry?: OAuthStatus\n    }\n\nconst PASTE_HERE_MSG = 'Paste code here if prompted > '\n\nexport function ConsoleOAuthFlow({\n  onDone,\n  startingMessage,\n  mode = 'login',\n  forceLoginMethod: forceLoginMethodProp,\n}: Props): React.ReactNode {\n  const settings = getSettings_DEPRECATED() || {}\n  const forceLoginMethod = forceLoginMethodProp ?? settings.forceLoginMethod\n  const orgUUID = settings.forceLoginOrgUUID\n  const forcedMethodMessage =\n    forceLoginMethod === 'claudeai'\n      ? 'Login method pre-selected: Subscription Plan (Claude Pro/Max)'\n      : forceLoginMethod === 'console'\n        ? 'Login method pre-selected: API Usage Billing (Anthropic Console)'\n        : null\n\n  const terminal = useTerminalNotification()\n\n  const [oauthStatus, setOAuthStatus] = useState<OAuthStatus>(() => {\n    if (mode === 'setup-token') {\n      return { state: 'ready_to_start' }\n    }\n    if (forceLoginMethod === 'claudeai' || forceLoginMethod === 'console') {\n      return { state: 'ready_to_start' }\n    }\n    return { state: 'idle' }\n  })\n\n  const [pastedCode, setPastedCode] = useState('')\n  const [cursorOffset, setCursorOffset] = useState(0)\n  const [oauthService] = useState(() => new OAuthService())\n  const [loginWithClaudeAi, setLoginWithClaudeAi] = useState(() => {\n    // Use Claude AI auth for setup-token mode to support user:inference scope\n    return mode === 'setup-token' || forceLoginMethod === 'claudeai'\n  })\n  // After a few seconds we suggest the user to copy/paste url if the\n  // browser did not open automatically. In this flow we expect the user to\n  // copy the code from the browser and paste it in the terminal\n  const [showPastePrompt, setShowPastePrompt] = useState(false)\n  const [urlCopied, setUrlCopied] = useState(false)\n\n  const textInputColumns = useTerminalSize().columns - PASTE_HERE_MSG.length - 1\n\n  // Log forced login method on mount\n  useEffect(() => {\n    if (forceLoginMethod === 'claudeai') {\n      logEvent('tengu_oauth_claudeai_forced', {})\n    } else if (forceLoginMethod === 'console') {\n      logEvent('tengu_oauth_console_forced', {})\n    }\n  }, [forceLoginMethod])\n\n  // Retry logic\n  useEffect(() => {\n    if (oauthStatus.state === 'about_to_retry') {\n      const timer = setTimeout(setOAuthStatus, 1000, oauthStatus.nextState)\n      return () => clearTimeout(timer)\n    }\n  }, [oauthStatus])\n\n  // Handle Enter to continue on success state\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      logEvent('tengu_oauth_success', { loginWithClaudeAi })\n      onDone()\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'success' && mode !== 'setup-token',\n    },\n  )\n\n  // Handle Enter to continue from platform setup\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      setOAuthStatus({ state: 'idle' })\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'platform_setup',\n    },\n  )\n\n  // Handle Enter to retry on error state\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      if (oauthStatus.state === 'error' && oauthStatus.toRetry) {\n        setPastedCode('')\n        setOAuthStatus({\n          state: 'about_to_retry',\n          nextState: oauthStatus.toRetry,\n        })\n      }\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'error' && !!oauthStatus.toRetry,\n    },\n  )\n\n  useEffect(() => {\n    if (\n      pastedCode === 'c' &&\n      oauthStatus.state === 'waiting_for_login' &&\n      showPastePrompt &&\n      !urlCopied\n    ) {\n      void setClipboard(oauthStatus.url).then(raw => {\n        if (raw) process.stdout.write(raw)\n        setUrlCopied(true)\n        setTimeout(setUrlCopied, 2000, false)\n      })\n      setPastedCode('')\n    }\n  }, [pastedCode, oauthStatus, showPastePrompt, urlCopied])\n\n  async function handleSubmitCode(value: string, url: string) {\n    try {\n      // Expecting format \"authorizationCode#state\" from the authorization callback URL\n      const [authorizationCode, state] = value.split('#')\n\n      if (!authorizationCode || !state) {\n        setOAuthStatus({\n          state: 'error',\n          message: 'Invalid code. Please make sure the full code was copied',\n          toRetry: { state: 'waiting_for_login', url },\n        })\n        return\n      }\n\n      // Track which path the user is taking (manual code entry)\n      logEvent('tengu_oauth_manual_entry', {})\n      oauthService.handleManualAuthCodeInput({\n        authorizationCode,\n        state,\n      })\n    } catch (err: unknown) {\n      logError(err)\n      setOAuthStatus({\n        state: 'error',\n        message: (err as Error).message,\n        toRetry: { state: 'waiting_for_login', url },\n      })\n    }\n  }\n\n  const startOAuth = useCallback(async () => {\n    try {\n      logEvent('tengu_oauth_flow_start', { loginWithClaudeAi })\n\n      const result = await oauthService\n        .startOAuthFlow(\n          async url => {\n            setOAuthStatus({ state: 'waiting_for_login', url })\n            setTimeout(setShowPastePrompt, 3000, true)\n          },\n          {\n            loginWithClaudeAi,\n            inferenceOnly: mode === 'setup-token',\n            expiresIn: mode === 'setup-token' ? 365 * 24 * 60 * 60 : undefined, // 1 year for setup-token\n            orgUUID,\n          },\n        )\n        .catch(err => {\n          const isTokenExchangeError = err.message.includes(\n            'Token exchange failed',\n          )\n          // Enterprise TLS proxies (Zscaler et al.) intercept the token\n          // exchange POST and cause cryptic SSL errors. Surface an\n          // actionable hint so the user isn't stuck in a login loop.\n          const sslHint = getSSLErrorHint(err)\n          setOAuthStatus({\n            state: 'error',\n            message:\n              sslHint ??\n              (isTokenExchangeError\n                ? 'Failed to exchange authorization code for access token. Please try again.'\n                : err.message),\n            toRetry:\n              mode === 'setup-token'\n                ? { state: 'ready_to_start' }\n                : { state: 'idle' },\n          })\n          logEvent('tengu_oauth_token_exchange_error', {\n            error: err.message,\n            ssl_error: sslHint !== null,\n          })\n          throw err\n        })\n\n      if (mode === 'setup-token') {\n        // For setup-token mode, return the OAuth access token directly (it can be used as an API key)\n        // Don't save to keychain - the token is displayed for manual use with CLAUDE_CODE_OAUTH_TOKEN\n        setOAuthStatus({ state: 'success', token: result.accessToken })\n      } else {\n        await installOAuthTokens(result)\n\n        const orgResult = await validateForceLoginOrg()\n        if (!orgResult.valid) {\n          throw new Error(orgResult.message)\n        }\n\n        setOAuthStatus({ state: 'success' })\n        void sendNotification(\n          {\n            message: 'Claude Code login successful',\n            notificationType: 'auth_success',\n          },\n          terminal,\n        )\n      }\n    } catch (err) {\n      const errorMessage = (err as Error).message\n      const sslHint = getSSLErrorHint(err)\n      setOAuthStatus({\n        state: 'error',\n        message: sslHint ?? errorMessage,\n        toRetry: {\n          state: mode === 'setup-token' ? 'ready_to_start' : 'idle',\n        },\n      })\n      logEvent('tengu_oauth_error', {\n        error:\n          errorMessage as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        ssl_error: sslHint !== null,\n      })\n    }\n  }, [oauthService, setShowPastePrompt, loginWithClaudeAi, mode, orgUUID])\n\n  const pendingOAuthStartRef = useRef(false)\n\n  useEffect(() => {\n    if (\n      oauthStatus.state === 'ready_to_start' &&\n      !pendingOAuthStartRef.current\n    ) {\n      pendingOAuthStartRef.current = true\n      process.nextTick(\n        (\n          startOAuth: () => Promise<void>,\n          pendingOAuthStartRef: React.MutableRefObject<boolean>,\n        ) => {\n          void startOAuth()\n          pendingOAuthStartRef.current = false\n        },\n        startOAuth,\n        pendingOAuthStartRef,\n      )\n    }\n  }, [oauthStatus.state, startOAuth])\n\n  // Auto-exit for setup-token mode\n  useEffect(() => {\n    if (mode === 'setup-token' && oauthStatus.state === 'success') {\n      // Delay to ensure static content is fully rendered before exiting\n      const timer = setTimeout(\n        (loginWithClaudeAi, onDone) => {\n          logEvent('tengu_oauth_success', { loginWithClaudeAi })\n          // Don't clear terminal so the token remains visible\n          onDone()\n        },\n        500,\n        loginWithClaudeAi,\n        onDone,\n      )\n      return () => clearTimeout(timer)\n    }\n  }, [mode, oauthStatus, loginWithClaudeAi, onDone])\n\n  // Cleanup OAuth service when component unmounts\n  useEffect(() => {\n    return () => {\n      oauthService.cleanup()\n    }\n  }, [oauthService])\n\n  return (\n    <Box flexDirection=\"column\" gap={1}>\n      {oauthStatus.state === 'waiting_for_login' && showPastePrompt && (\n        <Box flexDirection=\"column\" key=\"urlToCopy\" gap={1} paddingBottom={1}>\n          <Box paddingX={1}>\n            <Text dimColor>\n              Browser didn&apos;t open? Use the url below to sign in{' '}\n            </Text>\n            {urlCopied ? (\n              <Text color=\"success\">(Copied!)</Text>\n            ) : (\n              <Text dimColor>\n                <KeyboardShortcutHint shortcut=\"c\" action=\"copy\" parens />\n              </Text>\n            )}\n          </Box>\n          <Link url={oauthStatus.url}>\n            <Text dimColor>{oauthStatus.url}</Text>\n          </Link>\n        </Box>\n      )}\n      {mode === 'setup-token' &&\n        oauthStatus.state === 'success' &&\n        oauthStatus.token && (\n          <Box key=\"tokenOutput\" flexDirection=\"column\" gap={1} paddingTop={1}>\n            <Text color=\"success\">\n              ✓ Long-lived authentication token created successfully!\n            </Text>\n            <Box flexDirection=\"column\" gap={1}>\n              <Text>Your OAuth token (valid for 1 year):</Text>\n              <Text color=\"warning\">{oauthStatus.token}</Text>\n              <Text dimColor>\n                Store this token securely. You won&apos;t be able to see it\n                again.\n              </Text>\n              <Text dimColor>\n                Use this token by setting: export\n                CLAUDE_CODE_OAUTH_TOKEN=&lt;token&gt;\n              </Text>\n            </Box>\n          </Box>\n        )}\n      <Box paddingLeft={1} flexDirection=\"column\" gap={1}>\n        <OAuthStatusMessage\n          oauthStatus={oauthStatus}\n          mode={mode}\n          startingMessage={startingMessage}\n          forcedMethodMessage={forcedMethodMessage}\n          showPastePrompt={showPastePrompt}\n          pastedCode={pastedCode}\n          setPastedCode={setPastedCode}\n          cursorOffset={cursorOffset}\n          setCursorOffset={setCursorOffset}\n          textInputColumns={textInputColumns}\n          handleSubmitCode={handleSubmitCode}\n          setOAuthStatus={setOAuthStatus}\n          setLoginWithClaudeAi={setLoginWithClaudeAi}\n        />\n      </Box>\n    </Box>\n  )\n}\n\ntype OAuthStatusMessageProps = {\n  oauthStatus: OAuthStatus\n  mode: 'login' | 'setup-token'\n  startingMessage: string | undefined\n  forcedMethodMessage: string | null\n  showPastePrompt: boolean\n  pastedCode: string\n  setPastedCode: (value: string) => void\n  cursorOffset: number\n  setCursorOffset: (offset: number) => void\n  textInputColumns: number\n  handleSubmitCode: (value: string, url: string) => void\n  setOAuthStatus: (status: OAuthStatus) => void\n  setLoginWithClaudeAi: (value: boolean) => void\n}\n\nfunction OAuthStatusMessage({\n  oauthStatus,\n  mode,\n  startingMessage,\n  forcedMethodMessage,\n  showPastePrompt,\n  pastedCode,\n  setPastedCode,\n  cursorOffset,\n  setCursorOffset,\n  textInputColumns,\n  handleSubmitCode,\n  setOAuthStatus,\n  setLoginWithClaudeAi,\n}: OAuthStatusMessageProps): React.ReactNode {\n  switch (oauthStatus.state) {\n    case 'idle':\n      return (\n        <Box flexDirection=\"column\" gap={1} marginTop={1}>\n          <Text bold>\n            {startingMessage\n              ? startingMessage\n              : `Claude Code can be used with your Claude subscription or billed based on API usage through your Console account.`}\n          </Text>\n\n          <Text>Select login method:</Text>\n\n          <Box>\n            <Select\n              options={[\n                {\n                  label: (\n                    <Text>\n                      Claude account with subscription ·{' '}\n                      <Text dimColor>Pro, Max, Team, or Enterprise</Text>\n                      {\"external\" === 'ant' && (\n                        <Text>\n                          {'\\n'}\n                          <Text color=\"warning\">[ANT-ONLY]</Text>{' '}\n                          <Text dimColor>\n                            Please use this option unless you need to login to a\n                            special org for accessing sensitive data (e.g.\n                            customer data, HIPI data) with the Console option\n                          </Text>\n                        </Text>\n                      )}\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'claudeai',\n                },\n                {\n                  label: (\n                    <Text>\n                      Anthropic Console account ·{' '}\n                      <Text dimColor>API usage billing</Text>\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'console',\n                },\n                {\n                  label: (\n                    <Text>\n                      3rd-party platform ·{' '}\n                      <Text dimColor>\n                        Amazon Bedrock, Microsoft Foundry, or Vertex AI\n                      </Text>\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'platform',\n                },\n              ]}\n              onChange={value => {\n                if (value === 'platform') {\n                  logEvent('tengu_oauth_platform_selected', {})\n                  setOAuthStatus({ state: 'platform_setup' })\n                } else {\n                  setOAuthStatus({ state: 'ready_to_start' })\n                  if (value === 'claudeai') {\n                    logEvent('tengu_oauth_claudeai_selected', {})\n                    setLoginWithClaudeAi(true)\n                  } else {\n                    logEvent('tengu_oauth_console_selected', {})\n                    setLoginWithClaudeAi(false)\n                  }\n                }\n              }}\n            />\n          </Box>\n        </Box>\n      )\n\n    case 'platform_setup':\n      return (\n        <Box flexDirection=\"column\" gap={1} marginTop={1}>\n          <Text bold>Using 3rd-party platforms</Text>\n\n          <Box flexDirection=\"column\" gap={1}>\n            <Text>\n              Claude Code supports Amazon Bedrock, Microsoft Foundry, and Vertex\n              AI. Set the required environment variables, then restart Claude\n              Code.\n            </Text>\n\n            <Text>\n              If you are part of an enterprise organization, contact your\n              administrator for setup instructions.\n            </Text>\n\n            <Box flexDirection=\"column\" marginTop={1}>\n              <Text bold>Documentation:</Text>\n              <Text>\n                · Amazon Bedrock:{' '}\n                <Link url=\"https://code.claude.com/docs/en/amazon-bedrock\">\n                  https://code.claude.com/docs/en/amazon-bedrock\n                </Link>\n              </Text>\n              <Text>\n                · Microsoft Foundry:{' '}\n                <Link url=\"https://code.claude.com/docs/en/microsoft-foundry\">\n                  https://code.claude.com/docs/en/microsoft-foundry\n                </Link>\n              </Text>\n              <Text>\n                · Vertex AI:{' '}\n                <Link url=\"https://code.claude.com/docs/en/google-vertex-ai\">\n                  https://code.claude.com/docs/en/google-vertex-ai\n                </Link>\n              </Text>\n            </Box>\n\n            <Box marginTop={1}>\n              <Text dimColor>\n                Press <Text bold>Enter</Text> to go back to login options.\n              </Text>\n            </Box>\n          </Box>\n        </Box>\n      )\n\n    case 'waiting_for_login':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          {forcedMethodMessage && (\n            <Box>\n              <Text dimColor>{forcedMethodMessage}</Text>\n            </Box>\n          )}\n\n          {!showPastePrompt && (\n            <Box>\n              <Spinner />\n              <Text>Opening browser to sign in…</Text>\n            </Box>\n          )}\n\n          {showPastePrompt && (\n            <Box>\n              <Text>{PASTE_HERE_MSG}</Text>\n              <TextInput\n                value={pastedCode}\n                onChange={setPastedCode}\n                onSubmit={(value: string) =>\n                  handleSubmitCode(value, oauthStatus.url)\n                }\n                cursorOffset={cursorOffset}\n                onChangeCursorOffset={setCursorOffset}\n                columns={textInputColumns}\n                mask=\"*\"\n              />\n            </Box>\n          )}\n        </Box>\n      )\n\n    case 'creating_api_key':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Box>\n            <Spinner />\n            <Text>Creating API key for Claude Code…</Text>\n          </Box>\n        </Box>\n      )\n\n    case 'about_to_retry':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Text color=\"permission\">Retrying…</Text>\n        </Box>\n      )\n\n    case 'success':\n      return (\n        <Box flexDirection=\"column\">\n          {mode === 'setup-token' && oauthStatus.token ? null : (\n            <>\n              {getOauthAccountInfo()?.emailAddress ? (\n                <Text dimColor>\n                  Logged in as{' '}\n                  <Text>{getOauthAccountInfo()?.emailAddress}</Text>\n                </Text>\n              ) : null}\n              <Text color=\"success\">\n                Login successful. Press <Text bold>Enter</Text> to continue…\n              </Text>\n            </>\n          )}\n        </Box>\n      )\n\n    case 'error':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Text color=\"error\">OAuth error: {oauthStatus.message}</Text>\n\n          {oauthStatus.toRetry && (\n            <Box marginTop={1}>\n              <Text color=\"permission\">\n                Press <Text bold>Enter</Text> to retry.\n              </Text>\n            </Box>\n          )}\n        </Box>\n      )\n\n    default:\n      return null\n  }\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useRef","useState","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","installOAuthTokens","useTerminalSize","setClipboard","useTerminalNotification","Box","Link","Text","useKeybinding","getSSLErrorHint","sendNotification","OAuthService","getOauthAccountInfo","validateForceLoginOrg","logError","getSettings_DEPRECATED","Select","KeyboardShortcutHint","Spinner","TextInput","Props","onDone","startingMessage","mode","forceLoginMethod","OAuthStatus","state","url","nextState","token","message","toRetry","PASTE_HERE_MSG","ConsoleOAuthFlow","forceLoginMethodProp","ReactNode","settings","orgUUID","forceLoginOrgUUID","forcedMethodMessage","terminal","oauthStatus","setOAuthStatus","pastedCode","setPastedCode","cursorOffset","setCursorOffset","oauthService","loginWithClaudeAi","setLoginWithClaudeAi","showPastePrompt","setShowPastePrompt","urlCopied","setUrlCopied","textInputColumns","columns","length","timer","setTimeout","clearTimeout","context","isActive","then","raw","process","stdout","write","handleSubmitCode","value","authorizationCode","split","handleManualAuthCodeInput","err","Error","startOAuth","result","startOAuthFlow","inferenceOnly","expiresIn","undefined","catch","isTokenExchangeError","includes","sslHint","error","ssl_error","accessToken","orgResult","valid","notificationType","errorMessage","pendingOAuthStartRef","current","nextTick","Promise","MutableRefObject","cleanup","OAuthStatusMessageProps","offset","status","OAuthStatusMessage","t0","$","_c","t1","t2","t3","Symbol","for","t4","label","t5","t6","t7","value_0","t8","emailAddress"],"sources":["ConsoleOAuthFlow.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useRef, useState } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport { installOAuthTokens } from '../cli/handlers/auth.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { setClipboard } from '../ink/termio/osc.js'\nimport { useTerminalNotification } from '../ink/useTerminalNotification.js'\nimport { Box, Link, Text } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport { getSSLErrorHint } from '../services/api/errorUtils.js'\nimport { sendNotification } from '../services/notifier.js'\nimport { OAuthService } from '../services/oauth/index.js'\nimport { getOauthAccountInfo, validateForceLoginOrg } from '../utils/auth.js'\nimport { logError } from '../utils/log.js'\nimport { getSettings_DEPRECATED } from '../utils/settings/settings.js'\nimport { Select } from './CustomSelect/select.js'\nimport { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'\nimport { Spinner } from './Spinner.js'\nimport TextInput from './TextInput.js'\n\ntype Props = {\n  onDone(): void\n  startingMessage?: string\n  mode?: 'login' | 'setup-token'\n  forceLoginMethod?: 'claudeai' | 'console'\n}\n\ntype OAuthStatus =\n  | { state: 'idle' } // Initial state, waiting to select login method\n  | { state: 'platform_setup' } // Show platform setup info (Bedrock/Vertex/Foundry)\n  | { state: 'ready_to_start' } // Flow started, waiting for browser to open\n  | { state: 'waiting_for_login'; url: string } // Browser opened, waiting for user to login\n  | { state: 'creating_api_key' } // Got access token, creating API key\n  | { state: 'about_to_retry'; nextState: OAuthStatus }\n  | { state: 'success'; token?: string }\n  | {\n      state: 'error'\n      message: string\n      toRetry?: OAuthStatus\n    }\n\nconst PASTE_HERE_MSG = 'Paste code here if prompted > '\n\nexport function ConsoleOAuthFlow({\n  onDone,\n  startingMessage,\n  mode = 'login',\n  forceLoginMethod: forceLoginMethodProp,\n}: Props): React.ReactNode {\n  const settings = getSettings_DEPRECATED() || {}\n  const forceLoginMethod = forceLoginMethodProp ?? settings.forceLoginMethod\n  const orgUUID = settings.forceLoginOrgUUID\n  const forcedMethodMessage =\n    forceLoginMethod === 'claudeai'\n      ? 'Login method pre-selected: Subscription Plan (Claude Pro/Max)'\n      : forceLoginMethod === 'console'\n        ? 'Login method pre-selected: API Usage Billing (Anthropic Console)'\n        : null\n\n  const terminal = useTerminalNotification()\n\n  const [oauthStatus, setOAuthStatus] = useState<OAuthStatus>(() => {\n    if (mode === 'setup-token') {\n      return { state: 'ready_to_start' }\n    }\n    if (forceLoginMethod === 'claudeai' || forceLoginMethod === 'console') {\n      return { state: 'ready_to_start' }\n    }\n    return { state: 'idle' }\n  })\n\n  const [pastedCode, setPastedCode] = useState('')\n  const [cursorOffset, setCursorOffset] = useState(0)\n  const [oauthService] = useState(() => new OAuthService())\n  const [loginWithClaudeAi, setLoginWithClaudeAi] = useState(() => {\n    // Use Claude AI auth for setup-token mode to support user:inference scope\n    return mode === 'setup-token' || forceLoginMethod === 'claudeai'\n  })\n  // After a few seconds we suggest the user to copy/paste url if the\n  // browser did not open automatically. In this flow we expect the user to\n  // copy the code from the browser and paste it in the terminal\n  const [showPastePrompt, setShowPastePrompt] = useState(false)\n  const [urlCopied, setUrlCopied] = useState(false)\n\n  const textInputColumns = useTerminalSize().columns - PASTE_HERE_MSG.length - 1\n\n  // Log forced login method on mount\n  useEffect(() => {\n    if (forceLoginMethod === 'claudeai') {\n      logEvent('tengu_oauth_claudeai_forced', {})\n    } else if (forceLoginMethod === 'console') {\n      logEvent('tengu_oauth_console_forced', {})\n    }\n  }, [forceLoginMethod])\n\n  // Retry logic\n  useEffect(() => {\n    if (oauthStatus.state === 'about_to_retry') {\n      const timer = setTimeout(setOAuthStatus, 1000, oauthStatus.nextState)\n      return () => clearTimeout(timer)\n    }\n  }, [oauthStatus])\n\n  // Handle Enter to continue on success state\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      logEvent('tengu_oauth_success', { loginWithClaudeAi })\n      onDone()\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'success' && mode !== 'setup-token',\n    },\n  )\n\n  // Handle Enter to continue from platform setup\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      setOAuthStatus({ state: 'idle' })\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'platform_setup',\n    },\n  )\n\n  // Handle Enter to retry on error state\n  useKeybinding(\n    'confirm:yes',\n    () => {\n      if (oauthStatus.state === 'error' && oauthStatus.toRetry) {\n        setPastedCode('')\n        setOAuthStatus({\n          state: 'about_to_retry',\n          nextState: oauthStatus.toRetry,\n        })\n      }\n    },\n    {\n      context: 'Confirmation',\n      isActive: oauthStatus.state === 'error' && !!oauthStatus.toRetry,\n    },\n  )\n\n  useEffect(() => {\n    if (\n      pastedCode === 'c' &&\n      oauthStatus.state === 'waiting_for_login' &&\n      showPastePrompt &&\n      !urlCopied\n    ) {\n      void setClipboard(oauthStatus.url).then(raw => {\n        if (raw) process.stdout.write(raw)\n        setUrlCopied(true)\n        setTimeout(setUrlCopied, 2000, false)\n      })\n      setPastedCode('')\n    }\n  }, [pastedCode, oauthStatus, showPastePrompt, urlCopied])\n\n  async function handleSubmitCode(value: string, url: string) {\n    try {\n      // Expecting format \"authorizationCode#state\" from the authorization callback URL\n      const [authorizationCode, state] = value.split('#')\n\n      if (!authorizationCode || !state) {\n        setOAuthStatus({\n          state: 'error',\n          message: 'Invalid code. Please make sure the full code was copied',\n          toRetry: { state: 'waiting_for_login', url },\n        })\n        return\n      }\n\n      // Track which path the user is taking (manual code entry)\n      logEvent('tengu_oauth_manual_entry', {})\n      oauthService.handleManualAuthCodeInput({\n        authorizationCode,\n        state,\n      })\n    } catch (err: unknown) {\n      logError(err)\n      setOAuthStatus({\n        state: 'error',\n        message: (err as Error).message,\n        toRetry: { state: 'waiting_for_login', url },\n      })\n    }\n  }\n\n  const startOAuth = useCallback(async () => {\n    try {\n      logEvent('tengu_oauth_flow_start', { loginWithClaudeAi })\n\n      const result = await oauthService\n        .startOAuthFlow(\n          async url => {\n            setOAuthStatus({ state: 'waiting_for_login', url })\n            setTimeout(setShowPastePrompt, 3000, true)\n          },\n          {\n            loginWithClaudeAi,\n            inferenceOnly: mode === 'setup-token',\n            expiresIn: mode === 'setup-token' ? 365 * 24 * 60 * 60 : undefined, // 1 year for setup-token\n            orgUUID,\n          },\n        )\n        .catch(err => {\n          const isTokenExchangeError = err.message.includes(\n            'Token exchange failed',\n          )\n          // Enterprise TLS proxies (Zscaler et al.) intercept the token\n          // exchange POST and cause cryptic SSL errors. Surface an\n          // actionable hint so the user isn't stuck in a login loop.\n          const sslHint = getSSLErrorHint(err)\n          setOAuthStatus({\n            state: 'error',\n            message:\n              sslHint ??\n              (isTokenExchangeError\n                ? 'Failed to exchange authorization code for access token. Please try again.'\n                : err.message),\n            toRetry:\n              mode === 'setup-token'\n                ? { state: 'ready_to_start' }\n                : { state: 'idle' },\n          })\n          logEvent('tengu_oauth_token_exchange_error', {\n            error: err.message,\n            ssl_error: sslHint !== null,\n          })\n          throw err\n        })\n\n      if (mode === 'setup-token') {\n        // For setup-token mode, return the OAuth access token directly (it can be used as an API key)\n        // Don't save to keychain - the token is displayed for manual use with CLAUDE_CODE_OAUTH_TOKEN\n        setOAuthStatus({ state: 'success', token: result.accessToken })\n      } else {\n        await installOAuthTokens(result)\n\n        const orgResult = await validateForceLoginOrg()\n        if (!orgResult.valid) {\n          throw new Error(orgResult.message)\n        }\n\n        setOAuthStatus({ state: 'success' })\n        void sendNotification(\n          {\n            message: 'Claude Code login successful',\n            notificationType: 'auth_success',\n          },\n          terminal,\n        )\n      }\n    } catch (err) {\n      const errorMessage = (err as Error).message\n      const sslHint = getSSLErrorHint(err)\n      setOAuthStatus({\n        state: 'error',\n        message: sslHint ?? errorMessage,\n        toRetry: {\n          state: mode === 'setup-token' ? 'ready_to_start' : 'idle',\n        },\n      })\n      logEvent('tengu_oauth_error', {\n        error:\n          errorMessage as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        ssl_error: sslHint !== null,\n      })\n    }\n  }, [oauthService, setShowPastePrompt, loginWithClaudeAi, mode, orgUUID])\n\n  const pendingOAuthStartRef = useRef(false)\n\n  useEffect(() => {\n    if (\n      oauthStatus.state === 'ready_to_start' &&\n      !pendingOAuthStartRef.current\n    ) {\n      pendingOAuthStartRef.current = true\n      process.nextTick(\n        (\n          startOAuth: () => Promise<void>,\n          pendingOAuthStartRef: React.MutableRefObject<boolean>,\n        ) => {\n          void startOAuth()\n          pendingOAuthStartRef.current = false\n        },\n        startOAuth,\n        pendingOAuthStartRef,\n      )\n    }\n  }, [oauthStatus.state, startOAuth])\n\n  // Auto-exit for setup-token mode\n  useEffect(() => {\n    if (mode === 'setup-token' && oauthStatus.state === 'success') {\n      // Delay to ensure static content is fully rendered before exiting\n      const timer = setTimeout(\n        (loginWithClaudeAi, onDone) => {\n          logEvent('tengu_oauth_success', { loginWithClaudeAi })\n          // Don't clear terminal so the token remains visible\n          onDone()\n        },\n        500,\n        loginWithClaudeAi,\n        onDone,\n      )\n      return () => clearTimeout(timer)\n    }\n  }, [mode, oauthStatus, loginWithClaudeAi, onDone])\n\n  // Cleanup OAuth service when component unmounts\n  useEffect(() => {\n    return () => {\n      oauthService.cleanup()\n    }\n  }, [oauthService])\n\n  return (\n    <Box flexDirection=\"column\" gap={1}>\n      {oauthStatus.state === 'waiting_for_login' && showPastePrompt && (\n        <Box flexDirection=\"column\" key=\"urlToCopy\" gap={1} paddingBottom={1}>\n          <Box paddingX={1}>\n            <Text dimColor>\n              Browser didn&apos;t open? Use the url below to sign in{' '}\n            </Text>\n            {urlCopied ? (\n              <Text color=\"success\">(Copied!)</Text>\n            ) : (\n              <Text dimColor>\n                <KeyboardShortcutHint shortcut=\"c\" action=\"copy\" parens />\n              </Text>\n            )}\n          </Box>\n          <Link url={oauthStatus.url}>\n            <Text dimColor>{oauthStatus.url}</Text>\n          </Link>\n        </Box>\n      )}\n      {mode === 'setup-token' &&\n        oauthStatus.state === 'success' &&\n        oauthStatus.token && (\n          <Box key=\"tokenOutput\" flexDirection=\"column\" gap={1} paddingTop={1}>\n            <Text color=\"success\">\n              ✓ Long-lived authentication token created successfully!\n            </Text>\n            <Box flexDirection=\"column\" gap={1}>\n              <Text>Your OAuth token (valid for 1 year):</Text>\n              <Text color=\"warning\">{oauthStatus.token}</Text>\n              <Text dimColor>\n                Store this token securely. You won&apos;t be able to see it\n                again.\n              </Text>\n              <Text dimColor>\n                Use this token by setting: export\n                CLAUDE_CODE_OAUTH_TOKEN=&lt;token&gt;\n              </Text>\n            </Box>\n          </Box>\n        )}\n      <Box paddingLeft={1} flexDirection=\"column\" gap={1}>\n        <OAuthStatusMessage\n          oauthStatus={oauthStatus}\n          mode={mode}\n          startingMessage={startingMessage}\n          forcedMethodMessage={forcedMethodMessage}\n          showPastePrompt={showPastePrompt}\n          pastedCode={pastedCode}\n          setPastedCode={setPastedCode}\n          cursorOffset={cursorOffset}\n          setCursorOffset={setCursorOffset}\n          textInputColumns={textInputColumns}\n          handleSubmitCode={handleSubmitCode}\n          setOAuthStatus={setOAuthStatus}\n          setLoginWithClaudeAi={setLoginWithClaudeAi}\n        />\n      </Box>\n    </Box>\n  )\n}\n\ntype OAuthStatusMessageProps = {\n  oauthStatus: OAuthStatus\n  mode: 'login' | 'setup-token'\n  startingMessage: string | undefined\n  forcedMethodMessage: string | null\n  showPastePrompt: boolean\n  pastedCode: string\n  setPastedCode: (value: string) => void\n  cursorOffset: number\n  setCursorOffset: (offset: number) => void\n  textInputColumns: number\n  handleSubmitCode: (value: string, url: string) => void\n  setOAuthStatus: (status: OAuthStatus) => void\n  setLoginWithClaudeAi: (value: boolean) => void\n}\n\nfunction OAuthStatusMessage({\n  oauthStatus,\n  mode,\n  startingMessage,\n  forcedMethodMessage,\n  showPastePrompt,\n  pastedCode,\n  setPastedCode,\n  cursorOffset,\n  setCursorOffset,\n  textInputColumns,\n  handleSubmitCode,\n  setOAuthStatus,\n  setLoginWithClaudeAi,\n}: OAuthStatusMessageProps): React.ReactNode {\n  switch (oauthStatus.state) {\n    case 'idle':\n      return (\n        <Box flexDirection=\"column\" gap={1} marginTop={1}>\n          <Text bold>\n            {startingMessage\n              ? startingMessage\n              : `Claude Code can be used with your Claude subscription or billed based on API usage through your Console account.`}\n          </Text>\n\n          <Text>Select login method:</Text>\n\n          <Box>\n            <Select\n              options={[\n                {\n                  label: (\n                    <Text>\n                      Claude account with subscription ·{' '}\n                      <Text dimColor>Pro, Max, Team, or Enterprise</Text>\n                      {\"external\" === 'ant' && (\n                        <Text>\n                          {'\\n'}\n                          <Text color=\"warning\">[ANT-ONLY]</Text>{' '}\n                          <Text dimColor>\n                            Please use this option unless you need to login to a\n                            special org for accessing sensitive data (e.g.\n                            customer data, HIPI data) with the Console option\n                          </Text>\n                        </Text>\n                      )}\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'claudeai',\n                },\n                {\n                  label: (\n                    <Text>\n                      Anthropic Console account ·{' '}\n                      <Text dimColor>API usage billing</Text>\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'console',\n                },\n                {\n                  label: (\n                    <Text>\n                      3rd-party platform ·{' '}\n                      <Text dimColor>\n                        Amazon Bedrock, Microsoft Foundry, or Vertex AI\n                      </Text>\n                      {'\\n'}\n                    </Text>\n                  ),\n                  value: 'platform',\n                },\n              ]}\n              onChange={value => {\n                if (value === 'platform') {\n                  logEvent('tengu_oauth_platform_selected', {})\n                  setOAuthStatus({ state: 'platform_setup' })\n                } else {\n                  setOAuthStatus({ state: 'ready_to_start' })\n                  if (value === 'claudeai') {\n                    logEvent('tengu_oauth_claudeai_selected', {})\n                    setLoginWithClaudeAi(true)\n                  } else {\n                    logEvent('tengu_oauth_console_selected', {})\n                    setLoginWithClaudeAi(false)\n                  }\n                }\n              }}\n            />\n          </Box>\n        </Box>\n      )\n\n    case 'platform_setup':\n      return (\n        <Box flexDirection=\"column\" gap={1} marginTop={1}>\n          <Text bold>Using 3rd-party platforms</Text>\n\n          <Box flexDirection=\"column\" gap={1}>\n            <Text>\n              Claude Code supports Amazon Bedrock, Microsoft Foundry, and Vertex\n              AI. Set the required environment variables, then restart Claude\n              Code.\n            </Text>\n\n            <Text>\n              If you are part of an enterprise organization, contact your\n              administrator for setup instructions.\n            </Text>\n\n            <Box flexDirection=\"column\" marginTop={1}>\n              <Text bold>Documentation:</Text>\n              <Text>\n                · Amazon Bedrock:{' '}\n                <Link url=\"https://code.claude.com/docs/en/amazon-bedrock\">\n                  https://code.claude.com/docs/en/amazon-bedrock\n                </Link>\n              </Text>\n              <Text>\n                · Microsoft Foundry:{' '}\n                <Link url=\"https://code.claude.com/docs/en/microsoft-foundry\">\n                  https://code.claude.com/docs/en/microsoft-foundry\n                </Link>\n              </Text>\n              <Text>\n                · Vertex AI:{' '}\n                <Link url=\"https://code.claude.com/docs/en/google-vertex-ai\">\n                  https://code.claude.com/docs/en/google-vertex-ai\n                </Link>\n              </Text>\n            </Box>\n\n            <Box marginTop={1}>\n              <Text dimColor>\n                Press <Text bold>Enter</Text> to go back to login options.\n              </Text>\n            </Box>\n          </Box>\n        </Box>\n      )\n\n    case 'waiting_for_login':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          {forcedMethodMessage && (\n            <Box>\n              <Text dimColor>{forcedMethodMessage}</Text>\n            </Box>\n          )}\n\n          {!showPastePrompt && (\n            <Box>\n              <Spinner />\n              <Text>Opening browser to sign in…</Text>\n            </Box>\n          )}\n\n          {showPastePrompt && (\n            <Box>\n              <Text>{PASTE_HERE_MSG}</Text>\n              <TextInput\n                value={pastedCode}\n                onChange={setPastedCode}\n                onSubmit={(value: string) =>\n                  handleSubmitCode(value, oauthStatus.url)\n                }\n                cursorOffset={cursorOffset}\n                onChangeCursorOffset={setCursorOffset}\n                columns={textInputColumns}\n                mask=\"*\"\n              />\n            </Box>\n          )}\n        </Box>\n      )\n\n    case 'creating_api_key':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Box>\n            <Spinner />\n            <Text>Creating API key for Claude Code…</Text>\n          </Box>\n        </Box>\n      )\n\n    case 'about_to_retry':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Text color=\"permission\">Retrying…</Text>\n        </Box>\n      )\n\n    case 'success':\n      return (\n        <Box flexDirection=\"column\">\n          {mode === 'setup-token' && oauthStatus.token ? null : (\n            <>\n              {getOauthAccountInfo()?.emailAddress ? (\n                <Text dimColor>\n                  Logged in as{' '}\n                  <Text>{getOauthAccountInfo()?.emailAddress}</Text>\n                </Text>\n              ) : null}\n              <Text color=\"success\">\n                Login successful. Press <Text bold>Enter</Text> to continue…\n              </Text>\n            </>\n          )}\n        </Box>\n      )\n\n    case 'error':\n      return (\n        <Box flexDirection=\"column\" gap={1}>\n          <Text color=\"error\">OAuth error: {oauthStatus.message}</Text>\n\n          {oauthStatus.toRetry && (\n            <Box marginTop={1}>\n              <Text color=\"permission\">\n                Press <Text bold>Enter</Text> to retry.\n              </Text>\n            </Box>\n          )}\n        </Box>\n      )\n\n    default:\n      return null\n  }\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/components/CustomSelect/use-select-navigation.ts b/src/components/CustomSelect/use-select-navigation.ts
index 7ecb4e71..544bbfa7 100644
--- a/src/components/CustomSelect/use-select-navigation.ts
+++ b/src/components/CustomSelect/use-select-navigation.ts
@@ -84,44 +84,44 @@ const reducer = <T>(state: State<T>, action: Action<T>): State<T> => {
         return state
       }
 
-      // Wrap to first item if at the end
-      const next = item.next || state.optionMap.first
+      // If there's a next item in the list, go to it
+      if (item.next) {
+        const needsToScroll = item.next.index >= state.visibleToIndex
 
-      if (!next) {
+        if (!needsToScroll) {
+          return {
+            ...state,
+            focusedValue: item.next.value,
+          }
+        }
+
+        const nextVisibleToIndex = Math.min(
+          state.optionMap.size,
+          state.visibleToIndex + 1,
+        )
+
+        const nextVisibleFromIndex = nextVisibleToIndex - state.visibleOptionCount
+
+        return {
+          ...state,
+          focusedValue: item.next.value,
+          visibleFromIndex: nextVisibleFromIndex,
+          visibleToIndex: nextVisibleToIndex,
+        }
+      }
+
+      // No next item - wrap to first item
+      const firstItem = state.optionMap.first
+      if (!firstItem) {
         return state
       }
 
       // When wrapping to first, reset viewport to start
-      if (!item.next && next === state.optionMap.first) {
-        return {
-          ...state,
-          focusedValue: next.value,
-          visibleFromIndex: 0,
-          visibleToIndex: state.visibleOptionCount,
-        }
-      }
-
-      const needsToScroll = next.index >= state.visibleToIndex
-
-      if (!needsToScroll) {
-        return {
-          ...state,
-          focusedValue: next.value,
-        }
-      }
-
-      const nextVisibleToIndex = Math.min(
-        state.optionMap.size,
-        state.visibleToIndex + 1,
-      )
-
-      const nextVisibleFromIndex = nextVisibleToIndex - state.visibleOptionCount
-
       return {
         ...state,
-        focusedValue: next.value,
-        visibleFromIndex: nextVisibleFromIndex,
-        visibleToIndex: nextVisibleToIndex,
+        focusedValue: firstItem.value,
+        visibleFromIndex: 0,
+        visibleToIndex: state.visibleOptionCount,
       }
     }
 
@@ -136,44 +136,43 @@ const reducer = <T>(state: State<T>, action: Action<T>): State<T> => {
         return state
       }
 
-      // Wrap to last item if at the beginning
-      const previous = item.previous || state.optionMap.last
+      // If there's a previous item in the list, go to it
+      if (item.previous) {
+        const needsToScroll = item.previous.index < state.visibleFromIndex
 
-      if (!previous) {
-        return state
-      }
+        if (!needsToScroll) {
+          return {
+            ...state,
+            focusedValue: item.previous.value,
+          }
+        }
+
+        const nextVisibleFromIndex = Math.max(0, state.visibleFromIndex - 1)
+        const nextVisibleToIndex = nextVisibleFromIndex + state.visibleOptionCount
 
-      // When wrapping to last, reset viewport to end
-      if (!item.previous && previous === state.optionMap.last) {
-        const nextVisibleToIndex = state.optionMap.size
-        const nextVisibleFromIndex = Math.max(
-          0,
-          nextVisibleToIndex - state.visibleOptionCount,
-        )
         return {
           ...state,
-          focusedValue: previous.value,
+          focusedValue: item.previous.value,
           visibleFromIndex: nextVisibleFromIndex,
           visibleToIndex: nextVisibleToIndex,
         }
       }
 
-      const needsToScroll = previous.index <= state.visibleFromIndex
-
-      if (!needsToScroll) {
-        return {
-          ...state,
-          focusedValue: previous.value,
-        }
+      // No previous item - wrap to last item
+      const lastItem = state.optionMap.last
+      if (!lastItem) {
+        return state
       }
 
-      const nextVisibleFromIndex = Math.max(0, state.visibleFromIndex - 1)
-
-      const nextVisibleToIndex = nextVisibleFromIndex + state.visibleOptionCount
-
+      // When wrapping to last, reset viewport to end
+      const nextVisibleToIndex = state.optionMap.size
+      const nextVisibleFromIndex = Math.max(
+        0,
+        nextVisibleToIndex - state.visibleOptionCount,
+      )
       return {
         ...state,
-        focusedValue: previous.value,
+        focusedValue: lastItem.value,
         visibleFromIndex: nextVisibleFromIndex,
         visibleToIndex: nextVisibleToIndex,
       }
diff --git a/src/components/EffortPicker.tsx b/src/components/EffortPicker.tsx
new file mode 100644
index 00000000..2e86509e
--- /dev/null
+++ b/src/components/EffortPicker.tsx
@@ -0,0 +1,152 @@
+import React, { useState } from 'react'
+import { Box, Text } from '../ink.js'
+import { useMainLoopModel } from '../hooks/useMainLoopModel.js'
+import { useAppState, useSetAppState } from '../state/AppState.js'
+import type { EffortLevel, OpenAIEffortLevel } from '../utils/effort.js'
+import {
+  getAvailableEffortLevels,
+  getDisplayedEffortLevel,
+  getEffortLevelDescription,
+  getEffortLevelLabel,
+  getEffortValueDescription,
+  modelSupportsEffort,
+  modelUsesOpenAIEffort,
+  standardEffortToOpenAI,
+  isOpenAIEffortLevel,
+} from '../utils/effort.js'
+import { getAPIProvider } from '../utils/model/providers.js'
+import { getReasoningEffortForModel } from '../services/api/providerConfig.js'
+import { Select } from './CustomSelect/select.js'
+import { effortLevelToSymbol } from './EffortIndicator.js'
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'
+import { Byline } from './design-system/Byline.js'
+
+type EffortOption = {
+  label: React.ReactNode
+  value: string
+  description: string
+  isAvailable: boolean
+}
+
+type Props = {
+  onSelect: (effort: EffortLevel | undefined) => void
+  onCancel?: () => void
+}
+
+export function EffortPicker({ onSelect, onCancel }: Props) {
+  const model = useMainLoopModel()
+  const appStateEffort = useAppState((s: any) => s.effortValue)
+  const setAppState = useSetAppState()
+  const provider = getAPIProvider()
+  const usesOpenAIEffort = modelUsesOpenAIEffort(model)
+  const availableLevels = getAvailableEffortLevels(model)
+  const currentDisplayedLevel = getDisplayedEffortLevel(model, appStateEffort)
+
+  // For OpenAI/Codex, get the model's default reasoning effort
+  const modelReasoningEffort = usesOpenAIEffort ? getReasoningEffortForModel(model) : undefined
+  const defaultEffortForModel = modelReasoningEffort || currentDisplayedLevel
+
+  const options: EffortOption[] = [
+    {
+      label: <EffortOptionLabel level="auto" text="Auto" isCurrent={false} />,
+      value: 'auto',
+      description: 'Use the default effort level for your model',
+      isAvailable: true,
+    },
+    ...availableLevels.map(level => {
+      const displayLevel = usesOpenAIEffort
+        ? (level === 'xhigh' ? 'max' : level)
+        : level
+      const isCurrent = currentDisplayedLevel === displayLevel
+      return {
+        label: (
+          <EffortOptionLabel
+            level={level as EffortLevel}
+            text={getEffortLevelLabel(level as EffortLevel)}
+            isCurrent={isCurrent}
+          />
+        ),
+        value: level,
+        description: getEffortLevelDescription(level as EffortLevel),
+        isAvailable: true,
+      }
+    }),
+  ]
+
+  function handleSelect(value: string) {
+    if (value === 'auto') {
+      setAppState(prev => ({
+        ...prev,
+        effortValue: undefined,
+      }))
+      onSelect(undefined)
+    } else {
+      const effortLevel = value as EffortLevel
+      setAppState(prev => ({
+        ...prev,
+        effortValue: effortLevel,
+      }))
+      onSelect(effortLevel)
+    }
+  }
+
+  function handleCancel() {
+    onCancel?.()
+  }
+
+  const supportsEffort = modelSupportsEffort(model)
+  // For OpenAI/Codex, use the model's default reasoning effort as initial focus
+  // For Claude, use the displayed effort level or 'auto'
+  const initialFocus = usesOpenAIEffort
+    ? (modelReasoningEffort || 'auto')
+    : (appStateEffort ? String(appStateEffort) : 'auto')
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1} flexDirection="column">
+        <Text color="remember" bold={true}>Set effort level</Text>
+        <Text dimColor={true}>
+          {usesOpenAIEffort
+            ? `OpenAI/Codex provider (${provider})`
+            : supportsEffort
+              ? `Claude model · ${provider} provider`
+              : `Effort not supported for this model`
+          }
+        </Text>
+      </Box>
+
+      <Box marginBottom={1}>
+        <Select
+          options={options}
+          defaultValue={initialFocus}
+          onChange={handleSelect}
+          onCancel={handleCancel}
+          visibleOptionCount={Math.min(6, options.length)}
+          inlineDescriptions={true}
+        />
+      </Box>
+
+      <Box marginBottom={1}>
+        <Text dimColor={true} italic={true}>
+          <Byline>
+            <KeyboardShortcutHint shortcut="Enter" action="confirm" />
+            <KeyboardShortcutHint shortcut="Esc" action="cancel" />
+          </Byline>
+        </Text>
+      </Box>
+    </Box>
+  )
+}
+
+function EffortOptionLabel({ level, text, isCurrent }: { level: EffortLevel | 'auto', text: string, isCurrent: boolean }) {
+  const symbol = level === 'auto' ? '⊘' : effortLevelToSymbol(level as EffortLevel)
+  const color = isCurrent ? 'remember' : level === 'auto' ? 'subtle' : 'suggestion'
+
+  return (
+    <>
+      <Text color={color}>{symbol} </Text>
+      <Text bold={isCurrent}>{text}</Text>
+      {isCurrent && <Text dimColor={true}> (current)</Text>}
+    </>
+  )
+}
diff --git a/src/components/PromptInput/PromptInputFooterSuggestions.test.tsx b/src/components/PromptInput/PromptInputFooterSuggestions.test.tsx
new file mode 100644
index 00000000..c03b2432
--- /dev/null
+++ b/src/components/PromptInput/PromptInputFooterSuggestions.test.tsx
@@ -0,0 +1,36 @@
+import figures from 'figures'
+import React from 'react'
+import { describe, expect, it } from 'bun:test'
+import { renderToString } from '../../utils/staticRender.js'
+import {
+  PromptInputFooterSuggestions,
+  type SuggestionItem,
+} from './PromptInputFooterSuggestions.js'
+
+describe('PromptInputFooterSuggestions', () => {
+  it('renders a visible marker for the selected suggestion', async () => {
+    const suggestions: SuggestionItem[] = [
+      {
+        id: 'command-help',
+        displayText: '/help',
+        description: 'Show help',
+      },
+      {
+        id: 'command-doctor',
+        displayText: '/doctor',
+        description: 'Run diagnostics',
+      },
+    ]
+
+    const output = await renderToString(
+      <PromptInputFooterSuggestions
+        suggestions={suggestions}
+        selectedSuggestion={1}
+      />,
+      80,
+    )
+
+    expect(output).toContain(`${figures.pointer} /doctor`)
+    expect(output).toContain('  /help')
+  })
+})
diff --git a/src/components/PromptInput/PromptInputFooterSuggestions.tsx b/src/components/PromptInput/PromptInputFooterSuggestions.tsx
index f7337b29..de1e7c95 100644
--- a/src/components/PromptInput/PromptInputFooterSuggestions.tsx
+++ b/src/components/PromptInput/PromptInputFooterSuggestions.tsx
@@ -1,293 +1,219 @@
-import { c as _c } from "react-compiler-runtime";
-import * as React from 'react';
-import { memo, type ReactNode } from 'react';
-import { useTerminalSize } from '../../hooks/useTerminalSize.js';
-import { stringWidth } from '../../ink/stringWidth.js';
-import { Box, Text } from '../../ink.js';
-import { truncatePathMiddle, truncateToWidth } from '../../utils/format.js';
-import type { Theme } from '../../utils/theme.js';
+import figures from 'figures'
+import * as React from 'react'
+import { memo, type ReactNode } from 'react'
+import { useTerminalSize } from '../../hooks/useTerminalSize.js'
+import { stringWidth } from '../../ink/stringWidth.js'
+import { Box, Text } from '../../ink.js'
+import { truncatePathMiddle, truncateToWidth } from '../../utils/format.js'
+import type { Theme } from '../../utils/theme.js'
+
 export type SuggestionItem = {
-  id: string;
-  displayText: string;
-  tag?: string;
-  description?: string;
-  metadata?: unknown;
-  color?: keyof Theme;
-};
-export type SuggestionType = 'command' | 'file' | 'directory' | 'agent' | 'shell' | 'custom-title' | 'slack-channel' | 'none';
-export const OVERLAY_MAX_ITEMS = 5;
+  id: string
+  displayText: string
+  tag?: string
+  description?: string
+  metadata?: unknown
+  color?: keyof Theme
+}
+
+export type SuggestionType =
+  | 'command'
+  | 'file'
+  | 'directory'
+  | 'agent'
+  | 'shell'
+  | 'custom-title'
+  | 'slack-channel'
+  | 'none'
+
+export const OVERLAY_MAX_ITEMS = 5
+
+const SELECTED_PREFIX = `${figures.pointer} `
+const UNSELECTED_PREFIX = '  '
+const PREFIX_WIDTH = stringWidth(SELECTED_PREFIX)
 
-/**
- * Get the icon for a suggestion based on its type
- * Icons: + for files, ◇ for MCP resources, * for agents
- */
 function getIcon(itemId: string): string {
-  if (itemId.startsWith('file-')) return '+';
-  if (itemId.startsWith('mcp-resource-')) return '◇';
-  if (itemId.startsWith('agent-')) return '*';
-  return '+';
+  if (itemId.startsWith('file-')) return '+'
+  if (itemId.startsWith('mcp-resource-')) return '◇'
+  if (itemId.startsWith('agent-')) return '*'
+  return '+'
 }
 
-/**
- * Check if an item is a unified suggestion type (file, mcp-resource, or agent)
- */
 function isUnifiedSuggestion(itemId: string): boolean {
-  return itemId.startsWith('file-') || itemId.startsWith('mcp-resource-') || itemId.startsWith('agent-');
+  return (
+    itemId.startsWith('file-') ||
+    itemId.startsWith('mcp-resource-') ||
+    itemId.startsWith('agent-')
+  )
 }
-const SuggestionItemRow = memo(function SuggestionItemRow(t0) {
-  const $ = _c(36);
-  const {
-    item,
-    maxColumnWidth,
-    isSelected
-  } = t0;
-  const columns = useTerminalSize().columns;
-  const isUnified = isUnifiedSuggestion(item.id);
-  if (isUnified) {
-    let t1;
-    if ($[0] !== item.id) {
-      t1 = getIcon(item.id);
-      $[0] = item.id;
-      $[1] = t1;
-    } else {
-      t1 = $[1];
-    }
-    const icon = t1;
-    const textColor = isSelected ? "suggestion" : undefined;
-    const dimColor = !isSelected;
-    const isFile = item.id.startsWith("file-");
-    const isMcpResource = item.id.startsWith("mcp-resource-");
-    const separatorWidth = item.description ? 3 : 0;
-    let displayText;
+
+const SuggestionItemRow = memo(function SuggestionItemRow({
+  item,
+  maxColumnWidth,
+  isSelected,
+}: {
+  item: SuggestionItem
+  maxColumnWidth?: number
+  isSelected: boolean
+}): ReactNode {
+  const columns = useTerminalSize().columns
+  const selectionPrefix = isSelected ? SELECTED_PREFIX : UNSELECTED_PREFIX
+  const rowBackgroundColor: keyof Theme | undefined = isSelected
+    ? 'suggestion'
+    : undefined
+  const textColor: keyof Theme | undefined = isSelected ? 'inverseText' : undefined
+
+  if (isUnifiedSuggestion(item.id)) {
+    const icon = getIcon(item.id)
+    const dimColor = !isSelected
+    const isFile = item.id.startsWith('file-')
+    const isMcpResource = item.id.startsWith('mcp-resource-')
+    const iconWidth = 2
+    const paddingWidth = 4
+    const separatorWidth = item.description ? 3 : 0
+
+    let displayText: string
     if (isFile) {
-      let t2;
-      if ($[2] !== item.description) {
-        t2 = item.description ? Math.min(20, stringWidth(item.description)) : 0;
-        $[2] = item.description;
-        $[3] = t2;
-      } else {
-        t2 = $[3];
-      }
-      const descReserve = t2;
-      const maxPathLength = columns - 2 - 4 - separatorWidth - descReserve;
-      let t3;
-      if ($[4] !== item.displayText || $[5] !== maxPathLength) {
-        t3 = truncatePathMiddle(item.displayText, maxPathLength);
-        $[4] = item.displayText;
-        $[5] = maxPathLength;
-        $[6] = t3;
-      } else {
-        t3 = $[6];
-      }
-      displayText = t3;
+      const descReserve = item.description
+        ? Math.min(20, stringWidth(item.description))
+        : 0
+      const maxPathLength =
+        columns -
+        PREFIX_WIDTH -
+        iconWidth -
+        paddingWidth -
+        separatorWidth -
+        descReserve
+      displayText = truncatePathMiddle(item.displayText, maxPathLength)
+    } else if (isMcpResource) {
+      displayText = truncateToWidth(item.displayText, 30)
     } else {
-      if (isMcpResource) {
-        let t2;
-        if ($[7] !== item.displayText) {
-          t2 = truncateToWidth(item.displayText, 30);
-          $[7] = item.displayText;
-          $[8] = t2;
-        } else {
-          t2 = $[8];
-        }
-        displayText = t2;
-      } else {
-        displayText = item.displayText;
-      }
+      displayText = item.displayText
     }
-    const availableWidth = columns - 2 - stringWidth(displayText) - separatorWidth - 4;
-    let lineContent;
+
+    const availableWidth =
+      columns -
+      PREFIX_WIDTH -
+      iconWidth -
+      stringWidth(displayText) -
+      separatorWidth -
+      paddingWidth
+
+    let lineContent: string
     if (item.description) {
-      const maxDescLength = Math.max(0, availableWidth);
-      let t2;
-      if ($[9] !== item.description || $[10] !== maxDescLength) {
-        t2 = truncateToWidth(item.description.replace(/\s+/g, " "), maxDescLength);
-        $[9] = item.description;
-        $[10] = maxDescLength;
-        $[11] = t2;
-      } else {
-        t2 = $[11];
-      }
-      const truncatedDesc = t2;
-      lineContent = `${icon} ${displayText} – ${truncatedDesc}`;
+      const truncatedDesc = truncateToWidth(
+        item.description.replace(/\s+/g, ' '),
+        Math.max(0, availableWidth),
+      )
+      lineContent = `${selectionPrefix}${icon} ${displayText} - ${truncatedDesc}`
     } else {
-      lineContent = `${icon} ${displayText}`;
+      lineContent = `${selectionPrefix}${icon} ${displayText}`
     }
-    let t2;
-    if ($[12] !== dimColor || $[13] !== lineContent || $[14] !== textColor) {
-      t2 = <Text color={textColor} dimColor={dimColor} wrap="truncate">{lineContent}</Text>;
-      $[12] = dimColor;
-      $[13] = lineContent;
-      $[14] = textColor;
-      $[15] = t2;
-    } else {
-      t2 = $[15];
-    }
-    return t2;
+
+    return (
+      <Box width="100%" opaque={true} backgroundColor={rowBackgroundColor}>
+        <Text color={textColor} dimColor={dimColor} bold={isSelected} wrap="truncate">
+          {lineContent}
+        </Text>
+      </Box>
+    )
   }
-  const maxNameWidth = Math.floor(columns * 0.4);
-  const displayTextWidth = Math.min(maxColumnWidth ?? stringWidth(item.displayText) + 5, maxNameWidth);
-  const textColor_0 = item.color || (isSelected ? "suggestion" : undefined);
-  const shouldDim = !isSelected;
-  let displayText_0 = item.displayText;
-  if (stringWidth(displayText_0) > displayTextWidth - 2) {
-    const t1 = displayTextWidth - 2;
-    let t2;
-    if ($[16] !== displayText_0 || $[17] !== t1) {
-      t2 = truncateToWidth(displayText_0, t1);
-      $[16] = displayText_0;
-      $[17] = t1;
-      $[18] = t2;
-    } else {
-      t2 = $[18];
-    }
-    displayText_0 = t2;
+
+  const maxNameWidth = Math.floor(columns * 0.4)
+  const displayTextWidth = Math.min(
+    maxColumnWidth ?? stringWidth(item.displayText) + 5,
+    maxNameWidth,
+  )
+  const displayTextColor = isSelected ? 'inverseText' : item.color
+  const shouldDim = !isSelected
+
+  let displayText = item.displayText
+  if (stringWidth(displayText) > displayTextWidth - 2) {
+    displayText = truncateToWidth(displayText, displayTextWidth - 2)
   }
-  const paddedDisplayText = displayText_0 + " ".repeat(Math.max(0, displayTextWidth - stringWidth(displayText_0)));
-  const tagText = item.tag ? `[${item.tag}] ` : "";
-  const tagWidth = stringWidth(tagText);
-  const descriptionWidth = Math.max(0, columns - displayTextWidth - tagWidth - 4);
-  let t1;
-  if ($[19] !== descriptionWidth || $[20] !== item.description) {
-    t1 = item.description ? truncateToWidth(item.description.replace(/\s+/g, " "), descriptionWidth) : "";
-    $[19] = descriptionWidth;
-    $[20] = item.description;
-    $[21] = t1;
-  } else {
-    t1 = $[21];
-  }
-  const truncatedDescription = t1;
-  let t2;
-  if ($[22] !== paddedDisplayText || $[23] !== shouldDim || $[24] !== textColor_0) {
-    t2 = <Text color={textColor_0} dimColor={shouldDim}>{paddedDisplayText}</Text>;
-    $[22] = paddedDisplayText;
-    $[23] = shouldDim;
-    $[24] = textColor_0;
-    $[25] = t2;
-  } else {
-    t2 = $[25];
-  }
-  let t3;
-  if ($[26] !== tagText) {
-    t3 = tagText ? <Text dimColor={true}>{tagText}</Text> : null;
-    $[26] = tagText;
-    $[27] = t3;
-  } else {
-    t3 = $[27];
-  }
-  const t4 = isSelected ? "suggestion" : undefined;
-  const t5 = !isSelected;
-  let t6;
-  if ($[28] !== t4 || $[29] !== t5 || $[30] !== truncatedDescription) {
-    t6 = <Text color={t4} dimColor={t5}>{truncatedDescription}</Text>;
-    $[28] = t4;
-    $[29] = t5;
-    $[30] = truncatedDescription;
-    $[31] = t6;
-  } else {
-    t6 = $[31];
-  }
-  let t7;
-  if ($[32] !== t2 || $[33] !== t3 || $[34] !== t6) {
-    t7 = <Text wrap="truncate">{t2}{t3}{t6}</Text>;
-    $[32] = t2;
-    $[33] = t3;
-    $[34] = t6;
-    $[35] = t7;
-  } else {
-    t7 = $[35];
-  }
-  return t7;
-});
+
+  const paddedDisplayText =
+    selectionPrefix +
+    displayText +
+    ' '.repeat(Math.max(0, displayTextWidth - stringWidth(displayText)))
+  const tagText = item.tag ? `[${item.tag}] ` : ''
+  const tagWidth = stringWidth(tagText)
+  const descriptionWidth = Math.max(
+    0,
+    columns - PREFIX_WIDTH - displayTextWidth - tagWidth - 4,
+  )
+  const truncatedDescription = item.description
+    ? truncateToWidth(item.description.replace(/\s+/g, ' '), descriptionWidth)
+    : ''
+
+  return (
+    <Box width="100%" opaque={true} backgroundColor={rowBackgroundColor}>
+      <Text wrap="truncate">
+        <Text color={displayTextColor} dimColor={shouldDim} bold={isSelected}>
+          {paddedDisplayText}
+        </Text>
+        {tagText ? (
+          <Text color={textColor} dimColor={!isSelected}>
+            {tagText}
+          </Text>
+        ) : null}
+        <Text color={textColor} dimColor={!isSelected}>
+          {truncatedDescription}
+        </Text>
+      </Text>
+    </Box>
+  )
+})
+
 type Props = {
-  suggestions: SuggestionItem[];
-  selectedSuggestion: number;
-  maxColumnWidth?: number;
-  /**
-   * When true, the suggestions are rendered inside a position=absolute
-   * overlay. We omit minHeight and flex-end so the y-clamp in the
-   * renderer doesn't push fewer items down into the prompt area.
-   */
-  overlay?: boolean;
-};
-export function PromptInputFooterSuggestions(t0) {
-  const $ = _c(22);
-  const {
-    suggestions,
-    selectedSuggestion,
-    maxColumnWidth: maxColumnWidthProp,
-    overlay
-  } = t0;
-  const {
-    rows
-  } = useTerminalSize();
-  const maxVisibleItems = overlay ? OVERLAY_MAX_ITEMS : Math.min(6, Math.max(1, rows - 3));
+  suggestions: SuggestionItem[]
+  selectedSuggestion: number
+  maxColumnWidth?: number
+  overlay?: boolean
+}
+
+export function PromptInputFooterSuggestions({
+  suggestions,
+  selectedSuggestion,
+  maxColumnWidth: maxColumnWidthProp,
+  overlay,
+}: Props): ReactNode {
+  const { rows } = useTerminalSize()
+  const maxVisibleItems = overlay ? OVERLAY_MAX_ITEMS : Math.min(6, Math.max(1, rows - 3))
+
   if (suggestions.length === 0) {
-    return null;
+    return null
   }
-  let t1;
-  if ($[0] !== maxColumnWidthProp || $[1] !== suggestions) {
-    t1 = maxColumnWidthProp ?? Math.max(...suggestions.map(_temp)) + 5;
-    $[0] = maxColumnWidthProp;
-    $[1] = suggestions;
-    $[2] = t1;
-  } else {
-    t1 = $[2];
-  }
-  const maxColumnWidth = t1;
-  const startIndex = Math.max(0, Math.min(selectedSuggestion - Math.floor(maxVisibleItems / 2), suggestions.length - maxVisibleItems));
-  const endIndex = Math.min(startIndex + maxVisibleItems, suggestions.length);
-  let T0;
-  let t2;
-  let t3;
-  let t4;
-  if ($[3] !== endIndex || $[4] !== maxColumnWidth || $[5] !== overlay || $[6] !== selectedSuggestion || $[7] !== startIndex || $[8] !== suggestions) {
-    const visibleItems = suggestions.slice(startIndex, endIndex);
-    T0 = Box;
-    t2 = "column";
-    t3 = overlay ? undefined : "flex-end";
-    let t5;
-    if ($[13] !== maxColumnWidth || $[14] !== selectedSuggestion || $[15] !== suggestions) {
-      t5 = item_0 => <SuggestionItemRow key={item_0.id} item={item_0} maxColumnWidth={maxColumnWidth} isSelected={item_0.id === suggestions[selectedSuggestion]?.id} />;
-      $[13] = maxColumnWidth;
-      $[14] = selectedSuggestion;
-      $[15] = suggestions;
-      $[16] = t5;
-    } else {
-      t5 = $[16];
-    }
-    t4 = visibleItems.map(t5);
-    $[3] = endIndex;
-    $[4] = maxColumnWidth;
-    $[5] = overlay;
-    $[6] = selectedSuggestion;
-    $[7] = startIndex;
-    $[8] = suggestions;
-    $[9] = T0;
-    $[10] = t2;
-    $[11] = t3;
-    $[12] = t4;
-  } else {
-    T0 = $[9];
-    t2 = $[10];
-    t3 = $[11];
-    t4 = $[12];
-  }
-  let t5;
-  if ($[17] !== T0 || $[18] !== t2 || $[19] !== t3 || $[20] !== t4) {
-    t5 = <T0 flexDirection={t2} justifyContent={t3}>{t4}</T0>;
-    $[17] = T0;
-    $[18] = t2;
-    $[19] = t3;
-    $[20] = t4;
-    $[21] = t5;
-  } else {
-    t5 = $[21];
-  }
-  return t5;
+
+  const maxColumnWidth =
+    maxColumnWidthProp ??
+    Math.max(...suggestions.map(item => stringWidth(item.displayText))) + 5
+
+  const startIndex = Math.max(
+    0,
+    Math.min(
+      selectedSuggestion - Math.floor(maxVisibleItems / 2),
+      suggestions.length - maxVisibleItems,
+    ),
+  )
+  const endIndex = Math.min(startIndex + maxVisibleItems, suggestions.length)
+  const visibleItems = suggestions.slice(startIndex, endIndex)
+
+  return (
+    <Box
+      flexDirection="column"
+      justifyContent={overlay ? undefined : 'flex-end'}
+    >
+      {visibleItems.map(item => (
+        <SuggestionItemRow
+          key={`${item.id}:${item.id === suggestions[selectedSuggestion]?.id ? 'selected' : 'idle'}`}
+          item={item}
+          maxColumnWidth={maxColumnWidth}
+          isSelected={item.id === suggestions[selectedSuggestion]?.id}
+        />
+      ))}
+    </Box>
+  )
 }
-function _temp(item) {
-  return stringWidth(item.displayText);
-}
-export default memo(PromptInputFooterSuggestions);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","memo","ReactNode","useTerminalSize","stringWidth","Box","Text","truncatePathMiddle","truncateToWidth","Theme","SuggestionItem","id","displayText","tag","description","metadata","color","SuggestionType","OVERLAY_MAX_ITEMS","getIcon","itemId","startsWith","isUnifiedSuggestion","SuggestionItemRow","t0","$","_c","item","maxColumnWidth","isSelected","columns","isUnified","t1","icon","textColor","undefined","dimColor","isFile","isMcpResource","separatorWidth","t2","Math","min","descReserve","maxPathLength","t3","availableWidth","lineContent","maxDescLength","max","replace","truncatedDesc","maxNameWidth","floor","displayTextWidth","textColor_0","shouldDim","displayText_0","paddedDisplayText","repeat","tagText","tagWidth","descriptionWidth","truncatedDescription","t4","t5","t6","t7","Props","suggestions","selectedSuggestion","overlay","PromptInputFooterSuggestions","maxColumnWidthProp","rows","maxVisibleItems","length","map","_temp","startIndex","endIndex","T0","visibleItems","slice","item_0"],"sources":["PromptInputFooterSuggestions.tsx"],"sourcesContent":["import * as React from 'react'\nimport { memo, type ReactNode } from 'react'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, Text } from '../../ink.js'\nimport { truncatePathMiddle, truncateToWidth } from '../../utils/format.js'\nimport type { Theme } from '../../utils/theme.js'\n\nexport type SuggestionItem = {\n  id: string\n  displayText: string\n  tag?: string\n  description?: string\n  metadata?: unknown\n  color?: keyof Theme\n}\n\nexport type SuggestionType =\n  | 'command'\n  | 'file'\n  | 'directory'\n  | 'agent'\n  | 'shell'\n  | 'custom-title'\n  | 'slack-channel'\n  | 'none'\n\nexport const OVERLAY_MAX_ITEMS = 5\n\n/**\n * Get the icon for a suggestion based on its type\n * Icons: + for files, ◇ for MCP resources, * for agents\n */\nfunction getIcon(itemId: string): string {\n  if (itemId.startsWith('file-')) return '+'\n  if (itemId.startsWith('mcp-resource-')) return '◇'\n  if (itemId.startsWith('agent-')) return '*'\n  return '+'\n}\n\n/**\n * Check if an item is a unified suggestion type (file, mcp-resource, or agent)\n */\nfunction isUnifiedSuggestion(itemId: string): boolean {\n  return (\n    itemId.startsWith('file-') ||\n    itemId.startsWith('mcp-resource-') ||\n    itemId.startsWith('agent-')\n  )\n}\n\nconst SuggestionItemRow = memo(function SuggestionItemRow({\n  item,\n  maxColumnWidth,\n  isSelected,\n}: {\n  item: SuggestionItem\n  maxColumnWidth?: number\n  isSelected: boolean\n}): ReactNode {\n  const columns = useTerminalSize().columns\n  const isUnified = isUnifiedSuggestion(item.id)\n\n  // For unified suggestions (file, mcp-resource, agent), use single-line layout with icon\n  if (isUnified) {\n    const icon = getIcon(item.id)\n    const textColor: keyof Theme | undefined = isSelected\n      ? 'suggestion'\n      : undefined\n    const dimColor = !isSelected\n\n    const isFile = item.id.startsWith('file-')\n    const isMcpResource = item.id.startsWith('mcp-resource-')\n\n    // Calculate layout widths\n    // Layout: \"X \" (2) + displayText + \" – \" (3) + description + padding (4)\n    const iconWidth = 2 // icon + space (fixed)\n    const paddingWidth = 4\n    const separatorWidth = item.description ? 3 : 0 // ' – ' separator\n\n    // For files, truncate middle of path to show both directory context and filename\n    // For MCP resources, limit displayText to 30 chars (truncate from end)\n    // For agents, no truncation\n    let displayText: string\n    if (isFile) {\n      // Reserve space for description if present, otherwise use all available space\n      const descReserve = item.description\n        ? Math.min(20, stringWidth(item.description))\n        : 0\n      const maxPathLength =\n        columns - iconWidth - paddingWidth - separatorWidth - descReserve\n      displayText = truncatePathMiddle(item.displayText, maxPathLength)\n    } else if (isMcpResource) {\n      const maxDisplayTextLength = 30\n      displayText = truncateToWidth(item.displayText, maxDisplayTextLength)\n    } else {\n      displayText = item.displayText\n    }\n\n    const availableWidth =\n      columns -\n      iconWidth -\n      stringWidth(displayText) -\n      separatorWidth -\n      paddingWidth\n\n    // Build the full line as a single string to prevent wrapping\n    let lineContent: string\n    if (item.description) {\n      const maxDescLength = Math.max(0, availableWidth)\n      const truncatedDesc = truncateToWidth(\n        item.description.replace(/\\s+/g, ' '),\n        maxDescLength,\n      )\n      lineContent = `${icon} ${displayText} – ${truncatedDesc}`\n    } else {\n      lineContent = `${icon} ${displayText}`\n    }\n\n    return (\n      <Text color={textColor} dimColor={dimColor} wrap=\"truncate\">\n        {lineContent}\n      </Text>\n    )\n  }\n\n  // For non-unified suggestions (commands, shell, etc.), use improved layout from main\n  // Cap the command name column at 40% of terminal width to ensure description has space\n  const maxNameWidth = Math.floor(columns * 0.4)\n  const displayTextWidth = Math.min(\n    maxColumnWidth ?? stringWidth(item.displayText) + 5,\n    maxNameWidth,\n  )\n\n  const textColor = item.color || (isSelected ? 'suggestion' : undefined)\n  const shouldDim = !isSelected\n\n  // Truncate and pad the display text to fixed width\n  let displayText = item.displayText\n  if (stringWidth(displayText) > displayTextWidth - 2) {\n    displayText = truncateToWidth(displayText, displayTextWidth - 2)\n  }\n  const paddedDisplayText =\n    displayText +\n    ' '.repeat(Math.max(0, displayTextWidth - stringWidth(displayText)))\n\n  const tagText = item.tag ? `[${item.tag}] ` : ''\n  const tagWidth = stringWidth(tagText)\n  const descriptionWidth = Math.max(\n    0,\n    columns - displayTextWidth - tagWidth - 4,\n  )\n  // Skill descriptions can contain newlines (e.g. /claude-api's \"TRIGGER\n  // when:\" block). A multi-line row grows the overlay past minHeight; when\n  // the filter narrows past that skill, the overlay shrinks and leaves\n  // ghost rows. Flatten to one line before truncating.\n  const truncatedDescription = item.description\n    ? truncateToWidth(item.description.replace(/\\s+/g, ' '), descriptionWidth)\n    : ''\n\n  return (\n    <Text wrap=\"truncate\">\n      <Text color={textColor} dimColor={shouldDim}>\n        {paddedDisplayText}\n      </Text>\n      {tagText ? <Text dimColor>{tagText}</Text> : null}\n      <Text\n        color={isSelected ? 'suggestion' : undefined}\n        dimColor={!isSelected}\n      >\n        {truncatedDescription}\n      </Text>\n    </Text>\n  )\n})\n\ntype Props = {\n  suggestions: SuggestionItem[]\n  selectedSuggestion: number\n  maxColumnWidth?: number\n  /**\n   * When true, the suggestions are rendered inside a position=absolute\n   * overlay. We omit minHeight and flex-end so the y-clamp in the\n   * renderer doesn't push fewer items down into the prompt area.\n   */\n  overlay?: boolean\n}\n\nexport function PromptInputFooterSuggestions({\n  suggestions,\n  selectedSuggestion,\n  maxColumnWidth: maxColumnWidthProp,\n  overlay,\n}: Props): ReactNode {\n  const { rows } = useTerminalSize()\n  // Maximum number of suggestions to show at once (leaving space for prompt).\n  // Overlay mode (fullscreen) uses a fixed 5 — the floating box sits over\n  // the ScrollBox, so terminal height isn't the constraint.\n  const maxVisibleItems = overlay\n    ? OVERLAY_MAX_ITEMS\n    : Math.min(6, Math.max(1, rows - 3))\n\n  // No suggestions to display\n  if (suggestions.length === 0) {\n    return null\n  }\n\n  // Use prop if provided (stable width from all commands), otherwise calculate from visible\n  const maxColumnWidth =\n    maxColumnWidthProp ??\n    Math.max(...suggestions.map(item => stringWidth(item.displayText))) + 5\n\n  // Calculate visible items range based on selected index\n  const startIndex = Math.max(\n    0,\n    Math.min(\n      selectedSuggestion - Math.floor(maxVisibleItems / 2),\n      suggestions.length - maxVisibleItems,\n    ),\n  )\n  const endIndex = Math.min(startIndex + maxVisibleItems, suggestions.length)\n  const visibleItems = suggestions.slice(startIndex, endIndex)\n\n  // In non-overlay (inline) mode, justifyContent keeps suggestions\n  // anchored to the bottom (near the prompt). In overlay mode we omit\n  // both minHeight and flex-end: the parent is position=absolute with\n  // bottom='100%', so its y is clamped to 0 by the renderer when it\n  // would go negative. Adding minHeight + flex-end would create empty\n  // padding rows that shift the visible items down into the prompt area\n  // when the list has fewer items than maxVisibleItems.\n  return (\n    <Box\n      flexDirection=\"column\"\n      justifyContent={overlay ? undefined : 'flex-end'}\n    >\n      {visibleItems.map(item => (\n        <SuggestionItemRow\n          key={item.id}\n          item={item}\n          maxColumnWidth={maxColumnWidth}\n          isSelected={item.id === suggestions[selectedSuggestion]?.id}\n        />\n      ))}\n    </Box>\n  )\n}\n\nexport default memo(PromptInputFooterSuggestions)\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+
+export default memo(PromptInputFooterSuggestions)
diff --git a/src/components/StartupScreen.ts b/src/components/StartupScreen.ts
index ded4f457..e38a4111 100644
--- a/src/components/StartupScreen.ts
+++ b/src/components/StartupScreen.ts
@@ -80,6 +80,7 @@ const LOGO_CLAUDE = [
 
 function detectProvider(): { name: string; model: string; baseUrl: string; isLocal: boolean } {
   const useGemini = process.env.CLAUDE_CODE_USE_GEMINI === '1' || process.env.CLAUDE_CODE_USE_GEMINI === 'true'
+  const useGithub = process.env.CLAUDE_CODE_USE_GITHUB === '1' || process.env.CLAUDE_CODE_USE_GITHUB === 'true'
   const useOpenAI = process.env.CLAUDE_CODE_USE_OPENAI === '1' || process.env.CLAUDE_CODE_USE_OPENAI === 'true'
 
   if (useGemini) {
@@ -88,22 +89,53 @@ function detectProvider(): { name: string; model: string; baseUrl: string; isLoc
     return { name: 'Google Gemini', model, baseUrl, isLocal: false }
   }
 
+  if (useGithub) {
+    const model = process.env.OPENAI_MODEL || 'github:copilot'
+    const baseUrl =
+      process.env.OPENAI_BASE_URL || 'https://models.github.ai/inference'
+    return { name: 'GitHub Models', model, baseUrl, isLocal: false }
+  }
+
   if (useOpenAI) {
-    const model = process.env.OPENAI_MODEL || 'gpt-4o'
+    const rawModel = process.env.OPENAI_MODEL || 'gpt-4o'
     const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
     const isLocal = /localhost|127\.0\.0\.1|0\.0\.0\.0/.test(baseUrl)
     let name = 'OpenAI'
-    if (/deepseek/i.test(baseUrl) || /deepseek/i.test(model))       name = 'DeepSeek'
+    if (/deepseek/i.test(baseUrl) || /deepseek/i.test(rawModel))       name = 'DeepSeek'
     else if (/openrouter/i.test(baseUrl))                             name = 'OpenRouter'
     else if (/together/i.test(baseUrl))                               name = 'Together AI'
     else if (/groq/i.test(baseUrl))                                   name = 'Groq'
-    else if (/mistral/i.test(baseUrl) || /mistral/i.test(model))     name = 'Mistral'
+    else if (/mistral/i.test(baseUrl) || /mistral/i.test(rawModel))     name = 'Mistral'
     else if (/azure/i.test(baseUrl))                                  name = 'Azure OpenAI'
     else if (/localhost:11434/i.test(baseUrl))                        name = 'Ollama'
     else if (/localhost:1234/i.test(baseUrl))                         name = 'LM Studio'
-    else if (/llama/i.test(model))                                    name = 'Meta Llama'
+    else if (/llama/i.test(rawModel))                                    name = 'Meta Llama'
     else if (isLocal)                                                  name = 'Local'
-    return { name, model, baseUrl, isLocal }
+    
+    // Resolve model alias to actual model name + reasoning effort
+    let displayModel = rawModel
+    const codexAliases: Record<string, { model: string; reasoningEffort?: string }> = {
+      codexplan: { model: 'gpt-5.4', reasoningEffort: 'high' },
+      'gpt-5.4': { model: 'gpt-5.4', reasoningEffort: 'high' },
+      'gpt-5.3-codex': { model: 'gpt-5.3-codex', reasoningEffort: 'high' },
+      'gpt-5.3-codex-spark': { model: 'gpt-5.3-codex-spark' },
+      codexspark: { model: 'gpt-5.3-codex-spark' },
+      'gpt-5.2-codex': { model: 'gpt-5.2-codex', reasoningEffort: 'high' },
+      'gpt-5.1-codex-max': { model: 'gpt-5.1-codex-max', reasoningEffort: 'high' },
+      'gpt-5.1-codex-mini': { model: 'gpt-5.1-codex-mini' },
+      'gpt-5.4-mini': { model: 'gpt-5.4-mini', reasoningEffort: 'medium' },
+      'gpt-5.2': { model: 'gpt-5.2', reasoningEffort: 'medium' },
+    }
+    const alias = rawModel.toLowerCase()
+    if (alias in codexAliases) {
+      const resolved = codexAliases[alias]
+      displayModel = resolved.model
+      if (resolved.reasoningEffort) {
+        displayModel = `${displayModel} (${resolved.reasoningEffort})`
+      }
+    }
+    
+    return { name, model: displayModel, baseUrl, isLocal }
   }
 
   // Default: Anthropic
diff --git a/src/context/promptOverlayContext.tsx b/src/context/promptOverlayContext.tsx
index 98e36bb3..3c8907ec 100644
--- a/src/context/promptOverlayContext.tsx
+++ b/src/context/promptOverlayContext.tsx
@@ -70,17 +70,18 @@ export function usePromptOverlayDialog() {
  * No-op outside the provider (non-fullscreen renders inline instead).
  */
 export function useSetPromptOverlay(data) {
-  const $ = _c(4);
+  const $ = _c(8);
   const set = useContext(SetContext);
   let t0;
   let t1;
+  let t2;
+  let t3;
   if ($[0] !== data || $[1] !== set) {
     t0 = () => {
       if (!set) {
         return;
       }
       set(data);
-      return () => set(null);
     };
     t1 = [set, data];
     $[0] = data;
@@ -91,7 +92,23 @@ export function useSetPromptOverlay(data) {
     t0 = $[2];
     t1 = $[3];
   }
+  if ($[4] !== set) {
+    t2 = () => {
+      if (!set) {
+        return;
+      }
+      return () => set(null);
+    };
+    t3 = [set];
+    $[4] = set;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t2 = $[5];
+    t3 = $[6];
+  }
   useEffect(t0, t1);
+  useEffect(t2, t3);
 }
 
 /**
@@ -99,17 +116,18 @@ export function useSetPromptOverlay(data) {
  * No-op outside the provider (non-fullscreen renders inline instead).
  */
 export function useSetPromptOverlayDialog(node) {
-  const $ = _c(4);
+  const $ = _c(8);
   const set = useContext(SetDialogContext);
   let t0;
   let t1;
+  let t2;
+  let t3;
   if ($[0] !== node || $[1] !== set) {
     t0 = () => {
       if (!set) {
         return;
       }
       set(node);
-      return () => set(null);
     };
     t1 = [set, node];
     $[0] = node;
@@ -120,6 +138,22 @@ export function useSetPromptOverlayDialog(node) {
     t0 = $[2];
     t1 = $[3];
   }
+  if ($[4] !== set) {
+    t2 = () => {
+      if (!set) {
+        return;
+      }
+      return () => set(null);
+    };
+    t3 = [set];
+    $[4] = set;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t2 = $[5];
+    t3 = $[6];
+  }
   useEffect(t0, t1);
+  useEffect(t2, t3);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","ReactNode","useContext","useEffect","useState","SuggestionItem","PromptOverlayData","suggestions","selectedSuggestion","maxColumnWidth","Setter","d","T","DataContext","SetContext","DialogContext","SetDialogContext","PromptOverlayProvider","t0","$","_c","children","data","setData","dialog","setDialog","t1","t2","usePromptOverlay","usePromptOverlayDialog","useSetPromptOverlay","set","useSetPromptOverlayDialog","node"],"sources":["promptOverlayContext.tsx"],"sourcesContent":["/**\n * Portal for content that floats above the prompt so it escapes\n * FullscreenLayout's bottom-slot `overflowY:hidden` clip.\n *\n * The clip is load-bearing (CC-668: tall pastes squash the ScrollBox\n * without it), but floating overlays use `position:absolute\n * bottom=\"100%\"` to float above the prompt — and Ink's clip stack\n * intersects ALL descendants, so they were clipped to ~1 row.\n *\n * Two channels:\n * - `useSetPromptOverlay` — slash-command suggestion data (structured,\n *   written by PromptInputFooter)\n * - `useSetPromptOverlayDialog` — arbitrary dialog node (e.g.\n *   AutoModeOptInDialog, written by PromptInput)\n *\n * FullscreenLayout reads both and renders them outside the clipped slot.\n *\n * Split into data/setter context pairs so writers never re-render on\n * their own writes — the setter contexts are stable.\n */\nimport React, {\n  createContext,\n  type ReactNode,\n  useContext,\n  useEffect,\n  useState,\n} from 'react'\nimport type { SuggestionItem } from '../components/PromptInput/PromptInputFooterSuggestions.js'\n\nexport type PromptOverlayData = {\n  suggestions: SuggestionItem[]\n  selectedSuggestion: number\n  maxColumnWidth?: number\n}\n\ntype Setter<T> = (d: T | null) => void\n\nconst DataContext = createContext<PromptOverlayData | null>(null)\nconst SetContext = createContext<Setter<PromptOverlayData> | null>(null)\nconst DialogContext = createContext<ReactNode>(null)\nconst SetDialogContext = createContext<Setter<ReactNode> | null>(null)\n\nexport function PromptOverlayProvider({\n  children,\n}: {\n  children: ReactNode\n}): ReactNode {\n  const [data, setData] = useState<PromptOverlayData | null>(null)\n  const [dialog, setDialog] = useState<ReactNode>(null)\n  return (\n    <SetContext.Provider value={setData}>\n      <SetDialogContext.Provider value={setDialog}>\n        <DataContext.Provider value={data}>\n          <DialogContext.Provider value={dialog}>\n            {children}\n          </DialogContext.Provider>\n        </DataContext.Provider>\n      </SetDialogContext.Provider>\n    </SetContext.Provider>\n  )\n}\n\nexport function usePromptOverlay(): PromptOverlayData | null {\n  return useContext(DataContext)\n}\n\nexport function usePromptOverlayDialog(): ReactNode {\n  return useContext(DialogContext)\n}\n\n/**\n * Register suggestion data for the floating overlay. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlay(data: PromptOverlayData | null): void {\n  const set = useContext(SetContext)\n  useEffect(() => {\n    if (!set) return\n    set(data)\n    return () => set(null)\n  }, [set, data])\n}\n\n/**\n * Register a dialog node to float above the prompt. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlayDialog(node: ReactNode): void {\n  const set = useContext(SetDialogContext)\n  useEffect(() => {\n    if (!set) return\n    set(node)\n    return () => set(null)\n  }, [set, node])\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","ReactNode","useContext","useEffect","useState","SuggestionItem","PromptOverlayData","suggestions","selectedSuggestion","maxColumnWidth","Setter","d","T","DataContext","SetContext","DialogContext","SetDialogContext","PromptOverlayProvider","t0","$","_c","children","data","setData","dialog","setDialog","t1","t2","usePromptOverlay","usePromptOverlayDialog","useSetPromptOverlay","set","useSetPromptOverlayDialog","node"],"sources":["promptOverlayContext.tsx"],"sourcesContent":["/**\n * Portal for content that floats above the prompt so it escapes\n * FullscreenLayout's bottom-slot `overflowY:hidden` clip.\n *\n * The clip is load-bearing (CC-668: tall pastes squash the ScrollBox\n * without it), but floating overlays use `position:absolute\n * bottom=\"100%\"` to float above the prompt — and Ink's clip stack\n * intersects ALL descendants, so they were clipped to ~1 row.\n *\n * Two channels:\n * - `useSetPromptOverlay` — slash-command suggestion data (structured,\n *   written by PromptInputFooter)\n * - `useSetPromptOverlayDialog` — arbitrary dialog node (e.g.\n *   AutoModeOptInDialog, written by PromptInput)\n *\n * FullscreenLayout reads both and renders them outside the clipped slot.\n *\n * Split into data/setter context pairs so writers never re-render on\n * their own writes — the setter contexts are stable.\n */\nimport React, {\n  createContext,\n  type ReactNode,\n  useContext,\n  useEffect,\n  useState,\n} from 'react'\nimport type { SuggestionItem } from '../components/PromptInput/PromptInputFooterSuggestions.js'\n\nexport type PromptOverlayData = {\n  suggestions: SuggestionItem[]\n  selectedSuggestion: number\n  maxColumnWidth?: number\n}\n\ntype Setter<T> = (d: T | null) => void\n\nconst DataContext = createContext<PromptOverlayData | null>(null)\nconst SetContext = createContext<Setter<PromptOverlayData> | null>(null)\nconst DialogContext = createContext<ReactNode>(null)\nconst SetDialogContext = createContext<Setter<ReactNode> | null>(null)\n\nexport function PromptOverlayProvider({\n  children,\n}: {\n  children: ReactNode\n}): ReactNode {\n  const [data, setData] = useState<PromptOverlayData | null>(null)\n  const [dialog, setDialog] = useState<ReactNode>(null)\n  return (\n    <SetContext.Provider value={setData}>\n      <SetDialogContext.Provider value={setDialog}>\n        <DataContext.Provider value={data}>\n          <DialogContext.Provider value={dialog}>\n            {children}\n          </DialogContext.Provider>\n        </DataContext.Provider>\n      </SetDialogContext.Provider>\n    </SetContext.Provider>\n  )\n}\n\nexport function usePromptOverlay(): PromptOverlayData | null {\n  return useContext(DataContext)\n}\n\nexport function usePromptOverlayDialog(): ReactNode {\n  return useContext(DialogContext)\n}\n\n/**\n * Register suggestion data for the floating overlay. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlay(data: PromptOverlayData | null): void {\n  const set = useContext(SetContext)\n  useEffect(() => {\n    if (!set) return\n    set(data)\n    return () => set(null)\n  }, [set, data])\n}\n\n/**\n * Register a dialog node to float above the prompt. Clears on unmount.\n * No-op outside the provider (non-fullscreen renders inline instead).\n */\nexport function useSetPromptOverlayDialog(node: ReactNode): void {\n  const set = useContext(SetDialogContext)\n  useEffect(() => {\n    if (!set) return\n    set(node)\n    return () => set(null)\n  }, [set, node])\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/entrypoints/cli.tsx b/src/entrypoints/cli.tsx
index 71adb260..a119aa30 100644
--- a/src/entrypoints/cli.tsx
+++ b/src/entrypoints/cli.tsx
@@ -3,6 +3,11 @@ import {
   resolveCodexApiCredentials,
   resolveProviderRequest,
 } from '../services/api/providerConfig.js'
+import {
+  applyProfileEnvToProcessEnv,
+  buildStartupEnvFromProfile,
+  redactSecretValueForDisplay,
+} from '../utils/providerProfile.js'
 
 // Bugfix for corepack auto-pinning, which adds yarnpkg to peoples' package.jsons
 // eslint-disable-next-line custom-rules/no-top-level-side-effects
@@ -45,39 +50,72 @@ function isLocalProviderUrl(baseUrl: string | undefined): boolean {
   }
 }
 
-function validateProviderEnvOrExit(): void {
-  if (!isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)) {
-    return
+function getProviderValidationError(
+  env: NodeJS.ProcessEnv = process.env,
+): string | null {
+  const useOpenAI = isEnvTruthy(env.CLAUDE_CODE_USE_OPENAI)
+  const useGithub = isEnvTruthy(env.CLAUDE_CODE_USE_GITHUB)
+
+  if (isEnvTruthy(env.CLAUDE_CODE_USE_GEMINI)) {
+    if (!(env.GEMINI_API_KEY ?? env.GOOGLE_API_KEY)) {
+      return 'GEMINI_API_KEY is required when CLAUDE_CODE_USE_GEMINI=1.'
+    }
+    return null
+  }
+
+  if (useGithub && !useOpenAI) {
+    const token = (env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim()) ?? ''
+    if (!token) {
+      return 'GITHUB_TOKEN or GH_TOKEN is required when CLAUDE_CODE_USE_GITHUB=1.'
+    }
+    return null
+  }
+
+  if (!useOpenAI) {
+    return null
   }
 
   const request = resolveProviderRequest({
-    model: process.env.OPENAI_MODEL,
-    baseUrl: process.env.OPENAI_BASE_URL,
+    model: env.OPENAI_MODEL,
+    baseUrl: env.OPENAI_BASE_URL,
   })
 
-  if (process.env.OPENAI_API_KEY === 'SUA_CHAVE') {
-    console.error('Invalid OPENAI_API_KEY: placeholder value SUA_CHAVE detected. Set a real key or unset for local providers.')
-    process.exit(1)
+  if (env.OPENAI_API_KEY === 'SUA_CHAVE') {
+    return 'Invalid OPENAI_API_KEY: placeholder value SUA_CHAVE detected. Set a real key or unset for local providers.'
   }
 
   if (request.transport === 'codex_responses') {
-    const credentials = resolveCodexApiCredentials()
+    const credentials = resolveCodexApiCredentials(env)
     if (!credentials.apiKey) {
       const authHint = credentials.authPath
         ? ` or put auth.json at ${credentials.authPath}`
         : ''
-      console.error(`Codex auth is required for ${request.requestedModel}. Set CODEX_API_KEY${authHint}.`)
-      process.exit(1)
+      const safeModel =
+        redactSecretValueForDisplay(request.requestedModel, env) ??
+        'the requested model'
+      return `Codex auth is required for ${safeModel}. Set CODEX_API_KEY${authHint}.`
     }
     if (!credentials.accountId) {
-      console.error('Codex auth is missing chatgpt_account_id. Re-login with Codex or set CHATGPT_ACCOUNT_ID/CODEX_ACCOUNT_ID.')
-      process.exit(1)
+      return 'Codex auth is missing chatgpt_account_id. Re-login with Codex or set CHATGPT_ACCOUNT_ID/CODEX_ACCOUNT_ID.'
     }
-    return
+    return null
   }
 
-  if (!process.env.OPENAI_API_KEY && !isLocalProviderUrl(request.baseUrl)) {
-    console.error('OPENAI_API_KEY is required when CLAUDE_CODE_USE_OPENAI=1 and OPENAI_BASE_URL is not local.')
+  if (!env.OPENAI_API_KEY && !isLocalProviderUrl(request.baseUrl)) {
+    const hasGithubToken = !!(env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim())
+    if (useGithub && hasGithubToken) {
+      return null
+    }
+    return 'OPENAI_API_KEY is required when CLAUDE_CODE_USE_OPENAI=1 and OPENAI_BASE_URL is not local.'
+  }
+
+  return null
+}
+
+function validateProviderEnvOrExit(): void {
+  const error = getProviderValidationError()
+  if (error) {
+    console.error(error)
     process.exit(1)
   }
 }
@@ -98,6 +136,29 @@ async function main(): Promise<void> {
     return;
   }
 
+  {
+    const { enableConfigs } = await import('../utils/config.js')
+    enableConfigs()
+    const { applySafeConfigEnvironmentVariables } = await import('../utils/managedEnv.js')
+    applySafeConfigEnvironmentVariables()
+    const { hydrateGithubModelsTokenFromSecureStorage } = await import('../utils/githubModelsCredentials.js')
+    hydrateGithubModelsTokenFromSecureStorage()
+  }
+
+  const startupEnv = await buildStartupEnvFromProfile({
+    processEnv: process.env,
+  })
+  if (startupEnv !== process.env) {
+    const startupProfileError = getProviderValidationError(startupEnv)
+    if (startupProfileError) {
+      console.error(
+        `Warning: ignoring saved provider profile. ${startupProfileError}`,
+      )
+    } else {
+      applyProfileEnvToProcessEnv(process.env, startupEnv)
+    }
+  }
+
   validateProviderEnvOrExit()
 
   // Print the gradient startup screen before the Ink UI loads
diff --git a/src/hooks/useTypeahead.tsx b/src/hooks/useTypeahead.tsx
index a269902b..8183a011 100644
--- a/src/hooks/useTypeahead.tsx
+++ b/src/hooks/useTypeahead.tsx
@@ -1242,17 +1242,25 @@ export function useTypeahead({
   const handleAutocompletePrevious = useCallback(() => {
     setSuggestionsState(prev => ({
       ...prev,
-      selectedSuggestion: prev.selectedSuggestion <= 0 ? suggestions.length - 1 : prev.selectedSuggestion - 1
+      selectedSuggestion: prev.suggestions.length === 0
+        ? -1
+        : prev.selectedSuggestion <= 0
+          ? prev.suggestions.length - 1
+          : Math.min(prev.selectedSuggestion - 1, prev.suggestions.length - 1)
     }));
-  }, [suggestions.length, setSuggestionsState]);
+  }, [setSuggestionsState]);
 
   // Handler for autocomplete:next - selects next suggestion
   const handleAutocompleteNext = useCallback(() => {
     setSuggestionsState(prev => ({
       ...prev,
-      selectedSuggestion: prev.selectedSuggestion >= suggestions.length - 1 ? 0 : prev.selectedSuggestion + 1
+      selectedSuggestion: prev.suggestions.length === 0
+        ? -1
+        : prev.selectedSuggestion >= prev.suggestions.length - 1
+          ? 0
+          : Math.max(0, prev.selectedSuggestion + 1)
     }));
-  }, [suggestions.length, setSuggestionsState]);
+  }, [setSuggestionsState]);
 
   // Autocomplete context keybindings - only active when suggestions are visible
   const autocompleteHandlers = useMemo(() => ({
diff --git a/src/main.tsx b/src/main.tsx
index 07a3a3d2..a29c7e24 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -139,6 +139,7 @@ import { validateUuid } from './utils/uuid.js';
 // Plugin startup checks are now handled non-blockingly in REPL.tsx
 
 import { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js';
+import { registerMcpDoctorCommand } from 'src/commands/mcp/doctorCommand.js';
 import { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js';
 import { logPermissionContextForAnts } from 'src/services/internalLogging.js';
 import { fetchClaudeAIMcpConfigsIfEligible } from 'src/services/mcp/claudeai.js';
@@ -2313,7 +2314,11 @@ async function run(): Promise<CommanderCommand> {
         errors
       } = getSettingsWithErrors();
       const nonMcpErrors = errors.filter(e => !e.mcpErrorMetadata);
-      if (nonMcpErrors.length > 0 && !isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)) {
+      if (
+        nonMcpErrors.length > 0 &&
+        !isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) &&
+        !isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+      ) {
         await launchInvalidSettingsDialog(root, {
           settingsErrors: nonMcpErrors,
           onExit: () => gracefulShutdownSync(1)
@@ -3887,6 +3892,7 @@ async function run(): Promise<CommanderCommand> {
 
   // Register the mcp add subcommand (extracted for testability)
   registerMcpAddCommand(mcp);
+  registerMcpDoctorCommand(mcp);
   if (isXaaEnabled()) {
     registerMcpXaaIdpCommand(mcp);
   }
diff --git a/src/migrations/migrateSonnet1mToSonnet45.ts b/src/migrations/migrateSonnet1mToSonnet45.ts
index f2936388..23319591 100644
--- a/src/migrations/migrateSonnet1mToSonnet45.ts
+++ b/src/migrations/migrateSonnet1mToSonnet45.ts
@@ -3,6 +3,7 @@ import {
   setMainLoopModelOverride,
 } from '../bootstrap/state.js'
 import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import { getAPIProvider } from '../utils/model/providers.js'
 import {
   getSettingsForSource,
   updateSettingsForSource,
@@ -23,6 +24,10 @@ import {
  * tracked by a completion flag in global config.
  */
 export function migrateSonnet1mToSonnet45(): void {
+  if (getAPIProvider() !== 'firstParty') {
+    return
+  }
+
   const config = getGlobalConfig()
   if (config.sonnet1m45MigrationComplete) {
     return
diff --git a/src/services/api/client.ts b/src/services/api/client.ts
index 493f4d73..ee50e35c 100644
--- a/src/services/api/client.ts
+++ b/src/services/api/client.ts
@@ -154,7 +154,10 @@ export async function getAnthropicClient({
       fetch: resolvedFetch,
     }),
   }
-  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)) {
+  if (
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+  ) {
     const { createOpenAIShimClient } = await import('./openaiShim.js')
     return createOpenAIShimClient({
       defaultHeaders,
diff --git a/src/services/api/codexShim.test.ts b/src/services/api/codexShim.test.ts
index bee8f5ca..96ab999c 100644
--- a/src/services/api/codexShim.test.ts
+++ b/src/services/api/codexShim.test.ts
@@ -144,6 +144,42 @@ describe('Codex request translation', () => {
     ])
   })
 
+  test('removes unsupported uri format from strict Responses schemas', () => {
+    const tools = convertToolsToResponsesTools([
+      {
+        name: 'WebFetch',
+        description: 'Fetch a URL',
+        input_schema: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', format: 'uri' },
+            prompt: { type: 'string' },
+          },
+          required: ['url', 'prompt'],
+          additionalProperties: false,
+        },
+      },
+    ])
+
+    expect(tools).toEqual([
+      {
+        type: 'function',
+        name: 'WebFetch',
+        description: 'Fetch a URL',
+        parameters: {
+          type: 'object',
+          properties: {
+            url: { type: 'string' },
+            prompt: { type: 'string' },
+          },
+          required: ['url', 'prompt'],
+          additionalProperties: false,
+        },
+        strict: true,
+      },
+    ])
+  })
+
   test('converts assistant tool use and user tool result into Responses items', () => {
     const items = convertAnthropicMessagesToResponsesInput([
       {
diff --git a/src/services/api/codexShim.ts b/src/services/api/codexShim.ts
index c65abdf0..d6519b06 100644
--- a/src/services/api/codexShim.ts
+++ b/src/services/api/codexShim.ts
@@ -1,3 +1,4 @@
+import { APIError } from '@anthropic-ai/sdk'
 import type {
   ResolvedCodexCredentials,
   ResolvedProviderRequest,
@@ -234,7 +235,10 @@ export function convertAnthropicMessagesToResponsesInput(
           items.push({
             type: 'function_call_output',
             call_id: callId,
-            output: convertToolResultToText(toolResult.content),
+            output: (() => {
+              const out = convertToolResultToText(toolResult.content)
+              return toolResult.is_error ? `Error: ${out}` : out
+            })(),
           })
         }
 
@@ -311,6 +315,11 @@ function enforceStrictSchema(schema: unknown): Record<string, unknown> {
   // Codex API strict schemas reject these JSON schema keywords
   delete record.$schema
   delete record.propertyNames
+  // Codex Responses rejects JSON Schema's standard `uri` string format.
+  // Keep URL validation in the tool layer and send a plain string here.
+  if (record.format === 'uri') {
+    delete record.format
+  }
 
   if (record.type === 'object') {
     // OpenAI structured outputs completely forbid dynamic additionalProperties.
@@ -453,6 +462,7 @@ function convertToolChoice(toolChoice: unknown): unknown {
   if (!choice?.type) return undefined
   if (choice.type === 'auto') return 'auto'
   if (choice.type === 'any') return 'required'
+  if (choice.type === 'none') return 'none'
   if (choice.type === 'tool' && choice.name) {
     return {
       type: 'function',
@@ -553,7 +563,13 @@ export async function performCodexRequest(options: {
 
   if (!response.ok) {
     const errorBody = await response.text().catch(() => 'unknown error')
-    throw new Error(`Codex API error ${response.status}: ${errorBody}`)
+    let errorResponse: object | undefined
+    try { errorResponse = JSON.parse(errorBody) } catch { /* raw text */ }
+    throw APIError.generate(
+      response.status, errorResponse,
+      `Codex API error ${response.status}: ${errorBody}`,
+      response.headers as unknown as Record<string, string>,
+    )
   }
 
   return response
@@ -633,11 +649,9 @@ export async function collectCodexCompletedResponse(
 
   for await (const event of readSseEvents(response)) {
     if (event.event === 'response.failed') {
-      throw new Error(
-        event.data?.response?.error?.message ??
-          event.data?.error?.message ??
-          'Codex response failed',
-      )
+      const msg = event.data?.response?.error?.message ??
+        event.data?.error?.message ?? 'Codex response failed'
+      throw APIError.generate(500, undefined, msg, {} as Record<string, string>)
     }
 
     if (
@@ -650,7 +664,10 @@ export async function collectCodexCompletedResponse(
   }
 
   if (!completedResponse) {
-    throw new Error('Codex response ended without a completed payload')
+    throw APIError.generate(
+      500, undefined, 'Codex response ended without a completed payload',
+      {} as Record<string, string>,
+    )
   }
 
   return completedResponse
@@ -806,11 +823,9 @@ export async function* codexStreamToAnthropic(
     }
 
     if (event.event === 'response.failed') {
-      throw new Error(
-        payload?.response?.error?.message ??
-          payload?.error?.message ??
-          'Codex response failed',
-      )
+      const msg = payload?.response?.error?.message ??
+        payload?.error?.message ?? 'Codex response failed'
+      throw APIError.generate(500, undefined, msg, {} as Record<string, string>)
     }
   }
 
diff --git a/src/services/api/openaiShim.ts b/src/services/api/openaiShim.ts
index 2f06d312..1863ad88 100644
--- a/src/services/api/openaiShim.ts
+++ b/src/services/api/openaiShim.ts
@@ -14,8 +14,16 @@
  *   OPENAI_BASE_URL=http://...        — base URL (default: https://api.openai.com/v1)
  *   OPENAI_MODEL=gpt-4o              — default model override
  *   CODEX_API_KEY / ~/.codex/auth.json — Codex auth for codexplan/codexspark
+ *
+ * GitHub Models (models.github.ai), OpenAI-compatible:
+ *   CLAUDE_CODE_USE_GITHUB=1         — enable GitHub inference (no need for USE_OPENAI)
+ *   GITHUB_TOKEN or GH_TOKEN         — PAT with models access (mapped to Bearer auth)
+ *   OPENAI_MODEL                     — optional; use github:copilot or openai/gpt-4.1 style IDs
  */
 
+import { APIError } from '@anthropic-ai/sdk'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { hydrateGithubModelsTokenFromSecureStorage } from '../../utils/githubModelsCredentials.js'
 import {
   codexStreamToAnthropic,
   collectCodexCompletedResponse,
@@ -26,10 +34,31 @@ import {
   type ShimCreateParams,
 } from './codexShim.js'
 import {
+  isLocalProviderUrl,
   resolveCodexApiCredentials,
   resolveProviderRequest,
 } from './providerConfig.js'
 import { stripIncompatibleSchemaKeywords } from '../../utils/schemaSanitizer.js'
+import { redactSecretValueForDisplay } from '../../utils/providerProfile.js'
+
+const GITHUB_MODELS_DEFAULT_BASE = 'https://models.github.ai/inference'
+const GITHUB_API_VERSION = '2022-11-28'
+const GITHUB_429_MAX_RETRIES = 3
+const GITHUB_429_BASE_DELAY_SEC = 1
+const GITHUB_429_MAX_DELAY_SEC = 32
+
+function isGithubModelsMode(): boolean {
+  return isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+}
+
+function formatRetryAfterHint(response: Response): string {
+  const ra = response.headers.get('retry-after')
+  return ra ? ` (Retry-After: ${ra})` : ''
+}
+
+function sleepMs(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
 
 // ---------------------------------------------------------------------------
 // Types — minimal subset of Anthropic SDK types we need to produce
@@ -188,7 +217,10 @@ function convertMessages(
 
         const assistantMsg: OpenAIMessage = {
           role: 'assistant',
-          content: convertContentBlocks(textContent) as string,
+          content: (() => {
+            const c = convertContentBlocks(textContent)
+            return typeof c === 'string' ? c : Array.isArray(c) ? c.map((p: { text?: string }) => p.text ?? '').join('') : ''
+          })(),
         }
 
         if (toolUses.length > 0) {
@@ -217,7 +249,10 @@ function convertMessages(
       } else {
         result.push({
           role: 'assistant',
-          content: convertContentBlocks(content) as string,
+          content: (() => {
+            const c = convertContentBlocks(content)
+            return typeof c === 'string' ? c : Array.isArray(c) ? c.map((p: { text?: string }) => p.text ?? '').join('') : ''
+          })(),
         })
       }
     }
@@ -296,9 +331,7 @@ function normalizeSchemaForOpenAI(
 function convertTools(
   tools: Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>,
 ): OpenAITool[] {
-  const isGemini =
-    process.env.CLAUDE_CODE_USE_GEMINI === '1' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === 'true'
+  const isGemini = isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
 
   return tools
     .filter(t => t.name !== 'ToolSearchTool') // Not relevant for OpenAI
@@ -595,7 +628,8 @@ async function* openaiStreamToAnthropic(
       if (
         !hasEmittedFinalUsage &&
         chunkUsage &&
-        (chunk.choices?.length ?? 0) === 0
+        (chunk.choices?.length ?? 0) === 0 &&
+        lastStopReason !== null
       ) {
         yield {
           type: 'message_delta',
@@ -633,9 +667,11 @@ class OpenAIShimStream {
 
 class OpenAIShimMessages {
   private defaultHeaders: Record<string, string>
+  private reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh'
 
-  constructor(defaultHeaders: Record<string, string>) {
+  constructor(defaultHeaders: Record<string, string>, reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh') {
     this.defaultHeaders = defaultHeaders
+    this.reasoningEffort = reasoningEffort
   }
 
   create(
@@ -644,9 +680,12 @@ class OpenAIShimMessages {
   ) {
     const self = this
 
+    let httpResponse: Response | undefined
+
     const promise = (async () => {
-      const request = resolveProviderRequest({ model: params.model })
+      const request = resolveProviderRequest({ model: params.model, reasoningEffortOverride: self.reasoningEffort })
       const response = await self._doRequest(request, params, options)
+      httpResponse = response
 
       if (params.stream) {
         return new OpenAIShimStream(
@@ -673,8 +712,9 @@ class OpenAIShimMessages {
           const data = await promise
           return {
             data,
-            response: new Response(),
-            request_id: makeMessageId(),
+            response: httpResponse ?? new Response(),
+            request_id:
+              httpResponse?.headers.get('x-request-id') ?? makeMessageId(),
           }
         }
 
@@ -692,8 +732,11 @@ class OpenAIShimMessages {
         const authHint = credentials.authPath
           ? ` or place a Codex auth.json at ${credentials.authPath}`
           : ''
+        const safeModel =
+          redactSecretValueForDisplay(request.requestedModel, process.env) ??
+          'the requested model'
         throw new Error(
-          `Codex auth is required for ${request.requestedModel}. Set CODEX_API_KEY${authHint}.`,
+          `Codex auth is required for ${safeModel}. Set CODEX_API_KEY${authHint}.`,
         )
       }
       if (!credentials.accountId) {
@@ -752,10 +795,16 @@ class OpenAIShimMessages {
       body.max_completion_tokens = maxCompletionTokensValue
     }
 
-    if (params.stream) {
+    if (params.stream && !isLocalProviderUrl(request.baseUrl)) {
       body.stream_options = { include_usage: true }
     }
 
+    const isGithub = isGithubModelsMode()
+    if (isGithub && body.max_completion_tokens !== undefined) {
+      body.max_tokens = body.max_completion_tokens
+      delete body.max_completion_tokens
+    }
+
     if (params.temperature !== undefined) body.temperature = params.temperature
     if (params.top_p !== undefined) body.top_p = params.top_p
 
@@ -805,6 +854,11 @@ class OpenAIShimMessages {
       }
     }
 
+    if (isGithub) {
+      headers.Accept = 'application/vnd.github.v3+json'
+      headers['X-GitHub-Api-Version'] = GITHUB_API_VERSION
+    }
+
     // Build the chat completions URL
     // Azure Cognitive Services / Azure OpenAI require a deployment-specific path
     // and an api-version query parameter.
@@ -827,19 +881,50 @@ class OpenAIShimMessages {
       chatCompletionsUrl = `${request.baseUrl}/chat/completions`
     }
 
-    const response = await fetch(chatCompletionsUrl, {
-      method: 'POST',
+    const fetchInit = {
+      method: 'POST' as const,
       headers,
       body: JSON.stringify(body),
       signal: options?.signal,
-    })
-
-    if (!response.ok) {
-      const errorBody = await response.text().catch(() => 'unknown error')
-      throw new Error(`OpenAI API error ${response.status}: ${errorBody}`)
     }
 
-    return response
+    const maxAttempts = isGithub ? GITHUB_429_MAX_RETRIES : 1
+    let response: Response | undefined
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      response = await fetch(chatCompletionsUrl, fetchInit)
+      if (response.ok) {
+        return response
+      }
+      if (
+        isGithub &&
+        response.status === 429 &&
+        attempt < maxAttempts - 1
+      ) {
+        await response.text().catch(() => {})
+        const delaySec = Math.min(
+          GITHUB_429_BASE_DELAY_SEC * 2 ** attempt,
+          GITHUB_429_MAX_DELAY_SEC,
+        )
+        await sleepMs(delaySec * 1000)
+        continue
+      }
+      const errorBody = await response.text().catch(() => 'unknown error')
+      const rateHint =
+        isGithub && response.status === 429 ? formatRetryAfterHint(response) : ''
+      let errorResponse: object | undefined
+      try { errorResponse = JSON.parse(errorBody) } catch { /* raw text */ }
+      throw APIError.generate(
+        response.status,
+        errorResponse,
+        `OpenAI API error ${response.status}: ${errorBody}${rateHint}`,
+        response.headers as unknown as Record<string, string>,
+      )
+    }
+
+    throw APIError.generate(
+      500, undefined, 'OpenAI shim: request loop exited unexpectedly',
+      {} as Record<string, string>,
+    )
   }
 
   private _convertNonStreamingResponse(
@@ -849,7 +934,10 @@ class OpenAIShimMessages {
       choices?: Array<{
         message?: {
           role?: string
-          content?: string | null
+          content?:
+            | string
+            | null
+            | Array<{ type?: string; text?: string }>
           tool_calls?: Array<{
             id: string
             function: { name: string; arguments: string }
@@ -868,8 +956,25 @@ class OpenAIShimMessages {
     const choice = data.choices?.[0]
     const content: Array<Record<string, unknown>> = []
 
-    if (choice?.message?.content) {
-      content.push({ type: 'text', text: choice.message.content })
+    const rawContent = choice?.message?.content
+    if (typeof rawContent === 'string' && rawContent) {
+      content.push({ type: 'text', text: rawContent })
+    } else if (Array.isArray(rawContent) && rawContent.length > 0) {
+      const parts: string[] = []
+      for (const part of rawContent) {
+        if (
+          part &&
+          typeof part === 'object' &&
+          part.type === 'text' &&
+          typeof part.text === 'string'
+        ) {
+          parts.push(part.text)
+        }
+      }
+      const joined = parts.join('\n')
+      if (joined) {
+        content.push({ type: 'text', text: joined })
+      }
     }
 
     if (choice?.message?.tool_calls) {
@@ -917,9 +1022,11 @@ class OpenAIShimMessages {
 
 class OpenAIShimBeta {
   messages: OpenAIShimMessages
+  reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh'
 
-  constructor(defaultHeaders: Record<string, string>) {
-    this.messages = new OpenAIShimMessages(defaultHeaders)
+  constructor(defaultHeaders: Record<string, string>, reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh') {
+    this.messages = new OpenAIShimMessages(defaultHeaders, reasoningEffort)
+    this.reasoningEffort = reasoningEffort
   }
 }
 
@@ -927,13 +1034,13 @@ export function createOpenAIShimClient(options: {
   defaultHeaders?: Record<string, string>
   maxRetries?: number
   timeout?: number
+  reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh'
 }): unknown {
+  hydrateGithubModelsTokenFromSecureStorage()
+
   // When Gemini provider is active, map Gemini env vars to OpenAI-compatible ones
   // so the existing providerConfig.ts infrastructure picks them up correctly.
-  if (
-    process.env.CLAUDE_CODE_USE_GEMINI === '1' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === 'true'
-  ) {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)) {
     process.env.OPENAI_BASE_URL ??=
       process.env.GEMINI_BASE_URL ??
       'https://generativelanguage.googleapis.com/v1beta/openai'
@@ -942,11 +1049,15 @@ export function createOpenAIShimClient(options: {
     if (process.env.GEMINI_MODEL && !process.env.OPENAI_MODEL) {
       process.env.OPENAI_MODEL = process.env.GEMINI_MODEL
     }
+  } else if (isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)) {
+    process.env.OPENAI_BASE_URL ??= GITHUB_MODELS_DEFAULT_BASE
+    process.env.OPENAI_API_KEY ??=
+      process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? ''
   }
 
   const beta = new OpenAIShimBeta({
     ...(options.defaultHeaders ?? {}),
-  })
+  }, options.reasoningEffort)
 
   return {
     beta,
diff --git a/src/services/api/providerConfig.github.test.ts b/src/services/api/providerConfig.github.test.ts
new file mode 100644
index 00000000..6177a9c6
--- /dev/null
+++ b/src/services/api/providerConfig.github.test.ts
@@ -0,0 +1,41 @@
+import { afterEach, expect, test } from 'bun:test'
+
+import {
+  DEFAULT_GITHUB_MODELS_API_MODEL,
+  normalizeGithubModelsApiModel,
+  resolveProviderRequest,
+} from './providerConfig.js'
+
+const originalUseGithub = process.env.CLAUDE_CODE_USE_GITHUB
+
+afterEach(() => {
+  if (originalUseGithub === undefined) {
+    delete process.env.CLAUDE_CODE_USE_GITHUB
+  } else {
+    process.env.CLAUDE_CODE_USE_GITHUB = originalUseGithub
+  }
+})
+
+test.each([
+  ['copilot', DEFAULT_GITHUB_MODELS_API_MODEL],
+  ['github:copilot', DEFAULT_GITHUB_MODELS_API_MODEL],
+  ['', DEFAULT_GITHUB_MODELS_API_MODEL],
+  ['github:gpt-4o', 'gpt-4o'],
+  ['gpt-4o', 'gpt-4o'],
+  ['github:copilot?reasoning=high', DEFAULT_GITHUB_MODELS_API_MODEL],
+] as const)('normalizeGithubModelsApiModel(%s) -> %s', (input, expected) => {
+  expect(normalizeGithubModelsApiModel(input)).toBe(expected)
+})
+
+test('resolveProviderRequest applies GitHub normalization when CLAUDE_CODE_USE_GITHUB=1', () => {
+  process.env.CLAUDE_CODE_USE_GITHUB = '1'
+  const r = resolveProviderRequest({ model: 'github:gpt-4o' })
+  expect(r.resolvedModel).toBe('gpt-4o')
+  expect(r.transport).toBe('chat_completions')
+})
+
+test('resolveProviderRequest leaves model unchanged without GitHub flag', () => {
+  delete process.env.CLAUDE_CODE_USE_GITHUB
+  const r = resolveProviderRequest({ model: 'github:gpt-4o' })
+  expect(r.resolvedModel).toBe('github:gpt-4o')
+})
diff --git a/src/services/api/providerConfig.ts b/src/services/api/providerConfig.ts
index b197d785..1c3097db 100644
--- a/src/services/api/providerConfig.ts
+++ b/src/services/api/providerConfig.ts
@@ -2,8 +2,12 @@ import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
 export const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1'
 export const DEFAULT_CODEX_BASE_URL = 'https://chatgpt.com/backend-api/codex'
+/** Default GitHub Models API model when user selects copilot / github:copilot */
+export const DEFAULT_GITHUB_MODELS_API_MODEL = 'openai/gpt-4.1'
 
 const CODEX_ALIAS_MODELS: Record<
   string,
@@ -16,13 +20,43 @@ const CODEX_ALIAS_MODELS: Record<
     model: 'gpt-5.4',
     reasoningEffort: 'high',
   },
+  'gpt-5.4': {
+    model: 'gpt-5.4',
+    reasoningEffort: 'high',
+  },
+  'gpt-5.3-codex': {
+    model: 'gpt-5.3-codex',
+    reasoningEffort: 'high',
+  },
+  'gpt-5.3-codex-spark': {
+    model: 'gpt-5.3-codex-spark',
+  },
   codexspark: {
     model: 'gpt-5.3-codex-spark',
   },
+  'gpt-5.2-codex': {
+    model: 'gpt-5.2-codex',
+    reasoningEffort: 'high',
+  },
+  'gpt-5.1-codex-max': {
+    model: 'gpt-5.1-codex-max',
+    reasoningEffort: 'high',
+  },
+  'gpt-5.1-codex-mini': {
+    model: 'gpt-5.1-codex-mini',
+  },
+  'gpt-5.4-mini': {
+    model: 'gpt-5.4-mini',
+    reasoningEffort: 'medium',
+  },
+  'gpt-5.2': {
+    model: 'gpt-5.2',
+    reasoningEffort: 'medium',
+  },
 } as const
 
 type CodexAlias = keyof typeof CODEX_ALIAS_MODELS
-type ReasoningEffort = 'low' | 'medium' | 'high'
+type ReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh'
 
 export type ProviderTransport = 'chat_completions' | 'codex_responses'
 
@@ -98,7 +132,7 @@ function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
 function parseReasoningEffort(value: string | undefined): ReasoningEffort | undefined {
   if (!value) return undefined
   const normalized = value.trim().toLowerCase()
-  if (normalized === 'low' || normalized === 'medium' || normalized === 'high') {
+  if (normalized === 'low' || normalized === 'medium' || normalized === 'high' || normalized === 'xhigh') {
     return normalized
   }
   return undefined
@@ -171,16 +205,32 @@ export function isCodexBaseUrl(baseUrl: string | undefined): boolean {
   }
 }
 
+/**
+ * Normalize user model string for GitHub Models inference (models.github.ai).
+ * Mirrors runtime devsper `github._normalize_model_id`.
+ */
+export function normalizeGithubModelsApiModel(requestedModel: string): string {
+  const noQuery = requestedModel.split('?', 1)[0] ?? requestedModel
+  const segment =
+    noQuery.includes(':') ? noQuery.split(':', 2)[1]!.trim() : noQuery.trim()
+  if (!segment || segment.toLowerCase() === 'copilot') {
+    return DEFAULT_GITHUB_MODELS_API_MODEL
+  }
+  return segment
+}
+
 export function resolveProviderRequest(options?: {
   model?: string
   baseUrl?: string
   fallbackModel?: string
+  reasoningEffortOverride?: ReasoningEffort
 }): ResolvedProviderRequest {
+  const isGithubMode = isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
   const requestedModel =
     options?.model?.trim() ||
     process.env.OPENAI_MODEL?.trim() ||
     options?.fallbackModel?.trim() ||
-    'gpt-4o'
+    (isGithubMode ? 'github:copilot' : 'gpt-4o')
   const descriptor = parseModelDescriptor(requestedModel)
   const rawBaseUrl =
     options?.baseUrl ??
@@ -192,17 +242,28 @@ export function resolveProviderRequest(options?: {
       ? 'codex_responses'
       : 'chat_completions'
 
+  const resolvedModel =
+    transport === 'chat_completions' &&
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+      ? normalizeGithubModelsApiModel(requestedModel)
+      : descriptor.baseModel
+
+  const reasoning = options?.reasoningEffortOverride
+    ? { effort: options.reasoningEffortOverride }
+    : descriptor.reasoning
+
+
   return {
     transport,
     requestedModel,
-    resolvedModel: descriptor.baseModel,
+    resolvedModel,
     baseUrl:
       (rawBaseUrl ??
         (transport === 'codex_responses'
           ? DEFAULT_CODEX_BASE_URL
           : DEFAULT_OPENAI_BASE_URL)
       ).replace(/\/+$/, ''),
-    reasoning: descriptor.reasoning,
+    reasoning,
   }
 }
 
@@ -311,3 +372,11 @@ export function resolveCodexApiCredentials(
     source: 'auth.json',
   }
 }
+
+export function getReasoningEffortForModel(model: string): ReasoningEffort | undefined {
+  const normalized = model.trim().toLowerCase()
+  const base = normalized.split('?', 1)[0] ?? normalized
+  const alias = base as CodexAlias
+  const aliasConfig = CODEX_ALIAS_MODELS[alias]
+  return aliasConfig?.reasoningEffort
+}
diff --git a/src/services/github/deviceFlow.test.ts b/src/services/github/deviceFlow.test.ts
new file mode 100644
index 00000000..4b7ce584
--- /dev/null
+++ b/src/services/github/deviceFlow.test.ts
@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+import {
+  GitHubDeviceFlowError,
+  pollAccessToken,
+  requestDeviceCode,
+} from './deviceFlow.js'
+
+describe('requestDeviceCode', () => {
+  const originalFetch = globalThis.fetch
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  test('parses successful device code response', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            device_code: 'abc',
+            user_code: 'ABCD-1234',
+            verification_uri: 'https://github.com/login/device',
+            expires_in: 600,
+            interval: 5,
+          }),
+          { status: 200 },
+        ),
+      ),
+    )
+
+    const r = await requestDeviceCode({
+      clientId: 'test-client',
+      fetchImpl: globalThis.fetch,
+    })
+    expect(r.device_code).toBe('abc')
+    expect(r.user_code).toBe('ABCD-1234')
+    expect(r.verification_uri).toBe('https://github.com/login/device')
+    expect(r.expires_in).toBe(600)
+    expect(r.interval).toBe(5)
+  })
+
+  test('throws on HTTP error', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('bad', { status: 500 })),
+    )
+    await expect(
+      requestDeviceCode({ clientId: 'x', fetchImpl: globalThis.fetch }),
+    ).rejects.toThrow(GitHubDeviceFlowError)
+  })
+})
+
+describe('pollAccessToken', () => {
+  const originalFetch = globalThis.fetch
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  test('returns token when GitHub responds with access_token immediately', async () => {
+    let calls = 0
+    globalThis.fetch = mock(() => {
+      calls++
+      return Promise.resolve(
+        new Response(JSON.stringify({ access_token: 'tok-xyz' }), {
+          status: 200,
+        }),
+      )
+    })
+
+    const token = await pollAccessToken('dev-code', {
+      clientId: 'cid',
+      fetchImpl: globalThis.fetch,
+    })
+    expect(token).toBe('tok-xyz')
+    expect(calls).toBe(1)
+  })
+
+  test('throws on access_denied', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ error: 'access_denied' }), {
+          status: 200,
+        }),
+      ),
+    )
+    await expect(
+      pollAccessToken('dc', {
+        clientId: 'c',
+        fetchImpl: globalThis.fetch,
+      }),
+    ).rejects.toThrow(/denied/)
+  })
+})
diff --git a/src/services/github/deviceFlow.ts b/src/services/github/deviceFlow.ts
new file mode 100644
index 00000000..379d757e
--- /dev/null
+++ b/src/services/github/deviceFlow.ts
@@ -0,0 +1,174 @@
+/**
+ * GitHub OAuth device flow for CLI login (https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps#device-flow).
+ */
+
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js'
+
+export const DEFAULT_GITHUB_DEVICE_FLOW_CLIENT_ID = 'Ov23liXjWSSui6QIahPl'
+
+export const GITHUB_DEVICE_CODE_URL = 'https://github.com/login/device/code'
+export const GITHUB_DEVICE_ACCESS_TOKEN_URL =
+  'https://github.com/login/oauth/access_token'
+
+/** Match runtime devsper github_oauth DEFAULT_SCOPE */
+export const DEFAULT_GITHUB_DEVICE_SCOPE = 'read:user,models:read'
+
+export class GitHubDeviceFlowError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'GitHubDeviceFlowError'
+  }
+}
+
+export type DeviceCodeResult = {
+  device_code: string
+  user_code: string
+  verification_uri: string
+  expires_in: number
+  interval: number
+}
+
+export function getGithubDeviceFlowClientId(): string {
+  return (
+    process.env.GITHUB_DEVICE_FLOW_CLIENT_ID?.trim() ||
+    DEFAULT_GITHUB_DEVICE_FLOW_CLIENT_ID
+  )
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export async function requestDeviceCode(options?: {
+  clientId?: string
+  scope?: string
+  fetchImpl?: typeof fetch
+}): Promise<DeviceCodeResult> {
+  const clientId = options?.clientId ?? getGithubDeviceFlowClientId()
+  if (!clientId) {
+    throw new GitHubDeviceFlowError(
+      'No OAuth client ID: set GITHUB_DEVICE_FLOW_CLIENT_ID or paste a PAT instead.',
+    )
+  }
+  const fetchFn = options?.fetchImpl ?? fetch
+  const res = await fetchFn(GITHUB_DEVICE_CODE_URL, {
+    method: 'POST',
+    headers: { Accept: 'application/json' },
+    body: new URLSearchParams({
+      client_id: clientId,
+      scope: options?.scope ?? DEFAULT_GITHUB_DEVICE_SCOPE,
+    }),
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new GitHubDeviceFlowError(
+      `Device code request failed: ${res.status} ${text}`,
+    )
+  }
+  const data = (await res.json()) as Record<string, unknown>
+  const device_code = data.device_code
+  const user_code = data.user_code
+  const verification_uri = data.verification_uri
+  if (
+    typeof device_code !== 'string' ||
+    typeof user_code !== 'string' ||
+    typeof verification_uri !== 'string'
+  ) {
+    throw new GitHubDeviceFlowError('Malformed device code response from GitHub')
+  }
+  return {
+    device_code,
+    user_code,
+    verification_uri,
+    expires_in: typeof data.expires_in === 'number' ? data.expires_in : 900,
+    interval: typeof data.interval === 'number' ? data.interval : 5,
+  }
+}
+
+export type PollOptions = {
+  clientId?: string
+  initialInterval?: number
+  timeoutSeconds?: number
+  fetchImpl?: typeof fetch
+}
+
+export async function pollAccessToken(
+  deviceCode: string,
+  options?: PollOptions,
+): Promise<string> {
+  const clientId = options?.clientId ?? getGithubDeviceFlowClientId()
+  if (!clientId) {
+    throw new GitHubDeviceFlowError('client_id required for polling')
+  }
+  let interval = Math.max(1, options?.initialInterval ?? 5)
+  const timeoutSeconds = options?.timeoutSeconds ?? 900
+  const fetchFn = options?.fetchImpl ?? fetch
+  const start = Date.now()
+
+  while ((Date.now() - start) / 1000 < timeoutSeconds) {
+    const res = await fetchFn(GITHUB_DEVICE_ACCESS_TOKEN_URL, {
+      method: 'POST',
+      headers: { Accept: 'application/json' },
+      body: new URLSearchParams({
+        client_id: clientId,
+        device_code: deviceCode,
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      }),
+    })
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new GitHubDeviceFlowError(
+        `Token request failed: ${res.status} ${text}`,
+      )
+    }
+    const data = (await res.json()) as Record<string, unknown>
+    const err = data.error as string | undefined
+    if (err == null) {
+      const token = data.access_token
+      if (typeof token === 'string' && token) {
+        return token
+      }
+      throw new GitHubDeviceFlowError('No access_token in response')
+    }
+    if (err === 'authorization_pending') {
+      await sleep(interval * 1000)
+      continue
+    }
+    if (err === 'slow_down') {
+      interval =
+        typeof data.interval === 'number' ? data.interval : interval + 5
+      await sleep(interval * 1000)
+      continue
+    }
+    if (err === 'expired_token') {
+      throw new GitHubDeviceFlowError(
+        'Device code expired. Start the login flow again.',
+      )
+    }
+    if (err === 'access_denied') {
+      throw new GitHubDeviceFlowError('Authorization was denied or cancelled.')
+    }
+    throw new GitHubDeviceFlowError(`GitHub OAuth error: ${err}`)
+  }
+  throw new GitHubDeviceFlowError('Timed out waiting for authorization.')
+}
+
+/**
+ * Best-effort open browser / OS handler for the verification URL.
+ */
+export async function openVerificationUri(uri: string): Promise<void> {
+  try {
+    if (process.platform === 'darwin') {
+      await execFileNoThrow('open', [uri], { useCwd: false, timeout: 5000 })
+    } else if (process.platform === 'win32') {
+      await execFileNoThrow('cmd', ['/c', 'start', '', uri], {
+        useCwd: false,
+        timeout: 5000,
+      })
+    } else {
+      await execFileNoThrow('xdg-open', [uri], { useCwd: false, timeout: 5000 })
+    }
+  } catch {
+    // User can open the URL manually
+  }
+}
diff --git a/src/services/mcp/client.test.ts b/src/services/mcp/client.test.ts
new file mode 100644
index 00000000..6f69ee7b
--- /dev/null
+++ b/src/services/mcp/client.test.ts
@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { cleanupFailedConnection } from './client.js'
+
+test('cleanupFailedConnection awaits transport close before resolving', async () => {
+  let closed = false
+  let resolveClose: (() => void) | undefined
+
+  const transport = {
+    close: async () =>
+      await new Promise<void>(resolve => {
+        resolveClose = () => {
+          closed = true
+          resolve()
+        }
+      }),
+  }
+
+  const cleanupPromise = cleanupFailedConnection(transport)
+
+  assert.equal(closed, false)
+  resolveClose?.()
+  await cleanupPromise
+  assert.equal(closed, true)
+})
+
+test('cleanupFailedConnection closes in-process server and transport', async () => {
+  let inProcessClosed = false
+  let transportClosed = false
+
+  const inProcessServer = {
+    close: async () => {
+      inProcessClosed = true
+    },
+  }
+
+  const transport = {
+    close: async () => {
+      transportClosed = true
+    },
+  }
+
+  await cleanupFailedConnection(transport, inProcessServer)
+
+  assert.equal(inProcessClosed, true)
+  assert.equal(transportClosed, true)
+})
diff --git a/src/services/mcp/client.ts b/src/services/mcp/client.ts
index b053dbb6..8857b56c 100644
--- a/src/services/mcp/client.ts
+++ b/src/services/mcp/client.ts
@@ -560,6 +560,22 @@ function getRemoteMcpServerConnectionBatchSize(): number {
   )
 }
 
+type InProcessMcpServer = {
+  connect(t: Transport): Promise<void>
+  close(): Promise<void>
+}
+
+export async function cleanupFailedConnection(
+  transport: Pick<Transport, 'close'>,
+  inProcessServer?: Pick<InProcessMcpServer, 'close'>,
+): Promise<void> {
+  if (inProcessServer) {
+    await inProcessServer.close().catch(() => {})
+  }
+
+  await transport.close().catch(() => {})
+}
+
 function isLocalMcpServer(config: ScopedMcpServerConfig): boolean {
   return !config.type || config.type === 'stdio' || config.type === 'sdk'
 }
@@ -606,9 +622,7 @@ export const connectToServer = memoize(
     },
   ): Promise<MCPServerConnection> => {
     const connectStartTime = Date.now()
-    let inProcessServer:
-      | { connect(t: Transport): Promise<void>; close(): Promise<void> }
-      | undefined
+    let inProcessServer: InProcessMcpServer | undefined
     try {
       let transport
 
@@ -1145,9 +1159,10 @@ export const connectToServer = memoize(
           })
         }
         if (inProcessServer) {
-          inProcessServer.close().catch(() => { })
+          await cleanupFailedConnection(transport, inProcessServer)
+        } else {
+          await cleanupFailedConnection(transport)
         }
-        transport.close().catch(() => { })
         if (stderrOutput) {
           logMCPError(name, `Server stderr: ${stderrOutput}`)
         }
diff --git a/src/services/mcp/doctor.test.ts b/src/services/mcp/doctor.test.ts
new file mode 100644
index 00000000..83b74d3f
--- /dev/null
+++ b/src/services/mcp/doctor.test.ts
@@ -0,0 +1,540 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { ValidationError } from '../../utils/settings/validation.js'
+
+import {
+  buildEmptyDoctorReport,
+  doctorAllServers,
+  doctorServer,
+  findingsFromValidationErrors,
+  type McpDoctorDependencies,
+} from './doctor.js'
+
+function stdioConfig(scope: 'local' | 'project' | 'user' | 'enterprise', command: string) {
+  return {
+    type: 'stdio' as const,
+    command,
+    args: [],
+    scope,
+  }
+}
+
+function makeDependencies(overrides: Partial<McpDoctorDependencies> = {}): McpDoctorDependencies {
+  return {
+    getAllMcpConfigs: async () => ({ servers: {}, errors: [] }),
+    getMcpConfigsByScope: () => ({ servers: {}, errors: [] }),
+    getProjectMcpServerStatus: () => 'approved',
+    isMcpServerDisabled: () => false,
+    describeMcpConfigFilePath: scope => `scope://${scope}`,
+    clearServerCache: async () => {},
+    connectToServer: async (name, config) => ({
+      name,
+      type: 'connected',
+      capabilities: {},
+      config,
+      cleanup: async () => {},
+    }),
+    ...overrides,
+  }
+}
+
+test('buildEmptyDoctorReport returns zeroed summary', () => {
+  const report = buildEmptyDoctorReport({
+    configOnly: true,
+    scopeFilter: 'project',
+    targetName: 'filesystem',
+  })
+
+  assert.equal(report.targetName, 'filesystem')
+  assert.equal(report.scopeFilter, 'project')
+  assert.equal(report.configOnly, true)
+  assert.deepEqual(report.summary, {
+    totalReports: 0,
+    healthy: 0,
+    warnings: 0,
+    blocking: 0,
+  })
+  assert.deepEqual(report.findings, [])
+  assert.deepEqual(report.servers, [])
+})
+
+test('findingsFromValidationErrors maps missing env warnings into doctor findings', () => {
+  const validationErrors: ValidationError[] = [
+    {
+      file: '.mcp.json',
+      path: 'mcpServers.filesystem',
+      message: 'Missing environment variables: API_KEY, API_URL',
+      suggestion: 'Set the following environment variables: API_KEY, API_URL',
+      mcpErrorMetadata: {
+        scope: 'project',
+        serverName: 'filesystem',
+        severity: 'warning',
+      },
+    },
+  ]
+
+  const findings = findingsFromValidationErrors(validationErrors)
+
+  assert.equal(findings.length, 1)
+  assert.deepEqual(findings[0], {
+    blocking: false,
+    code: 'config.missing_env_vars',
+    message: 'Missing environment variables: API_KEY, API_URL',
+    remediation: 'Set the following environment variables: API_KEY, API_URL',
+    scope: 'project',
+    serverName: 'filesystem',
+    severity: 'warn',
+    sourcePath: '.mcp.json',
+  })
+})
+
+test('findingsFromValidationErrors maps Windows npx warnings into doctor findings', () => {
+  const validationErrors: ValidationError[] = [
+    {
+      file: '.mcp.json',
+      path: 'mcpServers.node-tools',
+      message: "Windows requires 'cmd /c' wrapper to execute npx",
+      suggestion:
+        'Change command to "cmd" with args ["/c", "npx", ...]. See: https://code.claude.com/docs/en/mcp#configure-mcp-servers',
+      mcpErrorMetadata: {
+        scope: 'project',
+        serverName: 'node-tools',
+        severity: 'warning',
+      },
+    },
+  ]
+
+  const findings = findingsFromValidationErrors(validationErrors)
+
+  assert.equal(findings.length, 1)
+  assert.equal(findings[0]?.code, 'config.windows_npx_wrapper_required')
+  assert.equal(findings[0]?.serverName, 'node-tools')
+  assert.equal(findings[0]?.severity, 'warn')
+  assert.equal(findings[0]?.blocking, false)
+})
+
+test('findingsFromValidationErrors maps fatal parse errors into blocking findings', () => {
+  const validationErrors: ValidationError[] = [
+    {
+      file: 'C:/repo/.mcp.json',
+      path: '',
+      message: 'MCP config is not a valid JSON',
+      suggestion: 'Fix the JSON syntax errors in the file',
+      mcpErrorMetadata: {
+        scope: 'project',
+        severity: 'fatal',
+      },
+    },
+  ]
+
+  const findings = findingsFromValidationErrors(validationErrors)
+
+  assert.equal(findings.length, 1)
+  assert.equal(findings[0]?.code, 'config.invalid_json')
+  assert.equal(findings[0]?.severity, 'error')
+  assert.equal(findings[0]?.blocking, true)
+})
+
+test('doctorAllServers reports global validation findings once without duplicating them into every server', async () => {
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { filesystem: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'project'
+        ? {
+            servers: {},
+            errors: [
+              {
+                file: '.mcp.json',
+                path: '',
+                message: 'MCP config is not a valid JSON',
+                suggestion: 'Fix the JSON syntax errors in the file',
+                mcpErrorMetadata: {
+                  scope: 'project',
+                  severity: 'fatal',
+                },
+              },
+            ],
+          }
+        : scope === 'local'
+          ? { servers: { filesystem: localConfig }, errors: [] }
+          : { servers: {}, errors: [] },
+  })
+
+  const report = await doctorAllServers({ configOnly: true }, deps)
+
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.summary.blocking, 1)
+  assert.equal(report.findings.length, 1)
+  assert.equal(report.findings[0]?.code, 'config.invalid_json')
+  assert.deepEqual(report.servers[0]?.findings, [])
+})
+
+test('doctorServer explains same-name shadowing across scopes', async () => {
+  const localConfig = stdioConfig('local', 'node-local')
+  const userConfig = stdioConfig('user', 'node-user')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: {
+        filesystem: localConfig,
+      },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope => {
+      switch (scope) {
+        case 'local':
+          return { servers: { filesystem: localConfig }, errors: [] }
+        case 'user':
+          return { servers: { filesystem: userConfig }, errors: [] }
+        default:
+          return { servers: {}, errors: [] }
+      }
+    },
+  })
+
+  const report = await doctorServer('filesystem', { configOnly: true }, deps)
+  assert.equal(report.servers.length, 1)
+  assert.equal(report.servers[0]?.definitions.length, 2)
+  assert.equal(report.servers[0]?.definitions.find(def => def.sourceType === 'local')?.runtimeActive, true)
+  assert.equal(report.servers[0]?.definitions.find(def => def.sourceType === 'user')?.runtimeActive, false)
+  assert.deepEqual(
+    report.servers[0]?.findings.map(finding => finding.code).sort(),
+    ['duplicate.same_name_multiple_scopes', 'scope.shadowed'],
+  )
+})
+
+test('doctorServer reports project servers pending approval', async () => {
+  const projectConfig = stdioConfig('project', 'node-project')
+  const deps = makeDependencies({
+    getMcpConfigsByScope: scope =>
+      scope === 'project'
+        ? { servers: { sentry: projectConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    getProjectMcpServerStatus: name => (name === 'sentry' ? 'pending' : 'approved'),
+  })
+
+  const report = await doctorServer('sentry', { configOnly: true }, deps)
+  assert.equal(report.servers.length, 1)
+  assert.equal(report.servers[0]?.definitions[0]?.pendingApproval, true)
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false)
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeVisible, false)
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'state.pending_project_approval'),
+    true,
+  )
+})
+
+test('doctorServer does not treat disabled servers as runtime-active or live-check targets', async () => {
+  let connectCalls = 0
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { github: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'local'
+        ? { servers: { github: localConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    isMcpServerDisabled: name => name === 'github',
+    connectToServer: async (name, config) => {
+      connectCalls += 1
+      return {
+        name,
+        type: 'failed',
+        config,
+        error: 'should not connect',
+      }
+    },
+  })
+
+  const report = await doctorServer('github', { configOnly: false }, deps)
+
+  assert.equal(connectCalls, 0)
+  assert.equal(report.summary.blocking, 0)
+  assert.equal(report.summary.warnings, 1)
+  assert.equal(report.servers[0]?.definitions[0]?.disabled, true)
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false)
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeVisible, false)
+  assert.equal(report.servers[0]?.liveCheck.result, 'disabled')
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'state.disabled' && finding.severity === 'warn'),
+    true,
+  )
+})
+
+test('doctorAllServers skips live checks in config-only mode', async () => {
+  let connectCalls = 0
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { linear: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'local'
+        ? { servers: { linear: localConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    connectToServer: async (name, config) => {
+      connectCalls += 1
+      return {
+        name,
+        type: 'connected',
+        capabilities: {},
+        config,
+        cleanup: async () => {},
+      }
+    },
+  })
+
+  const report = await doctorAllServers({ configOnly: true }, deps)
+  assert.equal(connectCalls, 0)
+  assert.equal(report.servers[0]?.liveCheck.attempted, false)
+  assert.equal(report.servers[0]?.liveCheck.result, 'skipped')
+})
+
+test('doctorAllServers honors scopeFilter when collecting names', async () => {
+  const pluginConfig = {
+    type: 'http' as const,
+    url: 'https://example.test/mcp',
+    scope: 'dynamic' as const,
+    pluginSource: 'plugin:github@official',
+  }
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { 'plugin:github:github': pluginConfig },
+      errors: [],
+    }),
+  })
+
+  const report = await doctorAllServers({ configOnly: true, scopeFilter: 'user' }, deps)
+
+  assert.equal(report.summary.totalReports, 0)
+  assert.deepEqual(report.servers, [])
+})
+
+test('doctorAllServers honors scopeFilter when collecting validation errors', async () => {
+  const userConfig = stdioConfig('user', 'node-user')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { filesystem: userConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope => {
+      switch (scope) {
+        case 'project':
+          return {
+            servers: {},
+            errors: [
+              {
+                file: '.mcp.json',
+                path: '',
+                message: 'MCP config is not a valid JSON',
+                suggestion: 'Fix the JSON syntax errors in the file',
+                mcpErrorMetadata: {
+                  scope: 'project',
+                  severity: 'fatal',
+                },
+              },
+            ],
+          }
+        case 'user':
+          return { servers: { filesystem: userConfig }, errors: [] }
+        default:
+          return { servers: {}, errors: [] }
+      }
+    },
+  })
+
+  const report = await doctorAllServers({ configOnly: true, scopeFilter: 'user' }, deps)
+
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.summary.blocking, 0)
+  assert.deepEqual(report.findings, [])
+  assert.deepEqual(report.servers[0]?.findings, [])
+})
+
+test('doctorAllServers includes observed runtime definitions for plugin-only servers', async () => {
+  const pluginConfig = {
+    type: 'http' as const,
+    url: 'https://example.test/mcp',
+    scope: 'dynamic' as const,
+    pluginSource: 'plugin:github@official',
+  }
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { 'plugin:github:github': pluginConfig },
+      errors: [],
+    }),
+  })
+
+  const report = await doctorAllServers({ configOnly: true }, deps)
+
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.servers[0]?.definitions.length, 1)
+  assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin')
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, true)
+})
+
+test('doctorAllServers reports disabled plugin servers as disabled, not not-found', async () => {
+  const pluginConfig = {
+    type: 'http' as const,
+    url: 'https://example.test/mcp',
+    scope: 'dynamic' as const,
+    pluginSource: 'plugin:github@official',
+  }
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { 'plugin:github:github': pluginConfig },
+      errors: [],
+    }),
+    isMcpServerDisabled: name => name === 'plugin:github:github',
+  })
+
+  const report = await doctorAllServers({ configOnly: true }, deps)
+
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.summary.warnings, 1)
+  assert.equal(report.summary.blocking, 0)
+  assert.equal(report.servers[0]?.definitions.length, 1)
+  assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin')
+  assert.equal(report.servers[0]?.definitions[0]?.disabled, true)
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false)
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'state.disabled' && !finding.blocking),
+    true,
+  )
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'state.not_found'),
+    false,
+  )
+})
+
+test('doctorServer converts failed live checks into blocking findings', async () => {
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { github: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'local'
+        ? { servers: { github: localConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    connectToServer: async (name, config) => ({
+      name,
+      type: 'failed',
+      config,
+      error: 'command not found: node-local',
+    }),
+  })
+
+  const report = await doctorServer('github', { configOnly: false }, deps)
+
+  assert.equal(report.summary.blocking, 1)
+  assert.equal(report.servers[0]?.liveCheck.result, 'failed')
+  assert.equal(
+    report.servers[0]?.findings.some(
+      finding => finding.code === 'stdio.command_not_found' && finding.blocking,
+    ),
+    true,
+  )
+})
+
+test('doctorServer converts needs-auth live checks into warning findings', async () => {
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { sentry: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'local'
+        ? { servers: { sentry: localConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    connectToServer: async (name, config) => ({
+      name,
+      type: 'needs-auth',
+      config,
+    }),
+  })
+
+  const report = await doctorServer('sentry', { configOnly: false }, deps)
+
+  assert.equal(report.summary.warnings, 1)
+  assert.equal(report.summary.blocking, 0)
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'auth.needs_auth' && finding.severity === 'warn'),
+    true,
+  )
+})
+
+test('doctorServer includes observed runtime definition for plugin-only targets', async () => {
+  const pluginConfig = {
+    type: 'http' as const,
+    url: 'https://example.test/mcp',
+    scope: 'dynamic' as const,
+    pluginSource: 'plugin:github@official',
+  }
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { 'plugin:github:github': pluginConfig },
+      errors: [],
+    }),
+  })
+
+  const report = await doctorServer('plugin:github:github', { configOnly: true }, deps)
+
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.servers[0]?.definitions.length, 1)
+  assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin')
+  assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, true)
+})
+
+test('doctorServer with scopeFilter does not leak runtime definition from another scope when target is absent', async () => {
+  let connectCalls = 0
+  const localConfig = stdioConfig('local', 'node-local')
+  const deps = makeDependencies({
+    getAllMcpConfigs: async () => ({
+      servers: { github: localConfig },
+      errors: [],
+    }),
+    getMcpConfigsByScope: scope =>
+      scope === 'local'
+        ? { servers: { github: localConfig }, errors: [] }
+        : { servers: {}, errors: [] },
+    connectToServer: async (name, config) => {
+      connectCalls += 1
+      return {
+        name,
+        type: 'connected',
+        capabilities: {},
+        config,
+        cleanup: async () => {},
+      }
+    },
+  })
+
+  const report = await doctorServer('github', { configOnly: false, scopeFilter: 'user' }, deps)
+
+  assert.equal(connectCalls, 0)
+  assert.equal(report.summary.totalReports, 1)
+  assert.equal(report.summary.blocking, 1)
+  assert.deepEqual(report.servers[0]?.definitions, [])
+  assert.equal(report.servers[0]?.liveCheck.result, 'skipped')
+  assert.equal(
+    report.servers[0]?.findings.some(finding => finding.code === 'state.not_found' && finding.blocking),
+    true,
+  )
+})
+
+test('doctorServer reports blocking not-found state when no definition exists', async () => {
+  const report = await doctorServer('missing-server', { configOnly: true }, makeDependencies())
+
+  assert.equal(report.summary.blocking, 1)
+  assert.equal(report.servers[0]?.findings.some(finding => finding.code === 'state.not_found' && finding.blocking), true)
+})
diff --git a/src/services/mcp/doctor.ts b/src/services/mcp/doctor.ts
new file mode 100644
index 00000000..6cdd15e5
--- /dev/null
+++ b/src/services/mcp/doctor.ts
@@ -0,0 +1,695 @@
+import type { ValidationError } from '../../utils/settings/validation.js'
+import { clearServerCache, connectToServer } from './client.js'
+import {
+  getAllMcpConfigs,
+  getMcpConfigsByScope,
+  isMcpServerDisabled,
+} from './config.js'
+import type {
+  ConfigScope,
+  ScopedMcpServerConfig,
+} from './types.js'
+import { describeMcpConfigFilePath, getProjectMcpServerStatus } from './utils.js'
+
+export type McpDoctorSeverity = 'info' | 'warn' | 'error'
+export type McpDoctorScopeFilter = 'local' | 'project' | 'user' | 'enterprise'
+
+export type McpDoctorFinding = {
+  blocking: boolean
+  code: string
+  message: string
+  remediation?: string
+  scope?: string
+  serverName?: string
+  severity: McpDoctorSeverity
+  sourcePath?: string
+}
+
+export type McpDoctorLiveCheck = {
+  attempted: boolean
+  durationMs?: number
+  error?: string
+  result?: 'connected' | 'needs-auth' | 'failed' | 'pending' | 'disabled' | 'skipped'
+}
+
+export type McpDoctorDefinition = {
+  name: string
+  sourceType:
+    | 'local'
+    | 'project'
+    | 'user'
+    | 'enterprise'
+    | 'managed'
+    | 'plugin'
+    | 'claudeai'
+    | 'dynamic'
+    | 'internal'
+  sourcePath?: string
+  transport?: string
+  runtimeVisible: boolean
+  runtimeActive: boolean
+  pendingApproval?: boolean
+  disabled?: boolean
+}
+
+export type McpDoctorServerReport = {
+  serverName: string
+  requestedByUser: boolean
+  definitions: McpDoctorDefinition[]
+  liveCheck: McpDoctorLiveCheck
+  findings: McpDoctorFinding[]
+}
+
+export type McpDoctorDependencies = {
+  getAllMcpConfigs: typeof getAllMcpConfigs
+  getMcpConfigsByScope: typeof getMcpConfigsByScope
+  getProjectMcpServerStatus: typeof getProjectMcpServerStatus
+  isMcpServerDisabled: typeof isMcpServerDisabled
+  describeMcpConfigFilePath: typeof describeMcpConfigFilePath
+  connectToServer: typeof connectToServer
+  clearServerCache: typeof clearServerCache
+}
+
+export type McpDoctorReport = {
+  generatedAt: string
+  targetName?: string
+  scopeFilter?: McpDoctorScopeFilter
+  configOnly: boolean
+  summary: {
+    totalReports: number
+    healthy: number
+    warnings: number
+    blocking: number
+  }
+  findings: McpDoctorFinding[]
+  servers: McpDoctorServerReport[]
+}
+
+const DEFAULT_DEPENDENCIES: McpDoctorDependencies = {
+  getAllMcpConfigs,
+  getMcpConfigsByScope,
+  getProjectMcpServerStatus,
+  isMcpServerDisabled,
+  describeMcpConfigFilePath,
+  connectToServer,
+  clearServerCache,
+}
+
+export function buildEmptyDoctorReport(options: {
+  configOnly: boolean
+  scopeFilter?: McpDoctorScopeFilter
+  targetName?: string
+}): McpDoctorReport {
+  return {
+    generatedAt: new Date().toISOString(),
+    targetName: options.targetName,
+    scopeFilter: options.scopeFilter,
+    configOnly: options.configOnly,
+    summary: {
+      totalReports: 0,
+      healthy: 0,
+      warnings: 0,
+      blocking: 0,
+    },
+    findings: [],
+    servers: [],
+  }
+}
+
+function getFindingCode(error: ValidationError): string {
+  if (error.message === 'MCP config is not a valid JSON') {
+    return 'config.invalid_json'
+  }
+  if (error.message.startsWith('Missing environment variables:')) {
+    return 'config.missing_env_vars'
+  }
+  if (error.message.includes("Windows requires 'cmd /c' wrapper to execute npx")) {
+    return 'config.windows_npx_wrapper_required'
+  }
+  if (error.message === 'Does not adhere to MCP server configuration schema') {
+    return 'config.invalid_schema'
+  }
+  return 'config.validation_error'
+}
+
+function getSeverity(error: ValidationError): McpDoctorSeverity {
+  const severity = error.mcpErrorMetadata?.severity
+  if (severity === 'fatal') {
+    return 'error'
+  }
+  if (severity === 'warning') {
+    return 'warn'
+  }
+  return 'warn'
+}
+
+export function findingsFromValidationErrors(
+  validationErrors: ValidationError[],
+): McpDoctorFinding[] {
+  return validationErrors.map(error => {
+    const severity = getSeverity(error)
+    return {
+      blocking: severity === 'error',
+      code: getFindingCode(error),
+      message: error.message,
+      remediation: error.suggestion,
+      scope: error.mcpErrorMetadata?.scope,
+      serverName: error.mcpErrorMetadata?.serverName,
+      severity,
+      sourcePath: error.file,
+    }
+  })
+}
+
+function splitValidationFindings(validationFindings: McpDoctorFinding[]): {
+  globalFindings: McpDoctorFinding[]
+  serverFindingsByName: Map<string, McpDoctorFinding[]>
+} {
+  const globalFindings: McpDoctorFinding[] = []
+  const serverFindingsByName = new Map<string, McpDoctorFinding[]>()
+
+  for (const finding of validationFindings) {
+    if (!finding.serverName) {
+      globalFindings.push(finding)
+      continue
+    }
+
+    const findings = serverFindingsByName.get(finding.serverName) ?? []
+    findings.push(finding)
+    serverFindingsByName.set(finding.serverName, findings)
+  }
+
+  return {
+    globalFindings,
+    serverFindingsByName,
+  }
+}
+
+function getSourceType(config: ScopedMcpServerConfig): McpDoctorDefinition['sourceType'] {
+  if (config.scope === 'claudeai') {
+    return 'claudeai'
+  }
+  if (config.scope === 'dynamic') {
+    return config.pluginSource ? 'plugin' : 'dynamic'
+  }
+  if (config.scope === 'managed') {
+    return 'managed'
+  }
+  return config.scope
+}
+
+function getTransport(config: ScopedMcpServerConfig): string {
+  return config.type ?? 'stdio'
+}
+
+function getConfigSignature(config: ScopedMcpServerConfig): string {
+  switch (config.type) {
+    case 'sse':
+    case 'http':
+    case 'ws':
+    case 'claudeai-proxy':
+      return `${config.scope}:${config.type}:${config.url}`
+    case 'sdk':
+      return `${config.scope}:${config.type}:${config.name}`
+    default:
+      return `${config.scope}:${config.type ?? 'stdio'}:${config.command}:${JSON.stringify(config.args ?? [])}`
+  }
+}
+
+function isSameDefinition(
+  config: ScopedMcpServerConfig,
+  activeConfig: ScopedMcpServerConfig | undefined,
+): boolean {
+  if (!activeConfig) {
+    return false
+  }
+  return getSourceType(config) === getSourceType(activeConfig) && getConfigSignature(config) === getConfigSignature(activeConfig)
+}
+
+function buildScopeDefinitions(
+  name: string,
+  scope: ConfigScope,
+  servers: Record<string, ScopedMcpServerConfig>,
+  activeConfig: ScopedMcpServerConfig | undefined,
+  deps: McpDoctorDependencies,
+): McpDoctorDefinition[] {
+  const config = servers[name]
+  if (!config) {
+    return []
+  }
+
+  const pendingApproval =
+    scope === 'project' ? deps.getProjectMcpServerStatus(name) === 'pending' : false
+  const disabled = deps.isMcpServerDisabled(name)
+  const runtimeActive = !disabled && isSameDefinition(config, activeConfig)
+
+  return [
+    {
+      name,
+      sourceType: getSourceType(config),
+      sourcePath: deps.describeMcpConfigFilePath(scope),
+      transport: getTransport(config),
+      runtimeVisible: runtimeActive,
+      runtimeActive,
+      pendingApproval,
+      disabled,
+    },
+  ]
+}
+
+function shouldIncludeScope(
+  scope: ConfigScope,
+  scopeFilter: McpDoctorScopeFilter | undefined,
+): boolean {
+  if (!scopeFilter) {
+    return scope === 'enterprise' || scope === 'local' || scope === 'project' || scope === 'user'
+  }
+  return scope === scopeFilter
+}
+
+function getValidationErrorsForSelectedScopes(
+  scopeResults: {
+    enterprise: ReturnType<McpDoctorDependencies['getMcpConfigsByScope']>
+    local: ReturnType<McpDoctorDependencies['getMcpConfigsByScope']>
+    project: ReturnType<McpDoctorDependencies['getMcpConfigsByScope']>
+    user: ReturnType<McpDoctorDependencies['getMcpConfigsByScope']>
+  },
+  scopeFilter: McpDoctorScopeFilter | undefined,
+): ValidationError[] {
+  return [
+    ...(shouldIncludeScope('enterprise', scopeFilter) ? scopeResults.enterprise.errors : []),
+    ...(shouldIncludeScope('local', scopeFilter) ? scopeResults.local.errors : []),
+    ...(shouldIncludeScope('project', scopeFilter) ? scopeResults.project.errors : []),
+    ...(shouldIncludeScope('user', scopeFilter) ? scopeResults.user.errors : []),
+  ]
+}
+
+function buildObservedDefinition(
+  name: string,
+  activeConfig: ScopedMcpServerConfig,
+  options?: {
+    disabled?: boolean
+    runtimeActive?: boolean
+    runtimeVisible?: boolean
+  },
+): McpDoctorDefinition {
+  return {
+    name,
+    sourceType: getSourceType(activeConfig),
+    sourcePath:
+      getSourceType(activeConfig) === 'plugin'
+        ? `plugin:${activeConfig.pluginSource ?? 'unknown'}`
+        : getSourceType(activeConfig) === 'claudeai'
+          ? 'claude.ai'
+          : activeConfig.scope,
+    transport: getTransport(activeConfig),
+    runtimeVisible: options?.runtimeVisible ?? true,
+    runtimeActive: options?.runtimeActive ?? true,
+    disabled: options?.disabled ?? false,
+  }
+}
+
+function hasDefinitionForRuntimeSource(
+  definitions: McpDoctorDefinition[],
+  runtimeConfig: ScopedMcpServerConfig,
+  deps: McpDoctorDependencies,
+): boolean {
+  const runtimeSourceType = getSourceType(runtimeConfig)
+  const runtimeSourcePath =
+    runtimeSourceType === 'plugin'
+      ? `plugin:${runtimeConfig.pluginSource ?? 'unknown'}`
+      : runtimeSourceType === 'claudeai'
+        ? 'claude.ai'
+        : deps.describeMcpConfigFilePath(runtimeConfig.scope)
+
+  return definitions.some(
+    definition =>
+      definition.sourceType === runtimeSourceType &&
+      definition.sourcePath === runtimeSourcePath &&
+      definition.transport === getTransport(runtimeConfig),
+  )
+}
+
+function buildShadowingFindings(definitions: McpDoctorDefinition[]): McpDoctorFinding[] {
+  const userEditable = definitions.filter(definition =>
+    definition.sourceType === 'local' ||
+    definition.sourceType === 'project' ||
+    definition.sourceType === 'user' ||
+    definition.sourceType === 'enterprise',
+  )
+
+  if (userEditable.length <= 1) {
+    return []
+  }
+
+  const active = userEditable.find(definition => definition.runtimeActive) ?? userEditable[0]
+  return [
+    {
+      blocking: false,
+      code: 'duplicate.same_name_multiple_scopes',
+      message: `Server is defined in multiple config scopes; active source is ${active.sourceType}`,
+      remediation: 'Remove or rename one of the duplicate definitions to avoid confusion.',
+      serverName: active.name,
+      severity: 'warn',
+    },
+    {
+      blocking: false,
+      code: 'scope.shadowed',
+      message: `${active.name} has shadowed definitions in lower-precedence config scopes.`,
+      remediation: 'Inspect the other definitions and remove the ones you no longer want to keep.',
+      serverName: active.name,
+      severity: 'warn',
+    },
+  ]
+}
+
+function buildStateFindings(definitions: McpDoctorDefinition[]): McpDoctorFinding[] {
+  const findings: McpDoctorFinding[] = []
+
+  for (const definition of definitions) {
+    if (definition.pendingApproval) {
+      findings.push({
+        blocking: false,
+        code: 'state.pending_project_approval',
+        message: `${definition.name} is declared in project config but pending project approval.`,
+        remediation: 'Approve the server in the project MCP approval flow before expecting it to become active.',
+        scope: 'project',
+        serverName: definition.name,
+        severity: 'warn',
+        sourcePath: definition.sourcePath,
+      })
+    }
+
+    if (definition.disabled) {
+      findings.push({
+        blocking: false,
+        code: 'state.disabled',
+        message: `${definition.name} is currently disabled.`,
+        remediation: 'Re-enable the server before expecting it to be available at runtime.',
+        serverName: definition.name,
+        severity: 'warn',
+        sourcePath: definition.sourcePath,
+      })
+    }
+  }
+
+  return findings
+}
+
+function summarizeReport(report: McpDoctorReport): McpDoctorReport {
+  const allFindings = [...report.findings, ...report.servers.flatMap(server => server.findings)]
+  const blocking = allFindings.filter(finding => finding.blocking).length
+  const warnings = allFindings.filter(finding => finding.severity === 'warn').length
+  const healthy = report.servers.filter(
+    server =>
+      server.liveCheck.result === 'connected' &&
+      server.findings.every(finding => !finding.blocking && finding.severity !== 'warn'),
+  ).length
+
+  return {
+    ...report,
+    summary: {
+      totalReports: report.servers.length,
+      healthy,
+      warnings,
+      blocking,
+    },
+  }
+}
+
+async function getLiveCheck(
+  name: string,
+  activeConfig: ScopedMcpServerConfig | undefined,
+  configOnly: boolean,
+  definitions: McpDoctorDefinition[],
+  deps: McpDoctorDependencies,
+): Promise<McpDoctorLiveCheck> {
+  if (configOnly) {
+    return { attempted: false, result: 'skipped' }
+  }
+
+  if (!activeConfig) {
+    if (definitions.some(definition => definition.pendingApproval)) {
+      return { attempted: false, result: 'pending' }
+    }
+    if (definitions.some(definition => definition.disabled)) {
+      return { attempted: false, result: 'disabled' }
+    }
+    return { attempted: false, result: 'skipped' }
+  }
+
+  const startedAt = Date.now()
+  const connection = await deps.connectToServer(name, activeConfig)
+  const durationMs = Date.now() - startedAt
+
+  try {
+    switch (connection.type) {
+      case 'connected':
+        return { attempted: true, result: 'connected', durationMs }
+      case 'needs-auth':
+        return { attempted: true, result: 'needs-auth', durationMs }
+      case 'disabled':
+        return { attempted: true, result: 'disabled', durationMs }
+      case 'pending':
+        return { attempted: true, result: 'pending', durationMs }
+      case 'failed':
+        return {
+          attempted: true,
+          result: 'failed',
+          durationMs,
+          error: connection.error,
+        }
+    }
+  } finally {
+    await deps.clearServerCache(name, activeConfig).catch(() => {
+      // Best-effort cleanup for diagnostic connections.
+    })
+  }
+}
+
+function buildLiveFindings(
+  name: string,
+  definitions: McpDoctorDefinition[],
+  liveCheck: McpDoctorLiveCheck,
+): McpDoctorFinding[] {
+  const activeDefinition = definitions.find(definition => definition.runtimeActive)
+
+  if (liveCheck.result === 'needs-auth') {
+    return [
+      {
+        blocking: false,
+        code: 'auth.needs_auth',
+        message: `${name} requires authentication before it can be used.`,
+        remediation: 'Authenticate the server and then rerun the doctor command.',
+        serverName: name,
+        severity: 'warn',
+        sourcePath: activeDefinition?.sourcePath,
+      },
+    ]
+  }
+
+  if (liveCheck.result === 'failed') {
+    const commandNotFound =
+      activeDefinition?.transport === 'stdio' &&
+      typeof liveCheck.error === 'string' &&
+      liveCheck.error.toLowerCase().includes('not found')
+
+    return [
+      {
+        blocking: true,
+        code: commandNotFound ? 'stdio.command_not_found' : 'health.failed',
+        message: liveCheck.error
+          ? `${name} failed its live health check: ${liveCheck.error}`
+          : `${name} failed its live health check.`,
+        remediation: commandNotFound
+          ? 'Verify the configured executable exists on PATH or use a full executable path.'
+          : 'Inspect the server configuration and retry the connection once the underlying problem is fixed.',
+        serverName: name,
+        severity: 'error',
+        sourcePath: activeDefinition?.sourcePath,
+      },
+    ]
+  }
+
+  return []
+}
+
+async function buildServerReport(
+  name: string,
+  options: {
+    configOnly: boolean
+    requestedByUser: boolean
+    scopeFilter?: McpDoctorScopeFilter
+  },
+  validationFindingsByName: Map<string, McpDoctorFinding[]>,
+  deps: McpDoctorDependencies,
+): Promise<McpDoctorServerReport> {
+  const scopeResults = {
+    enterprise: deps.getMcpConfigsByScope('enterprise'),
+    local: deps.getMcpConfigsByScope('local'),
+    project: deps.getMcpConfigsByScope('project'),
+    user: deps.getMcpConfigsByScope('user'),
+  }
+  const { servers: activeServers } = await deps.getAllMcpConfigs()
+  const serverDisabled = deps.isMcpServerDisabled(name)
+  const runtimeConfig = activeServers[name] ?? undefined
+  const activeConfig = serverDisabled ? undefined : runtimeConfig
+
+  const definitions = [
+    ...(shouldIncludeScope('enterprise', options.scopeFilter)
+      ? buildScopeDefinitions(name, 'enterprise', scopeResults.enterprise.servers, activeConfig, deps)
+      : []),
+    ...(shouldIncludeScope('local', options.scopeFilter)
+      ? buildScopeDefinitions(name, 'local', scopeResults.local.servers, activeConfig, deps)
+      : []),
+    ...(shouldIncludeScope('project', options.scopeFilter)
+      ? buildScopeDefinitions(name, 'project', scopeResults.project.servers, activeConfig, deps)
+      : []),
+    ...(shouldIncludeScope('user', options.scopeFilter)
+      ? buildScopeDefinitions(name, 'user', scopeResults.user.servers, activeConfig, deps)
+      : []),
+  ]
+
+  const shouldAddObservedDefinition =
+    !!runtimeConfig &&
+    !hasDefinitionForRuntimeSource(definitions, runtimeConfig, deps) &&
+    ((definitions.length === 0 && !options.scopeFilter) ||
+      (definitions.length > 0 && definitions.every(definition => !definition.runtimeActive)))
+
+  if (runtimeConfig && shouldAddObservedDefinition) {
+    definitions.push(
+      buildObservedDefinition(name, runtimeConfig, {
+        disabled: serverDisabled,
+        runtimeActive: !serverDisabled,
+        runtimeVisible: !serverDisabled,
+      }),
+    )
+  }
+
+  const visibleRuntimeConfig =
+    definitions.some(definition => definition.runtimeActive) || shouldAddObservedDefinition
+      ? activeConfig
+      : undefined
+
+  const findings: McpDoctorFinding[] = [
+    ...(validationFindingsByName.get(name) ?? []),
+    ...buildShadowingFindings(definitions),
+    ...buildStateFindings(definitions),
+  ]
+
+  if (definitions.length === 0 && !shouldAddObservedDefinition) {
+    findings.push({
+      blocking: true,
+      code: 'state.not_found',
+      message: `${name} was not found in the selected MCP configuration sources.`,
+      remediation: 'Check the server name and scope, or add the MCP server before retrying.',
+      serverName: name,
+      severity: 'error',
+    })
+  }
+
+  const liveCheck = await getLiveCheck(name, visibleRuntimeConfig, options.configOnly, definitions, deps)
+  findings.push(...buildLiveFindings(name, definitions, liveCheck))
+
+  return {
+    serverName: name,
+    requestedByUser: options.requestedByUser,
+    definitions,
+    liveCheck,
+    findings,
+  }
+}
+
+function getServerNames(
+  scopeServers: Array<Record<string, ScopedMcpServerConfig>>,
+  activeServers: Record<string, ScopedMcpServerConfig>,
+  includeActiveServers: boolean,
+): string[] {
+  const names = new Set<string>(includeActiveServers ? Object.keys(activeServers) : [])
+  for (const servers of scopeServers) {
+    for (const name of Object.keys(servers)) {
+      names.add(name)
+    }
+  }
+  return [...names].sort()
+}
+
+export async function doctorAllServers(
+  options: { configOnly: boolean; scopeFilter?: McpDoctorScopeFilter } = {
+    configOnly: false,
+  },
+  deps: McpDoctorDependencies = DEFAULT_DEPENDENCIES,
+): Promise<McpDoctorReport> {
+  const report = buildEmptyDoctorReport(options)
+  const scopeResults = {
+    enterprise: deps.getMcpConfigsByScope('enterprise'),
+    local: deps.getMcpConfigsByScope('local'),
+    project: deps.getMcpConfigsByScope('project'),
+    user: deps.getMcpConfigsByScope('user'),
+  }
+  const validationFindings = findingsFromValidationErrors(
+    getValidationErrorsForSelectedScopes(scopeResults, options.scopeFilter),
+  )
+  const { globalFindings, serverFindingsByName } = splitValidationFindings(validationFindings)
+  const { servers: activeServers } = await deps.getAllMcpConfigs()
+  const names = getServerNames(
+    [
+      ...(shouldIncludeScope('enterprise', options.scopeFilter) ? [scopeResults.enterprise.servers] : []),
+      ...(shouldIncludeScope('local', options.scopeFilter) ? [scopeResults.local.servers] : []),
+      ...(shouldIncludeScope('project', options.scopeFilter) ? [scopeResults.project.servers] : []),
+      ...(shouldIncludeScope('user', options.scopeFilter) ? [scopeResults.user.servers] : []),
+    ],
+    activeServers,
+    !options.scopeFilter,
+  )
+
+  const servers = await Promise.all(
+    names.map(name =>
+      buildServerReport(
+        name,
+        {
+          configOnly: options.configOnly,
+          requestedByUser: false,
+          scopeFilter: options.scopeFilter,
+        },
+        serverFindingsByName,
+        deps,
+      ),
+    ),
+  )
+
+  report.servers = servers
+  report.findings = globalFindings
+  return summarizeReport(report)
+}
+
+export async function doctorServer(
+  name: string,
+  options: { configOnly: boolean; scopeFilter?: McpDoctorScopeFilter },
+  deps: McpDoctorDependencies = DEFAULT_DEPENDENCIES,
+): Promise<McpDoctorReport> {
+  const report = buildEmptyDoctorReport({ ...options, targetName: name })
+  const scopeResults = {
+    enterprise: deps.getMcpConfigsByScope('enterprise'),
+    local: deps.getMcpConfigsByScope('local'),
+    project: deps.getMcpConfigsByScope('project'),
+    user: deps.getMcpConfigsByScope('user'),
+  }
+  const validationFindings = findingsFromValidationErrors(
+    getValidationErrorsForSelectedScopes(scopeResults, options.scopeFilter),
+  )
+  const { globalFindings, serverFindingsByName } = splitValidationFindings(validationFindings)
+  const server = await buildServerReport(
+    name,
+    {
+      configOnly: options.configOnly,
+      requestedByUser: true,
+      scopeFilter: options.scopeFilter,
+    },
+    serverFindingsByName,
+    deps,
+  )
+  report.servers = [server]
+  report.findings = globalFindings
+  return summarizeReport(report)
+}
diff --git a/src/tools/AgentTool/AgentTool.tsx b/src/tools/AgentTool/AgentTool.tsx
index ee378b7b..dd7fafde 100644
--- a/src/tools/AgentTool/AgentTool.tsx
+++ b/src/tools/AgentTool/AgentTool.tsx
@@ -589,7 +589,19 @@ export const AgentTool = buildTool({
     } | null = null;
     if (effectiveIsolation === 'worktree') {
       const slug = `agent-${earlyAgentId.slice(0, 8)}`;
-      worktreeInfo = await createAgentWorktree(slug);
+      try {
+        worktreeInfo = await createAgentWorktree(slug);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('Cannot create agent worktree: not in a git repository')) {
+          if (isolation === 'worktree') {
+            throw error;
+          }
+          logForDebugging('Agent worktree isolation unavailable outside a git repository; falling back to the current working directory.');
+        } else {
+          throw error;
+        }
+      }
     }
 
     // Fork + worktree: inject a notice telling the child to translate paths
@@ -1395,4 +1407,4 @@ function resolveTeamName(input: {
   if (!isAgentSwarmsEnabled()) return undefined;
   return input.team_name || appState.teamContext?.teamName;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","buildTool","ToolDef","toolMatchesName","Message","MessageType","NormalizedUserMessage","getQuerySourceForAgent","z","clearInvokedSkillsForAgent","getSdkAgentProgressSummariesEnabled","enhanceSystemPromptWithEnvDetails","getSystemPrompt","isCoordinatorMode","startAgentSummarization","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearDumpState","completeAgentTask","completeAsyncAgent","createActivityDescriptionResolver","createProgressTracker","enqueueAgentNotification","failAgentTask","failAsyncAgent","getProgressUpdate","getTokenCountFromTracker","isLocalAgentTask","killAsyncAgent","registerAgentForeground","registerAsyncAgent","unregisterAgentForeground","updateAgentProgress","updateAsyncAgentProgress","updateProgressFromMessage","checkRemoteAgentEligibility","formatPreconditionError","getRemoteTaskSessionUrl","registerRemoteAgentTask","assembleToolPool","asAgentId","runWithAgentContext","isAgentSwarmsEnabled","getCwd","runWithCwdOverride","logForDebugging","isEnvTruthy","AbortError","errorMessage","toError","CacheSafeParams","lazySchema","createUserMessage","extractTextContent","isSyntheticMessage","normalizeMessages","getAgentModel","permissionModeSchema","PermissionResult","filterDeniedAgents","getDenyRuleForAgent","enqueueSdkEvent","writeAgentMetadata","sleep","buildEffectiveSystemPrompt","asSystemPrompt","getTaskOutputPath","getParentSessionId","isTeammate","isInProcessTeammate","teleportToRemote","getAssistantMessageContentLength","createAgentId","createAgentWorktree","hasWorktreeChanges","removeAgentWorktree","BASH_TOOL_NAME","BackgroundHint","FILE_READ_TOOL_NAME","spawnTeammate","setAgentColor","agentToolResultSchema","classifyHandoffIfNeeded","emitTaskProgress","extractPartialResult","finalizeAgentTool","getLastToolUseName","runAsyncAgentLifecycle","GENERAL_PURPOSE_AGENT","AGENT_TOOL_NAME","LEGACY_AGENT_TOOL_NAME","ONE_SHOT_BUILTIN_AGENT_TYPES","buildForkedMessages","buildWorktreeNotice","FORK_AGENT","isForkSubagentEnabled","isInForkChild","AgentDefinition","filterAgentsByMcpRequirements","hasRequiredMcpServers","isBuiltInAgent","getPrompt","runAgent","renderGroupedAgentToolUse","renderToolResultMessage","renderToolUseErrorMessage","renderToolUseMessage","renderToolUseProgressMessage","renderToolUseRejectedMessage","renderToolUseTag","userFacingName","userFacingNameBackgroundColor","proactiveModule","require","PROGRESS_THRESHOLD_MS","isBackgroundTasksDisabled","process","env","CLAUDE_CODE_DISABLE_BACKGROUND_TASKS","getAutoBackgroundMs","CLAUDE_AUTO_BACKGROUND_TASKS","baseInputSchema","object","description","string","describe","prompt","subagent_type","optional","model","enum","run_in_background","boolean","fullInputSchema","multiAgentInputSchema","name","team_name","mode","merge","extend","isolation","cwd","inputSchema","schema","omit","InputSchema","ReturnType","AgentToolInput","infer","outputSchema","syncOutputSchema","status","literal","asyncOutputSchema","agentId","outputFile","canReadOutputFile","union","OutputSchema","Output","input","TeammateSpawnedOutput","teammate_id","agent_id","agent_type","color","tmux_session_name","tmux_window_name","tmux_pane_id","is_splitpane","plan_mode_required","RemoteLaunchedOutput","taskId","sessionUrl","InternalOutput","AgentToolProgress","ShellProgress","Progress","AgentTool","agents","tools","getToolPermissionContext","allowedAgentTypes","toolPermissionContext","mcpServersWithTools","tool","startsWith","parts","split","serverName","includes","push","agentsWithMcpRequirementsMet","filteredAgents","isCoordinator","CLAUDE_CODE_COORDINATOR_MODE","searchHint","aliases","maxResultSizeChars","call","modelParam","spawnMode","toolUseContext","canUseTool","assistantMessage","onProgress","startTime","Date","now","undefined","appState","getAppState","permissionMode","rootSetAppState","setAppStateForTasks","setAppState","Error","teamName","resolveTeamName","agentDef","options","agentDefinitions","activeAgents","find","a","agentType","result","use_splitpane","invokingRequestId","requestId","spawnResult","const","data","effectiveType","isForkPath","selectedAgent","querySource","messages","allAgents","filter","found","agent","agentExistsButDenied","denyRule","source","map","join","background","requiredMcpServers","length","hasPendingRequiredServers","mcp","clients","some","c","type","pattern","toLowerCase","currentAppState","MAX_WAIT_MS","POLL_INTERVAL_MS","deadline","hasFailedRequiredServer","stillPending","serversWithTools","missing","server","resolvedAgentModel","mainLoopModel","is_built_in_agent","is_resume","is_async","is_fork","effectiveIsolation","eligibility","eligible","reasons","errors","bundleFailHint","session","initialMessage","signal","abortController","onBundleFail","msg","sessionId","remoteTaskType","id","title","command","context","toolUseId","remoteResult","enhancedSystemPrompt","forkParentSystemPrompt","promptMessages","renderedSystemPrompt","mainThreadAgentDefinition","additionalWorkingDirectories","Array","from","keys","defaultSystemPrompt","mcpClients","customSystemPrompt","appendSystemPrompt","agentPrompt","memory","scope","error","content","metadata","isAsync","forceAsync","assistantForceAsync","kairosEnabled","shouldRunAsync","isProactiveActive","workerPermissionContext","workerTools","earlyAgentId","worktreeInfo","worktreePath","worktreeBranch","headCommit","gitRoot","hookBased","slug","slice","runAgentParams","Parameters","agentDefinition","override","systemPrompt","availableTools","forkContextMessages","useExactTools","cwdOverridePath","wrapWithCwd","fn","T","cleanupWorktreeIfNeeded","Promise","changed","catch","_err","asyncAgentId","agentBackgroundTask","prev","next","Map","agentNameRegistry","set","asyncAgentContext","parentSessionId","subagentName","isBuiltIn","invocationKind","invocationEmitted","makeStream","onCacheSafeParams","agentIdForCleanup","enableSummarization","getWorktreeResult","t","syncAgentId","syncAgentContext","agentMessages","agentStartTime","syncTracker","syncResolveActivity","normalizedPromptMessages","normalizedFirstMessage","m","toolUseID","message","foregroundTaskId","backgroundPromise","cancelAutoBackground","registration","autoBackgroundMs","backgroundSignal","then","backgroundHintShown","wasBackgrounded","stopForegroundSummarization","summaryTaskId","agentIterator","params","stop","Symbol","asyncIterator","syncAgentError","wasAborted","worktreeResult","elapsed","setToolJSX","jsx","shouldHidePromptInput","shouldContinueAnimation","showSpinner","nextMessagePromise","raceResult","race","r","task","tasks","isBackgrounded","backgroundedTaskId","stopBackgroundedSummarization","return","tracker","resolveActivity2","existingMsg","lastToolName","agentResult","finalMessage","backgroundedAppState","handoffWarning","abortSignal","subagentType","totalToolUseCount","usage","totalTokens","toolUses","durationMs","totalDurationMs","duration_ms","reason","partialResult","errMsg","done","value","contentLength","setResponseLength","len","normalizedNew","level","progress","subtype","task_id","tool_use_id","output_file","summary","total_tokens","tokenCount","tool_uses","toolUseCount","lastMessage","findLast","_","hasAssistantMessages","text","isReadOnly","toAutoClassifierInput","i","tags","prefix","isConcurrencySafe","getActivityDescription","checkPermissions","behavior","updatedInput","mapToolResultToToolResultBlockParam","internalData","spawnData","instructions","worktreeData","Record","worktreeInfoText","contentOrMarker","has","renderGroupedToolUse","teamContext"],"sources":["AgentTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { buildTool, type ToolDef, toolMatchesName } from 'src/Tool.js'\nimport type {\n  Message as MessageType,\n  NormalizedUserMessage,\n} from 'src/types/message.js'\nimport { getQuerySourceForAgent } from 'src/utils/promptCategory.js'\nimport { z } from 'zod/v4'\nimport {\n  clearInvokedSkillsForAgent,\n  getSdkAgentProgressSummariesEnabled,\n} from '../../bootstrap/state.js'\nimport {\n  enhanceSystemPromptWithEnvDetails,\n  getSystemPrompt,\n} from '../../constants/prompts.js'\nimport { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'\nimport { startAgentSummarization } from '../../services/AgentSummary/agentSummary.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { clearDumpState } from '../../services/api/dumpPrompts.js'\nimport {\n  completeAgentTask as completeAsyncAgent,\n  createActivityDescriptionResolver,\n  createProgressTracker,\n  enqueueAgentNotification,\n  failAgentTask as failAsyncAgent,\n  getProgressUpdate,\n  getTokenCountFromTracker,\n  isLocalAgentTask,\n  killAsyncAgent,\n  registerAgentForeground,\n  registerAsyncAgent,\n  unregisterAgentForeground,\n  updateAgentProgress as updateAsyncAgentProgress,\n  updateProgressFromMessage,\n} from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport {\n  checkRemoteAgentEligibility,\n  formatPreconditionError,\n  getRemoteTaskSessionUrl,\n  registerRemoteAgentTask,\n} from '../../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport { assembleToolPool } from '../../tools.js'\nimport { asAgentId } from '../../types/ids.js'\nimport { runWithAgentContext } from '../../utils/agentContext.js'\nimport { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'\nimport { getCwd, runWithCwdOverride } from '../../utils/cwd.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { AbortError, errorMessage, toError } from '../../utils/errors.js'\nimport type { CacheSafeParams } from '../../utils/forkedAgent.js'\nimport { lazySchema } from '../../utils/lazySchema.js'\nimport {\n  createUserMessage,\n  extractTextContent,\n  isSyntheticMessage,\n  normalizeMessages,\n} from '../../utils/messages.js'\nimport { getAgentModel } from '../../utils/model/agent.js'\nimport { permissionModeSchema } from '../../utils/permissions/PermissionMode.js'\nimport type { PermissionResult } from '../../utils/permissions/PermissionResult.js'\nimport {\n  filterDeniedAgents,\n  getDenyRuleForAgent,\n} from '../../utils/permissions/permissions.js'\nimport { enqueueSdkEvent } from '../../utils/sdkEventQueue.js'\nimport { writeAgentMetadata } from '../../utils/sessionStorage.js'\nimport { sleep } from '../../utils/sleep.js'\nimport { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js'\nimport { asSystemPrompt } from '../../utils/systemPromptType.js'\nimport { getTaskOutputPath } from '../../utils/task/diskOutput.js'\nimport { getParentSessionId, isTeammate } from '../../utils/teammate.js'\nimport { isInProcessTeammate } from '../../utils/teammateContext.js'\nimport { teleportToRemote } from '../../utils/teleport.js'\nimport { getAssistantMessageContentLength } from '../../utils/tokens.js'\nimport { createAgentId } from '../../utils/uuid.js'\nimport {\n  createAgentWorktree,\n  hasWorktreeChanges,\n  removeAgentWorktree,\n} from '../../utils/worktree.js'\nimport { BASH_TOOL_NAME } from '../BashTool/toolName.js'\nimport { BackgroundHint } from '../BashTool/UI.js'\nimport { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'\nimport { spawnTeammate } from '../shared/spawnMultiAgent.js'\nimport { setAgentColor } from './agentColorManager.js'\nimport {\n  agentToolResultSchema,\n  classifyHandoffIfNeeded,\n  emitTaskProgress,\n  extractPartialResult,\n  finalizeAgentTool,\n  getLastToolUseName,\n  runAsyncAgentLifecycle,\n} from './agentToolUtils.js'\nimport { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'\nimport {\n  AGENT_TOOL_NAME,\n  LEGACY_AGENT_TOOL_NAME,\n  ONE_SHOT_BUILTIN_AGENT_TYPES,\n} from './constants.js'\nimport {\n  buildForkedMessages,\n  buildWorktreeNotice,\n  FORK_AGENT,\n  isForkSubagentEnabled,\n  isInForkChild,\n} from './forkSubagent.js'\nimport type { AgentDefinition } from './loadAgentsDir.js'\nimport {\n  filterAgentsByMcpRequirements,\n  hasRequiredMcpServers,\n  isBuiltInAgent,\n} from './loadAgentsDir.js'\nimport { getPrompt } from './prompt.js'\nimport { runAgent } from './runAgent.js'\nimport {\n  renderGroupedAgentToolUse,\n  renderToolResultMessage,\n  renderToolUseErrorMessage,\n  renderToolUseMessage,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseTag,\n  userFacingName,\n  userFacingNameBackgroundColor,\n} from './UI.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? (require('../../proactive/index.js') as typeof import('../../proactive/index.js'))\n    : null\n/* eslint-enable @typescript-eslint/no-require-imports */\n\n// Progress display constants (for showing background hint)\nconst PROGRESS_THRESHOLD_MS = 2000 // Show background hint after 2 seconds\n\n// Check if background tasks are disabled at module load time\nconst isBackgroundTasksDisabled =\n  // eslint-disable-next-line custom-rules/no-process-env-top-level -- Intentional: schema must be defined at module load\n  isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)\n\n// Auto-background agent tasks after this many ms (0 = disabled)\n// Enabled by env var OR GrowthBook gate (checked lazily since GB may not be ready at module load)\nfunction getAutoBackgroundMs(): number {\n  if (\n    isEnvTruthy(process.env.CLAUDE_AUTO_BACKGROUND_TASKS) ||\n    getFeatureValue_CACHED_MAY_BE_STALE('tengu_auto_background_agents', false)\n  ) {\n    return 120_000\n  }\n  return 0\n}\n\n// Multi-agent type constants are defined inline inside gated blocks to enable dead code elimination\n\n// Base input schema without multi-agent parameters\nconst baseInputSchema = lazySchema(() =>\n  z.object({\n    description: z\n      .string()\n      .describe('A short (3-5 word) description of the task'),\n    prompt: z.string().describe('The task for the agent to perform'),\n    subagent_type: z\n      .string()\n      .optional()\n      .describe('The type of specialized agent to use for this task'),\n    model: z\n      .enum(['sonnet', 'opus', 'haiku'])\n      .optional()\n      .describe(\n        \"Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent.\",\n      ),\n    run_in_background: z\n      .boolean()\n      .optional()\n      .describe(\n        'Set to true to run this agent in the background. You will be notified when it completes.',\n      ),\n  }),\n)\n\n// Full schema combining base + multi-agent params + isolation\nconst fullInputSchema = lazySchema(() => {\n  // Multi-agent parameters\n  const multiAgentInputSchema = z.object({\n    name: z\n      .string()\n      .optional()\n      .describe(\n        'Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running.',\n      ),\n    team_name: z\n      .string()\n      .optional()\n      .describe(\n        'Team name for spawning. Uses current team context if omitted.',\n      ),\n    mode: permissionModeSchema()\n      .optional()\n      .describe(\n        'Permission mode for spawned teammate (e.g., \"plan\" to require plan approval).',\n      ),\n  })\n\n  return baseInputSchema()\n    .merge(multiAgentInputSchema)\n    .extend({\n      isolation: (\"external\" === 'ant'\n        ? z.enum(['worktree', 'remote'])\n        : z.enum(['worktree'])\n      )\n        .optional()\n        .describe(\n          \"external\" === 'ant'\n            ? 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo. \"remote\" launches the agent in a remote CCR environment (always runs in background).'\n            : 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo.',\n        ),\n      cwd: z\n        .string()\n        .optional()\n        .describe(\n          'Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: \"worktree\".',\n        ),\n    })\n})\n\n// Strip optional fields from the schema when the backing feature is off so\n// the model never sees them. Done via .omit() rather than conditional spread\n// inside .extend() because the spread-ternary breaks Zod's type inference\n// (field type collapses to `unknown`). The ternary return produces a union\n// type, but call() destructures via the explicit AgentToolInput type below\n// which always includes all optional fields.\nexport const inputSchema = lazySchema(() => {\n  const schema = feature('KAIROS')\n    ? fullInputSchema()\n    : fullInputSchema().omit({ cwd: true })\n\n  // GrowthBook-in-lazySchema is acceptable here (unlike subagent_type, which\n  // was removed in 906da6c723): the divergence window is one-session-per-\n  // gate-flip via _CACHED_MAY_BE_STALE disk read, and worst case is either\n  // \"schema shows a no-op param\" (gate flips on mid-session: param ignored\n  // by forceAsync) or \"schema hides a param that would've worked\" (gate\n  // flips off mid-session: everything still runs async via memoized\n  // forceAsync). No Zod rejection, no crash — unlike required→optional.\n  return isBackgroundTasksDisabled || isForkSubagentEnabled()\n    ? schema.omit({ run_in_background: true })\n    : schema\n})\ntype InputSchema = ReturnType<typeof inputSchema>\n\n// Explicit type widens the schema inference to always include all optional\n// fields even when .omit() strips them for gating (cwd, run_in_background).\n// subagent_type is optional; call() defaults it to general-purpose when the\n// fork gate is off, or routes to the fork path when the gate is on.\ntype AgentToolInput = z.infer<ReturnType<typeof baseInputSchema>> & {\n  name?: string\n  team_name?: string\n  mode?: z.infer<ReturnType<typeof permissionModeSchema>>\n  isolation?: 'worktree' | 'remote'\n  cwd?: string\n}\n\n// Output schema - multi-agent spawned schema added dynamically at runtime when enabled\nexport const outputSchema = lazySchema(() => {\n  const syncOutputSchema = agentToolResultSchema().extend({\n    status: z.literal('completed'),\n    prompt: z.string(),\n  })\n\n  const asyncOutputSchema = z.object({\n    status: z.literal('async_launched'),\n    agentId: z.string().describe('The ID of the async agent'),\n    description: z.string().describe('The description of the task'),\n    prompt: z.string().describe('The prompt for the agent'),\n    outputFile: z\n      .string()\n      .describe('Path to the output file for checking agent progress'),\n    canReadOutputFile: z\n      .boolean()\n      .optional()\n      .describe(\n        'Whether the calling agent has Read/Bash tools to check progress',\n      ),\n  })\n\n  return z.union([syncOutputSchema, asyncOutputSchema])\n})\ntype OutputSchema = ReturnType<typeof outputSchema>\ntype Output = z.input<OutputSchema>\n\n// Private type for teammate spawn results - excluded from exported schema for dead code elimination\n// The 'teammate_spawned' status string is only included when ENABLE_AGENT_SWARMS is true\ntype TeammateSpawnedOutput = {\n  status: 'teammate_spawned'\n  prompt: string\n  teammate_id: string\n  agent_id: string\n  agent_type?: string\n  model?: string\n  name: string\n  color?: string\n  tmux_session_name: string\n  tmux_window_name: string\n  tmux_pane_id: string\n  team_name?: string\n  is_splitpane?: boolean\n  plan_mode_required?: boolean\n}\n\n// Combined output type including both public and internal types\n// Note: TeammateSpawnedOutput type is fine - TypeScript types are erased at compile time\n// Private type for remote-launched results — excluded from exported schema\n// like TeammateSpawnedOutput for dead code elimination purposes. Exported\n// for UI.tsx to do proper discriminated-union narrowing instead of ad-hoc casts.\nexport type RemoteLaunchedOutput = {\n  status: 'remote_launched'\n  taskId: string\n  sessionUrl: string\n  description: string\n  prompt: string\n  outputFile: string\n}\n\ntype InternalOutput = Output | TeammateSpawnedOutput | RemoteLaunchedOutput\n\nimport type { AgentToolProgress, ShellProgress } from '../../types/tools.js'\n// AgentTool forwards both its own progress events and shell progress\n// events from the sub-agent so the SDK receives tool_progress updates during bash/powershell runs.\nexport type Progress = AgentToolProgress | ShellProgress\n\nexport const AgentTool = buildTool({\n  async prompt({ agents, tools, getToolPermissionContext, allowedAgentTypes }) {\n    const toolPermissionContext = await getToolPermissionContext()\n\n    // Get MCP servers that have tools available\n    const mcpServersWithTools: string[] = []\n    for (const tool of tools) {\n      if (tool.name?.startsWith('mcp__')) {\n        const parts = tool.name.split('__')\n        const serverName = parts[1]\n        if (serverName && !mcpServersWithTools.includes(serverName)) {\n          mcpServersWithTools.push(serverName)\n        }\n      }\n    }\n\n    // Filter agents: first by MCP requirements, then by permission rules\n    const agentsWithMcpRequirementsMet = filterAgentsByMcpRequirements(\n      agents,\n      mcpServersWithTools,\n    )\n    const filteredAgents = filterDeniedAgents(\n      agentsWithMcpRequirementsMet,\n      toolPermissionContext,\n      AGENT_TOOL_NAME,\n    )\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n    return await getPrompt(filteredAgents, isCoordinator, allowedAgentTypes)\n  },\n  name: AGENT_TOOL_NAME,\n  searchHint: 'delegate work to a subagent',\n  aliases: [LEGACY_AGENT_TOOL_NAME],\n  maxResultSizeChars: 100_000,\n  async description() {\n    return 'Launch a new agent'\n  },\n  get inputSchema(): InputSchema {\n    return inputSchema()\n  },\n  get outputSchema(): OutputSchema {\n    return outputSchema()\n  },\n  async call(\n    {\n      prompt,\n      subagent_type,\n      description,\n      model: modelParam,\n      run_in_background,\n      name,\n      team_name,\n      mode: spawnMode,\n      isolation,\n      cwd,\n    }: AgentToolInput,\n    toolUseContext,\n    canUseTool,\n    assistantMessage,\n    onProgress?,\n  ) {\n    const startTime = Date.now()\n    const model = isCoordinatorMode() ? undefined : modelParam\n\n    // Get app state for permission mode and agent filtering\n    const appState = toolUseContext.getAppState()\n    const permissionMode = appState.toolPermissionContext.mode\n    // In-process teammates get a no-op setAppState; setAppStateForTasks\n    // reaches the root store so task registration/progress/kill stay visible.\n    const rootSetAppState =\n      toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState\n\n    // Check if user is trying to use agent teams without access\n    if (team_name && !isAgentSwarmsEnabled()) {\n      throw new Error('Agent Teams is not yet available on your plan.')\n    }\n\n    // Teammates (in-process or tmux) passing `name` would trigger spawnTeammate()\n    // below, but TeamFile.members is a flat array with one leadAgentId — nested\n    // teammates land in the roster with no provenance and confuse the lead.\n    const teamName = resolveTeamName({ team_name }, appState)\n    if (isTeammate() && teamName && name) {\n      throw new Error(\n        'Teammates cannot spawn other teammates — the team roster is flat. To spawn a subagent instead, omit the `name` parameter.',\n      )\n    }\n    // In-process teammates cannot spawn background agents (their lifecycle is\n    // tied to the leader's process). Tmux teammates are separate processes and\n    // can manage their own background agents.\n    if (isInProcessTeammate() && teamName && run_in_background === true) {\n      throw new Error(\n        'In-process teammates cannot spawn background agents. Use run_in_background=false for synchronous subagents.',\n      )\n    }\n\n    // Check if this is a multi-agent spawn request\n    // Spawn is triggered when team_name is set (from param or context) and name is provided\n    if (teamName && name) {\n      // Set agent definition color for grouped UI display before spawning\n      const agentDef = subagent_type\n        ? toolUseContext.options.agentDefinitions.activeAgents.find(\n            a => a.agentType === subagent_type,\n          )\n        : undefined\n      if (agentDef?.color) {\n        setAgentColor(subagent_type!, agentDef.color)\n      }\n      const result = await spawnTeammate(\n        {\n          name,\n          prompt,\n          description,\n          team_name: teamName,\n          use_splitpane: true,\n          plan_mode_required: spawnMode === 'plan',\n          model: model ?? agentDef?.model,\n          agent_type: subagent_type,\n          invokingRequestId: assistantMessage?.requestId,\n        },\n        toolUseContext,\n      )\n\n      // Type assertion uses TeammateSpawnedOutput (defined above) instead of any.\n      // This type is excluded from the exported outputSchema for dead code elimination.\n      // Cast through unknown because TeammateSpawnedOutput is intentionally\n      // not part of the exported Output union (for dead code elimination purposes).\n      const spawnResult: TeammateSpawnedOutput = {\n        status: 'teammate_spawned' as const,\n        prompt,\n        ...result.data,\n      }\n      return { data: spawnResult } as unknown as { data: Output }\n    }\n\n    // Fork subagent experiment routing:\n    // - subagent_type set: use it (explicit wins)\n    // - subagent_type omitted, gate on: fork path (undefined)\n    // - subagent_type omitted, gate off: default general-purpose\n    const effectiveType =\n      subagent_type ??\n      (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType)\n    const isForkPath = effectiveType === undefined\n\n    let selectedAgent: AgentDefinition\n    if (isForkPath) {\n      // Recursive fork guard: fork children keep the Agent tool in their\n      // pool for cache-identical tool defs, so reject fork attempts at call\n      // time. Primary check is querySource (compaction-resistant — set on\n      // context.options at spawn time, survives autocompact's message\n      // rewrite). Message-scan fallback catches any path where querySource\n      // wasn't threaded.\n      if (\n        toolUseContext.options.querySource ===\n          `agent:builtin:${FORK_AGENT.agentType}` ||\n        isInForkChild(toolUseContext.messages)\n      ) {\n        throw new Error(\n          'Fork is not available inside a forked worker. Complete your task directly using your tools.',\n        )\n      }\n      selectedAgent = FORK_AGENT\n    } else {\n      // Filter agents to exclude those denied via Agent(AgentName) syntax\n      const allAgents = toolUseContext.options.agentDefinitions.activeAgents\n      const { allowedAgentTypes } = toolUseContext.options.agentDefinitions\n      const agents = filterDeniedAgents(\n        // When allowedAgentTypes is set (from Agent(x,y) tool spec), restrict to those types\n        allowedAgentTypes\n          ? allAgents.filter(a => allowedAgentTypes.includes(a.agentType))\n          : allAgents,\n        appState.toolPermissionContext,\n        AGENT_TOOL_NAME,\n      )\n\n      const found = agents.find(agent => agent.agentType === effectiveType)\n      if (!found) {\n        // Check if the agent exists but is denied by permission rules\n        const agentExistsButDenied = allAgents.find(\n          agent => agent.agentType === effectiveType,\n        )\n        if (agentExistsButDenied) {\n          const denyRule = getDenyRuleForAgent(\n            appState.toolPermissionContext,\n            AGENT_TOOL_NAME,\n            effectiveType,\n          )\n          throw new Error(\n            `Agent type '${effectiveType}' has been denied by permission rule '${AGENT_TOOL_NAME}(${effectiveType})' from ${denyRule?.source ?? 'settings'}.`,\n          )\n        }\n        throw new Error(\n          `Agent type '${effectiveType}' not found. Available agents: ${agents\n            .map(a => a.agentType)\n            .join(', ')}`,\n        )\n      }\n      selectedAgent = found\n    }\n\n    // Same lifecycle constraint as the run_in_background guard above, but for\n    // agent definitions that force background via `background: true`. Checked\n    // here because selectedAgent is only now resolved.\n    if (\n      isInProcessTeammate() &&\n      teamName &&\n      selectedAgent.background === true\n    ) {\n      throw new Error(\n        `In-process teammates cannot spawn background agents. Agent '${selectedAgent.agentType}' has background: true in its definition.`,\n      )\n    }\n\n    // Capture for type narrowing — `let selectedAgent` prevents TS from\n    // narrowing property types across the if-else assignment above.\n    const requiredMcpServers = selectedAgent.requiredMcpServers\n\n    // Check if required MCP servers have tools available\n    // A server that's connected but not authenticated won't have any tools\n    if (requiredMcpServers?.length) {\n      // If any required servers are still pending (connecting), wait for them\n      // before checking tool availability. This avoids a race condition where\n      // the agent is invoked before MCP servers finish connecting.\n      const hasPendingRequiredServers = appState.mcp.clients.some(\n        c =>\n          c.type === 'pending' &&\n          requiredMcpServers.some(pattern =>\n            c.name.toLowerCase().includes(pattern.toLowerCase()),\n          ),\n      )\n\n      let currentAppState = appState\n      if (hasPendingRequiredServers) {\n        const MAX_WAIT_MS = 30_000\n        const POLL_INTERVAL_MS = 500\n        const deadline = Date.now() + MAX_WAIT_MS\n\n        while (Date.now() < deadline) {\n          await sleep(POLL_INTERVAL_MS)\n          currentAppState = toolUseContext.getAppState()\n\n          // Early exit: if any required server has already failed, no point\n          // waiting for other pending servers — the check will fail regardless.\n          const hasFailedRequiredServer = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'failed' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (hasFailedRequiredServer) break\n\n          const stillPending = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'pending' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (!stillPending) break\n        }\n      }\n\n      // Get servers that actually have tools (meaning they're connected AND authenticated)\n      const serversWithTools: string[] = []\n      for (const tool of currentAppState.mcp.tools) {\n        if (tool.name?.startsWith('mcp__')) {\n          // Extract server name from tool name (format: mcp__serverName__toolName)\n          const parts = tool.name.split('__')\n          const serverName = parts[1]\n          if (serverName && !serversWithTools.includes(serverName)) {\n            serversWithTools.push(serverName)\n          }\n        }\n      }\n\n      if (!hasRequiredMcpServers(selectedAgent, serversWithTools)) {\n        const missing = requiredMcpServers.filter(\n          pattern =>\n            !serversWithTools.some(server =>\n              server.toLowerCase().includes(pattern.toLowerCase()),\n            ),\n        )\n        throw new Error(\n          `Agent '${selectedAgent.agentType}' requires MCP servers matching: ${missing.join(', ')}. ` +\n            `MCP servers with tools: ${serversWithTools.length > 0 ? serversWithTools.join(', ') : 'none'}. ` +\n            `Use /mcp to configure and authenticate the required MCP servers.`,\n        )\n      }\n    }\n\n    // Initialize the color for this agent if it has a predefined one\n    if (selectedAgent.color) {\n      setAgentColor(selectedAgent.agentType, selectedAgent.color)\n    }\n\n    // Resolve agent params for logging (these are already resolved in runAgent)\n    const resolvedAgentModel = getAgentModel(\n      selectedAgent.model,\n      toolUseContext.options.mainLoopModel,\n      isForkPath ? undefined : model,\n      permissionMode,\n    )\n\n    logEvent('tengu_agent_tool_selected', {\n      agent_type:\n        selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      model:\n        resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        selectedAgent.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      color:\n        selectedAgent.color as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      is_built_in_agent: isBuiltInAgent(selectedAgent),\n      is_resume: false,\n      is_async:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n      is_fork: isForkPath,\n    })\n\n    // Resolve effective isolation mode (explicit param overrides agent def)\n    const effectiveIsolation = isolation ?? selectedAgent.isolation\n\n    // Remote isolation: delegate to CCR. Gated ant-only — the guard enables\n    // dead code elimination of the entire block for external builds.\n    if (\"external\" === 'ant' && effectiveIsolation === 'remote') {\n      const eligibility = await checkRemoteAgentEligibility()\n      if (!eligibility.eligible) {\n        const reasons = eligibility.errors\n          .map(formatPreconditionError)\n          .join('\\n')\n        throw new Error(`Cannot launch remote agent:\\n${reasons}`)\n      }\n\n      let bundleFailHint: string | undefined\n      const session = await teleportToRemote({\n        initialMessage: prompt,\n        description,\n        signal: toolUseContext.abortController.signal,\n        onBundleFail: msg => {\n          bundleFailHint = msg\n        },\n      })\n      if (!session) {\n        throw new Error(bundleFailHint ?? 'Failed to create remote session')\n      }\n\n      const { taskId, sessionId } = registerRemoteAgentTask({\n        remoteTaskType: 'remote-agent',\n        session: { id: session.id, title: session.title || description },\n        command: prompt,\n        context: toolUseContext,\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      logEvent('tengu_agent_tool_remote_launched', {\n        agent_type:\n          selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      const remoteResult: RemoteLaunchedOutput = {\n        status: 'remote_launched',\n        taskId,\n        sessionUrl: getRemoteTaskSessionUrl(sessionId),\n        description,\n        prompt,\n        outputFile: getTaskOutputPath(taskId),\n      }\n      return { data: remoteResult } as unknown as { data: Output }\n    }\n    // System prompt + prompt messages: branch on fork path.\n    //\n    // Fork path: child inherits the PARENT's system prompt (not FORK_AGENT's)\n    // for cache-identical API request prefixes. Prompt messages are built via\n    // buildForkedMessages() which clones the parent's full assistant message\n    // (all tool_use blocks) + placeholder tool_results + per-child directive.\n    //\n    // Normal path: build the selected agent's own system prompt with env\n    // details, and use a simple user message for the prompt.\n    let enhancedSystemPrompt: string[] | undefined\n    let forkParentSystemPrompt:\n      | ReturnType<typeof buildEffectiveSystemPrompt>\n      | undefined\n    let promptMessages: MessageType[]\n\n    if (isForkPath) {\n      if (toolUseContext.renderedSystemPrompt) {\n        forkParentSystemPrompt = toolUseContext.renderedSystemPrompt\n      } else {\n        // Fallback: recompute. May diverge from parent's cached bytes if\n        // GrowthBook state changed between parent turn-start and fork spawn.\n        const mainThreadAgentDefinition = appState.agent\n          ? appState.agentDefinitions.activeAgents.find(\n              a => a.agentType === appState.agent,\n            )\n          : undefined\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n        const defaultSystemPrompt = await getSystemPrompt(\n          toolUseContext.options.tools,\n          toolUseContext.options.mainLoopModel,\n          additionalWorkingDirectories,\n          toolUseContext.options.mcpClients,\n        )\n        forkParentSystemPrompt = buildEffectiveSystemPrompt({\n          mainThreadAgentDefinition,\n          toolUseContext,\n          customSystemPrompt: toolUseContext.options.customSystemPrompt,\n          defaultSystemPrompt,\n          appendSystemPrompt: toolUseContext.options.appendSystemPrompt,\n        })\n      }\n      promptMessages = buildForkedMessages(prompt, assistantMessage)\n    } else {\n      try {\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n\n        // All agents have getSystemPrompt - pass toolUseContext to all\n        const agentPrompt = selectedAgent.getSystemPrompt({ toolUseContext })\n\n        // Log agent memory loaded event for subagents\n        if (selectedAgent.memory) {\n          logEvent('tengu_agent_memory_loaded', {\n            ...(\"external\" === 'ant' && {\n              agent_type:\n                selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            }),\n            scope:\n              selectedAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            source:\n              'subagent' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n\n        // Apply environment details enhancement\n        enhancedSystemPrompt = await enhanceSystemPromptWithEnvDetails(\n          [agentPrompt],\n          resolvedAgentModel,\n          additionalWorkingDirectories,\n        )\n      } catch (error) {\n        logForDebugging(\n          `Failed to get system prompt for agent ${selectedAgent.agentType}: ${errorMessage(error)}`,\n        )\n      }\n      promptMessages = [createUserMessage({ content: prompt })]\n    }\n\n    const metadata = {\n      prompt,\n      resolvedAgentModel,\n      isBuiltInAgent: isBuiltInAgent(selectedAgent),\n      startTime,\n      agentType: selectedAgent.agentType,\n      isAsync:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n    }\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n\n    // Fork subagent experiment: force ALL spawns async for a unified\n    // <task-notification> interaction model (not just fork spawns — all of them).\n    const forceAsync = isForkSubagentEnabled()\n\n    // Assistant mode: force all agents async. Synchronous subagents hold the\n    // main loop's turn open until they complete — the daemon's inputQueue\n    // backs up, and the first overdue cron catch-up on spawn becomes N\n    // serial subagent turns blocking all user input. Same gate as\n    // executeForkedSlashCommand's fire-and-forget path; the\n    // <task-notification> re-entry there is handled by the else branch\n    // below (registerAsyncAgentTask + notifyOnCompletion).\n    const assistantForceAsync = feature('KAIROS')\n      ? appState.kairosEnabled\n      : false\n\n    const shouldRunAsync =\n      (run_in_background === true ||\n        selectedAgent.background === true ||\n        isCoordinator ||\n        forceAsync ||\n        assistantForceAsync ||\n        (proactiveModule?.isProactiveActive() ?? false)) &&\n      !isBackgroundTasksDisabled\n    // Assemble the worker's tool pool independently of the parent's.\n    // Workers always get their tools from assembleToolPool with their own\n    // permission mode, so they aren't affected by the parent's tool\n    // restrictions. This is computed here so that runAgent doesn't need to\n    // import from tools.ts (which would create a circular dependency).\n    const workerPermissionContext = {\n      ...appState.toolPermissionContext,\n      mode: selectedAgent.permissionMode ?? 'acceptEdits',\n    }\n    const workerTools = assembleToolPool(\n      workerPermissionContext,\n      appState.mcp.tools,\n    )\n\n    // Create a stable agent ID early so it can be used for worktree slug\n    const earlyAgentId = createAgentId()\n\n    // Set up worktree isolation if requested\n    let worktreeInfo: {\n      worktreePath: string\n      worktreeBranch?: string\n      headCommit?: string\n      gitRoot?: string\n      hookBased?: boolean\n    } | null = null\n\n    if (effectiveIsolation === 'worktree') {\n      const slug = `agent-${earlyAgentId.slice(0, 8)}`\n      worktreeInfo = await createAgentWorktree(slug)\n    }\n\n    // Fork + worktree: inject a notice telling the child to translate paths\n    // and re-read potentially stale files. Appended after the fork directive\n    // so it appears as the most recent guidance the child sees.\n    if (isForkPath && worktreeInfo) {\n      promptMessages.push(\n        createUserMessage({\n          content: buildWorktreeNotice(getCwd(), worktreeInfo.worktreePath),\n        }),\n      )\n    }\n\n    const runAgentParams: Parameters<typeof runAgent>[0] = {\n      agentDefinition: selectedAgent,\n      promptMessages,\n      toolUseContext,\n      canUseTool,\n      isAsync: shouldRunAsync,\n      querySource:\n        toolUseContext.options.querySource ??\n        getQuerySourceForAgent(\n          selectedAgent.agentType,\n          isBuiltInAgent(selectedAgent),\n        ),\n      model: isForkPath ? undefined : model,\n      // Fork path: pass parent's system prompt AND parent's exact tool\n      // array (cache-identical prefix). workerTools is rebuilt under\n      // permissionMode 'bubble' which differs from the parent's mode, so\n      // its tool-def serialization diverges and breaks cache at the first\n      // differing tool. useExactTools also inherits the parent's\n      // thinkingConfig and isNonInteractiveSession (see runAgent.ts).\n      //\n      // Normal path: when a cwd override is in effect (worktree isolation\n      // or explicit cwd), skip the pre-built system prompt so runAgent's\n      // buildAgentSystemPrompt() runs inside wrapWithCwd where getCwd()\n      // returns the override path.\n      override: isForkPath\n        ? { systemPrompt: forkParentSystemPrompt }\n        : enhancedSystemPrompt && !worktreeInfo && !cwd\n          ? { systemPrompt: asSystemPrompt(enhancedSystemPrompt) }\n          : undefined,\n      availableTools: isForkPath ? toolUseContext.options.tools : workerTools,\n      // Pass parent conversation when the fork-subagent path needs full\n      // context. useExactTools inherits thinkingConfig (runAgent.ts:624).\n      forkContextMessages: isForkPath ? toolUseContext.messages : undefined,\n      ...(isForkPath && { useExactTools: true }),\n      worktreePath: worktreeInfo?.worktreePath,\n      description,\n    }\n\n    // Helper to wrap execution with a cwd override: explicit cwd arg (KAIROS)\n    // takes precedence over worktree isolation path.\n    const cwdOverridePath = cwd ?? worktreeInfo?.worktreePath\n    const wrapWithCwd = <T,>(fn: () => T): T =>\n      cwdOverridePath ? runWithCwdOverride(cwdOverridePath, fn) : fn()\n\n    // Helper to clean up worktree after agent completes\n    const cleanupWorktreeIfNeeded = async (): Promise<{\n      worktreePath?: string\n      worktreeBranch?: string\n    }> => {\n      if (!worktreeInfo) return {}\n      const { worktreePath, worktreeBranch, headCommit, gitRoot, hookBased } =\n        worktreeInfo\n      // Null out to make idempotent — guards against double-call if code\n      // between cleanup and end of try throws into catch\n      worktreeInfo = null\n      if (hookBased) {\n        // Hook-based worktrees are always kept since we can't detect VCS changes\n        logForDebugging(`Hook-based agent worktree kept at: ${worktreePath}`)\n        return { worktreePath }\n      }\n      if (headCommit) {\n        const changed = await hasWorktreeChanges(worktreePath, headCommit)\n        if (!changed) {\n          await removeAgentWorktree(worktreePath, worktreeBranch, gitRoot)\n          // Clear worktreePath from metadata so resume doesn't try to use\n          // a deleted directory. Fire-and-forget to match runAgent's\n          // writeAgentMetadata handling.\n          void writeAgentMetadata(asAgentId(earlyAgentId), {\n            agentType: selectedAgent.agentType,\n            description,\n          }).catch(_err =>\n            logForDebugging(`Failed to clear worktree metadata: ${_err}`),\n          )\n          return {}\n        }\n      }\n      logForDebugging(`Agent worktree has changes, keeping: ${worktreePath}`)\n      return { worktreePath, worktreeBranch }\n    }\n\n    if (shouldRunAsync) {\n      const asyncAgentId = earlyAgentId\n      const agentBackgroundTask = registerAsyncAgent({\n        agentId: asyncAgentId,\n        description,\n        prompt,\n        selectedAgent,\n        setAppState: rootSetAppState,\n        // Don't link to parent's abort controller -- background agents should\n        // survive when the user presses ESC to cancel the main thread.\n        // They are killed explicitly via chat:killAgents.\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      // Register name → agentId for SendMessage routing. Post-registerAsyncAgent\n      // so we don't leave a stale entry if spawn fails. Sync agents skipped —\n      // coordinator is blocked, so SendMessage routing doesn't apply.\n      if (name) {\n        rootSetAppState(prev => {\n          const next = new Map(prev.agentNameRegistry)\n          next.set(name, asAgentId(asyncAgentId))\n          return { ...prev, agentNameRegistry: next }\n        })\n      }\n\n      // Wrap async agent execution in agent context for analytics attribution\n      const asyncAgentContext = {\n        agentId: asyncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Workload propagation: handlePromptSubmit wraps the entire turn in\n      // runWithWorkload (AsyncLocalStorage). ALS context is captured at\n      // invocation time — when this `void` fires — and survives every await\n      // inside. No capture/restore needed; the detached closure sees the\n      // parent turn's workload automatically, isolated from its finally.\n      void runWithAgentContext(asyncAgentContext, () =>\n        wrapWithCwd(() =>\n          runAsyncAgentLifecycle({\n            taskId: agentBackgroundTask.agentId,\n            abortController: agentBackgroundTask.abortController!,\n            makeStream: onCacheSafeParams =>\n              runAgent({\n                ...runAgentParams,\n                override: {\n                  ...runAgentParams.override,\n                  agentId: asAgentId(agentBackgroundTask.agentId),\n                  abortController: agentBackgroundTask.abortController!,\n                },\n                onCacheSafeParams,\n              }),\n            metadata,\n            description,\n            toolUseContext,\n            rootSetAppState,\n            agentIdForCleanup: asyncAgentId,\n            enableSummarization:\n              isCoordinator ||\n              isForkSubagentEnabled() ||\n              getSdkAgentProgressSummariesEnabled(),\n            getWorktreeResult: cleanupWorktreeIfNeeded,\n          }),\n        ),\n      )\n\n      const canReadOutputFile = toolUseContext.options.tools.some(\n        t =>\n          toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n          toolMatchesName(t, BASH_TOOL_NAME),\n      )\n      return {\n        data: {\n          isAsync: true as const,\n          status: 'async_launched' as const,\n          agentId: agentBackgroundTask.agentId,\n          description: description,\n          prompt: prompt,\n          outputFile: getTaskOutputPath(agentBackgroundTask.agentId),\n          canReadOutputFile,\n        },\n      }\n    } else {\n      // Create an explicit agentId for sync agents\n      const syncAgentId = asAgentId(earlyAgentId)\n\n      // Set up agent context for sync execution (for analytics attribution)\n      const syncAgentContext = {\n        agentId: syncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Wrap entire sync agent execution in context for analytics attribution\n      // and optionally in a worktree cwd override for filesystem isolation\n      return runWithAgentContext(syncAgentContext, () =>\n        wrapWithCwd(async () => {\n          const agentMessages: MessageType[] = []\n          const agentStartTime = Date.now()\n          const syncTracker = createProgressTracker()\n          const syncResolveActivity = createActivityDescriptionResolver(\n            toolUseContext.options.tools,\n          )\n\n          // Yield initial progress message to carry metadata (prompt)\n          if (promptMessages.length > 0) {\n            const normalizedPromptMessages = normalizeMessages(promptMessages)\n            const normalizedFirstMessage = normalizedPromptMessages.find(\n              (m): m is NormalizedUserMessage => m.type === 'user',\n            )\n            if (\n              normalizedFirstMessage &&\n              normalizedFirstMessage.type === 'user' &&\n              onProgress\n            ) {\n              onProgress({\n                toolUseID: `agent_${assistantMessage.message.id}`,\n                data: {\n                  message: normalizedFirstMessage,\n                  type: 'agent_progress',\n                  prompt,\n                  agentId: syncAgentId,\n                },\n              })\n            }\n          }\n\n          // Register as foreground task immediately so it can be backgrounded at any time\n          // Skip registration if background tasks are disabled\n          let foregroundTaskId: string | undefined\n          // Create the background race promise once outside the loop — otherwise\n          // each iteration adds a new .then() reaction to the same pending\n          // promise, accumulating callbacks for the lifetime of the agent.\n          let backgroundPromise: Promise<{ type: 'background' }> | undefined\n          let cancelAutoBackground: (() => void) | undefined\n          if (!isBackgroundTasksDisabled) {\n            const registration = registerAgentForeground({\n              agentId: syncAgentId,\n              description,\n              prompt,\n              selectedAgent,\n              setAppState: rootSetAppState,\n              toolUseId: toolUseContext.toolUseId,\n              autoBackgroundMs: getAutoBackgroundMs() || undefined,\n            })\n            foregroundTaskId = registration.taskId\n            backgroundPromise = registration.backgroundSignal.then(() => ({\n              type: 'background' as const,\n            }))\n            cancelAutoBackground = registration.cancelAutoBackground\n          }\n\n          // Track if we've shown the background hint UI\n          let backgroundHintShown = false\n          // Track if the agent was backgrounded (cleanup handled by backgrounded finally)\n          let wasBackgrounded = false\n          // Per-scope stop function — NOT shared with the backgrounded closure.\n          // idempotent: startAgentSummarization's stop() checks `stopped` flag.\n          let stopForegroundSummarization: (() => void) | undefined\n          // const capture for sound type narrowing inside the callback below\n          const summaryTaskId = foregroundTaskId\n\n          // Get async iterator for the agent\n          const agentIterator = runAgent({\n            ...runAgentParams,\n            override: {\n              ...runAgentParams.override,\n              agentId: syncAgentId,\n            },\n            onCacheSafeParams:\n              summaryTaskId && getSdkAgentProgressSummariesEnabled()\n                ? (params: CacheSafeParams) => {\n                    const { stop } = startAgentSummarization(\n                      summaryTaskId,\n                      syncAgentId,\n                      params,\n                      rootSetAppState,\n                    )\n                    stopForegroundSummarization = stop\n                  }\n                : undefined,\n          })[Symbol.asyncIterator]()\n\n          // Track if an error occurred during iteration\n          let syncAgentError: Error | undefined\n          let wasAborted = false\n          let worktreeResult: {\n            worktreePath?: string\n            worktreeBranch?: string\n          } = {}\n\n          try {\n            while (true) {\n              const elapsed = Date.now() - agentStartTime\n\n              // Show background hint after threshold (but task is already registered)\n              // Skip if background tasks are disabled\n              if (\n                !isBackgroundTasksDisabled &&\n                !backgroundHintShown &&\n                elapsed >= PROGRESS_THRESHOLD_MS &&\n                toolUseContext.setToolJSX\n              ) {\n                backgroundHintShown = true\n                toolUseContext.setToolJSX({\n                  jsx: <BackgroundHint />,\n                  shouldHidePromptInput: false,\n                  shouldContinueAnimation: true,\n                  showSpinner: true,\n                })\n              }\n\n              // Race between next message and background signal\n              // If background tasks are disabled, just await the next message directly\n              const nextMessagePromise = agentIterator.next()\n              const raceResult = backgroundPromise\n                ? await Promise.race([\n                    nextMessagePromise.then(r => ({\n                      type: 'message' as const,\n                      result: r,\n                    })),\n                    backgroundPromise,\n                  ])\n                : {\n                    type: 'message' as const,\n                    result: await nextMessagePromise,\n                  }\n\n              // Check if we were backgrounded via backgroundAll()\n              // foregroundTaskId is guaranteed to be defined if raceResult.type is 'background'\n              // because backgroundPromise is only defined when foregroundTaskId is defined\n              if (raceResult.type === 'background' && foregroundTaskId) {\n                const appState = toolUseContext.getAppState()\n                const task = appState.tasks[foregroundTaskId]\n                if (isLocalAgentTask(task) && task.isBackgrounded) {\n                  // Capture the taskId for use in the async callback\n                  const backgroundedTaskId = foregroundTaskId\n                  wasBackgrounded = true\n                  // Stop foreground summarization; the backgrounded closure\n                  // below owns its own independent stop function.\n                  stopForegroundSummarization?.()\n\n                  // Workload: inherited via ALS at `void` invocation time,\n                  // same as the async-from-start path above.\n                  // Continue agent in background and return async result\n                  void runWithAgentContext(syncAgentContext, async () => {\n                    let stopBackgroundedSummarization: (() => void) | undefined\n                    try {\n                      // Clean up the foreground iterator so its finally block runs\n                      // (releases MCP connections, session hooks, prompt cache tracking, etc.)\n                      // Timeout prevents blocking if MCP server cleanup hangs.\n                      // .catch() prevents unhandled rejection if timeout wins the race.\n                      await Promise.race([\n                        agentIterator.return(undefined).catch(() => {}),\n                        sleep(1000),\n                      ])\n                      // Initialize progress tracking from existing messages\n                      const tracker = createProgressTracker()\n                      const resolveActivity2 =\n                        createActivityDescriptionResolver(\n                          toolUseContext.options.tools,\n                        )\n                      for (const existingMsg of agentMessages) {\n                        updateProgressFromMessage(\n                          tracker,\n                          existingMsg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                      }\n                      for await (const msg of runAgent({\n                        ...runAgentParams,\n                        isAsync: true, // Agent is now running in background\n                        override: {\n                          ...runAgentParams.override,\n                          agentId: asAgentId(backgroundedTaskId),\n                          abortController: task.abortController,\n                        },\n                        onCacheSafeParams: getSdkAgentProgressSummariesEnabled()\n                          ? (params: CacheSafeParams) => {\n                              const { stop } = startAgentSummarization(\n                                backgroundedTaskId,\n                                asAgentId(backgroundedTaskId),\n                                params,\n                                rootSetAppState,\n                              )\n                              stopBackgroundedSummarization = stop\n                            }\n                          : undefined,\n                      })) {\n                        agentMessages.push(msg)\n\n                        // Track progress for backgrounded agents\n                        updateProgressFromMessage(\n                          tracker,\n                          msg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                        updateAsyncAgentProgress(\n                          backgroundedTaskId,\n                          getProgressUpdate(tracker),\n                          rootSetAppState,\n                        )\n\n                        const lastToolName = getLastToolUseName(msg)\n                        if (lastToolName) {\n                          emitTaskProgress(\n                            tracker,\n                            backgroundedTaskId,\n                            toolUseContext.toolUseId,\n                            description,\n                            startTime,\n                            lastToolName,\n                          )\n                        }\n                      }\n                      const agentResult = finalizeAgentTool(\n                        agentMessages,\n                        backgroundedTaskId,\n                        metadata,\n                      )\n\n                      // Mark task completed FIRST so TaskOutput(block=true)\n                      // unblocks immediately. classifyHandoffIfNeeded and\n                      // cleanupWorktreeIfNeeded can hang — they must not gate\n                      // the status transition (gh-20236).\n                      completeAsyncAgent(agentResult, rootSetAppState)\n\n                      // Extract text from agent result content for the notification\n                      let finalMessage = extractTextContent(\n                        agentResult.content,\n                        '\\n',\n                      )\n\n                      if (feature('TRANSCRIPT_CLASSIFIER')) {\n                        const backgroundedAppState =\n                          toolUseContext.getAppState()\n                        const handoffWarning = await classifyHandoffIfNeeded({\n                          agentMessages,\n                          tools: toolUseContext.options.tools,\n                          toolPermissionContext:\n                            backgroundedAppState.toolPermissionContext,\n                          abortSignal: task.abortController!.signal,\n                          subagentType: selectedAgent.agentType,\n                          totalToolUseCount: agentResult.totalToolUseCount,\n                        })\n                        if (handoffWarning) {\n                          finalMessage = `${handoffWarning}\\n\\n${finalMessage}`\n                        }\n                      }\n\n                      // Clean up worktree before notification so we can include it\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'completed',\n                        setAppState: rootSetAppState,\n                        finalMessage,\n                        usage: {\n                          totalTokens: getTokenCountFromTracker(tracker),\n                          toolUses: agentResult.totalToolUseCount,\n                          durationMs: agentResult.totalDurationMs,\n                        },\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } catch (error) {\n                      if (error instanceof AbortError) {\n                        // Transition status BEFORE worktree cleanup so\n                        // TaskOutput unblocks even if git hangs (gh-20236).\n                        killAsyncAgent(backgroundedTaskId, rootSetAppState)\n                        logEvent('tengu_agent_tool_terminated', {\n                          agent_type:\n                            metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          model:\n                            metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          duration_ms: Date.now() - metadata.startTime,\n                          is_async: true,\n                          is_built_in_agent: metadata.isBuiltInAgent,\n                          reason:\n                            'user_cancel_background' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                        })\n                        const worktreeResult = await cleanupWorktreeIfNeeded()\n                        const partialResult =\n                          extractPartialResult(agentMessages)\n                        enqueueAgentNotification({\n                          taskId: backgroundedTaskId,\n                          description,\n                          status: 'killed',\n                          setAppState: rootSetAppState,\n                          toolUseId: toolUseContext.toolUseId,\n                          finalMessage: partialResult,\n                          ...worktreeResult,\n                        })\n                        return\n                      }\n                      const errMsg = errorMessage(error)\n                      failAsyncAgent(\n                        backgroundedTaskId,\n                        errMsg,\n                        rootSetAppState,\n                      )\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'failed',\n                        error: errMsg,\n                        setAppState: rootSetAppState,\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } finally {\n                      stopBackgroundedSummarization?.()\n                      clearInvokedSkillsForAgent(syncAgentId)\n                      clearDumpState(syncAgentId)\n                      // Note: worktree cleanup is done before enqueueAgentNotification\n                      // in both try and catch paths so we can include worktree info\n                    }\n                  })\n\n                  // Return async_launched result immediately\n                  const canReadOutputFile = toolUseContext.options.tools.some(\n                    t =>\n                      toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n                      toolMatchesName(t, BASH_TOOL_NAME),\n                  )\n                  return {\n                    data: {\n                      isAsync: true as const,\n                      status: 'async_launched' as const,\n                      agentId: backgroundedTaskId,\n                      description: description,\n                      prompt: prompt,\n                      outputFile: getTaskOutputPath(backgroundedTaskId),\n                      canReadOutputFile,\n                    },\n                  }\n                }\n              }\n\n              // Process the message from the race result\n              if (raceResult.type !== 'message') {\n                // This shouldn't happen - background case handled above\n                continue\n              }\n              const { result } = raceResult\n              if (result.done) break\n              const message = result.value\n\n              agentMessages.push(message)\n\n              // Emit task_progress for the VS Code subagent panel\n              updateProgressFromMessage(\n                syncTracker,\n                message,\n                syncResolveActivity,\n                toolUseContext.options.tools,\n              )\n              if (foregroundTaskId) {\n                const lastToolName = getLastToolUseName(message)\n                if (lastToolName) {\n                  emitTaskProgress(\n                    syncTracker,\n                    foregroundTaskId,\n                    toolUseContext.toolUseId,\n                    description,\n                    agentStartTime,\n                    lastToolName,\n                  )\n                  // Keep AppState task.progress in sync when SDK summaries are\n                  // enabled, so updateAgentSummary reads correct token/tool counts\n                  // instead of zeros.\n                  if (getSdkAgentProgressSummariesEnabled()) {\n                    updateAsyncAgentProgress(\n                      foregroundTaskId,\n                      getProgressUpdate(syncTracker),\n                      rootSetAppState,\n                    )\n                  }\n                }\n              }\n\n              // Forward bash_progress events from sub-agent to parent so the SDK\n              // receives tool_progress events just as it does for the main agent.\n              if (\n                message.type === 'progress' &&\n                (message.data.type === 'bash_progress' ||\n                  message.data.type === 'powershell_progress') &&\n                onProgress\n              ) {\n                onProgress({\n                  toolUseID: message.toolUseID,\n                  data: message.data,\n                })\n              }\n\n              if (message.type !== 'assistant' && message.type !== 'user') {\n                continue\n              }\n\n              // Increment token count in spinner for assistant messages\n              // Subagent streaming events are filtered out in runAgent.ts, so we\n              // need to count tokens from completed messages here\n              if (message.type === 'assistant') {\n                const contentLength = getAssistantMessageContentLength(message)\n                if (contentLength > 0) {\n                  toolUseContext.setResponseLength(len => len + contentLength)\n                }\n              }\n\n              const normalizedNew = normalizeMessages([message])\n              for (const m of normalizedNew) {\n                for (const content of m.message.content) {\n                  if (\n                    content.type !== 'tool_use' &&\n                    content.type !== 'tool_result'\n                  ) {\n                    continue\n                  }\n\n                  // Forward progress updates\n                  if (onProgress) {\n                    onProgress({\n                      toolUseID: `agent_${assistantMessage.message.id}`,\n                      data: {\n                        message: m,\n                        type: 'agent_progress',\n                        // prompt only needed on first progress message (UI.tsx:624\n                        // reads progressMessages[0]). Omit here to avoid duplication.\n                        prompt: '',\n                        agentId: syncAgentId,\n                      },\n                    })\n                  }\n                }\n              }\n            }\n          } catch (error) {\n            // Handle errors from the sync agent loop\n            // AbortError should be re-thrown for proper interruption handling\n            if (error instanceof AbortError) {\n              wasAborted = true\n              logEvent('tengu_agent_tool_terminated', {\n                agent_type:\n                  metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                model:\n                  metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                duration_ms: Date.now() - metadata.startTime,\n                is_async: false,\n                is_built_in_agent: metadata.isBuiltInAgent,\n                reason:\n                  'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              })\n              throw error\n            }\n\n            // Log the error for debugging\n            logForDebugging(`Sync agent error: ${errorMessage(error)}`, {\n              level: 'error',\n            })\n\n            // Store the error to handle after cleanup\n            syncAgentError = toError(error)\n          } finally {\n            // Clear the background hint UI\n            if (toolUseContext.setToolJSX) {\n              toolUseContext.setToolJSX(null)\n            }\n\n            // Stop foreground summarization. Idempotent — if already stopped at\n            // the backgrounding transition, this is a no-op. The backgrounded\n            // closure owns a separate stop function (stopBackgroundedSummarization).\n            stopForegroundSummarization?.()\n\n            // Unregister foreground task if agent completed without being backgrounded\n            if (foregroundTaskId) {\n              unregisterAgentForeground(foregroundTaskId, rootSetAppState)\n              // Notify SDK consumers (e.g. VS Code subagent panel) that this\n              // foreground agent is done. Goes through drainSdkEvents() — does\n              // NOT trigger the print.ts XML task_notification parser or the LLM loop.\n              if (!wasBackgrounded) {\n                const progress = getProgressUpdate(syncTracker)\n                enqueueSdkEvent({\n                  type: 'system',\n                  subtype: 'task_notification',\n                  task_id: foregroundTaskId,\n                  tool_use_id: toolUseContext.toolUseId,\n                  status: syncAgentError\n                    ? 'failed'\n                    : wasAborted\n                      ? 'stopped'\n                      : 'completed',\n                  output_file: '',\n                  summary: description,\n                  usage: {\n                    total_tokens: progress.tokenCount,\n                    tool_uses: progress.toolUseCount,\n                    duration_ms: Date.now() - agentStartTime,\n                  },\n                })\n              }\n            }\n\n            // Clean up scoped skills so they don't accumulate in the global map\n            clearInvokedSkillsForAgent(syncAgentId)\n\n            // Clean up dumpState entry for this agent to prevent unbounded growth\n            // Skip if backgrounded — the backgrounded agent's finally handles cleanup\n            if (!wasBackgrounded) {\n              clearDumpState(syncAgentId)\n            }\n\n            // Cancel auto-background timer if agent completed before it fired\n            cancelAutoBackground?.()\n\n            // Clean up worktree if applicable (in finally to handle abort/error paths)\n            // Skip if backgrounded — the background continuation is still running in it\n            if (!wasBackgrounded) {\n              worktreeResult = await cleanupWorktreeIfNeeded()\n            }\n          }\n\n          // Re-throw abort errors\n          // TODO: Find a cleaner way to express this\n          const lastMessage = agentMessages.findLast(\n            _ => _.type !== 'system' && _.type !== 'progress',\n          )\n          if (lastMessage && isSyntheticMessage(lastMessage)) {\n            logEvent('tengu_agent_tool_terminated', {\n              agent_type:\n                metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              model:\n                metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              duration_ms: Date.now() - metadata.startTime,\n              is_async: false,\n              is_built_in_agent: metadata.isBuiltInAgent,\n              reason:\n                'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            throw new AbortError()\n          }\n\n          // If an error occurred during iteration, try to return a result with\n          // whatever messages we have. If we have no assistant messages,\n          // re-throw the error so it's properly handled by the tool framework.\n          if (syncAgentError) {\n            // Check if we have any assistant messages to return\n            const hasAssistantMessages = agentMessages.some(\n              msg => msg.type === 'assistant',\n            )\n\n            if (!hasAssistantMessages) {\n              // No messages collected, re-throw the error\n              throw syncAgentError\n            }\n\n            // We have some messages, try to finalize and return them\n            // This allows the parent agent to see partial progress even after an error\n            logForDebugging(\n              `Sync agent recovering from error with ${agentMessages.length} messages`,\n            )\n          }\n\n          const agentResult = finalizeAgentTool(\n            agentMessages,\n            syncAgentId,\n            metadata,\n          )\n\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            const currentAppState = toolUseContext.getAppState()\n            const handoffWarning = await classifyHandoffIfNeeded({\n              agentMessages,\n              tools: toolUseContext.options.tools,\n              toolPermissionContext: currentAppState.toolPermissionContext,\n              abortSignal: toolUseContext.abortController.signal,\n              subagentType: selectedAgent.agentType,\n              totalToolUseCount: agentResult.totalToolUseCount,\n            })\n            if (handoffWarning) {\n              agentResult.content = [\n                { type: 'text' as const, text: handoffWarning },\n                ...agentResult.content,\n              ]\n            }\n          }\n\n          return {\n            data: {\n              status: 'completed' as const,\n              prompt,\n              ...agentResult,\n              ...worktreeResult,\n            },\n          }\n        }),\n      )\n    }\n  },\n  isReadOnly() {\n    return true // delegates permission checks to its underlying tools\n  },\n  toAutoClassifierInput(input) {\n    const i = input as AgentToolInput\n    const tags = [\n      i.subagent_type,\n      i.mode ? `mode=${i.mode}` : undefined,\n    ].filter((t): t is string => t !== undefined)\n    const prefix = tags.length > 0 ? `(${tags.join(', ')}): ` : ': '\n    return `${prefix}${i.prompt}`\n  },\n  isConcurrencySafe() {\n    return true\n  },\n  userFacingName,\n  userFacingNameBackgroundColor,\n  getActivityDescription(input) {\n    return input?.description ?? 'Running task'\n  },\n  async checkPermissions(input, context): Promise<PermissionResult> {\n    const appState = context.getAppState()\n\n    // Only route through auto mode classifier when in auto mode\n    // In all other modes, auto-approve sub-agent generation\n    // Note: \"external\" === 'ant' guard enables dead code elimination for external builds\n    if (\n      \"external\" === 'ant' &&\n      appState.toolPermissionContext.mode === 'auto'\n    ) {\n      return {\n        behavior: 'passthrough',\n        message: 'Agent tool requires permission to spawn sub-agents.',\n      }\n    }\n\n    return { behavior: 'allow', updatedInput: input }\n  },\n  mapToolResultToToolResultBlockParam(data, toolUseID) {\n    // Multi-agent spawn result\n    const internalData = data as InternalOutput\n    if (\n      typeof internalData === 'object' &&\n      internalData !== null &&\n      'status' in internalData &&\n      internalData.status === 'teammate_spawned'\n    ) {\n      const spawnData = internalData as TeammateSpawnedOutput\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Spawned successfully.\nagent_id: ${spawnData.teammate_id}\nname: ${spawnData.name}\nteam_name: ${spawnData.team_name}\nThe agent is now running and will receive instructions via mailbox.`,\n          },\n        ],\n      }\n    }\n    if ('status' in internalData && internalData.status === 'remote_launched') {\n      const r = internalData\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Remote agent launched in CCR.\\ntaskId: ${r.taskId}\\nsession_url: ${r.sessionUrl}\\noutput_file: ${r.outputFile}\\nThe agent is running remotely. You will be notified automatically when it completes.\\nBriefly tell the user what you launched and end your response.`,\n          },\n        ],\n      }\n    }\n    if (data.status === 'async_launched') {\n      const prefix = `Async agent launched successfully.\\nagentId: ${data.agentId} (internal ID - do not mention to user. Use SendMessage with to: '${data.agentId}' to continue this agent.)\\nThe agent is working in the background. You will be notified automatically when it completes.`\n      const instructions = data.canReadOutputFile\n        ? `Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.\\noutput_file: ${data.outputFile}\\nIf asked, you can check progress before completion by using ${FILE_READ_TOOL_NAME} or ${BASH_TOOL_NAME} tail on the output file.`\n        : `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`\n      const text = `${prefix}\\n${instructions}`\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text,\n          },\n        ],\n      }\n    }\n    if (data.status === 'completed') {\n      const worktreeData = data as Record<string, unknown>\n      const worktreeInfoText = worktreeData.worktreePath\n        ? `\\nworktreePath: ${worktreeData.worktreePath}\\nworktreeBranch: ${worktreeData.worktreeBranch}`\n        : ''\n      // If the subagent completes with no content, the tool_result is just the\n      // agentId/usage trailer below — a metadata-only block at the prompt tail.\n      // Some models read that as \"nothing to act on\" and end their turn\n      // immediately. Say so explicitly so the parent has something to react to.\n      const contentOrMarker =\n        data.content.length > 0\n          ? data.content\n          : [\n              {\n                type: 'text' as const,\n                text: '(Subagent completed but returned no output.)',\n              },\n            ]\n      // One-shot built-ins (Explore, Plan) are never continued via SendMessage\n      // — the agentId hint and <usage> block are dead weight (~135 chars ×\n      // 34M Explore runs/week ≈ 1-2 Gtok/week). Telemetry doesn't parse this\n      // block (it uses logEvent in finalizeAgentTool), so dropping is safe.\n      // agentType is optional for resume compat — missing means show trailer.\n      if (\n        data.agentType &&\n        ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) &&\n        !worktreeInfoText\n      ) {\n        return {\n          tool_use_id: toolUseID,\n          type: 'tool_result',\n          content: contentOrMarker,\n        }\n      }\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          ...contentOrMarker,\n          {\n            type: 'text',\n            text: `agentId: ${data.agentId} (use SendMessage with to: '${data.agentId}' to continue this agent)${worktreeInfoText}\n<usage>total_tokens: ${data.totalTokens}\ntool_uses: ${data.totalToolUseCount}\nduration_ms: ${data.totalDurationMs}</usage>`,\n          },\n        ],\n      }\n    }\n    data satisfies never\n    throw new Error(\n      `Unexpected agent tool result status: ${(data as { status: string }).status}`,\n    )\n  },\n  renderToolResultMessage,\n  renderToolUseMessage,\n  renderToolUseTag,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseErrorMessage,\n  renderGroupedToolUse: renderGroupedAgentToolUse,\n} satisfies ToolDef<InputSchema, Output, Progress>)\n\nfunction resolveTeamName(\n  input: { team_name?: string },\n  appState: { teamContext?: { teamName: string } },\n): string | undefined {\n  if (!isAgentSwarmsEnabled()) return undefined\n  return input.team_name || appState.teamContext?.teamName\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","buildTool","ToolDef","toolMatchesName","Message","MessageType","NormalizedUserMessage","getQuerySourceForAgent","z","clearInvokedSkillsForAgent","getSdkAgentProgressSummariesEnabled","enhanceSystemPromptWithEnvDetails","getSystemPrompt","isCoordinatorMode","startAgentSummarization","getFeatureValue_CACHED_MAY_BE_STALE","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearDumpState","completeAgentTask","completeAsyncAgent","createActivityDescriptionResolver","createProgressTracker","enqueueAgentNotification","failAgentTask","failAsyncAgent","getProgressUpdate","getTokenCountFromTracker","isLocalAgentTask","killAsyncAgent","registerAgentForeground","registerAsyncAgent","unregisterAgentForeground","updateAgentProgress","updateAsyncAgentProgress","updateProgressFromMessage","checkRemoteAgentEligibility","formatPreconditionError","getRemoteTaskSessionUrl","registerRemoteAgentTask","assembleToolPool","asAgentId","runWithAgentContext","isAgentSwarmsEnabled","getCwd","runWithCwdOverride","logForDebugging","isEnvTruthy","AbortError","errorMessage","toError","CacheSafeParams","lazySchema","createUserMessage","extractTextContent","isSyntheticMessage","normalizeMessages","getAgentModel","permissionModeSchema","PermissionResult","filterDeniedAgents","getDenyRuleForAgent","enqueueSdkEvent","writeAgentMetadata","sleep","buildEffectiveSystemPrompt","asSystemPrompt","getTaskOutputPath","getParentSessionId","isTeammate","isInProcessTeammate","teleportToRemote","getAssistantMessageContentLength","createAgentId","createAgentWorktree","hasWorktreeChanges","removeAgentWorktree","BASH_TOOL_NAME","BackgroundHint","FILE_READ_TOOL_NAME","spawnTeammate","setAgentColor","agentToolResultSchema","classifyHandoffIfNeeded","emitTaskProgress","extractPartialResult","finalizeAgentTool","getLastToolUseName","runAsyncAgentLifecycle","GENERAL_PURPOSE_AGENT","AGENT_TOOL_NAME","LEGACY_AGENT_TOOL_NAME","ONE_SHOT_BUILTIN_AGENT_TYPES","buildForkedMessages","buildWorktreeNotice","FORK_AGENT","isForkSubagentEnabled","isInForkChild","AgentDefinition","filterAgentsByMcpRequirements","hasRequiredMcpServers","isBuiltInAgent","getPrompt","runAgent","renderGroupedAgentToolUse","renderToolResultMessage","renderToolUseErrorMessage","renderToolUseMessage","renderToolUseProgressMessage","renderToolUseRejectedMessage","renderToolUseTag","userFacingName","userFacingNameBackgroundColor","proactiveModule","require","PROGRESS_THRESHOLD_MS","isBackgroundTasksDisabled","process","env","CLAUDE_CODE_DISABLE_BACKGROUND_TASKS","getAutoBackgroundMs","CLAUDE_AUTO_BACKGROUND_TASKS","baseInputSchema","object","description","string","describe","prompt","subagent_type","optional","model","enum","run_in_background","boolean","fullInputSchema","multiAgentInputSchema","name","team_name","mode","merge","extend","isolation","cwd","inputSchema","schema","omit","InputSchema","ReturnType","AgentToolInput","infer","outputSchema","syncOutputSchema","status","literal","asyncOutputSchema","agentId","outputFile","canReadOutputFile","union","OutputSchema","Output","input","TeammateSpawnedOutput","teammate_id","agent_id","agent_type","color","tmux_session_name","tmux_window_name","tmux_pane_id","is_splitpane","plan_mode_required","RemoteLaunchedOutput","taskId","sessionUrl","InternalOutput","AgentToolProgress","ShellProgress","Progress","AgentTool","agents","tools","getToolPermissionContext","allowedAgentTypes","toolPermissionContext","mcpServersWithTools","tool","startsWith","parts","split","serverName","includes","push","agentsWithMcpRequirementsMet","filteredAgents","isCoordinator","CLAUDE_CODE_COORDINATOR_MODE","searchHint","aliases","maxResultSizeChars","call","modelParam","spawnMode","toolUseContext","canUseTool","assistantMessage","onProgress","startTime","Date","now","undefined","appState","getAppState","permissionMode","rootSetAppState","setAppStateForTasks","setAppState","Error","teamName","resolveTeamName","agentDef","options","agentDefinitions","activeAgents","find","a","agentType","result","use_splitpane","invokingRequestId","requestId","spawnResult","const","data","effectiveType","isForkPath","selectedAgent","querySource","messages","allAgents","filter","found","agent","agentExistsButDenied","denyRule","source","map","join","background","requiredMcpServers","length","hasPendingRequiredServers","mcp","clients","some","c","type","pattern","toLowerCase","currentAppState","MAX_WAIT_MS","POLL_INTERVAL_MS","deadline","hasFailedRequiredServer","stillPending","serversWithTools","missing","server","resolvedAgentModel","mainLoopModel","is_built_in_agent","is_resume","is_async","is_fork","effectiveIsolation","eligibility","eligible","reasons","errors","bundleFailHint","session","initialMessage","signal","abortController","onBundleFail","msg","sessionId","remoteTaskType","id","title","command","context","toolUseId","remoteResult","enhancedSystemPrompt","forkParentSystemPrompt","promptMessages","renderedSystemPrompt","mainThreadAgentDefinition","additionalWorkingDirectories","Array","from","keys","defaultSystemPrompt","mcpClients","customSystemPrompt","appendSystemPrompt","agentPrompt","memory","scope","error","content","metadata","isAsync","forceAsync","assistantForceAsync","kairosEnabled","shouldRunAsync","isProactiveActive","workerPermissionContext","workerTools","earlyAgentId","worktreeInfo","worktreePath","worktreeBranch","headCommit","gitRoot","hookBased","slug","slice","runAgentParams","Parameters","agentDefinition","override","systemPrompt","availableTools","forkContextMessages","useExactTools","cwdOverridePath","wrapWithCwd","fn","T","cleanupWorktreeIfNeeded","Promise","changed","catch","_err","asyncAgentId","agentBackgroundTask","prev","next","Map","agentNameRegistry","set","asyncAgentContext","parentSessionId","subagentName","isBuiltIn","invocationKind","invocationEmitted","makeStream","onCacheSafeParams","agentIdForCleanup","enableSummarization","getWorktreeResult","t","syncAgentId","syncAgentContext","agentMessages","agentStartTime","syncTracker","syncResolveActivity","normalizedPromptMessages","normalizedFirstMessage","m","toolUseID","message","foregroundTaskId","backgroundPromise","cancelAutoBackground","registration","autoBackgroundMs","backgroundSignal","then","backgroundHintShown","wasBackgrounded","stopForegroundSummarization","summaryTaskId","agentIterator","params","stop","Symbol","asyncIterator","syncAgentError","wasAborted","worktreeResult","elapsed","setToolJSX","jsx","shouldHidePromptInput","shouldContinueAnimation","showSpinner","nextMessagePromise","raceResult","race","r","task","tasks","isBackgrounded","backgroundedTaskId","stopBackgroundedSummarization","return","tracker","resolveActivity2","existingMsg","lastToolName","agentResult","finalMessage","backgroundedAppState","handoffWarning","abortSignal","subagentType","totalToolUseCount","usage","totalTokens","toolUses","durationMs","totalDurationMs","duration_ms","reason","partialResult","errMsg","done","value","contentLength","setResponseLength","len","normalizedNew","level","progress","subtype","task_id","tool_use_id","output_file","summary","total_tokens","tokenCount","tool_uses","toolUseCount","lastMessage","findLast","_","hasAssistantMessages","text","isReadOnly","toAutoClassifierInput","i","tags","prefix","isConcurrencySafe","getActivityDescription","checkPermissions","behavior","updatedInput","mapToolResultToToolResultBlockParam","internalData","spawnData","instructions","worktreeData","Record","worktreeInfoText","contentOrMarker","has","renderGroupedToolUse","teamContext"],"sources":["AgentTool.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { buildTool, type ToolDef, toolMatchesName } from 'src/Tool.js'\nimport type {\n  Message as MessageType,\n  NormalizedUserMessage,\n} from 'src/types/message.js'\nimport { getQuerySourceForAgent } from 'src/utils/promptCategory.js'\nimport { z } from 'zod/v4'\nimport {\n  clearInvokedSkillsForAgent,\n  getSdkAgentProgressSummariesEnabled,\n} from '../../bootstrap/state.js'\nimport {\n  enhanceSystemPromptWithEnvDetails,\n  getSystemPrompt,\n} from '../../constants/prompts.js'\nimport { isCoordinatorMode } from '../../coordinator/coordinatorMode.js'\nimport { startAgentSummarization } from '../../services/AgentSummary/agentSummary.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { clearDumpState } from '../../services/api/dumpPrompts.js'\nimport {\n  completeAgentTask as completeAsyncAgent,\n  createActivityDescriptionResolver,\n  createProgressTracker,\n  enqueueAgentNotification,\n  failAgentTask as failAsyncAgent,\n  getProgressUpdate,\n  getTokenCountFromTracker,\n  isLocalAgentTask,\n  killAsyncAgent,\n  registerAgentForeground,\n  registerAsyncAgent,\n  unregisterAgentForeground,\n  updateAgentProgress as updateAsyncAgentProgress,\n  updateProgressFromMessage,\n} from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport {\n  checkRemoteAgentEligibility,\n  formatPreconditionError,\n  getRemoteTaskSessionUrl,\n  registerRemoteAgentTask,\n} from '../../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport { assembleToolPool } from '../../tools.js'\nimport { asAgentId } from '../../types/ids.js'\nimport { runWithAgentContext } from '../../utils/agentContext.js'\nimport { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'\nimport { getCwd, runWithCwdOverride } from '../../utils/cwd.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\nimport { AbortError, errorMessage, toError } from '../../utils/errors.js'\nimport type { CacheSafeParams } from '../../utils/forkedAgent.js'\nimport { lazySchema } from '../../utils/lazySchema.js'\nimport {\n  createUserMessage,\n  extractTextContent,\n  isSyntheticMessage,\n  normalizeMessages,\n} from '../../utils/messages.js'\nimport { getAgentModel } from '../../utils/model/agent.js'\nimport { permissionModeSchema } from '../../utils/permissions/PermissionMode.js'\nimport type { PermissionResult } from '../../utils/permissions/PermissionResult.js'\nimport {\n  filterDeniedAgents,\n  getDenyRuleForAgent,\n} from '../../utils/permissions/permissions.js'\nimport { enqueueSdkEvent } from '../../utils/sdkEventQueue.js'\nimport { writeAgentMetadata } from '../../utils/sessionStorage.js'\nimport { sleep } from '../../utils/sleep.js'\nimport { buildEffectiveSystemPrompt } from '../../utils/systemPrompt.js'\nimport { asSystemPrompt } from '../../utils/systemPromptType.js'\nimport { getTaskOutputPath } from '../../utils/task/diskOutput.js'\nimport { getParentSessionId, isTeammate } from '../../utils/teammate.js'\nimport { isInProcessTeammate } from '../../utils/teammateContext.js'\nimport { teleportToRemote } from '../../utils/teleport.js'\nimport { getAssistantMessageContentLength } from '../../utils/tokens.js'\nimport { createAgentId } from '../../utils/uuid.js'\nimport {\n  createAgentWorktree,\n  hasWorktreeChanges,\n  removeAgentWorktree,\n} from '../../utils/worktree.js'\nimport { BASH_TOOL_NAME } from '../BashTool/toolName.js'\nimport { BackgroundHint } from '../BashTool/UI.js'\nimport { FILE_READ_TOOL_NAME } from '../FileReadTool/prompt.js'\nimport { spawnTeammate } from '../shared/spawnMultiAgent.js'\nimport { setAgentColor } from './agentColorManager.js'\nimport {\n  agentToolResultSchema,\n  classifyHandoffIfNeeded,\n  emitTaskProgress,\n  extractPartialResult,\n  finalizeAgentTool,\n  getLastToolUseName,\n  runAsyncAgentLifecycle,\n} from './agentToolUtils.js'\nimport { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js'\nimport {\n  AGENT_TOOL_NAME,\n  LEGACY_AGENT_TOOL_NAME,\n  ONE_SHOT_BUILTIN_AGENT_TYPES,\n} from './constants.js'\nimport {\n  buildForkedMessages,\n  buildWorktreeNotice,\n  FORK_AGENT,\n  isForkSubagentEnabled,\n  isInForkChild,\n} from './forkSubagent.js'\nimport type { AgentDefinition } from './loadAgentsDir.js'\nimport {\n  filterAgentsByMcpRequirements,\n  hasRequiredMcpServers,\n  isBuiltInAgent,\n} from './loadAgentsDir.js'\nimport { getPrompt } from './prompt.js'\nimport { runAgent } from './runAgent.js'\nimport {\n  renderGroupedAgentToolUse,\n  renderToolResultMessage,\n  renderToolUseErrorMessage,\n  renderToolUseMessage,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseTag,\n  userFacingName,\n  userFacingNameBackgroundColor,\n} from './UI.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst proactiveModule =\n  feature('PROACTIVE') || feature('KAIROS')\n    ? (require('../../proactive/index.js') as typeof import('../../proactive/index.js'))\n    : null\n/* eslint-enable @typescript-eslint/no-require-imports */\n\n// Progress display constants (for showing background hint)\nconst PROGRESS_THRESHOLD_MS = 2000 // Show background hint after 2 seconds\n\n// Check if background tasks are disabled at module load time\nconst isBackgroundTasksDisabled =\n  // eslint-disable-next-line custom-rules/no-process-env-top-level -- Intentional: schema must be defined at module load\n  isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS)\n\n// Auto-background agent tasks after this many ms (0 = disabled)\n// Enabled by env var OR GrowthBook gate (checked lazily since GB may not be ready at module load)\nfunction getAutoBackgroundMs(): number {\n  if (\n    isEnvTruthy(process.env.CLAUDE_AUTO_BACKGROUND_TASKS) ||\n    getFeatureValue_CACHED_MAY_BE_STALE('tengu_auto_background_agents', false)\n  ) {\n    return 120_000\n  }\n  return 0\n}\n\n// Multi-agent type constants are defined inline inside gated blocks to enable dead code elimination\n\n// Base input schema without multi-agent parameters\nconst baseInputSchema = lazySchema(() =>\n  z.object({\n    description: z\n      .string()\n      .describe('A short (3-5 word) description of the task'),\n    prompt: z.string().describe('The task for the agent to perform'),\n    subagent_type: z\n      .string()\n      .optional()\n      .describe('The type of specialized agent to use for this task'),\n    model: z\n      .enum(['sonnet', 'opus', 'haiku'])\n      .optional()\n      .describe(\n        \"Optional model override for this agent. Takes precedence over the agent definition's model frontmatter. If omitted, uses the agent definition's model, or inherits from the parent.\",\n      ),\n    run_in_background: z\n      .boolean()\n      .optional()\n      .describe(\n        'Set to true to run this agent in the background. You will be notified when it completes.',\n      ),\n  }),\n)\n\n// Full schema combining base + multi-agent params + isolation\nconst fullInputSchema = lazySchema(() => {\n  // Multi-agent parameters\n  const multiAgentInputSchema = z.object({\n    name: z\n      .string()\n      .optional()\n      .describe(\n        'Name for the spawned agent. Makes it addressable via SendMessage({to: name}) while running.',\n      ),\n    team_name: z\n      .string()\n      .optional()\n      .describe(\n        'Team name for spawning. Uses current team context if omitted.',\n      ),\n    mode: permissionModeSchema()\n      .optional()\n      .describe(\n        'Permission mode for spawned teammate (e.g., \"plan\" to require plan approval).',\n      ),\n  })\n\n  return baseInputSchema()\n    .merge(multiAgentInputSchema)\n    .extend({\n      isolation: (\"external\" === 'ant'\n        ? z.enum(['worktree', 'remote'])\n        : z.enum(['worktree'])\n      )\n        .optional()\n        .describe(\n          \"external\" === 'ant'\n            ? 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo. \"remote\" launches the agent in a remote CCR environment (always runs in background).'\n            : 'Isolation mode. \"worktree\" creates a temporary git worktree so the agent works on an isolated copy of the repo.',\n        ),\n      cwd: z\n        .string()\n        .optional()\n        .describe(\n          'Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: \"worktree\".',\n        ),\n    })\n})\n\n// Strip optional fields from the schema when the backing feature is off so\n// the model never sees them. Done via .omit() rather than conditional spread\n// inside .extend() because the spread-ternary breaks Zod's type inference\n// (field type collapses to `unknown`). The ternary return produces a union\n// type, but call() destructures via the explicit AgentToolInput type below\n// which always includes all optional fields.\nexport const inputSchema = lazySchema(() => {\n  const schema = feature('KAIROS')\n    ? fullInputSchema()\n    : fullInputSchema().omit({ cwd: true })\n\n  // GrowthBook-in-lazySchema is acceptable here (unlike subagent_type, which\n  // was removed in 906da6c723): the divergence window is one-session-per-\n  // gate-flip via _CACHED_MAY_BE_STALE disk read, and worst case is either\n  // \"schema shows a no-op param\" (gate flips on mid-session: param ignored\n  // by forceAsync) or \"schema hides a param that would've worked\" (gate\n  // flips off mid-session: everything still runs async via memoized\n  // forceAsync). No Zod rejection, no crash — unlike required→optional.\n  return isBackgroundTasksDisabled || isForkSubagentEnabled()\n    ? schema.omit({ run_in_background: true })\n    : schema\n})\ntype InputSchema = ReturnType<typeof inputSchema>\n\n// Explicit type widens the schema inference to always include all optional\n// fields even when .omit() strips them for gating (cwd, run_in_background).\n// subagent_type is optional; call() defaults it to general-purpose when the\n// fork gate is off, or routes to the fork path when the gate is on.\ntype AgentToolInput = z.infer<ReturnType<typeof baseInputSchema>> & {\n  name?: string\n  team_name?: string\n  mode?: z.infer<ReturnType<typeof permissionModeSchema>>\n  isolation?: 'worktree' | 'remote'\n  cwd?: string\n}\n\n// Output schema - multi-agent spawned schema added dynamically at runtime when enabled\nexport const outputSchema = lazySchema(() => {\n  const syncOutputSchema = agentToolResultSchema().extend({\n    status: z.literal('completed'),\n    prompt: z.string(),\n  })\n\n  const asyncOutputSchema = z.object({\n    status: z.literal('async_launched'),\n    agentId: z.string().describe('The ID of the async agent'),\n    description: z.string().describe('The description of the task'),\n    prompt: z.string().describe('The prompt for the agent'),\n    outputFile: z\n      .string()\n      .describe('Path to the output file for checking agent progress'),\n    canReadOutputFile: z\n      .boolean()\n      .optional()\n      .describe(\n        'Whether the calling agent has Read/Bash tools to check progress',\n      ),\n  })\n\n  return z.union([syncOutputSchema, asyncOutputSchema])\n})\ntype OutputSchema = ReturnType<typeof outputSchema>\ntype Output = z.input<OutputSchema>\n\n// Private type for teammate spawn results - excluded from exported schema for dead code elimination\n// The 'teammate_spawned' status string is only included when ENABLE_AGENT_SWARMS is true\ntype TeammateSpawnedOutput = {\n  status: 'teammate_spawned'\n  prompt: string\n  teammate_id: string\n  agent_id: string\n  agent_type?: string\n  model?: string\n  name: string\n  color?: string\n  tmux_session_name: string\n  tmux_window_name: string\n  tmux_pane_id: string\n  team_name?: string\n  is_splitpane?: boolean\n  plan_mode_required?: boolean\n}\n\n// Combined output type including both public and internal types\n// Note: TeammateSpawnedOutput type is fine - TypeScript types are erased at compile time\n// Private type for remote-launched results — excluded from exported schema\n// like TeammateSpawnedOutput for dead code elimination purposes. Exported\n// for UI.tsx to do proper discriminated-union narrowing instead of ad-hoc casts.\nexport type RemoteLaunchedOutput = {\n  status: 'remote_launched'\n  taskId: string\n  sessionUrl: string\n  description: string\n  prompt: string\n  outputFile: string\n}\n\ntype InternalOutput = Output | TeammateSpawnedOutput | RemoteLaunchedOutput\n\nimport type { AgentToolProgress, ShellProgress } from '../../types/tools.js'\n// AgentTool forwards both its own progress events and shell progress\n// events from the sub-agent so the SDK receives tool_progress updates during bash/powershell runs.\nexport type Progress = AgentToolProgress | ShellProgress\n\nexport const AgentTool = buildTool({\n  async prompt({ agents, tools, getToolPermissionContext, allowedAgentTypes }) {\n    const toolPermissionContext = await getToolPermissionContext()\n\n    // Get MCP servers that have tools available\n    const mcpServersWithTools: string[] = []\n    for (const tool of tools) {\n      if (tool.name?.startsWith('mcp__')) {\n        const parts = tool.name.split('__')\n        const serverName = parts[1]\n        if (serverName && !mcpServersWithTools.includes(serverName)) {\n          mcpServersWithTools.push(serverName)\n        }\n      }\n    }\n\n    // Filter agents: first by MCP requirements, then by permission rules\n    const agentsWithMcpRequirementsMet = filterAgentsByMcpRequirements(\n      agents,\n      mcpServersWithTools,\n    )\n    const filteredAgents = filterDeniedAgents(\n      agentsWithMcpRequirementsMet,\n      toolPermissionContext,\n      AGENT_TOOL_NAME,\n    )\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n    return await getPrompt(filteredAgents, isCoordinator, allowedAgentTypes)\n  },\n  name: AGENT_TOOL_NAME,\n  searchHint: 'delegate work to a subagent',\n  aliases: [LEGACY_AGENT_TOOL_NAME],\n  maxResultSizeChars: 100_000,\n  async description() {\n    return 'Launch a new agent'\n  },\n  get inputSchema(): InputSchema {\n    return inputSchema()\n  },\n  get outputSchema(): OutputSchema {\n    return outputSchema()\n  },\n  async call(\n    {\n      prompt,\n      subagent_type,\n      description,\n      model: modelParam,\n      run_in_background,\n      name,\n      team_name,\n      mode: spawnMode,\n      isolation,\n      cwd,\n    }: AgentToolInput,\n    toolUseContext,\n    canUseTool,\n    assistantMessage,\n    onProgress?,\n  ) {\n    const startTime = Date.now()\n    const model = isCoordinatorMode() ? undefined : modelParam\n\n    // Get app state for permission mode and agent filtering\n    const appState = toolUseContext.getAppState()\n    const permissionMode = appState.toolPermissionContext.mode\n    // In-process teammates get a no-op setAppState; setAppStateForTasks\n    // reaches the root store so task registration/progress/kill stay visible.\n    const rootSetAppState =\n      toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState\n\n    // Check if user is trying to use agent teams without access\n    if (team_name && !isAgentSwarmsEnabled()) {\n      throw new Error('Agent Teams is not yet available on your plan.')\n    }\n\n    // Teammates (in-process or tmux) passing `name` would trigger spawnTeammate()\n    // below, but TeamFile.members is a flat array with one leadAgentId — nested\n    // teammates land in the roster with no provenance and confuse the lead.\n    const teamName = resolveTeamName({ team_name }, appState)\n    if (isTeammate() && teamName && name) {\n      throw new Error(\n        'Teammates cannot spawn other teammates — the team roster is flat. To spawn a subagent instead, omit the `name` parameter.',\n      )\n    }\n    // In-process teammates cannot spawn background agents (their lifecycle is\n    // tied to the leader's process). Tmux teammates are separate processes and\n    // can manage their own background agents.\n    if (isInProcessTeammate() && teamName && run_in_background === true) {\n      throw new Error(\n        'In-process teammates cannot spawn background agents. Use run_in_background=false for synchronous subagents.',\n      )\n    }\n\n    // Check if this is a multi-agent spawn request\n    // Spawn is triggered when team_name is set (from param or context) and name is provided\n    if (teamName && name) {\n      // Set agent definition color for grouped UI display before spawning\n      const agentDef = subagent_type\n        ? toolUseContext.options.agentDefinitions.activeAgents.find(\n            a => a.agentType === subagent_type,\n          )\n        : undefined\n      if (agentDef?.color) {\n        setAgentColor(subagent_type!, agentDef.color)\n      }\n      const result = await spawnTeammate(\n        {\n          name,\n          prompt,\n          description,\n          team_name: teamName,\n          use_splitpane: true,\n          plan_mode_required: spawnMode === 'plan',\n          model: model ?? agentDef?.model,\n          agent_type: subagent_type,\n          invokingRequestId: assistantMessage?.requestId,\n        },\n        toolUseContext,\n      )\n\n      // Type assertion uses TeammateSpawnedOutput (defined above) instead of any.\n      // This type is excluded from the exported outputSchema for dead code elimination.\n      // Cast through unknown because TeammateSpawnedOutput is intentionally\n      // not part of the exported Output union (for dead code elimination purposes).\n      const spawnResult: TeammateSpawnedOutput = {\n        status: 'teammate_spawned' as const,\n        prompt,\n        ...result.data,\n      }\n      return { data: spawnResult } as unknown as { data: Output }\n    }\n\n    // Fork subagent experiment routing:\n    // - subagent_type set: use it (explicit wins)\n    // - subagent_type omitted, gate on: fork path (undefined)\n    // - subagent_type omitted, gate off: default general-purpose\n    const effectiveType =\n      subagent_type ??\n      (isForkSubagentEnabled() ? undefined : GENERAL_PURPOSE_AGENT.agentType)\n    const isForkPath = effectiveType === undefined\n\n    let selectedAgent: AgentDefinition\n    if (isForkPath) {\n      // Recursive fork guard: fork children keep the Agent tool in their\n      // pool for cache-identical tool defs, so reject fork attempts at call\n      // time. Primary check is querySource (compaction-resistant — set on\n      // context.options at spawn time, survives autocompact's message\n      // rewrite). Message-scan fallback catches any path where querySource\n      // wasn't threaded.\n      if (\n        toolUseContext.options.querySource ===\n          `agent:builtin:${FORK_AGENT.agentType}` ||\n        isInForkChild(toolUseContext.messages)\n      ) {\n        throw new Error(\n          'Fork is not available inside a forked worker. Complete your task directly using your tools.',\n        )\n      }\n      selectedAgent = FORK_AGENT\n    } else {\n      // Filter agents to exclude those denied via Agent(AgentName) syntax\n      const allAgents = toolUseContext.options.agentDefinitions.activeAgents\n      const { allowedAgentTypes } = toolUseContext.options.agentDefinitions\n      const agents = filterDeniedAgents(\n        // When allowedAgentTypes is set (from Agent(x,y) tool spec), restrict to those types\n        allowedAgentTypes\n          ? allAgents.filter(a => allowedAgentTypes.includes(a.agentType))\n          : allAgents,\n        appState.toolPermissionContext,\n        AGENT_TOOL_NAME,\n      )\n\n      const found = agents.find(agent => agent.agentType === effectiveType)\n      if (!found) {\n        // Check if the agent exists but is denied by permission rules\n        const agentExistsButDenied = allAgents.find(\n          agent => agent.agentType === effectiveType,\n        )\n        if (agentExistsButDenied) {\n          const denyRule = getDenyRuleForAgent(\n            appState.toolPermissionContext,\n            AGENT_TOOL_NAME,\n            effectiveType,\n          )\n          throw new Error(\n            `Agent type '${effectiveType}' has been denied by permission rule '${AGENT_TOOL_NAME}(${effectiveType})' from ${denyRule?.source ?? 'settings'}.`,\n          )\n        }\n        throw new Error(\n          `Agent type '${effectiveType}' not found. Available agents: ${agents\n            .map(a => a.agentType)\n            .join(', ')}`,\n        )\n      }\n      selectedAgent = found\n    }\n\n    // Same lifecycle constraint as the run_in_background guard above, but for\n    // agent definitions that force background via `background: true`. Checked\n    // here because selectedAgent is only now resolved.\n    if (\n      isInProcessTeammate() &&\n      teamName &&\n      selectedAgent.background === true\n    ) {\n      throw new Error(\n        `In-process teammates cannot spawn background agents. Agent '${selectedAgent.agentType}' has background: true in its definition.`,\n      )\n    }\n\n    // Capture for type narrowing — `let selectedAgent` prevents TS from\n    // narrowing property types across the if-else assignment above.\n    const requiredMcpServers = selectedAgent.requiredMcpServers\n\n    // Check if required MCP servers have tools available\n    // A server that's connected but not authenticated won't have any tools\n    if (requiredMcpServers?.length) {\n      // If any required servers are still pending (connecting), wait for them\n      // before checking tool availability. This avoids a race condition where\n      // the agent is invoked before MCP servers finish connecting.\n      const hasPendingRequiredServers = appState.mcp.clients.some(\n        c =>\n          c.type === 'pending' &&\n          requiredMcpServers.some(pattern =>\n            c.name.toLowerCase().includes(pattern.toLowerCase()),\n          ),\n      )\n\n      let currentAppState = appState\n      if (hasPendingRequiredServers) {\n        const MAX_WAIT_MS = 30_000\n        const POLL_INTERVAL_MS = 500\n        const deadline = Date.now() + MAX_WAIT_MS\n\n        while (Date.now() < deadline) {\n          await sleep(POLL_INTERVAL_MS)\n          currentAppState = toolUseContext.getAppState()\n\n          // Early exit: if any required server has already failed, no point\n          // waiting for other pending servers — the check will fail regardless.\n          const hasFailedRequiredServer = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'failed' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (hasFailedRequiredServer) break\n\n          const stillPending = currentAppState.mcp.clients.some(\n            c =>\n              c.type === 'pending' &&\n              requiredMcpServers.some(pattern =>\n                c.name.toLowerCase().includes(pattern.toLowerCase()),\n              ),\n          )\n          if (!stillPending) break\n        }\n      }\n\n      // Get servers that actually have tools (meaning they're connected AND authenticated)\n      const serversWithTools: string[] = []\n      for (const tool of currentAppState.mcp.tools) {\n        if (tool.name?.startsWith('mcp__')) {\n          // Extract server name from tool name (format: mcp__serverName__toolName)\n          const parts = tool.name.split('__')\n          const serverName = parts[1]\n          if (serverName && !serversWithTools.includes(serverName)) {\n            serversWithTools.push(serverName)\n          }\n        }\n      }\n\n      if (!hasRequiredMcpServers(selectedAgent, serversWithTools)) {\n        const missing = requiredMcpServers.filter(\n          pattern =>\n            !serversWithTools.some(server =>\n              server.toLowerCase().includes(pattern.toLowerCase()),\n            ),\n        )\n        throw new Error(\n          `Agent '${selectedAgent.agentType}' requires MCP servers matching: ${missing.join(', ')}. ` +\n            `MCP servers with tools: ${serversWithTools.length > 0 ? serversWithTools.join(', ') : 'none'}. ` +\n            `Use /mcp to configure and authenticate the required MCP servers.`,\n        )\n      }\n    }\n\n    // Initialize the color for this agent if it has a predefined one\n    if (selectedAgent.color) {\n      setAgentColor(selectedAgent.agentType, selectedAgent.color)\n    }\n\n    // Resolve agent params for logging (these are already resolved in runAgent)\n    const resolvedAgentModel = getAgentModel(\n      selectedAgent.model,\n      toolUseContext.options.mainLoopModel,\n      isForkPath ? undefined : model,\n      permissionMode,\n    )\n\n    logEvent('tengu_agent_tool_selected', {\n      agent_type:\n        selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      model:\n        resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        selectedAgent.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      color:\n        selectedAgent.color as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      is_built_in_agent: isBuiltInAgent(selectedAgent),\n      is_resume: false,\n      is_async:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n      is_fork: isForkPath,\n    })\n\n    // Resolve effective isolation mode (explicit param overrides agent def)\n    const effectiveIsolation = isolation ?? selectedAgent.isolation\n\n    // Remote isolation: delegate to CCR. Gated ant-only — the guard enables\n    // dead code elimination of the entire block for external builds.\n    if (\"external\" === 'ant' && effectiveIsolation === 'remote') {\n      const eligibility = await checkRemoteAgentEligibility()\n      if (!eligibility.eligible) {\n        const reasons = eligibility.errors\n          .map(formatPreconditionError)\n          .join('\\n')\n        throw new Error(`Cannot launch remote agent:\\n${reasons}`)\n      }\n\n      let bundleFailHint: string | undefined\n      const session = await teleportToRemote({\n        initialMessage: prompt,\n        description,\n        signal: toolUseContext.abortController.signal,\n        onBundleFail: msg => {\n          bundleFailHint = msg\n        },\n      })\n      if (!session) {\n        throw new Error(bundleFailHint ?? 'Failed to create remote session')\n      }\n\n      const { taskId, sessionId } = registerRemoteAgentTask({\n        remoteTaskType: 'remote-agent',\n        session: { id: session.id, title: session.title || description },\n        command: prompt,\n        context: toolUseContext,\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      logEvent('tengu_agent_tool_remote_launched', {\n        agent_type:\n          selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      const remoteResult: RemoteLaunchedOutput = {\n        status: 'remote_launched',\n        taskId,\n        sessionUrl: getRemoteTaskSessionUrl(sessionId),\n        description,\n        prompt,\n        outputFile: getTaskOutputPath(taskId),\n      }\n      return { data: remoteResult } as unknown as { data: Output }\n    }\n    // System prompt + prompt messages: branch on fork path.\n    //\n    // Fork path: child inherits the PARENT's system prompt (not FORK_AGENT's)\n    // for cache-identical API request prefixes. Prompt messages are built via\n    // buildForkedMessages() which clones the parent's full assistant message\n    // (all tool_use blocks) + placeholder tool_results + per-child directive.\n    //\n    // Normal path: build the selected agent's own system prompt with env\n    // details, and use a simple user message for the prompt.\n    let enhancedSystemPrompt: string[] | undefined\n    let forkParentSystemPrompt:\n      | ReturnType<typeof buildEffectiveSystemPrompt>\n      | undefined\n    let promptMessages: MessageType[]\n\n    if (isForkPath) {\n      if (toolUseContext.renderedSystemPrompt) {\n        forkParentSystemPrompt = toolUseContext.renderedSystemPrompt\n      } else {\n        // Fallback: recompute. May diverge from parent's cached bytes if\n        // GrowthBook state changed between parent turn-start and fork spawn.\n        const mainThreadAgentDefinition = appState.agent\n          ? appState.agentDefinitions.activeAgents.find(\n              a => a.agentType === appState.agent,\n            )\n          : undefined\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n        const defaultSystemPrompt = await getSystemPrompt(\n          toolUseContext.options.tools,\n          toolUseContext.options.mainLoopModel,\n          additionalWorkingDirectories,\n          toolUseContext.options.mcpClients,\n        )\n        forkParentSystemPrompt = buildEffectiveSystemPrompt({\n          mainThreadAgentDefinition,\n          toolUseContext,\n          customSystemPrompt: toolUseContext.options.customSystemPrompt,\n          defaultSystemPrompt,\n          appendSystemPrompt: toolUseContext.options.appendSystemPrompt,\n        })\n      }\n      promptMessages = buildForkedMessages(prompt, assistantMessage)\n    } else {\n      try {\n        const additionalWorkingDirectories = Array.from(\n          appState.toolPermissionContext.additionalWorkingDirectories.keys(),\n        )\n\n        // All agents have getSystemPrompt - pass toolUseContext to all\n        const agentPrompt = selectedAgent.getSystemPrompt({ toolUseContext })\n\n        // Log agent memory loaded event for subagents\n        if (selectedAgent.memory) {\n          logEvent('tengu_agent_memory_loaded', {\n            ...(\"external\" === 'ant' && {\n              agent_type:\n                selectedAgent.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            }),\n            scope:\n              selectedAgent.memory as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            source:\n              'subagent' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          })\n        }\n\n        // Apply environment details enhancement\n        enhancedSystemPrompt = await enhanceSystemPromptWithEnvDetails(\n          [agentPrompt],\n          resolvedAgentModel,\n          additionalWorkingDirectories,\n        )\n      } catch (error) {\n        logForDebugging(\n          `Failed to get system prompt for agent ${selectedAgent.agentType}: ${errorMessage(error)}`,\n        )\n      }\n      promptMessages = [createUserMessage({ content: prompt })]\n    }\n\n    const metadata = {\n      prompt,\n      resolvedAgentModel,\n      isBuiltInAgent: isBuiltInAgent(selectedAgent),\n      startTime,\n      agentType: selectedAgent.agentType,\n      isAsync:\n        (run_in_background === true || selectedAgent.background === true) &&\n        !isBackgroundTasksDisabled,\n    }\n\n    // Use inline env check instead of coordinatorModule to avoid circular\n    // dependency issues during test module loading.\n    const isCoordinator = feature('COORDINATOR_MODE')\n      ? isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)\n      : false\n\n    // Fork subagent experiment: force ALL spawns async for a unified\n    // <task-notification> interaction model (not just fork spawns — all of them).\n    const forceAsync = isForkSubagentEnabled()\n\n    // Assistant mode: force all agents async. Synchronous subagents hold the\n    // main loop's turn open until they complete — the daemon's inputQueue\n    // backs up, and the first overdue cron catch-up on spawn becomes N\n    // serial subagent turns blocking all user input. Same gate as\n    // executeForkedSlashCommand's fire-and-forget path; the\n    // <task-notification> re-entry there is handled by the else branch\n    // below (registerAsyncAgentTask + notifyOnCompletion).\n    const assistantForceAsync = feature('KAIROS')\n      ? appState.kairosEnabled\n      : false\n\n    const shouldRunAsync =\n      (run_in_background === true ||\n        selectedAgent.background === true ||\n        isCoordinator ||\n        forceAsync ||\n        assistantForceAsync ||\n        (proactiveModule?.isProactiveActive() ?? false)) &&\n      !isBackgroundTasksDisabled\n    // Assemble the worker's tool pool independently of the parent's.\n    // Workers always get their tools from assembleToolPool with their own\n    // permission mode, so they aren't affected by the parent's tool\n    // restrictions. This is computed here so that runAgent doesn't need to\n    // import from tools.ts (which would create a circular dependency).\n    const workerPermissionContext = {\n      ...appState.toolPermissionContext,\n      mode: selectedAgent.permissionMode ?? 'acceptEdits',\n    }\n    const workerTools = assembleToolPool(\n      workerPermissionContext,\n      appState.mcp.tools,\n    )\n\n    // Create a stable agent ID early so it can be used for worktree slug\n    const earlyAgentId = createAgentId()\n\n    // Set up worktree isolation if requested\n    let worktreeInfo: {\n      worktreePath: string\n      worktreeBranch?: string\n      headCommit?: string\n      gitRoot?: string\n      hookBased?: boolean\n    } | null = null\n\n    if (effectiveIsolation === 'worktree') {\n      const slug = `agent-${earlyAgentId.slice(0, 8)}`\n      worktreeInfo = await createAgentWorktree(slug)\n    }\n\n    // Fork + worktree: inject a notice telling the child to translate paths\n    // and re-read potentially stale files. Appended after the fork directive\n    // so it appears as the most recent guidance the child sees.\n    if (isForkPath && worktreeInfo) {\n      promptMessages.push(\n        createUserMessage({\n          content: buildWorktreeNotice(getCwd(), worktreeInfo.worktreePath),\n        }),\n      )\n    }\n\n    const runAgentParams: Parameters<typeof runAgent>[0] = {\n      agentDefinition: selectedAgent,\n      promptMessages,\n      toolUseContext,\n      canUseTool,\n      isAsync: shouldRunAsync,\n      querySource:\n        toolUseContext.options.querySource ??\n        getQuerySourceForAgent(\n          selectedAgent.agentType,\n          isBuiltInAgent(selectedAgent),\n        ),\n      model: isForkPath ? undefined : model,\n      // Fork path: pass parent's system prompt AND parent's exact tool\n      // array (cache-identical prefix). workerTools is rebuilt under\n      // permissionMode 'bubble' which differs from the parent's mode, so\n      // its tool-def serialization diverges and breaks cache at the first\n      // differing tool. useExactTools also inherits the parent's\n      // thinkingConfig and isNonInteractiveSession (see runAgent.ts).\n      //\n      // Normal path: when a cwd override is in effect (worktree isolation\n      // or explicit cwd), skip the pre-built system prompt so runAgent's\n      // buildAgentSystemPrompt() runs inside wrapWithCwd where getCwd()\n      // returns the override path.\n      override: isForkPath\n        ? { systemPrompt: forkParentSystemPrompt }\n        : enhancedSystemPrompt && !worktreeInfo && !cwd\n          ? { systemPrompt: asSystemPrompt(enhancedSystemPrompt) }\n          : undefined,\n      availableTools: isForkPath ? toolUseContext.options.tools : workerTools,\n      // Pass parent conversation when the fork-subagent path needs full\n      // context. useExactTools inherits thinkingConfig (runAgent.ts:624).\n      forkContextMessages: isForkPath ? toolUseContext.messages : undefined,\n      ...(isForkPath && { useExactTools: true }),\n      worktreePath: worktreeInfo?.worktreePath,\n      description,\n    }\n\n    // Helper to wrap execution with a cwd override: explicit cwd arg (KAIROS)\n    // takes precedence over worktree isolation path.\n    const cwdOverridePath = cwd ?? worktreeInfo?.worktreePath\n    const wrapWithCwd = <T,>(fn: () => T): T =>\n      cwdOverridePath ? runWithCwdOverride(cwdOverridePath, fn) : fn()\n\n    // Helper to clean up worktree after agent completes\n    const cleanupWorktreeIfNeeded = async (): Promise<{\n      worktreePath?: string\n      worktreeBranch?: string\n    }> => {\n      if (!worktreeInfo) return {}\n      const { worktreePath, worktreeBranch, headCommit, gitRoot, hookBased } =\n        worktreeInfo\n      // Null out to make idempotent — guards against double-call if code\n      // between cleanup and end of try throws into catch\n      worktreeInfo = null\n      if (hookBased) {\n        // Hook-based worktrees are always kept since we can't detect VCS changes\n        logForDebugging(`Hook-based agent worktree kept at: ${worktreePath}`)\n        return { worktreePath }\n      }\n      if (headCommit) {\n        const changed = await hasWorktreeChanges(worktreePath, headCommit)\n        if (!changed) {\n          await removeAgentWorktree(worktreePath, worktreeBranch, gitRoot)\n          // Clear worktreePath from metadata so resume doesn't try to use\n          // a deleted directory. Fire-and-forget to match runAgent's\n          // writeAgentMetadata handling.\n          void writeAgentMetadata(asAgentId(earlyAgentId), {\n            agentType: selectedAgent.agentType,\n            description,\n          }).catch(_err =>\n            logForDebugging(`Failed to clear worktree metadata: ${_err}`),\n          )\n          return {}\n        }\n      }\n      logForDebugging(`Agent worktree has changes, keeping: ${worktreePath}`)\n      return { worktreePath, worktreeBranch }\n    }\n\n    if (shouldRunAsync) {\n      const asyncAgentId = earlyAgentId\n      const agentBackgroundTask = registerAsyncAgent({\n        agentId: asyncAgentId,\n        description,\n        prompt,\n        selectedAgent,\n        setAppState: rootSetAppState,\n        // Don't link to parent's abort controller -- background agents should\n        // survive when the user presses ESC to cancel the main thread.\n        // They are killed explicitly via chat:killAgents.\n        toolUseId: toolUseContext.toolUseId,\n      })\n\n      // Register name → agentId for SendMessage routing. Post-registerAsyncAgent\n      // so we don't leave a stale entry if spawn fails. Sync agents skipped —\n      // coordinator is blocked, so SendMessage routing doesn't apply.\n      if (name) {\n        rootSetAppState(prev => {\n          const next = new Map(prev.agentNameRegistry)\n          next.set(name, asAgentId(asyncAgentId))\n          return { ...prev, agentNameRegistry: next }\n        })\n      }\n\n      // Wrap async agent execution in agent context for analytics attribution\n      const asyncAgentContext = {\n        agentId: asyncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Workload propagation: handlePromptSubmit wraps the entire turn in\n      // runWithWorkload (AsyncLocalStorage). ALS context is captured at\n      // invocation time — when this `void` fires — and survives every await\n      // inside. No capture/restore needed; the detached closure sees the\n      // parent turn's workload automatically, isolated from its finally.\n      void runWithAgentContext(asyncAgentContext, () =>\n        wrapWithCwd(() =>\n          runAsyncAgentLifecycle({\n            taskId: agentBackgroundTask.agentId,\n            abortController: agentBackgroundTask.abortController!,\n            makeStream: onCacheSafeParams =>\n              runAgent({\n                ...runAgentParams,\n                override: {\n                  ...runAgentParams.override,\n                  agentId: asAgentId(agentBackgroundTask.agentId),\n                  abortController: agentBackgroundTask.abortController!,\n                },\n                onCacheSafeParams,\n              }),\n            metadata,\n            description,\n            toolUseContext,\n            rootSetAppState,\n            agentIdForCleanup: asyncAgentId,\n            enableSummarization:\n              isCoordinator ||\n              isForkSubagentEnabled() ||\n              getSdkAgentProgressSummariesEnabled(),\n            getWorktreeResult: cleanupWorktreeIfNeeded,\n          }),\n        ),\n      )\n\n      const canReadOutputFile = toolUseContext.options.tools.some(\n        t =>\n          toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n          toolMatchesName(t, BASH_TOOL_NAME),\n      )\n      return {\n        data: {\n          isAsync: true as const,\n          status: 'async_launched' as const,\n          agentId: agentBackgroundTask.agentId,\n          description: description,\n          prompt: prompt,\n          outputFile: getTaskOutputPath(agentBackgroundTask.agentId),\n          canReadOutputFile,\n        },\n      }\n    } else {\n      // Create an explicit agentId for sync agents\n      const syncAgentId = asAgentId(earlyAgentId)\n\n      // Set up agent context for sync execution (for analytics attribution)\n      const syncAgentContext = {\n        agentId: syncAgentId,\n        // For subagents from teammates: use team lead's session\n        // For subagents from main REPL: undefined (no parent session)\n        parentSessionId: getParentSessionId(),\n        agentType: 'subagent' as const,\n        subagentName: selectedAgent.agentType,\n        isBuiltIn: isBuiltInAgent(selectedAgent),\n        invokingRequestId: assistantMessage?.requestId,\n        invocationKind: 'spawn' as const,\n        invocationEmitted: false,\n      }\n\n      // Wrap entire sync agent execution in context for analytics attribution\n      // and optionally in a worktree cwd override for filesystem isolation\n      return runWithAgentContext(syncAgentContext, () =>\n        wrapWithCwd(async () => {\n          const agentMessages: MessageType[] = []\n          const agentStartTime = Date.now()\n          const syncTracker = createProgressTracker()\n          const syncResolveActivity = createActivityDescriptionResolver(\n            toolUseContext.options.tools,\n          )\n\n          // Yield initial progress message to carry metadata (prompt)\n          if (promptMessages.length > 0) {\n            const normalizedPromptMessages = normalizeMessages(promptMessages)\n            const normalizedFirstMessage = normalizedPromptMessages.find(\n              (m): m is NormalizedUserMessage => m.type === 'user',\n            )\n            if (\n              normalizedFirstMessage &&\n              normalizedFirstMessage.type === 'user' &&\n              onProgress\n            ) {\n              onProgress({\n                toolUseID: `agent_${assistantMessage.message.id}`,\n                data: {\n                  message: normalizedFirstMessage,\n                  type: 'agent_progress',\n                  prompt,\n                  agentId: syncAgentId,\n                },\n              })\n            }\n          }\n\n          // Register as foreground task immediately so it can be backgrounded at any time\n          // Skip registration if background tasks are disabled\n          let foregroundTaskId: string | undefined\n          // Create the background race promise once outside the loop — otherwise\n          // each iteration adds a new .then() reaction to the same pending\n          // promise, accumulating callbacks for the lifetime of the agent.\n          let backgroundPromise: Promise<{ type: 'background' }> | undefined\n          let cancelAutoBackground: (() => void) | undefined\n          if (!isBackgroundTasksDisabled) {\n            const registration = registerAgentForeground({\n              agentId: syncAgentId,\n              description,\n              prompt,\n              selectedAgent,\n              setAppState: rootSetAppState,\n              toolUseId: toolUseContext.toolUseId,\n              autoBackgroundMs: getAutoBackgroundMs() || undefined,\n            })\n            foregroundTaskId = registration.taskId\n            backgroundPromise = registration.backgroundSignal.then(() => ({\n              type: 'background' as const,\n            }))\n            cancelAutoBackground = registration.cancelAutoBackground\n          }\n\n          // Track if we've shown the background hint UI\n          let backgroundHintShown = false\n          // Track if the agent was backgrounded (cleanup handled by backgrounded finally)\n          let wasBackgrounded = false\n          // Per-scope stop function — NOT shared with the backgrounded closure.\n          // idempotent: startAgentSummarization's stop() checks `stopped` flag.\n          let stopForegroundSummarization: (() => void) | undefined\n          // const capture for sound type narrowing inside the callback below\n          const summaryTaskId = foregroundTaskId\n\n          // Get async iterator for the agent\n          const agentIterator = runAgent({\n            ...runAgentParams,\n            override: {\n              ...runAgentParams.override,\n              agentId: syncAgentId,\n            },\n            onCacheSafeParams:\n              summaryTaskId && getSdkAgentProgressSummariesEnabled()\n                ? (params: CacheSafeParams) => {\n                    const { stop } = startAgentSummarization(\n                      summaryTaskId,\n                      syncAgentId,\n                      params,\n                      rootSetAppState,\n                    )\n                    stopForegroundSummarization = stop\n                  }\n                : undefined,\n          })[Symbol.asyncIterator]()\n\n          // Track if an error occurred during iteration\n          let syncAgentError: Error | undefined\n          let wasAborted = false\n          let worktreeResult: {\n            worktreePath?: string\n            worktreeBranch?: string\n          } = {}\n\n          try {\n            while (true) {\n              const elapsed = Date.now() - agentStartTime\n\n              // Show background hint after threshold (but task is already registered)\n              // Skip if background tasks are disabled\n              if (\n                !isBackgroundTasksDisabled &&\n                !backgroundHintShown &&\n                elapsed >= PROGRESS_THRESHOLD_MS &&\n                toolUseContext.setToolJSX\n              ) {\n                backgroundHintShown = true\n                toolUseContext.setToolJSX({\n                  jsx: <BackgroundHint />,\n                  shouldHidePromptInput: false,\n                  shouldContinueAnimation: true,\n                  showSpinner: true,\n                })\n              }\n\n              // Race between next message and background signal\n              // If background tasks are disabled, just await the next message directly\n              const nextMessagePromise = agentIterator.next()\n              const raceResult = backgroundPromise\n                ? await Promise.race([\n                    nextMessagePromise.then(r => ({\n                      type: 'message' as const,\n                      result: r,\n                    })),\n                    backgroundPromise,\n                  ])\n                : {\n                    type: 'message' as const,\n                    result: await nextMessagePromise,\n                  }\n\n              // Check if we were backgrounded via backgroundAll()\n              // foregroundTaskId is guaranteed to be defined if raceResult.type is 'background'\n              // because backgroundPromise is only defined when foregroundTaskId is defined\n              if (raceResult.type === 'background' && foregroundTaskId) {\n                const appState = toolUseContext.getAppState()\n                const task = appState.tasks[foregroundTaskId]\n                if (isLocalAgentTask(task) && task.isBackgrounded) {\n                  // Capture the taskId for use in the async callback\n                  const backgroundedTaskId = foregroundTaskId\n                  wasBackgrounded = true\n                  // Stop foreground summarization; the backgrounded closure\n                  // below owns its own independent stop function.\n                  stopForegroundSummarization?.()\n\n                  // Workload: inherited via ALS at `void` invocation time,\n                  // same as the async-from-start path above.\n                  // Continue agent in background and return async result\n                  void runWithAgentContext(syncAgentContext, async () => {\n                    let stopBackgroundedSummarization: (() => void) | undefined\n                    try {\n                      // Clean up the foreground iterator so its finally block runs\n                      // (releases MCP connections, session hooks, prompt cache tracking, etc.)\n                      // Timeout prevents blocking if MCP server cleanup hangs.\n                      // .catch() prevents unhandled rejection if timeout wins the race.\n                      await Promise.race([\n                        agentIterator.return(undefined).catch(() => {}),\n                        sleep(1000),\n                      ])\n                      // Initialize progress tracking from existing messages\n                      const tracker = createProgressTracker()\n                      const resolveActivity2 =\n                        createActivityDescriptionResolver(\n                          toolUseContext.options.tools,\n                        )\n                      for (const existingMsg of agentMessages) {\n                        updateProgressFromMessage(\n                          tracker,\n                          existingMsg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                      }\n                      for await (const msg of runAgent({\n                        ...runAgentParams,\n                        isAsync: true, // Agent is now running in background\n                        override: {\n                          ...runAgentParams.override,\n                          agentId: asAgentId(backgroundedTaskId),\n                          abortController: task.abortController,\n                        },\n                        onCacheSafeParams: getSdkAgentProgressSummariesEnabled()\n                          ? (params: CacheSafeParams) => {\n                              const { stop } = startAgentSummarization(\n                                backgroundedTaskId,\n                                asAgentId(backgroundedTaskId),\n                                params,\n                                rootSetAppState,\n                              )\n                              stopBackgroundedSummarization = stop\n                            }\n                          : undefined,\n                      })) {\n                        agentMessages.push(msg)\n\n                        // Track progress for backgrounded agents\n                        updateProgressFromMessage(\n                          tracker,\n                          msg,\n                          resolveActivity2,\n                          toolUseContext.options.tools,\n                        )\n                        updateAsyncAgentProgress(\n                          backgroundedTaskId,\n                          getProgressUpdate(tracker),\n                          rootSetAppState,\n                        )\n\n                        const lastToolName = getLastToolUseName(msg)\n                        if (lastToolName) {\n                          emitTaskProgress(\n                            tracker,\n                            backgroundedTaskId,\n                            toolUseContext.toolUseId,\n                            description,\n                            startTime,\n                            lastToolName,\n                          )\n                        }\n                      }\n                      const agentResult = finalizeAgentTool(\n                        agentMessages,\n                        backgroundedTaskId,\n                        metadata,\n                      )\n\n                      // Mark task completed FIRST so TaskOutput(block=true)\n                      // unblocks immediately. classifyHandoffIfNeeded and\n                      // cleanupWorktreeIfNeeded can hang — they must not gate\n                      // the status transition (gh-20236).\n                      completeAsyncAgent(agentResult, rootSetAppState)\n\n                      // Extract text from agent result content for the notification\n                      let finalMessage = extractTextContent(\n                        agentResult.content,\n                        '\\n',\n                      )\n\n                      if (feature('TRANSCRIPT_CLASSIFIER')) {\n                        const backgroundedAppState =\n                          toolUseContext.getAppState()\n                        const handoffWarning = await classifyHandoffIfNeeded({\n                          agentMessages,\n                          tools: toolUseContext.options.tools,\n                          toolPermissionContext:\n                            backgroundedAppState.toolPermissionContext,\n                          abortSignal: task.abortController!.signal,\n                          subagentType: selectedAgent.agentType,\n                          totalToolUseCount: agentResult.totalToolUseCount,\n                        })\n                        if (handoffWarning) {\n                          finalMessage = `${handoffWarning}\\n\\n${finalMessage}`\n                        }\n                      }\n\n                      // Clean up worktree before notification so we can include it\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'completed',\n                        setAppState: rootSetAppState,\n                        finalMessage,\n                        usage: {\n                          totalTokens: getTokenCountFromTracker(tracker),\n                          toolUses: agentResult.totalToolUseCount,\n                          durationMs: agentResult.totalDurationMs,\n                        },\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } catch (error) {\n                      if (error instanceof AbortError) {\n                        // Transition status BEFORE worktree cleanup so\n                        // TaskOutput unblocks even if git hangs (gh-20236).\n                        killAsyncAgent(backgroundedTaskId, rootSetAppState)\n                        logEvent('tengu_agent_tool_terminated', {\n                          agent_type:\n                            metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          model:\n                            metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                          duration_ms: Date.now() - metadata.startTime,\n                          is_async: true,\n                          is_built_in_agent: metadata.isBuiltInAgent,\n                          reason:\n                            'user_cancel_background' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                        })\n                        const worktreeResult = await cleanupWorktreeIfNeeded()\n                        const partialResult =\n                          extractPartialResult(agentMessages)\n                        enqueueAgentNotification({\n                          taskId: backgroundedTaskId,\n                          description,\n                          status: 'killed',\n                          setAppState: rootSetAppState,\n                          toolUseId: toolUseContext.toolUseId,\n                          finalMessage: partialResult,\n                          ...worktreeResult,\n                        })\n                        return\n                      }\n                      const errMsg = errorMessage(error)\n                      failAsyncAgent(\n                        backgroundedTaskId,\n                        errMsg,\n                        rootSetAppState,\n                      )\n                      const worktreeResult = await cleanupWorktreeIfNeeded()\n                      enqueueAgentNotification({\n                        taskId: backgroundedTaskId,\n                        description,\n                        status: 'failed',\n                        error: errMsg,\n                        setAppState: rootSetAppState,\n                        toolUseId: toolUseContext.toolUseId,\n                        ...worktreeResult,\n                      })\n                    } finally {\n                      stopBackgroundedSummarization?.()\n                      clearInvokedSkillsForAgent(syncAgentId)\n                      clearDumpState(syncAgentId)\n                      // Note: worktree cleanup is done before enqueueAgentNotification\n                      // in both try and catch paths so we can include worktree info\n                    }\n                  })\n\n                  // Return async_launched result immediately\n                  const canReadOutputFile = toolUseContext.options.tools.some(\n                    t =>\n                      toolMatchesName(t, FILE_READ_TOOL_NAME) ||\n                      toolMatchesName(t, BASH_TOOL_NAME),\n                  )\n                  return {\n                    data: {\n                      isAsync: true as const,\n                      status: 'async_launched' as const,\n                      agentId: backgroundedTaskId,\n                      description: description,\n                      prompt: prompt,\n                      outputFile: getTaskOutputPath(backgroundedTaskId),\n                      canReadOutputFile,\n                    },\n                  }\n                }\n              }\n\n              // Process the message from the race result\n              if (raceResult.type !== 'message') {\n                // This shouldn't happen - background case handled above\n                continue\n              }\n              const { result } = raceResult\n              if (result.done) break\n              const message = result.value\n\n              agentMessages.push(message)\n\n              // Emit task_progress for the VS Code subagent panel\n              updateProgressFromMessage(\n                syncTracker,\n                message,\n                syncResolveActivity,\n                toolUseContext.options.tools,\n              )\n              if (foregroundTaskId) {\n                const lastToolName = getLastToolUseName(message)\n                if (lastToolName) {\n                  emitTaskProgress(\n                    syncTracker,\n                    foregroundTaskId,\n                    toolUseContext.toolUseId,\n                    description,\n                    agentStartTime,\n                    lastToolName,\n                  )\n                  // Keep AppState task.progress in sync when SDK summaries are\n                  // enabled, so updateAgentSummary reads correct token/tool counts\n                  // instead of zeros.\n                  if (getSdkAgentProgressSummariesEnabled()) {\n                    updateAsyncAgentProgress(\n                      foregroundTaskId,\n                      getProgressUpdate(syncTracker),\n                      rootSetAppState,\n                    )\n                  }\n                }\n              }\n\n              // Forward bash_progress events from sub-agent to parent so the SDK\n              // receives tool_progress events just as it does for the main agent.\n              if (\n                message.type === 'progress' &&\n                (message.data.type === 'bash_progress' ||\n                  message.data.type === 'powershell_progress') &&\n                onProgress\n              ) {\n                onProgress({\n                  toolUseID: message.toolUseID,\n                  data: message.data,\n                })\n              }\n\n              if (message.type !== 'assistant' && message.type !== 'user') {\n                continue\n              }\n\n              // Increment token count in spinner for assistant messages\n              // Subagent streaming events are filtered out in runAgent.ts, so we\n              // need to count tokens from completed messages here\n              if (message.type === 'assistant') {\n                const contentLength = getAssistantMessageContentLength(message)\n                if (contentLength > 0) {\n                  toolUseContext.setResponseLength(len => len + contentLength)\n                }\n              }\n\n              const normalizedNew = normalizeMessages([message])\n              for (const m of normalizedNew) {\n                for (const content of m.message.content) {\n                  if (\n                    content.type !== 'tool_use' &&\n                    content.type !== 'tool_result'\n                  ) {\n                    continue\n                  }\n\n                  // Forward progress updates\n                  if (onProgress) {\n                    onProgress({\n                      toolUseID: `agent_${assistantMessage.message.id}`,\n                      data: {\n                        message: m,\n                        type: 'agent_progress',\n                        // prompt only needed on first progress message (UI.tsx:624\n                        // reads progressMessages[0]). Omit here to avoid duplication.\n                        prompt: '',\n                        agentId: syncAgentId,\n                      },\n                    })\n                  }\n                }\n              }\n            }\n          } catch (error) {\n            // Handle errors from the sync agent loop\n            // AbortError should be re-thrown for proper interruption handling\n            if (error instanceof AbortError) {\n              wasAborted = true\n              logEvent('tengu_agent_tool_terminated', {\n                agent_type:\n                  metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                model:\n                  metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                duration_ms: Date.now() - metadata.startTime,\n                is_async: false,\n                is_built_in_agent: metadata.isBuiltInAgent,\n                reason:\n                  'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              })\n              throw error\n            }\n\n            // Log the error for debugging\n            logForDebugging(`Sync agent error: ${errorMessage(error)}`, {\n              level: 'error',\n            })\n\n            // Store the error to handle after cleanup\n            syncAgentError = toError(error)\n          } finally {\n            // Clear the background hint UI\n            if (toolUseContext.setToolJSX) {\n              toolUseContext.setToolJSX(null)\n            }\n\n            // Stop foreground summarization. Idempotent — if already stopped at\n            // the backgrounding transition, this is a no-op. The backgrounded\n            // closure owns a separate stop function (stopBackgroundedSummarization).\n            stopForegroundSummarization?.()\n\n            // Unregister foreground task if agent completed without being backgrounded\n            if (foregroundTaskId) {\n              unregisterAgentForeground(foregroundTaskId, rootSetAppState)\n              // Notify SDK consumers (e.g. VS Code subagent panel) that this\n              // foreground agent is done. Goes through drainSdkEvents() — does\n              // NOT trigger the print.ts XML task_notification parser or the LLM loop.\n              if (!wasBackgrounded) {\n                const progress = getProgressUpdate(syncTracker)\n                enqueueSdkEvent({\n                  type: 'system',\n                  subtype: 'task_notification',\n                  task_id: foregroundTaskId,\n                  tool_use_id: toolUseContext.toolUseId,\n                  status: syncAgentError\n                    ? 'failed'\n                    : wasAborted\n                      ? 'stopped'\n                      : 'completed',\n                  output_file: '',\n                  summary: description,\n                  usage: {\n                    total_tokens: progress.tokenCount,\n                    tool_uses: progress.toolUseCount,\n                    duration_ms: Date.now() - agentStartTime,\n                  },\n                })\n              }\n            }\n\n            // Clean up scoped skills so they don't accumulate in the global map\n            clearInvokedSkillsForAgent(syncAgentId)\n\n            // Clean up dumpState entry for this agent to prevent unbounded growth\n            // Skip if backgrounded — the backgrounded agent's finally handles cleanup\n            if (!wasBackgrounded) {\n              clearDumpState(syncAgentId)\n            }\n\n            // Cancel auto-background timer if agent completed before it fired\n            cancelAutoBackground?.()\n\n            // Clean up worktree if applicable (in finally to handle abort/error paths)\n            // Skip if backgrounded — the background continuation is still running in it\n            if (!wasBackgrounded) {\n              worktreeResult = await cleanupWorktreeIfNeeded()\n            }\n          }\n\n          // Re-throw abort errors\n          // TODO: Find a cleaner way to express this\n          const lastMessage = agentMessages.findLast(\n            _ => _.type !== 'system' && _.type !== 'progress',\n          )\n          if (lastMessage && isSyntheticMessage(lastMessage)) {\n            logEvent('tengu_agent_tool_terminated', {\n              agent_type:\n                metadata.agentType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              model:\n                metadata.resolvedAgentModel as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n              duration_ms: Date.now() - metadata.startTime,\n              is_async: false,\n              is_built_in_agent: metadata.isBuiltInAgent,\n              reason:\n                'user_cancel_sync' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n            })\n            throw new AbortError()\n          }\n\n          // If an error occurred during iteration, try to return a result with\n          // whatever messages we have. If we have no assistant messages,\n          // re-throw the error so it's properly handled by the tool framework.\n          if (syncAgentError) {\n            // Check if we have any assistant messages to return\n            const hasAssistantMessages = agentMessages.some(\n              msg => msg.type === 'assistant',\n            )\n\n            if (!hasAssistantMessages) {\n              // No messages collected, re-throw the error\n              throw syncAgentError\n            }\n\n            // We have some messages, try to finalize and return them\n            // This allows the parent agent to see partial progress even after an error\n            logForDebugging(\n              `Sync agent recovering from error with ${agentMessages.length} messages`,\n            )\n          }\n\n          const agentResult = finalizeAgentTool(\n            agentMessages,\n            syncAgentId,\n            metadata,\n          )\n\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            const currentAppState = toolUseContext.getAppState()\n            const handoffWarning = await classifyHandoffIfNeeded({\n              agentMessages,\n              tools: toolUseContext.options.tools,\n              toolPermissionContext: currentAppState.toolPermissionContext,\n              abortSignal: toolUseContext.abortController.signal,\n              subagentType: selectedAgent.agentType,\n              totalToolUseCount: agentResult.totalToolUseCount,\n            })\n            if (handoffWarning) {\n              agentResult.content = [\n                { type: 'text' as const, text: handoffWarning },\n                ...agentResult.content,\n              ]\n            }\n          }\n\n          return {\n            data: {\n              status: 'completed' as const,\n              prompt,\n              ...agentResult,\n              ...worktreeResult,\n            },\n          }\n        }),\n      )\n    }\n  },\n  isReadOnly() {\n    return true // delegates permission checks to its underlying tools\n  },\n  toAutoClassifierInput(input) {\n    const i = input as AgentToolInput\n    const tags = [\n      i.subagent_type,\n      i.mode ? `mode=${i.mode}` : undefined,\n    ].filter((t): t is string => t !== undefined)\n    const prefix = tags.length > 0 ? `(${tags.join(', ')}): ` : ': '\n    return `${prefix}${i.prompt}`\n  },\n  isConcurrencySafe() {\n    return true\n  },\n  userFacingName,\n  userFacingNameBackgroundColor,\n  getActivityDescription(input) {\n    return input?.description ?? 'Running task'\n  },\n  async checkPermissions(input, context): Promise<PermissionResult> {\n    const appState = context.getAppState()\n\n    // Only route through auto mode classifier when in auto mode\n    // In all other modes, auto-approve sub-agent generation\n    // Note: \"external\" === 'ant' guard enables dead code elimination for external builds\n    if (\n      \"external\" === 'ant' &&\n      appState.toolPermissionContext.mode === 'auto'\n    ) {\n      return {\n        behavior: 'passthrough',\n        message: 'Agent tool requires permission to spawn sub-agents.',\n      }\n    }\n\n    return { behavior: 'allow', updatedInput: input }\n  },\n  mapToolResultToToolResultBlockParam(data, toolUseID) {\n    // Multi-agent spawn result\n    const internalData = data as InternalOutput\n    if (\n      typeof internalData === 'object' &&\n      internalData !== null &&\n      'status' in internalData &&\n      internalData.status === 'teammate_spawned'\n    ) {\n      const spawnData = internalData as TeammateSpawnedOutput\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Spawned successfully.\nagent_id: ${spawnData.teammate_id}\nname: ${spawnData.name}\nteam_name: ${spawnData.team_name}\nThe agent is now running and will receive instructions via mailbox.`,\n          },\n        ],\n      }\n    }\n    if ('status' in internalData && internalData.status === 'remote_launched') {\n      const r = internalData\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text: `Remote agent launched in CCR.\\ntaskId: ${r.taskId}\\nsession_url: ${r.sessionUrl}\\noutput_file: ${r.outputFile}\\nThe agent is running remotely. You will be notified automatically when it completes.\\nBriefly tell the user what you launched and end your response.`,\n          },\n        ],\n      }\n    }\n    if (data.status === 'async_launched') {\n      const prefix = `Async agent launched successfully.\\nagentId: ${data.agentId} (internal ID - do not mention to user. Use SendMessage with to: '${data.agentId}' to continue this agent.)\\nThe agent is working in the background. You will be notified automatically when it completes.`\n      const instructions = data.canReadOutputFile\n        ? `Do not duplicate this agent's work — avoid working with the same files or topics it is using. Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.\\noutput_file: ${data.outputFile}\\nIf asked, you can check progress before completion by using ${FILE_READ_TOOL_NAME} or ${BASH_TOOL_NAME} tail on the output file.`\n        : `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`\n      const text = `${prefix}\\n${instructions}`\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          {\n            type: 'text',\n            text,\n          },\n        ],\n      }\n    }\n    if (data.status === 'completed') {\n      const worktreeData = data as Record<string, unknown>\n      const worktreeInfoText = worktreeData.worktreePath\n        ? `\\nworktreePath: ${worktreeData.worktreePath}\\nworktreeBranch: ${worktreeData.worktreeBranch}`\n        : ''\n      // If the subagent completes with no content, the tool_result is just the\n      // agentId/usage trailer below — a metadata-only block at the prompt tail.\n      // Some models read that as \"nothing to act on\" and end their turn\n      // immediately. Say so explicitly so the parent has something to react to.\n      const contentOrMarker =\n        data.content.length > 0\n          ? data.content\n          : [\n              {\n                type: 'text' as const,\n                text: '(Subagent completed but returned no output.)',\n              },\n            ]\n      // One-shot built-ins (Explore, Plan) are never continued via SendMessage\n      // — the agentId hint and <usage> block are dead weight (~135 chars ×\n      // 34M Explore runs/week ≈ 1-2 Gtok/week). Telemetry doesn't parse this\n      // block (it uses logEvent in finalizeAgentTool), so dropping is safe.\n      // agentType is optional for resume compat — missing means show trailer.\n      if (\n        data.agentType &&\n        ONE_SHOT_BUILTIN_AGENT_TYPES.has(data.agentType) &&\n        !worktreeInfoText\n      ) {\n        return {\n          tool_use_id: toolUseID,\n          type: 'tool_result',\n          content: contentOrMarker,\n        }\n      }\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result',\n        content: [\n          ...contentOrMarker,\n          {\n            type: 'text',\n            text: `agentId: ${data.agentId} (use SendMessage with to: '${data.agentId}' to continue this agent)${worktreeInfoText}\n<usage>total_tokens: ${data.totalTokens}\ntool_uses: ${data.totalToolUseCount}\nduration_ms: ${data.totalDurationMs}</usage>`,\n          },\n        ],\n      }\n    }\n    data satisfies never\n    throw new Error(\n      `Unexpected agent tool result status: ${(data as { status: string }).status}`,\n    )\n  },\n  renderToolResultMessage,\n  renderToolUseMessage,\n  renderToolUseTag,\n  renderToolUseProgressMessage,\n  renderToolUseRejectedMessage,\n  renderToolUseErrorMessage,\n  renderGroupedToolUse: renderGroupedAgentToolUse,\n} satisfies ToolDef<InputSchema, Output, Progress>)\n\nfunction resolveTeamName(\n  input: { team_name?: string },\n  appState: { teamContext?: { teamName: string } },\n): string | undefined {\n  if (!isAgentSwarmsEnabled()) return undefined\n  return input.team_name || appState.teamContext?.teamName\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/tools/WebSearchTool/WebSearchTool.ts b/src/tools/WebSearchTool/WebSearchTool.ts
index bbe12eb7..1410452a 100644
--- a/src/tools/WebSearchTool/WebSearchTool.ts
+++ b/src/tools/WebSearchTool/WebSearchTool.ts
@@ -7,6 +7,11 @@ import type { PermissionResult } from 'src/utils/permissions/PermissionResult.js
 import { z } from 'zod/v4'
 import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
 import { queryModelWithStreaming } from '../../services/api/claude.js'
+import { collectCodexCompletedResponse } from '../../services/api/codexShim.js'
+import {
+  resolveCodexApiCredentials,
+  resolveProviderRequest,
+} from '../../services/api/providerConfig.js'
 import { buildTool, type ToolDef } from '../../Tool.js'
 import { lazySchema } from '../../utils/lazySchema.js'
 import { logError } from '../../utils/log.js'
@@ -83,6 +88,213 @@ function makeToolSchema(input: Input): BetaWebSearchTool20250305 {
   }
 }
 
+function isCodexResponsesWebSearchEnabled(): boolean {
+  if (getAPIProvider() !== 'openai') {
+    return false
+  }
+
+  const request = resolveProviderRequest({
+    model: getMainLoopModel(),
+    baseUrl: process.env.OPENAI_BASE_URL,
+  })
+  return request.transport === 'codex_responses'
+}
+
+function makeCodexWebSearchTool(input: Input): Record<string, unknown> {
+  const tool: Record<string, unknown> = {
+    type: 'web_search',
+  }
+
+  if (input.allowed_domains?.length) {
+    tool.filters = {
+      allowed_domains: input.allowed_domains,
+    }
+  }
+
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
+  if (timezone) {
+    tool.user_location = {
+      type: 'approximate',
+      timezone,
+    }
+  }
+
+  return tool
+}
+
+function buildCodexWebSearchInputText(input: Input): string {
+  if (!input.blocked_domains?.length) {
+    return input.query
+  }
+
+  // Responses web_search supports allowed_domains filters but not blocked domains.
+  // Convert blocked domains into common search-engine exclusion operators so the
+  // constraint still affects ranking and candidate selection.
+  const excludedSites = input.blocked_domains.map(domain => `-site:${domain}`)
+  return `${input.query} ${excludedSites.join(' ')}`
+}
+
+function buildCodexWebSearchInput(input: Input): Array<Record<string, unknown>> {
+  return [
+    {
+      type: 'message',
+      role: 'user',
+      content: [
+        {
+          type: 'input_text',
+          text: buildCodexWebSearchInputText(input),
+        },
+      ],
+    },
+  ]
+}
+
+function buildCodexWebSearchInstructions(): string {
+  return [
+    'You are the OpenClaude web search tool.',
+    'Search the web for the user query and return a concise factual answer.',
+    'Include source URLs in the response.',
+  ].join(' ')
+}
+
+function makeOutputFromCodexWebSearchResponse(
+  response: Record<string, unknown>,
+  query: string,
+  durationSeconds: number,
+): Output {
+  const results: (SearchResult | string)[] = []
+  const sourceMap = new Map<string, { title: string; url: string }>()
+  const output = Array.isArray(response.output) ? response.output : []
+
+  for (const item of output) {
+    if (item?.type === 'web_search_call') {
+      const sources = Array.isArray(item.action?.sources)
+        ? item.action.sources
+        : []
+      for (const source of sources) {
+        if (typeof source?.url !== 'string' || !source.url) continue
+        sourceMap.set(source.url, {
+          title:
+            typeof source.title === 'string' && source.title
+              ? source.title
+              : source.url,
+          url: source.url,
+        })
+      }
+      continue
+    }
+
+    if (item?.type !== 'message' || !Array.isArray(item.content)) {
+      continue
+    }
+
+    for (const part of item.content) {
+      if (part?.type === 'output_text' && typeof part.text === 'string') {
+        const trimmed = part.text.trim()
+        if (trimmed) {
+          results.push(trimmed)
+        }
+      }
+
+      const annotations = Array.isArray(part?.annotations)
+        ? part.annotations
+        : []
+      for (const annotation of annotations) {
+        if (annotation?.type !== 'url_citation') continue
+        if (typeof annotation.url !== 'string' || !annotation.url) continue
+        sourceMap.set(annotation.url, {
+          title:
+            typeof annotation.title === 'string' && annotation.title
+              ? annotation.title
+              : annotation.url,
+          url: annotation.url,
+        })
+      }
+    }
+  }
+
+  if (results.length === 0 && typeof response.output_text === 'string') {
+    const trimmed = response.output_text.trim()
+    if (trimmed) {
+      results.push(trimmed)
+    }
+  }
+
+  if (sourceMap.size > 0) {
+    results.push({
+      tool_use_id: 'codex-web-search',
+      content: Array.from(sourceMap.values()),
+    })
+  }
+
+  return {
+    query,
+    results,
+    durationSeconds,
+  }
+}
+
+async function runCodexWebSearch(
+  input: Input,
+  signal: AbortSignal,
+): Promise<Output> {
+  const startTime = performance.now()
+  const request = resolveProviderRequest({
+    model: getMainLoopModel(),
+    baseUrl: process.env.OPENAI_BASE_URL,
+  })
+  const credentials = resolveCodexApiCredentials()
+
+  if (!credentials.apiKey) {
+    throw new Error('Codex web search requires CODEX_API_KEY or a valid auth.json.')
+  }
+  if (!credentials.accountId) {
+    throw new Error(
+      'Codex web search requires CHATGPT_ACCOUNT_ID or an auth.json with chatgpt_account_id.',
+    )
+  }
+
+  const body: Record<string, unknown> = {
+    model: request.resolvedModel,
+    input: buildCodexWebSearchInput(input),
+    instructions: buildCodexWebSearchInstructions(),
+    tools: [makeCodexWebSearchTool(input)],
+    tool_choice: 'required',
+    include: ['web_search_call.action.sources'],
+    store: false,
+    stream: true,
+  }
+
+  if (request.reasoning) {
+    body.reasoning = request.reasoning
+  }
+
+  const response = await fetch(`${request.baseUrl}/responses`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${credentials.apiKey}`,
+      'chatgpt-account-id': credentials.accountId,
+      originator: 'openclaude',
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => 'unknown error')
+    throw new Error(`Codex web search error ${response.status}: ${errorBody}`)
+  }
+
+  const payload = await collectCodexCompletedResponse(response)
+  const endTime = performance.now()
+  return makeOutputFromCodexWebSearchResponse(
+    payload,
+    input.query,
+    (endTime - startTime) / 1000,
+  )
+}
+
 function makeOutputFromSearchResponse(
   result: BetaContentBlock[],
   query: string,
@@ -169,6 +381,10 @@ export const WebSearchTool = buildTool({
     const provider = getAPIProvider()
     const model = getMainLoopModel()
 
+    if (isCodexResponsesWebSearchEnabled()) {
+      return true
+    }
+
     // Enable for firstParty
     if (provider === 'firstParty') {
       return true
@@ -221,6 +437,12 @@ export const WebSearchTool = buildTool({
     }
   },
   async prompt() {
+    if (isCodexResponsesWebSearchEnabled()) {
+      return getWebSearchPrompt().replace(
+        /\n\s*-\s*Web search is only available in the US/,
+        '',
+      )
+    }
     return getWebSearchPrompt()
   },
   renderToolUseMessage,
@@ -252,6 +474,12 @@ export const WebSearchTool = buildTool({
     return { result: true }
   },
   async call(input, context, _canUseTool, _parentMessage, onProgress) {
+    if (isCodexResponsesWebSearchEnabled()) {
+      return {
+        data: await runCodexWebSearch(input, context.abortController.signal),
+      }
+    }
+
     const startTime = performance.now()
     const { query } = input
     const userMessage = createUserMessage({
diff --git a/src/utils/auth.ts b/src/utils/auth.ts
index b1cd024e..37d1ca1f 100644
--- a/src/utils/auth.ts
+++ b/src/utils/auth.ts
@@ -117,7 +117,8 @@ export function isAnthropicAuthEnabled(): boolean {
     isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
-    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
 
   // Check if user has configured an external API key source
   // This allows externally-provided API keys to work (without requiring proxy configuration)
@@ -1731,14 +1732,15 @@ export function getSubscriptionName(): string {
   }
 }
 
-/** Check if using third-party services (Bedrock or Vertex or Foundry or OpenAI-compatible or Gemini) */
+/** Check if using third-party services (Bedrock or Vertex or Foundry or OpenAI-compatible or Gemini or GitHub Models) */
 export function isUsing3PServices(): boolean {
   return !!(
     isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY) ||
     isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
-    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
   )
 }
 
diff --git a/src/utils/autoUpdater.ts b/src/utils/autoUpdater.ts
index 2a5fc6f9..4d4c2bf3 100644
--- a/src/utils/autoUpdater.ts
+++ b/src/utils/autoUpdater.ts
@@ -9,6 +9,7 @@ import {
   logEvent,
 } from 'src/services/analytics/index.js'
 import { type ReleaseChannel, saveGlobalConfig } from './config.js'
+import { getAPIProvider } from './model/providers.js'
 import { logForDebugging } from './debug.js'
 import { env } from './env.js'
 import { getClaudeConfigHomeDir } from './envUtils.js'
@@ -72,6 +73,12 @@ export async function assertMinVersion(): Promise<void> {
     return
   }
 
+  // Skip version check for third-party providers — the min version
+  // kill-switch is Anthropic-specific and should not block 3P users
+  if (getAPIProvider() !== 'firstParty') {
+    return
+  }
+
   try {
     const versionConfig = await getDynamicConfig_BLOCKS_ON_INIT<{
       minVersion: string
diff --git a/src/utils/context.ts b/src/utils/context.ts
index f13b2b0a..4eae1782 100644
--- a/src/utils/context.ts
+++ b/src/utils/context.ts
@@ -74,10 +74,9 @@ export function getContextWindowForModel(
 
   // OpenAI-compatible provider — use known context windows for the model
   if (
-    process.env.CLAUDE_CODE_USE_OPENAI === '1' ||
-    process.env.CLAUDE_CODE_USE_OPENAI === 'true' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === '1' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === 'true'
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
   ) {
     const openaiWindow = getOpenAIContextWindow(model)
     if (openaiWindow !== undefined) {
@@ -178,10 +177,9 @@ export function getModelMaxOutputTokens(model: string): {
 
   // OpenAI-compatible provider — use known output limits to avoid 400 errors
   if (
-    process.env.CLAUDE_CODE_USE_OPENAI === '1' ||
-    process.env.CLAUDE_CODE_USE_OPENAI === 'true' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === '1' ||
-    process.env.CLAUDE_CODE_USE_GEMINI === 'true'
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI) ||
+    isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
   ) {
     const openaiMax = getOpenAIMaxOutputTokens(model)
     if (openaiMax !== undefined) {
diff --git a/src/utils/effort.ts b/src/utils/effort.ts
index cafcf3de..2a391ee6 100644
--- a/src/utils/effort.ts
+++ b/src/utils/effort.ts
@@ -17,6 +17,14 @@ export const EFFORT_LEVELS = [
   'max',
 ] as const satisfies readonly EffortLevel[]
 
+export const OPENAI_EFFORT_LEVELS = [
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+] as const
+
+export type OpenAIEffortLevel = typeof OPENAI_EFFORT_LEVELS[number]
 export type EffortValue = EffortLevel | number
 
 // @[MODEL LAUNCH]: Add the new model to the allowlist if it supports the effort parameter.
@@ -68,6 +76,46 @@ export function isEffortLevel(value: string): value is EffortLevel {
   return (EFFORT_LEVELS as readonly string[]).includes(value)
 }
 
+export function isOpenAIEffortLevel(value: string): value is OpenAIEffortLevel {
+  return (OPENAI_EFFORT_LEVELS as readonly string[]).includes(value)
+}
+
+export function modelUsesOpenAIEffort(model: string): boolean {
+  const provider = getAPIProvider()
+  return provider === 'openai' || provider === 'codex'
+}
+
+export function getAvailableEffortLevels(model: string): EffortLevel[] | OpenAIEffortLevel[] {
+  if (modelUsesOpenAIEffort(model)) {
+    return [...OPENAI_EFFORT_LEVELS] as OpenAIEffortLevel[]
+  }
+  const levels: EffortLevel[] = ['low', 'medium', 'high']
+  if (modelSupportsMaxEffort(model)) {
+    levels.push('max')
+  }
+  return levels
+}
+
+export function getEffortLevelLabel(level: EffortLevel | OpenAIEffortLevel): string {
+  if (level === 'xhigh') return 'Extra High'
+  if (level === 'max') return 'Max'
+  return capitalize(level)
+}
+
+export function openAIEffortToStandard(level: OpenAIEffortLevel): EffortLevel {
+  if (level === 'xhigh') return 'max'
+  return level
+}
+
+export function standardEffortToOpenAI(level: EffortLevel): OpenAIEffortLevel {
+  if (level === 'max') return 'xhigh'
+  return level as OpenAIEffortLevel
+}
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
 export function parseEffortValue(value: unknown): EffortValue | undefined {
   if (value === undefined || value === null || value === '') {
     return undefined
@@ -221,7 +269,7 @@ export function convertEffortValueToLevel(value: EffortValue): EffortLevel {
  * @param level The effort level to describe
  * @returns Human-readable description
  */
-export function getEffortLevelDescription(level: EffortLevel): string {
+export function getEffortLevelDescription(level: EffortLevel | OpenAIEffortLevel): string {
   switch (level) {
     case 'low':
       return 'Quick, straightforward implementation with minimal overhead'
@@ -231,6 +279,8 @@ export function getEffortLevelDescription(level: EffortLevel): string {
       return 'Comprehensive implementation with extensive testing and documentation'
     case 'max':
       return 'Maximum capability with deepest reasoning (Opus 4.6 only)'
+    case 'xhigh':
+      return 'Extra high reasoning effort for complex tasks (OpenAI/Codex)'
   }
 }
 
diff --git a/src/utils/githubModelsCredentials.hydrate.test.ts b/src/utils/githubModelsCredentials.hydrate.test.ts
new file mode 100644
index 00000000..23b0a5ee
--- /dev/null
+++ b/src/utils/githubModelsCredentials.hydrate.test.ts
@@ -0,0 +1,66 @@
+/**
+ * Hydrate tests live in a separate file with no static import of
+ * githubModelsCredentials so Bun's mock.module can replace secureStorage
+ * before that module is first loaded.
+ */
+import { afterEach, describe, expect, mock, test } from 'bun:test'
+
+describe('hydrateGithubModelsTokenFromSecureStorage', () => {
+  const orig = {
+    CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
+    GITHUB_TOKEN: process.env.GITHUB_TOKEN,
+    GH_TOKEN: process.env.GH_TOKEN,
+    CLAUDE_CODE_SIMPLE: process.env.CLAUDE_CODE_SIMPLE,
+  }
+
+  afterEach(() => {
+    mock.restore()
+    for (const [k, v] of Object.entries(orig)) {
+      if (v === undefined) {
+        delete process.env[k as keyof typeof orig]
+      } else {
+        process.env[k as keyof typeof orig] = v
+      }
+    }
+  })
+
+  test('sets GITHUB_TOKEN from secure storage when USE_GITHUB and env token empty', async () => {
+    process.env.CLAUDE_CODE_USE_GITHUB = '1'
+    delete process.env.GITHUB_TOKEN
+    delete process.env.GH_TOKEN
+    delete process.env.CLAUDE_CODE_SIMPLE
+
+    mock.module('./secureStorage/index.js', () => ({
+      getSecureStorage: () => ({
+        read: () => ({
+          githubModels: { accessToken: 'stored-secret' },
+        }),
+      }),
+    }))
+
+    const { hydrateGithubModelsTokenFromSecureStorage } = await import(
+      './githubModelsCredentials.js'
+    )
+    hydrateGithubModelsTokenFromSecureStorage()
+    expect(process.env.GITHUB_TOKEN).toBe('stored-secret')
+  })
+
+  test('does not override existing GITHUB_TOKEN', async () => {
+    process.env.CLAUDE_CODE_USE_GITHUB = '1'
+    process.env.GITHUB_TOKEN = 'already'
+
+    mock.module('./secureStorage/index.js', () => ({
+      getSecureStorage: () => ({
+        read: () => ({
+          githubModels: { accessToken: 'stored-secret' },
+        }),
+      }),
+    }))
+
+    const { hydrateGithubModelsTokenFromSecureStorage } = await import(
+      './githubModelsCredentials.js'
+    )
+    hydrateGithubModelsTokenFromSecureStorage()
+    expect(process.env.GITHUB_TOKEN).toBe('already')
+  })
+})
diff --git a/src/utils/githubModelsCredentials.test.ts b/src/utils/githubModelsCredentials.test.ts
new file mode 100644
index 00000000..81c3cdcc
--- /dev/null
+++ b/src/utils/githubModelsCredentials.test.ts
@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  clearGithubModelsToken,
+  readGithubModelsToken,
+  saveGithubModelsToken,
+} from './githubModelsCredentials.js'
+
+describe('readGithubModelsToken', () => {
+  test('returns undefined in bare mode', () => {
+    const prev = process.env.CLAUDE_CODE_SIMPLE
+    process.env.CLAUDE_CODE_SIMPLE = '1'
+    expect(readGithubModelsToken()).toBeUndefined()
+    if (prev === undefined) {
+      delete process.env.CLAUDE_CODE_SIMPLE
+    } else {
+      process.env.CLAUDE_CODE_SIMPLE = prev
+    }
+  })
+})
+
+describe('saveGithubModelsToken / clearGithubModelsToken', () => {
+  test('save returns failure in bare mode', () => {
+    const prev = process.env.CLAUDE_CODE_SIMPLE
+    process.env.CLAUDE_CODE_SIMPLE = '1'
+    const r = saveGithubModelsToken('abc')
+    expect(r.success).toBe(false)
+    expect(r.warning).toContain('Bare mode')
+    if (prev === undefined) {
+      delete process.env.CLAUDE_CODE_SIMPLE
+    } else {
+      process.env.CLAUDE_CODE_SIMPLE = prev
+    }
+  })
+
+  test('clear succeeds in bare mode', () => {
+    const prev = process.env.CLAUDE_CODE_SIMPLE
+    process.env.CLAUDE_CODE_SIMPLE = '1'
+    expect(clearGithubModelsToken().success).toBe(true)
+    if (prev === undefined) {
+      delete process.env.CLAUDE_CODE_SIMPLE
+    } else {
+      process.env.CLAUDE_CODE_SIMPLE = prev
+    }
+  })
+})
+
diff --git a/src/utils/githubModelsCredentials.ts b/src/utils/githubModelsCredentials.ts
new file mode 100644
index 00000000..83d5934c
--- /dev/null
+++ b/src/utils/githubModelsCredentials.ts
@@ -0,0 +1,73 @@
+import { isBareMode, isEnvTruthy } from './envUtils.js'
+import { getSecureStorage } from './secureStorage/index.js'
+
+/** JSON key in the shared OpenClaude secure storage blob. */
+export const GITHUB_MODELS_STORAGE_KEY = 'githubModels' as const
+
+export type GithubModelsCredentialBlob = {
+  accessToken: string
+}
+
+export function readGithubModelsToken(): string | undefined {
+  if (isBareMode()) return undefined
+  try {
+    const data = getSecureStorage().read() as
+      | ({ githubModels?: GithubModelsCredentialBlob } & Record<string, unknown>)
+      | null
+    const t = data?.githubModels?.accessToken?.trim()
+    return t || undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * If GitHub Models mode is on and no token is in the environment, copy the
+ * stored token into process.env so the OpenAI shim and validation see it.
+ */
+export function hydrateGithubModelsTokenFromSecureStorage(): void {
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)) {
+    return
+  }
+  if (process.env.GITHUB_TOKEN?.trim() || process.env.GH_TOKEN?.trim()) {
+    return
+  }
+  if (isBareMode()) {
+    return
+  }
+  const t = readGithubModelsToken()
+  if (t) {
+    process.env.GITHUB_TOKEN = t
+  }
+}
+
+export function saveGithubModelsToken(token: string): {
+  success: boolean
+  warning?: string
+} {
+  if (isBareMode()) {
+    return { success: false, warning: 'Bare mode: secure storage is disabled.' }
+  }
+  const trimmed = token.trim()
+  if (!trimmed) {
+    return { success: false, warning: 'Token is empty.' }
+  }
+  const secureStorage = getSecureStorage()
+  const prev = secureStorage.read() || {}
+  const merged = {
+    ...(prev as Record<string, unknown>),
+    [GITHUB_MODELS_STORAGE_KEY]: { accessToken: trimmed },
+  }
+  return secureStorage.update(merged as typeof prev)
+}
+
+export function clearGithubModelsToken(): { success: boolean; warning?: string } {
+  if (isBareMode()) {
+    return { success: true }
+  }
+  const secureStorage = getSecureStorage()
+  const prev = secureStorage.read() || {}
+  const next = { ...(prev as Record<string, unknown>) }
+  delete next[GITHUB_MODELS_STORAGE_KEY]
+  return secureStorage.update(next as typeof prev)
+}
diff --git a/src/utils/managedEnvConstants.ts b/src/utils/managedEnvConstants.ts
index 12c56565..86b2da29 100644
--- a/src/utils/managedEnvConstants.ts
+++ b/src/utils/managedEnvConstants.ts
@@ -18,6 +18,7 @@ const PROVIDER_MANAGED_ENV_VARS = new Set([
   'CLAUDE_CODE_USE_BEDROCK',
   'CLAUDE_CODE_USE_VERTEX',
   'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_USE_GITHUB',
   // Endpoint config (base URLs, project/resource identifiers)
   'ANTHROPIC_BASE_URL',
   'ANTHROPIC_BEDROCK_BASE_URL',
@@ -147,6 +148,7 @@ export const SAFE_ENV_VARS = new Set([
   'CLAUDE_CODE_SUBAGENT_MODEL',
   'CLAUDE_CODE_USE_BEDROCK',
   'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_USE_GITHUB',
   'CLAUDE_CODE_USE_VERTEX',
   'DISABLE_AUTOUPDATER',
   'DISABLE_BUG_COMMAND',
diff --git a/src/utils/model/aliases.ts b/src/utils/model/aliases.ts
index 91514da1..75ae388c 100644
--- a/src/utils/model/aliases.ts
+++ b/src/utils/model/aliases.ts
@@ -6,8 +6,6 @@ export const MODEL_ALIASES = [
   'sonnet[1m]',
   'opus[1m]',
   'opusplan',
-  'codexplan',
-  'codexspark',
 ] as const
 export type ModelAlias = (typeof MODEL_ALIASES)[number]
 
diff --git a/src/utils/model/model.ts b/src/utils/model/model.ts
index 6c81a8ef..97a74d95 100644
--- a/src/utils/model/model.ts
+++ b/src/utils/model/model.ts
@@ -123,6 +123,10 @@ export function getDefaultOpusModel(): ModelName {
   if (getAPIProvider() === 'openai') {
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
+  // Codex provider: use user-specified model or default to gpt-5.4
+  if (getAPIProvider() === 'codex') {
+    return process.env.OPENAI_MODEL || 'gpt-5.4'
+  }
   // 3P providers (Bedrock, Vertex, Foundry) — kept as a separate branch
   // even when values match, since 3P availability lags firstParty and
   // these will diverge again at the next model launch.
@@ -145,6 +149,10 @@ export function getDefaultSonnetModel(): ModelName {
   if (getAPIProvider() === 'openai') {
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
+  // Codex provider
+  if (getAPIProvider() === 'codex') {
+    return process.env.OPENAI_MODEL || 'gpt-5.4'
+  }
   // Default to Sonnet 4.5 for 3P since they may not have 4.6 yet
   if (getAPIProvider() !== 'firstParty') {
     return getModelStrings().sonnet45
@@ -165,6 +173,10 @@ export function getDefaultHaikuModel(): ModelName {
   if (getAPIProvider() === 'openai') {
     return process.env.OPENAI_MODEL || 'gpt-4o-mini'
   }
+  // Codex provider
+  if (getAPIProvider() === 'codex') {
+    return process.env.OPENAI_MODEL || 'gpt-5.4'
+  }
 
   // Haiku 4.5 is available on all platforms (first-party, Foundry, Bedrock, Vertex)
   return getModelStrings().haiku45
@@ -217,6 +229,10 @@ export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
   if (getAPIProvider() === 'openai') {
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
+  // Codex provider: always use the configured Codex model (default gpt-5.4)
+  if (getAPIProvider() === 'codex') {
+    return process.env.OPENAI_MODEL || 'gpt-5.4'
+  }
 
   // Ants default to defaultModel from flag config, or Opus 1M if not configured
   if (process.env.USER_TYPE === 'ant') {
@@ -343,12 +359,6 @@ export function renderDefaultModelSetting(
   if (setting === 'opusplan') {
     return 'Opus 4.6 in plan mode, else Sonnet 4.6'
   }
-  if (setting === 'codexplan') {
-    return 'Codex Plan (GPT-5.4 high reasoning)'
-  }
-  if (setting === 'codexspark') {
-    return 'Codex Spark (GPT-5.3 Codex Spark)'
-  }
   return renderModelName(parseUserSpecifiedModel(setting))
 }
 
@@ -383,11 +393,12 @@ export function renderModelSetting(setting: ModelName | ModelAlias): string {
   if (setting === 'opusplan') {
     return 'Opus Plan'
   }
+  // Handle Codex models - show actual model name + resolved model
   if (setting === 'codexplan') {
-    return 'Codex Plan'
+    return 'codexplan (gpt-5.4)'
   }
   if (setting === 'codexspark') {
-    return 'Codex Spark'
+    return 'codexspark (gpt-5.3-codex-spark)'
   }
   if (isModelAlias(setting)) {
     return capitalize(setting)
@@ -401,8 +412,8 @@ export function renderModelSetting(setting: ModelName | ModelAlias): string {
  * if the model is not recognized as a public model.
  */
 export function getPublicModelDisplayName(model: ModelName): string | null {
-  // For OpenAI/Gemini providers, show the actual model name not a Claude alias
-  if (getAPIProvider() === 'openai' || getAPIProvider() === 'gemini') {
+  // For OpenAI/Gemini/Codex providers, show the actual model name not a Claude alias
+  if (getAPIProvider() === 'openai' || getAPIProvider() === 'gemini' || getAPIProvider() === 'codex') {
     return null
   }
   switch (model) {
@@ -517,10 +528,6 @@ export function parseUserSpecifiedModel(
 
   if (isModelAlias(modelString)) {
     switch (modelString) {
-      case 'codexplan':
-        return modelInputTrimmed
-      case 'codexspark':
-        return modelInputTrimmed
       case 'opusplan':
         return getDefaultSonnetModel() + (has1mTag ? '[1m]' : '') // Sonnet is default, Opus in plan mode
       case 'sonnet':
@@ -535,6 +542,14 @@ export function parseUserSpecifiedModel(
     }
   }
 
+  // Handle Codex aliases - map to actual model names
+  if (modelString === 'codexplan') {
+    return 'gpt-5.4'
+  }
+  if (modelString === 'codexspark') {
+    return 'gpt-5.3-codex-spark'
+  }
+
   // Opus 4/4.1 are no longer available on the first-party API (same as
   // Claude.ai) — silently remap to the current Opus default. The 'opus'
   // alias already resolves to 4.6, so the only users on these explicit
diff --git a/src/utils/model/modelOptions.ts b/src/utils/model/modelOptions.ts
index 0c464d6a..84371c84 100644
--- a/src/utils/model/modelOptions.ts
+++ b/src/utils/model/modelOptions.ts
@@ -268,20 +268,65 @@ function getOpusPlanOption(): ModelOption {
 
 function getCodexPlanOption(): ModelOption {
   return {
-    value: 'codexplan',
-    label: 'Codex Plan',
+    value: 'gpt-5.4',
+    label: 'gpt-5.4',
     description: 'GPT-5.4 on the Codex backend with high reasoning',
   }
 }
 
 function getCodexSparkOption(): ModelOption {
   return {
-    value: 'codexspark',
-    label: 'Codex Spark',
+    value: 'gpt-5.3-codex-spark',
+    label: 'gpt-5.3-codex-spark',
     description: 'GPT-5.3 Codex Spark on the Codex backend for fast tool loops',
   }
 }
 
+function getCodexModelOptions(): ModelOption[] {
+  return [
+    {
+      value: 'gpt-5.4',
+      label: 'gpt-5.4',
+      description: 'GPT-5.4 with high reasoning',
+    },
+    {
+      value: 'gpt-5.3-codex',
+      label: 'gpt-5.3-codex',
+      description: 'GPT-5.3 Codex with high reasoning',
+    },
+    {
+      value: 'gpt-5.3-codex-spark',
+      label: 'gpt-5.3-codex-spark',
+      description: 'GPT-5.3 Codex Spark for fast tool loops',
+    },
+    {
+      value: 'codexspark',
+      label: 'codexspark',
+      description: 'GPT-5.3 Codex Spark alias for fast tool loops',
+    },
+    {
+      value: 'gpt-5.2-codex',
+      label: 'gpt-5.2-codex',
+      description: 'GPT-5.2 Codex with high reasoning',
+    },
+    {
+      value: 'gpt-5.1-codex-max',
+      label: 'gpt-5.1-codex-max',
+      description: 'GPT-5.1 Codex Max for deep reasoning',
+    },
+    {
+      value: 'gpt-5.1-codex-mini',
+      label: 'gpt-5.1-codex-mini',
+      description: 'GPT-5.1 Codex Mini - faster, cheaper',
+    },
+    {
+      value: 'gpt-5.4-mini',
+      label: 'gpt-5.4-mini',
+      description: 'GPT-5.4 Mini - faster, cheaper',
+    },
+  ]
+}
+
 // @[MODEL LAUNCH]: Update the model picker lists below to include/reorder options for the new model.
 // Each user tier (ant, Max/Team Premium, Pro/Team Standard/Enterprise, PAYG 1P, PAYG 3P) has its own list.
 function getModelOptionsBase(fastMode = false): ModelOption[] {
@@ -360,8 +405,9 @@ function getModelOptionsBase(fastMode = false): ModelOption[] {
   // PAYG 3P: Default (Sonnet 4.5) + Sonnet (3P custom) or Sonnet 4.6/1M + Opus (3P custom) or Opus 4.1/Opus 4.6/Opus1M + Haiku + Opus 4.1
   const payg3pOptions = [getDefaultOptionForUser(fastMode)]
 
-  if (getAPIProvider() === 'openai') {
-    payg3pOptions.push(getCodexPlanOption(), getCodexSparkOption())
+  // Add Codex models for openai and codex providers
+  if (getAPIProvider() === 'openai' || getAPIProvider() === 'codex') {
+    payg3pOptions.push(...getCodexModelOptions())
   }
 
   const customSonnet = getCustomSonnetOption()
@@ -517,9 +563,9 @@ export function getModelOptions(fastMode = false): ModelOption[] {
     return filterModelOptionsByAllowlist(options)
   } else if (customModel === 'opusplan') {
     return filterModelOptionsByAllowlist([...options, getOpusPlanOption()])
-  } else if (customModel === 'codexplan') {
+  } else if (customModel === 'gpt-5.4') {
     return filterModelOptionsByAllowlist([...options, getCodexPlanOption()])
-  } else if (customModel === 'codexspark') {
+  } else if (customModel === 'gpt-5.3-codex-spark') {
     return filterModelOptionsByAllowlist([...options, getCodexSparkOption()])
   } else if (customModel === 'opus' && getAPIProvider() === 'firstParty') {
     return filterModelOptionsByAllowlist([
@@ -554,11 +600,23 @@ export function getModelOptions(fastMode = false): ModelOption[] {
  */
 function filterModelOptionsByAllowlist(options: ModelOption[]): ModelOption[] {
   const settings = getSettings_DEPRECATED() || {}
-  if (!settings.availableModels) {
-    return options // No restrictions
-  }
-  return options.filter(
+  const filtered = !settings.availableModels
+    ? options // No restrictions
+    : options.filter(
     opt =>
       opt.value === null || (opt.value !== null && isModelAllowed(opt.value)),
   )
+
+  // Select state uses option values as identity keys. If two entries share the
+  // same value (e.g. provider-specific aliases collapsing to one model ID),
+  // navigation/focus can become inconsistent and appear as duplicate rendering.
+  const seen = new Set<string>()
+  return filtered.filter(opt => {
+    const key = String(opt.value)
+    if (seen.has(key)) {
+      return false
+    }
+    seen.add(key)
+    return true
+  })
 }
diff --git a/src/utils/model/modelStrings.ts b/src/utils/model/modelStrings.ts
index 5b7be104..4d8399d1 100644
--- a/src/utils/model/modelStrings.ts
+++ b/src/utils/model/modelStrings.ts
@@ -23,9 +23,12 @@ export type ModelStrings = Record<ModelKey, string>
 const MODEL_KEYS = Object.keys(ALL_MODEL_CONFIGS) as ModelKey[]
 
 function getBuiltinModelStrings(provider: APIProvider): ModelStrings {
+  // Codex piggybacks on the OpenAI provider transport for Anthropic tier aliases.
+  // Reuse OpenAI mappings so model string lookups never return undefined.
+  const providerKey = provider === 'codex' ? 'openai' : provider
   const out = {} as ModelStrings
   for (const key of MODEL_KEYS) {
-    out[key] = ALL_MODEL_CONFIGS[key][provider]
+    out[key] = ALL_MODEL_CONFIGS[key][providerKey]
   }
   return out
 }
diff --git a/src/utils/model/openaiContextWindows.ts b/src/utils/model/openaiContextWindows.ts
index 4a31a8e5..6cb12c37 100644
--- a/src/utils/model/openaiContextWindows.ts
+++ b/src/utils/model/openaiContextWindows.ts
@@ -44,6 +44,11 @@ const OPENAI_CONTEXT_WINDOWS: Record<string, number> = {
   'google/gemini-2.0-flash':1_048_576,
   'google/gemini-2.5-pro':  1_048_576,
 
+  // Google (native via CLAUDE_CODE_USE_GEMINI)
+  'gemini-2.0-flash':       1_048_576,
+  'gemini-2.5-pro':         1_048_576,
+  'gemini-2.5-flash':       1_048_576,
+
   // Ollama local models
   'llama3.3:70b':               8_192,
   'llama3.1:8b':                8_192,
@@ -94,7 +99,12 @@ const OPENAI_MAX_OUTPUT_TOKENS: Record<string, number> = {
 
   // Google (via OpenRouter)
   'google/gemini-2.0-flash':   8_192,
-  'google/gemini-2.5-pro':    32_768,
+  'google/gemini-2.5-pro':    65_536,
+
+  // Google (native via CLAUDE_CODE_USE_GEMINI)
+  'gemini-2.0-flash':          8_192,
+  'gemini-2.5-pro':           65_536,
+  'gemini-2.5-flash':         65_536,
 
   // Ollama local models (conservative safe defaults)
   'llama3.3:70b':               4_096,
diff --git a/src/utils/model/providers.test.ts b/src/utils/model/providers.test.ts
index 1da3d596..ea03454f 100644
--- a/src/utils/model/providers.test.ts
+++ b/src/utils/model/providers.test.ts
@@ -7,6 +7,7 @@ import {
 
 const originalEnv = {
   CLAUDE_CODE_USE_GEMINI: process.env.CLAUDE_CODE_USE_GEMINI,
+  CLAUDE_CODE_USE_GITHUB: process.env.CLAUDE_CODE_USE_GITHUB,
   CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
   CLAUDE_CODE_USE_BEDROCK: process.env.CLAUDE_CODE_USE_BEDROCK,
   CLAUDE_CODE_USE_VERTEX: process.env.CLAUDE_CODE_USE_VERTEX,
@@ -15,6 +16,7 @@ const originalEnv = {
 
 afterEach(() => {
   process.env.CLAUDE_CODE_USE_GEMINI = originalEnv.CLAUDE_CODE_USE_GEMINI
+  process.env.CLAUDE_CODE_USE_GITHUB = originalEnv.CLAUDE_CODE_USE_GITHUB
   process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
   process.env.CLAUDE_CODE_USE_BEDROCK = originalEnv.CLAUDE_CODE_USE_BEDROCK
   process.env.CLAUDE_CODE_USE_VERTEX = originalEnv.CLAUDE_CODE_USE_VERTEX
@@ -23,6 +25,7 @@ afterEach(() => {
 
 function clearProviderEnv(): void {
   delete process.env.CLAUDE_CODE_USE_GEMINI
+  delete process.env.CLAUDE_CODE_USE_GITHUB
   delete process.env.CLAUDE_CODE_USE_OPENAI
   delete process.env.CLAUDE_CODE_USE_BEDROCK
   delete process.env.CLAUDE_CODE_USE_VERTEX
@@ -38,6 +41,7 @@ test('first-party provider keeps Anthropic account setup flow enabled', () => {
 
 test.each([
   ['CLAUDE_CODE_USE_OPENAI', 'openai'],
+  ['CLAUDE_CODE_USE_GITHUB', 'github'],
   ['CLAUDE_CODE_USE_GEMINI', 'gemini'],
   ['CLAUDE_CODE_USE_BEDROCK', 'bedrock'],
   ['CLAUDE_CODE_USE_VERTEX', 'vertex'],
@@ -52,3 +56,11 @@ test.each([
     expect(usesAnthropicAccountFlow()).toBe(false)
   },
 )
+
+test('GEMINI takes precedence over GitHub when both are set', () => {
+  clearProviderEnv()
+  process.env.CLAUDE_CODE_USE_GEMINI = '1'
+  process.env.CLAUDE_CODE_USE_GITHUB = '1'
+
+  expect(getAPIProvider()).toBe('gemini')
+})
diff --git a/src/utils/model/providers.ts b/src/utils/model/providers.ts
index 847b5fc3..6b6d627e 100644
--- a/src/utils/model/providers.ts
+++ b/src/utils/model/providers.ts
@@ -1,25 +1,50 @@
 import type { AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../../services/analytics/index.js'
 import { isEnvTruthy } from '../envUtils.js'
 
-export type APIProvider = 'firstParty' | 'bedrock' | 'vertex' | 'foundry' | 'openai' | 'gemini'
+export type APIProvider =
+  | 'firstParty'
+  | 'bedrock'
+  | 'vertex'
+  | 'foundry'
+  | 'openai'
+  | 'gemini'
+  | 'github'
+  | 'codex'
 
 export function getAPIProvider(): APIProvider {
   return isEnvTruthy(process.env.CLAUDE_CODE_USE_GEMINI)
     ? 'gemini'
-    : isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
-      ? 'openai'
-      : isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)
-        ? 'bedrock'
-        : isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)
-          ? 'vertex'
-          : isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)
-            ? 'foundry'
-            : 'firstParty'
+    : isEnvTruthy(process.env.CLAUDE_CODE_USE_GITHUB)
+      ? 'github'
+      : isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
+        ? isCodexModel()
+          ? 'codex'
+          : 'openai'
+        : isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)
+          ? 'bedrock'
+          : isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)
+            ? 'vertex'
+            : isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)
+              ? 'foundry'
+              : 'firstParty'
 }
 
 export function usesAnthropicAccountFlow(): boolean {
   return getAPIProvider() === 'firstParty'
 }
+function isCodexModel(): boolean {
+  const model = (process.env.OPENAI_MODEL || '').toLowerCase()
+  return (
+    model === 'codexplan' ||
+    model === 'codexspark' ||
+    model === 'gpt-5.4' ||
+    model === 'gpt-5.3-codex' ||
+    model === 'gpt-5.3-codex-spark' ||
+    model === 'gpt-5.2-codex' ||
+    model === 'gpt-5.1-codex-max' ||
+    model === 'gpt-5.1-codex-mini'
+  )
+}
 
 export function getAPIProviderForStatsig(): AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS {
   return getAPIProvider() as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
diff --git a/src/utils/providerDiscovery.ts b/src/utils/providerDiscovery.ts
new file mode 100644
index 00000000..5e209d65
--- /dev/null
+++ b/src/utils/providerDiscovery.ts
@@ -0,0 +1,189 @@
+import type { OllamaModelDescriptor } from './providerRecommendation.ts'
+
+export const DEFAULT_OLLAMA_BASE_URL = 'http://localhost:11434'
+export const DEFAULT_ATOMIC_CHAT_BASE_URL = 'http://127.0.0.1:1337'
+
+function withTimeoutSignal(timeoutMs: number): {
+  signal: AbortSignal
+  clear: () => void
+} {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timeout),
+  }
+}
+
+function trimTrailingSlash(value: string): string {
+  return value.replace(/\/+$/, '')
+}
+
+export function getOllamaApiBaseUrl(baseUrl?: string): string {
+  const parsed = new URL(
+    baseUrl || process.env.OLLAMA_BASE_URL || DEFAULT_OLLAMA_BASE_URL,
+  )
+  const pathname = trimTrailingSlash(parsed.pathname)
+  parsed.pathname = pathname.endsWith('/v1')
+    ? pathname.slice(0, -3) || '/'
+    : pathname || '/'
+  parsed.search = ''
+  parsed.hash = ''
+  return trimTrailingSlash(parsed.toString())
+}
+
+export function getOllamaChatBaseUrl(baseUrl?: string): string {
+  return `${getOllamaApiBaseUrl(baseUrl)}/v1`
+}
+
+export function getAtomicChatApiBaseUrl(baseUrl?: string): string {
+  const parsed = new URL(
+    baseUrl || process.env.ATOMIC_CHAT_BASE_URL || DEFAULT_ATOMIC_CHAT_BASE_URL,
+  )
+  const pathname = trimTrailingSlash(parsed.pathname)
+  parsed.pathname = pathname.endsWith('/v1')
+    ? pathname.slice(0, -3) || '/'
+    : pathname || '/'
+  parsed.search = ''
+  parsed.hash = ''
+  return trimTrailingSlash(parsed.toString())
+}
+
+export function getAtomicChatChatBaseUrl(baseUrl?: string): string {
+  return `${getAtomicChatApiBaseUrl(baseUrl)}/v1`
+}
+
+export async function hasLocalOllama(baseUrl?: string): Promise<boolean> {
+  const { signal, clear } = withTimeoutSignal(1200)
+  try {
+    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/tags`, {
+      method: 'GET',
+      signal,
+    })
+    return response.ok
+  } catch {
+    return false
+  } finally {
+    clear()
+  }
+}
+
+export async function listOllamaModels(
+  baseUrl?: string,
+): Promise<OllamaModelDescriptor[]> {
+  const { signal, clear } = withTimeoutSignal(5000)
+  try {
+    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/tags`, {
+      method: 'GET',
+      signal,
+    })
+    if (!response.ok) {
+      return []
+    }
+
+    const data = (await response.json()) as {
+      models?: Array<{
+        name?: string
+        size?: number
+        details?: {
+          family?: string
+          families?: string[]
+          parameter_size?: string
+          quantization_level?: string
+        }
+      }>
+    }
+
+    return (data.models ?? [])
+      .filter(model => Boolean(model.name))
+      .map(model => ({
+        name: model.name!,
+        sizeBytes: typeof model.size === 'number' ? model.size : null,
+        family: model.details?.family ?? null,
+        families: model.details?.families ?? [],
+        parameterSize: model.details?.parameter_size ?? null,
+        quantizationLevel: model.details?.quantization_level ?? null,
+      }))
+  } catch {
+    return []
+  } finally {
+    clear()
+  }
+}
+
+export async function hasLocalAtomicChat(baseUrl?: string): Promise<boolean> {
+  const { signal, clear } = withTimeoutSignal(1200)
+  try {
+    const response = await fetch(`${getAtomicChatChatBaseUrl(baseUrl)}/models`, {
+      method: 'GET',
+      signal,
+    })
+    return response.ok
+  } catch {
+    return false
+  } finally {
+    clear()
+  }
+}
+
+export async function listAtomicChatModels(
+  baseUrl?: string,
+): Promise<string[]> {
+  const { signal, clear } = withTimeoutSignal(5000)
+  try {
+    const response = await fetch(`${getAtomicChatChatBaseUrl(baseUrl)}/models`, {
+      method: 'GET',
+      signal,
+    })
+    if (!response.ok) {
+      return []
+    }
+
+    const data = (await response.json()) as {
+      data?: Array<{ id?: string }>
+    }
+
+    return (data.data ?? [])
+      .filter(model => Boolean(model.id))
+      .map(model => model.id!)
+  } catch {
+    return []
+  } finally {
+    clear()
+  }
+}
+
+export async function benchmarkOllamaModel(
+  modelName: string,
+  baseUrl?: string,
+): Promise<number | null> {
+  const start = Date.now()
+  const { signal, clear } = withTimeoutSignal(20000)
+  try {
+    const response = await fetch(`${getOllamaApiBaseUrl(baseUrl)}/api/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      signal,
+      body: JSON.stringify({
+        model: modelName,
+        stream: false,
+        messages: [{ role: 'user', content: 'Reply with OK.' }],
+        options: {
+          temperature: 0,
+          num_predict: 8,
+        },
+      }),
+    })
+    if (!response.ok) {
+      return null
+    }
+    await response.json()
+    return Date.now() - start
+  } catch {
+    return null
+  } finally {
+    clear()
+  }
+}
diff --git a/src/utils/providerProfile.test.ts b/src/utils/providerProfile.test.ts
index e90746c6..44f8cf94 100644
--- a/src/utils/providerProfile.test.ts
+++ b/src/utils/providerProfile.test.ts
@@ -1,15 +1,24 @@
 import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import test from 'node:test'
 
 import {
+  buildStartupEnvFromProfile,
+  buildAtomicChatProfileEnv,
   buildCodexProfileEnv,
   buildGeminiProfileEnv,
   buildLaunchEnv,
   buildOllamaProfileEnv,
   buildOpenAIProfileEnv,
+  createProfileFile,
+  maskSecretForDisplay,
+  loadProfileFile,
+  PROFILE_FILE_NAME,
+  redactSecretValueForDisplay,
+  saveProfileFile,
+  sanitizeProviderConfigValue,
   selectAutoProfile,
   type ProfileFile,
 } from './providerProfile.ts'
@@ -359,6 +368,112 @@ test('gemini profiles require a key', () => {
   assert.equal(env, null)
 })
 
+test('saveProfileFile writes a profile that loadProfileFile can read back', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'openclaude-profile-file-'))
+
+  try {
+    const persisted = createProfileFile('openai', {
+      OPENAI_API_KEY: 'sk-test',
+      OPENAI_MODEL: 'gpt-4o',
+    })
+
+    const filePath = saveProfileFile(persisted, { cwd })
+
+    assert.equal(filePath, join(cwd, PROFILE_FILE_NAME))
+    assert.equal(
+      JSON.parse(readFileSync(filePath, 'utf8')).profile,
+      'openai',
+    )
+    assert.deepEqual(loadProfileFile({ cwd }), persisted)
+  } finally {
+    rmSync(cwd, { recursive: true, force: true })
+  }
+})
+
+test('buildStartupEnvFromProfile applies persisted gemini settings when no provider is explicitly selected', async () => {
+  const env = await buildStartupEnvFromProfile({
+    persisted: profile('gemini', {
+      GEMINI_API_KEY: 'gem-test',
+      GEMINI_MODEL: 'gemini-2.5-flash',
+    }),
+    processEnv: {},
+  })
+
+  assert.equal(env.CLAUDE_CODE_USE_GEMINI, '1')
+  assert.equal(env.CLAUDE_CODE_USE_OPENAI, undefined)
+  assert.equal(env.GEMINI_API_KEY, 'gem-test')
+  assert.equal(env.GEMINI_MODEL, 'gemini-2.5-flash')
+})
+
+test('buildStartupEnvFromProfile leaves explicit provider selections untouched', async () => {
+  const processEnv = {
+    CLAUDE_CODE_USE_GEMINI: '1',
+    GEMINI_API_KEY: 'gem-live',
+    GEMINI_MODEL: 'gemini-2.0-flash',
+  }
+
+  const env = await buildStartupEnvFromProfile({
+    persisted: profile('openai', {
+      OPENAI_API_KEY: 'sk-persisted',
+      OPENAI_MODEL: 'gpt-4o',
+    }),
+    processEnv,
+  })
+
+  assert.equal(env, processEnv)
+  assert.equal(env.CLAUDE_CODE_USE_GEMINI, '1')
+  assert.equal(env.OPENAI_API_KEY, undefined)
+})
+
+test('buildStartupEnvFromProfile treats explicit falsey provider flags as user intent', async () => {
+  const processEnv = {
+    CLAUDE_CODE_USE_OPENAI: '0',
+  }
+
+  const env = await buildStartupEnvFromProfile({
+    persisted: profile('gemini', {
+      GEMINI_API_KEY: 'gem-persisted',
+      GEMINI_MODEL: 'gemini-2.5-flash',
+    }),
+    processEnv,
+  })
+
+  assert.equal(env, processEnv)
+  assert.equal(env.CLAUDE_CODE_USE_OPENAI, '0')
+  assert.equal(env.GEMINI_API_KEY, undefined)
+})
+
+test('maskSecretForDisplay preserves only a short prefix and suffix', () => {
+  assert.equal(maskSecretForDisplay('sk-secret-12345678'), 'sk-...5678')
+  assert.equal(maskSecretForDisplay('AIzaSecret12345678'), 'AIza...5678')
+})
+
+test('redactSecretValueForDisplay masks poisoned display fields that equal configured secrets', () => {
+  const apiKey = 'sk-secret-12345678'
+
+  assert.equal(
+    redactSecretValueForDisplay(apiKey, { OPENAI_API_KEY: apiKey }),
+    'sk-...5678',
+  )
+  assert.equal(
+    redactSecretValueForDisplay('gpt-4o', { OPENAI_API_KEY: apiKey }),
+    'gpt-4o',
+  )
+})
+
+test('sanitizeProviderConfigValue drops secret-like poisoned values', () => {
+  const apiKey = 'sk-secret-12345678'
+
+  assert.equal(
+    sanitizeProviderConfigValue(apiKey, { OPENAI_API_KEY: apiKey }),
+    undefined,
+  )
+  assert.equal(
+    sanitizeProviderConfigValue('gpt-4o', { OPENAI_API_KEY: apiKey }),
+    'gpt-4o',
+  )
+})
+
 test('openai profiles ignore codex shell transport hints', () => {
   const env = buildOpenAIProfileEnv({
     goal: 'balanced',
@@ -377,7 +492,110 @@ test('openai profiles ignore codex shell transport hints', () => {
   })
 })
 
+test('openai profiles ignore poisoned shell model and base url values', () => {
+  const env = buildOpenAIProfileEnv({
+    goal: 'balanced',
+    apiKey: 'sk-live',
+    processEnv: {
+      OPENAI_BASE_URL: 'sk-live',
+      OPENAI_MODEL: 'sk-live',
+      OPENAI_API_KEY: 'sk-live',
+    },
+  })
+
+  assert.deepEqual(env, {
+    OPENAI_BASE_URL: 'https://api.openai.com/v1',
+    OPENAI_MODEL: 'gpt-4o',
+    OPENAI_API_KEY: 'sk-live',
+  })
+})
+
+test('startup env ignores poisoned persisted openai model and base url', async () => {
+  const env = await buildStartupEnvFromProfile({
+    persisted: profile('openai', {
+      OPENAI_API_KEY: 'sk-live',
+      OPENAI_MODEL: 'sk-live',
+      OPENAI_BASE_URL: 'sk-live',
+    }),
+    processEnv: {},
+  })
+
+  assert.equal(env.CLAUDE_CODE_USE_OPENAI, '1')
+  assert.equal(env.OPENAI_API_KEY, 'sk-live')
+  assert.equal(env.OPENAI_MODEL, 'gpt-4o')
+  assert.equal(env.OPENAI_BASE_URL, 'https://api.openai.com/v1')
+})
+
 test('auto profile falls back to openai when no viable ollama model exists', () => {
   assert.equal(selectAutoProfile(null), 'openai')
   assert.equal(selectAutoProfile('qwen2.5-coder:7b'), 'ollama')
 })
+
+// ── Atomic Chat profile tests ────────────────────────────────────────────────
+
+test('atomic-chat profiles never persist openai api keys', () => {
+  const env = buildAtomicChatProfileEnv('some-local-model', {
+    getAtomicChatChatBaseUrl: () => 'http://127.0.0.1:1337/v1',
+  })
+
+  assert.deepEqual(env, {
+    OPENAI_BASE_URL: 'http://127.0.0.1:1337/v1',
+    OPENAI_MODEL: 'some-local-model',
+  })
+  assert.equal('OPENAI_API_KEY' in env, false)
+})
+
+test('atomic-chat profiles respect custom base url', () => {
+  const env = buildAtomicChatProfileEnv('my-model', {
+    baseUrl: 'http://192.168.1.100:1337',
+    getAtomicChatChatBaseUrl: (baseUrl?: string) =>
+      baseUrl ? `${baseUrl}/v1` : 'http://127.0.0.1:1337/v1',
+  })
+
+  assert.equal(env.OPENAI_BASE_URL, 'http://192.168.1.100:1337/v1')
+  assert.equal(env.OPENAI_MODEL, 'my-model')
+})
+
+test('matching persisted atomic-chat env is reused for atomic-chat launch', async () => {
+  const env = await buildLaunchEnv({
+    profile: 'atomic-chat',
+    persisted: profile('atomic-chat', {
+      OPENAI_BASE_URL: 'http://127.0.0.1:1337/v1',
+      OPENAI_MODEL: 'llama-3.1-8b',
+    }),
+    goal: 'balanced',
+    processEnv: {},
+    getAtomicChatChatBaseUrl: () => 'http://127.0.0.1:1337/v1',
+    resolveAtomicChatDefaultModel: async () => 'other-model',
+  })
+
+  assert.equal(env.OPENAI_BASE_URL, 'http://127.0.0.1:1337/v1')
+  assert.equal(env.OPENAI_MODEL, 'llama-3.1-8b')
+  assert.equal(env.OPENAI_API_KEY, undefined)
+  assert.equal(env.CODEX_API_KEY, undefined)
+})
+
+test('atomic-chat launch ignores mismatched persisted openai env', async () => {
+  const env = await buildLaunchEnv({
+    profile: 'atomic-chat',
+    persisted: profile('openai', {
+      OPENAI_BASE_URL: 'https://api.openai.com/v1',
+      OPENAI_MODEL: 'gpt-4o',
+      OPENAI_API_KEY: 'sk-persisted',
+    }),
+    goal: 'balanced',
+    processEnv: {
+      OPENAI_API_KEY: 'sk-live',
+      CODEX_API_KEY: 'codex-live',
+      CHATGPT_ACCOUNT_ID: 'acct_live',
+    },
+    getAtomicChatChatBaseUrl: () => 'http://127.0.0.1:1337/v1',
+    resolveAtomicChatDefaultModel: async () => 'local-model',
+  })
+
+  assert.equal(env.OPENAI_BASE_URL, 'http://127.0.0.1:1337/v1')
+  assert.equal(env.OPENAI_MODEL, 'local-model')
+  assert.equal(env.OPENAI_API_KEY, undefined)
+  assert.equal(env.CODEX_API_KEY, undefined)
+  assert.equal(env.CHATGPT_ACCOUNT_ID, undefined)
+})
diff --git a/src/utils/providerProfile.ts b/src/utils/providerProfile.ts
index 866c19c5..42da7412 100644
--- a/src/utils/providerProfile.ts
+++ b/src/utils/providerProfile.ts
@@ -1,3 +1,5 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import {
   DEFAULT_CODEX_BASE_URL,
   DEFAULT_OPENAI_BASE_URL,
@@ -7,13 +9,42 @@ import {
 } from '../services/api/providerConfig.ts'
 import {
   getGoalDefaultOpenAIModel,
+  normalizeRecommendationGoal,
   type RecommendationGoal,
 } from './providerRecommendation.ts'
+import { getOllamaChatBaseUrl } from './providerDiscovery.ts'
 
-const DEFAULT_GEMINI_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/openai'
-const DEFAULT_GEMINI_MODEL = 'gemini-2.0-flash'
+export const PROFILE_FILE_NAME = '.openclaude-profile.json'
+export const DEFAULT_GEMINI_BASE_URL =
+  'https://generativelanguage.googleapis.com/v1beta/openai'
+export const DEFAULT_GEMINI_MODEL = 'gemini-2.0-flash'
 
-export type ProviderProfile = 'openai' | 'ollama' | 'codex' | 'gemini'
+const PROFILE_ENV_KEYS = [
+  'CLAUDE_CODE_USE_OPENAI',
+  'CLAUDE_CODE_USE_GEMINI',
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  'CLAUDE_CODE_USE_FOUNDRY',
+  'OPENAI_BASE_URL',
+  'OPENAI_MODEL',
+  'OPENAI_API_KEY',
+  'CODEX_API_KEY',
+  'CHATGPT_ACCOUNT_ID',
+  'CODEX_ACCOUNT_ID',
+  'GEMINI_API_KEY',
+  'GEMINI_MODEL',
+  'GEMINI_BASE_URL',
+  'GOOGLE_API_KEY',
+] as const
+
+const SECRET_ENV_KEYS = [
+  'OPENAI_API_KEY',
+  'CODEX_API_KEY',
+  'GEMINI_API_KEY',
+  'GOOGLE_API_KEY',
+] as const
+
+export type ProviderProfile = 'openai' | 'ollama' | 'codex' | 'gemini' | 'atomic-chat'
 
 export type ProfileEnv = {
   OPENAI_BASE_URL?: string
@@ -33,6 +64,36 @@ export type ProfileFile = {
   createdAt: string
 }
 
+type SecretValueSource = Partial<
+  Pick<
+    NodeJS.ProcessEnv & ProfileEnv,
+    (typeof SECRET_ENV_KEYS)[number]
+  >
+>
+
+type ProfileFileLocation = {
+  cwd?: string
+  filePath?: string
+}
+
+function resolveProfileFilePath(options?: ProfileFileLocation): string {
+  if (options?.filePath) {
+    return options.filePath
+  }
+
+  return resolve(options?.cwd ?? process.cwd(), PROFILE_FILE_NAME)
+}
+
+export function isProviderProfile(value: unknown): value is ProviderProfile {
+  return (
+    value === 'openai' ||
+    value === 'ollama' ||
+    value === 'codex' ||
+    value === 'gemini' ||
+    value === 'atomic-chat'
+  )
+}
+
 export function sanitizeApiKey(
   key: string | null | undefined,
 ): string | undefined {
@@ -40,6 +101,95 @@ export function sanitizeApiKey(
   return key
 }
 
+function looksLikeSecretValue(value: string): boolean {
+  const trimmed = value.trim()
+  if (!trimmed) return false
+
+  if (trimmed.startsWith('sk-') || trimmed.startsWith('sk-ant-')) {
+    return true
+  }
+
+  if (trimmed.startsWith('AIza')) {
+    return true
+  }
+
+  return false
+}
+
+function collectSecretValues(
+  sources: Array<SecretValueSource | null | undefined>,
+): string[] {
+  const values = new Set<string>()
+
+  for (const source of sources) {
+    if (!source) continue
+
+    for (const key of SECRET_ENV_KEYS) {
+      const value = sanitizeApiKey(source[key])
+      if (value) {
+        values.add(value)
+      }
+    }
+  }
+
+  return [...values]
+}
+
+export function maskSecretForDisplay(
+  value: string | null | undefined,
+): string | undefined {
+  const sanitized = sanitizeApiKey(value)
+  if (!sanitized) return undefined
+
+  if (sanitized.length <= 8) {
+    return 'configured'
+  }
+
+  if (sanitized.startsWith('sk-')) {
+    return `${sanitized.slice(0, 3)}...${sanitized.slice(-4)}`
+  }
+
+  if (sanitized.startsWith('AIza')) {
+    return `${sanitized.slice(0, 4)}...${sanitized.slice(-4)}`
+  }
+
+  return `${sanitized.slice(0, 2)}...${sanitized.slice(-4)}`
+}
+
+export function redactSecretValueForDisplay(
+  value: string | null | undefined,
+  ...sources: Array<SecretValueSource | null | undefined>
+): string | undefined {
+  if (!value) return undefined
+
+  const trimmed = value.trim()
+  if (!trimmed) return trimmed
+
+  const secretValues = collectSecretValues(sources)
+  if (secretValues.includes(trimmed) || looksLikeSecretValue(trimmed)) {
+    return maskSecretForDisplay(trimmed) ?? 'configured'
+  }
+
+  return trimmed
+}
+
+export function sanitizeProviderConfigValue(
+  value: string | null | undefined,
+  ...sources: Array<SecretValueSource | null | undefined>
+): string | undefined {
+  if (!value) return undefined
+
+  const trimmed = value.trim()
+  if (!trimmed) return undefined
+
+  const secretValues = collectSecretValues(sources)
+  if (secretValues.includes(trimmed) || looksLikeSecretValue(trimmed)) {
+    return undefined
+  }
+
+  return trimmed
+}
+
 export function buildOllamaProfileEnv(
   model: string,
   options: {
@@ -53,6 +203,19 @@ export function buildOllamaProfileEnv(
   }
 }
 
+export function buildAtomicChatProfileEnv(
+  model: string,
+  options: {
+    baseUrl?: string | null
+    getAtomicChatChatBaseUrl: (baseUrl?: string) => string
+  },
+): ProfileEnv {
+  return {
+    OPENAI_BASE_URL: options.getAtomicChatChatBaseUrl(options.baseUrl ?? undefined),
+    OPENAI_MODEL: model,
+  }
+}
+
 export function buildGeminiProfileEnv(options: {
   model?: string | null
   baseUrl?: string | null
@@ -71,11 +234,23 @@ export function buildGeminiProfileEnv(options: {
 
   const env: ProfileEnv = {
     GEMINI_MODEL:
-      options.model || processEnv.GEMINI_MODEL || DEFAULT_GEMINI_MODEL,
+      sanitizeProviderConfigValue(options.model, { GEMINI_API_KEY: key }, processEnv) ||
+      sanitizeProviderConfigValue(
+        processEnv.GEMINI_MODEL,
+        { GEMINI_API_KEY: key },
+        processEnv,
+      ) ||
+      DEFAULT_GEMINI_MODEL,
     GEMINI_API_KEY: key,
   }
 
-  const baseUrl = options.baseUrl || processEnv.GEMINI_BASE_URL
+  const baseUrl =
+    sanitizeProviderConfigValue(options.baseUrl, { GEMINI_API_KEY: key }, processEnv) ||
+    sanitizeProviderConfigValue(
+      processEnv.GEMINI_BASE_URL,
+      { GEMINI_API_KEY: key },
+      processEnv,
+    )
   if (baseUrl) {
     env.GEMINI_BASE_URL = baseUrl
   }
@@ -97,21 +272,39 @@ export function buildOpenAIProfileEnv(options: {
   }
 
   const defaultModel = getGoalDefaultOpenAIModel(options.goal)
+  const shellOpenAIModel = sanitizeProviderConfigValue(
+    processEnv.OPENAI_MODEL,
+    { OPENAI_API_KEY: key },
+    processEnv,
+  )
+  const shellOpenAIBaseUrl = sanitizeProviderConfigValue(
+    processEnv.OPENAI_BASE_URL,
+    { OPENAI_API_KEY: key },
+    processEnv,
+  )
   const shellOpenAIRequest = resolveProviderRequest({
-    model: processEnv.OPENAI_MODEL,
-    baseUrl: processEnv.OPENAI_BASE_URL,
+    model: shellOpenAIModel,
+    baseUrl: shellOpenAIBaseUrl,
     fallbackModel: defaultModel,
   })
   const useShellOpenAIConfig = shellOpenAIRequest.transport === 'chat_completions'
 
   return {
     OPENAI_BASE_URL:
-      options.baseUrl ||
-      (useShellOpenAIConfig ? processEnv.OPENAI_BASE_URL : undefined) ||
+      sanitizeProviderConfigValue(
+        options.baseUrl,
+        { OPENAI_API_KEY: key },
+        processEnv,
+      ) ||
+      (useShellOpenAIConfig ? shellOpenAIBaseUrl : undefined) ||
       DEFAULT_OPENAI_BASE_URL,
     OPENAI_MODEL:
-      options.model ||
-      (useShellOpenAIConfig ? processEnv.OPENAI_MODEL : undefined) ||
+      sanitizeProviderConfigValue(
+        options.model,
+        { OPENAI_API_KEY: key },
+        processEnv,
+      ) ||
+      (useShellOpenAIConfig ? shellOpenAIModel : undefined) ||
       defaultModel,
     OPENAI_API_KEY: key,
   }
@@ -158,6 +351,62 @@ export function createProfileFile(
   }
 }
 
+export function loadProfileFile(options?: ProfileFileLocation): ProfileFile | null {
+  const filePath = resolveProfileFilePath(options)
+  if (!existsSync(filePath)) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8')) as Partial<ProfileFile>
+    if (!isProviderProfile(parsed.profile) || !parsed.env || typeof parsed.env !== 'object') {
+      return null
+    }
+
+    return {
+      profile: parsed.profile,
+      env: parsed.env,
+      createdAt:
+        typeof parsed.createdAt === 'string'
+          ? parsed.createdAt
+          : new Date().toISOString(),
+    }
+  } catch {
+    return null
+  }
+}
+
+export function saveProfileFile(
+  profileFile: ProfileFile,
+  options?: ProfileFileLocation,
+): string {
+  const filePath = resolveProfileFilePath(options)
+  writeFileSync(filePath, JSON.stringify(profileFile, null, 2), {
+    encoding: 'utf8',
+    mode: 0o600,
+  })
+  return filePath
+}
+
+export function deleteProfileFile(options?: ProfileFileLocation): string {
+  const filePath = resolveProfileFilePath(options)
+  rmSync(filePath, { force: true })
+  return filePath
+}
+
+export function hasExplicitProviderSelection(
+  processEnv: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return (
+    processEnv.CLAUDE_CODE_USE_OPENAI !== undefined ||
+    processEnv.CLAUDE_CODE_USE_GITHUB !== undefined ||
+    processEnv.CLAUDE_CODE_USE_GEMINI !== undefined ||
+    processEnv.CLAUDE_CODE_USE_BEDROCK !== undefined ||
+    processEnv.CLAUDE_CODE_USE_VERTEX !== undefined ||
+    processEnv.CLAUDE_CODE_USE_FOUNDRY !== undefined
+  )
+}
+
 export function selectAutoProfile(
   recommendedOllamaModel: string | null,
 ): ProviderProfile {
@@ -171,12 +420,46 @@ export async function buildLaunchEnv(options: {
   processEnv?: NodeJS.ProcessEnv
   getOllamaChatBaseUrl?: (baseUrl?: string) => string
   resolveOllamaDefaultModel?: (goal: RecommendationGoal) => Promise<string>
+  getAtomicChatChatBaseUrl?: (baseUrl?: string) => string
+  resolveAtomicChatDefaultModel?: () => Promise<string | null>
 }): Promise<NodeJS.ProcessEnv> {
   const processEnv = options.processEnv ?? process.env
   const persistedEnv =
     options.persisted?.profile === options.profile
       ? options.persisted.env ?? {}
       : {}
+  const persistedOpenAIModel = sanitizeProviderConfigValue(
+    persistedEnv.OPENAI_MODEL,
+    persistedEnv,
+  )
+  const persistedOpenAIBaseUrl = sanitizeProviderConfigValue(
+    persistedEnv.OPENAI_BASE_URL,
+    persistedEnv,
+  )
+  const shellOpenAIModel = sanitizeProviderConfigValue(
+    processEnv.OPENAI_MODEL,
+    processEnv,
+  )
+  const shellOpenAIBaseUrl = sanitizeProviderConfigValue(
+    processEnv.OPENAI_BASE_URL,
+    processEnv,
+  )
+  const persistedGeminiModel = sanitizeProviderConfigValue(
+    persistedEnv.GEMINI_MODEL,
+    persistedEnv,
+  )
+  const persistedGeminiBaseUrl = sanitizeProviderConfigValue(
+    persistedEnv.GEMINI_BASE_URL,
+    persistedEnv,
+  )
+  const shellGeminiModel = sanitizeProviderConfigValue(
+    processEnv.GEMINI_MODEL,
+    processEnv,
+  )
+  const shellGeminiBaseUrl = sanitizeProviderConfigValue(
+    processEnv.GEMINI_BASE_URL,
+    processEnv,
+  )
 
   const shellGeminiKey = sanitizeApiKey(
     processEnv.GEMINI_API_KEY ?? processEnv.GOOGLE_API_KEY,
@@ -190,14 +473,15 @@ export async function buildLaunchEnv(options: {
     }
 
     delete env.CLAUDE_CODE_USE_OPENAI
+    delete env.CLAUDE_CODE_USE_GITHUB
 
     env.GEMINI_MODEL =
-      processEnv.GEMINI_MODEL ||
-      persistedEnv.GEMINI_MODEL ||
+      shellGeminiModel ||
+      persistedGeminiModel ||
       DEFAULT_GEMINI_MODEL
     env.GEMINI_BASE_URL =
-      processEnv.GEMINI_BASE_URL ||
-      persistedEnv.GEMINI_BASE_URL ||
+      shellGeminiBaseUrl ||
+      persistedGeminiBaseUrl ||
       DEFAULT_GEMINI_BASE_URL
 
     const geminiKey = shellGeminiKey || persistedGeminiKey
@@ -224,6 +508,7 @@ export async function buildLaunchEnv(options: {
   }
 
   delete env.CLAUDE_CODE_USE_GEMINI
+  delete env.CLAUDE_CODE_USE_GITHUB
   delete env.GEMINI_API_KEY
   delete env.GEMINI_MODEL
   delete env.GEMINI_BASE_URL
@@ -235,10 +520,30 @@ export async function buildLaunchEnv(options: {
     const resolveOllamaModel =
       options.resolveOllamaDefaultModel ?? (async () => 'llama3.1:8b')
 
-    env.OPENAI_BASE_URL = persistedEnv.OPENAI_BASE_URL || getOllamaBaseUrl()
+    env.OPENAI_BASE_URL = persistedOpenAIBaseUrl || getOllamaBaseUrl()
+    env.OPENAI_MODEL =
+      persistedOpenAIModel ||
+      (await resolveOllamaModel(options.goal))
+
+    delete env.OPENAI_API_KEY
+    delete env.CODEX_API_KEY
+    delete env.CHATGPT_ACCOUNT_ID
+    delete env.CODEX_ACCOUNT_ID
+
+    return env
+  }
+
+  if (options.profile === 'atomic-chat') {
+    const getAtomicChatBaseUrl =
+      options.getAtomicChatChatBaseUrl ?? (() => 'http://127.0.0.1:1337/v1')
+    const resolveModel =
+      options.resolveAtomicChatDefaultModel ?? (async () => null as string | null)
+
+    env.OPENAI_BASE_URL = persistedEnv.OPENAI_BASE_URL || getAtomicChatBaseUrl()
     env.OPENAI_MODEL =
       persistedEnv.OPENAI_MODEL ||
-      (await resolveOllamaModel(options.goal))
+      (await resolveModel()) ||
+      ''
 
     delete env.OPENAI_API_KEY
     delete env.CODEX_API_KEY
@@ -250,10 +555,10 @@ export async function buildLaunchEnv(options: {
 
   if (options.profile === 'codex') {
     env.OPENAI_BASE_URL =
-      persistedEnv.OPENAI_BASE_URL && isCodexBaseUrl(persistedEnv.OPENAI_BASE_URL)
-        ? persistedEnv.OPENAI_BASE_URL
+      persistedOpenAIBaseUrl && isCodexBaseUrl(persistedOpenAIBaseUrl)
+        ? persistedOpenAIBaseUrl
         : DEFAULT_CODEX_BASE_URL
-    env.OPENAI_MODEL = persistedEnv.OPENAI_MODEL || 'codexplan'
+    env.OPENAI_MODEL = persistedOpenAIModel || 'codexplan'
     delete env.OPENAI_API_KEY
 
     const codexKey =
@@ -284,27 +589,27 @@ export async function buildLaunchEnv(options: {
 
   const defaultOpenAIModel = getGoalDefaultOpenAIModel(options.goal)
   const shellOpenAIRequest = resolveProviderRequest({
-    model: processEnv.OPENAI_MODEL,
-    baseUrl: processEnv.OPENAI_BASE_URL,
+    model: shellOpenAIModel,
+    baseUrl: shellOpenAIBaseUrl,
     fallbackModel: defaultOpenAIModel,
   })
   const persistedOpenAIRequest = resolveProviderRequest({
-    model: persistedEnv.OPENAI_MODEL,
-    baseUrl: persistedEnv.OPENAI_BASE_URL,
+    model: persistedOpenAIModel,
+    baseUrl: persistedOpenAIBaseUrl,
     fallbackModel: defaultOpenAIModel,
   })
   const useShellOpenAIConfig = shellOpenAIRequest.transport === 'chat_completions'
   const usePersistedOpenAIConfig =
-    (!persistedEnv.OPENAI_MODEL && !persistedEnv.OPENAI_BASE_URL) ||
+    (!persistedOpenAIModel && !persistedOpenAIBaseUrl) ||
     persistedOpenAIRequest.transport === 'chat_completions'
 
   env.OPENAI_BASE_URL =
-    (useShellOpenAIConfig ? processEnv.OPENAI_BASE_URL : undefined) ||
-    (usePersistedOpenAIConfig ? persistedEnv.OPENAI_BASE_URL : undefined) ||
+    (useShellOpenAIConfig ? shellOpenAIBaseUrl : undefined) ||
+    (usePersistedOpenAIConfig ? persistedOpenAIBaseUrl : undefined) ||
     DEFAULT_OPENAI_BASE_URL
   env.OPENAI_MODEL =
-    (useShellOpenAIConfig ? processEnv.OPENAI_MODEL : undefined) ||
-    (usePersistedOpenAIConfig ? persistedEnv.OPENAI_MODEL : undefined) ||
+    (useShellOpenAIConfig ? shellOpenAIModel : undefined) ||
+    (usePersistedOpenAIConfig ? persistedOpenAIModel : undefined) ||
     defaultOpenAIModel
   env.OPENAI_API_KEY = processEnv.OPENAI_API_KEY || persistedEnv.OPENAI_API_KEY
   delete env.CODEX_API_KEY
@@ -312,3 +617,44 @@ export async function buildLaunchEnv(options: {
   delete env.CODEX_ACCOUNT_ID
   return env
 }
+
+export async function buildStartupEnvFromProfile(options?: {
+  persisted?: ProfileFile | null
+  goal?: RecommendationGoal
+  processEnv?: NodeJS.ProcessEnv
+  getOllamaChatBaseUrl?: (baseUrl?: string) => string
+  resolveOllamaDefaultModel?: (goal: RecommendationGoal) => Promise<string>
+}): Promise<NodeJS.ProcessEnv> {
+  const processEnv = options?.processEnv ?? process.env
+  if (hasExplicitProviderSelection(processEnv)) {
+    return processEnv
+  }
+
+  const persisted = options?.persisted ?? loadProfileFile()
+  if (!persisted) {
+    return processEnv
+  }
+
+  return buildLaunchEnv({
+    profile: persisted.profile,
+    persisted,
+    goal:
+      options?.goal ??
+      normalizeRecommendationGoal(processEnv.OPENCLAUDE_PROFILE_GOAL),
+    processEnv,
+    getOllamaChatBaseUrl:
+      options?.getOllamaChatBaseUrl ?? getOllamaChatBaseUrl,
+    resolveOllamaDefaultModel: options?.resolveOllamaDefaultModel,
+  })
+}
+
+export function applyProfileEnvToProcessEnv(
+  targetEnv: NodeJS.ProcessEnv,
+  nextEnv: NodeJS.ProcessEnv,
+): void {
+  for (const key of PROFILE_ENV_KEYS) {
+    delete targetEnv[key]
+  }
+
+  Object.assign(targetEnv, nextEnv)
+}
diff --git a/src/utils/status.tsx b/src/utils/status.tsx
index bc159cdb..a712034d 100644
--- a/src/utils/status.tsx
+++ b/src/utils/status.tsx
@@ -12,6 +12,7 @@ import { formatNumber } from './format.js';
 import { getIdeClientName, type IDEExtensionInstallationStatus, isJetBrainsIde, toIDEDisplayName } from './ide.js';
 import { getClaudeAiUserDefaultModelDescription, modelDisplayString } from './model/model.js';
 import { getAPIProvider } from './model/providers.js';
+import { resolveProviderRequest } from '../services/api/providerConfig.js';
 import { getMTLSConfig } from './mtls.js';
 import { checkInstall } from './nativeInstaller/index.js';
 import { getProxyUrl } from './proxy.js';
@@ -20,6 +21,7 @@ import { getSettingsWithAllErrors } from './settings/allErrors.js';
 import { getEnabledSettingSources, getSettingSourceDisplayNameCapitalized } from './settings/constants.js';
 import { getManagedFileSettingsPresence, getPolicySettingsOrigin, getSettingsForSource } from './settings/settings.js';
 import type { ThemeName } from './theme.js';
+import { redactSecretValueForDisplay } from './providerProfile.js';
 export type Property = {
   label?: string;
   value: React.ReactNode | Array<string>;
@@ -246,6 +248,7 @@ export function buildAPIProviderProperties(): Property[] {
       vertex: 'Google Vertex AI',
       foundry: 'Microsoft Foundry',
       openai: 'OpenAI-compatible',
+      codex: 'Codex',
       gemini: 'Google Gemini',
     }[apiProvider];
     properties.push({
@@ -327,14 +330,53 @@ export function buildAPIProviderProperties(): Property[] {
     if (openaiBaseUrl) {
       properties.push({
         label: 'OpenAI base URL',
-        value: openaiBaseUrl
+        value: redactSecretValueForDisplay(openaiBaseUrl, process.env) ?? openaiBaseUrl
       });
     }
     const openaiModel = process.env.OPENAI_MODEL;
     if (openaiModel) {
+      // Build display model string with resolved model + reasoning effort
+      let modelDisplay = openaiModel;
+      const resolved = resolveProviderRequest({ model: openaiModel });
+      const resolvedModel = resolved.resolvedModel;
+      const reasoningEffort = resolved.reasoning?.effort;
+      if (resolvedModel && resolvedModel !== openaiModel.toLowerCase()) {
+        // Show resolved model name
+        modelDisplay = resolvedModel;
+      }
+      if (reasoningEffort) {
+        modelDisplay = `${modelDisplay} (${reasoningEffort})`;
+      }
       properties.push({
         label: 'Model',
-        value: openaiModel
+        value: redactSecretValueForDisplay(modelDisplay, process.env) ?? modelDisplay
+      });
+    }
+  } else if (apiProvider === 'codex') {
+    const codexBaseUrl = process.env.OPENAI_BASE_URL;
+    if (codexBaseUrl) {
+      properties.push({
+        label: 'Codex base URL',
+        value: redactSecretValueForDisplay(codexBaseUrl, process.env) ?? codexBaseUrl
+      });
+    }
+    const openaiModel = process.env.OPENAI_MODEL;
+    if (openaiModel) {
+      // Build display model string with resolved model + reasoning effort
+      let modelDisplay = openaiModel;
+      const resolved = resolveProviderRequest({ model: openaiModel });
+      const resolvedModel = resolved.resolvedModel;
+      const reasoningEffort = resolved.reasoning?.effort;
+      if (resolvedModel && resolvedModel !== openaiModel.toLowerCase()) {
+        // Show resolved model name
+        modelDisplay = resolvedModel;
+      }
+      if (reasoningEffort) {
+        modelDisplay = `${modelDisplay} (${reasoningEffort})`;
+      }
+      properties.push({
+        label: 'Model',
+        value: redactSecretValueForDisplay(modelDisplay, process.env) ?? modelDisplay
       });
     }
   } else if (apiProvider === 'gemini') {
@@ -342,14 +384,14 @@ export function buildAPIProviderProperties(): Property[] {
     if (geminiBaseUrl) {
       properties.push({
         label: 'Gemini base URL',
-        value: geminiBaseUrl
+        value: redactSecretValueForDisplay(geminiBaseUrl, process.env) ?? geminiBaseUrl
       });
     }
     const geminiModel = process.env.GEMINI_MODEL;
     if (geminiModel) {
       properties.push({
         label: 'Model',
-        value: geminiModel
+        value: redactSecretValueForDisplay(geminiModel, process.env) ?? geminiModel
       });
     }
   }
@@ -391,4 +433,4 @@ export function getModelDisplayLabel(mainLoopModel: string | null): string {
   }
   return modelLabel;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","color","Text","MCPServerConnection","getAccountInformation","isClaudeAISubscriber","getLargeMemoryFiles","getMemoryFiles","MAX_MEMORY_CHARACTER_COUNT","getDoctorDiagnostic","getAWSRegion","getDefaultVertexRegion","isEnvTruthy","getDisplayPath","formatNumber","getIdeClientName","IDEExtensionInstallationStatus","isJetBrainsIde","toIDEDisplayName","getClaudeAiUserDefaultModelDescription","modelDisplayString","getAPIProvider","getMTLSConfig","checkInstall","getProxyUrl","SandboxManager","getSettingsWithAllErrors","getEnabledSettingSources","getSettingSourceDisplayNameCapitalized","getManagedFileSettingsPresence","getPolicySettingsOrigin","getSettingsForSource","ThemeName","Property","label","value","ReactNode","Array","Diagnostic","buildSandboxProperties","isSandboxed","isSandboxingEnabled","buildIDEProperties","mcpClients","ideInstallationStatus","theme","ideClient","find","client","name","ideName","ideType","pluginOrExtension","error","cross","installed","type","installedVersion","serverInfo","version","buildMcpProperties","clients","servers","filter","length","byState","connected","pending","needsAuth","failed","s","parts","push","join","buildMemoryDiagnostics","Promise","files","largeFiles","diagnostics","forEach","file","displayPath","path","content","buildSettingSourcesProperties","enabledSources","sourcesWithSettings","source","settings","Object","keys","sourceNames","map","origin","hasBase","hasDropIns","buildInstallationDiagnostics","installWarnings","warning","message","buildInstallationHealthDiagnostics","diagnostic","items","errors","validationErrors","invalidFiles","from","Set","fileList","warnings","issue","hasUpdatePermissions","buildAccountProperties","accountInfo","properties","subscription","tokenSource","apiKeySource","organization","process","env","IS_DEMO","email","buildAPIProviderProperties","apiProvider","providerLabel","bedrock","vertex","foundry","anthropicBaseUrl","ANTHROPIC_BASE_URL","bedrockBaseUrl","BEDROCK_BASE_URL","CLAUDE_CODE_SKIP_BEDROCK_AUTH","vertexBaseUrl","VERTEX_BASE_URL","gcpProject","ANTHROPIC_VERTEX_PROJECT_ID","CLAUDE_CODE_SKIP_VERTEX_AUTH","foundryBaseUrl","ANTHROPIC_FOUNDRY_BASE_URL","foundryResource","ANTHROPIC_FOUNDRY_RESOURCE","CLAUDE_CODE_SKIP_FOUNDRY_AUTH","proxyUrl","mtlsConfig","NODE_EXTRA_CA_CERTS","cert","CLAUDE_CODE_CLIENT_CERT","key","CLAUDE_CODE_CLIENT_KEY","getModelDisplayLabel","mainLoopModel","modelLabel","description","bold"],"sources":["status.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { color, Text } from '../ink.js'\nimport type { MCPServerConnection } from '../services/mcp/types.js'\nimport { getAccountInformation, isClaudeAISubscriber } from './auth.js'\nimport {\n  getLargeMemoryFiles,\n  getMemoryFiles,\n  MAX_MEMORY_CHARACTER_COUNT,\n} from './claudemd.js'\nimport { getDoctorDiagnostic } from './doctorDiagnostic.js'\nimport {\n  getAWSRegion,\n  getDefaultVertexRegion,\n  isEnvTruthy,\n} from './envUtils.js'\nimport { getDisplayPath } from './file.js'\nimport { formatNumber } from './format.js'\nimport {\n  getIdeClientName,\n  type IDEExtensionInstallationStatus,\n  isJetBrainsIde,\n  toIDEDisplayName,\n} from './ide.js'\nimport {\n  getClaudeAiUserDefaultModelDescription,\n  modelDisplayString,\n} from './model/model.js'\nimport { getAPIProvider } from './model/providers.js'\nimport { getMTLSConfig } from './mtls.js'\nimport { checkInstall } from './nativeInstaller/index.js'\nimport { getProxyUrl } from './proxy.js'\nimport { SandboxManager } from './sandbox/sandbox-adapter.js'\nimport { getSettingsWithAllErrors } from './settings/allErrors.js'\nimport {\n  getEnabledSettingSources,\n  getSettingSourceDisplayNameCapitalized,\n} from './settings/constants.js'\nimport {\n  getManagedFileSettingsPresence,\n  getPolicySettingsOrigin,\n  getSettingsForSource,\n} from './settings/settings.js'\nimport type { ThemeName } from './theme.js'\n\nexport type Property = {\n  label?: string\n  value: React.ReactNode | Array<string>\n}\n\nexport type Diagnostic = React.ReactNode\n\nexport function buildSandboxProperties(): Property[] {\n  if (\"external\" !== 'ant') {\n    return []\n  }\n\n  const isSandboxed = SandboxManager.isSandboxingEnabled()\n\n  return [\n    {\n      label: 'Bash Sandbox',\n      value: isSandboxed ? 'Enabled' : 'Disabled',\n    },\n  ]\n}\n\nexport function buildIDEProperties(\n  mcpClients: MCPServerConnection[],\n  ideInstallationStatus: IDEExtensionInstallationStatus | null = null,\n  theme: ThemeName,\n): Property[] {\n  const ideClient = mcpClients?.find(client => client.name === 'ide')\n\n  if (ideInstallationStatus) {\n    const ideName = toIDEDisplayName(ideInstallationStatus.ideType)\n    const pluginOrExtension = isJetBrainsIde(ideInstallationStatus.ideType)\n      ? 'plugin'\n      : 'extension'\n\n    if (ideInstallationStatus.error) {\n      return [\n        {\n          label: 'IDE',\n          value: (\n            <Text>\n              {color('error', theme)(figures.cross)} Error installing {ideName}{' '}\n              {pluginOrExtension}: {ideInstallationStatus.error}\n              {'\\n'}Please restart your IDE and try again.\n            </Text>\n          ),\n        },\n      ]\n    }\n\n    if (ideInstallationStatus.installed) {\n      if (ideClient && ideClient.type === 'connected') {\n        if (\n          ideInstallationStatus.installedVersion !==\n          ideClient.serverInfo?.version\n        ) {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion} (server version: ${ideClient.serverInfo?.version})`,\n            },\n          ]\n        } else {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion}`,\n            },\n          ]\n        }\n      } else {\n        return [\n          {\n            label: 'IDE',\n            value: `Installed ${ideName} ${pluginOrExtension}`,\n          },\n        ]\n      }\n    }\n  } else if (ideClient) {\n    const ideName = getIdeClientName(ideClient) ?? 'IDE'\n    if (ideClient.type === 'connected') {\n      return [\n        {\n          label: 'IDE',\n          value: `Connected to ${ideName} extension`,\n        },\n      ]\n    } else {\n      return [\n        {\n          label: 'IDE',\n          value: `${color('error', theme)(figures.cross)} Not connected to ${ideName}`,\n        },\n      ]\n    }\n  }\n\n  return []\n}\n\nexport function buildMcpProperties(\n  clients: MCPServerConnection[] = [],\n  theme: ThemeName,\n): Property[] {\n  const servers = clients.filter(client => client.name !== 'ide')\n  if (!servers.length) {\n    return []\n  }\n\n  // Summary instead of a full server list — 20+ servers wrapped onto many\n  // rows, dominating the Status pane. Show counts by state + /mcp hint.\n  const byState = { connected: 0, pending: 0, needsAuth: 0, failed: 0 }\n  for (const s of servers) {\n    if (s.type === 'connected') byState.connected++\n    else if (s.type === 'pending') byState.pending++\n    else if (s.type === 'needs-auth') byState.needsAuth++\n    else byState.failed++\n  }\n  const parts: string[] = []\n  if (byState.connected)\n    parts.push(color('success', theme)(`${byState.connected} connected`))\n  if (byState.needsAuth)\n    parts.push(color('warning', theme)(`${byState.needsAuth} need auth`))\n  if (byState.pending)\n    parts.push(color('inactive', theme)(`${byState.pending} pending`))\n  if (byState.failed)\n    parts.push(color('error', theme)(`${byState.failed} failed`))\n\n  return [\n    {\n      label: 'MCP servers',\n      value: `${parts.join(', ')} ${color('inactive', theme)('· /mcp')}`,\n    },\n  ]\n}\n\nexport async function buildMemoryDiagnostics(): Promise<Diagnostic[]> {\n  const files = await getMemoryFiles()\n  const largeFiles = getLargeMemoryFiles(files)\n\n  const diagnostics: Diagnostic[] = []\n\n  largeFiles.forEach(file => {\n    const displayPath = getDisplayPath(file.path)\n    diagnostics.push(\n      `Large ${displayPath} will impact performance (${formatNumber(file.content.length)} chars > ${formatNumber(MAX_MEMORY_CHARACTER_COUNT)})`,\n    )\n  })\n\n  return diagnostics\n}\n\nexport function buildSettingSourcesProperties(): Property[] {\n  const enabledSources = getEnabledSettingSources()\n\n  // Filter to only sources that actually have settings loaded\n  const sourcesWithSettings = enabledSources.filter(source => {\n    const settings = getSettingsForSource(source)\n    return settings !== null && Object.keys(settings).length > 0\n  })\n\n  // Map internal names to user-friendly names\n  // For policySettings, distinguish between remote and local (or skip if neither exists)\n  const sourceNames = sourcesWithSettings\n    .map(source => {\n      if (source === 'policySettings') {\n        const origin = getPolicySettingsOrigin()\n        if (origin === null) {\n          return null // Skip - no policy settings exist\n        }\n        switch (origin) {\n          case 'remote':\n            return 'Enterprise managed settings (remote)'\n          case 'plist':\n            return 'Enterprise managed settings (plist)'\n          case 'hklm':\n            return 'Enterprise managed settings (HKLM)'\n          case 'file': {\n            const { hasBase, hasDropIns } = getManagedFileSettingsPresence()\n            if (hasBase && hasDropIns) {\n              return 'Enterprise managed settings (file + drop-ins)'\n            }\n            if (hasDropIns) {\n              return 'Enterprise managed settings (drop-ins)'\n            }\n            return 'Enterprise managed settings (file)'\n          }\n          case 'hkcu':\n            return 'Enterprise managed settings (HKCU)'\n        }\n      }\n      return getSettingSourceDisplayNameCapitalized(source)\n    })\n    .filter((name): name is string => name !== null)\n\n  return [\n    {\n      label: 'Setting sources',\n      value: sourceNames,\n    },\n  ]\n}\n\nexport async function buildInstallationDiagnostics(): Promise<Diagnostic[]> {\n  const installWarnings = await checkInstall()\n  return installWarnings.map(warning => warning.message)\n}\n\nexport async function buildInstallationHealthDiagnostics(): Promise<\n  Diagnostic[]\n> {\n  const diagnostic = await getDoctorDiagnostic()\n  const items: Diagnostic[] = []\n\n  const { errors: validationErrors } = getSettingsWithAllErrors()\n  if (validationErrors.length > 0) {\n    const invalidFiles = Array.from(\n      new Set(validationErrors.map(error => error.file)),\n    )\n    const fileList = invalidFiles.join(', ')\n\n    items.push(\n      `Found invalid settings files: ${fileList}. They will be ignored.`,\n    )\n  }\n\n  // Add warnings from doctor diagnostic (includes leftover installations, config mismatches, etc.)\n  diagnostic.warnings.forEach(warning => {\n    items.push(warning.issue)\n  })\n\n  if (diagnostic.hasUpdatePermissions === false) {\n    items.push('No write permissions for auto-updates (requires sudo)')\n  }\n\n  return items\n}\n\nexport function buildAccountProperties(): Property[] {\n  const accountInfo = getAccountInformation()\n  if (!accountInfo) {\n    return []\n  }\n\n  const properties: Property[] = []\n\n  if (accountInfo.subscription) {\n    properties.push({\n      label: 'Login method',\n      value: `${accountInfo.subscription} Account`,\n    })\n  }\n\n  if (accountInfo.tokenSource) {\n    properties.push({\n      label: 'Auth token',\n      value: accountInfo.tokenSource,\n    })\n  }\n\n  if (accountInfo.apiKeySource) {\n    properties.push({\n      label: 'API key',\n      value: accountInfo.apiKeySource,\n    })\n  }\n\n  // Hide sensitive account info in demo mode\n  if (accountInfo.organization && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Organization',\n      value: accountInfo.organization,\n    })\n  }\n  if (accountInfo.email && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Email',\n      value: accountInfo.email,\n    })\n  }\n\n  return properties\n}\n\nexport function buildAPIProviderProperties(): Property[] {\n  const apiProvider = getAPIProvider()\n\n  const properties: Property[] = []\n\n  if (apiProvider !== 'firstParty') {\n    const providerLabel = {\n      bedrock: 'AWS Bedrock',\n      vertex: 'Google Vertex AI',\n      foundry: 'Microsoft Foundry',\n    }[apiProvider]\n\n    properties.push({\n      label: 'API provider',\n      value: providerLabel,\n    })\n  }\n\n  if (apiProvider === 'firstParty') {\n    const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL\n    if (anthropicBaseUrl) {\n      properties.push({\n        label: 'Anthropic base URL',\n        value: anthropicBaseUrl,\n      })\n    }\n  } else if (apiProvider === 'bedrock') {\n    const bedrockBaseUrl = process.env.BEDROCK_BASE_URL\n    if (bedrockBaseUrl) {\n      properties.push({\n        label: 'Bedrock base URL',\n        value: bedrockBaseUrl,\n      })\n    }\n\n    properties.push({\n      label: 'AWS region',\n      value: getAWSRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {\n      properties.push({\n        value: 'AWS auth skipped',\n      })\n    }\n  } else if (apiProvider === 'vertex') {\n    const vertexBaseUrl = process.env.VERTEX_BASE_URL\n    if (vertexBaseUrl) {\n      properties.push({\n        label: 'Vertex base URL',\n        value: vertexBaseUrl,\n      })\n    }\n\n    const gcpProject = process.env.ANTHROPIC_VERTEX_PROJECT_ID\n    if (gcpProject) {\n      properties.push({\n        label: 'GCP project',\n        value: gcpProject,\n      })\n    }\n\n    properties.push({\n      label: 'Default region',\n      value: getDefaultVertexRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {\n      properties.push({\n        value: 'GCP auth skipped',\n      })\n    }\n  } else if (apiProvider === 'foundry') {\n    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL\n    if (foundryBaseUrl) {\n      properties.push({\n        label: 'Microsoft Foundry base URL',\n        value: foundryBaseUrl,\n      })\n    }\n\n    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE\n    if (foundryResource) {\n      properties.push({\n        label: 'Microsoft Foundry resource',\n        value: foundryResource,\n      })\n    }\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FOUNDRY_AUTH)) {\n      properties.push({\n        value: 'Microsoft Foundry auth skipped',\n      })\n    }\n  }\n\n  const proxyUrl = getProxyUrl()\n  if (proxyUrl) {\n    properties.push({\n      label: 'Proxy',\n      value: proxyUrl,\n    })\n  }\n\n  const mtlsConfig = getMTLSConfig()\n  if (process.env.NODE_EXTRA_CA_CERTS) {\n    properties.push({\n      label: 'Additional CA cert(s)',\n      value: process.env.NODE_EXTRA_CA_CERTS,\n    })\n  }\n  if (mtlsConfig) {\n    if (mtlsConfig.cert && process.env.CLAUDE_CODE_CLIENT_CERT) {\n      properties.push({\n        label: 'mTLS client cert',\n        value: process.env.CLAUDE_CODE_CLIENT_CERT,\n      })\n    }\n\n    if (mtlsConfig.key && process.env.CLAUDE_CODE_CLIENT_KEY) {\n      properties.push({\n        label: 'mTLS client key',\n        value: process.env.CLAUDE_CODE_CLIENT_KEY,\n      })\n    }\n  }\n\n  return properties\n}\n\nexport function getModelDisplayLabel(mainLoopModel: string | null): string {\n  let modelLabel = modelDisplayString(mainLoopModel)\n\n  if (mainLoopModel === null && isClaudeAISubscriber()) {\n    const description = getClaudeAiUserDefaultModelDescription()\n\n    modelLabel = `${chalk.bold('Default')} ${description}`\n  }\n\n  return modelLabel\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","color","Text","MCPServerConnection","getAccountInformation","isClaudeAISubscriber","getLargeMemoryFiles","getMemoryFiles","MAX_MEMORY_CHARACTER_COUNT","getDoctorDiagnostic","getAWSRegion","getDefaultVertexRegion","isEnvTruthy","getDisplayPath","formatNumber","getIdeClientName","IDEExtensionInstallationStatus","isJetBrainsIde","toIDEDisplayName","getClaudeAiUserDefaultModelDescription","modelDisplayString","getAPIProvider","getMTLSConfig","checkInstall","getProxyUrl","SandboxManager","getSettingsWithAllErrors","getEnabledSettingSources","getSettingSourceDisplayNameCapitalized","getManagedFileSettingsPresence","getPolicySettingsOrigin","getSettingsForSource","ThemeName","Property","label","value","ReactNode","Array","Diagnostic","buildSandboxProperties","isSandboxed","isSandboxingEnabled","buildIDEProperties","mcpClients","ideInstallationStatus","theme","ideClient","find","client","name","ideName","ideType","pluginOrExtension","error","cross","installed","type","installedVersion","serverInfo","version","buildMcpProperties","clients","servers","filter","length","byState","connected","pending","needsAuth","failed","s","parts","push","join","buildMemoryDiagnostics","Promise","files","largeFiles","diagnostics","forEach","file","displayPath","path","content","buildSettingSourcesProperties","enabledSources","sourcesWithSettings","source","settings","Object","keys","sourceNames","map","origin","hasBase","hasDropIns","buildInstallationDiagnostics","installWarnings","warning","message","buildInstallationHealthDiagnostics","diagnostic","items","errors","validationErrors","invalidFiles","from","Set","fileList","warnings","issue","hasUpdatePermissions","buildAccountProperties","accountInfo","properties","subscription","tokenSource","apiKeySource","organization","process","env","IS_DEMO","email","buildAPIProviderProperties","apiProvider","providerLabel","bedrock","vertex","foundry","anthropicBaseUrl","ANTHROPIC_BASE_URL","bedrockBaseUrl","BEDROCK_BASE_URL","CLAUDE_CODE_SKIP_BEDROCK_AUTH","vertexBaseUrl","VERTEX_BASE_URL","gcpProject","ANTHROPIC_VERTEX_PROJECT_ID","CLAUDE_CODE_SKIP_VERTEX_AUTH","foundryBaseUrl","ANTHROPIC_FOUNDRY_BASE_URL","foundryResource","ANTHROPIC_FOUNDRY_RESOURCE","CLAUDE_CODE_SKIP_FOUNDRY_AUTH","proxyUrl","mtlsConfig","NODE_EXTRA_CA_CERTS","cert","CLAUDE_CODE_CLIENT_CERT","key","CLAUDE_CODE_CLIENT_KEY","getModelDisplayLabel","mainLoopModel","modelLabel","description","bold"],"sources":["status.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { color, Text } from '../ink.js'\nimport type { MCPServerConnection } from '../services/mcp/types.js'\nimport { getAccountInformation, isClaudeAISubscriber } from './auth.js'\nimport {\n  getLargeMemoryFiles,\n  getMemoryFiles,\n  MAX_MEMORY_CHARACTER_COUNT,\n} from './claudemd.js'\nimport { getDoctorDiagnostic } from './doctorDiagnostic.js'\nimport {\n  getAWSRegion,\n  getDefaultVertexRegion,\n  isEnvTruthy,\n} from './envUtils.js'\nimport { getDisplayPath } from './file.js'\nimport { formatNumber } from './format.js'\nimport {\n  getIdeClientName,\n  type IDEExtensionInstallationStatus,\n  isJetBrainsIde,\n  toIDEDisplayName,\n} from './ide.js'\nimport {\n  getClaudeAiUserDefaultModelDescription,\n  modelDisplayString,\n} from './model/model.js'\nimport { getAPIProvider } from './model/providers.js'\nimport { getMTLSConfig } from './mtls.js'\nimport { checkInstall } from './nativeInstaller/index.js'\nimport { getProxyUrl } from './proxy.js'\nimport { SandboxManager } from './sandbox/sandbox-adapter.js'\nimport { getSettingsWithAllErrors } from './settings/allErrors.js'\nimport {\n  getEnabledSettingSources,\n  getSettingSourceDisplayNameCapitalized,\n} from './settings/constants.js'\nimport {\n  getManagedFileSettingsPresence,\n  getPolicySettingsOrigin,\n  getSettingsForSource,\n} from './settings/settings.js'\nimport type { ThemeName } from './theme.js'\n\nexport type Property = {\n  label?: string\n  value: React.ReactNode | Array<string>\n}\n\nexport type Diagnostic = React.ReactNode\n\nexport function buildSandboxProperties(): Property[] {\n  if (\"external\" !== 'ant') {\n    return []\n  }\n\n  const isSandboxed = SandboxManager.isSandboxingEnabled()\n\n  return [\n    {\n      label: 'Bash Sandbox',\n      value: isSandboxed ? 'Enabled' : 'Disabled',\n    },\n  ]\n}\n\nexport function buildIDEProperties(\n  mcpClients: MCPServerConnection[],\n  ideInstallationStatus: IDEExtensionInstallationStatus | null = null,\n  theme: ThemeName,\n): Property[] {\n  const ideClient = mcpClients?.find(client => client.name === 'ide')\n\n  if (ideInstallationStatus) {\n    const ideName = toIDEDisplayName(ideInstallationStatus.ideType)\n    const pluginOrExtension = isJetBrainsIde(ideInstallationStatus.ideType)\n      ? 'plugin'\n      : 'extension'\n\n    if (ideInstallationStatus.error) {\n      return [\n        {\n          label: 'IDE',\n          value: (\n            <Text>\n              {color('error', theme)(figures.cross)} Error installing {ideName}{' '}\n              {pluginOrExtension}: {ideInstallationStatus.error}\n              {'\\n'}Please restart your IDE and try again.\n            </Text>\n          ),\n        },\n      ]\n    }\n\n    if (ideInstallationStatus.installed) {\n      if (ideClient && ideClient.type === 'connected') {\n        if (\n          ideInstallationStatus.installedVersion !==\n          ideClient.serverInfo?.version\n        ) {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion} (server version: ${ideClient.serverInfo?.version})`,\n            },\n          ]\n        } else {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion}`,\n            },\n          ]\n        }\n      } else {\n        return [\n          {\n            label: 'IDE',\n            value: `Installed ${ideName} ${pluginOrExtension}`,\n          },\n        ]\n      }\n    }\n  } else if (ideClient) {\n    const ideName = getIdeClientName(ideClient) ?? 'IDE'\n    if (ideClient.type === 'connected') {\n      return [\n        {\n          label: 'IDE',\n          value: `Connected to ${ideName} extension`,\n        },\n      ]\n    } else {\n      return [\n        {\n          label: 'IDE',\n          value: `${color('error', theme)(figures.cross)} Not connected to ${ideName}`,\n        },\n      ]\n    }\n  }\n\n  return []\n}\n\nexport function buildMcpProperties(\n  clients: MCPServerConnection[] = [],\n  theme: ThemeName,\n): Property[] {\n  const servers = clients.filter(client => client.name !== 'ide')\n  if (!servers.length) {\n    return []\n  }\n\n  // Summary instead of a full server list — 20+ servers wrapped onto many\n  // rows, dominating the Status pane. Show counts by state + /mcp hint.\n  const byState = { connected: 0, pending: 0, needsAuth: 0, failed: 0 }\n  for (const s of servers) {\n    if (s.type === 'connected') byState.connected++\n    else if (s.type === 'pending') byState.pending++\n    else if (s.type === 'needs-auth') byState.needsAuth++\n    else byState.failed++\n  }\n  const parts: string[] = []\n  if (byState.connected)\n    parts.push(color('success', theme)(`${byState.connected} connected`))\n  if (byState.needsAuth)\n    parts.push(color('warning', theme)(`${byState.needsAuth} need auth`))\n  if (byState.pending)\n    parts.push(color('inactive', theme)(`${byState.pending} pending`))\n  if (byState.failed)\n    parts.push(color('error', theme)(`${byState.failed} failed`))\n\n  return [\n    {\n      label: 'MCP servers',\n      value: `${parts.join(', ')} ${color('inactive', theme)('· /mcp')}`,\n    },\n  ]\n}\n\nexport async function buildMemoryDiagnostics(): Promise<Diagnostic[]> {\n  const files = await getMemoryFiles()\n  const largeFiles = getLargeMemoryFiles(files)\n\n  const diagnostics: Diagnostic[] = []\n\n  largeFiles.forEach(file => {\n    const displayPath = getDisplayPath(file.path)\n    diagnostics.push(\n      `Large ${displayPath} will impact performance (${formatNumber(file.content.length)} chars > ${formatNumber(MAX_MEMORY_CHARACTER_COUNT)})`,\n    )\n  })\n\n  return diagnostics\n}\n\nexport function buildSettingSourcesProperties(): Property[] {\n  const enabledSources = getEnabledSettingSources()\n\n  // Filter to only sources that actually have settings loaded\n  const sourcesWithSettings = enabledSources.filter(source => {\n    const settings = getSettingsForSource(source)\n    return settings !== null && Object.keys(settings).length > 0\n  })\n\n  // Map internal names to user-friendly names\n  // For policySettings, distinguish between remote and local (or skip if neither exists)\n  const sourceNames = sourcesWithSettings\n    .map(source => {\n      if (source === 'policySettings') {\n        const origin = getPolicySettingsOrigin()\n        if (origin === null) {\n          return null // Skip - no policy settings exist\n        }\n        switch (origin) {\n          case 'remote':\n            return 'Enterprise managed settings (remote)'\n          case 'plist':\n            return 'Enterprise managed settings (plist)'\n          case 'hklm':\n            return 'Enterprise managed settings (HKLM)'\n          case 'file': {\n            const { hasBase, hasDropIns } = getManagedFileSettingsPresence()\n            if (hasBase && hasDropIns) {\n              return 'Enterprise managed settings (file + drop-ins)'\n            }\n            if (hasDropIns) {\n              return 'Enterprise managed settings (drop-ins)'\n            }\n            return 'Enterprise managed settings (file)'\n          }\n          case 'hkcu':\n            return 'Enterprise managed settings (HKCU)'\n        }\n      }\n      return getSettingSourceDisplayNameCapitalized(source)\n    })\n    .filter((name): name is string => name !== null)\n\n  return [\n    {\n      label: 'Setting sources',\n      value: sourceNames,\n    },\n  ]\n}\n\nexport async function buildInstallationDiagnostics(): Promise<Diagnostic[]> {\n  const installWarnings = await checkInstall()\n  return installWarnings.map(warning => warning.message)\n}\n\nexport async function buildInstallationHealthDiagnostics(): Promise<\n  Diagnostic[]\n> {\n  const diagnostic = await getDoctorDiagnostic()\n  const items: Diagnostic[] = []\n\n  const { errors: validationErrors } = getSettingsWithAllErrors()\n  if (validationErrors.length > 0) {\n    const invalidFiles = Array.from(\n      new Set(validationErrors.map(error => error.file)),\n    )\n    const fileList = invalidFiles.join(', ')\n\n    items.push(\n      `Found invalid settings files: ${fileList}. They will be ignored.`,\n    )\n  }\n\n  // Add warnings from doctor diagnostic (includes leftover installations, config mismatches, etc.)\n  diagnostic.warnings.forEach(warning => {\n    items.push(warning.issue)\n  })\n\n  if (diagnostic.hasUpdatePermissions === false) {\n    items.push('No write permissions for auto-updates (requires sudo)')\n  }\n\n  return items\n}\n\nexport function buildAccountProperties(): Property[] {\n  const accountInfo = getAccountInformation()\n  if (!accountInfo) {\n    return []\n  }\n\n  const properties: Property[] = []\n\n  if (accountInfo.subscription) {\n    properties.push({\n      label: 'Login method',\n      value: `${accountInfo.subscription} Account`,\n    })\n  }\n\n  if (accountInfo.tokenSource) {\n    properties.push({\n      label: 'Auth token',\n      value: accountInfo.tokenSource,\n    })\n  }\n\n  if (accountInfo.apiKeySource) {\n    properties.push({\n      label: 'API key',\n      value: accountInfo.apiKeySource,\n    })\n  }\n\n  // Hide sensitive account info in demo mode\n  if (accountInfo.organization && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Organization',\n      value: accountInfo.organization,\n    })\n  }\n  if (accountInfo.email && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Email',\n      value: accountInfo.email,\n    })\n  }\n\n  return properties\n}\n\nexport function buildAPIProviderProperties(): Property[] {\n  const apiProvider = getAPIProvider()\n\n  const properties: Property[] = []\n\n  if (apiProvider !== 'firstParty') {\n    const providerLabel = {\n      bedrock: 'AWS Bedrock',\n      vertex: 'Google Vertex AI',\n      foundry: 'Microsoft Foundry',\n    }[apiProvider]\n\n    properties.push({\n      label: 'API provider',\n      value: providerLabel,\n    })\n  }\n\n  if (apiProvider === 'firstParty') {\n    const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL\n    if (anthropicBaseUrl) {\n      properties.push({\n        label: 'Anthropic base URL',\n        value: anthropicBaseUrl,\n      })\n    }\n  } else if (apiProvider === 'bedrock') {\n    const bedrockBaseUrl = process.env.BEDROCK_BASE_URL\n    if (bedrockBaseUrl) {\n      properties.push({\n        label: 'Bedrock base URL',\n        value: bedrockBaseUrl,\n      })\n    }\n\n    properties.push({\n      label: 'AWS region',\n      value: getAWSRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {\n      properties.push({\n        value: 'AWS auth skipped',\n      })\n    }\n  } else if (apiProvider === 'vertex') {\n    const vertexBaseUrl = process.env.VERTEX_BASE_URL\n    if (vertexBaseUrl) {\n      properties.push({\n        label: 'Vertex base URL',\n        value: vertexBaseUrl,\n      })\n    }\n\n    const gcpProject = process.env.ANTHROPIC_VERTEX_PROJECT_ID\n    if (gcpProject) {\n      properties.push({\n        label: 'GCP project',\n        value: gcpProject,\n      })\n    }\n\n    properties.push({\n      label: 'Default region',\n      value: getDefaultVertexRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {\n      properties.push({\n        value: 'GCP auth skipped',\n      })\n    }\n  } else if (apiProvider === 'foundry') {\n    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL\n    if (foundryBaseUrl) {\n      properties.push({\n        label: 'Microsoft Foundry base URL',\n        value: foundryBaseUrl,\n      })\n    }\n\n    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE\n    if (foundryResource) {\n      properties.push({\n        label: 'Microsoft Foundry resource',\n        value: foundryResource,\n      })\n    }\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FOUNDRY_AUTH)) {\n      properties.push({\n        value: 'Microsoft Foundry auth skipped',\n      })\n    }\n  }\n\n  const proxyUrl = getProxyUrl()\n  if (proxyUrl) {\n    properties.push({\n      label: 'Proxy',\n      value: proxyUrl,\n    })\n  }\n\n  const mtlsConfig = getMTLSConfig()\n  if (process.env.NODE_EXTRA_CA_CERTS) {\n    properties.push({\n      label: 'Additional CA cert(s)',\n      value: process.env.NODE_EXTRA_CA_CERTS,\n    })\n  }\n  if (mtlsConfig) {\n    if (mtlsConfig.cert && process.env.CLAUDE_CODE_CLIENT_CERT) {\n      properties.push({\n        label: 'mTLS client cert',\n        value: process.env.CLAUDE_CODE_CLIENT_CERT,\n      })\n    }\n\n    if (mtlsConfig.key && process.env.CLAUDE_CODE_CLIENT_KEY) {\n      properties.push({\n        label: 'mTLS client key',\n        value: process.env.CLAUDE_CODE_CLIENT_KEY,\n      })\n    }\n  }\n\n  return properties\n}\n\nexport function getModelDisplayLabel(mainLoopModel: string | null): string {\n  let modelLabel = modelDisplayString(mainLoopModel)\n\n  if (mainLoopModel === null && isClaudeAISubscriber()) {\n    const description = getClaudeAiUserDefaultModelDescription()\n\n    modelLabel = `${chalk.bold('Default')} ${description}`\n  }\n\n  return modelLabel\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/utils/suggestions/commandSuggestions.ts b/src/utils/suggestions/commandSuggestions.ts
index 4a90db55..2f83ae6f 100644
--- a/src/utils/suggestions/commandSuggestions.ts
+++ b/src/utils/suggestions/commandSuggestions.ts
@@ -286,6 +286,25 @@ function createCommandSuggestionItem(
   }
 }
 
+/**
+ * Ensure suggestion IDs are unique for React keys and selection logic.
+ * If duplicates exist, append a stable numeric suffix to subsequent entries.
+ */
+function ensureUniqueSuggestionIds(items: SuggestionItem[]): SuggestionItem[] {
+  const counts = new Map<string, number>()
+  return items.map(item => {
+    const seen = counts.get(item.id) ?? 0
+    counts.set(item.id, seen + 1)
+    if (seen === 0) {
+      return item
+    }
+    return {
+      ...item,
+      id: `${item.id}#${seen + 1}`,
+    }
+  })
+}
+
 /**
  * Generate command suggestions based on input
  */
@@ -369,14 +388,14 @@ export function generateCommandSuggestions(
 
     // Combine with built-in commands prioritized after recently used,
     // so they remain visible even when many skills are installed
-    return [
+    return ensureUniqueSuggestionIds([
       ...recentlyUsed,
       ...builtinCommands,
       ...userCommands,
       ...projectCommands,
       ...policyCommands,
       ...otherCommands,
-    ].map(cmd => createCommandSuggestionItem(cmd))
+    ].map(cmd => createCommandSuggestionItem(cmd)))
   }
 
   // The Fuse index filters isHidden at build time and is keyed on the
@@ -491,10 +510,13 @@ export function generateCommandSuggestions(
   if (hiddenExact) {
     const hiddenId = getCommandId(hiddenExact)
     if (!fuseSuggestions.some(s => s.id === hiddenId)) {
-      return [createCommandSuggestionItem(hiddenExact), ...fuseSuggestions]
+      return ensureUniqueSuggestionIds([
+        createCommandSuggestionItem(hiddenExact),
+        ...fuseSuggestions,
+      ])
     }
   }
-  return fuseSuggestions
+  return ensureUniqueSuggestionIds(fuseSuggestions)
 }
 
 /**
diff --git a/src/utils/swarm/spawnUtils.ts b/src/utils/swarm/spawnUtils.ts
index cfccdf5a..037d273d 100644
--- a/src/utils/swarm/spawnUtils.ts
+++ b/src/utils/swarm/spawnUtils.ts
@@ -99,6 +99,18 @@ const TEAMMATE_ENV_VARS = [
   'CLAUDE_CODE_USE_BEDROCK',
   'CLAUDE_CODE_USE_VERTEX',
   'CLAUDE_CODE_USE_FOUNDRY',
+  'CLAUDE_CODE_USE_GITHUB',
+  'CLAUDE_CODE_USE_GEMINI',
+  'CLAUDE_CODE_USE_OPENAI',
+  'GITHUB_TOKEN',
+  'GH_TOKEN',
+  'OPENAI_API_KEY',
+  'OPENAI_BASE_URL',
+  'OPENAI_MODEL',
+  'GEMINI_API_KEY',
+  'GEMINI_BASE_URL',
+  'GEMINI_MODEL',
+  'GOOGLE_API_KEY',
   // Custom API endpoint
   'ANTHROPIC_BASE_URL',
   // Config directory override
diff --git a/test_atomic_chat_provider.py b/test_atomic_chat_provider.py
new file mode 100644
index 00000000..819c610c
--- /dev/null
+++ b/test_atomic_chat_provider.py
@@ -0,0 +1,130 @@
+"""
+test_atomic_chat_provider.py
+Run: pytest test_atomic_chat_provider.py -v
+"""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from atomic_chat_provider import (
+    atomic_chat,
+    list_atomic_chat_models,
+    check_atomic_chat_running,
+)
+
+
+@pytest.mark.asyncio
+async def test_atomic_chat_running_true():
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.get = AsyncMock(return_value=mock_response)
+        result = await check_atomic_chat_running()
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_atomic_chat_running_false_on_exception():
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.get = AsyncMock(side_effect=Exception("refused"))
+        result = await check_atomic_chat_running()
+    assert result is False
+
+
+@pytest.mark.asyncio
+async def test_list_models_returns_ids():
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "data": [{"id": "llama-3.1-8b"}, {"id": "mistral-7b"}],
+    }
+    mock_response.raise_for_status = MagicMock()
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.get = AsyncMock(return_value=mock_response)
+        models = await list_atomic_chat_models()
+    assert "llama-3.1-8b" in models
+    assert "mistral-7b" in models
+
+
+@pytest.mark.asyncio
+async def test_list_models_empty_on_failure():
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.get = AsyncMock(side_effect=Exception("down"))
+        models = await list_atomic_chat_models()
+    assert models == []
+
+
+@pytest.mark.asyncio
+async def test_atomic_chat_returns_anthropic_format():
+    mock_response = MagicMock()
+    mock_response.raise_for_status = MagicMock()
+    mock_response.json.return_value = {
+        "id": "chatcmpl-abc123",
+        "choices": [{"message": {"content": "42 is the answer."}}],
+        "usage": {"prompt_tokens": 10, "completion_tokens": 8},
+    }
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.post = AsyncMock(return_value=mock_response)
+        result = await atomic_chat(
+            model="llama-3.1-8b",
+            messages=[{"role": "user", "content": "What is 6*7?"}],
+        )
+    assert result["type"] == "message"
+    assert result["role"] == "assistant"
+    assert "42" in result["content"][0]["text"]
+    assert result["usage"]["input_tokens"] == 10
+    assert result["usage"]["output_tokens"] == 8
+
+
+@pytest.mark.asyncio
+async def test_atomic_chat_prepends_system():
+    captured = {}
+
+    async def mock_post(url, json=None, **kwargs):
+        captured.update(json or {})
+        m = MagicMock()
+        m.raise_for_status = MagicMock()
+        m.json.return_value = {
+            "id": "chatcmpl-xyz",
+            "choices": [{"message": {"content": "ok"}}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1},
+        }
+        return m
+
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.post = mock_post
+        await atomic_chat(
+            model="llama-3.1-8b",
+            messages=[{"role": "user", "content": "Hi"}],
+            system="Be helpful.",
+        )
+    assert captured["messages"][0]["role"] == "system"
+    assert "helpful" in captured["messages"][0]["content"]
+
+
+@pytest.mark.asyncio
+async def test_atomic_chat_sends_correct_payload():
+    captured = {}
+
+    async def mock_post(url, json=None, **kwargs):
+        captured.update(json or {})
+        m = MagicMock()
+        m.raise_for_status = MagicMock()
+        m.json.return_value = {
+            "id": "chatcmpl-xyz",
+            "choices": [{"message": {"content": "ok"}}],
+            "usage": {"prompt_tokens": 1, "completion_tokens": 1},
+        }
+        return m
+
+    with patch("atomic_chat_provider.httpx.AsyncClient") as MockClient:
+        MockClient.return_value.__aenter__.return_value.post = mock_post
+        await atomic_chat(
+            model="test-model",
+            messages=[{"role": "user", "content": "Test"}],
+            max_tokens=2048,
+            temperature=0.5,
+        )
+    assert captured["model"] == "test-model"
+    assert captured["max_tokens"] == 2048
+    assert captured["temperature"] == 0.5
+    assert captured["stream"] is False