omnilane 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -6,6 +6,13 @@ semantic version tags.
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-07-18
+
+### Added
+
+- Dependency-free MCP stdio server (`omnilane mcp`) exposing routing, lane
+  discovery, and background-job status/results to any MCP-capable host.
+
 ## [0.8.2] - 2026-07-18
 
 ### Added
@@ -252,7 +259,8 @@ semantic version tags.
 - Initial shared routing table, cross-vendor dispatcher, runners, installer,
   and baseline lint fixes.
 
-[Unreleased]: https://github.com/Seraphim0916/omnilane/compare/v0.8.2...HEAD
+[Unreleased]: https://github.com/Seraphim0916/omnilane/compare/v0.8.3...HEAD
+[0.8.3]: https://github.com/Seraphim0916/omnilane/compare/v0.8.2...v0.8.3
 [0.8.2]: https://github.com/Seraphim0916/omnilane/compare/v0.8.1...v0.8.2
 
 [0.8.1]: https://github.com/Seraphim0916/omnilane/compare/v0.8.0...v0.8.1

package/README.ja.md

@@ -5,8 +5,9 @@
 ### ルーティングテーブルは一枚、ハーネスは全部。
 
 *メインループはもう、どのモデルを使うか迷わない。*<br/>
-すべてのサブタスクを、その作業が本当に得意なモデルへ——<br/>
-**Claude Code · Codex · Grok Build · Antigravity** を横断、いまのサブスクリプションのままで。
+**Claude Code · Codex · Grok Build · Antigravity** のどれから操縦しても、すべてのサブタスクを<br/>
+その作業が本当に得意なモデルへ——Codex、Claude、Grok、Gemini、Kimi、Qwen、OpenCode、<br/>
+さらに OpenRouter 経由の任意のホスト型モデル——いまのサブスクリプションのまま、または API キー一つで。
 
 <img src="docs/hero.ja.png" alt="omnilane が各サブタスクを Claude Code・Codex・Grok・Antigravity の最適なモデルへ振り分ける" width="820"/>
 
@@ -20,6 +21,14 @@
 
 ---
 
+## v0.8.3 の新機能
+
+- **MCP サーバー** — `omnilane mcp` は依存ゼロの stdio MCP サーバーを起動し、
+  MCP 対応ホスト(Claude Code、Codex、Gemini CLI、Cursor、OpenCode など)が
+  スキルなしで omnilane を発見・呼び出しできます:ツールは `route`、
+  `jobs_status`、`jobs_result`、`list_lanes`。`route` は読み取り専用の
+  advise がデフォルトで、work モードには明示的な workdir が必須です。
+
 ## v0.8.2 の新機能
 
 - **`openrouter` vendor** — `curl` と `OPENROUTER_API_KEY` だけで
@@ -114,8 +123,9 @@ omnilane ui start     # 任意:ブラウザでジョブをライブ表示
 ## 🧭 仕組み
 
 omnilane は、**どの** agentic CLI のメインループでも、サブタスクをレーンに
