diff --git a/docs/CLI_TOOL_EXECUTION.md b/docs/CLI_TOOL_EXECUTION.md
new file mode 100644
index 00000000..880f55db
--- /dev/null
+++ b/docs/CLI_TOOL_EXECUTION.md
@@ -0,0 +1,160 @@
+# CLI Tool Execution for Spec Task Runner
+
+## Overview
+
+The Spec Task Runner can now execute tasks via external CLI tools (GitHub Copilot CLI, Claude Code, Gemini CLI, Codex) instead of exclusively through the built-in LLM provider. CLI tools run as external processes, work directly on the filesystem, and use the Backlog MCP server to manage task status — the same completion detection mechanism used by the LLM path.
+
+## Architecture
+
+### Strategy Pattern
+
+`SpecTaskRunnerService.submitNextTask()` delegates to one of two execution paths based on the user's selection:
+
+```
+submitNextTask()
+  ├── submitTaskViaLlm()   →  message bus  →  langchain4j agent loop  →  backlog_task_edit(Done)
+  └── submitTaskViaCli()   →  ProcessBuilder  →  CLI tool (with Backlog MCP)  →  task_edit(Done)
+```
+
+Both paths converge at `notifyPromptExecutionCompleted()` — the only difference is what triggers it.
+
+### Completion Detection (Both Paths)
+
+```
+LLM Path:   prompt → langchain4j → backlog_task_edit(Done) → spec file changes
+                                                                    ↓
+                                                      onSpecsChanged() sets flag
+                                                                    ↓
+             ActionButtonsPanel.enableButtons() → notifyPromptExecutionCompleted()
+                                                                    ↓
+                                                         advance immediately
+
+CLI Path:   prompt → ProcessBuilder → CLI tool → task_edit(Done) → spec file changes
+                                                                    ↓
+                                                      onSpecsChanged() sets flag
+                                                                    ↓
+             process.waitFor() exits → notifyPromptExecutionCompleted()
+                                                                    ↓
+                                                         advance immediately
+```
+
+**Important**: `ActionButtonsPanel.enableButtons()` guards its call to `notifyPromptExecutionCompleted()` with `!runner.isCliMode()` so it only fires for the LLM path. Without this guard, the LLM prompt lifecycle (which still runs in the background) would trigger a spurious completion notification immediately after the CLI process starts, causing every task to be skipped via the grace timer.
+
+If the CLI tool exits without marking the task Done, the existing grace timer fires after 3 seconds and skips to the next task.
+
+### Prompt Construction
+
+CLI tools receive the same structured prompt as the LLM provider:
+
+1. **Instruction block** (`SpecContextBuilder.buildCliInstruction()`) — task identification, step-by-step workflow using Backlog MCP tools (set In Progress, check criteria, append notes, write summary, set Done)
+2. **Context block** (`SpecContextBuilder.buildContext()`) — full `<TaskSpec>` XML with metadata, description, acceptance criteria, definition of done, dependencies, references, implementation plan/notes
+3. **Implementation request** suffix
+
+### Process Execution
+
+`CliTaskExecutorService` runs the CLI tool as an external process:
+
+- **Command format**: `[executablePath, promptFlag, prompt, ...extraArgs]`
+- **Working directory**: project base path
+- **Thread model**: pooled thread via `ApplicationManager.executeOnPooledThread()`
+- **Output streaming**: stdout/stderr streamed line-by-line to an IntelliJ `ConsoleView` in the Run tool window
+- **Debug logging**: command details, process PID, exit code, elapsed time, and first 5 lines of output are logged to the IDE log for troubleshooting
+- **Cancellation**: `Process.destroyForcibly()` on cancel
+
+## Configuration
+
+### CLI Tool Settings
+
+Settings > Spec Driven Development > CLI Runners
+
+Each CLI tool entry has:
+
+| Field | Description | Example |
+|-------|-------------|---------|
+| Name | Display name used in the mode selector | `copilot` |
+| Executable Path | Absolute path to the CLI binary | `/opt/homebrew/bin/copilot` |
+| Prompt Flag | Flag that precedes the prompt argument | `-p` |
+| Extra Args | Additional arguments appended after the prompt | `--allow-all` |
+| Enabled | Whether the tool appears in the mode selector | `true` |
+
+A default **copilot** entry is pre-populated: `/opt/homebrew/bin/copilot -p "..." --allow-all`
+
+### Execution Mode Selector
+
+The Spec Browser toolbar includes a ComboBox with:
+- **LLM Provider** — uses the built-in langchain4j agent loop (default)
+- **CLI: {name}** — one entry per enabled CLI tool
+
+Selection is persisted to `DevoxxGenieStateService` (`specRunnerMode` and `specSelectedCliTool`). The combo refreshes automatically when settings are applied (via `SETTINGS_CHANGED_TOPIC` subscription).
+
+## Prerequisites
+
+CLI tools **must have the Backlog MCP server installed** and configured. The tool needs access to the same backlog directory so it can:
+
+1. Set task status to "In Progress"
+2. Check off acceptance criteria as it works
+3. Append implementation notes
+4. Write a final summary
+5. Set task status to "Done"
+
+Without Backlog MCP, the CLI tool cannot mark tasks as complete, and the grace timer will skip tasks after 3 seconds.
+
+## Files
+
+### New Files
+
+| File | Type | Description |
+|------|------|-------------|
+| `model/spec/CliToolConfig.java` | Model | CLI tool configuration (name, path, flag, args, enabled) |
+| `service/spec/CliTaskExecutorService.java` | Service | Runs CLI processes, streams output, notifies on exit |
+| `service/spec/CliConsoleManager.java` | Service | Manages ConsoleView in the Run tool window |
+
+### Modified Files
+
+| File | Changes |
+|------|---------|
+| `service/spec/SpecTaskRunnerService.java` | Added `cliMode` flag (with getter), `submitTaskViaCli()`, `findCliTool()`, CLI cancel support, debug logging |
+| `service/spec/SpecContextBuilder.java` | Added `buildCliInstruction()` for CLI-specific prompt instructions |
+| `ui/settings/DevoxxGenieStateService.java` | Added `cliTools`, `specRunnerMode`, `specSelectedCliTool` fields |
+| `ui/settings/spec/SpecSettingsComponent.java` | Added CLI Runners section with table, Add/Edit/Remove dialog |
+| `ui/panel/spec/SpecBrowserPanel.java` | Added execution mode ComboBox in toolbar, subscribes to `SETTINGS_CHANGED_TOPIC` to refresh combo |
+| `ui/panel/ActionButtonsPanel.java` | Guarded `notifyPromptExecutionCompleted()` with `!runner.isCliMode()` to prevent LLM path from interfering with CLI execution |
+
+## Testing
+
+1. **Settings**: Open Settings > Spec Driven Development > verify CLI Runners section with pre-populated copilot entry
+2. **Mode selector**: Open Spec Browser > verify ComboBox shows "LLM Provider" and "CLI: copilot"
+3. **Single task CLI run**: Select "CLI: copilot", check one To Do task, click Run Selected:
+   - Run tool window opens with console showing CLI output
+   - CLI tool receives prompt with full task spec and backlog instructions
+   - CLI tool uses Backlog MCP to mark task In Progress then Done
+   - `onSpecsChanged()` detects Done, process exits, runner advances
+4. **Batch run**: Run multiple tasks to verify sequential execution with dependency ordering
+5. **Cancel**: Click Cancel during CLI execution to verify process is killed
+6. **Grace timer**: If CLI exits without marking Done, grace timer fires and task is skipped
+7. **Error handling**: Configure an invalid executable path to verify graceful error notification
+
+## Troubleshooting
+
+### Debug Logging
+
+`CliTaskExecutorService` and `SpecTaskRunnerService` emit detailed logs to the IDE log (Help > Show Log in Finder). Key log lines to look for:
+
+| Log Pattern | What It Tells You |
+|-------------|-------------------|
+| `CLI execute: task=..., promptLength=...` | Command details and prompt size |
+| `CLI process started successfully (pid=...)` | Process launched; if missing, `ProcessBuilder.start()` failed |
+| `CLI process exited: ... exitCode=..., elapsed=...ms` | How long the process ran and whether it succeeded |
+| `CLI stdout [...] line N: ...` | First 5 lines of stdout (look for error messages from the CLI tool) |
+| `CLI stderr [...] line N: ...` | First 5 lines of stderr |
+| `CLI stdout-reader finished: 0 lines total` | CLI produced no output — likely crashed or rejected the prompt |
+| `CLI mode: specRunnerMode=..., specSelectedCliTool=...` | Confirms the correct mode and tool are selected |
+
+### Common Issues
+
+| Symptom | Likely Cause |
+|---------|-------------|
+| Process exits in < 1 second with no output | Prompt exceeds OS argument length limit (~256KB on macOS). Consider shortening task descriptions. |
+| All tasks skipped as "not marked Done" | CLI tool doesn't have Backlog MCP installed, or MCP server is not pointing to the correct backlog directory. |
+| ComboBox only shows "LLM Provider" | CLI tools not saved — open Settings > Spec Driven Development > CLI Runners, verify entries, click Apply. |
+| Grace timer skips tasks immediately | `ActionButtonsPanel.enableButtons()` firing in CLI mode — verify the `!runner.isCliMode()` guard is present. |
diff --git a/docusaurus/blog/2026-02-09-devoxxgenie-goes-agentic.md b/docusaurus/blog/2026-02-09-devoxxgenie-goes-agentic.md
index cd40a61d..df75b444 100644
--- a/docusaurus/blog/2026-02-09-devoxxgenie-goes-agentic.md
+++ b/docusaurus/blog/2026-02-09-devoxxgenie-goes-agentic.md
@@ -76,7 +76,7 @@ The plugin prioritizes developer control across every dimension:
 
 ## What's Next
 
-This is just the beginning. With [Spec Driven Development](/docs/features/spec-driven-development) (SDD) now available in v0.9.7, you can define tasks as structured specs and let the agent implement them autonomously — complete with acceptance criteria tracking and a visual Kanban board.
+This is just the beginning. With [Spec-driven Development](/docs/features/spec-driven-development) (SDD) now available in v0.9.7, you can define tasks as structured specs and let the agent implement them autonomously — complete with acceptance criteria tracking and a visual Kanban board.
 
 We're not just chatting with AI anymore. We're collaborating with it.
 
diff --git a/docusaurus/blog/2026-02-10-spec-driven-development.md b/docusaurus/blog/2026-02-10-spec-driven-development.md
index 59c0d536..58ed07e4 100644
--- a/docusaurus/blog/2026-02-10-spec-driven-development.md
+++ b/docusaurus/blog/2026-02-10-spec-driven-development.md
@@ -1,21 +1,21 @@
 ---
 slug: spec-driven-development
-title: "Stop Prompting, Start Specifying: Introducing Spec Driven Development in DevoxxGenie"
+title: "Stop Prompting, Start Specifying: Introducing Spec-driven Development in DevoxxGenie"
 authors: [stephanj]
-tags: [spec driven development, SDD, agent mode, backlog.md, kanban, agentic AI, IntelliJ IDEA, LLM, Java, open source]
+tags: [spec-driven development, SDD, agent mode, backlog.md, kanban, agentic AI, IntelliJ IDEA, LLM, Java, open source]
 date: 2026-02-10
-description: "Introducing Spec Driven Development (SDD) in DevoxxGenie v0.9.7 — define structured task specs with acceptance criteria and let the AI agent implement them."
-keywords: [devoxxgenie, spec driven development, sdd, backlog.md, task specs, kanban board, agent mode, acceptance criteria, milestones, agentic programming]
+description: "Introducing Spec-driven Development (SDD) in DevoxxGenie v0.9.7 — define structured task specs with acceptance criteria and let the AI agent implement them."
+keywords: [devoxxgenie, spec-driven development, sdd, backlog.md, task specs, kanban board, agent mode, acceptance criteria, milestones, agentic programming]
 image: /img/devoxxgenie-social-card.jpg
 ---
 
-# Stop Prompting, Start Specifying: Introducing Spec Driven Development in DevoxxGenie
+# Stop Prompting, Start Specifying: Introducing Spec-driven Development in DevoxxGenie
 
 We've all been there. You open your AI coding assistant, type a prompt, get a result, realise it missed half the requirements, rephrase, try again. Rephrase and repeat. It works (kind of) but it doesn't scale and we lose history.
 
 What if instead of ad-hoc prompting, you could define exactly what needs to be built as a structured spec, and then let the AI agent implement it autonomously — checking off acceptance criteria as it goes?
 
-That's the idea behind **Spec Driven Development (SDD)**, the latest feature in DevoxxGenie v0.9.7.
+That's the idea behind **Spec-driven Development (SDD)**, the latest feature in DevoxxGenie v0.9.7.
 
 <!-- truncate -->
 
