ai-consultants 2.19.2 → 2.21.0

package/.claude/commands/ai-consultants:help.md

@@ -13,6 +13,7 @@ All skill details (consultants, personas, presets, strategies, features, configu
 |---------|-------------|
 | `/ai-consultants:consult` | Main consultation — ask AI consultants a coding question |
 | `/ai-consultants:debate` | Run consultation with multi-round debate |
+| `/ai-consultants:roster-audit` | Audit which consultants add distinct value vs echo the panel |
 | `/ai-consultants:help` | Show this help |
 
 ## Quick Examples

package/.claude/commands/ai-consultants:roster-audit.md

@@ -0,0 +1,38 @@
+---
+description: Audit the consultant roster for uncorrelated value — which consultants contribute a distinct approach vs echo the panel (candidates to drop or down-weight). Use when deciding roster composition or after noticing redundant consultations.
+argument-hint: [--recent N] [--threshold PCT] [dir ...]
+allowed-tools: Bash
+---
+
+# AI Consultants - Roster Audit
+
+Measure each consultant's *uncorrelated value* across past consultations: a
+consultant whose approach rarely differs from the rest (low keyword overlap) is
+redundant; one that is often distinct earns its seat on diversity. This is the
+"does it add signal the others miss?" bar, applied to the panel.
+
+**Arguments:** $ARGUMENTS
+
+## Instructions
+
+1. Run the audit (pass `$ARGUMENTS` through; with no args it audits the most
+   recent consultations under the output base):
+   ```bash
+   cd "${AI_CONSULTANTS_DIR:-$HOME/.claude/skills/ai-consultants}" && ./scripts/roster_audit.sh $ARGUMENTS
+   ```
+   - No args → the 20 most recent consultation dirs.
+   - `--recent N` → the N most recent; `--threshold PCT` → correlation cutoff (default 20%).
+   - Or pass explicit consultation output dirs; add `--json` for machine-readable output.
+
+2. **Present the table** as-is (consultant · participated · distinct · distinct% ·
+   verdict), then interpret each verdict:
+   - **unique-value** — pulls its weight on diversity; keep.
+   - **some-value** — contributes occasionally.
+   - **redundant?** — correlated with the panel; candidate to drop or down-weight
+     in `references/affinity.json` (lower its category affinities, or its
+     capability axes when capability routing is enabled).
+   - **insufficient-data** — too few samples; audit more consultations.
+
+3. If the audit prints "nothing to audit" (exit 1), tell the user no consultations
+   with ≥2 responders were found and suggest running some consultations first —
+   each `consult_all.sh` run writes an output directory the audit can read.

package/CLAUDE.md

@@ -6,7 +6,7 @@ AI Consultants is a multi-model AI deliberation system that queries up to 15 AI
 
 **Self-Exclusion**: The invoking agent is automatically excluded from the panel to prevent self-consultation. Claude Code won't query Claude, Codex CLI won't query Codex, etc.
 
-**Version**: 2.19.2
+**Version**: 2.21.0
 
 ## Distribution
 
@@ -38,7 +38,12 @@ ai-consultants/
 │   ├── consult_all.sh          # Main orchestrator - entry point
 │   ├── config.sh               # Centralized configuration
 │   ├── doctor.sh               # Diagnostic and auto-fix tool (v2.2)
+│   ├── update_clis.sh          # Check/update installed consultant CLIs (v2.21)
 │   ├── peer_review.sh          # Anonymous peer review (v2.2)
+│   ├── roster_audit.sh         # Roster uncorrelated-value audit (v2.20)
+│   ├── roster_calibrate.sh     # Measured capability calibration, Tier A (v2.20)
+│   ├── run_calibration.sh      # Calibration data-collection harness (v2.20)
+│   ├── taste_elo.sh            # Pairwise-judge taste Elo, Tier B (v2.20)
 │   ├── install.sh              # One-liner installer (v2.2)
 │   ├── query_*.sh              # Wrapper for each consultant
 │   ├── query_claude.sh         # Claude consultant (v2.2)
@@ -55,6 +60,7 @@ ai-consultants/
 │       ├── voting.sh           # Voting/consensus + confidence intervals
 │       ├── routing.sh          # Smart routing + cost-aware routing
 │       ├── orchestration.sh    # Dynamic orchestration planner + shapes (v2.16)
+│       ├── stance.sh           # Stance-based semantic consensus (v2.21, opt-in)
 │       ├── session.sh          # Session management
 │       ├── costs.sh            # Cost tracking + response limits
 │       ├── cache.sh            # Semantic caching (v2.3)
@@ -281,7 +287,7 @@ curl -fsSL https://ampcode.com/install.sh | bash
 ```
 
 **Environment Variables:**
-- `ENABLE_AMP` - Enable Amp consultant (default: false)
+- `ENABLE_AMP` - Enable Amp consultant (default: true)
 - `AMP_CMD` - CLI command (default: amp)
 - `AMP_TIMEOUT` - Timeout in seconds (default: 180)
 - `AMP_API_KEY` - API key for authentication
@@ -322,7 +328,7 @@ Qwen3 now supports CLI/API mode switching using the qwen-code CLI.
 export QWEN3_USE_API=false
 ./scripts/consult_all.sh "question"
 
-# API mode (default, preserves v2.6 behavior)
+# API mode (opt-in)
 export QWEN3_USE_API=true
 export QWEN3_API_KEY="your-dashscope-key"
 ./scripts/consult_all.sh "question"
@@ -338,7 +344,7 @@ npm install -g @qwen-code/qwen-code@latest
 ## v2.6 Features
 
 ### CLI/API Mode Switching
-Five consultants can now switch between CLI and API mode: **Gemini, Codex, Claude, Mistral, Qwen3**.
+Six consultants can now switch between CLI and API mode: **Gemini, Codex, Claude, Mistral, Qwen3, MiniMax**.
 
 When API mode is enabled for an agent, CLI mode is disabled (mutual exclusivity).
 
@@ -375,6 +381,7 @@ New environment variables in `config.sh`:
 | `CLAUDE_USE_API` | false | Use Anthropic API instead of claude CLI |
 | `MISTRAL_USE_API` | false | Use Mistral API instead of vibe CLI |
 | `QWEN3_USE_API` | false | Use DashScope API instead of qwen CLI (v2.7) |
+| `MINIMAX_USE_API` | false | Use MiniMax API instead of the mmx CLI (v2.21) |
 | `GEMINI_API_URL` | https://generativelanguage.googleapis.com/v1beta/models | Google AI endpoint |
 | `CODEX_API_URL` | https://api.openai.com/v1/chat/completions | OpenAI endpoint |
 | `CLAUDE_API_URL` | https://api.anthropic.com/v1/messages | Anthropic endpoint |
@@ -645,7 +652,7 @@ for f in scripts/*.sh scripts/lib/*.sh; do bash -n "$f" && echo "OK: $f"; done
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `INVOKING_AGENT` | unknown | Agent invoking the skill (for self-exclusion) |
-| `ENABLE_CLAUDE` | false | Enable Claude consultant |
+| `ENABLE_CLAUDE` | true | Enable Claude consultant (auto-excluded under Claude Code) |
 | `ENABLE_DEBATE` | false | Enable Multi-Agent Debate |
 | `DEBATE_ROUNDS` | 1 | Number of debate rounds |
 | `ENABLE_SYNTHESIS` | true | Auto-synthesis of responses |
@@ -668,15 +675,23 @@ for f in scripts/*.sh scripts/lib/*.sh; do bash -n "$f" && echo "OK: $f"; done
 | `ENABLE_COST_AWARE_ROUTING` | false | Cost-based model routing (v2.3) |
 | `ENABLE_DEBATE_OPTIMIZATION` | false | Skip debate if all agree (v2.3, opt-in) |
 | `ENABLE_COMPACT_REPORT` | true | Compact report format (v2.3) |
+| `ENABLE_CAPABILITY_WEIGHTING` | false | Capability-weighted voting (v2.20, opt-in) |
+| `ENABLE_CAPABILITY_ROUTING` | false | Capability-aware panel composition (v2.20, opt-in) |
+| `CAPABILITY_WEIGHT_STRENGTH` | 10 | Vote-weight modulation: conf*(S+cap)/S (v2.20) |
+| `CAPABILITY_DEFAULT` | 5 | Fallback capability for a missing consultant/axis (v2.20) |
+| `ENABLE_STANCE_CONSENSUS` | false | Enumerated-stance exact-match consensus (v2.21, opt-in; +1 LLM call/run) |
+| `STANCE_MAX_OPTIONS` | 5 | Max stance options generated per question (v2.21) |
 | `ENABLE_BUDGET_LIMIT` | false | Budget enforcement (v2.4, opt-in) |
 | `BUDGET_ACTION` | warn | Action on budget exceeded: warn/stop (v2.4) |
 | `QWEN3_USE_API` | false | Use DashScope API instead of qwen CLI (v2.7) |
 | `QWEN3_CMD` | qwen | Qwen CLI command (v2.7) |
-| `ENABLE_KIMI` | false | Enable Kimi consultant (v2.9) |
+| `ENABLE_KIMI` | true | Enable Kimi consultant (v2.9) |
 | `KIMI_CMD` | kimi | Kimi CLI command (v2.9) |
 | `KIMI_MODEL` | kimi-code/kimi-for-coding | Kimi model (v2.9) |
-| `ENABLE_MINIMAX` | false | Enable MiniMax consultant (v2.10) |
-| `MINIMAX_API_KEY` | - | MiniMax API key (v2.10) |
+| `ENABLE_MINIMAX` | true | Enable MiniMax consultant (v2.10; CLI via mmx v2.21) |
+| `MINIMAX_USE_API` | false | Use MiniMax API instead of the mmx CLI (v2.21) |
+| `MINIMAX_CMD` | mmx | MiniMax CLI command (v2.21) |
+| `MINIMAX_API_KEY` | - | MiniMax API key (API mode only) (v2.10) |
 | `MINIMAX_MODEL` | MiniMax-M2.7 | MiniMax model (v2.10) |
 
 ## External Dependencies
@@ -691,6 +706,7 @@ for f in scripts/*.sh scripts/lib/*.sh; do bash -n "$f" && echo "OK: $f"; done
 - `kimi` CLI - Kimi Code (v2.9)
 - `claude` CLI - Claude (v2.2, also used for synthesis)
 - `qwen` CLI - Qwen via qwen-code (v2.7, optional)
+- `mmx` CLI - MiniMax via mmx-cli (v2.21, optional; `npm i -g mmx-cli`, auth `mmx auth login`)
 - `ollama` CLI - Local models (v2.2)
 - `jq` - JSON parsing
 
@@ -826,6 +842,26 @@ curl -fsSL https://raw.githubusercontent.com/matteoscurati/ai-consultants/main/s
 
 ## Changelog
 
+### v2.21.0
+- **CLI-first transport (principle).** Every `*_USE_API` defaults `false`; a consultant with a CLI always uses it, API is opt-in (CLI-less model or explicit choice). `ENABLE_AMP`/`ENABLE_CLAUDE` default true.
+- **MiniMax via `mmx` CLI** (was API-only). `query_minimax.sh` runs `mmx text chat --non-interactive …` in CLI mode; `config.sh` adds `MINIMAX_CMD` + auto-resolves `MINIMAX_USE_API` (API iff `MINIMAX_API_KEY` set — back-compat), drops MiniMax from `API_CONSULTANTS`; `doctor.sh` treats it as switchable.
+- **`scripts/update_clis.sh`** (+ `ai-consultants update-clis`): per CLI-backed consultant, `detect_method` (brew formula/cask, npm, uv, pipx, pip, self-update, curl installer) → update. `--dry-run`, `--only`.
+- **Stance consensus** (opt-in, `ENABLE_STANCE_CONSENSUS`): new `lib/stance.sh` (`generate_stance_options` — one synthesizer call wrapped in `run_with_timeout`; `_stance_clean`; `build_stance_prompt`). `consult_all.sh` generates the shared set → `stance_options.json` + exports `STANCE_OPTIONS_PROMPT`; injected via `personas.sh` (CLI) + `api_query.sh` (API). `voting.sh::calculate_consensus_score` scores the plurality stance over the PANEL size (not the count of emitted stances). `STANCE_MAX_OPTIONS`, `STANCE_TIMEOUT`.
+- **Smoke-test reliability**: `query_gemini.sh` (`agy -p "$QUERY"`), `query_kimi.sh` (`stream-json` + `_kimi_extract_content`), `query_kilo.sh` (de-fence). Shared `_is_consultant_response_file` metadata filter in `common.sh`, applied across `voting.sh`/`synthesize.sh`/`peer_review.sh`/`reflection.sh`. `orchestration.sh` stalled→stable relabel (set -e-safe) + debate-round promote validation.
+- **Persona fix**: `_AGENT_DEFAULT_PERSONAS` mapped `GLM|17`/`DEEPSEEK|7` (each got the other's persona) → `GLM|7`/`DEEPSEEK|17`.
+- **Dev/reliability**: reliability tracking + Amp/Claude default-on; offline e2e test; `scripts/release.sh` version-bump automation; calibration fixes (diagnosable peer-review failures + cost-only path); `test_user_config.sh` XDG test made hermetic (unset the exported `_AI_CONSULTANTS_XDG_*` intermediates). `npm test` = 18 suites. Hardened by a `/code-review max` pass.
+
+### v2.20.0
+- **Capability axes (borrowed from the delegation-kit cost/intelligence/taste table).** `references/affinity.json` → v1.1: new `capabilities` (per-consultant {intelligence, taste, cost}, 1-10), `category_axis` (category → the quality axis it stresses: taste for API_DESIGN/ARCHITECTURE/CODE_REVIEW/GENERAL, intelligence otherwise), `capability_default`. New `lib/routing.sh::get_capability` / `get_category_axis` (cached like `get_affinity`).
+- **Capability-weighted voting** (`ENABLE_CAPABILITY_WEIGHTING`, opt-in): `lib/voting.sh::_effective_vote_weight` modulates a vote by the consultant's capability on the run's axis — `confidence × (S + cap) / S` (`S = CAPABILITY_WEIGHT_STRENGTH`, default 10). Applied in `calculate_weighted_recommendation` and `calculate_final_score` (normalizer uses the same weight → 1-10 scale preserved). Axis from `QUESTION_CATEGORY`. `cost` never weights a vote (tie-break intelligence > taste > cost).
+- **Capability-aware composition** (`ENABLE_CAPABILITY_ROUTING`, opt-in): `select_consultants` keeps the raw-affinity eligibility filter but ranks eligible consultants by `affinity + (cap − capability_default)`, so under a size limit the quality axis reorders who makes the cut.
+- **Roster audit** — `scripts/roster_audit.sh` scores each consultant's "distinct approach" rate (max pairwise Jaccard of approaches < threshold) across consultations; verdicts unique-value / some-value / redundant? / insufficient-data. Wired as `doctor.sh --roster-audit` (short-circuit mode) and the `/ai-consultants:roster-audit` slash command (3 hosts). Reuses `voting.sh` keyword/Jaccard helpers.
+- **Measured calibration** — `scripts/roster_calibrate.sh` (Tier A): intelligence/taste = mean blind peer-review score sliced by `category_axis`, cost = mean observed `tokens_used`×rate (60/40 split, rank-normalized cheapest=10); emits a `capabilities` block (`--json`/`--write`). `scripts/taste_elo.sh` (Tier B): taste via pairwise-judge Elo (pluggable judge — `JUDGE_CLI` / `TASTE_JUDGE_CMD`). `scripts/run_calibration.sh` drives `references/calibration_benchmark.json` (50 questions, 20 taste / 30 intelligence) through the panel with peer review, then calibrates.
+- **Config** (`config.sh`): `ENABLE_CAPABILITY_WEIGHTING`, `ENABLE_CAPABILITY_ROUTING` (both false), `CAPABILITY_WEIGHT_STRENGTH` (10), `CAPABILITY_DEFAULT` (5). **Observability**: `consult_all.sh` records `capability{weighting_enabled, routing_enabled, axis}` in `optimization_metrics.json`.
+- **Tests**: `test_capability_weighting` (17), `test_roster_audit` (6), `test_roster_calibrate` (10), `test_taste_elo` (6) — 12 suites total. All opt-in; with flags off, existing voting/routing/parity tests pass unchanged. shellcheck clean.
+- **Docs**: `SMART_ROUTING.md` (capability + roster-audit + measured-calibration sections), `.env.example`, `references/configuration.md`, env-var table + structure list here. Website feature card added (sync on push).
+- **Seeds are subjective** (Claude/Codex grounded on the model-routing table; the rest heuristic) — the calibration workflow measures them empirically. Fully back-compat.
+
 ### v2.19.2
 - **Cost tracking silently lost on a fresh install — fixed.** `lib/costs.sh::track_session_cost` wrote to `$COST_TRACKING_FILE` (`$XDG_DATA_HOME/ai-consultants/costs.json`, i.e. `~/.local/share/...`) without ever creating the parent directory. That dir doesn't exist until something makes it, and `costs.json` is the only artifact stored there — so on a fresh install every session's cost write failed with "No such file or directory" (swallowed under `set -e` in the caller) and cumulative cost tracking never accumulated. Fix: `mkdir -p "$(dirname "$COST_TRACKING_FILE")"` up front; on failure, `log_warn` + `return 0`.
 - **Function split for lock discipline**: `track_session_cost` (outer) now owns dir creation + locking and delegates the read-modify-write to a new inner `_track_session_cost_update`, which runs with the lock held and never propagates failure. Rationale documented inline: the caller in `consult_all.sh` runs under `set -e` *after* every consultant has already been queried and billed, so a bookkeeping failure must degrade to a warning, never abort the run.

package/README.md

@@ -1,8 +1,8 @@
-# AI Consultants v2.19.2
+# AI Consultants v2.21.0
 
 > **A harness for every question.** A panel of up to 15 frontier models that writes its own playbook per question — fan out, debate to convergence, cross-examine under adversarial review, or run a tournament — and checks its work before it reaches you.
 
-[![Version](https://img.shields.io/badge/version-2.19.2-blue.svg)](https://github.com/matteoscurati/ai-consultants)
+[![Version](https://img.shields.io/badge/version-2.21.0-blue.svg)](https://github.com/matteoscurati/ai-consultants)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Claude Code Skill](https://img.shields.io/badge/Claude%20Code-Skill-orange.svg)](https://docs.anthropic.com/en/docs/claude-code/skills)
 [![GitHub stars](https://img.shields.io/github/stars/matteoscurati/ai-consultants?style=social)](https://github.com/matteoscurati/ai-consultants)
@@ -580,6 +580,8 @@ ai-consultants doctor --json                                   # JSON for automa
 ai-consultants doctor --live                                   # Real ping per consultant — catches installed-but-unauthenticated CLIs
 ai-consultants doctor --suggest-config                         # Print recommended ENABLE_* based on detected CLIs
 ai-consultants doctor --suggest-preset --question "..."        # Recommend preset + strategy for a question
+ai-consultants update-clis                                     # Check & update every installed consultant CLI
+ai-consultants update-clis --dry-run                           # Preview: each CLI's install method + update command
 ```
 
 > When a consultant fails mid-consultation, the run surfaces the captured reason (e.g. `CLI not found`, `401 Unauthorized`) instead of a bare "Failed", so you can tell *not installed* from *not authenticated* from *transient*.
@@ -609,6 +611,11 @@ The **shape** is chosen per question (or pinned via `ORCHESTRATION_MODE`):
 
 Set `ORCHESTRATION_MODE=fixed` for the classic fixed-round pipeline.
 
+Consensus is measured lexically by default; set `ENABLE_STANCE_CONSENSUS=true`
+(opt-in, v2.21) to have the panel pick from a shared set of enumerated stance
+options and score agreement by exact match instead — see
+[references/configuration.md](references/configuration.md#semantic-consensus-v221-opt-in).
+
 With peer review:
 ```
 Responses -> Anonymize -> Peer Ranking -> De-anonymize -> Peer Scores

package/SKILL.md

@@ -5,10 +5,10 @@ license: MIT
 compatibility: Requires bash, jq, and at least 2 AI CLI tools (agy, codex, vibe, etc.). macOS and Linux.
 metadata:
   author: matteoscurati
-  version: 2.19.2
+  version: 2.21.0
 ---
 
-# AI Consultants v2.19.2 - AI Expert Panel
+# AI Consultants v2.21.0 - AI Expert Panel
 
 **A harness for every question.** Convene a panel of AI "consultants" for coding questions — and let the engine pick *how* they deliberate: a quick read, a convergence loop, an adversarial refutation gate, a tournament, or an exhaustive sweep. Each consultant has a **configurable persona** that shapes its analysis.
 
@@ -42,11 +42,12 @@ Configuration (presets, strategies, features, personas, API keys) can be managed
 | **Kimi** | `kimi` | The Eastern Sage | Holistic, balanced perspectives |
 | **Claude** | `claude` | The Synthesizer | Big picture, synthesis |
 | **Qwen** | `qwen` | The Analyst | Data-driven, metrics |
+| **MiniMax** | `mmx` | The Pragmatic Optimizer | Performance, efficiency, pragmatism |
 | **Ollama** | `ollama` | The Local Expert | Privacy-first, zero cost |
 
-**API-only consultants**: GLM (The Methodologist), Grok (The Provocateur), DeepSeek (The Code Specialist), MiniMax (The Pragmatic Optimizer)
+**API-only consultants**: GLM (The Methodologist), Grok (The Provocateur), DeepSeek (The Code Specialist)
 
-**CLI/API Mode**: Gemini, Codex, Claude, Mistral, and Qwen can switch between CLI and API mode via `*_USE_API` environment variables. Gemini auto-selects API mode when `GEMINI_API_KEY` is set (no `agy` install needed) and the CLI otherwise.
+**CLI/API Mode**: Gemini, Codex, Claude, Mistral, Qwen, and MiniMax can switch between CLI and API mode via `*_USE_API` environment variables. Gemini auto-selects API mode when `GEMINI_API_KEY` is set (no `agy` install needed) and the CLI otherwise.
 
 **Self-Exclusion**: The invoking agent is automatically excluded from the panel. When invoked from Claude Code, Claude is excluded; when invoked from Codex CLI, Codex is excluded, etc.
 
@@ -96,6 +97,7 @@ Query is classified, then sent to consultants in parallel. Responses are scored,
 | **Smart Routing** | Auto-select best consultants per question type | `ENABLE_SMART_ROUTING` |
 | **Cost Tracking** | Track API usage costs | `ENABLE_COST_TRACKING` |
 | **Panic Mode** | Auto-add rigor when uncertainty detected | `ENABLE_PANIC_MODE` |
+| **Stance Consensus** | Panel picks from enumerated stances; agreement by exact match (opt-in, v2.21) | `ENABLE_STANCE_CONSENSUS` |
 
 ## Configuration
 
@@ -136,6 +138,10 @@ Diagnose and fix issues:
 ./scripts/doctor.sh --live       # Real ping per consultant — catches installed-but-unauthenticated CLIs
 ```
 
+Keep the consultant CLIs current with `ai-consultants update-clis` (`--dry-run` to
+preview, `--only <cli>` to target one) — it detects how each CLI was installed
+(brew/npm/uv/pipx/curl/self-update) and updates it.
+
 When a consultant fails during a consultation, the run prints the captured reason (e.g. "CLI not found", "401 Unauthorized"). The run is also **graded** MET/DEGRADED/FAILED by how many responded (`QUORUM_MIN`), with a "Diagnosed Failures" section in the report. Set `ENABLE_HEALTH_GATE=true` to ping consultants and drop the dead ones *before* the run.
 
 ## Interpreting Results

package/bin/ai-consultants

@@ -55,6 +55,7 @@ Usage:
   ai-consultants --preset <name> "question"   Use a configuration preset
   ai-consultants --strategy <name> "question" Use a synthesis strategy
   ai-consultants doctor [--fix] [--json]      Run diagnostics
+  ai-consultants update-clis [--dry-run]      Check & update installed consultant CLIs
   ai-consultants init [--force]               Scaffold ~/.config/ai-consultants/{config.sh,.env}
   ai-consultants install                      Install slash commands to ~/.claude/commands/
   ai-consultants version                      Show version
@@ -78,6 +79,10 @@ EOF
     shift
     exec "$SCRIPTS_DIR/doctor.sh" "$@"
     ;;
+  update-clis|update)
+    shift
+    exec "$SCRIPTS_DIR/update_clis.sh" "$@"
+    ;;
   init)
     shift
     FORCE=false

