@darkiceinteractive/mcp-conductor 3.0.0-beta.2 → 3.1.1

package/README.md

@@ -1,6 +1,6 @@
 # MCP Conductor
 
-**99.7% fewer tokens. Parallel execution. One `npx` command.**
+**The canonical MCP hub for any agent platform. 99.7% fewer tokens. One `npx` command.**
 
 [![npm version](https://img.shields.io/npm/v/@darkiceinteractive/mcp-conductor.svg?style=flat)](https://www.npmjs.com/package/@darkiceinteractive/mcp-conductor)
 [![npm downloads](https://img.shields.io/npm/dm/@darkiceinteractive/mcp-conductor.svg?style=flat)](https://www.npmjs.com/package/@darkiceinteractive/mcp-conductor)
@@ -8,56 +8,49 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Deno](https://img.shields.io/badge/runtime-Deno%202.x-black?logo=deno)](https://deno.land)
 
-MCP Conductor is a single MCP server that orchestrates all your other MCP servers through a sandboxed Deno runtime. Instead of Claude making direct tool calls (and dumping every intermediate result into your context window), Claude writes TypeScript code that runs in an isolated sandbox. Only the final result comes back.
+MCP Conductor is a single MCP server that orchestrates all your other MCP servers through a sandboxed Deno runtime. Works with Claude Code, Claude Desktop, Cursor, Gemini CLI, Codex CLI, Cline, Zed, Continue.dev, OpenCode, and Kimi Code. Instead of your AI client making direct tool calls (and dumping every intermediate result into your context window), it writes TypeScript code that runs in an isolated sandbox. Only the final result comes back.
 
 ```
-Before: 153,900 tokens → Claude context window → 153,900 tokens billed
-After:  153,900 tokens → Deno sandbox → 435 tokens → Claude context window
+Before: 153,900 tokens → AI client context window → 153,900 tokens billed
+After:  153,900 tokens → Deno sandbox → 435 tokens → AI client context window
 ```
 
 **Average measured reduction: 99.7%. Verified against Anthropic's published benchmarks.**
 
 ---
 
-## What's New in v3 (beta)
+## Quick Install
 
-v3 is a ground-up registry-driven architecture. Every backend tool is described, validated, and type-generated at startup. New workstreams add production-grade reliability, caching, observability, and multi-agent coordination.
+### v3.1.1 — Supported Clients
 
-| Workstream | Feature | Docs |
-|---|---|---|
-| Phase 1 | Tool Registry — schema validation, hot-reload, type generation | [architecture](./docs/v3/architecture.md) |
-| Phase 2 | Response cache — LRU + CBOR serialisation, TTL per tool | [configuration](./docs/v3/configuration.md) |
-| Phase 3 | Reliability gateway — timeout, retry, circuit breaker | [architecture](./docs/v3/architecture.md) |
-| Phase 4 | Connection pool + warm sandbox pool | [configuration](./docs/v3/configuration.md) |
-| Phase 5 | Sandbox API — `compact`, `summarize`, `findTool`, `budget` | [sandbox-api](./docs/v3/sandbox-api.md) |
-| Phase 6 | Daemon mode, shared KV store, distributed lock | [configuration](./docs/v3/configuration.md) |
-| Phase 7 | Structured observability, session replay | [architecture](./docs/v3/architecture.md) |
-| X1 | Passthrough adapter — expose backend tools directly | [recipes](./docs/v3/recipes.md) |
-| X2 | Lifecycle tools, CLI wizard | [sandbox-api](./docs/v3/sandbox-api.md) |
-| X4 | PII tokenisation, response redaction | [configuration](./docs/v3/configuration.md) |
-
-Migrating from v2? See the [migration guide](./docs/v3/migration.md).
-
----
+| Client | Config path (macOS) | Config path (Linux) | Config path (Windows) |
+|---|---|---|---|
+| Claude Code | `~/.claude/settings.json` | `~/.claude/settings.json` | `%APPDATA%\Claude Code\claude_code_config.json` |
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | `~/.config/claude/claude_desktop_config.json` | `%APPDATA%\Claude\claude_desktop_config.json` |
+| Cursor | `~/.cursor/mcp.json` | `~/.cursor/mcp.json` | `~/.cursor/mcp.json` |
+| Gemini CLI | `~/.gemini/settings.json` | `~/.gemini/settings.json` | `~/.gemini/settings.json` |
+| Codex CLI | `~/.codex/config.toml` | `~/.codex/config.toml` | `~/.codex/config.toml` |
+| Cline | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` | `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` | `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json` |
+| Zed | `~/Library/Application Support/Zed/settings.json` | `~/.config/zed/settings.json` | `%LOCALAPPDATA%\Zed\settings.json` |
+| Continue.dev | `~/.continue/config.yaml` | `~/.continue/config.yaml` | `~/.continue/config.yaml` |
+| OpenCode | `~/.config/opencode/opencode.json` | `~/.config/opencode/opencode.json` | `%APPDATA%\opencode\opencode.json` |
+| Kimi Code | `~/Library/Application Support/Kimi Code/mcp_settings.json` | `~/.config/kimi-code/mcp_settings.json` | `%APPDATA%\Kimi Code\mcp_settings.json` |
 
-## Quick Start
+### Guided Setup (recommended)
 
-### 1. Install Deno
+The setup wizard auto-detects every supported client on your machine and offers per-client consolidation:
 
 ```bash
-# macOS
-brew install deno
+npx -y @darkiceinteractive/mcp-conductor-cli@next setup
+```
 
-# Linux
-curl -fsSL https://deno.land/install.sh | sh
+See [What the wizard does](#what-the-wizard-does) below.
 
-# Windows
-winget install DenoLand.Deno
-```
+### Manual Config Snippets
 
-### 2. Add to Your AI Tool
+Paste the appropriate block into your client's config file. The wizard does this automatically.
 
-**Claude Code** (`~/.claude/settings.json`), **Claude Desktop**, **Gemini CLI** (`~/.gemini/settings.json`), **Kimi CLI** (`~/.kimi/mcp.json`), **Cursor** (`.cursor/mcp.json`), **Windsurf** (`~/.codeium/windsurf/mcp_config.json`), **Cline**, or **VS Code** (`.vscode/mcp.json`):
+**Claude Code** (`~/.claude/settings.json`):
 
 ```json
 {
@@ -70,333 +63,222 @@ winget install DenoLand.Deno
 }
 ```
 
-**OpenAI Codex** (`~/.codex/config.toml`):
-
-```toml
-[mcp_servers.mcp-conductor]
-command = "npx"
-args = ["-y", "@darkiceinteractive/mcp-conductor"]
-```
-
-> **Note:** VS Code uses `"servers"` instead of `"mcpServers"` and requires `"type": "stdio"`. See the [full multi-platform guide](./docs/guide/mcp-clients.md) for exact config per platform.
-
-### 3. Restart Your AI Tool
-
-That's it. Ask your AI to list MCP servers — you should see `mcp-conductor` with its tools.
-
----
-
-## What This Solves
-
-When Claude calls MCP tools directly, every response lands in the context window — raw JSON, file metadata, pagination objects, fields you never asked for. A single GitHub `list_issues` call can return 40,000+ tokens. If you're making 10 calls per task, that's 400,000 tokens before Claude has written a single line of code.
-
-MCP Conductor flips the model: Claude writes TypeScript code that *processes* the tool responses inside a Deno sandbox. The sandbox can call any connected MCP server, filter and aggregate the results, and return only the compact summary. Your context window stays small. Your costs stay low.
-
-```typescript
-// This runs inside the Deno sandbox — not in Claude's context window
-const [issues, files] = await mcp.batch([
-  () => mcp.server('github').call('list_issues', { owner: 'myorg', repo: 'myrepo', state: 'open' }),
-  () => mcp.server('filesystem').call('list_directory', { path: '/src' })
-]);
-
-return {
-  openBugs: issues.filter(i => i.labels.some(l => l.name === 'bug')).length,
-  tsFiles: files.filter(f => f.name.endsWith('.ts')).length
-};
-// Returns: {"openBugs": 12, "tsFiles": 47}  ←  under 100 tokens
-```
-
----
+**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
 
-## How It Works
-
-```
-Claude
-  └── execute_code (writes TypeScript)
-        └── Deno Sandbox (50ms startup, <50MB RAM)
-              ├── mcp.server('github').call(...)     ← your MCP servers
-              ├── mcp.server('filesystem').call(...) ← hidden from Claude
-              └── mcp.server('brave-search').call(...)
-                    └── return { compact: "summary" } → back to Claude
+```json
+{
+  "mcpServers": {
+    "mcp-conductor": {
+      "command": "npx",
+      "args": ["-y", "@darkiceinteractive/mcp-conductor"]
+    }
+  }
+}
 ```
 
-The Deno sandbox runs with minimal permissions:
-- Network: localhost bridge only
-- No filesystem access (MCP handles that)
-- No environment variable access
-- No subprocess spawning
-
-**Why Deno?** 50ms cold start vs 500ms–2s for Docker, under 50MB vs 200MB+ memory overhead, TypeScript natively, granular permission model.
-
----
-
-## Adding Your Servers
-
-Create `~/.mcp-conductor.json` to register backend servers:
+**Cursor** (`~/.cursor/mcp.json`):
 
 ```json
 {
-  "exclusive": true,
-  "servers": {
-    "filesystem": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname"],
-      "env": {}
-    },
-    "github": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"],
-      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token" }
-    },
-    "brave-search": {
-      "command": "npx",
-      "args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
-      "env": { "BRAVE_API_KEY": "your-key" },
-      "rateLimit": {
-        "requestsPerSecond": 20,
-        "burstSize": 20,
-        "onLimitExceeded": "queue",
-        "maxQueueTimeMs": 30000
-      }
-    },
-    "memory": {
+  "mcpServers": {
+    "mcp-conductor": {
       "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-memory"],
-      "env": {}
+      "args": ["-y", "@darkiceinteractive/mcp-conductor"]
     }
   }
 }
 ```
 
-Set `"exclusive": true` to route *all* MCP calls through the sandbox. This is the recommended setting for maximum token savings — Claude cannot bypass the conductor.
+For Codex CLI (TOML), Continue.dev (YAML), and other formats, use `mcp-conductor-cli export --client <id>` — see [Multi-client export](#multi-client-export).
 
-**Hot reload:** Edit the file and save. Changes apply in ~500ms, no restart needed.
+Restart your AI tool after editing the config. That's it.
 
 ---
 
-## The `mcp` API
+## What the Wizard Does
 
-Inside `execute_code`, you have access to the `mcp` object:
+Running `npx -y @darkiceinteractive/mcp-conductor-cli@next setup` steps through the following for each detected client:
 
-```typescript
-// Call a server tool
-const result = await mcp.server('github').call('list_issues', { owner: 'org', repo: 'repo' });
-
-// Parallel execution — executes all calls simultaneously.
-// Two call shapes are supported:
-//
-//   1. Callback form (composable, no rate-limit detection):
-const [issues, files, searches] = await mcp.batch([
-  () => mcp.server('github').call('list_issues', { owner: 'org', repo: 'repo' }),
-  () => mcp.server('filesystem').call('list_directory', { path: '/src' }),
-  () => mcp.server('brave-search').call('search', { q: 'topic', count: 5 })
-]);
+1. **Scan** — discovers all 10 client config locations on your machine (global and project-local).
+2. **Diff** — for each existing config, parses the current server list and shows what will move.
+3. **Confirm per-client** — prompts once per client; you can skip any client individually.
+4. **Write conductor config** — merges your existing servers into `~/.mcp-conductor.json` and installs the conductor entry back into the client config.
+5. **Backup originals** — creates a timestamped `.bak.YYYYMMDDHHMMSS` copy of every config file before modifying it.
 
-//   2. Descriptor form (rate-limit aware, retries on 429s):
-const [a, b] = await mcp.batch([
-  { server: 'github', tool: 'list_issues', params: { owner: 'org', repo: 'repo' } },
-  { server: 'filesystem', tool: 'list_directory', params: { path: '/src' } },
-]);
+In non-interactive environments (CI, piped stdin) the wizard proceeds automatically with safe defaults.
 
-// Batch web searches (handles rate limits automatically)
-const results = await mcp.batchSearch(['query 1', 'query 2', 'query 3'], { topN: 3 });
+---
 
-// Progress updates (visible in Claude)
-mcp.progress('Processing 500 files...');
+## Verifying Setup
 
-// Debug logging
-console.log('issue count:', issues.length);
+```bash
+mcp-conductor-cli doctor
 ```
 
----
-
-## Measuring Your Savings
+The `doctor` command runs a health check across all configured servers and prints an **MCP CLIENT COVERAGE** section showing every detected client config with an `[OK]` or `[MISSING]` status for the conductor entry.
 
-After any workflow, ask Claude to call `get_metrics`:
-
-```json
-{
-  "totalExecutions": 47,
-  "averageCompressionRatio": 0.943,
-  "totalTokensSaved": 1847230,
-  "averageExecutionMs": 73,
-  "lastExecution": {
-    "compressionRatio": 0.978,
-    "tokensSaved": 44200,
-    "inputTokens": 45000,
-    "outputTokens": 800
-  }
-}
+```
+MCP CLIENT COVERAGE
+  [OK]      Claude Code        ~/.claude/settings.json
+  [OK]      Claude Desktop     ~/Library/Application Support/Claude/claude_desktop_config.json
+  [OK]      Cursor             ~/.cursor/mcp.json
+  [MISSING] Zed                ~/Library/Application Support/Zed/settings.json
 ```
 
-`compressionRatio: 0.978` means 97.8% of tokens were processed inside the sandbox rather than billed to your context window. `totalTokensSaved: 1,847,230` is the cumulative count across all 47 executions.
+Run `npx -y @darkiceinteractive/mcp-conductor-cli@next setup` to install the conductor entry in any `[MISSING]` client.
 
 ---
 
-## MCP Tools Available to Claude
-
-| Tool | Description |
-|------|-------------|
-| `execute_code` | Run TypeScript in the Deno sandbox with MCP server access |
-| `list_servers` | List all connected backend servers |
-| `discover_tools` | Search for tools across all servers |
-| `get_metrics` | Session statistics and compression ratios |
-| `set_mode` | Switch between `execution`, `passthrough`, or `hybrid` mode |
-| `compare_modes` | Compare how a task runs in each mode |
-| `add_server` | Add a server to the conductor config at runtime |
-| `remove_server` | Remove a server at runtime |
-| `update_server` | Update a server's config (e.g. rotate an API key) without restart |
-| `reload_servers` | Reload config after manual edits |
-| `passthrough_call` | Make a direct tool call (high token cost — debug only) |
-
----
+## Multi-client Export
 
-## CLI Reference
+Generate a ready-to-paste config snippet for any supported client:
 
 ```bash
-# Check system requirements (Node, Deno, Claude config)
-mcp-conductor-cli check
+# Codex CLI — writes TOML
+mcp-conductor-cli export --client codex
 
-# Show current configuration status
-mcp-conductor-cli status
+# Continue.dev — writes YAML
+mcp-conductor-cli export --client continue
 
-# Enable exclusive mode (migrates servers to ~/.mcp-conductor.json)
-mcp-conductor-cli enable-exclusive [--dry-run]
-
-# Disable exclusive mode (restores servers to Claude config)
-mcp-conductor-cli disable-exclusive [--dry-run]
-
-# Add/remove/list servers in conductor config
-mcp-conductor-cli config add <name> <command> [args...]
-mcp-conductor-cli config remove <name>
-mcp-conductor-cli config servers
+# Claude Desktop — writes JSON (default)
+mcp-conductor-cli export --client claude-desktop
+```
 
-# Manage Claude Code permissions (auto-allow all MCP tools)
-mcp-conductor-cli permissions discover --new-only
-mcp-conductor-cli permissions add [--scope project]
+The exported file is written to the current directory as `<client>-config.<ext>`. Pass `--output <path>` to override.
 
-# Install CLAUDE.md to teach Claude to use execute_code
-mcp-conductor-cli install-instructions --dir /path/to/project
-```
+Full client setup documentation is at **[docs.darkice.co/setup/clients](https://docs.darkice.co/setup/clients)**.
 
 ---
 
-## Recipes
-
-### Parallel GitHub + Filesystem analysis
+## 30-Second Example
 
 ```typescript
-mcp.progress('Fetching issues and scanning codebase...');
+// Your AI client writes this code, which runs inside the Deno sandbox
 const [issues, files] = await mcp.batch([
-  () => mcp.server('github').call('list_issues', { owner: 'myorg', repo: 'myrepo', state: 'open', per_page: 100 }),
-  () => mcp.server('filesystem').call('search_files', { path: '/src', pattern: '*.ts' })
+  () => mcp.server('github').call('list_issues', { owner: 'myorg', repo: 'myrepo', state: 'open' }),
+  () => mcp.server('filesystem').call('list_directory', { path: '/src' })
 ]);
+
 return {
   openBugs: issues.filter(i => i.labels.some(l => l.name === 'bug')).length,
-  tsFileCount: files.length
+  tsFiles: files.filter(f => f.name.endsWith('.ts')).length
 };
+// Returns: {"openBugs": 12, "tsFiles": 47}  ←  under 100 tokens
 ```
 
-### Parallel web research
+---
 
-```typescript
-const topics = ['MCP protocol 2026', 'Deno performance benchmarks', 'token optimization AI'];
-const results = await mcp.batch(
-  topics.map(q => () => mcp.server('brave-search').call('search', { q, count: 5 }))
-);
-return results.map((r, i) => ({ topic: topics[i], topResult: r[0]?.title, url: r[0]?.url }));
-```
+## Why It Matters
 
-### Cross-session memory persistence
+When an AI client calls MCP tools directly, every response lands in the context window — raw JSON, file metadata, pagination objects, fields you never asked for. A single GitHub `list_issues` call can return 40,000+ tokens. If you're making 10 calls per task, that's 400,000 tokens before the model has written a single line of code.
 
-```typescript
-// Session 1: store results
-const analysis = { /* ... your analysis ... */ };
-await mcp.server('memory').call('store', { key: 'weekly-audit', value: analysis });
-return analysis;
-
-// Session 2: retrieve and compare
-const previous = await mcp.server('memory').call('retrieve', { key: 'weekly-audit' });
-// diff previous vs current...
-```
+MCP Conductor flips the model: the client writes TypeScript code that *processes* the tool responses inside a Deno sandbox. The sandbox can call any connected MCP server, filter and aggregate the results, and return only the compact summary. Your context window stays small. Your costs stay low.
+
+| Scenario | Without Conductor | With Conductor | Reduction |
+|---|---|---|---|
+| 300-document Drive pipeline | 153,900 tokens | 435 tokens | **99.72%** |
+| GitHub issues triage (10 repos) | ~400,000 tokens | ~2,000 tokens | **99.5%** |
+| Web research (5 searches) | ~50,000 tokens | ~800 tokens | **98.4%** |
 
 ---
 
-## Troubleshooting
+## v3 Highlights
 
-**"Deno not found"** — Install Deno, then `source ~/.zshrc` (or open a new terminal). Verify with `deno --version`.
+| Feature | What it does | Docs |
+|---|---|---|
+| Tool Registry | Schema validation, hot-reload, type generation | [Architecture](https://docs.darkice.co/docs/v3/architecture) |
+| Response Cache | LRU + CBOR serialisation, TTL per tool | [Configuration](https://docs.darkice.co/docs/v3/configuration) |
+| Reliability Gateway | Timeout, retry, circuit breaker | [Architecture](https://docs.darkice.co/docs/v3/architecture) |
+| Connection Pool | Warm sandbox pool, persistent server connections | [Configuration](https://docs.darkice.co/docs/v3/configuration) |
+| Sandbox API | `compact`, `summarize`, `findTool`, `budget` | [Sandbox API](https://docs.darkice.co/docs/v3/sandbox-api) |
+| Daemon Mode | Shared KV store, distributed lock | [Configuration](https://docs.darkice.co/docs/v3/configuration) |
+| Observability | Cost predictor, hot-path profiler, session replay | [Architecture](https://docs.darkice.co/docs/v3/architecture) |
+| Passthrough Adapter | Expose backend tools directly (X1) | [Recipes](https://docs.darkice.co/docs/v3/recipes) |
+| Lifecycle Tools + CLI | `import_servers_from_claude`, setup wizard (X2) | [Sandbox API](https://docs.darkice.co/docs/v3/sandbox-api) |
+| PII Tokenisation | Built-in redaction matchers (X4) | [Configuration](https://docs.darkice.co/docs/v3/configuration) |
+
+## v3.1.1 Additions
+
+| Feature | What it does |
+|---|---|
+| Multi-client adapters | Read and write configs for all 10 supported clients |
+| Setup wizard (MC3) | Interactive per-client consolidation with backups |
+| Per-client export (MC4) | `export --client <id>` writes the correct format (JSON / TOML / YAML) |
+| Doctor client coverage (MC5) | `doctor` reports `[OK]` / `[MISSING]` per detected client config |
+
+Migrating from v2? See the [migration guide](https://docs.darkice.co/docs/v3/migration).
 
-**"Server not connecting"** — Validate your JSON: `cat ~/.mcp-conductor.json | python3 -m json.tool`. Check that env vars are set (not still saying `"your-token"`).
+---
 
-**"`exclusive` mode not working"** — `"exclusive": true` must be at the root level, not inside `"servers"`.
+## Token-Savings Reporter
 
-**"Rate limit errors from brave-search"** — Add a `rateLimit` block to the server config (see example above). Set `onLimitExceeded: "queue"` to buffer requests.
+Pass `show_token_savings: true` on any `execute_code` call to see a breakdown:
 
-**"Config changes not applying"** — The file watcher requires valid JSON. If you saved a file with a syntax error, fix it and save again.
+```json
+{
+  "result": { "processed": 300, "with_dates": 287 },
+  "tokenSavings": {
+    "estimatedPassthroughTokens": 153900,
+    "actualExecutionTokens": 435,
+    "tokensSaved": 153465,
+    "savingsPercent": 99.72
+  }
+}
+```
 
-Full troubleshooting guide: [docs/troubleshooting.md](./docs/troubleshooting.md)
+Or enable it globally in `~/.mcp-conductor.json`:
+
+```json
+{
+  "metrics": {
+    "alwaysShowTokenSavings": true
+  }
+}
+```
+
+Session totals are always available via `get_metrics`.
 
 ---
 
-## Development
+## Docs
 
-```bash
-git clone https://github.com/darkiceinteractive/mcp-conductor.git
-cd mcp-conductor
-npm install
-npm run build
-npm run test:run           # 673 tests, 82% coverage
-npm run test:coverage      # with coverage report
-npm run dev                # watch mode
-```
+Full documentation at **https://docs.darkice.co** — deploys at D4. In the meantime, all reference material is in [`docs/v3/`](./docs/v3/).
 
-**Requirements:** Node.js 18+, Deno 2.x
+| Guide | Description |
+|-------|-------------|
+| [Architecture](./docs/v3/architecture.md) | System design and data flow |
+| [Configuration](./docs/v3/configuration.md) | All config options |
+| [Sandbox API](./docs/v3/sandbox-api.md) | The `mcp` object inside `execute_code` |
+| [Recipes](./docs/v3/recipes.md) | Practical patterns and examples |
+| [Migration (v2 → v3)](./docs/v3/migration.md) | Breaking changes and migration steps |
+| [Client Setup](https://docs.darkice.co/setup/clients) | Per-client config reference for all 10 supported clients |
 
 ---
 
-## Architecture
+## CLI Quick-Start
 
-Full architecture documentation: [docs/guide/](./docs/guide/)
+```bash
+# Guided multi-client setup — detects all supported client configs automatically
+npx -y @darkiceinteractive/mcp-conductor-cli@next setup
 
-```
-Claude Code / Claude Desktop
-    │
-    └── MCP Protocol
-            │
-    ┌───────▼──────────────┐
-    │    MCP Conductor      │
-    │  (Node.js MCP server) │
-    │                       │
-    │  execute_code ──────► Deno Subprocess (50ms, <50MB)
-    │  list_servers         │   TypeScript code runs here
-    │  get_metrics          │   MCP calls via HTTP bridge
-    │  add_server           │   Only result exits sandbox
-    └───────────────────────┘
-              │
-    ┌─────────▼──────────────────────────────┐
-    │         HTTP Bridge (localhost)         │
-    └──┬──────────┬──────────┬───────────────┘
-       │          │          │
-   github     filesystem  brave-search  ... (any MCP server)
-```
+# Health check with client coverage report
+mcp-conductor-cli doctor
 
----
+# Export config for a specific client (TOML for Codex, YAML for Continue, etc.)
+mcp-conductor-cli export --client <client-id>
 
-## Documentation
+# Check system requirements (Node, Deno, conductor config)
+mcp-conductor-cli check
 
-| Guide | Description |
-|-------|-------------|
-| [Getting Started](./docs/guide/getting-started.md) | First-time setup walkthrough |
-| [MCP Clients](./docs/guide/mcp-clients.md) | Setup for Claude, Codex, Gemini, Kimi, VS Code, Cursor, Windsurf, Cline |
-| [Configuration](./docs/configuration.md) | All config options and environment variables |
-| [Architecture](./docs/architecture.md) | System design and data flow |
-| [MCP Tools Reference](./docs/api/tools.md) | All tools available to Claude |
-| [Sandbox API](./docs/api/sandbox-api.md) | The `mcp` object inside execute_code |
-| [CLI Reference](./docs/cli-reference.md) | Command-line tool usage |
-| [Examples](./docs/examples/) | Recipes and patterns |
-| [Benchmarks](./docs/benchmarks/methodology.md) | Token savings methodology and results |
-| [Security](./docs/permissions.md) | Deno sandbox permission model |
-| [Troubleshooting](./docs/troubleshooting.md) | Common issues and fixes |
+# Show current configuration status
+mcp-conductor-cli status
+
+# Enable exclusive mode (routes all MCP calls through the sandbox)
+mcp-conductor-cli enable-exclusive [--dry-run]
+
+# Add a backend server
+mcp-conductor-cli config add github npx -- -y @modelcontextprotocol/server-github
+```
 
 ---
 

package/dist/bin/cli.d.ts

@@ -10,8 +10,8 @@
  *   test     — transient connect + list tools
  *   routing  — show/apply routing recommendations
  *   doctor   — health check all servers
- *   import   — non-interactive import from Claude configs
- *   export   — generate mcpServers JSON for Claude rollback
+ *   import   — non-interactive import from MCP client configs
+ *   export   — generate mcpServers JSON for client rollback
  *   daemon   — start|stop|status|logs (wired to Phase 6 module)
  *
  * @module bin/cli