@@ -24,7 +24,7 @@ That's the idea behind **Spec Driven Development (SDD)**, the latest feature in
   width="100%"
   style={{aspectRatio: '16/9', maxWidth: '720px', borderRadius: '8px'}}
   src="https://www.youtube.com/embed/t1MOHCfsdvk"
-  title="Spec Driven Development Demo"
+  title="Spec-driven Development Demo"
   frameBorder="0"
   allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
   allowFullScreen
@@ -105,7 +105,7 @@ I could also have used a local model like GLM-4.7-Flash via Ollama, which works
 
 ## The Bigger Picture
 
-DevoxxGenie started as a simple LLM chat plugin. With [Agent Mode](/docs/features/agent-mode), [MCP support](/docs/features/mcp_expanded), and now [Spec Driven Development](/docs/features/spec-driven-development), it's evolving into something more — an AI-augmented development environment where structured specifications replace ad-hoc prompts, and autonomous agents replace copy-paste workflows.
+DevoxxGenie started as a simple LLM chat plugin. With [Agent Mode](/docs/features/agent-mode), [MCP support](/docs/features/mcp_expanded), and now [Spec-driven Development](/docs/features/spec-driven-development), it's evolving into something more — an AI-augmented development environment where structured specifications replace ad-hoc prompts, and autonomous agents replace copy-paste workflows.
 
 We're not just chatting with AI anymore. We're collaborating with it.
 
diff --git a/docusaurus/docs/features/agent-mode.md b/docusaurus/docs/features/agent-mode.md
index 368e6cae..536d8ea1 100644
--- a/docusaurus/docs/features/agent-mode.md
+++ b/docusaurus/docs/features/agent-mode.md
@@ -263,7 +263,7 @@ Final Response (synthesized by main agent)
 
 ## Batch Task Execution (Agent Loop)
 
-Agent Mode powers the [Agent Loop](sdd-agent-loop.md), which lets you run multiple tasks sequentially in a single batch. Combined with [Spec Driven Development](spec-driven-development.md), you can define structured task specs and have the agent implement them one after another — with dependency ordering, progress tracking, and automatic advancement to the next task.
+Agent Mode powers the [Agent Loop](sdd-agent-loop.md), which lets you run multiple tasks sequentially in a single batch. Combined with [Spec-driven Development](spec-driven-development.md), you can define structured task specs and have the agent implement them one after another — with dependency ordering, progress tracking, and automatic advancement to the next task.
 
 ## Best Practices
 
diff --git a/docusaurus/docs/features/cli-runners.md b/docusaurus/docs/features/cli-runners.md
new file mode 100644
index 00000000..fb26a7a1
--- /dev/null
+++ b/docusaurus/docs/features/cli-runners.md
@@ -0,0 +1,105 @@
+---
+sidebar_position: 5
+title: CLI Runners
+description: Execute spec tasks via external CLI tools like Claude Code, GitHub Copilot CLI, OpenAI Codex CLI, or Google Gemini CLI. DevoxxGenie manages the task lifecycle while your preferred tool does the implementation.
+keywords: [devoxxgenie, cli runners, claude code, copilot, codex, gemini, cli tools, spec-driven development, sdd, agent loop]
+image: /img/devoxxgenie-social-card.jpg
+---
+
+# CLI Runners
+
+Instead of using the built-in LLM provider, you can execute spec tasks via **external CLI tools** — such as Claude Code, GitHub Copilot CLI, OpenAI Codex CLI, or Google Gemini CLI. This lets you leverage the tool you already use and trust, while DevoxxGenie manages the task lifecycle.
+
+CLI Runners integrate with both [Spec-driven Development](spec-driven-development.md) (single task execution) and the [Agent Loop](sdd-agent-loop.md) (batch task execution).
+
+## How It Works
+
+Each CLI tool is launched as an external process with your task prompt piped in. A **Backlog MCP config** is auto-generated and passed to the CLI so it can read and update tasks using the same backlog tools as the built-in agent. The output streams live into an IntelliJ **Run** tool window console.
+
+```
+┌──────────────────┐     ┌──────────────────────┐     ┌──────────────────┐
+│  DevoxxGenie     │────▶│  CLI Process          │────▶│  Backlog MCP     │
+│  (Task Runner)   │     │  (Claude/Copilot/...) │     │  (task updates)  │
+└──────────────────┘     └──────────────────────┘     └──────────────────┘
+        │                          │                          │
+  Launches process         Implements the task         Sets status to Done,
+  with prompt + MCP        using its own tools         checks off criteria
+  config via stdin                                     via MCP tools
+```
+
+## Supported CLI Tools
+
+| CLI Tool | Prompt Delivery | MCP Support | Default Args |
+|----------|----------------|-------------|--------------|
+| **Claude Code** | stdin (`-p` flag) | Auto-generated `--mcp-config` | `-p --dangerously-skip-permissions --model opus --allowedTools Backlog.md` |
+| **GitHub Copilot** | stdin | Auto-generated `--additional-mcp-config` (with `@` prefix) | `--allow-all` |
+| **OpenAI Codex** | Trailing argument | Not supported | `exec --model gpt-5.3-codex --full-auto` |
+| **Google Gemini** | stdin | Auto-generated `--mcp-config` | *(none)* |
+| **Custom** | stdin | Configurable | *(user-defined)* |
+
+:::note
+Codex CLI does not support MCP, so it cannot update task status directly. The task runner detects completion via the spec file watcher and terminates the Codex process automatically.
+:::
+
+## Setup
+
+1. Open **Settings** > **Tools** > **DevoxxGenie** > **Spec Driven Dev**
+2. Scroll to the **CLI Runners** section
+3. Click **+** to add a new CLI tool
+4. Select the **Type** from the dropdown — all fields are pre-filled with sensible defaults
+5. Adjust the **Executable path** if your CLI is installed in a different location
+6. Optionally add **Env vars** (e.g., `ANTHROPIC_API_KEY=sk-...`) for tools that need API keys when launched from IntelliJ
+7. Click **Test Connection** to verify the tool is installed and authenticated
+8. Click **OK**, then **Apply**
+
+You can configure **multiple CLI tools** — for example, Claude for complex tasks and Codex for quick fixes. Switch between them in the toolbar.
+
+![CLI Runners configuration list in Settings](/img/CLI-Runners-Setup.png)
+
+## Selecting the Execution Mode
+
+The **DevoxxGenie Specs** toolbar contains an execution mode dropdown:
+
+- **LLM Provider** — uses the built-in LLM agent (default)
+- **CLI: Claude** / **CLI: Copilot** / etc. — uses the configured external CLI tool
+
+The selection is persisted across IDE restarts. When you click **Run Selected** or **Run All To Do**, tasks are executed using whichever mode is selected.
+
+![Selecting a CLI runner from the execution mode dropdown](/img/CLI-Runners-Selection.png)
+
+## Configuration Reference
+
+| Field | Description |
+|-------|-------------|
+| **Type** | Preset type (Claude, Copilot, Codex, Gemini, Custom). Selecting a type auto-fills the other fields. |
+| **Executable path** | Absolute path to the CLI binary (e.g., `/opt/homebrew/bin/claude`) |
+| **Extra args** | Command-line arguments passed to the CLI. These are split on whitespace — no shell quoting needed. |
+| **Env vars** | Optional environment variables as `KEY=VALUE, KEY2=VALUE2`. Useful for API keys not inherited from the shell. |
+| **MCP config flag** | Read-only. The CLI flag used to pass the auto-generated Backlog MCP config file. Set automatically per tool type. |
+| **Enabled** | Toggle to enable/disable a tool without deleting its configuration |
+
+## Console Output
+
+When a CLI tool runs, its stdout and stderr stream into the **Run** tool window in IntelliJ. Each task execution shows:
+
+- A header with the task ID, title, and CLI tool name
+- The full output from the CLI tool
+- An exit summary with exit code and elapsed time
+
+## Adding a Custom CLI Tool
+
+If your CLI tool is not in the preset list:
+
+1. Select **Custom** as the Type
+2. Enter the executable path and arguments manually
+3. Set the **MCP config flag** if your tool supports an MCP config file (leave empty if not)
+4. The prompt is piped via stdin by default — ensure your tool reads from stdin in non-interactive mode
+
+## Troubleshooting
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| CLI tool fails immediately | Authentication error or wrong path | Check the executable path and env vars in **Settings → Spec Driven Dev → CLI Runners**, use **Test Connection** to verify |
+| CLI process doesn't exit | Some CLI tools (e.g., Codex) don't self-exit after completing | The runner detects task completion via the file watcher and terminates the process automatically |
+| No output in console | Process started but no stdout | Check that the executable path is correct and the tool is authenticated. Try running the command manually in a terminal |
+| MCP tools not available | CLI tool doesn't receive the Backlog MCP config | Verify the tool type is set correctly — MCP config is auto-generated per tool type. Codex does not support MCP |
diff --git a/docusaurus/docs/features/overview.md b/docusaurus/docs/features/overview.md
index 1e37a1ae..46bc5cde 100644
--- a/docusaurus/docs/features/overview.md
+++ b/docusaurus/docs/features/overview.md
@@ -12,7 +12,7 @@ DevoxxGenie offers a comprehensive set of features designed to enhance your deve
 
 ## Core Features
 
-### Spec Driven Development (SDD)
+### Spec-driven Development (SDD)
 
 Define tasks as structured markdown specs with acceptance criteria, and let the LLM agent implement them autonomously:
 
@@ -92,7 +92,7 @@ DevoxxGenie also includes experimental features that are being developed and ref
 
 For detailed information about specific features, check out the dedicated pages:
 
-- [Spec Driven Development](spec-driven-development.md)
+- [Spec-driven Development](spec-driven-development.md)
 - [Chat Interface](chat-interface.md)
 - [MCP Support](mcp_expanded.md)
 - [Agent Mode](agent-mode.md)
diff --git a/docusaurus/docs/features/sdd-agent-loop.md b/docusaurus/docs/features/sdd-agent-loop.md
index c5fed964..26de218e 100644
--- a/docusaurus/docs/features/sdd-agent-loop.md
+++ b/docusaurus/docs/features/sdd-agent-loop.md
@@ -2,7 +2,7 @@
 sidebar_position: 4
 title: Agent Loop — Batch Task Execution
 description: Run multiple SDD tasks sequentially with dependency ordering, progress tracking, and automatic task advancement. Each task gets a fresh conversation and the agent updates notes, summaries, and acceptance criteria as it works.
-keywords: [devoxxgenie, sdd, agent loop, batch execution, dependencies, task runner, spec driven development]
+keywords: [devoxxgenie, sdd, agent loop, batch execution, dependencies, task runner, spec-driven development, cli runners]
 image: /img/devoxxgenie-social-card.jpg
 ---
 
@@ -12,6 +12,8 @@ The Agent Loop lets you run multiple tasks sequentially in a single batch. Each
 
 This is useful when you have a set of related tasks (e.g., "implement the auth module") and want the agent to work through them without manual intervention.
 
+The Agent Loop works with both the **built-in LLM provider** and **external CLI tools** (Claude Code, Copilot, Codex, Gemini). See [CLI Runners](cli-runners.md) for setup instructions.
+
 <div style={{textAlign: 'center', margin: '2rem 0'}}>
 <video
   width="100%"
@@ -204,3 +206,5 @@ Each skip triggers a notification with the specific reason. The skip count is in
 | Task stuck in "In Progress" | Agent didn't mark the task as Done | Cancel the run, review the agent's output, and manually set the task status |
 | No tasks executed | All selected tasks are already Done or have unsatisfied deps | Check task statuses and dependency chains in the DevoxxGenie Specs |
 | Checkboxes cleared after run | Normal behavior | Checkboxes are automatically cleared when a batch run finishes |
+| CLI tool fails immediately | Authentication error or wrong path | Check the executable path and env vars in **Settings → Spec Driven Dev → CLI Runners**, use **Test Connection** to verify. See [CLI Runners](cli-runners.md). |
+| CLI process doesn't exit | Some CLI tools (e.g., Codex) don't self-exit after completing | The runner detects task completion via the file watcher and terminates the process automatically |
diff --git a/docusaurus/docs/features/spec-driven-development.md b/docusaurus/docs/features/spec-driven-development.md
index 9ff19d2e..25af96c5 100644
--- a/docusaurus/docs/features/spec-driven-development.md
+++ b/docusaurus/docs/features/spec-driven-development.md
@@ -1,28 +1,28 @@
 ---
 sidebar_position: 3
-title: Spec Driven Development
-description: Use Spec Driven Development (SDD) with Backlog.md to define tasks as structured markdown specs, then let the LLM agent implement them autonomously within your IDE.
-keywords: [devoxxgenie, spec driven development, sdd, backlog.md, task specs, agent mode, acceptance criteria, milestones]
+title: Spec-driven Development
+description: Use Spec-driven Development (SDD) with Backlog.md to define tasks as structured markdown specs, then let the LLM agent implement them autonomously within your IDE.
+keywords: [devoxxgenie, spec-driven development, sdd, backlog.md, task specs, agent mode, acceptance criteria, milestones]
 image: /img/devoxxgenie-social-card.jpg
 ---
 