package/docs/COST_RATES.md

@@ -1,4 +1,4 @@
-# Cost Rates - AI Consultants v2.19.2
+# Cost Rates - AI Consultants v2.21.0
 
 This page documents the per-token rates used by the cost tracking system.
 

package/docs/SETUP.md

@@ -358,15 +358,19 @@ curl -L code.kimi.com/install.sh | bash
 
 Verify: `kimi --version`
 
-### MiniMax (API-only) - v2.10
+### MiniMax (CLI via mmx) - v2.21
 
-MiniMax requires an API key — no CLI installation needed.
+MiniMax runs via the `mmx` CLI by default (CLI-first, OAuth). Install and sign in:
 
 ```bash
-export MINIMAX_API_KEY="your-key"
-export ENABLE_MINIMAX=true
+npm install -g mmx-cli
+mmx auth login          # OAuth (browser); or: mmx auth login --api-key <key>
 ```
 
+API mode is opt-in: set `MINIMAX_USE_API=true` with `MINIMAX_API_KEY`.
+
+Verify: `mmx --version`
+
 ---
 
 ## Ollama (Local Models) - v2.2
@@ -521,7 +525,7 @@ INVOKING_AGENT=codex ./scripts/consult_all.sh "Question"
 
 ## CLI/API Mode Switching (v2.6+)
 