-分類し、各レーンをその作業が最も得意なベンダー CLI へヘッドレスで
-ディスパッチさせる仕組みです。既存のサブスクリプションログインをそのまま使います:
+分類し、各レーンをその作業が最も得意なベンダーへヘッドレスで
+ディスパッチさせる仕組みです。既存のサブスクリプションログインをそのまま
+使います(`openrouter` vendor は例外:CLI 不要、API キー一つで直接接続):
 
 ```mermaid
 flowchart LR
@@ -243,9 +253,11 @@ omnilane ui stop     # 正常に停止
 
 ## 📦 インストール
 
-前提:ルーティングしたいベンダー CLI(`codex`、`claude`、`grok`、`agy`)が
-ログイン済みで `PATH` 上にあること——**持っている分だけで OK**、
-足りないレーンは自動的に降格します。
+前提:ルーティングしたいベンダー CLI(`codex`、`claude`、`grok`、`agy`、
+任意で `kimi`、`qwen`、`opencode`)がログイン済みで `PATH` 上にあること——
+**持っている分だけで OK**、足りないレーンは自動的に降格します。
+`openrouter` vendor は例外で、CLI は不要——`curl` と環境変数の
+`OPENROUTER_API_KEY` だけで動きます。
 
 最速:`./install.sh` — 本機の CLI を検出してスキルを接続し、残りのプラグイン
 コマンドを表示、実効ルーティングを出力し、最後に対話式設定メニューを
@@ -271,6 +283,28 @@ CLI バージョンにより異なる場合あり)へマーカー付きの可逆
 - **Antigravity**:`agy plugin install <このリポジトリ>`(先に
   `agy plugin validate` で確認)
 
+### MCP サーバー
+
+`omnilane mcp` は依存ゼロでローカル実行される MCP stdio サーバーを起動し、
+MCP 対応ホストがスキルの導入やルーティングリマインダーなしで omnilane を
+発見・呼び出しできるようにします。ホスト側の設定でインストール済み CLI を
+指定してください:
+
+```json
+{
+  "mcpServers": {
+    "omnilane": {
+      "command": "omnilane",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+サーバーは `route`、`jobs_status`、`jobs_result`、`list_lanes` を公開します。
+`route` のデフォルトは読み取り専用の `advise` モードで、`work` を選ぶ呼び
+出しには明示的な `workdir` が必須です。
+
 ## ⚙️ カスタマイズ
 
 三層、すべて任意:
@@ -325,9 +359,13 @@ configure.sh                                        # 対話式レーンメニ
 ## 🎭 モード
 
 - **advise(デフォルト)** — 読み取り専用ワーカー。Codex は read-only
-  サンドボックス、Claude は Read/Glob/Grep のみ、Grok は plan モード。
+  サンドボックス、Claude は Read/Glob/Grep のみ、Grok は plan モード、
+  Kimi と OpenCode はそれぞれの読み取り専用 plan モードに固定、
+  OpenRouter は設計上 advise 専用(純推論)。
 - **work** — 指定した `--workdir` 内でのみファイル編集可。Codex は
   workspace-write、Claude は編集自動承認、Gemini は accept-edits モード。
+  `openrouter` vendor は work モードを明確に拒否します——編集はエージェント型
+  CLI ベンダーへ。
 
 ## 🔒 安全機構
 
@@ -381,11 +419,14 @@ configure.sh                                        # 対話式レーンメニ
 
 ## 🌱 ステータス
 
-v0.5.1 は Git 管理外でも Codex `work` を利用可能に保ち、process group の
-クリーンアップで停止を制限し、公開バージョン情報を同期します。v0.5.0 の
-インストーラー、ライフサイクル、ジョブストア、期限、診断、リリース CI の
-強化も維持します。Grok/Antigravity のコマンドシェル挙動は CLI バージョンで
-変わる可能性があります。issue と PR を歓迎します。
+v0.8.3 は 8 つのディスパッチベンダーを備えます——4 つのハーネスネイティブ
+(codex、claude、grok、gemini)、3 つの集約/オーバーフロー CLI(kimi、qwen、
+opencode)、そして CLI 不要の `openrouter` 直接 API ベンダー——すべて統一
+runner 契約と契約テスト付き。Claude Code の `SessionStart` 自動リマインダー
+も同梱。kimi、qwen、opencode、openrouter の runner はフェイクバイナリで
+契約テスト済みです。実モデルでの報告を歓迎します。Grok/Antigravity の
+コマンドシェル挙動は CLI バージョンで変わる可能性があります。issue と PR を
+歓迎します。
 
 プロジェクト文書：[コントリビューション](CONTRIBUTING.md) ·
 [セキュリティ](SECURITY.md) · [変更履歴](CHANGELOG.md)

package/README.ko.md

@@ -5,8 +5,9 @@
 ### 라우팅 테이블 하나로, 모든 하네스를.
 
 *메인 루프가 더 이상 어떤 모델을 쓸지 고민하지 않습니다.*<br/>
-모든 서브태스크를 그 일을 정말 잘하는 모델에게——<br/>
-**Claude Code · Codex · Grok Build · Antigravity** 를 가로질러, 이미 내고 있는 구독 그대로.
+**Claude Code · Codex · Grok Build · Antigravity** 어디서 운전하든, 모든 서브태스크를<br/>
+그 일을 정말 잘하는 모델에게——Codex, Claude, Grok, Gemini, Kimi, Qwen, OpenCode,<br/>
+그리고 OpenRouter 를 통한 모든 호스팅 모델까지——이미 내고 있는 구독 그대로, 또는 API 키 하나로.
 
 <img src="docs/hero.ko.png" alt="omnilane 이 각 서브태스크를 Claude Code·Codex·Grok·Antigravity 중 가장 잘하는 모델로 보냅니다" width="820"/>
 
@@ -20,6 +21,14 @@
 
 ---
 
+## v0.8.3 새 기능
+
+- **MCP 서버** — `omnilane mcp` 는 의존성 없는 stdio MCP 서버를 시작하여,
+  MCP 지원 호스트(Claude Code, Codex, Gemini CLI, Cursor, OpenCode 등)가
+  스킬 설치 없이 omnilane 을 발견하고 호출할 수 있습니다: 도구는 `route`,
+  `jobs_status`, `jobs_result`, `list_lanes`. `route` 는 읽기 전용 advise 가
+  기본값이며, work 모드는 명시적 workdir 이 필요합니다.
+
 ## v0.8.2 새 기능
 
 - **`openrouter` vendor** — `curl`과 `OPENROUTER_API_KEY`만으로
@@ -114,8 +123,9 @@ omnilane ui start     # 선택: 브라우저에서 잡을 실시간 확인
 ## 🧭 동작 방식
 
 omnilane 은 **어떤** agentic CLI 든 메인 루프가 서브태스크를 레인으로 분류하고,
-각 레인을 그 작업에 가장 강한 벤더 CLI 로 헤드리스 디스패치하게 해 줍니다.
-기존 구독 로그인을 그대로 사용합니다:
+각 레인을 그 작업에 가장 강한 벤더로 헤드리스 디스패치하게 해 줍니다.
+기존 구독 로그인을 그대로 사용합니다(`openrouter` vendor 는 예외: CLI 없이
+API 키 하나로 직접 연결):
 
 ```mermaid
 flowchart LR
@@ -240,8 +250,10 @@ omnilane ui stop     # 정상 중지
 
 ## 📦 설치
 
-전제: 라우팅할 벤더 CLI(`codex`, `claude`, `grok`, `agy`)가 로그인된 채
-`PATH` 에 있을 것——**가진 것만 있으면 됩니다**, 없는 레인은 자동 강등.
+전제: 라우팅할 벤더 CLI(`codex`, `claude`, `grok`, `agy`, 선택적으로
+`kimi`, `qwen`, `opencode`)가 로그인된 채 `PATH` 에 있을 것——**가진 것만
+있으면 됩니다**, 없는 레인은 자동 강등. `openrouter` vendor 는 예외로 CLI 가
+필요 없습니다——`curl` 과 환경 변수의 `OPENROUTER_API_KEY` 만 있으면 됩니다.
 
 가장 빠른 방법: `./install.sh` — 로컬 CLI 를 감지해 스킬을 연결하고, 나머지
 플러그인 명령을 안내하며, 실효 라우팅을 출력한 뒤 대화형 설정 메뉴를
@@ -265,6 +277,27 @@ omnilane ui stop     # 정상 중지
 - **Antigravity**: `agy plugin install <이 저장소>`(먼저
   `agy plugin validate` 로 확인)
 
+### MCP 서버
+
+`omnilane mcp` 는 의존성 없이 로컬에서 실행되는 MCP stdio 서버를 시작하여,
+MCP 지원 호스트가 스킬 설치나 라우팅 리마인더 없이 omnilane 을 발견하고
+호출할 수 있게 합니다. 호스트 설정에서 설치된 CLI 를 지정하면 됩니다:
+
+```json
+{
+  "mcpServers": {
+    "omnilane": {
+      "command": "omnilane",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+서버는 `route`, `jobs_status`, `jobs_result`, `list_lanes` 를 제공합니다.
+`route` 의 기본값은 읽기 전용 `advise` 모드이며, `work` 를 선택한 호출은
+명시적 `workdir` 을 함께 제공해야 합니다.
+
 ## ⚙️ 사용자 설정
 
 세 계층, 모두 선택 사항:
@@ -318,9 +351,12 @@ CLI 를 사용할 수 없음, `5` 1라운드 성공 투표자 부족, `6` 2라
 ## 🎭 모드
 
 - **advise(기본)** — 읽기 전용 워커. Codex 는 read-only 샌드박스,
-  Claude 는 Read/Glob/Grep 만, Grok 은 plan 모드.
+  Claude 는 Read/Glob/Grep 만, Grok 은 plan 모드, Kimi 와 OpenCode 는 각자의
+  읽기 전용 plan 모드 고정, OpenRouter 는 설계상 advise 전용(순수 추론).
 - **work** — 지정한 `--workdir` 안에서만 파일 수정 허용. Codex 는
   workspace-write, Claude 는 편집 자동 승인, Gemini 는 accept-edits 모드.
+  `openrouter` vendor 는 work 모드를 명확한 오류로 거부합니다——파일 편집은
+  에이전트형 CLI 벤더로 보내세요.
 
 ## 🔒 안전 장치
 
@@ -371,11 +407,13 @@ CLI 를 사용할 수 없음, `5` 1라운드 성공 투표자 부족, `6` 2라
 
 ## 🌱 상태
 
-v0.5.1 은 Git 저장소 밖에서도 Codex `work` 를 사용할 수 있게 유지하고 process
-group 정리로 멈춤을 제한하며 모든 공개 버전 정보를 동기화합니다. v0.5.0 의 설치
-프로그램, 디스패치 수명주기, 잡 저장소, 전체 기한, 진단, 릴리스 CI 강화도 그대로
-유지합니다. Grok/Antigravity 커맨드 셸 동작은 CLI 버전에 따라 달라질 수 있습니다.
-issue 와 PR 환영합니다.
+v0.8.3 는 8개의 디스패치 벤더를 갖춥니다——4개의 하네스 네이티브(codex,
+claude, grok, gemini), 3개의 집합/오버플로 CLI(kimi, qwen, opencode), 그리고
+CLI 가 필요 없는 `openrouter` 직접 API 벤더——모두 통일 runner 계약과 계약
+테스트를 갖추었고, Claude Code `SessionStart` 자동 리마인더도 포함합니다.
+kimi, qwen, opencode, openrouter 의 runner 는 페이크 바이너리로 계약 테스트를
+마쳤습니다. 실제 모델 사용 보고를 환영합니다. Grok/Antigravity 커맨드 셸
+동작은 CLI 버전에 따라 달라질 수 있습니다. issue 와 PR 환영합니다.
 
 프로젝트 문서: [기여 가이드](CONTRIBUTING.md) · [보안 정책](SECURITY.md) ·
 [변경 기록](CHANGELOG.md)

package/README.md

@@ -5,8 +5,9 @@
 ### One routing table, every harness.
 
 *Your main loop stops guessing which model to use.*<br/>
-Every subtask goes to the model that is actually best at it — across<br/>
-**Claude Code · Codex · Grok Build · Antigravity**, on the subscriptions you already pay for.
+Drive it from **Claude Code · Codex · Grok Build · Antigravity**, and every subtask goes<br/>
+to the model that is actually best at it — Codex, Claude, Grok, Gemini, Kimi, Qwen, OpenCode,<br/>
+or any hosted model via OpenRouter — on the subscriptions you already pay for, or a single API key.
 
 <img src="docs/hero.png" alt="omnilane routes each subtask to the best model across Claude Code, Codex, Grok and Antigravity" width="820"/>
 
@@ -20,6 +21,14 @@ Every subtask goes to the model that is actually best at it — across<br/>
 
 ---
 
+## What's new in v0.8.3
+
+- **MCP server** — `omnilane mcp` starts a zero-dependency stdio MCP server,
+  so any MCP-capable host (Claude Code, Codex, Gemini CLI, Cursor, OpenCode…)
+  can discover and call omnilane without installing the skill: tools `route`,
+  `jobs_status`, `jobs_result`, and `list_lanes`. `route` defaults to
+  read-only advise mode; work mode requires an explicit workdir.
+
 ## What's new in v0.8.2
 
 - **`openrouter` vendor** — dispatch straight to the OpenRouter API with
@@ -115,8 +124,9 @@ omnilane ui start     # optional: watch jobs live in your browser
 ## 🧭 How it works
 
 omnilane lets the main loop of **any** agentic CLI classify subtasks into
-lanes and dispatch each lane to the best vendor's CLI — headlessly, using
-your existing subscription logins:
+lanes and dispatch each lane to the best vendor — headlessly, using your
+existing subscription logins (or, for the `openrouter` vendor, a direct API
+key with no extra CLI at all):
 
 ```mermaid
 flowchart LR
@@ -244,8 +254,10 @@ Core routing does not need Python; only this UI requires Python 3.9 or newer.
 ## 📦 Install
 
 Requirements: the vendor CLIs you want to route to, logged in (`codex`,
-`claude`, `grok`, `agy`) and on `PATH` — install only the ones you have; the
-rest of the table degrades automatically.
+`claude`, `grok`, `agy`, and optionally `kimi`, `qwen`, `opencode`) and on
+`PATH` — install only the ones you have; the rest of the table degrades
+automatically. The `openrouter` vendor is the exception: it needs no CLI,
+only `curl` and an `OPENROUTER_API_KEY` in your environment.
 
 Quickest: `./install.sh` — symlinks the skill for the CLIs it finds, prints
 the plugin commands for the rest, shows your effective routing, and offers the
@@ -272,6 +284,27 @@ Rollback the installer-owned links and marked reminders with
 - **Antigravity**: `agy plugin install <this repo>` (check first with
   `agy plugin validate <this repo>`)
 
+### MCP server
+
+`omnilane mcp` starts a zero-dependency, local MCP stdio server so any
+MCP-capable host can discover and call omnilane without installing the skill or
+adding a routing reminder. Configure the host to launch the installed CLI:
+
+```json
+{
+  "mcpServers": {
+    "omnilane": {
+      "command": "omnilane",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+The server exposes `route`, `jobs_status`, `jobs_result`, and `list_lanes`.
+`route` defaults to read-only `advise` mode. Calls that select `work` must also
+provide an explicit `workdir`.
+
 ## ⚙️ Configure
 
 Three layers, all optional:
@@ -343,11 +376,13 @@ code passes through.
 ## 🎭 Modes
 
 - **advise** (default) — read-only worker. Codex runs in a read-only sandbox;
-  Claude gets only Read/Glob/Grep; Grok runs in plan mode. Use for reviews,
-  questions, second opinions.
+  Claude gets only Read/Glob/Grep; Grok runs in plan mode; Kimi and OpenCode
+  pin their read-only plan modes; OpenRouter is advise-only by design (pure
+  inference). Use for reviews, questions, second opinions.
 - **work** — the worker may edit files, only inside the `--workdir` you name.
   Codex gets a workspace-write sandbox; Claude auto-accepts edits; Gemini runs
-  in accept-edits mode.
+  in accept-edits mode. The `openrouter` vendor refuses work mode with a clear
+  error — route edits to an agentic CLI vendor instead.
 
 ## 🔒 Safety rails
 
@@ -404,11 +439,13 @@ configurator and `routing.local.yaml` exist so you can disagree.
 
 ## 🌱 Status
 
-v0.5.1 keeps Codex `work` usable outside Git while bounding stalls with
-process-group cleanup, and synchronizes every public version surface. It builds
-on v0.5.0's installer, lifecycle, job-store, deadline, diagnostics, and release
-CI hardening. Grok/Antigravity command-shell behavior may still vary across CLI
-versions. Issues and PRs welcome.
+v0.8.3 spans eight dispatch vendors — four harness natives (codex, claude,
+grok, gemini), three aggregator/overflow CLIs (kimi, qwen, opencode), and the
+CLI-free `openrouter` direct-API vendor — on the uniform runner contract with
+contract tests, plus the Claude Code `SessionStart` auto-reminder. kimi, qwen,
+opencode, and openrouter runners are contract-tested against fake binaries;
+real-model reports welcome. Grok/Antigravity command-shell behavior may still
+vary across CLI versions. Issues and PRs welcome.
 
 Project policies: [Contributing](CONTRIBUTING.md) · [Security](SECURITY.md) ·
 [Changelog](CHANGELOG.md)

package/README.zh-CN.md

@@ -5,8 +5,9 @@
 ### 一张路由表,四个执行框架通用。
 
 *让主循环不再猜要用哪个模型。*<br/>
-每个子任务都派给真正最擅长它的模型——横跨<br/>
-**Claude Code · Codex · Grok Build · Antigravity**,直接用你已经在付的订阅。
+从 **Claude Code · Codex · Grok Build · Antigravity** 任一框架驾驶,每个子任务都派给<br/>
+真正最擅长它的模型——Codex、Claude、Grok、Gemini、Kimi、Qwen、OpenCode,<br/>
+或经 OpenRouter 直达任何托管模型——用你已经在付的订阅,或一把 API 密钥。
 
 <img src="docs/hero.zh-CN.png" alt="omnilane 把每个子任务派给 Claude Code、Codex、Grok、Antigravity 中最擅长的模型" width="820"/>
 
@@ -20,6 +21,14 @@
 
 ---
 
+## v0.8.3 新功能
+
+- **MCP server** — `omnilane mcp` 启动零依赖的 stdio MCP server,任何支持
+  MCP 的宿主(Claude Code、Codex、Gemini CLI、Cursor、OpenCode……)无需安装
+  skill 即可发现并调用 omnilane:提供 `route`、`jobs_status`、`jobs_result`、
+  `list_lanes` 四个工具。`route` 默认只读 advise 模式;work 模式必须明确
+  指定 workdir。
+
 ## v0.8.2 新功能
 
 - **`openrouter` vendor** — 只需 `curl` 加一个 `OPENROUTER_API_KEY`,
@@ -101,7 +110,8 @@ omnilane ui start     # 可选:在浏览器实时查看派发
 ## 🧭 工作原理
 
 omnilane 让**任何**一个 agentic CLI 的主循环把子任务分类到通道(lane),
-再以无头方式把每条通道派发给该项工作最强的厂商 CLI,直接沿用你已有的订阅登录:
+再以无头方式把每条通道派发给该项工作最强的厂商——直接沿用你已有的订阅登录
+(`openrouter` vendor 例外:免装任何 CLI,一把 API 密钥直连):
 
 ```mermaid
 flowchart LR
@@ -215,8 +225,10 @@ Esc。服务器发送事件(SSE)会实时更新，又不会重建当前聚焦的
 
 ## 📦 安装
 
-前置需求:想路由到的厂商 CLI(`codex`、`claude`、`grok`、`agy`)已登录且在
-`PATH` 上——**有几家装几家就好**,缺的通道会自动降级。
+前置需求:想路由到的厂商 CLI(`codex`、`claude`、`grok`、`agy`,另可选
+`kimi`、`qwen`、`opencode`)已登录且在 `PATH` 上——**有几家装几家就好**,
+缺的通道会自动降级。`openrouter` vendor 是例外:不需要任何 CLI,只要
+`curl` 和环境变量里的 `OPENROUTER_API_KEY`。
 
 最快:`./install.sh` — 自动检测本机的 CLI、接好技能、列出其余的插件安装命令、
 打印这台机器的生效路由表,最后询问是否进入交互设置菜单(`--uninstall` 可逆)。
@@ -238,6 +250,27 @@ Esc。服务器发送事件(SSE)会实时更新，又不会重建当前聚焦的
 - **Antigravity**:`agy plugin install <本仓库路径>`(先用
   `agy plugin validate` 检查)
 
+### MCP server
+
+`omnilane mcp` 会启动零依赖、跑在本机的 MCP stdio server,让任何支持 MCP
+的宿主无需安装 skill、也不用加路由提醒,即可发现并调用 omnilane。在宿主
+配置里指向已安装的 CLI 即可:
+
+```json
+{
+  "mcpServers": {
+    "omnilane": {
+      "command": "omnilane",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+Server 提供 `route`、`jobs_status`、`jobs_result`、`list_lanes` 四个工具。
+`route` 默认只读 `advise` 模式;选择 `work` 的调用必须同时提供明确的
+`workdir`。
+
 ## ⚙️ 自定义设置
 
 三层,全部可选:
@@ -291,9 +324,11 @@ configure.sh                                        # 交互通道菜单
 ## 🎭 模式
 
 - **advise(默认)** — 只读工作端。Codex 跑只读沙箱;Claude 只给
-  Read/Glob/Grep;Grok 跑 plan 模式。适合审查、提问、第二意见。
+  Read/Glob/Grep;Grok 跑 plan 模式;Kimi 与 OpenCode 锁各自的只读
+  plan 模式;OpenRouter 天生只做 advise(纯推理)。适合审查、提问、第二意见。
 - **work** — 允许改文件,仅限你指定的 `--workdir`。Codex 给
   workspace-write 沙箱;Claude 自动接受编辑;Gemini 跑 accept-edits 模式。
+  `openrouter` vendor 会明确拒绝 work 模式——改文件请走代理式 CLI vendor。
 
 ## 🔒 内置安全机制
 
@@ -345,10 +380,12 @@ configure.sh                                        # 交互通道菜单
 
 ## 🌱 状态
 
-v0.5.1 让 Codex `work` 在非 Git 目录仍可使用，同时以进程组清理限制卡死，
-并同步所有公开版本来源。它延续 v0.5.0 对安装器、派发生命周期、作业存储、
-整体截止时间、诊断和发布 CI 的强化。Grok/Antigravity 命令壳行为仍可能随
-CLI 版本变动。欢迎提交 issue 与 PR。
+v0.8.3 共有八个派发 vendor——四个框架原生(codex、claude、grok、gemini)、
+三个聚合/溢流 CLI(kimi、qwen、opencode),加上免 CLI 的 `openrouter` 直连
+API vendor——全部走统一 runner 契约并附 contract 测试,另有 Claude Code
+`SessionStart` 自动提醒。kimi、qwen、opencode、openrouter 的 runner 以假
+可执行文件做过契约测试;欢迎反馈真实模型使用经验。Grok/Antigravity 命令壳
+行为仍可能随 CLI 版本变动。欢迎提交 issue 与 PR。
 
 项目文档：[贡献指南](CONTRIBUTING.md) · [安全政策](SECURITY.md) ·
 [变更记录](CHANGELOG.md)

package/README.zh-TW.md

@@ -5,8 +5,9 @@
 ### 一張路由表,四個執行框架通用。
 
 *讓主迴圈不再猜要用哪個模型。*<br/>
-每個子任務都派給真正最擅長它的模型——橫跨<br/>
-**Claude Code · Codex · Grok Build · Antigravity**,直接用你已經在付的訂閱。
+從 **Claude Code · Codex · Grok Build · Antigravity** 任一框架開車,每個子任務都派給<br/>
+真正最擅長它的模型——Codex、Claude、Grok、Gemini、Kimi、Qwen、OpenCode,<br/>
+或經 OpenRouter 直達任何託管模型——用你已經在付的訂閱,或一把 API 金鑰。
 
 <img src="docs/hero.zh-TW.png" alt="omnilane 把每個子任務派給 Claude Code、Codex、Grok、Antigravity 中最擅長的模型" width="820"/>
 
@@ -20,6 +21,14 @@
 
 ---
 
+## v0.8.3 新功能
+
+- **MCP server** — `omnilane mcp` 啟動零依賴的 stdio MCP server,任何支援
+  MCP 的宿主(Claude Code、Codex、Gemini CLI、Cursor、OpenCode……)不必安裝
+  skill 就能發現並呼叫 omnilane:提供 `route`、`jobs_status`、`jobs_result`、
+  `list_lanes` 四個工具。`route` 預設唯讀 advise 模式;work 模式必須明確
+  指定 workdir。
+
 ## v0.8.2 新功能
 
 - **`openrouter` vendor** — 只要 `curl` 加一把 `OPENROUTER_API_KEY`,
@@ -101,7 +110,8 @@ omnilane ui start     # 選配:在瀏覽器即時看派工
 ## 🧭 運作方式
 
 omnilane 讓**任何**一個 agentic CLI 的主迴圈把子任務分類到通道(lane),
-再以無頭方式把每條通道派工給該項工作最強的廠商 CLI,直接沿用你既有的訂閱登入:
+再以無頭方式把每條通道派工給該項工作最強的廠商——直接沿用你既有的訂閱登入
+(`openrouter` vendor 例外:免裝任何 CLI,一把 API 金鑰直連):
 
 ```mermaid
 flowchart LR
@@ -215,8 +225,10 @@ omnilane ui stop     # 正常停止
 
 ## 📦 安裝
 
-前置需求:想路由到的廠商 CLI(`codex`、`claude`、`grok`、`agy`)已登入且在
-`PATH` 上——**有幾家裝幾家就好**,缺的通道會自動降級。
+前置需求:想路由到的廠商 CLI(`codex`、`claude`、`grok`、`agy`,另可選
+`kimi`、`qwen`、`opencode`)已登入且在 `PATH` 上——**有幾家裝幾家就好**,
+缺的通道會自動降級。`openrouter` vendor 是例外:不需要任何 CLI,只要
+`curl` 和環境變數裡的 `OPENROUTER_API_KEY`。
 
 最快:`./install.sh` — 自動偵測本機的 CLI、接好技能、列出其餘的外掛安裝指令、
 印出這台機器的生效路由表,最後問你要不要進入互動設定選單(`--uninstall` 可逆)。
@@ -239,6 +251,27 @@ omnilane ui stop     # 正常停止
 - **Antigravity**:`agy plugin install <本 repo 路徑>`(先用
   `agy plugin validate` 檢查)
 
+### MCP server
+
+`omnilane mcp` 會啟動零依賴、跑在本機的 MCP stdio server,讓任何支援 MCP
+的宿主不必安裝 skill、也不用加路由提醒,就能發現並呼叫 omnilane。在宿主
+設定裡指向已安裝的 CLI 即可:
+
+```json
+{
+  "mcpServers": {
+    "omnilane": {
+      "command": "omnilane",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+Server 提供 `route`、`jobs_status`、`jobs_result`、`list_lanes` 四個工具。
+`route` 預設唯讀 `advise` 模式;選 `work` 的呼叫必須同時提供明確的
+`workdir`。
+
 ## ⚙️ 自訂設定
 
 三層,全部選用:
@@ -304,9 +337,11 @@ codex/claude/grok/gemini 自選 1-4 個評審。開了之後,同一個問題丟
 ## 🎭 模式
 
 - **advise(預設)** — 唯讀工作端。Codex 跑唯讀沙箱;Claude 只給
-  Read/Glob/Grep;Grok 跑 plan 模式。適合審查、提問、第二意見。
+  Read/Glob/Grep;Grok 跑 plan 模式;Kimi 與 OpenCode 鎖各自的唯讀
+  plan 模式;OpenRouter 天生只做 advise(純推論)。適合審查、提問、第二意見。
 - **work** — 允許改檔案,僅限你指定的 `--workdir`。Codex 給
   workspace-write 沙箱;Claude 自動接受編輯;Gemini 跑 accept-edits 模式。
+  `openrouter` vendor 會明確拒絕 work 模式——改檔請走代理式 CLI vendor。
 
 ## 🔒 內建安全機制
 
@@ -355,10 +390,12 @@ codex/claude/grok/gemini 自選 1-4 個評審。開了之後,同一個問題丟
 
 ## 🌱 狀態
 
-v0.5.1 讓 Codex `work` 在非 Git 目錄仍可使用，同時以程序群組清理限制卡死，
-並同步所有公開版本來源。它延續 v0.5.0 對安裝器、派工生命週期、job 儲存、
-整體截止時間、診斷與發布 CI 的強化。Grok/Antigravity 指令殼行為仍可能隨
-CLI 版本變動。歡迎回報 issue 與 PR。
+v0.8.3 共有八個派工 vendor——四個框架原生(codex、claude、grok、gemini)、
+三個聚合/溢流 CLI(kimi、qwen、opencode),加上免 CLI 的 `openrouter` 直連
+API vendor——全部走統一 runner 契約並附 contract 測試,另有 Claude Code
+`SessionStart` 自動提醒。kimi、qwen、opencode、openrouter 的 runner 以假
+執行檔做過契約測試;歡迎回報真實模型使用經驗。Grok/Antigravity 指令殼行為
+仍可能隨 CLI 版本變動。歡迎回報 issue 與 PR。
 
 專案文件：[貢獻指南](CONTRIBUTING.md) · [安全政策](SECURITY.md) ·
 [變更紀錄](CHANGELOG.md)

package/VERSION

@@ -1 +1 @@
-0.8.2
+0.8.3

package/bin/omnilane

@@ -31,6 +31,13 @@ case "$cmd" in
   list)      exec bash "$REPO/scripts/dispatch.sh" --list ;;
   route|dispatch) exec bash "$REPO/scripts/dispatch.sh" "$@" ;;
   jobs)      exec bash "$REPO/scripts/jobs.sh" "$@" ;;
+  mcp)
+    command -v node >/dev/null 2>&1 || {
+      echo "omnilane: mcp requires Node.js on PATH" >&2
+      exit 1
+    }
+    exec node "$REPO/bin/omnilane-mcp" "$@"
+    ;;
   completion)
     [[ $# -eq 1 ]] || {
       echo "usage: omnilane completion bash|zsh" >&2
@@ -61,6 +68,7 @@ omnilane — one routing table, every harness
   omnilane route [--vendor V] [flags] LANE "TASK"
                                         dispatch or consult a model
   omnilane jobs  [--json] COMMAND [ARGS]  list, status, result, stats, wait, or audit
+  omnilane mcp                          start the MCP stdio server
   omnilane completion bash|zsh           print a shell completion script
   omnilane release-audit [flags]          offline, read-only release gate
   omnilane doctor [--json]              read-only local health report

package/bin/omnilane-mcp

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const DISPATCH_SCRIPT = path.join(ROOT, 'scripts', 'dispatch.sh');
+const JOBS_SCRIPT = path.join(ROOT, 'scripts', 'jobs.sh');
+const LATEST_PROTOCOL_VERSION = '2025-11-25';
+const SUPPORTED_PROTOCOL_VERSIONS = new Set([
+  '2025-11-25',
+  '2025-06-18',
+  '2025-03-26',
+  '2024-11-05',
+]);
+const MAX_COLLECTED_BYTES = 1024 * 1024;
+const TRUNCATION_MARKER = `[omnilane-mcp: output truncated after ${MAX_COLLECTED_BYTES} bytes]`;
+const LANE_PATTERN = /^[a-z][a-z0-9-]*$/;
+const JOB_ID_PATTERN = /^[0-9]{8}-[0-9]{6}-[0-9]+-[0-9]+$/;
+const OWN = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+
+let serverVersion;
+try {
+  serverVersion = fs.readFileSync(path.join(ROOT, 'VERSION'), 'utf8').trim();
+  if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.test(serverVersion)) {
+    throw new Error('invalid VERSION file');
+  }
+} catch (error) {
+  process.stderr.write(`omnilane-mcp: ${error.message}\n`);
+  process.exit(1);
+}
+
+const tools = [
+  {
+    name: 'route',
+    description: 'Route a task through omnilane. Defaults to read-only advise mode; work mode requires an explicit workdir.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lane: {
+          type: 'string',
+          pattern: '^[a-z][a-z0-9-]*$',
+          description: 'Configured omnilane lane name.',
+        },
+        task: { type: 'string', description: 'Task text sent to the selected lane.' },
+        mode: {
+          type: 'string',
+          enum: ['advise', 'work'],
+          default: 'advise',
+          description: 'Read-only advice or write-enabled work.',
+        },
+        workdir: {
+          type: 'string',
+          minLength: 1,
+          description: 'Working directory. Required when mode is work.',
+        },
+        vendor: { type: 'string', description: 'Optional configured vendor override.' },
+        model: { type: 'string', description: 'Optional routed model override.' },
+        effort: { type: 'string', description: 'Optional routed effort override.' },
+        background: {
+          type: 'boolean',
+          default: false,
+          description: 'Run as an omnilane background job and return its job ID.',
+        },
+        timeout: {
+          type: 'integer',
+          minimum: 1,
+          description: 'Per-call timeout in seconds forwarded to dispatch.sh.',
+        },
+      },
+      required: ['lane', 'task'],
+      additionalProperties: false,
+      allOf: [
+        {
+          if: { properties: { mode: { const: 'work' } }, required: ['mode'] },
+          then: { required: ['workdir'] },
+        },
+      ],
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
+  },
+  {
+    name: 'jobs_status',
+    description: 'Read the current status of one omnilane background job.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          pattern: '^[0-9]{8}-[0-9]{6}-[0-9]+-[0-9]+$',
+          description: 'Omnilane background job ID.',
+        },
+      },
+      required: ['id'],
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'jobs_result',
+    description: 'Read the result of one completed omnilane background job.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          pattern: '^[0-9]{8}-[0-9]{6}-[0-9]+-[0-9]+$',
+          description: 'Omnilane background job ID.',
+        },
+      },
+      required: ['id'],
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'list_lanes',
+    description: 'List the effective omnilane routing table and available fallback selection.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+];
+
+class RpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+}
+
+const activeChildren = new Set();
+let shuttingDown = false;
+let outputClosed = false;
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function textResult(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function toolError(message) {
+  return {
+    content: [{ type: 'text', text: `Error: ${message}` }],
+    isError: true,
+  };
+}
+
+function writeMessage(message) {
+  if (outputClosed) return;
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+function writeResult(id, result) {
+  writeMessage({ jsonrpc: '2.0', id, result });
+}
+
+function writeError(id, code, message, data) {
+  const error = { code, message };
+  if (data !== undefined) error.data = data;
+  writeMessage({ jsonrpc: '2.0', id, error });
+}
+
+function validationError(args, allowedKeys) {
+  if (!isObject(args)) return 'arguments must be an object';
+  const unexpected = Object.keys(args).filter((key) => !allowedKeys.includes(key));
+  if (unexpected.length > 0) return `unexpected argument: ${unexpected[0]}`;
+  return null;
+}
+
+function validateRouteArguments(args) {
+  let error = validationError(args, [
+    'lane', 'task', 'mode', 'workdir', 'vendor', 'model', 'effort',
+    'background', 'timeout',
+  ]);
+  if (error) return error;
+  if (typeof args.lane !== 'string' || !LANE_PATTERN.test(args.lane)) {
+    return 'lane must match ^[a-z][a-z0-9-]*$';
+  }
+  if (typeof args.task !== 'string') return 'task must be a string';
+  if (OWN(args, 'mode') && args.mode !== 'advise' && args.mode !== 'work') {
+    return 'mode must be advise or work';
+  }
+  if (OWN(args, 'workdir') && (typeof args.workdir !== 'string' || args.workdir.length === 0)) {
+    return 'workdir must be a non-empty string';
+  }
+  for (const key of ['vendor', 'model', 'effort']) {
+    if (OWN(args, key) && typeof args[key] !== 'string') return `${key} must be a string`;
+  }
+  if (OWN(args, 'background') && typeof args.background !== 'boolean') {
+    return 'background must be a boolean';
+  }
+  if (OWN(args, 'timeout') && (!Number.isInteger(args.timeout) || args.timeout < 1)) {
+    return 'timeout must be a positive integer';
+  }
+  if (args.mode === 'work' && !OWN(args, 'workdir')) {
+    return 'work mode requires an explicit workdir';
+  }
+  return null;
+}
+
+function validateJobArguments(args) {
+  const error = validationError(args, ['id']);
+  if (error) return error;
+  if (typeof args.id !== 'string' || !JOB_ID_PATTERN.test(args.id)) {
+    return 'id must match ^[0-9]{8}-[0-9]{6}-[0-9]+-[0-9]+$';
+  }
+  return null;
+}
+
+function createCapture() {
+  const chunks = { stdout: [], stderr: [] };
+  let collected = 0;
+  let truncated = false;
+
+  function add(stream, chunk) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const remaining = MAX_COLLECTED_BYTES - collected;
+    if (remaining > 0) {
+      chunks[stream].push(buffer.subarray(0, remaining));
+      collected += Math.min(buffer.length, remaining);
+    }
+    if (buffer.length > remaining) truncated = true;
+  }
+
+  function read(stream) {
+    return Buffer.concat(chunks[stream]).toString('utf8');
+  }
+
+  return {
+    add,
+    stdout: () => read('stdout'),
+    stderr: () => read('stderr'),
+    wasTruncated: () => truncated,
+  };
+}
+
+function appendTruncationMarker(text, truncated) {
+  if (!truncated) return text;
+  const separator = text.length === 0 || text.endsWith('\n') ? '' : '\n';
+  return `${text}${separator}${TRUNCATION_MARKER}`;
+}
+
+function runScript(script, args) {
+  return new Promise((resolve) => {
+    const capture = createCapture();
+    let child;
+    let settled = false;
+
+    try {
+      child = spawn('bash', [script].concat(args), {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      resolve({ spawnError: error });
+      return;
+    }
+
+    activeChildren.add(child);
+    child.stdout.on('data', (chunk) => capture.add('stdout', chunk));
+    child.stderr.on('data', (chunk) => capture.add('stderr', chunk));
+
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      activeChildren.delete(child);
+      resolve(Object.assign(result, {
+        stdout: capture.stdout(),
+        stderr: capture.stderr(),
+        truncated: capture.wasTruncated(),
+      }));
+      if (shuttingDown && activeChildren.size === 0) {
+        setImmediate(() => process.exit(0));
+      }
+    }
+
+    child.once('error', (error) => finish({ spawnError: error }));
+    child.once('close', (code, signal) => finish({ code, signal }));
+  });
+}
+
+function processFailure(label, result) {
+  if (result.spawnError) {
+    return toolError(`${label} could not start: ${result.spawnError.message}`);
+  }
+  const parts = [];
+  if (result.stderr) parts.push(result.stderr);
+  if (result.stdout) parts.push(result.stdout);
+  let detail = parts.join(parts.length > 1 ? '\n' : '');
+  detail = appendTruncationMarker(detail, result.truncated);
+  const status = result.signal ? `signal ${result.signal}` : `exit ${result.code}`;
+  return toolError(`${label} failed with ${status}${detail ? `:\n${detail}` : ''}`);
+}
+
+async function runToolScript(label, script, args) {
+  const result = await runScript(script, args);
+  if (result.spawnError || result.code !== 0) return processFailure(label, result);
+  return textResult(appendTruncationMarker(result.stdout, result.truncated));
+}
+
+async function callRoute(args) {
+  const error = validateRouteArguments(args);
+  if (error) return toolError(error);
+
+  const mode = OWN(args, 'mode') ? args.mode : 'advise';
+  const argv = ['--mode', mode];
+  for (const key of ['workdir', 'vendor', 'model', 'effort', 'timeout']) {
+    if (OWN(args, key)) argv.push(`--${key}`, String(args[key]));
+  }
+  if (args.background === true) argv.push('--background');
+  argv.push(args.lane, args.task);
+
+  const result = await runScript(DISPATCH_SCRIPT, argv);
+  if (result.spawnError || result.code !== 0) return processFailure('route', result);
+  const stdout = appendTruncationMarker(result.stdout, result.truncated);
+  if (args.background === true) {
+    const jobId = stdout.split(/\r?\n/).find((line) => JOB_ID_PATTERN.test(line));
+    if (!jobId) return toolError('background route did not return a valid job ID');
+    return textResult(jobId);
+  }
+  return textResult(stdout);
+}
+
+async function callTool(name, args) {
+  if (name === 'route') return callRoute(args);
+  if (name === 'list_lanes') {
+    const error = validationError(args, []);
+    if (error) return toolError(error);
+    return runToolScript('list_lanes', DISPATCH_SCRIPT, ['--list']);
+  }
+  if (name === 'jobs_status' || name === 'jobs_result') {
+    const error = validateJobArguments(args);
+    if (error) return toolError(error);
+    const command = name === 'jobs_status' ? 'status' : 'result';
+    return runToolScript(name, JOBS_SCRIPT, [command, args.id]);
+  }
+  throw new RpcError(-32602, `Unknown tool: ${name}`);
+}
+
+function initialize(params) {
+  if (!isObject(params) || typeof params.protocolVersion !== 'string') {
+    throw new RpcError(-32602, 'initialize requires a protocolVersion string');
+  }
+  const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(params.protocolVersion)
+    ? params.protocolVersion
+    : LATEST_PROTOCOL_VERSION;
+  return {
+    protocolVersion,
+    capabilities: { tools: {} },
+    serverInfo: { name: 'omnilane', version: serverVersion },
+  };
+}
+
+async function handleRequest(message) {
+  switch (message.method) {
+    case 'initialize':
+      return initialize(message.params);
+    case 'tools/list':
+      if (message.params !== undefined && !isObject(message.params)) {
+        throw new RpcError(-32602, 'tools/list params must be an object');
+      }
+      return { tools };
+    case 'tools/call': {
+      if (!isObject(message.params) || typeof message.params.name !== 'string') {
+        throw new RpcError(-32602, 'tools/call requires a tool name');
+      }
+      const args = message.params.arguments === undefined ? {} : message.params.arguments;
+      return callTool(message.params.name, args);
+    }
+    default:
+      throw new RpcError(-32601, `Method not found: ${message.method}`);
+  }
+}
+
+async function processLine(line) {
+  if (line.length === 0) return;
+
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch (error) {
+    writeError(null, -32700, 'Parse error');
+    return;
+  }
+
+  const hasId = isObject(message) && OWN(message, 'id');
+  if (!isObject(message) || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+    if (hasId) writeError(message.id, -32600, 'Invalid Request');
+    return;
+  }
+  if (!hasId) return;
+
+  try {
+    writeResult(message.id, await handleRequest(message));
+  } catch (error) {
+    if (error instanceof RpcError) {
+      writeError(message.id, error.code, error.message, error.data);
+    } else {
+      process.stderr.write(`omnilane-mcp: internal error: ${error.message}\n`);
+      writeError(message.id, -32603, 'Internal error');
+    }
+  }
+}
+
+const input = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity,
+  terminal: false,
+});
+
+input.on('line', (line) => {
+  processLine(line).catch((error) => {
+    process.stderr.write(`omnilane-mcp: internal error: ${error.message}\n`);
+  });
+});
+
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  input.close();
+  for (const child of activeChildren) child.kill('SIGTERM');
+  if (activeChildren.size === 0) process.exit(0);
+  setTimeout(() => process.exit(0), 1000);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.stdout.on('error', (error) => {
+  if (error.code === 'EPIPE') {
+    outputClosed = true;
+    shutdown();
+    return;
+  }
+  process.stderr.write(`omnilane-mcp: stdout error: ${error.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnilane",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "One routing table, every harness — classify subtasks into lanes and dispatch each lane to the best vendor's agentic CLI (Codex, Claude, Gemini, Grok) using your existing subscription logins.",
   "bin": {
     "omnilane": "bin/omnilane"