-# Spec Driven Development (SDD)
+# Spec-driven Development (SDD)
 
-Spec Driven Development (SDD) is a workflow where you define **what** needs to be built as structured task specifications, and the LLM agent figures out **how** to build it. Instead of writing code instructions in chat, you write clear specs with acceptance criteria, and the agent implements them autonomously using its built-in tools.
+Spec-driven Development (SDD) is a workflow where you define **what** needs to be built as structured task specifications, and the LLM agent figures out **how** to build it. Instead of writing code instructions in chat, you write clear specs with acceptance criteria, and the agent implements them autonomously using its built-in tools.
 
 <div style={{textAlign: 'center', margin: '2rem 0'}}>
 <iframe
   width="100%"
   style={{aspectRatio: '16/9', maxWidth: '720px', borderRadius: '8px'}}
   src="https://www.youtube.com/embed/t1MOHCfsdvk"
-  title="Spec Driven Development Demo"
+  title="Spec-driven Development Demo"
   frameBorder="0"
   allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
   allowFullScreen
 />
 </div>
 
-## Why Spec Driven Development?
+## Why Spec-driven Development?
 
 Traditional AI-assisted coding relies on ad-hoc prompts: you describe what you want in natural language and hope the LLM understands. SDD takes a more disciplined approach:
 
@@ -452,6 +452,12 @@ npm i -g backlog.md
 
 For running multiple tasks sequentially with dependency ordering, progress tracking, and automatic task advancement, see [Agent Loop — Batch Task Execution](sdd-agent-loop.md).
 
+Both the built-in LLM provider and external [CLI Runners](cli-runners.md) support batch execution.
+
+## CLI Runners
+
+Instead of using the built-in LLM provider, you can execute spec tasks via **external CLI tools** — such as Claude Code, GitHub Copilot CLI, OpenAI Codex CLI, or Google Gemini CLI. See the dedicated [CLI Runners](cli-runners.md) page for setup instructions, supported tools, and configuration details.
+
 ## Tips and Best Practices
 
 - **Write clear acceptance criteria**: The more specific your criteria, the better the agent can implement and verify its work