-Five consultants can switch between CLI mode (using local CLI tools) and API mode (direct API calls): **Gemini, Codex, Claude, Mistral, and Qwen3**.
+Six consultants can switch between CLI mode (using local CLI tools) and API mode (direct API calls): **Gemini, Codex, Claude, Mistral, Qwen3, and MiniMax**.
 
 ### Why Use API Mode?
 

package/docs/SMART_ROUTING.md

@@ -46,13 +46,21 @@ customization possible without editing bash.
 
 ```json
 {
-  "version": "1.0",
+  "version": "1.1",
   "default_score": 5,
   "general_score": 8,
+  "capability_default": 5,
   "known_consultants": ["Gemini", "Codex", "..."],
   "categories": {
     "CODE_REVIEW": { "Gemini": 7, "Codex": 10, "..." },
     "BUG_DEBUG":   { "..." }
+  },
+  "capabilities": {
+    "Gemini": { "intelligence": 8, "taste": 8, "cost": 6 },
+    "Codex":  { "intelligence": 8, "taste": 5, "cost": 4 }
+  },
+  "category_axis": {
+    "API_DESIGN": "taste", "CODE_REVIEW": "taste", "ALGORITHM": "intelligence"
   }
 }
 ```
@@ -119,6 +127,112 @@ COMPLEXITY_THRESHOLD_MEDIUM=6    # Score 4-6 = use standard models
 
 See [COST_RATES.md](COST_RATES.md) for model pricing by tier.
 
