omnilane 0.8.3 → 0.9.1

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.1",
   "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 ]]