omnilane 0.8.3 → 0.9.0

package/bin/omnilane-mcp

@@ -9,6 +9,7 @@ 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 DOCTOR_SCRIPT = path.join(ROOT, 'scripts', 'doctor.sh');
 const LATEST_PROTOCOL_VERSION = '2025-11-25';
 const SUPPORTED_PROTOCOL_VERSIONS = new Set([
   '2025-11-25',
@@ -146,6 +147,196 @@ const tools = [
       openWorldHint: false,
     },
   },
+  {
+    name: 'explain',
+    description: 'Explain one lane offline: every fallback candidate and the selected vendor, with no provider call and no job state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lane: {
+          type: 'string',
+          pattern: '^[a-z][a-z0-9-]*$',
+          description: 'Configured omnilane lane name.',
+        },
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human table.',
+        },
+      },
+      required: ['lane'],
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'validate',
+    description: 'Lint the effective routing table offline and report PASS/WARN/FAIL per lane, with no provider call and no job state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human report.',
+        },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'dry_run',
+    description: 'Resolve a dispatch plan (vendor, model, mode, timeouts, side-effect decision) without calling any provider or creating job state. 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 used only to resolve the plan; it is never sent to a provider.' },
+        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.' },
+        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: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'jobs_list',
+    description: 'List omnilane background jobs. Metadata only; task and result bodies stay private.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human list.',
+        },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'doctor',
+    description: 'Read-only local health report for routing, state, watchdog, and optional UI support.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human report.',
+        },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'jobs_stats',
+    description: 'Aggregate local background-job outcomes and lane/vendor distribution from bounded public metadata. Never reads task or result bodies.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        last: {
+          type: 'integer',
+          minimum: 1,
+          description: 'Limit the aggregate to the most recent N jobs.',
+        },
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human report.',
+        },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  {
+    name: 'jobs_audit',
+    description: 'Bounded read-only integrity and privacy scan of the local job store. Reports findings without printing task or result content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        last: {
+          type: 'integer',
+          minimum: 1,
+          description: 'Limit the scan to the most recent N jobs.',
+        },
+        json: {
+          type: 'boolean',
+          default: false,
+          description: 'Return the versioned JSON envelope instead of the human report.',
+        },
+      },
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
 ];
 
 class RpcError extends Error {
@@ -237,6 +428,60 @@ function validateJobArguments(args) {
   return null;
 }
 
+function validateJsonOnlyArguments(args) {
+  const error = validationError(args, ['json']);
+  if (error) return error;
+  if (OWN(args, 'json') && typeof args.json !== 'boolean') return 'json must be a boolean';
+  return null;
+}
+
+function validateJobsQueryArguments(args) {
+  const error = validationError(args, ['last', 'json']);
+  if (error) return error;
+  if (OWN(args, 'last') && (!Number.isInteger(args.last) || args.last < 1)) {
+    return 'last must be a positive integer';
+  }
+  if (OWN(args, 'json') && typeof args.json !== 'boolean') return 'json must be a boolean';
+  return null;
+}
+
+function validateExplainArguments(args) {
+  const error = validationError(args, ['lane', 'json']);
+  if (error) return error;
+  if (typeof args.lane !== 'string' || !LANE_PATTERN.test(args.lane)) {
+    return 'lane must match ^[a-z][a-z0-9-]*$';
+  }
+  if (OWN(args, 'json') && typeof args.json !== 'boolean') return 'json must be a boolean';
+  return null;
+}
+
+function validateDryRunArguments(args) {
+  const error = validationError(args, [
+    'lane', 'task', 'mode', 'workdir', 'vendor', 'model', 'effort', '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, '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 createCapture() {
   const chunks = { stdout: [], stderr: [] };
   let collected = 0;
@@ -363,6 +608,52 @@ async function callTool(name, args) {
     const command = name === 'jobs_status' ? 'status' : 'result';
     return runToolScript(name, JOBS_SCRIPT, [command, args.id]);
   }
+  if (name === 'jobs_list') {
+    const error = validateJsonOnlyArguments(args);
+    if (error) return toolError(error);
+    const argv = args.json === true ? ['--json', 'list'] : ['list'];
+    return runToolScript('jobs_list', JOBS_SCRIPT, argv);
+  }
+  if (name === 'explain') {
+    const error = validateExplainArguments(args);
+    if (error) return toolError(error);
+    const argv = ['--explain', args.lane];
+    if (args.json === true) argv.push('--json');
+    return runToolScript('explain', DISPATCH_SCRIPT, argv);
+  }
+  if (name === 'validate') {
+    const error = validateJsonOnlyArguments(args);
+    if (error) return toolError(error);
+    const argv = ['--validate'];
+    if (args.json === true) argv.push('--json');
+    return runToolScript('validate', DISPATCH_SCRIPT, argv);
+  }
+  if (name === 'dry_run') {
+    const error = validateDryRunArguments(args);
+    if (error) return toolError(error);
+    const mode = OWN(args, 'mode') ? args.mode : 'advise';
+    const argv = ['--dry-run', '--mode', mode];
+    for (const key of ['workdir', 'vendor', 'model', 'effort', 'timeout']) {
+      if (OWN(args, key)) argv.push(`--${key}`, String(args[key]));
+    }
+    argv.push(args.lane, args.task);
+    return runToolScript('dry_run', DISPATCH_SCRIPT, argv);
+  }
+  if (name === 'doctor') {
+    const error = validateJsonOnlyArguments(args);
+    if (error) return toolError(error);
+    const argv = args.json === true ? ['--json'] : [];
+    return runToolScript('doctor', DOCTOR_SCRIPT, argv);
+  }
+  if (name === 'jobs_stats' || name === 'jobs_audit') {
+    const error = validateJobsQueryArguments(args);
+    if (error) return toolError(error);
+    const argv = [];
+    if (args.json === true) argv.push('--json');
+    argv.push(name === 'jobs_stats' ? 'stats' : 'audit');
+    if (OWN(args, 'last')) argv.push('--last', String(args.last));
+    return runToolScript(name, JOBS_SCRIPT, argv);
+  }
   throw new RpcError(-32602, `Unknown tool: ${name}`);
 }
 

package/completions/omnilane.fish

@@ -0,0 +1,50 @@
+# Fish completion for omnilane. Static command/option completion only; it never
+# invokes dispatch, provider CLIs, or the executable machine-local overlay.
+# Dynamic lane-name and job-id completion remain Bash/Zsh-only for now.
+
+# Top-level subcommands (offered only before a subcommand is chosen).
+complete -c omnilane -f -n __fish_use_subcommand -a version       -d 'installed release version'
+complete -c omnilane -f -n __fish_use_subcommand -a list          -d 'effective routing table'
+complete -c omnilane -f -n __fish_use_subcommand -a route         -d 'dispatch or consult a model'
+complete -c omnilane -f -n __fish_use_subcommand -a dispatch      -d 'dispatch or consult a model'
+complete -c omnilane -f -n __fish_use_subcommand -a jobs          -d 'inspect background jobs'
+complete -c omnilane -f -n __fish_use_subcommand -a mcp           -d 'MCP stdio server'
+complete -c omnilane -f -n __fish_use_subcommand -a doctor        -d 'read-only health report'
+complete -c omnilane -f -n __fish_use_subcommand -a release-audit -d 'offline release gate'
+complete -c omnilane -f -n __fish_use_subcommand -a ui            -d 'Live Board server'
+complete -c omnilane -f -n __fish_use_subcommand -a configure     -d 'lane routing (menu or set/get/unset/list/diff)'
+complete -c omnilane -f -n __fish_use_subcommand -a completion    -d 'print a shell completion script'
+complete -c omnilane -f -n __fish_use_subcommand -a help          -d 'usage'
+
+# route / dispatch options.
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l mode        -x -a 'advise work'                                                                              -d 'read-only advise or write-enabled work'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l vendor      -x -a 'codex claude grok gemini kimi qwen opencode openrouter deepseek zai mistral groq cerebras exec vote' -d 'pin one vendor, no fallback'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l effort      -x -a 'low medium high xhigh max'                                                                -d 'reasoning effort'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l workdir     -r                                                                                              -d 'working directory'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l model       -x                                                                                              -d 'routed model override'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l timeout     -x                                                                                              -d 'per-call timeout in seconds'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l job-timeout -x                                                                                              -d 'whole-job timeout in seconds'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l background                                                                                                  -d 'run as a background job'
+complete -c omnilane -n '__fish_seen_subcommand_from route dispatch' -l dry-run                                                                                                     -d 'resolve the plan and stop'
+
+# jobs subcommands (only before a jobs subcommand is chosen).
+complete -c omnilane -f \
+  -n '__fish_seen_subcommand_from jobs; and not __fish_seen_subcommand_from list status result tail retry stats wait audit prune cancel rm help' \
+  -a 'list status result tail retry stats wait audit prune cancel rm help' -d 'jobs subcommand'
+complete -c omnilane -n '__fish_seen_subcommand_from jobs' -l json -d 'JSON output'
+# jobs list / stats filters.
+complete -c omnilane -n '__fish_seen_subcommand_from jobs; and __fish_seen_subcommand_from list stats' -l lane   -x                                                                                    -d 'filter by lane'
+complete -c omnilane -n '__fish_seen_subcommand_from jobs; and __fish_seen_subcommand_from list stats' -l vendor -x -a 'codex claude grok gemini kimi qwen opencode openrouter deepseek zai mistral groq cerebras exec' -d 'filter by vendor'
+complete -c omnilane -n '__fish_seen_subcommand_from jobs; and __fish_seen_subcommand_from list'       -l status -x -a 'running done'                                                                    -d 'filter by status'
+
+# configure subcommands (non-interactive).
+complete -c omnilane -f -n '__fish_seen_subcommand_from configure; and not __fish_seen_subcommand_from set get unset list diff' -a 'set get unset list diff' -d 'configure action'
+
+# doctor / release-audit / ui / completion.
+complete -c omnilane -n '__fish_seen_subcommand_from doctor' -l json -d 'JSON output'
+complete -c omnilane -n '__fish_seen_subcommand_from release-audit' -l target -x       -d 'target version'
+complete -c omnilane -n '__fish_seen_subcommand_from release-audit' -l allow-dirty     -d 'permit a dirty tree'
+complete -c omnilane -n '__fish_seen_subcommand_from release-audit' -l require-tag     -d 'require an annotated tag'
+complete -c omnilane -n '__fish_seen_subcommand_from release-audit' -l json            -d 'JSON output'
+complete -c omnilane -f -n '__fish_seen_subcommand_from ui'         -a 'start status url stop' -d 'Live Board action'
+complete -c omnilane -f -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish'         -d 'target shell'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnilane",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "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/scripts/check.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+set -uo pipefail
+# omnilane self-check: run the CONTRIBUTING required checks in one command.
+# Usage: check.sh [--quick] [REPO_DIR]
+#   --quick    skip the two slow suite runs (python unittest, tests/run.sh)
+# A SKIP (tool unavailable or target absent) is not a failure; the script exits
+# non-zero only when a check actually FAILs. No -e: checks may fail and are
+# tallied rather than aborting the run.
+
+QUICK=0
+REPO=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --quick) QUICK=1; shift ;;
+    -h|--help) echo "usage: check.sh [--quick] [REPO_DIR]"; exit 0 ;;
+    --) shift; break ;;
+    -*) echo "check.sh: unknown option: $1" >&2; exit 2 ;;
+    *) if [[ -n "$REPO" ]]; then echo "check.sh: too many arguments" >&2; exit 2; fi
+       REPO="$1"; shift ;;
+  esac
+done
+if [[ $# -gt 0 ]]; then
+  if [[ -n "$REPO" ]]; then echo "check.sh: too many arguments" >&2; exit 2; fi
+  REPO="$1"
+fi
+[[ -n "$REPO" ]] || REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+PASS_N=0; FAIL_N=0; SKIP_N=0
+_pass() { PASS_N=$((PASS_N + 1)); printf 'PASS %s\n' "$1"; }
+_skip() { SKIP_N=$((SKIP_N + 1)); printf 'SKIP %s (%s)\n' "$1" "$2"; }
+_fail() { FAIL_N=$((FAIL_N + 1)); printf 'FAIL %s\n' "$1"; [[ -z "${2:-}" ]] || printf '  %s\n' "$2"; }
+
+# Shell files present in the repo (CONTRIBUTING's bash -n / shellcheck set).
+shell_files=()
+for pattern in 'bin/omnilane' 'scripts/*.sh' 'scripts/lib/*.sh' 'scripts/runners/*.sh' 'install.sh'; do
+  # shellcheck disable=SC2086  # $pattern is an intentional glob against $REPO
+  for f in $REPO/$pattern; do
+    [[ -f "$f" ]] && shell_files+=("$f")
+  done
+done
+
+# 1) bash -n on every tracked shell file
+if [[ ${#shell_files[@]} -eq 0 ]]; then
+  _skip bash-syntax "no shell files found"
+else
+  bad=""
+  for f in "${shell_files[@]}"; do
+    bash -n "$f" 2>/dev/null || bad="$bad ${f##*/}"
+  done
+  if [[ -z "$bad" ]]; then _pass bash-syntax; else _fail bash-syntax "invalid:$bad"; fi
+fi
+
+# 2) shellcheck -S warning (skip if unavailable)
+if ! command -v shellcheck >/dev/null 2>&1; then
+  _skip shellcheck "not installed"
+elif [[ ${#shell_files[@]} -eq 0 ]]; then
+  _skip shellcheck "no shell files"
+elif shellcheck -S warning "${shell_files[@]}" >/dev/null 2>&1; then
+  _pass shellcheck
+else
+  _fail shellcheck "shellcheck -S warning reported findings"
+fi
+
+# 3) perl -c on the job-timeout supervisor
+perl_file="$REPO/scripts/lib/job-timeout.pl"
+if ! command -v perl >/dev/null 2>&1; then
+  _skip perl-syntax "perl not installed"
+elif [[ ! -f "$perl_file" ]]; then
+  _skip perl-syntax "job-timeout.pl absent"
+elif perl -c "$perl_file" >/dev/null 2>&1; then
+  _pass perl-syntax
+else
+  _fail perl-syntax "perl -c failed"
+fi
+
+# 4) python compile of the UI and test modules
+py_files=()
+for rel in scripts/ui.py tests/test_ui.py tests/test_ci_policy.py tests/ui_browser_harness.py; do
+  [[ -f "$REPO/$rel" ]] && py_files+=("$REPO/$rel")
+done
+if ! command -v python3 >/dev/null 2>&1; then
+  _skip py-compile "python3 not installed"
+elif [[ ${#py_files[@]} -eq 0 ]]; then
+  _skip py-compile "no python files"
+elif python3 -m py_compile "${py_files[@]}" >/dev/null 2>&1; then
+  _pass py-compile
+else
+  _fail py-compile "py_compile failed"
+fi
+
+# 5) python unit tests (slow; --quick skips)
+if [[ "$QUICK" -eq 1 ]]; then
+  _skip unittest "--quick"
+elif ! command -v python3 >/dev/null 2>&1; then
+  _skip unittest "python3 not installed"
+elif [[ ! -d "$REPO/tests" ]]; then
+  _skip unittest "no tests dir"
+elif ( cd "$REPO" && python3 -m unittest discover -s tests -p 'test_*.py' >/dev/null 2>&1 ); then
+  _pass unittest
+else
+  _fail unittest "python unittest suite failed"
+fi
+
+# 6) shell test suite (slow; --quick skips)
+if [[ "$QUICK" -eq 1 ]]; then
+  _skip shell-suite "--quick"
+elif [[ ! -f "$REPO/tests/run.sh" ]]; then
+  _skip shell-suite "tests/run.sh absent"
+elif bash "$REPO/tests/run.sh" >/dev/null 2>&1; then
+  _pass shell-suite
+else
+  _fail shell-suite "bash tests/run.sh failed"
+fi
+
+# 7) effective routing table resolves
+if [[ ! -f "$REPO/scripts/dispatch.sh" ]]; then
+  _skip dispatch-list "dispatch.sh absent"
+elif bash "$REPO/scripts/dispatch.sh" --list >/dev/null 2>&1; then
+  _pass dispatch-list
+else
+  _fail dispatch-list "dispatch.sh --list failed"
+fi
+
+printf '\nsummary: %d passed, %d skipped, %d failed\n' "$PASS_N" "$SKIP_N" "$FAIL_N"
+[[ "$FAIL_N" -eq 0 ]]

package/scripts/configure.sh

@@ -9,6 +9,142 @@ source "$(dirname "${BASH_SOURCE[0]}")/lib/i18n.sh"
 
 LOCAL_FILE="$OMNILANE_HOME/routing.local.yaml"
 
+# --- Non-interactive subcommands -------------------------------------------
+# `configure set|get|unset|list` script the same routing.local.yaml the menu
+# writes, so automation never needs a tty. No subcommand => interactive menu.
+
+cfg_usage() {
+  cat >&2 <<'EOF'
+usage: configure                 interactive lane menu
+       configure set LANE SPEC   set/override one lane. SPEC = "vendor model effort [| ...]" or "off".
+                                 Quote the whole SPEC (and the model) when a model name has spaces.
+       configure get LANE        show the effective routing line for LANE
+       configure unset LANE      remove LANE's local override
+       configure list            show current local overrides
+       configure diff            show how local overrides change the effective table vs the defaults
+EOF
+}
+
+# Reject shell-dangerous bytes while allowing the routing RHS grammar
+# (chains with |, quoted "models with spaces", slashes, effort tokens).
+cfg_spec_is_safe() {
+  case "$1" in
+    '') return 1 ;;
+    *'$'*|*'`'*|*'\'*|*'#'*|*';'*|*'&'*|*'<'*|*'>'*|*$'\r'*|*$'\n'*) return 1 ;;
+    *) return 0 ;;
+  esac
+}
+
+cfg_lane_is_known() {
+  local want="$1" line
+  while IFS= read -r line; do
+    case "$line" in "$want":*) return 0 ;; esac
+  done < "$OMNILANE_REPO/routing.yaml"
+  return 1
+}
+
+cfg_valid_lane() { [[ "$1" =~ ^[a-z][a-z0-9-]*$ ]]; }
+
+cfg_set() {
+  local lane="${1:-}"; shift || true
+  local spec="$*"
+  cfg_valid_lane "$lane" || { echo "omnilane: invalid lane '$lane'" >&2; exit 2; }
+  cfg_lane_is_known "$lane" || { echo "omnilane: unknown lane '$lane' (see: omnilane list)" >&2; exit 2; }
+  [[ -n "$spec" ]] || { echo "omnilane: missing routing spec for '$lane'" >&2; cfg_usage; exit 2; }
+  cfg_spec_is_safe "$spec" || { echo 'omnilane: unsafe routing spec (not allowed: $ ` \ # ; & < > newlines)' >&2; exit 2; }
+
+  mkdir -p "$OMNILANE_HOME"
+  local had_file=0
+  if [[ -f "$LOCAL_FILE" ]]; then had_file=1; cp "$LOCAL_FILE" "$LOCAL_FILE.bak"; fi
+  local tmp="$LOCAL_FILE.tmp.$$"
+  {
+    echo "# updated by 'configure set' on $(date +%F) — first match per lane wins"
+    echo "$lane: $spec"
+    [[ "$had_file" -eq 1 ]] && grep -v '^#' "$LOCAL_FILE.bak" | grep -v "^$lane:" || true
+  } > "$tmp"
+  mv "$tmp" "$LOCAL_FILE"
+
+  # Semantic guard: reject only a structural FAIL on THIS lane. Availability
+  # WARN (validate exit 4) is fine — the vendor CLI may be legitimately absent.
+  local validate_out
+  validate_out="$(OMNILANE_HOME="$OMNILANE_HOME" bash "$OMNILANE_REPO/scripts/dispatch.sh" --validate 2>&1)" || true
+  if printf '%s\n' "$validate_out" | grep -q "^FAIL $lane "; then
+    if [[ "$had_file" -eq 1 ]]; then mv "$LOCAL_FILE.bak" "$LOCAL_FILE"; else /bin/rm -f "$LOCAL_FILE"; fi
+    echo "omnilane: rejected — $(printf '%s\n' "$validate_out" | grep "^FAIL $lane " | head -1)" >&2
+    exit 2
+  fi
+  [[ "$had_file" -eq 1 ]] && /bin/rm -f "$LOCAL_FILE.bak"
+  echo "set $lane -> $spec"
+}
+
+cfg_get() {
+  local lane="${1:-}"
+  cfg_valid_lane "$lane" || { echo "omnilane: invalid lane '$lane'" >&2; exit 2; }
+  local line
+  line="$(OMNILANE_HOME="$OMNILANE_HOME" bash "$OMNILANE_REPO/scripts/dispatch.sh" --list 2>/dev/null | grep "^$lane:" | head -1 || true)"
+  [[ -n "$line" ]] || { echo "omnilane: unknown lane '$lane' (see: omnilane list)" >&2; exit 2; }
+  printf '%s\n' "$line"
+}
+
+cfg_unset() {
+  local lane="${1:-}"
+  cfg_valid_lane "$lane" || { echo "omnilane: invalid lane '$lane'" >&2; exit 2; }
+  if [[ ! -f "$LOCAL_FILE" ]] || ! grep -q "^$lane:" "$LOCAL_FILE"; then
+    echo "no local override for '$lane'"; return 0
+  fi
+  cp "$LOCAL_FILE" "$LOCAL_FILE.bak"
+  grep -v "^$lane:" "$LOCAL_FILE.bak" > "$LOCAL_FILE" || true
+  /bin/rm -f "$LOCAL_FILE.bak"
+  echo "unset $lane (local override removed)"
+}
+
+cfg_list() {
+  if [[ -f "$LOCAL_FILE" ]] && grep -qE '^[a-z]' "$LOCAL_FILE"; then
+    cat "$LOCAL_FILE"
+  else
+    echo "no local overrides in $LOCAL_FILE"
+  fi
+}
+
+# Diff the effective table (local wins) against a defaults-only resolution, so
+# the user sees exactly which lanes their overrides change. Reuses dispatch.sh
+# --list for both, so availability annotation and formatting stay consistent; a
+# throwaway empty OMNILANE_HOME yields the defaults-only table.
+cfg_diff() {
+  if [[ ! -f "$LOCAL_FILE" ]] || ! grep -qE '^[a-z]' "$LOCAL_FILE"; then
+    echo "no local overrides ($LOCAL_FILE); effective table equals the defaults"
+    return 0
+  fi
+  local empty eff def changed=0 lane eff_line def_line
+  empty="$(mktemp -d "${TMPDIR:-/tmp}/omnilane-diff.XXXXXX")"
+  eff="$(OMNILANE_HOME="$OMNILANE_HOME" bash "$OMNILANE_REPO/scripts/dispatch.sh" --list 2>/dev/null || true)"
+  def="$(OMNILANE_HOME="$empty" bash "$OMNILANE_REPO/scripts/dispatch.sh" --list 2>/dev/null || true)"
+  /bin/rm -rf "$empty"
+  while IFS= read -r eff_line; do
+    [[ "$eff_line" =~ ^([a-z][a-z0-9-]*): ]] || continue
+    lane="${BASH_REMATCH[1]}"
+    def_line="$(printf '%s\n' "$def" | grep "^$lane:" | head -1 || true)"
+    if [[ "$eff_line" != "$def_line" ]]; then
+      changed=1
+      printf 'default> %s\n' "${def_line:-($lane not in defaults)}"
+      printf 'local  > %s\n' "$eff_line"
+      echo
+    fi
+  done <<DIFF_EFF
+$eff
+DIFF_EFF
+  [[ "$changed" -eq 1 ]] || echo "local overrides present, but the effective table matches the defaults"
+}
+
+case "${1:-}" in
+  set)   shift; cfg_set "$@"; exit $? ;;
+  get)   shift; cfg_get "$@"; exit $? ;;
+  unset) shift; cfg_unset "$@"; exit $? ;;
+  list)  shift; cfg_list "$@"; exit $? ;;
+  diff)  cfg_diff; exit $? ;;
+  -h|--help|help) cfg_usage; exit 0 ;;
+esac
+
 # Curated suggestions only — "c" always allows free text so new models work.
 CODEX_MODELS=("gpt-5.6-sol" "gpt-5.6-terra" "gpt-5.6-luna")
 CODEX_EFFORTS=("xhigh" "max" "ultra" "high" "medium" "low" "minimal" "none")
@@ -21,6 +157,13 @@ QWEN_MODELS=("qwen3-coder-plus" "qwen3-coder-flash")
 # OpenCode models use provider/model form; OpenRouter models are catalog slugs.
 OPENCODE_MODELS=("openrouter/anthropic/claude-sonnet-5" "openrouter/openai/gpt-5.6-sol" "opencode/default (leave model to opencode)")
 OPENROUTER_MODELS=("anthropic/claude-sonnet-5" "openai/gpt-5.6-sol" "moonshotai/kimi-k3" "qwen/qwen3-coder-plus")
+# Direct-API OpenAI-compatible vendors (curl + <VENDOR>_API_KEY); slugs are
+# suggestions — "c" free text covers anything each provider's /models lists.
+DEEPSEEK_MODELS=("deepseek-chat" "deepseek-reasoner" "deepseek-v4-flash")
+ZAI_MODELS=("glm-4.6")
+MISTRAL_MODELS=("devstral-latest" "codestral-latest" "mistral-medium-latest")
+GROQ_MODELS=("openai/gpt-oss-120b" "qwen/qwen3.6-27b" "openai/gpt-oss-20b")
+CEREBRAS_MODELS=("gpt-oss-120b" "qwen-3-32b" "llama-3.3-70b")
 
 custom_value_is_safe() {
   case "$1" in
@@ -79,7 +222,7 @@ while true; do
     echo "$(msgf cfg_pick_range "${#LANES[@]}")"; continue
   fi
   lane="${LANES[$((n - 1))]}"
-  vendor="$(pick "$(msgf cfg_vendor_for "$lane")" codex claude grok gemini kimi qwen opencode openrouter "vote (multi-model panel)" "exec (your own script/gate)" off)"
+  vendor="$(pick "$(msgf cfg_vendor_for "$lane")" codex claude grok gemini kimi qwen opencode openrouter deepseek zai mistral groq cerebras "vote (multi-model panel)" "exec (your own script/gate)" off)"
   [[ "$vendor" == exec* ]] && vendor="exec"
   [[ "$vendor" == vote* ]] && vendor="vote"
   if [[ "$vendor" == "off" ]]; then
@@ -96,6 +239,11 @@ while true; do
     opencode)   model="$(pick "$(msg cfg_model)" "${OPENCODE_MODELS[@]}")"; effort="-"
                 [[ "$model" == "opencode/default"* ]] && model="-" ;;
     openrouter) model="$(pick "$(msg cfg_model)" "${OPENROUTER_MODELS[@]}")"; effort="-" ;;
+    deepseek)   model="$(pick "$(msg cfg_model)" "${DEEPSEEK_MODELS[@]}")"; effort="-" ;;
+    zai)        model="$(pick "$(msg cfg_model)" "${ZAI_MODELS[@]}")";      effort="-" ;;
+    mistral)    model="$(pick "$(msg cfg_model)" "${MISTRAL_MODELS[@]}")";  effort="-" ;;
+    groq)       model="$(pick "$(msg cfg_model)" "${GROQ_MODELS[@]}")";     effort="-" ;;
+    cerebras)   model="$(pick "$(msg cfg_model)" "${CEREBRAS_MODELS[@]}")"; effort="-" ;;
     vote)   while true; do
               count="$(pick "$(msg cfg_voters_count)" "1" "2" "3" "4")"
               [[ "$count" =~ ^[1-4]$ ]] && break