+## Capability-Aware Routing & Voting (v2.20+)
+
+Beyond category *fit* (the affinity matrix), v1.1 of `affinity.json` adds a
+per-consultant **capability** score on three axes (1-10): `intelligence`,
+`taste`, and `cost`. A `category_axis` map names the quality axis each category
+stresses — **taste** for design-shaped work (API_DESIGN, ARCHITECTURE,
+CODE_REVIEW, GENERAL), **intelligence** otherwise.
+
+Two opt-in features consume this:
+
+- **`ENABLE_CAPABILITY_WEIGHTING`** — a consultant's vote weight becomes
+  `confidence × (S + capability) / S` (`S = CAPABILITY_WEIGHT_STRENGTH`, default
+  10), so on a taste-shaped question a high-taste model's opinion counts for more.
+- **`ENABLE_CAPABILITY_ROUTING`** — panel *eligibility* still uses raw affinity,
+  but the *sort rank* becomes `affinity + (capability − CAPABILITY_DEFAULT)`, so
+  under a size limit the quality axis reorders which eligible consultants make
+  the cut.
+
+`cost` is an efficiency axis for budget-aware composition only — **never** a
+vote weight (tie-break order: intelligence > taste > cost). Scores are
+subjective, point-in-time seeds — re-derive them for your own panel. Helpers:
+`get_capability <consultant> <axis>` and `get_category_axis <category>` in
+`lib/routing.sh`.
+
+## Roster Audit — Uncorrelated Value (v2.20+)
+
+Adding a consultant only helps if it says something the others don't. The
+`scripts/roster_audit.sh` tool measures this across past consultations: a
+consultant's approach is *distinct* in a round when its keyword set has low
+Jaccard overlap (`< --threshold`, default 20%) with **every** other consultant
+that round. A consultant that is rarely distinct is correlated with the panel —
+a candidate to drop or down-weight; one that is often distinct earns its seat on
+diversity.
+
+```bash
+# audit specific consultation output dirs
+./scripts/roster_audit.sh /path/to/consultation_dir ...
+
+# or the N most recent under the consultations base
+./scripts/roster_audit.sh --recent 30
+
+# machine-readable
+./scripts/roster_audit.sh --json --recent 30
+```
+
+Read-only; reuses the `voting.sh` keyword/Jaccard machinery. Consultations with
+fewer than two responders are skipped (correlation is undefined). This is the
+model-routing "before a new model earns a row" bar (contribute >=1 thing the
+incumbents miss) applied to the consultation panel instead of a review lane.
+
+## Measured Calibration — Replacing the Heuristic Seeds (v2.20+)
+
+The `capabilities` scores in `affinity.json` ship as subjective seeds. To
+**measure** them instead of guessing, three tools derive each axis from data the
+tool already produces — sliced by the same `category_axis` that consumes them:
+
+| Tool | Derives | From |
+|---|---|---|
+| `scripts/roster_calibrate.sh` | intelligence, taste, cost (**Tier A**) | blind peer-review scores (sliced by axis) + observed `tokens_used` × catalog rate |
+| `scripts/taste_elo.sh` | taste (**Tier B**) | pairwise LLM-as-judge Elo over taste-axis answers (removes peer self-bias) |
+| `references/calibration_benchmark.json` | the question set | 50 questions, 5 per category, balanced across the two axes |
+| `scripts/run_calibration.sh` | the data | runs the benchmark through the panel with `ENABLE_PEER_REVIEW=true`, then calibrates |
+
+### Workflow
+
+```bash
+# 1. Collect data: run the benchmark through the full panel (real calls — costs money).
+./scripts/run_calibration.sh --limit 10 --dry-run   # preview
+./scripts/run_calibration.sh                         # full 50-question run
+
+# 2. Tier A: measured intelligence/taste/cost -> capabilities block
+./scripts/roster_calibrate.sh --recent 50            # print measured block
+./scripts/roster_calibrate.sh --recent 50 --write    # merge into affinity.json (keeps unmeasured cells)
+
+# 3. Tier B (optional): refine taste via pairwise-judge Elo
+./scripts/taste_elo.sh --recent 50 --write
+```
+
+Both `roster_calibrate.sh` and `taste_elo.sh` also accept explicit consultation
+dirs and `--json`, and back up `affinity.json` to `.bak` before `--write`.
+
+### How each axis is measured
+
+- **cost** — mean *observed* `$/response` (`tokens_used` × catalog rate, 60/40
+  input/output split), rank-normalized so the cheapest = 10. This is cost per
+  *task* (verbosity + completion), not per-token sticker price — a terse pricey
+  model can still rank cheap.
+- **intelligence / taste** — mean **blind peer-review** `quality_score` (already
+  1-10), sliced by `category_axis`: intelligence = performance on
+  intelligence-axis categories, taste = on taste-axis categories.
+- **taste (Tier B)** — taste has no ground truth, so `taste_elo.sh` measures it
+  *relative to a chosen judge*. Each pair of answers on a taste-axis question is
+  shown to the judge, which picks the better one on design taste only; wins feed
+  an Elo ranking. The judge is pluggable:
+  - `JUDGE_CLI` — CLI for the built-in judge (default `claude`).
+  - `TASTE_JUDGE_CMD` — external judge `cmd <ctx> <A.json> <B.json>` printing
+    `A`/`B` (used by tests and custom judges).
+
+### Companion: which consultants earn a seat
+
+`roster_audit.sh` (above) answers *who to keep*; calibration answers *how much
+each is worth per axis*. Together they make the roster data-driven: audit to
+prune redundant consultants, calibrate to score the survivors, then enable
+`ENABLE_CAPABILITY_WEIGHTING` / `ENABLE_CAPABILITY_ROUTING` to act on the
+measured scores.
+
 ## Timeout per Category
 
 Timeouts optimized based on category complexity:

