omnilane 0.8.1 → 0.8.3

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,25 @@
 
 ---
 
+## 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`,
+  就能直連 OpenRouter API 派工:任何 omnilane 安裝都摸得到數百個
+  託管模型,不必再裝任何代理 CLI。僅限 advise/consult(不能改檔,
+  work 模式會明確報錯指路),模型 slug 必填,例如
+  `dispatch.sh --vendor openrouter --model anthropic/claude-sonnet-5 consult "..."`。
+- **`opencode` vendor** — 透過 OpenCode 多供應商聚合 CLI 無頭派工
+  (`opencode run`)。advise 模式鎖定內建唯讀 `plan` agent;work 模式
+  用 `--auto`。加入預設 `coding-overflow` 鏈作為最後備援。
+
 ## v0.8.1 新功能
 
 - **Claude Code 外掛開場自動載入路由提醒** — 外掛新增 `SessionStart`
@@ -90,7 +110,8 @@ omnilane ui start     # 選配:在瀏覽器即時看派工
 ## 🧭 運作方式
 
 omnilane 讓**任何**一個 agentic CLI 的主迴圈把子任務分類到通道(lane),
-再以無頭方式把每條通道派工給該項工作最強的廠商 CLI,直接沿用你既有的訂閱登入:
+再以無頭方式把每條通道派工給該項工作最強的廠商——直接沿用你既有的訂閱登入
+(`openrouter` vendor 例外:免裝任何 CLI,一把 API 金鑰直連):
 
 ```mermaid
 flowchart LR
@@ -134,7 +155,7 @@ flowchart LR
 | 📚 long-context | Gemini 3.1 Pro (High) | Claude Opus 4.8 (high) | 百萬 token 長文整合——僅限分析,不派 agentic 長鏈 |
 | ⚡ fast-agentic | Gemini 3.5 Flash (High) | GPT-5.6 Luna (high) | 快速多步驟 agentic 迴圈、多模態檢查 |
 | 📡 live-search | Grok 4.5 | —(off) | 即時 X/網路搜尋與社群脈絡 |
-| 🚰 coding-overflow | Grok 4.5 | Kimi K3 → Qwen3 Coder Plus | Codex 額度吃緊時的中量級編碼溢流道;事實性宣稱須另行查證 |
+| 🚰 coding-overflow | Grok 4.5 | Kimi K3 → Qwen3 Coder Plus → OpenCode | Codex 額度吃緊時的中量級編碼溢流道;事實性宣稱須另行查證 |
 | 🗳️ arbitrate | off(選配評審團) | — | 內建意見評審團,重大決定用——預設關閉,要用在 `routing.local.yaml` 開;每評審每輪燒一次額度 |
 
 **備選模型**是候選鏈的下一位——首選那家的廠商 CLI 沒裝時,派工就降到它。
@@ -204,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` 可逆)。
@@ -228,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`。
+
 ## ⚙️ 自訂設定
 
 三層,全部選用:
@@ -293,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。
 
 ## 🔒 內建安全機制
 
@@ -344,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.1
+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/completions/_omnilane

@@ -64,7 +64,7 @@ _omnilane() {
         '--dry-run[resolve and print the plan without side effects]' \
         '--mode[execution mode]:mode:(advise work)' \
         '--workdir[target directory]:directory:_directories' \
-        '--vendor[vendor override]:vendor:(codex claude grok gemini exec vote)' \
+        '--vendor[vendor override]:vendor:(codex claude grok gemini kimi qwen opencode openrouter exec vote)' \
         '--model[model override]:model:' \
         '--effort[reasoning effort]:effort:(low medium high xhigh max)' \
         '--timeout[per-call seconds]:seconds:' \

package/completions/omnilane.bash

@@ -64,7 +64,7 @@ _omnilane() {
       route|dispatch)
         case "$prev" in
           --mode) words="advise work" ;;
-          --vendor) words="codex claude grok gemini kimi qwen exec vote" ;;
+          --vendor) words="codex claude grok gemini kimi qwen opencode openrouter exec vote" ;;
           --effort) words="low medium high xhigh max" ;;
           --workdir)
             COMPREPLY=()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnilane",
-  "version": "0.8.1",
+  "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"

package/routing.yaml

@@ -1,6 +1,8 @@
 # omnilane — single routing table shared by every harness (CC / Codex / Grok / Antigravity)
 # Format: one lane per line ->  lane: vendor model effort [| vendor model effort | off]
-#   vendor  = codex | claude | grok | gemini
+#   vendor  = codex | claude | grok | gemini | kimi | qwen | opencode | openrouter
+#   openrouter is direct-API (needs only OPENROUTER_API_KEY + curl) and advise/consult
+#   only — it cannot edit files, so it is not in the default work-capable chains.
 #   effort  = codex reasoning effort / claude --effort / agy thinking suffix / (grok: ignored)
 #   Fallback chain: the first candidate whose vendor CLI is installed wins, so the
 #   same table degrades gracefully when you only subscribe to one or two vendors.
@@ -22,7 +24,7 @@ ui-draft:        codex gpt-5.6-sol xhigh | claude claude-opus-4-8 high  # only w
 long-context:    gemini "Gemini 3.1 Pro (High)" - | claude claude-opus-4-8 high | codex gpt-5.6-sol high  # 1M-token synthesis ONLY — never agentic loops (AA agentic 21.4)
 fast-agentic:    gemini "Gemini 3.5 Flash (High)" - | codex gpt-5.6-luna high  # speed + agentic tool loops
 live-search:     grok grok-4.5 - | off          # native X/web search lane; no real substitute
-coding-overflow: grok grok-4.5 - | kimi kimi-k3 - | qwen qwen3-coder-plus - | off  # codex-quota relief valve: mid-tier coding; verify factual claims (grok hallucination-prone). kimi/qwen model fields are CLI aliases — adjust to your login.
+coding-overflow: grok grok-4.5 - | kimi kimi-k3 - | qwen qwen3-coder-plus - | opencode - - | off  # codex-quota relief valve: mid-tier coding; verify factual claims (grok hallucination-prone). kimi/qwen model fields are CLI aliases — adjust to your login. opencode "-" model = its own configured default.
 arbitrate:       off - -                        # opinion panel is OPT-IN: it costs one call per voter per round.
                                                 # Enable: `arbitrate: vote codex,claude,grok -` (any 1-4 of codex/claude/grok/gemini)
                                                 # Debate round (each voter rebuts the others): set the effort field to 2.