diff --git a/docusaurus/docusaurus.config.js b/docusaurus/docusaurus.config.js
index 555e80e7..d72b77cb 100644
--- a/docusaurus/docusaurus.config.js
+++ b/docusaurus/docusaurus.config.js
@@ -175,7 +175,7 @@ const config = {
       // SEO and Social cards
       image: 'img/devoxxgenie-social-card.jpg',
       metadata: [
-        {name: 'keywords', content: 'java, intellij plugin, llm, code assistant, spec driven development, sdd, backlog.md, rag, ai coding, local llm, cloud llm, mcp, openai, anthropic, ollama'},
+        {name: 'keywords', content: 'java, intellij plugin, llm, code assistant, spec-driven development, sdd, backlog.md, rag, ai coding, local llm, cloud llm, mcp, openai, anthropic, ollama'},
         {name: 'description', content: 'DevoxxGenie is a free, open-source LLM Code Assistant plugin for IntelliJ IDEA. Supports local models (Ollama, LMStudio) and cloud providers (OpenAI, Anthropic, Google). Features include MCP, RAG, web search, and custom skills.'},
         {name: 'og:type', content: 'website'},
         {name: 'og:site_name', content: 'DevoxxGenie'},
diff --git a/docusaurus/sidebars.js b/docusaurus/sidebars.js
index c11d7ead..b98ac810 100644
--- a/docusaurus/sidebars.js
+++ b/docusaurus/sidebars.js
@@ -51,6 +51,7 @@ const sidebars = {
         'llm-providers/local-models',
         'llm-providers/cloud-models',
         'llm-providers/custom-providers',
+        'features/cli-runners',
       ],
     },
     {
diff --git a/docusaurus/src/components/HomepageFeatures/index.js b/docusaurus/src/components/HomepageFeatures/index.js
index 5a28ee3c..37496c4c 100644
--- a/docusaurus/src/components/HomepageFeatures/index.js
+++ b/docusaurus/src/components/HomepageFeatures/index.js
@@ -17,7 +17,7 @@ import DragDropIcon from './icons/DragDrop';
 
 const FeatureList = [
   {
-    title: 'Spec Driven Development',
+    title: 'Spec-driven Development',
     icon: SpecDrivenDevIcon,
     link: '/docs/features/spec-driven-development',
     description: (
diff --git a/docusaurus/src/pages/index.js b/docusaurus/src/pages/index.js
index d8e1a32c..d0a2b073 100644
--- a/docusaurus/src/pages/index.js
+++ b/docusaurus/src/pages/index.js
@@ -69,7 +69,7 @@ export default function Home() {
                 <iframe
                   className={styles.demoVideo}
                   src="https://www.youtube.com/embed/t1MOHCfsdvk"
-                  title="Spec Driven Development Demo"
+                  title="Spec-driven Development Demo"
                   frameBorder="0"
                   allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
                   allowFullScreen
@@ -94,7 +94,7 @@ export default function Home() {
         <div className="container home-section">
           <div className="row">
             <div className="col col--6">
-              <h2>Spec Driven Development</h2>
+              <h2>Spec-driven Development</h2>
               <p>
                 Define <strong>what</strong> needs to be built as structured task specs with acceptance criteria, and let the LLM agent figure out <strong>how</strong> to build it. Powered by <a href="https://backlog.md" target="_blank" rel="noopener noreferrer">Backlog.md</a> integration, SDD brings disciplined, traceable AI-assisted development to your IDE.
               </p>
diff --git a/docusaurus/static/api/welcome.json b/docusaurus/static/api/welcome.json
index 9a2fffc5..ae65910e 100644
--- a/docusaurus/static/api/welcome.json
+++ b/docusaurus/static/api/welcome.json
@@ -5,7 +5,7 @@
   "description": "The Devoxx Genie plugin allows you to interact with Local & Cloud Large Language Models (LLMs). The remote LLM's do require an API key in the Settings page",
   "instructions": "Start by selecting a language model provider. Select some code, or add some files, type your prompt, and click submit button. Discover and install MCP servers from the MCP Marketplace in Settings!",
   "features": [
-    { "emoji": "\uD83D\uDCCB", "name": "Spec Driven Development", "description": "Define tasks in Backlog.md, browse them in the Spec Browser with Task List and Kanban Board views, then let the Agent implement them autonomously. Enable in Settings > Spec Driven Development!" },
+    { "emoji": "\uD83D\uDCCB", "name": "Spec-driven Development", "description": "Define tasks in Backlog.md, browse them in the Spec Browser with Task List and Kanban Board views, then let the Agent implement them autonomously. Enable in Settings > Spec-driven Development!" },
     { "emoji": "\uD83E\uDD16", "name": "Agent Mode", "description": "Autonomous code exploration and modification with built-in tools (read, write, edit, search files). Parallel sub-agents investigate multiple areas concurrently. Configure in Agent Settings!" },
     { "emoji": "\uD83D\uDECD\uFE0F", "name": "MCP Marketplace", "description": "Discover and install MCP servers directly from Settings." },
     { "emoji": "\uD83D\uDCC2", "name": "@ Opens Files Popup", "description": "Type @ in your prompt to open the file selection dialog." },
diff --git a/docusaurus/static/img/CLI-Runners-Selection.png b/docusaurus/static/img/CLI-Runners-Selection.png
new file mode 100644
index 00000000..25964079
Binary files /dev/null and b/docusaurus/static/img/CLI-Runners-Selection.png differ
diff --git a/docusaurus/static/img/CLI-Runners-Setup.png b/docusaurus/static/img/CLI-Runners-Setup.png
new file mode 100644
index 00000000..0bac31c7
Binary files /dev/null and b/docusaurus/static/img/CLI-Runners-Setup.png differ
diff --git a/src/main/java/com/devoxx/genie/model/spec/CliToolConfig.java b/src/main/java/com/devoxx/genie/model/spec/CliToolConfig.java
new file mode 100644
index 00000000..c32ef529
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/model/spec/CliToolConfig.java
@@ -0,0 +1,94 @@
+package com.devoxx.genie.model.spec;
+
+import com.devoxx.genie.service.spec.command.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Configuration for a CLI tool that can execute spec tasks externally.
+ * CLI tools must have the Backlog MCP server installed so they can
+ * get/update/list backlog tasks just like the internal LLM flow.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CliToolConfig {
+
+    /**
+     * Known CLI tool types. Each type maps to a {@link CliCommand}
+     * implementation that encapsulates tool-specific execution behavior.
+     */
+    @Getter
+    public enum CliType {
+        COPILOT("Copilot"),
+        CLAUDE("Claude"),
+        CODEX("Codex"),
+        GEMINI("Gemini"),
+        CUSTOM("Custom");
+
+        private final String displayName;
+
+        CliType(String displayName) {
+            this.displayName = displayName;
+        }
+
+        /** Factory method — creates the Command (GoF) for this CLI type. */
+        public @NotNull CliCommand createCommand() {
+            return switch (this) {
+                case COPILOT -> new CopilotCliCommand();
+                case CLAUDE -> new ClaudeCliCommand();
+                case CODEX -> new CodexCliCommand();
+                case GEMINI -> new GeminiCliCommand();
+                case CUSTOM -> new CustomCliCommand();
+            };
+        }
+    }
+
+    @Builder.Default
+    private CliType type = CliType.CUSTOM;
+    @Builder.Default
+    private String name = "";
+    @Builder.Default
+    private String executablePath = "";
+    @Builder.Default
+    private List<String> extraArgs = new ArrayList<>();
+    @Builder.Default
+    private boolean enabled = true;
+    /**
+     * Optional environment variables passed to the CLI process.
+     * Useful for API keys, tokens, or tool-specific configuration
+     * (e.g., GITHUB_TOKEN, ANTHROPIC_API_KEY).
+     */
+    @Builder.Default
+    private Map<String, String> envVars = new LinkedHashMap<>();
+    /**
+     * CLI flag for passing the MCP config file path.
+     * When set, the executor auto-generates a Backlog MCP config file
+     * and appends [mcpConfigFlag, configPath] to the command.
+     */
+    @Builder.Default
+    private String mcpConfigFlag = "";
+
+    /**
+     * Build the base command list for ProcessBuilder.
+     * Format: [executablePath, ...extraArgs]
+     */
+    public List<String> buildCommand() {
+        List<String> cmd = new ArrayList<>();
+        cmd.add(executablePath);
+        if (extraArgs != null) {
+            cmd.addAll(extraArgs);
+        }
+        return cmd;
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/CliConsoleManager.java b/src/main/java/com/devoxx/genie/service/spec/CliConsoleManager.java
new file mode 100644
index 00000000..532d58d9
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/CliConsoleManager.java
@@ -0,0 +1,132 @@
+package com.devoxx.genie.service.spec;
+
+import com.intellij.execution.filters.TextConsoleBuilderFactory;
+import com.intellij.execution.ui.ConsoleView;
+import com.intellij.execution.ui.ConsoleViewContentType;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.components.Service;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.wm.ToolWindow;
+import com.intellij.openapi.wm.ToolWindowManager;
+import com.intellij.ui.content.Content;
+import com.intellij.ui.content.ContentFactory;
+import com.intellij.ui.content.ContentManager;
+import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Manages an IntelliJ Run tool window console for CLI task runner output.
+ * Creates/reuses a ConsoleView in the Run tool window so users can watch
+ * CLI progress in real-time.
+ */
+@Slf4j
+@Service(Service.Level.PROJECT)
+public final class CliConsoleManager implements Disposable {
+
+    private static final String CONTENT_DISPLAY_NAME = "Spec CLI Runner";
+    private static final String TOOL_WINDOW_ID = "Run";
+
+    private final Project project;
+    private ConsoleView consoleView;
+
+    public CliConsoleManager(@NotNull Project project) {
+        this.project = project;
+    }
+
+    public static CliConsoleManager getInstance(@NotNull Project project) {
+        return project.getService(CliConsoleManager.class);
+    }
+
+    /**
+     * Get or create the console view, ensuring it is attached to the Run tool window.
+     */
+    public @NotNull ConsoleView getOrCreateConsole() {
+        if (consoleView == null) {
+            consoleView = TextConsoleBuilderFactory.getInstance()
+                    .createBuilder(project)
+                    .getConsole();
+            attachToRunToolWindow();
+        }
+        return consoleView;
+    }
+
+    /**
+     * Print a task header line to the console.
+     */
+    public void printTaskHeader(@NotNull String taskId, @NotNull String title, @NotNull String toolName) {
+        ConsoleView console = getOrCreateConsole();
+        console.print(
+                "\n=== Running " + taskId + ": " + title + " via " + toolName + " ===\n\n",
+                ConsoleViewContentType.SYSTEM_OUTPUT
+        );
+    }
+
+    /**
+     * Print a line of process output.
+     */
+    public void printOutput(@NotNull String line) {
+        ConsoleView console = getOrCreateConsole();
+        console.print(line + "\n", ConsoleViewContentType.NORMAL_OUTPUT);
+    }
+
+    /**
+     * Print an error line.
+     */
+    public void printError(@NotNull String line) {
+        ConsoleView console = getOrCreateConsole();
+        console.print(line + "\n", ConsoleViewContentType.ERROR_OUTPUT);
+    }
+
+    /**
+     * Print a system message (e.g., process exit info).
+     */
+    public void printSystem(@NotNull String message) {
+        ConsoleView console = getOrCreateConsole();
+        console.print(message + "\n", ConsoleViewContentType.SYSTEM_OUTPUT);
+    }
+
+    /**
+     * Activate the Run tool window so the console is visible.
+     */
+    public void activateToolWindow() {
+        ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(TOOL_WINDOW_ID);
+        if (toolWindow != null) {
+            toolWindow.show();
+            // Select our content tab
+            ContentManager cm = toolWindow.getContentManager();
+            Content content = cm.findContent(CONTENT_DISPLAY_NAME);
+            if (content != null) {
+                cm.setSelectedContent(content);
+            }
+        }
+    }
+
+    private void attachToRunToolWindow() {
+        ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(TOOL_WINDOW_ID);
+        if (toolWindow == null) {
+            log.warn("Run tool window not found, console output will not be visible");
+            return;
+        }
+
+        ContentManager cm = toolWindow.getContentManager();
+
+        // Remove existing content with same name to avoid duplicates
+        Content existing = cm.findContent(CONTENT_DISPLAY_NAME);
+        if (existing != null) {
+            cm.removeContent(existing, true);
+        }
+
+        Content content = ContentFactory.getInstance().createContent(
+                consoleView.getComponent(), CONTENT_DISPLAY_NAME, false);
+        content.setDisposer(this);
+        cm.addContent(content);
+    }
+
+    @Override
+    public void dispose() {
+        if (consoleView != null) {
+            consoleView.dispose();
+            consoleView = null;
+        }
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/CliTaskExecutorService.java b/src/main/java/com/devoxx/genie/service/spec/CliTaskExecutorService.java
new file mode 100644
index 00000000..1ef5dae5
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/CliTaskExecutorService.java
@@ -0,0 +1,281 @@
+package com.devoxx.genie.service.spec;
+
+import com.devoxx.genie.model.spec.CliToolConfig;
+import com.devoxx.genie.service.spec.command.CliCommand;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.components.Service;
+import com.intellij.openapi.project.Project;
+import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Project-scoped service that runs a CLI tool as an external process.
+ * Delegates command construction and prompt delivery to the tool's
+ * {@link CliCommand} implementation (Command pattern).
+ */
+@Slf4j
+@Service(Service.Level.PROJECT)
+public final class CliTaskExecutorService implements Disposable {
+
+    private final Project project;
+    private volatile Process activeProcess;
+    private volatile CliCommand activeCommand;
+    /** Set when the process is killed intentionally because the task was marked Done. */
+    private volatile boolean taskCompletedKill = false;
+
+    public CliTaskExecutorService(@NotNull Project project) {
+        this.project = project;
+    }
+
+    public static CliTaskExecutorService getInstance(@NotNull Project project) {
+        return project.getService(CliTaskExecutorService.class);
+    }
+
+    /**
+     * Execute a CLI tool with the given prompt.
+     * Runs the process on a pooled thread, streams output to console,
+     * and calls notifyPromptExecutionCompleted() on process exit.
+     */
+    public void execute(@NotNull CliToolConfig cliTool,
+                        @NotNull String prompt,
+                        @NotNull String taskId,
+                        @NotNull String taskTitle) {
+        CliConsoleManager consoleManager = CliConsoleManager.getInstance(project);
+        consoleManager.printTaskHeader(taskId, taskTitle, cliTool.getName());
+        consoleManager.activateToolWindow();
+
+        // Resolve the Command for this CLI type
+        CliToolConfig.CliType cliType = cliTool.getType() != null ? cliTool.getType() : CliToolConfig.CliType.CUSTOM;
+        CliCommand cliCommand = cliType.createCommand();
+        activeCommand = cliCommand;
+
+        // Generate MCP config and let the command build the full process command
+        String mcpConfigPath = generateMcpConfig(cliCommand.mcpJsonKey());
+        List<String> command = cliCommand.buildProcessCommand(cliTool, prompt, mcpConfigPath);
+
+        log.info("CLI execute: task={}, tool={}, type={}, command={}, promptLength={}",
+                taskId, cliTool.getName(), cliType, command, prompt.length());
+
+        String basePath = project.getBasePath();
+        log.info("CLI working directory: {}", basePath);
+
+        ApplicationManager.getApplication().executeOnPooledThread(() -> {
+            log.info("CLI pooled thread started for task {}", taskId);
+            long startTime = System.currentTimeMillis();
+
+            try {
+                ProcessBuilder pb = new ProcessBuilder(command);
+                pb.redirectErrorStream(false);
+
+                if (basePath != null) {
+                    pb.directory(new java.io.File(basePath));
+                }
+
+                // Inherit the user's shell environment (PATH, tokens, etc.)
+                // IntelliJ launched from Dock doesn't inherit ~/.zshrc env vars
+                pb.environment().putAll(com.intellij.util.EnvironmentUtil.getEnvironmentMap());
+
+                // Overlay with tool-specific env var overrides
+                if (cliTool.getEnvVars() != null && !cliTool.getEnvVars().isEmpty()) {
+                    pb.environment().putAll(cliTool.getEnvVars());
+                    log.info("CLI env vars overrides: {}", cliTool.getEnvVars().keySet());
+                }
+
+                log.info("CLI starting process...");
+                activeProcess = pb.start();
+                log.info("CLI process started successfully (pid={})", activeProcess.pid());
+
+                // Delegate prompt delivery to the command
+                cliCommand.writePrompt(activeProcess, prompt);
+                log.info("CLI prompt delivered via {} ({} chars)",
+                        cliCommand.getClass().getSimpleName(), prompt.length());
+
+                // Collect stderr lines for error reporting
+                List<String> stderrLines = Collections.synchronizedList(new ArrayList<>());
+
+                // Stream stdout and stderr concurrently
+                Thread stdoutThread = createStreamReader(
+                        activeProcess, true, consoleManager, taskId, null);
+                Thread stderrThread = createStreamReader(
+                        activeProcess, false, consoleManager, taskId, stderrLines);
+
+                stdoutThread.start();
+                stderrThread.start();
+
+                log.info("CLI waiting for process to finish (task={})", taskId);
+                int exitCode = activeProcess.waitFor();
+                long elapsed = System.currentTimeMillis() - startTime;
+                stdoutThread.join(5000);
+                stderrThread.join(5000);
+
+                activeProcess = null;
+                activeCommand = null;
+
+                boolean completedKill = taskCompletedKill;
+                taskCompletedKill = false;
+
+                log.info("CLI process exited: task={}, exitCode={}, completedKill={}, elapsed={}ms",
+                        taskId, exitCode, completedKill, elapsed);
+
+                String exitMsg = "\n=== Process exited with code " + exitCode + " (after " + elapsed + "ms) ===\n";
+                ApplicationManager.getApplication().invokeLater(() -> {
+                    if (exitCode == 0 || completedKill) {
+                        consoleManager.printSystem(exitMsg);
+                        log.info("CLI notifying prompt execution completed for task {}", taskId);
+                        SpecTaskRunnerService.getInstance(project).notifyPromptExecutionCompleted();
+                    } else {
+                        consoleManager.printError(exitMsg);
+                        String errorOutput = String.join("\n", stderrLines).trim();
+                        log.warn("CLI task {} failed with exit code {}: {}", taskId, exitCode,
+                                errorOutput.length() > 300 ? errorOutput.substring(0, 300) + "..." : errorOutput);
+                        SpecTaskRunnerService.getInstance(project)
+                                .notifyCliTaskFailed(exitCode, errorOutput);
+                    }
+                });
+
+            } catch (IOException e) {
+                long elapsed = System.currentTimeMillis() - startTime;
+                activeProcess = null;
+                activeCommand = null;
+                log.error("CLI failed to start process: task={}, elapsed={}ms, error={}",
+                        taskId, elapsed, e.getMessage(), e);
+                ApplicationManager.getApplication().invokeLater(() -> {
+                    consoleManager.printError("Failed to start process: " + e.getMessage());
+                    SpecTaskRunnerService.getInstance(project)
+                            .notifyCliTaskFailed(-1, e.getMessage());
+                });
+            } catch (InterruptedException e) {
+                long elapsed = System.currentTimeMillis() - startTime;
+                activeProcess = null;
+                activeCommand = null;
+                Thread.currentThread().interrupt();
+                log.info("CLI process interrupted: task={}, elapsed={}ms", taskId, elapsed);
+                ApplicationManager.getApplication().invokeLater(() -> {
+                    consoleManager.printSystem("Process interrupted");
+                    SpecTaskRunnerService.getInstance(project).notifyPromptExecutionCompleted();
+                });
+            }
+        });
+
+        log.info("CLI execute() returned (process running async) for task {}", taskId);
+    }
+
+    /**
+     * Cancel the currently running process (user-initiated).
+     */
+    public void cancelCurrentProcess() {
+        Process process = activeProcess;
+        if (process != null && process.isAlive()) {
+            log.info("Destroying CLI process (pid={})", process.pid());
+            process.destroyForcibly();
+            activeProcess = null;
+            ApplicationManager.getApplication().invokeLater(() ->
+                    CliConsoleManager.getInstance(project).printSystem("\n=== Process cancelled ===\n"));
+        }
+    }
+
+    /**
+     * Called when the backlog task is marked Done while the process is still running.
+     * Delegates to the active {@link CliCommand#onTaskCompleted(Process)} —
+     * only commands that don't self-exit (e.g., Codex) will kill the process.
+     */
+    public void notifyTaskDone() {
+        CliCommand command = activeCommand;
+        Process process = activeProcess;
+        if (command != null && process != null && process.isAlive()) {
+            if (command.onTaskCompleted(process)) {
+                taskCompletedKill = true;
+                log.info("CLI process killed by {} — task completed", command.getClass().getSimpleName());
+            }
+        }
+    }
+
+    public boolean isRunning() {
+        Process process = activeProcess;
+        return process != null && process.isAlive();
+    }
+
+    /**
+     * Generate a temporary MCP config JSON file for the Backlog MCP server.
+     * The file is written to the system temp directory and deleted on JVM exit.
+     */
+    private @Nullable String generateMcpConfig(@NotNull String mcpJsonKey) {
+        try {
+            java.io.File tempFile = java.io.File.createTempFile("backlog-mcp-", ".json");
+            tempFile.deleteOnExit();
+
+            String config = "{\n" +
+                    "  \"" + mcpJsonKey + "\": {\n" +
+                    "    \"backlog\": {\n" +
+                    "      \"command\": \"backlog\",\n" +
+                    "      \"args\": [\"mcp\", \"start\"]\n" +
+                    "    }\n" +
+                    "  }\n" +
+                    "}";
+
+            java.nio.file.Files.writeString(tempFile.toPath(), config, StandardCharsets.UTF_8);
+            log.info("CLI generated MCP config (key={}) at {}", mcpJsonKey, tempFile.getAbsolutePath());
+            return tempFile.getAbsolutePath();
+        } catch (IOException e) {
+            log.error("Failed to generate MCP config: {}", e.getMessage(), e);
+            return null;
+        }
+    }
+
+    private @NotNull Thread createStreamReader(@NotNull Process process,
+                                               boolean isStdout,
+                                               @NotNull CliConsoleManager consoleManager,
+                                               @NotNull String taskId,
+                                               @Nullable List<String> lineCollector) {
+        String streamName = isStdout ? "stdout" : "stderr";
+        Thread thread = new Thread(() -> {
+            log.debug("CLI {}-reader started for task {}", streamName, taskId);
+            int lineCount = 0;
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(
+                    isStdout ? process.getInputStream() : process.getErrorStream(),
+                    StandardCharsets.UTF_8))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    lineCount++;
+                    final String text = line;
+                    if (lineCollector != null) {
+                        lineCollector.add(text);
+                    }
+                    // Log first 5 lines and every 50th line to IDE log for debugging
+                    if (lineCount <= 5 || lineCount % 50 == 0) {
+                        log.info("CLI {} [{}] line {}: {}", streamName, taskId, lineCount,
+                                text.length() > 200 ? text.substring(0, 200) + "..." : text);
+                    }
+                    ApplicationManager.getApplication().invokeLater(() -> {
+                        if (isStdout) {
+                            consoleManager.printOutput(text);
+                        } else {
+                            consoleManager.printError(text);
+                        }
+                    });
+                }
+            } catch (IOException e) {
+                log.debug("CLI {}-reader ended for task {} ({}): {}", streamName, taskId,
+                        lineCount > 0 ? lineCount + " lines read" : "no output", e.getMessage());
+            }
+            log.info("CLI {}-reader finished for task {}: {} lines total", streamName, taskId, lineCount);
+        }, "cli-" + streamName + "-reader-" + taskId);
+        thread.setDaemon(true);
+        return thread;
+    }
+
+    @Override
+    public void dispose() {
+        cancelCurrentProcess();
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/SpecContextBuilder.java b/src/main/java/com/devoxx/genie/service/spec/SpecContextBuilder.java
index 50a30994..be547e9c 100644
--- a/src/main/java/com/devoxx/genie/service/spec/SpecContextBuilder.java
+++ b/src/main/java/com/devoxx/genie/service/spec/SpecContextBuilder.java
@@ -112,6 +112,31 @@ private SpecContextBuilder() {
         return sb.toString();
     }
 
+    /**
+     * Build instruction prefix for CLI tools that have the Backlog MCP server installed.
+     * Same backlog task management workflow as the LLM agent path.
+     */
+    public static @NotNull String buildCliInstruction(@NotNull TaskSpec spec) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("You are implementing task ");
+        if (spec.getId() != null) {
+            sb.append(spec.getId());
+        }
+        if (spec.getTitle() != null) {
+            sb.append(": ").append(spec.getTitle());
+        }
+        sb.append(".\n\n");
+        sb.append("Follow the acceptance criteria exactly.\n\n");
+        sb.append("IMPORTANT: Use the Backlog MCP tools to keep the task updated as you work:\n");
+        sb.append("1. FIRST, use backlog task_edit to set status to 'In Progress' when you start.\n");
+        sb.append("2. Use backlog task_edit with acceptanceCriteriaCheck to check off each criterion as you complete it.\n");
+        sb.append("3. Use backlog task_edit with notesAppend to record what you changed, which files were modified, and why.\n");
+        sb.append("4. When finished, use backlog task_edit to write a detailed finalSummary of everything that was implemented.\n");
+        sb.append("5. LAST, use backlog task_edit to set status to 'Done'.\n");
+        sb.append("\nYou MUST complete steps 3 and 4 before step 5. The notes and final summary are essential for traceability.\n");
+        return sb.toString();
+    }
+
     /**
      * Build an agent instruction prefix for working on a specific task.
      */
diff --git a/src/main/java/com/devoxx/genie/service/spec/SpecTaskRunnerService.java b/src/main/java/com/devoxx/genie/service/spec/SpecTaskRunnerService.java
index b4646627..4a9602c5 100644
--- a/src/main/java/com/devoxx/genie/service/spec/SpecTaskRunnerService.java
+++ b/src/main/java/com/devoxx/genie/service/spec/SpecTaskRunnerService.java
@@ -1,8 +1,10 @@
 package com.devoxx.genie.service.spec;
 
+import com.devoxx.genie.model.spec.CliToolConfig;
 import com.devoxx.genie.model.spec.TaskSpec;
 import com.devoxx.genie.service.FileListManager;
 import com.devoxx.genie.service.prompt.memory.ChatMemoryService;
+import com.devoxx.genie.ui.settings.DevoxxGenieStateService;
 import com.devoxx.genie.ui.topic.AppTopics;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
@@ -60,6 +62,10 @@ public enum RunnerState {
     private final Set<String> completedTaskIds = new HashSet<>();
     private Set<String> selectedTaskIds = Collections.emptySet();
 
+    // CLI execution mode flag, determined at start of runTasks()
+    @Getter
+    private boolean cliMode = false;
+
     public SpecTaskRunnerService(@NotNull Project project) {
         this.project = project;
     }
@@ -105,6 +111,10 @@ public void runTasks(@NotNull List<TaskSpec> tasks) {
                         .map(t -> t.getId() != null ? t.getId() : "?")
                         .collect(Collectors.joining(" → ")));
 
+        // Determine execution mode at the start of the run
+        DevoxxGenieStateService stateService = DevoxxGenieStateService.getInstance();
+        cliMode = "cli".equalsIgnoreCase(stateService.getSpecRunnerMode());
+
         currentTaskIndex = -1;
         completedCount = 0;
         skippedCount = 0;
@@ -140,10 +150,47 @@ public void cancel() {
             return;
         }
         log.info("Cancelling task runner");
+        if (cliMode) {
+            CliTaskExecutorService.getInstance(project).cancelCurrentProcess();
+        }
         state = RunnerState.CANCELLED;
         finish(RunnerState.CANCELLED);
     }
 
+    /**
+     * Called when a CLI tool exits with a non-zero exit code.
+     * Immediately fails the current task with the error details and stops
+     * the entire run — subsequent tasks would likely fail the same way
+     * (e.g., authentication errors).
+     */
+    public void notifyCliTaskFailed(int exitCode, @NotNull String errorOutput) {
+        if (state != RunnerState.WAITING_FOR_COMPLETION) {
+            return;
+        }
+
+        TaskSpec current = getCurrentTask();
+        if (current == null) {
+            return;
+        }
+
+        cancelGraceTimer();
+
+        // Extract first meaningful line of stderr for the skip reason
+        String firstLine = errorOutput.lines()
+                .filter(l -> !l.isBlank())
+                .findFirst()
+                .orElse("Unknown error");
+        String reason = "CLI tool failed (exit code " + exitCode + "): " + firstLine;
+
+        log.error("CLI task {} failed: {}", current.getId(), reason);
+        skippedCount++;
+        notifyTaskSkipped(current, reason);
+
+        // Stop the run — remaining tasks will likely fail the same way
+        log.info("Stopping task runner due to CLI failure");
+        finish(RunnerState.ERROR);
+    }
+
     /**
      * Called when prompt execution completes (success or failure).
      * <p>
@@ -281,25 +328,75 @@ private void submitNextTask() {
             return;
         }
 
-        // Start a fresh conversation for each task
-        startFreshConversation();
-
-        // Submit the task prompt
         state = RunnerState.WAITING_FOR_COMPLETION;
         notifyTaskStarted(fresh);
 
-        String taskDetails = SpecContextBuilder.buildContext(fresh);
-        String instruction = SpecContextBuilder.buildAgentInstruction(fresh);
+        if (cliMode) {
+            submitTaskViaCli(fresh);
+        } else {
+            submitTaskViaLlm(fresh);
+        }
+    }
+
+    private void submitTaskViaLlm(@NotNull TaskSpec task) {
+        // Start a fresh conversation for each task
+        startFreshConversation();
+
+        String taskDetails = SpecContextBuilder.buildContext(task);
+        String instruction = SpecContextBuilder.buildAgentInstruction(task);
         String prompt = instruction + "\n\n" + taskDetails +
                 "\n\nPlease implement the task described above, satisfying all acceptance criteria.";
 
         project.getMessageBus()
                 .syncPublisher(AppTopics.PROMPT_SUBMISSION_TOPIC)
                 .onPromptSubmitted(project, prompt);
+    }
 
-        // No timeout timer — tasks can take varying amounts of time,
-        // especially during batch runs of 50+ tasks. The agent will
-        // set the task to Done when finished, which triggers advancement.
+    private void submitTaskViaCli(@NotNull TaskSpec task) {
+        DevoxxGenieStateService stateService = DevoxxGenieStateService.getInstance();
+        String toolName = stateService.getSpecSelectedCliTool();
+        log.info("CLI mode: specRunnerMode={}, specSelectedCliTool='{}'",
+                stateService.getSpecRunnerMode(), toolName);
+
+        CliToolConfig cliTool = findCliTool(toolName);
+        if (cliTool == null) {
+            log.error("CLI tool '{}' not found or not enabled. Available tools: {}", toolName,
+                    stateService.getCliTools());
+            skipTask(task, "CLI tool '" + toolName + "' not found or not enabled");
+            return;
+        }
+
+        log.info("CLI tool resolved: name={}, type={}, path={}, extraArgs={}, enabled={}",
+                cliTool.getName(), cliTool.getType(),
+                cliTool.getExecutablePath(), cliTool.getExtraArgs(), cliTool.isEnabled());
+
+        // Build prompt: CLI instruction (workflow steps) + task ID reference.
+        // The CLI tool has Backlog MCP, so it fetches full task details itself.
+        String taskId = task.getId() != null ? task.getId() : "?";
+        String instruction = SpecContextBuilder.buildCliInstruction(task);
+        String prompt = instruction +
+                "\n\nStart by using backlog task_view with id '" + taskId +
+                "' to read the full task details and acceptance criteria." +
+                "\n\nPlease implement the task, satisfying all acceptance criteria.";
+
+        log.info("CLI prompt for task {}: {} chars", taskId, prompt.length());
+
+        CliTaskExecutorService.getInstance(project).execute(
+                cliTool, prompt,
+                task.getId() != null ? task.getId() : "?",
+                task.getTitle() != null ? task.getTitle() : "Untitled"
+        );
+    }
+
+    private @Nullable CliToolConfig findCliTool(@Nullable String name) {
+        if (name == null || name.isEmpty()) return null;
+        DevoxxGenieStateService stateService = DevoxxGenieStateService.getInstance();
+        List<CliToolConfig> tools = stateService.getCliTools();
+        if (tools == null) return null;
+        return tools.stream()
+                .filter(t -> t.isEnabled() && name.equalsIgnoreCase(t.getName()))
+                .findFirst()
+                .orElse(null);
     }
 
     private void onSpecsChanged() {
@@ -334,6 +431,12 @@ private void onSpecsChanged() {
                 log.info("Task {} detected as Done (deferring advance until prompt completes)", fresh.getId());
                 cancelGraceTimer();
                 currentTaskDoneWhileExecuting = true;
+
+                // In CLI mode, notify the executor — the command decides
+                // whether to kill the process (e.g., Codex doesn't self-exit).
+                if (cliMode) {
+                    CliTaskExecutorService.getInstance(project).notifyTaskDone();
+                }
             }
         });
     }
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/AbstractCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/AbstractCliCommand.java
new file mode 100644
index 00000000..a2d0b0e3
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/AbstractCliCommand.java
@@ -0,0 +1,55 @@
+package com.devoxx.genie.service.spec.command;
+
+import com.devoxx.genie.model.spec.CliToolConfig;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Base implementation with shared behavior for most CLI tools:
+ * builds the command from config, appends MCP config flag,
+ * and pipes the prompt via stdin.
+ */
+public abstract class AbstractCliCommand implements CliCommand {
+
+    @Override
+    public @NotNull List<String> buildProcessCommand(@NotNull CliToolConfig config,
+                                                      @NotNull String prompt,
+                                                      @Nullable String mcpConfigPath) {
+        List<String> command = new ArrayList<>(config.buildCommand());
+        appendMcpConfig(command, config, mcpConfigPath);
+        return command;
+    }
+
+    protected void appendMcpConfig(@NotNull List<String> command,
+                                    @NotNull CliToolConfig config,
+                                    @Nullable String mcpConfigPath) {
+        String flag = config.getMcpConfigFlag();
+        if (flag != null && !flag.isEmpty() && mcpConfigPath != null) {
+            command.add(flag);
+            command.add(formatMcpConfigPath(mcpConfigPath));
+        }
+    }
+
+    protected @NotNull String formatMcpConfigPath(@NotNull String path) {
+        return path;
+    }
+
+    @Override
+    public void writePrompt(@NotNull Process process, @NotNull String prompt) throws IOException {
+        try (var writer = new OutputStreamWriter(process.getOutputStream(), StandardCharsets.UTF_8)) {
+            writer.write(prompt);
+            writer.flush();
+        }
+    }
+
+    @Override
+    public @NotNull String mcpJsonKey() {
+        return "mcpServers";
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/ClaudeCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/ClaudeCliCommand.java
new file mode 100644
index 00000000..bf20a11c
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/ClaudeCliCommand.java
@@ -0,0 +1,25 @@
+package com.devoxx.genie.service.spec.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Claude Code CLI: prompt piped via stdin with -p flag.
+ * Example: echo "prompt" | claude -p --dangerously-skip-permissions --model opus --allowedTools Backlog.md --mcp-config config.json
+ */
+public class ClaudeCliCommand extends AbstractCliCommand {
+
+    @Override
+    public @NotNull String defaultExecutablePath() {
+        return "/opt/homebrew/bin/claude";
+    }
+
+    @Override
+    public @NotNull String defaultExtraArgs() {
+        return "-p --dangerously-skip-permissions --model opus --allowedTools Backlog.md";
+    }
+
+    @Override
+    public @NotNull String defaultMcpConfigFlag() {
+        return "--mcp-config";
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/CliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/CliCommand.java
new file mode 100644
index 00000000..c3f0717b
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/CliCommand.java
@@ -0,0 +1,55 @@
+package com.devoxx.genie.service.spec.command;
+
+import com.devoxx.genie.model.spec.CliToolConfig;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Command pattern (GoF) interface for CLI tool execution.
+ * Each CLI tool type (Claude, Copilot, Codex, Gemini) has its own
+ * implementation that encapsulates tool-specific behavior:
+ * command construction, prompt delivery, and MCP config format.
+ */
+public interface CliCommand {
+
+    /**
+     * Build the full command list for ProcessBuilder,
+     * including MCP config flag and prompt (if passed as a trailing argument).
+     */
+    @NotNull List<String> buildProcessCommand(@NotNull CliToolConfig config,
+                                               @NotNull String prompt,
+                                               @Nullable String mcpConfigPath);
+
+    /**
+     * Deliver the prompt to the running process.
+     * Implementations either pipe it via stdin or close stdin
+     * (when the prompt was already appended as a command-line argument).
+     */
+    void writePrompt(@NotNull Process process, @NotNull String prompt) throws IOException;
+
+    /** MCP config JSON top-level key (e.g., "mcpServers" or "servers"). */
+    @NotNull String mcpJsonKey();
+
+    /** Default executable path for auto-population in settings dialog. */
+    @NotNull String defaultExecutablePath();
+
+    /** Default extra arguments for auto-population in settings dialog. */
+    @NotNull String defaultExtraArgs();
+
+    /** Default MCP config CLI flag (e.g., "--mcp-config"). */
+    @NotNull String defaultMcpConfigFlag();
+
+    /**
+     * Called when the backlog task is marked Done while the process is still running.
+     * Most CLI tools (Claude, Copilot) exit on their own — default is no-op.
+     * Override to forcibly kill the process for tools that don't self-exit (e.g., Codex).
+     *
+     * @return true if the process was killed, false if no action was taken
+     */
+    default boolean onTaskCompleted(@NotNull Process process) {
+        return false;
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/CodexCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/CodexCliCommand.java
new file mode 100644
index 00000000..2454e78c
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/CodexCliCommand.java
@@ -0,0 +1,58 @@
+package com.devoxx.genie.service.spec.command;
+
+import com.devoxx.genie.model.spec.CliToolConfig;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * OpenAI Codex CLI: prompt passed as a trailing positional argument (not stdin).
+ * Example: codex exec --model gpt-5.3-codex --full-auto --mcp-config config.json "prompt"
+ */
+public class CodexCliCommand extends AbstractCliCommand {
+
+    @Override
+    public @NotNull List<String> buildProcessCommand(@NotNull CliToolConfig config,
+                                                      @NotNull String prompt,
+                                                      @Nullable String mcpConfigPath) {
+        List<String> command = new ArrayList<>(config.buildCommand());
+        appendMcpConfig(command, config, mcpConfigPath);
+        // Codex takes the prompt as a trailing positional argument
+        command.add(prompt);
+        return command;
+    }
+
+    @Override
+    public void writePrompt(@NotNull Process process, @NotNull String prompt) throws IOException {
+        // Prompt already passed as command-line argument — close stdin
+        process.getOutputStream().close();
+    }
+
+    @Override
+    public @NotNull String defaultExecutablePath() {
+        return "/opt/homebrew/bin/codex";
+    }
+
+    @Override
+    public @NotNull String defaultExtraArgs() {
+        return "exec --model gpt-5.3-codex --full-auto";
+    }
+
+    @Override
+    public @NotNull String defaultMcpConfigFlag() {
+        return "";
+    }
+
+    @Override
+    public boolean onTaskCompleted(@NotNull Process process) {
+        // Codex doesn't exit on its own after completing — kill it
+        if (process.isAlive()) {
+            process.destroyForcibly();
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/CopilotCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/CopilotCliCommand.java
new file mode 100644
index 00000000..40f164f0
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/CopilotCliCommand.java
@@ -0,0 +1,30 @@
+package com.devoxx.genie.service.spec.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * GitHub Copilot CLI: prompt piped via stdin, MCP config path prefixed with @.
+ * Example: echo "prompt" | copilot --allow-all --additional-mcp-config @config.json
+ */
+public class CopilotCliCommand extends AbstractCliCommand {
+
+    @Override
+    protected @NotNull String formatMcpConfigPath(@NotNull String path) {
+        return "@" + path;
+    }
+
+    @Override
+    public @NotNull String defaultExecutablePath() {
+        return "/opt/homebrew/bin/copilot";
+    }
+
+    @Override
+    public @NotNull String defaultExtraArgs() {
+        return "--allow-all";
+    }
+
+    @Override
+    public @NotNull String defaultMcpConfigFlag() {
+        return "--additional-mcp-config";
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/CustomCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/CustomCliCommand.java
new file mode 100644
index 00000000..fee662a1
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/CustomCliCommand.java
@@ -0,0 +1,25 @@
+package com.devoxx.genie.service.spec.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Custom CLI tool with user-defined configuration.
+ * Defaults to stdin prompt delivery and mcpServers JSON key.
+ */
+public class CustomCliCommand extends AbstractCliCommand {
+
+    @Override
+    public @NotNull String defaultExecutablePath() {
+        return "";
+    }
+
+    @Override
+    public @NotNull String defaultExtraArgs() {
+        return "";
+    }
+
+    @Override
+    public @NotNull String defaultMcpConfigFlag() {
+        return "";
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/service/spec/command/GeminiCliCommand.java b/src/main/java/com/devoxx/genie/service/spec/command/GeminiCliCommand.java
new file mode 100644
index 00000000..a7fe71e6
--- /dev/null
+++ b/src/main/java/com/devoxx/genie/service/spec/command/GeminiCliCommand.java
@@ -0,0 +1,25 @@
+package com.devoxx.genie.service.spec.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Google Gemini CLI: prompt piped via stdin.
+ * Example: echo "prompt" | gemini --mcp-config config.json
+ */
+public class GeminiCliCommand extends AbstractCliCommand {
+
+    @Override
+    public @NotNull String defaultExecutablePath() {
+        return "/opt/homebrew/bin/gemini";
+    }
+
+    @Override
+    public @NotNull String defaultExtraArgs() {
+        return "";
+    }
+
+    @Override
+    public @NotNull String defaultMcpConfigFlag() {
+        return "--mcp-config";
+    }
+}
diff --git a/src/main/java/com/devoxx/genie/ui/panel/ActionButtonsPanel.java b/src/main/java/com/devoxx/genie/ui/panel/ActionButtonsPanel.java
index 1dfd733f..32a16800 100644
--- a/src/main/java/com/devoxx/genie/ui/panel/ActionButtonsPanel.java
+++ b/src/main/java/com/devoxx/genie/ui/panel/ActionButtonsPanel.java
@@ -237,8 +237,9 @@ public void enableButtons() {
 
             // Notify the spec task runner that prompt execution completed so it can
             // start a grace timer and advance if the task wasn't marked Done.
+            // Skip in CLI mode — the CLI process exit handles notification instead.
             SpecTaskRunnerService runner = SpecTaskRunnerService.getInstance(project);
-            if (runner.isRunning()) {
+            if (runner.isRunning() && !runner.isCliMode()) {
                 runner.notifyPromptExecutionCompleted();
             }
         });
diff --git a/src/main/java/com/devoxx/genie/ui/panel/spec/SpecBrowserPanel.java b/src/main/java/com/devoxx/genie/ui/panel/spec/SpecBrowserPanel.java
index 0b2c0734..14b41e96 100644
--- a/src/main/java/com/devoxx/genie/ui/panel/spec/SpecBrowserPanel.java
+++ b/src/main/java/com/devoxx/genie/ui/panel/spec/SpecBrowserPanel.java
@@ -1,11 +1,13 @@
 package com.devoxx.genie.ui.panel.spec;
 
+import com.devoxx.genie.model.spec.CliToolConfig;
 import com.devoxx.genie.model.spec.TaskSpec;
 import com.devoxx.genie.service.spec.CircularDependencyException;
 import com.devoxx.genie.service.spec.SpecContextBuilder;
 import com.devoxx.genie.service.spec.SpecService;
 import com.devoxx.genie.service.spec.SpecTaskRunnerListener;
 import com.devoxx.genie.service.spec.SpecTaskRunnerService;
+import com.devoxx.genie.ui.settings.DevoxxGenieStateService;
 import com.devoxx.genie.ui.topic.AppTopics;
 import com.devoxx.genie.ui.util.NotificationUtil;
 import com.intellij.icons.AllIcons;
@@ -62,6 +64,11 @@ public class SpecBrowserPanel extends SimpleToolWindowPanel implements SpecTaskR
     private AnAction runAllTodoAction;
     private AnAction cancelRunAction;
 
+    // Execution mode ComboBox
+    private JComboBox<String> executionModeCombo;
+    private boolean refreshingCombo = false;
+    private static final String LLM_PROVIDER_LABEL = "LLM Provider";
+
     public SpecBrowserPanel(@NotNull Project project) {
         super(true, true);
         this.project = project;
@@ -137,6 +144,14 @@ public void componentResized(ComponentEvent e) {
         SpecTaskRunnerService runner = SpecTaskRunnerService.getInstance(project);
         runner.addListener(this);
 
+        // Refresh execution mode combo when settings change (e.g., CLI tools added/removed)
+        // SpecSettingsConfigurable publishes on the project message bus
+        project.getMessageBus()
+                .connect()
+                .subscribe(AppTopics.SETTINGS_CHANGED_TOPIC,
+                        (com.devoxx.genie.ui.listener.SettingsChangeListener) hasKey ->
+                                ApplicationManager.getApplication().invokeLater(this::refreshExecutionModeCombo));
+
         // Initial load
         refreshTree();
     }
@@ -213,7 +228,68 @@ public void update(@NotNull AnActionEvent e) {
 
         ActionToolbar toolbar = ActionManager.getInstance().createActionToolbar("SpecBrowser", actionGroup, true);
         toolbar.setTargetComponent(this);
-        setToolbar(toolbar.getComponent());
+
+        // Build a composite toolbar with the execution mode ComboBox + action buttons
+        executionModeCombo = new JComboBox<>();
+        executionModeCombo.setToolTipText("Select execution mode: LLM Provider or external CLI tool");
+        refreshExecutionModeCombo();
+        executionModeCombo.addActionListener(e -> onExecutionModeChanged());
+
+        JPanel toolbarPanel = new JPanel(new BorderLayout());
+        toolbarPanel.add(executionModeCombo, BorderLayout.WEST);
+        toolbarPanel.add(toolbar.getComponent(), BorderLayout.CENTER);
+        setToolbar(toolbarPanel);
+    }
+
+    private void refreshExecutionModeCombo() {
+        if (executionModeCombo == null) return;
+
+        // Suppress listener during programmatic updates
+        refreshingCombo = true;
+        try {
+            executionModeCombo.removeAllItems();
+            executionModeCombo.addItem(LLM_PROVIDER_LABEL);
+
+            DevoxxGenieStateService stateService = DevoxxGenieStateService.getInstance();
+            List<CliToolConfig> tools = stateService.getCliTools();
+            if (tools != null) {
+                for (CliToolConfig tool : tools) {
+                    if (tool.isEnabled()) {
+                        executionModeCombo.addItem("CLI: " + tool.getName());
+                    }
+                }
+            }
+
+            // Restore selection
+            String mode = stateService.getSpecRunnerMode();
+            if ("cli".equalsIgnoreCase(mode)) {
+                String selectedTool = stateService.getSpecSelectedCliTool();
+                String label = "CLI: " + selectedTool;
+                for (int i = 0; i < executionModeCombo.getItemCount(); i++) {
+                    if (label.equals(executionModeCombo.getItemAt(i))) {
+                        executionModeCombo.setSelectedIndex(i);
+                        return;
+                    }
+                }
+            }
+            executionModeCombo.setSelectedIndex(0);
+        } finally {
+            refreshingCombo = false;
+        }
+    }
+
+    private void onExecutionModeChanged() {
+        if (executionModeCombo == null || refreshingCombo) return;
+        String selected = (String) executionModeCombo.getSelectedItem();
+        DevoxxGenieStateService stateService = DevoxxGenieStateService.getInstance();
+
+        if (selected == null || LLM_PROVIDER_LABEL.equals(selected)) {
+            stateService.setSpecRunnerMode("llm");
+            stateService.setSpecSelectedCliTool("");
+        } else if (selected.startsWith("CLI: ")) {
+            stateService.setSpecRunnerMode("cli");
+            stateService.setSpecSelectedCliTool(selected.substring("CLI: ".length()));
+        }
     }
 
     // ===== Checkbox Handling =====
@@ -330,10 +406,14 @@ public void onRunFinished(int completed, int skipped, int total, SpecTaskRunnerS
         String msg = switch (finalState) {
             case ALL_COMPLETED -> String.format("Batch run complete: %d/%d tasks done", completed, total);
             case CANCELLED -> String.format("Batch run cancelled: %d/%d done, %d skipped", completed, total, skipped);
-            case ERROR -> "Batch run ended with errors";
+            case ERROR -> String.format("Batch run stopped due to error: %d/%d done, %d skipped. Check the CLI tool's authentication and configuration.", completed, total, skipped);
             default -> "Batch run finished";
         };
-        NotificationUtil.sendNotification(project, msg);
+        if (finalState == SpecTaskRunnerService.RunnerState.ERROR) {
+            NotificationUtil.sendErrorNotification(project, msg);
+        } else {
+            NotificationUtil.sendNotification(project, msg);
+        }
     }
 
     // ===== Existing Methods =====
diff --git a/src/main/java/com/devoxx/genie/ui/settings/DevoxxGenieStateService.java b/src/main/java/com/devoxx/genie/ui/settings/DevoxxGenieStateService.java
index 5e037e7a..5afe56f3 100644
--- a/src/main/java/com/devoxx/genie/ui/settings/DevoxxGenieStateService.java
+++ b/src/main/java/com/devoxx/genie/ui/settings/DevoxxGenieStateService.java
@@ -5,6 +5,7 @@
 import com.devoxx.genie.model.agent.SubAgentConfig;
 import com.devoxx.genie.model.enumarations.ModelProvider;
 import com.devoxx.genie.model.mcp.MCPSettings;
+import com.devoxx.genie.model.spec.CliToolConfig;
 import com.devoxx.genie.service.DevoxxGenieSettingsService;
 import com.devoxx.genie.util.DefaultLLMSettingsUtil;
 import com.intellij.openapi.application.ApplicationManager;
@@ -237,6 +238,11 @@ public static DevoxxGenieStateService getInstance() {
     private Boolean autoInjectSpecContext = true;
     private Integer specTaskRunnerTimeoutMinutes = 10;
 
+    // CLI tool runner settings for spec tasks
+    private List<CliToolConfig> cliTools = new ArrayList<>();
+    private String specRunnerMode = "llm";          // "llm" or "cli"
+    private String specSelectedCliTool = "";         // name of selected CLI tool
+
     // Inline completion settings
     private String inlineCompletionProvider = "";  // "", "Ollama", or "LMStudio"
     private String inlineCompletionModel = "";
diff --git a/src/main/java/com/devoxx/genie/ui/settings/spec/SpecSettingsComponent.java b/src/main/java/com/devoxx/genie/ui/settings/spec/SpecSettingsComponent.java
index 6ccbf6b4..9d6a1f37 100644
--- a/src/main/java/com/devoxx/genie/ui/settings/spec/SpecSettingsComponent.java
+++ b/src/main/java/com/devoxx/genie/ui/settings/spec/SpecSettingsComponent.java
@@ -1,5 +1,6 @@
 package com.devoxx.genie.ui.settings.spec;
 
+import com.devoxx.genie.model.spec.CliToolConfig;
 import com.devoxx.genie.service.spec.BacklogConfigService;
 import com.devoxx.genie.service.spec.SpecService;
 import com.devoxx.genie.ui.settings.AbstractSettingsComponent;
@@ -11,13 +12,18 @@
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ui.ToolbarDecorator;
 import com.intellij.ui.components.JBCheckBox;
 import com.intellij.ui.components.JBLabel;
 import com.intellij.ui.components.JBTextField;
+import com.intellij.ui.table.JBTable;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
+import javax.swing.table.AbstractTableModel;
 import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -41,6 +47,9 @@ public class SpecSettingsComponent extends AbstractSettingsComponent {
                     stateService.getSpecTaskRunnerTimeoutMinutes() != null ? stateService.getSpecTaskRunnerTimeoutMinutes() : 10,
                     1, 60, 1));
 
+    private final CliToolTableModel cliToolTableModel = new CliToolTableModel();
+    private final JBTable cliToolTable = new JBTable(cliToolTableModel);
+
     public SpecSettingsComponent(@NotNull Project project) {
         this.project = project;
         JPanel contentPanel = new JPanel(new GridBagLayout());
@@ -107,6 +116,41 @@ public SpecSettingsComponent(@NotNull Project project) {
                 "to complete before being automatically skipped. The timeout resets if the agent " +
                 "starts working on the task (status changes to 'In Progress').");
 
+        // --- CLI Runners ---
+        addSection(contentPanel, gbc, "CLI Runners");
+
+        addHelpText(contentPanel, gbc,
+                "Configure external CLI tools (e.g., GitHub Copilot CLI, Claude Code, Gemini CLI) " +
+                "that can execute spec tasks instead of the built-in LLM provider. " +
+                "CLI tools must have the Backlog MCP server installed so they can update task status. " +
+                "Select the execution mode in the Spec Browser toolbar.");
+
+        // Configure table columns
+        cliToolTable.getColumnModel().getColumn(0).setMaxWidth(60);   // Enabled
+        cliToolTable.getColumnModel().getColumn(0).setMinWidth(60);
+        cliToolTable.getColumnModel().getColumn(1).setPreferredWidth(80);  // Type
+        cliToolTable.getColumnModel().getColumn(2).setPreferredWidth(220); // Path
+        cliToolTable.getColumnModel().getColumn(3).setPreferredWidth(170); // MCP Config Flag
+        cliToolTable.setRowHeight(25);
+
+        ToolbarDecorator decorator = ToolbarDecorator.createDecorator(cliToolTable)
+                .setAddAction(button -> addCliTool())
+                .setEditAction(button -> editCliTool())
+                .setRemoveAction(button -> removeCliTool());
+
+        JPanel tablePanel = decorator.createPanel();
+        tablePanel.setPreferredSize(new Dimension(-1, 150));
+
+        gbc.gridwidth = 2;
+        gbc.gridx = 0;
+        gbc.fill = GridBagConstraints.BOTH;
+        contentPanel.add(tablePanel, gbc);
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+        gbc.gridy++;
+
+        // Load existing CLI tools from state
+        loadCliTools();
+
         // Filler
         gbc.weighty = 1.0;
         gbc.gridy++;
@@ -115,6 +159,59 @@ public SpecSettingsComponent(@NotNull Project project) {
         panel.add(contentPanel, BorderLayout.NORTH);
     }
 
+    // ===== CLI Tool Table Management =====
+
+    private void loadCliTools() {
+        List<CliToolConfig> tools = stateService.getCliTools();
+        if (tools != null) {
+            for (CliToolConfig tool : tools) {
+                cliToolTableModel.addTool(tool);
+            }
+        }
+        // Pre-populate with Copilot if no tools configured
+        if (cliToolTableModel.getRowCount() == 0) {
+            com.devoxx.genie.service.spec.command.CliCommand cmd = CliToolConfig.CliType.COPILOT.createCommand();
+            List<String> defaultArgs = new ArrayList<>();
+            for (String arg : cmd.defaultExtraArgs().split("\\s+")) {
+                if (!arg.isEmpty()) defaultArgs.add(arg);
+            }
+            cliToolTableModel.addTool(CliToolConfig.builder()
+                    .type(CliToolConfig.CliType.COPILOT)
+                    .name(CliToolConfig.CliType.COPILOT.getDisplayName())
+                    .executablePath(cmd.defaultExecutablePath())
+                    .extraArgs(defaultArgs)
+                    .mcpConfigFlag(cmd.defaultMcpConfigFlag())
+                    .enabled(true)
+                    .build());
+        }
+    }
+
+    private void addCliTool() {
+        CliToolDialog dialog = new CliToolDialog(null);
+        if (dialog.showAndGet()) {
+            cliToolTableModel.addTool(dialog.getResult());
+        }
+    }
+
+    private void editCliTool() {
+        int row = cliToolTable.getSelectedRow();
+        if (row < 0) return;
+        CliToolConfig existing = cliToolTableModel.getToolAt(row);
+        CliToolDialog dialog = new CliToolDialog(existing);
+        if (dialog.showAndGet()) {
+            cliToolTableModel.updateTool(row, dialog.getResult());
+        }
+    }
+
+    private void removeCliTool() {
+        int row = cliToolTable.getSelectedRow();
+        if (row >= 0) {
+            cliToolTableModel.removeTool(row);
+        }
+    }
+
+    // ===== Existing Helper Methods =====
+
     private void addFullWidthRow(JPanel panel, GridBagConstraints gbc, JComponent component) {
         gbc.gridwidth = 2;
         gbc.gridx = 0;
@@ -176,7 +273,6 @@ private void performInit() {
                 ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
 
                 try {
-                    // Step 1: Create directory structure
                     indicator.setText("Creating backlog directory structure...");
                     indicator.setIndeterminate(false);
                     indicator.setFraction(0.2);
@@ -185,7 +281,6 @@ private void performInit() {
 
                     indicator.checkCanceled();
 
-                    // Step 2: Refresh VFS
                     indicator.setText("Refreshing project files...");
                     indicator.setFraction(0.6);
 
@@ -204,7 +299,6 @@ private void performInit() {
 
                     indicator.checkCanceled();
 
-                    // Step 3: Refresh spec service cache
                     indicator.setText("Updating spec browser...");
                     indicator.setFraction(0.9);
 
@@ -221,7 +315,6 @@ private void performInit() {
             cancelled = true;
         }
 
-        // Back on EDT — update UI
         if (cancelled) {
             statusLabel.setText("Cancelled");
             initBacklogButton.setEnabled(true);
@@ -240,13 +333,22 @@ public boolean isModified() {
         DevoxxGenieStateService state = DevoxxGenieStateService.getInstance();
         return enableSpecBrowserCheckbox.isSelected() != Boolean.TRUE.equals(state.getSpecBrowserEnabled())
                 || !Objects.equals(specDirectoryField.getText().trim(), state.getSpecDirectory())
-                || !Objects.equals(taskRunnerTimeoutSpinner.getValue(), state.getSpecTaskRunnerTimeoutMinutes());
+                || !Objects.equals(taskRunnerTimeoutSpinner.getValue(), state.getSpecTaskRunnerTimeoutMinutes())
+                || isCliToolsModified();
+    }
+
+    private boolean isCliToolsModified() {
+        List<CliToolConfig> saved = stateService.getCliTools();
+        List<CliToolConfig> current = cliToolTableModel.getAllTools();
+        if (saved == null) return !current.isEmpty();
+        return !saved.equals(current);
     }
 
     public void apply() {
         stateService.setSpecBrowserEnabled(enableSpecBrowserCheckbox.isSelected());
         stateService.setSpecDirectory(specDirectoryField.getText().trim());
         stateService.setSpecTaskRunnerTimeoutMinutes((Integer) taskRunnerTimeoutSpinner.getValue());
+        stateService.setCliTools(new ArrayList<>(cliToolTableModel.getAllTools()));
     }
 
     public void reset() {
@@ -254,10 +356,409 @@ public void reset() {
         enableSpecBrowserCheckbox.setSelected(Boolean.TRUE.equals(state.getSpecBrowserEnabled()));
         specDirectoryField.setText(state.getSpecDirectory() != null ? state.getSpecDirectory() : "backlog");
         taskRunnerTimeoutSpinner.setValue(state.getSpecTaskRunnerTimeoutMinutes() != null ? state.getSpecTaskRunnerTimeoutMinutes() : 10);
+
+        cliToolTableModel.clear();
+        List<CliToolConfig> tools = state.getCliTools();
+        if (tools != null) {
+            for (CliToolConfig tool : tools) {
+                cliToolTableModel.addTool(tool);
+            }
+        }
     }
 
     @Override
     public void addListeners() {
         // No dynamic listeners needed
     }
+
+    // ===== CLI Tool Table Model =====
+
+    private static class CliToolTableModel extends AbstractTableModel {
+        private static final String[] COLUMNS = {"Enabled", "Type", "Executable Path", "MCP Config Flag"};
+        private final List<CliToolConfig> tools = new ArrayList<>();
+
+        @Override
+        public int getRowCount() {
+            return tools.size();
+        }
+
+        @Override
+        public int getColumnCount() {
+            return COLUMNS.length;
+        }
+
+        @Override
+        public String getColumnName(int column) {
+            return COLUMNS[column];
+        }
+
+        @Override
+        public Class<?> getColumnClass(int columnIndex) {
+            return columnIndex == 0 ? Boolean.class : String.class;
+        }
+
+        @Override
+        public boolean isCellEditable(int rowIndex, int columnIndex) {
+            return columnIndex == 0; // Only "Enabled" is directly editable
+        }
+
+        @Override
+        public Object getValueAt(int rowIndex, int columnIndex) {
+            CliToolConfig tool = tools.get(rowIndex);
+            return switch (columnIndex) {
+                case 0 -> tool.isEnabled();
+                case 1 -> tool.getType() != null ? tool.getType().getDisplayName() : "";
+                case 2 -> tool.getExecutablePath();
+                case 3 -> tool.getMcpConfigFlag() != null ? tool.getMcpConfigFlag() : "";
+                default -> "";
+            };
+        }
+
+        @Override
+        public void setValueAt(Object value, int rowIndex, int columnIndex) {
+            if (columnIndex == 0 && value instanceof Boolean) {
+                tools.get(rowIndex).setEnabled((Boolean) value);
+                fireTableCellUpdated(rowIndex, columnIndex);
+            }
+        }
+
+        public void addTool(CliToolConfig tool) {
+            tools.add(tool);
+            fireTableRowsInserted(tools.size() - 1, tools.size() - 1);
+        }
+
+        public void updateTool(int row, CliToolConfig tool) {
+            tools.set(row, tool);
+            fireTableRowsUpdated(row, row);
+        }
+
+        public void removeTool(int row) {
+            tools.remove(row);
+            fireTableRowsDeleted(row, row);
+        }
+
+        public CliToolConfig getToolAt(int row) {
+            return tools.get(row);
+        }
+
+        public List<CliToolConfig> getAllTools() {
+            return new ArrayList<>(tools);
+        }
+
+        public void clear() {
+            int size = tools.size();
+            if (size > 0) {
+                tools.clear();
+                fireTableRowsDeleted(0, size - 1);
+            }
+        }
+    }
+
+    // ===== CLI Tool Dialog =====
+
+    private static class CliToolDialog extends com.intellij.openapi.ui.DialogWrapper {
+        private final JComboBox<CliToolConfig.CliType> typeCombo = new JComboBox<>(CliToolConfig.CliType.values());
+        private final JBTextField pathField = new JBTextField();
+        private final JBTextField argsField = new JBTextField();
+        private final JBTextField envVarsField = new JBTextField();
+        private final JBTextField mcpConfigFlagField = new JBTextField();
+        private final JBCheckBox enabledCheckbox = new JBCheckBox("Enabled", true);
+        private final JBLabel testResultLabel = new JBLabel();
+        private boolean suppressTypeListener = false;
+
+        CliToolDialog(CliToolConfig existing) {
+            super(true);
+            setTitle(existing == null ? "Add CLI Tool" : "Edit CLI Tool");
+            if (existing != null) {
+                suppressTypeListener = true;
+                typeCombo.setSelectedItem(existing.getType() != null ? existing.getType() : CliToolConfig.CliType.CUSTOM);
+                suppressTypeListener = false;
+                pathField.setText(existing.getExecutablePath());
+                argsField.setText(existing.getExtraArgs() != null ? String.join(" ", existing.getExtraArgs()) : "");
+                envVarsField.setText(formatEnvVars(existing.getEnvVars()));
+                mcpConfigFlagField.setText(existing.getMcpConfigFlag() != null ? existing.getMcpConfigFlag() : "");
+                enabledCheckbox.setSelected(existing.isEnabled());
+            }
+            init();
+            // Pre-fill defaults for the initially selected type when adding a new entry
+            if (existing == null) {
+                onTypeChanged();
+            }
+        }
+
+        @Override
+        protected JComponent createCenterPanel() {
+            JPanel panel = new JPanel(new GridBagLayout());
+            GridBagConstraints gbc = new GridBagConstraints();
+            gbc.fill = GridBagConstraints.HORIZONTAL;
+            gbc.insets = new Insets(4, 4, 4, 4);
+            gbc.anchor = GridBagConstraints.WEST;
+
+            // Type selector (first row)
+            gbc.gridy = 0;
+            gbc.gridx = 0;
+            gbc.weightx = 0;
+            panel.add(new JBLabel("Type:"), gbc);
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            typeCombo.setRenderer(new DefaultListCellRenderer() {
+                @Override
+                public java.awt.Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean sel, boolean focus) {
+                    super.getListCellRendererComponent(list, value, index, sel, focus);
+                    if (value instanceof CliToolConfig.CliType t) setText(t.getDisplayName());
+                    return this;
+                }
+            });
+            typeCombo.addActionListener(e -> onTypeChanged());
+            panel.add(typeCombo, gbc);
+
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.weightx = 0;
+            panel.add(new JBLabel("Executable path:"), gbc);
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            panel.add(pathField, gbc);
+
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.weightx = 0;
+            panel.add(new JBLabel("Extra args:"), gbc);
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            panel.add(argsField, gbc);
+
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.weightx = 0;
+            panel.add(new JBLabel("Env vars:"), gbc);
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            envVarsField.getEmptyText().setText("KEY=VALUE, KEY2=VALUE2");
+            panel.add(envVarsField, gbc);
+
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.weightx = 0;
+            panel.add(new JBLabel("MCP config flag:"), gbc);
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            mcpConfigFlagField.setEditable(false);
+            mcpConfigFlagField.setEnabled(false);
+            panel.add(mcpConfigFlagField, gbc);
+
+            // Help text for MCP config
+            gbc.gridy++;
+            gbc.gridx = 1;
+            gbc.weightx = 1.0;
+            JBLabel mcpHelpLabel = new JBLabel("Backlog MCP config is auto-generated and passed to the CLI tool");
+            mcpHelpLabel.setForeground(UIManager.getColor("Label.disabledForeground"));
+            mcpHelpLabel.setFont(mcpHelpLabel.getFont().deriveFont((float) mcpHelpLabel.getFont().getSize() - 1));
+            panel.add(mcpHelpLabel, gbc);
+
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.gridwidth = 2;
+            panel.add(enabledCheckbox, gbc);
+
+            // Test button row
+            gbc.gridy++;
+            gbc.gridx = 0;
+            gbc.gridwidth = 2;
+            JPanel testRow = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 0));
+            JButton testButton = new JButton("Test Connection");
+            testButton.addActionListener(e -> runTest());
+            testRow.add(testButton);
+            testResultLabel.setForeground(UIManager.getColor("Label.disabledForeground"));
+            testRow.add(testResultLabel);
+            panel.add(testRow, gbc);
+
+            return panel;
+        }
+
+        private void onTypeChanged() {
+            if (suppressTypeListener) return;
+            CliToolConfig.CliType type = (CliToolConfig.CliType) typeCombo.getSelectedItem();
+            if (type == null || type == CliToolConfig.CliType.CUSTOM) return;
+
+            // Delegate to the Command for this type — no switch needed
+            com.devoxx.genie.service.spec.command.CliCommand command = type.createCommand();
+            pathField.setText(command.defaultExecutablePath());
+            argsField.setText(command.defaultExtraArgs());
+            mcpConfigFlagField.setText(command.defaultMcpConfigFlag());
+        }
+
+        private void runTest() {
+            String path = pathField.getText().trim();
+            if (path.isEmpty()) {
+                testResultLabel.setForeground(UIManager.getColor("Component.errorFocusColor"));
+                testResultLabel.setText("Executable path is empty");
+                return;
+            }
+
+            testResultLabel.setForeground(UIManager.getColor("Label.disabledForeground"));
+            testResultLabel.setText("Testing...");
+
+            com.intellij.openapi.application.ApplicationManager.getApplication().executeOnPooledThread(() -> {
+                try {
+                    // Build the actual command using the configured flags and pipe a test prompt via stdin
+                    // This verifies authentication, not just installation
+                    CliToolConfig testConfig = getResult();
+                    java.util.List<String> command = testConfig.buildCommand();
+
+                    ProcessBuilder pb = new ProcessBuilder(command);
+                    pb.redirectErrorStream(false);
+
+                    // Inherit the user's shell environment (PATH, tokens, etc.)
+                    pb.environment().putAll(com.intellij.util.EnvironmentUtil.getEnvironmentMap());
+
+                    // Overlay with tool-specific env var overrides
+                    if (testConfig.getEnvVars() != null && !testConfig.getEnvVars().isEmpty()) {
+                        pb.environment().putAll(testConfig.getEnvVars());
+                    }
+
+                    Process process = pb.start();
+
+                    // Pipe test prompt via stdin
+                    try (var writer = new java.io.OutputStreamWriter(
+                            process.getOutputStream(), java.nio.charset.StandardCharsets.UTF_8)) {
+                        writer.write("Respond with only: OK");
+                        writer.flush();
+                    }
+
+                    // Read stdout and stderr in parallel
+                    StringBuilder stdout = new StringBuilder();
+                    StringBuilder stderr = new StringBuilder();
+
+                    Thread stdoutReader = new Thread(() -> {
+                        try (java.io.BufferedReader reader = new java.io.BufferedReader(
+                                new java.io.InputStreamReader(process.getInputStream()))) {
+                            String line;
+                            int count = 0;
+                            while ((line = reader.readLine()) != null && count < 10) {
+                                if (stdout.length() > 0) stdout.append(" ");
+                                stdout.append(line);
+                                count++;
+                            }
+                        } catch (java.io.IOException ignored) {}
+                    });
+                    Thread stderrReader = new Thread(() -> {
+                        try (java.io.BufferedReader reader = new java.io.BufferedReader(
+                                new java.io.InputStreamReader(process.getErrorStream()))) {
+                            String line;
+                            int count = 0;
+                            while ((line = reader.readLine()) != null && count < 10) {
+                                if (stderr.length() > 0) stderr.append(" ");
+                                stderr.append(line);
+                                count++;
+                            }
+                        } catch (java.io.IOException ignored) {}
+                    });
+
+                    stdoutReader.setDaemon(true);
+                    stderrReader.setDaemon(true);
+                    stdoutReader.start();
+                    stderrReader.start();
+
+                    boolean exited = process.waitFor(30, java.util.concurrent.TimeUnit.SECONDS);
+                    if (!exited) {
+                        process.destroyForcibly();
+                        showTestResult(false, "Timed out after 30s");
+                        return;
+                    }
+
+                    stdoutReader.join(3000);
+                    stderrReader.join(3000);
+
+                    int exitCode = process.exitValue();
+                    if (exitCode == 0) {
+                        showTestResult(true, "Connected successfully");
+                    } else {
+                        // Prefer stderr for error messages, fall back to stdout
+                        String err = stderr.toString().trim();
+                        if (err.isEmpty()) err = stdout.toString().trim();
+                        if (err.isEmpty()) err = "Exit code " + exitCode;
+                        showTestResult(false, err);
+                    }
+
+                } catch (java.io.IOException ex) {
+                    showTestResult(false, "Not found: " + ex.getMessage());
+                } catch (InterruptedException ex) {
+                    Thread.currentThread().interrupt();
+                    showTestResult(false, "Interrupted");
+                }
+            });
+        }
+
+        private void showTestResult(boolean success, String message) {
+            SwingUtilities.invokeLater(() -> {
+                String truncated = message.length() > 80 ? message.substring(0, 80) + "..." : message;
+                if (success) {
+                    testResultLabel.setForeground(new java.awt.Color(0, 128, 0));
+                    testResultLabel.setText(truncated);
+                } else {
+                    testResultLabel.setForeground(UIManager.getColor("Component.errorFocusColor"));
+                    testResultLabel.setText(truncated);
+                }
+            });
+        }
+
+        private static String formatEnvVars(java.util.Map<String, String> envVars) {
+            if (envVars == null || envVars.isEmpty()) return "";
+            StringBuilder sb = new StringBuilder();
+            for (var entry : envVars.entrySet()) {
+                if (sb.length() > 0) sb.append(", ");
+                sb.append(entry.getKey()).append("=").append(entry.getValue());
+            }
+            return sb.toString();
+        }
+
+        /**
+         * Strip surrounding shell-style quotes from an argument.
+         * ProcessBuilder doesn't use a shell, so literal quotes must be removed.
+         */
+        private static String stripShellQuotes(String arg) {
+            if (arg.length() >= 2) {
+                if ((arg.startsWith("'") && arg.endsWith("'")) ||
+                        (arg.startsWith("\"") && arg.endsWith("\""))) {
+                    return arg.substring(1, arg.length() - 1);
+                }
+            }
+            return arg;
+        }
+
+        private static java.util.Map<String, String> parseEnvVars(String text) {
+            java.util.Map<String, String> map = new java.util.LinkedHashMap<>();
+            if (text == null || text.isEmpty()) return map;
+            for (String pair : text.split(",")) {
+                String trimmed = pair.trim();
+                int eq = trimmed.indexOf('=');
+                if (eq > 0 && eq < trimmed.length() - 1) {
+                    map.put(trimmed.substring(0, eq).trim(), trimmed.substring(eq + 1).trim());
+                }
+            }
+            return map;
+        }
+
+        public CliToolConfig getResult() {
+            List<String> args = new ArrayList<>();
+            String argsText = argsField.getText().trim();
+            if (!argsText.isEmpty()) {
+                for (String arg : argsText.split("\\s+")) {
+                    args.add(stripShellQuotes(arg));
+                }
+            }
+            CliToolConfig.CliType selectedType = (CliToolConfig.CliType) typeCombo.getSelectedItem();
+            if (selectedType == null) selectedType = CliToolConfig.CliType.CUSTOM;
+            return CliToolConfig.builder()
+                    .type(selectedType)
+                    .name(selectedType.getDisplayName())
+                    .executablePath(pathField.getText().trim())
+                    .extraArgs(args)
+                    .envVars(parseEnvVars(envVarsField.getText().trim()))
+                    .mcpConfigFlag(mcpConfigFlagField.getText().trim())
+                    .enabled(enabledCheckbox.isSelected())
+                    .build();
+        }
+    }
 }