package/docs/cost_rates.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.19.2",
+  "version": "2.21.0",
   "updated": "2026-06-24",
   "models": {
     "_comment_units": "All rates are USD per 1,000 tokens (per-1K). lib/costs.sh computes cost as (token_count / 1000) * rate, so every value here MUST be a per-1K rate = (provider $/1M price) / 1000. Do NOT paste $/MTok figures directly.",

package/docs/releases/v2.20.0.md

@@ -0,0 +1,65 @@
+# Release v2.20.0
+
+**Date:** 2026-07-12
+**Type:** Minor — capability-aware deliberation + measured roster calibration
+**Previous:** v2.19.2
+
+## Highlights
+
+- **Capability-aware voting & composition** — weight votes and rank the panel by each model's capability on the quality axis a question stresses (intelligence or taste). Opt-in.
+- **Roster audit** — see which consultants add distinct value vs merely echo the panel.
+- **Measured calibration** — derive the capability scores from data (blind peer review + observed cost + pairwise-judge Elo) instead of heuristics.
+- Everything new is opt-in and additive: with the flags off, behavior is identical to v2.19.2.
+
+## What's New
+
+### Capability axes (`affinity.json` v1.1)
+
+Beyond category *fit* (the affinity matrix), each consultant now has a `capabilities` score on three axes (1-10) and a `category_axis` map names the quality axis each category stresses — **taste** for API_DESIGN / ARCHITECTURE / CODE_REVIEW / GENERAL, **intelligence** otherwise.
+
+| Flag (default off) | Effect |
+|---|---|
+| `ENABLE_CAPABILITY_WEIGHTING` | A consultant's vote weight becomes `confidence × (S + capability) / S` on the run's axis (`S = CAPABILITY_WEIGHT_STRENGTH`, default 10). |
+| `ENABLE_CAPABILITY_ROUTING` | Panel *eligibility* still uses raw affinity, but eligible consultants are ranked by `affinity + capability`, so under a size limit the quality axis reorders who makes the cut. |
+
+`cost` is a composition/budget axis only — never a vote weight (tie-break order: intelligence > taste > cost).
+
+### Roster audit — uncorrelated value
+
+`scripts/roster_audit.sh` scores each consultant's *distinctiveness* across past consultations: an approach with low keyword overlap versus every other consultant that round is "distinct". A consultant rarely distinct is correlated with the panel (candidate to drop or down-weight); one often distinct earns its seat. Also available as `doctor.sh --roster-audit` and the `/ai-consultants:roster-audit` slash command. Read-only.
+
+### Measured calibration (Tier A + Tier B)
+
+Replace the heuristic capability seeds with measurements, each derived from a signal the tool already records and sliced by the same `category_axis`:
+
+- **`scripts/roster_calibrate.sh` (Tier A)** — intelligence/taste = mean **blind peer-review** score on that axis's categories; cost = mean **observed** `tokens_used` × catalog rate (60/40 split, rank-normalized, cheapest = 10 → cost per *task*, not per token).
+- **`scripts/taste_elo.sh` (Tier B)** — taste via **pairwise LLM-as-judge Elo** on taste-axis answers (removes the peer panel's self-bias). Judge is pluggable: `JUDGE_CLI` (default `claude`) or `TASTE_JUDGE_CMD`.
+- **`scripts/run_calibration.sh` + `references/calibration_benchmark.json`** — 50 questions (20 taste / 30 intelligence) run through the panel with `ENABLE_PEER_REVIEW=true`, then calibrated.
+
+Both calibrators accept `--json` and `--write` (merge measured scores into `affinity.json`, backing it up first).
+
+## Breaking Changes
+
+None. All features are opt-in; with the flags off, behavior is identical to v2.19.2. The shipped `capabilities` scores are subjective seeds (Claude/Codex grounded on the model-routing table, the rest heuristic) until you run the calibration workflow.
+
+## Upgrade Guide
+
+```bash
+cd ~/.claude/skills/ai-consultants && git pull   # or: npx ai-consultants@latest install
+```
+
+Optional — measure capability scores for your own panel:
+
+```bash
+./scripts/run_calibration.sh              # collect data (real calls; --limit to sample)
+./scripts/roster_calibrate.sh --write     # Tier A: intelligence/taste/cost -> affinity.json
+./scripts/taste_elo.sh --write            # Tier B: refine taste (optional)
+```
+
+## Commits
+
+- `_______` feat: capability-aware voting/routing + roster audit + measured calibration (v2.20.0)
+
+## Contributors
+
+- @matteoscurati

package/docs/releases/v2.21.0.md

@@ -0,0 +1,65 @@
+# Release v2.21.0
+
+**Date:** 2026-07-14
+**Type:** Minor — CLI-first transport, MiniMax on the mmx CLI, `update-clis`, and opt-in stance consensus
+**Previous:** v2.20.0
+
+## Highlights
+
+- **CLI-first is now the rule.** Any consultant that ships a CLI uses it by default; API mode is opt-in — only for CLI-less models or an explicit `*_USE_API=true`. Amp and Claude are on by default.
+- **MiniMax runs on the `mmx` CLI** (it was API-only). Existing API-only setups keep working: `MINIMAX_USE_API` auto-resolves to API mode only when `MINIMAX_API_KEY` is set.
+- **`ai-consultants update-clis`** keeps every consultant CLI current, detecting how each was installed.
+- **Stance-based semantic consensus** (opt-in): the panel picks from a shared set of enumerated stance options, so agreement is scored by exact match instead of lexical similarity.
+- A batch of smoke-test-surfaced reliability fixes across the Gemini/Kimi/Kilo adapters and the voting/synthesis pipeline, plus a runtime persona fix. Hardened by a multi-agent `/code-review max` pass.
+
+## What's New
+
+### CLI-first transport
+
+Every `*_USE_API` flag now defaults to `false`. A consultant with a CLI always uses it; API mode is reserved for models without a CLI or an explicit opt-in. `ENABLE_AMP` and `ENABLE_CLAUDE` default on.
+
+### MiniMax via the `mmx` CLI
+
+`query_minimax.sh` runs `mmx text chat --non-interactive --quiet --no-color --output text …` by default. `MINIMAX_CMD` (default `mmx`) sets the binary. To preserve pre-2.21 behavior, `MINIMAX_USE_API` auto-resolves:
+
+- `MINIMAX_API_KEY` set → API mode (the only transport before 2.21 — nothing breaks on upgrade).
+- otherwise → the `mmx` CLI.
+
+An explicit `MINIMAX_USE_API=true|false` always wins. `doctor` validates the CLI in CLI mode and the key in API mode.
+
+### `update-clis`
+
+```bash
+ai-consultants update-clis            # update every installed consultant CLI
+ai-consultants update-clis --dry-run  # show each CLI's install method + the exact update command
+ai-consultants update-clis --only mmx # limit to one CLI (by consultant name or binary)
+```
+
+For each CLI-backed consultant it detects the install method — brew formula/cask, npm, uv, pipx, pip, a self-updating binary, or a curl installer — and updates it via the matching command, best-effort.
+
+### Stance-based semantic consensus (opt-in)
+
+| Flag (default) | Effect |
+|---|---|
+| `ENABLE_STANCE_CONSENSUS` (false) | One LLM call enumerates 2–`STANCE_MAX_OPTIONS` mutually-exclusive stance options for the question; each consultant picks one verbatim; consensus = the plurality stance's share of the **panel**. |
+| `STANCE_MAX_OPTIONS` (5) | Cap on the generated option set. |
+| `STANCE_TIMEOUT` (60) | Seconds for the stance-generation call (guards a blocking/unauthenticated synthesizer at startup). |
+
+The lexical cluster (Jaccard over the free-text `approach`) can't tell that "Commit the lockfile" and "Always keep package-lock in git" agree; the stance signal makes agreement exact-matchable. Every path degrades to the lexical cluster if fewer than two stances are emitted or generation fails, so it is always safe to enable. The generated options are written to `stance_options.json` in the output dir.
+
+### Reliability fixes
+
+- **CLI adapters** (from a full-panel smoke test): Gemini (`agy -p "$QUERY"`, not the broken `-p -`), Kimi (`--output-format stream-json` + a hardened extractor), and Kilo (strip the ```json fence) return structured responses instead of the unstructured fallback.
+- **Metadata pollution**: a shared `_is_consultant_response_file` filter keeps pipeline files (`voting.json`, `orchestration.json`, `stance_options.json`, …) out of every voting/synthesis/peer-review glob, so they can't become phantom votes, reviewees, or synthesis inputs. Consensus is the largest agreeing cluster (single-linkage over Jaccard).
+- **Orchestration**: a lexical "stalled" is relabeled "stable" when the panel's own per-round signal says positions stopped moving (now `set -e`-safe against a malformed round summary); a debate round's refined stance is validated before it is grafted.
+- **Personas**: GLM and DeepSeek were transposed at runtime — each consultant ran under the other's persona name and prompt. Fixed.
+
+### Under the hood
+
+Reliability tracking with Amp/Claude default-on; an offline end-to-end integration test; `scripts/release.sh` version-bump automation; calibration fixes (diagnosable peer-review failures + a cost-only path). `npm test` now runs 18 suites.
+
+## Upgrade notes
+
+- **Fully back-compat.** With the new flags off, behavior matches v2.20.0.
+- **MiniMax users**: if you ran MiniMax via `MINIMAX_API_KEY`, nothing changes — it stays on the API. To switch to the CLI, `npm install -g mmx-cli` and `mmx auth login`, then unset the key (or set `MINIMAX_USE_API=false`).
+- **New opt-in flags**: `ENABLE_STANCE_CONSENSUS`, `STANCE_MAX_OPTIONS`, `STANCE_TIMEOUT`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-consultants",
-  "version": "2.19.2",
+  "version": "2.21.0",
   "description": "A harness for every question - a panel of up to 15 AI models that picks its own deliberation strategy per question (convergence, adversarial verification, tournament) and checks its work before answering",
   "bin": {
     "ai-consultants": "bin/ai-consultants"