ai-consultants 2.25.0 → 2.25.1

package/CLAUDE.md

@@ -6,7 +6,7 @@ AI Consultants is a multi-model AI deliberation system that queries up to 11 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.25.0
+**Version**: 2.25.1
 
 ## Distribution
 
@@ -801,6 +801,16 @@ curl -fsSL https://raw.githubusercontent.com/matteoscurati/ai-consultants/main/s
 
 ## Changelog
 
+### v2.25.1
+- **Six defects found by an independent review of the released v2.25.0** (Codex `gpt-5.6-sol`, effort high, read-only via the `sol-reviewer` profile). Five were reproduced locally by executing the shipped functions before accepting them; the bash 3.2 crash was verified by the reviewer against `/bin/bash 3.2.57`.
+- **`calculate_final_score` scored every consultant as a dissenter.** `calculate_weighted_recommendation` emitted `_map_sanitize_key`'s output (spaces and punctuation stripped) as the winner, while `calculate_final_score` compared the raw `.response.approach` against it. Unanimous multiword panels scored 2/10, single-word panels 10/10. Voting now keeps original strings in bash 3.2-compatible indexed arrays. **The shipped voting tests used single-word approaches, which is exactly why this survived every prior review** — when writing a voting fixture, use a realistic multiword approach.
+- **v2.25.0's recursive billing scan was too wide.** It was made recursive to reach `round_N/`, which also captured `peer_review/` — anonymized copies carry the original `tokens_used`, bookkeeping files take the `// 1000` fallback. Now scoped to root + `round_<digits>/`. `_is_consultant_response_file` became a shape check (object, non-empty `.consultant`, object `.response`) instead of a six-name denylist; it gates 16 call sites across voting/synthesis/peer-review/costs, and was verified to still accept error responses, which must stay counted for quorum.
+- **`select_consultants` returned disabled and self-excluded consultants.** Eligibility lived only in `consult_all.sh`'s non-smart branch. Now applied in `routing.sh` where the output is consumed, with `declare -f` guards; custom-agent discovery was extracted to `_list_custom_api_agents` (common.sh) and is shared with `_discover_custom_api_agents`.
+- **Consensus used connected components**, so similarity being non-transitive produced 100% for `alpha beta`/`beta gamma`/`gamma delta`. Replaced with an exact maximum-clique search with branch-and-bound. Worst case is exponential; measured 1s at 11 consultants and 4s at 30, and the panel is bounded by the roster.
+- **The CI caught a test that passed locally for the wrong reason — read this before trusting a local green.** `test_suite.sh` asserted DeepSeek is selected for QUICK_SYNTAX without enabling it; `ENABLE_DEEPSEEK` defaults to false, so once routing honoured `ENABLE_*` the assertion only held for someone whose user config enables it. It passed on the maintainer's machine and failed on Ubuntu. **`npm test` from your own shell is not a clean signal**: `load_user_config` exports `~/.config/ai-consultants/.env` into every suite. Verify with `AI_CONSULTANTS_CONFIG_DIR=<empty dir> npm test`, which is the condition CI runs in. Note `env -i` is NOT the right harness — it strips variables the tests legitimately need and makes `test_context_optimization.sh` fail on unmodified HEAD.
+- **`estimate_tokens ""` read stdin, and it hung the release gate for hours.** The function chose stdin-vs-argument by emptiness (`[[ -z "$text" ]]`), so an explicit empty string was indistinguishable from no argument and fell through to `cat`. `test_suite.sh` calls `estimate_tokens ""`; with stdin closed (CI, background tasks piping from /dev/null) `cat` gets EOF and returns 0 — the "empty string: 0 tokens" assertion passes by accident. With stdin an open pipe (an interactive-ish local gate run) it blocks forever. `release.sh`'s gate wedged for ~10h on exactly this, and an earlier run had left a second orphaned tree hung ~16h. Fixed at the source: decide by `$#`, not emptiness — `estimate_tokens ""` now returns 0 without touching stdin, and only a genuinely arg-less call reads it. Regression test drives it under a never-closing fifo with `run_with_timeout`, so a re-hang is a FAIL not an infinite run. **This is a third hermeticity axis after `LOG_LEVEL` and the user config: a suite can pass or hang depending on whether stdin is closed.** The lesson compounds — several "22/22 passed" reports earlier in this work were real only because their stdin happened to be closed; the gate was never as green as it read.
+- **Deliberately unchanged**: peer review still runs after voting and synthesis, so its scores cannot alter the recommendation the docs call a "refutation gate". That is an architectural decision, not a bug fix. The same review also judged the panel premise itself weak — it measures agreement rather than correctness, and no held-out comparison against a single strong model exists in the repo.
+
 ### v2.25.0
 - **`tokens_used` was hardcoded to 0, so the cost report priced pipeline metadata and nothing else.** `build_response_metadata` (`lib/common.sh`) emitted a literal `tokens_used: 0` and was the only writer of that field in the repo; `calculate_session_cost` (`lib/costs.sh:248`) multiplies it by the model rate. Structurally zero for all 11 consultants, both transports, since the field existed. **Do not describe this as "every session reported $0.00"** — I did, in three changelogs, and it is wrong: the pipeline files caught by the same unfiltered glob have no `tokens_used` key at all, so they took the `// 1000` fallback at the default rate (~$0.009 each). Measured against HEAD on a realistic three-consultant directory, v2.24 reports **$0.0270**, entirely phantom. The reported number tracked how many pipeline stages ran. Worse in API mode: `run_api_mode_query` (`lib/api_query.sh:154`) called `extract_token_usage`, which computes the right number (verified: extracts 85 from a live Token Plan body), `log_debug`'d it, and dropped it on the floor.
 - **Four paths write response metadata**, which is why the fix is spread out: `process_consultant_response` (codex/cursor/gemini/kimi/minimax/qwen3), direct builder calls (claude/mistral), `run_api_consultant` (glm/deepseek/grok), and the error path. All converge on `build_response_metadata`, so that is where the new `tokens`/`tokens_source` parameters land; the builders thread them through and default to `0`/`unknown` so pre-existing 5-arg calls still work.

package/README.md

@@ -1,8 +1,8 @@
-# AI Consultants v2.25.0
+# AI Consultants v2.25.1
 
 > **A harness for every question.** A panel of up to 11 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.25.0-blue.svg)](https://github.com/matteoscurati/ai-consultants)
+[![Version](https://img.shields.io/badge/version-2.25.1-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)

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.25.0
+  version: 2.25.1
 ---
 
-# AI Consultants v2.25.0 - AI Expert Panel
+# AI Consultants v2.25.1 - 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.
 

package/docs/COST_RATES.md

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

package/docs/cost_rates.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.25.0",
+  "version": "2.25.1",
   "updated": "2026-07-16",
   "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.25.1.md

@@ -0,0 +1,77 @@
+# Release v2.25.1
+
+**Date:** 2026-07-21
+**Type:** Patch — six defects found by an independent review of v2.25.0
+**Previous:** v2.25.0
+
+## Highlights
+
+- **The final score said 2/10 even when every consultant agreed.** Fixed.
+- **Peer-review artifacts were being billed as consultations** — a regression introduced by v2.25.0's own cost work.
+- **Smart routing queried consultants you had disabled**, and billed them.
+- Gemini API-mode calls were costed as the wrong model.
+- Peer review crashed on the stock macOS shell.
+- Consensus reported 100% for panels that genuinely disagreed.
+
+## What's New
+
+### The score was wrong on essentially every consultation
+
+The recommendation was emitted as a key with spaces and punctuation stripped, while scoring compared each consultant's original answer against that stripped version. Nothing ever matched, so every consultant was counted as a dissenter.
+
+| Answer | Score |
+|---|---|
+| `Use JWT with rotating sessions` | 2/10 |
+| `JWT` | 10/10 |
+
+Same panel, same unanimity, same confidence. Real answers are multiword.
+
+The same stripping merged genuinely different options: `Use JWT + sessions` and `Use JWT sessions` collapsed into one. Both are fixed, and the voting tests now use realistic multiword answers — using single-word ones is why this survived.
+
+### A regression from v2.25.0
+
+v2.25.0 made the cost scan recursive so it would reach debate rounds. That also reached everything peer review writes below the response directory: anonymized copies keep the original token counts, and bookkeeping files fall back to 1000 tokens each. A run whose real cost was $0.125 reported $0.244.
+
+Billing now covers the responses and the debate rounds and nothing else, and a response is recognised by its structure rather than by its filename.
+
+### Disabled consultants were being queried
+
+`ENABLE_*` and self-exclusion were applied only on the non-smart path. With `ENABLE_SMART_ROUTING=true`, a consultant you had disabled — or the agent invoking the skill — could still be sent the question and billed. Custom API agents were excluded from smart routing entirely; they are now included.
+
+### The rest
+
+- **Gemini API mode** sent `GEMINI_API_MODEL` but recorded `GEMINI_MODEL`, mispricing by 2.24x.
+- **Peer review** used two bash 4 constructs under `/bin/bash` 3.2, the stock macOS shell that `doctor` reports as supported.
+- **Consensus** grouped answers transitively, so A resembling B and B resembling C put A and C together even with nothing in common. Groups now require their members to resemble each other, which also prevents a convergence loop ending early on false agreement.
+
+## Breaking Changes
+
+None. No configuration key, default, or output field changed.
+
+Two numbers will move, both because they were wrong: the final score rises on any panel that agreed on a multiword answer, and consensus falls on panels that were being merged transitively.
+
+## Upgrade Guide
+
+```bash
+# If installed via git clone
+cd ~/.claude/skills/ai-consultants && git pull
+
+# If installed via curl | bash
+curl -fsSL https://raw.githubusercontent.com/matteoscurati/ai-consultants/main/scripts/install.sh | bash
+```
+
+No configuration changes required.
+
+## Verification
+
+Each fix carries a regression test observed failing before the change. `npm test` covers 22 suites.
+
+One test in this release passed locally and failed in CI: it asserted a consultant was selected without enabling it, and `ENABLE_DEEPSEEK` defaults to false — so it held only for a maintainer whose own config enabled it. Verify with the user config neutralised, which is the condition CI runs in:
+
+```bash
+AI_CONSULTANTS_CONFIG_DIR=$(mktemp -d) npm test
+```
+
+## Contributors
+
+- @matteoscurati

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-consultants",
-  "version": "2.25.0",
+  "version": "2.25.1",
   "description": "A harness for every question - a panel of up to 11 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"

package/scripts/config.sh

@@ -861,4 +861,4 @@ EOF
 # VERSION
 # =============================================================================
 
-AI_CONSULTANTS_VERSION="2.25.0"
+AI_CONSULTANTS_VERSION="2.25.1"

package/scripts/consult_all.sh

@@ -46,25 +46,12 @@ source "$SCRIPT_DIR/lib/orchestration.sh"
 # Discovers custom API agents from environment variables
 # Convention: ENABLE_AGENTNAME=true with AGENTNAME_API_URL set
 _discover_custom_api_agents() {
-    while IFS='=' read -r var value; do
-        [[ "$var" != ENABLE_* ]] && continue
-        [[ "$value" != "true" ]] && continue
-
-        local agent_upper="${var#ENABLE_}"
-
-        # Skip known agents (uses helper from common.sh)
-        is_known_agent "$agent_upper" && continue
-
-        # Check if it has an API URL configured (indicates it's an API agent)
-        local url_var="${agent_upper}_API_URL"
-        [[ -z "${!url_var:-}" ]] && continue
-
-        # Add custom API agent with proper case
-        local agent_name
-        agent_name=$(to_title "$agent_upper")
+    local agent_name
+    while IFS= read -r agent_name; do
+        [[ -n "$agent_name" ]] || continue
         SELECTED_CONSULTANTS+=("$agent_name")
         log_debug "Discovered custom API agent: $agent_name"
-    done < <(env)
+    done < <(_list_custom_api_agents | sort -u)
 }
 
 # --- Show usage help ---

package/scripts/lib/common.sh

@@ -302,6 +302,23 @@ is_known_agent() {
     return 1
 }
 
+# List enabled custom API consultants discovered from the environment.
+# Convention: ENABLE_AGENTNAME=true plus AGENTNAME_API_URL. Known consultants
+# and non-consultant feature flags are excluded by the shared registry.
+_list_custom_api_agents() {
+    local var value agent_upper url_var agent_name
+    while IFS='=' read -r var value; do
+        [[ "$var" == ENABLE_* && "$value" == "true" ]] || continue
+        agent_upper="${var#ENABLE_}"
+        is_known_agent "$agent_upper" && continue
+
+        url_var="${agent_upper}_API_URL"
+        [[ -n "${!url_var:-}" ]] || continue
+        agent_name=$(to_title "$agent_upper")
+        printf '%s\n' "$agent_name"
+    done < <(env)
+}
+
 # =============================================================================
 # CLI/API MODE SWITCHING (v2.6)
 # =============================================================================
@@ -892,9 +909,16 @@ get_panic_diagnosis() {
 # Uses ~4 characters per token approximation for English text
 # Usage: estimate_tokens "text" or echo "text" | estimate_tokens
 estimate_tokens() {
-    local text="${1:-}"
-    if [[ -z "$text" ]]; then
-        # Read from stdin if no argument
+    local text
+    # Decide by argument COUNT, not emptiness: `estimate_tokens ""` is an
+    # explicit empty string (0 tokens), not a request to read stdin. Keying on
+    # `-z` made the two indistinguishable, so an empty-string call fell through
+    # to `cat` and blocked forever whenever stdin was an open pipe rather than
+    # closed/EOF — a hang that passed in CI (stdin is /dev/null there) and wedged
+    # local gate runs. Only a genuinely arg-less call reads stdin.
+    if [[ $# -gt 0 ]]; then
+        text="$1"
+    else
         text=$(cat)
     fi
     local chars
@@ -1117,22 +1141,19 @@ _kimi_extract_content() {
     ' "$1" 2>/dev/null
 }
 
-# consult_all.sh writes non-consultant pipeline metadata (orchestration.json,
-# panic_diagnosis.json, voting.json, synthesis.json, optimization_metrics.json,
-# stance_options.json) into the SAME dir as per-consultant responses. None carry .consultant /
-# .response.approach, so an unfiltered glob turns them into phantom "unknown"
-# votes / peer-review reviewees / synthesis inputs. Every loop that globs the
-# responses dir for consultant data must gate on this. Shared by voting.sh,
-# peer_review.sh, synthesize.sh.
+# Validate the response envelope rather than guessing from filenames. Pipeline
+# metadata and peer-review artifacts can use arbitrary names, while anonymous
+# copies deliberately remove the consultant identity. Every loop that consumes
+# consultant responses must gate on the actual shape. Shared by voting.sh,
+# peer_review.sh, synthesize.sh, and costs.sh.
 _is_consultant_response_file() {
     local f="$1"
     [[ -f "$f" && -s "$f" ]] || return 1
-    # ${f##*/} is an in-process basename (no fork) -- this runs in hot voting loops.
-    case "${f##*/}" in
-        orchestration.json|panic_diagnosis.json|voting.json|synthesis.json|optimization_metrics.json|stance_options.json)
-            return 1 ;;
-    esac
-    return 0
+    jq -e '
+        type == "object" and
+        (.consultant | type == "string" and length > 0) and
+        (.response | type == "object")
+    ' "$f" >/dev/null 2>&1
 }
 
 # Extract a concise, ANSI-stripped failure reason from a consultant's captured

package/scripts/lib/costs.sh

@@ -266,23 +266,41 @@ is_unpriced_model() {
 # before v2.25.0 made tokens_used non-zero and turned them into money:
 #   - only consultant responses (voting.json and friends carry no tokens_used
 #     and would each be priced at the `// 1000` fallback times the default rate);
-#   - debate/peer-review rounds live in `round_N/` subdirectories and are
-#     separate billed queries, so the glob must recurse;
+#   - debate rounds live in `round_N/` subdirectories and are separate billed
+#     queries, so those directories must be included without recursing into
+#     derived peer-review trees;
 #   - a cache hit made no API call, and `<consultant>_escalated.json` is a copy
 #     of a file already counted, so both are excluded.
 _billable_response_files() {
     local responses_dir="$1"
     [[ -d "$responses_dir" ]] || return 0
 
-    local f
-    while IFS= read -r f; do
+    local f round_dir round_name
+    for f in "$responses_dir"/*.json "$responses_dir"/round_*/*.json; do
         [[ -f "$f" && -s "$f" ]] || continue
-        [[ "$(basename "$f")" == *_escalated.json ]] && continue
+
+        # Nested billable files are allowed only one level below an exact
+        # round_<digits> directory. Peer-review and other derived trees are not
+        # provider queries and must never reach the token fallback.
+        if [[ "${f%/*}" != "$responses_dir" ]]; then
+            round_dir="${f%/*}"
+            round_name="${round_dir##*/}"
+            case "$round_name" in
+                round_[0-9]*)
+                    case "${round_name#round_}" in
+                        *[!0-9]*) continue ;;
+                    esac
+                    ;;
+                *) continue ;;
+            esac
+        fi
+
+        [[ "${f##*/}" == *_escalated.json ]] && continue
         _is_consultant_response_file "$f" 2>/dev/null || continue
         # A cache hit is a replay of an earlier response, metadata included.
         [[ "$(jq -r '.cache_metadata.from_cache // false' "$f" 2>/dev/null)" == "true" ]] && continue
         printf '%s\n' "$f"
-    done < <(find "$responses_dir" -type f -name '*.json' 2>/dev/null | sort)
+    done
 }
 
 # Calculate total session cost from responses

package/scripts/lib/routing.sh

@@ -183,10 +183,12 @@ select_consultants() {
     local min_affinity="${2:-7}"
     local max_consultants="${3:-8}"
 
-    # Include all consultants (order matches ALL_CONSULTANTS in config.sh)
+    # Known roster order matches ALL_CONSULTANTS in config.sh. Eligibility is
+    # applied here because smart-routing callers consume this output directly.
     local consultants=("Gemini" "Codex" "Mistral" "Cursor" "Kimi" "Claude" "Qwen3" "GLM" "Grok" "DeepSeek" "MiniMax")
     local selected=()
     local scores=()
+    local custom_consultants=()
 
     # Collect affinities. When capability-aware routing is on, the ELIGIBILITY
     # filter still uses raw category affinity (same panel as before), but the
@@ -198,6 +200,14 @@ select_consultants() {
         _cap_axis=$(get_category_axis "$category")
     fi
     for c in "${consultants[@]}"; do
+        local consultant_flag enable_var
+        consultant_flag=$(printf '%s' "$c" | tr '[:lower:]' '[:upper:]')
+        enable_var="ENABLE_${consultant_flag}"
+        [[ "${!enable_var:-true}" == "true" ]] || continue
+        if declare -f should_skip_consultant >/dev/null 2>&1 && should_skip_consultant "$consultant_flag"; then
+            continue
+        fi
+
         local score=$(get_affinity "$category" "$c")
         if [[ $score -ge $min_affinity ]]; then
             local rank=$score
@@ -211,6 +221,15 @@ select_consultants() {
         fi
     done
 
+    # Custom agents have no affinity entry. Their explicit ENABLE_* + API URL
+    # configuration is the eligibility signal, so reserve panel slots for them
+    # after affinity-ranked known consultants instead of silently omitting them.
+    if declare -f _list_custom_api_agents >/dev/null 2>&1; then
+        while IFS= read -r c; do
+            [[ -n "$c" ]] && custom_consultants+=("$c")
+        done < <(_list_custom_api_agents | sort -u)
+    fi
+
     # Sort by score (simple bubble sort)
     local n=${#selected[@]}
     for ((i=0; i<n-1; i++)); do
@@ -228,15 +247,23 @@ select_consultants() {
         done
     done
 
-    # Limit to maximum requested
+    # Limit to the requested panel size while keeping room for configured
+    # custom agents, which are appended in stable name order.
     local count=0
+    local known_limit=$(( max_consultants - ${#custom_consultants[@]} ))
+    [[ $known_limit -lt 0 ]] && known_limit=0
     for c in ${selected[@]+"${selected[@]}"}; do
-        if [[ $count -ge $max_consultants ]]; then
+        if [[ $count -ge $known_limit ]]; then
             break
         fi
         echo "$c"
         count=$((count + 1))
     done
+    for c in ${custom_consultants[@]+"${custom_consultants[@]}"}; do
+        [[ $count -ge $max_consultants ]] && break
+        echo "$c"
+        count=$((count + 1))
+    done
 }
 
 # Get the list of consultants as JSON

package/scripts/lib/voting.sh

@@ -135,6 +135,49 @@ _jaccard_similarity() {
     fi
 }
 
+# Exact maximum-clique search over the approach-similarity graph. Candidates
+# are space-separated numeric indices; each recursive level keeps only nodes
+# adjacent to every node already chosen. The default panel is at most eleven,
+# so this bounded backtracking stays small while avoiding order-dependent or
+# transitive clustering. Globals are used because Bash 3.2 has no namerefs.
+_CONSENSUS_NEIGHBORS=()
+_CONSENSUS_MAX_CLUSTER=0
+_find_largest_pairwise_cluster() {
+    local candidates="$1"
+    local chosen_count="$2"
+    local candidate remaining_count=0 other next_candidates neighbors
+
+    if [[ $chosen_count -gt $_CONSENSUS_MAX_CLUSTER ]]; then
+        _CONSENSUS_MAX_CLUSTER=$chosen_count
+    fi
+
+    for candidate in $candidates; do
+        remaining_count=$((remaining_count + 1))
+    done
+    [[ $((chosen_count + remaining_count)) -le $_CONSENSUS_MAX_CLUSTER ]] && return
+
+    while [[ -n "$candidates" ]]; do
+        candidate="${candidates%% *}"
+        if [[ "$candidates" == *" "* ]]; then
+            candidates="${candidates#* }"
+        else
+            candidates=""
+        fi
+
+        next_candidates=""
+        neighbors=" ${_CONSENSUS_NEIGHBORS[$candidate]:-} "
+        for other in $candidates; do
+            if [[ "$neighbors" == *" $other "* ]]; then
+                next_candidates="${next_candidates:+$next_candidates }$other"
+            fi
+        done
+        _find_largest_pairwise_cluster "$next_candidates" $((chosen_count + 1))
+
+        remaining_count=$((remaining_count - 1))
+        [[ $((chosen_count + remaining_count)) -le $_CONSENSUS_MAX_CLUSTER ]] && return
+    done
+}
+
 # Calculate consensus score based on keyword overlap between approaches
 # Uses Jaccard similarity instead of exact string matching so that
 # "JWT tokens", "JWT-based auth", and "JSON Web Tokens" are recognized as similar.
@@ -198,7 +241,7 @@ calculate_consensus_score() {
         return
     fi
 
-    # Consensus = size of the LARGEST cluster of mutually-similar approaches
+    # Consensus = size of the LARGEST cluster of pairwise-similar approaches
     # (Jaccard >= threshold), as a percentage of all approaches. This asks
     # "does a majority agree?" rather than "is the whole panel mutually similar?"
     # -- the latter is structurally capped low whenever any single consultant
@@ -208,37 +251,32 @@ calculate_consensus_score() {
     # robust fix is a controlled-vocabulary stance field, tracked separately).
     local threshold=15
 
-    # Agglomerate: for each similar pair, merge their clusters (relabel). O(n^3)
-    # but n is tiny (<= panel size), so no Union-Find is needed at this scale.
-    local -a cluster
-    local i j
-    for ((i=0; i<total; i++)); do cluster[i]=$i; done
+    # Build the undirected similarity graph once, then find its exact maximum
+    # clique. Connected components are invalid here because similarity is not
+    # transitive: A~B and B~C does not imply A~C.
+    _CONSENSUS_NEIGHBORS=()
+    _CONSENSUS_MAX_CLUSTER=0
+    local i j candidates=""
+    for ((i=0; i<total; i++)); do
+        _CONSENSUS_NEIGHBORS[$i]=""
+        candidates="${candidates:+$candidates }$i"
+    done
     for ((i=0; i<total; i++)); do
         for ((j=i+1; j<total; j++)); do
             local sim
             sim=$(_jaccard_similarity "${keyword_sets[$i]}" "${keyword_sets[$j]}")
             if [[ $sim -ge $threshold ]]; then
-                local ci=${cluster[$i]} cj=${cluster[$j]} k
-                if [[ $ci -ne $cj ]]; then
-                    for ((k=0; k<total; k++)); do
-                        [[ ${cluster[$k]} -eq $cj ]] && cluster[$k]=$ci
-                    done
-                fi
+                _CONSENSUS_NEIGHBORS[$i]="${_CONSENSUS_NEIGHBORS[$i]:+${_CONSENSUS_NEIGHBORS[$i]} }$j"
+                _CONSENSUS_NEIGHBORS[$j]="${_CONSENSUS_NEIGHBORS[$j]:+${_CONSENSUS_NEIGHBORS[$j]} }$i"
             fi
         done
     done
 
-    # Largest cluster size / total, as a percentage. Cluster labels are indices
-    # 0..total-1, so a plain indexed array suffices (bash 3.2 has no assoc arrays).
-    local -a csize
-    for ((i=0; i<total; i++)); do csize[i]=0; done
-    local maxc=0 lbl
-    for ((i=0; i<total; i++)); do
-        lbl=${cluster[$i]}
-        csize[$lbl]=$(( csize[$lbl] + 1 ))
-        [[ ${csize[$lbl]} -gt $maxc ]] && maxc=${csize[$lbl]}
-    done
-    echo $(( maxc * 100 / total ))
+    _find_largest_pairwise_cluster "$candidates" 0
+    local max_cluster=$_CONSENSUS_MAX_CLUSTER
+    _CONSENSUS_NEIGHBORS=()
+    _CONSENSUS_MAX_CLUSTER=0
+    echo $(( max_cluster * 100 / total ))
 }
 
 # Determine the consensus level from a score
@@ -264,51 +302,55 @@ get_consensus_level() {
 # Output: JSON with the recommendation
 calculate_weighted_recommendation() {
     local responses_dir="$1"
-
-    # Clear any previous map state
-    map_clear "APPROACH_WEIGHTS"
-    map_clear "APPROACH_SUPPORTERS"
+    local -a approaches=()
+    local -a approach_weights=()
+    local -a approach_supporters=()
 
     # Resolve the capability-weighting axis once (empty when weighting is off)
     local _cap_axis
     _cap_axis=$(_voting_capability_axis)
 
-    # Collect weights for each approach
+    # Keep the original approach strings as indexed-array values. The generic
+    # Bash 3.2 map encodes keys as shell variable names, so using an approach as
+    # a map key loses punctuation and whitespace, cannot round-trip into the
+    # final score, and can merge distinct recommendations.
     for f in "$responses_dir"/*.json; do
         if _is_consultant_response_file "$f"; then
-            local consultant approach confidence current_weight current_supporters weight
+            local consultant approach confidence weight index i
             consultant=$(jq -r '.consultant // "unknown"' "$f" 2>/dev/null)
             approach=$(jq -r '.response.approach // "unknown"' "$f" 2>/dev/null)
             confidence=$(jq -r '.confidence.score // 5' "$f" 2>/dev/null)
 
-            # Add weight (capability-modulated when ENABLE_CAPABILITY_WEIGHTING)
             weight=$(_effective_vote_weight "$consultant" "$confidence" "$_cap_axis")
-            current_weight=$(map_get "APPROACH_WEIGHTS" "$approach")
-            map_set "APPROACH_WEIGHTS" "$approach" "$((${current_weight:-0} + weight))"
+            index=-1
+            for ((i=0; i<${#approaches[@]}; i++)); do
+                if [[ "${approaches[$i]}" == "$approach" ]]; then
+                    index=$i
+                    break
+                fi
+            done
 
-            # Add supporter
-            current_supporters=$(map_get "APPROACH_SUPPORTERS" "$approach")
-            if [[ -z "$current_supporters" ]]; then
-                map_set "APPROACH_SUPPORTERS" "$approach" "$consultant"
+            if [[ $index -lt 0 ]]; then
+                index=${#approaches[@]}
+                approaches+=("$approach")
+                approach_weights+=("$weight")
+                approach_supporters+=("$consultant")
             else
-                map_set "APPROACH_SUPPORTERS" "$approach" "${current_supporters},$consultant"
+                approach_weights[$index]=$(( approach_weights[$index] + weight ))
+                approach_supporters[$index]="${approach_supporters[$index]},$consultant"
             fi
         fi
     done
 
-    # Find the approach with the highest weight using map_keys
     local best_approach=""
     local best_weight=0
     local best_supporters=""
-    local approach weight
-
-    for approach in $(map_keys "APPROACH_WEIGHTS"); do
-        weight=$(map_get "APPROACH_WEIGHTS" "$approach")
-        weight="${weight:-0}"
-        if [[ $weight -gt $best_weight ]]; then
-            best_weight=$weight
-            best_approach="$approach"
-            best_supporters=$(map_get "APPROACH_SUPPORTERS" "$approach")
+    local i
+    for ((i=0; i<${#approaches[@]}; i++)); do
+        if [[ ${approach_weights[$i]} -gt $best_weight ]]; then
+            best_weight=${approach_weights[$i]}
+            best_approach="${approaches[$i]}"
+            best_supporters="${approach_supporters[$i]}"
         fi
     done
 
@@ -398,30 +440,36 @@ calculate_final_score() {
 # Usage: simple_majority_vote <json_responses_dir>
 simple_majority_vote() {
     local responses_dir="$1"
-
-    # Clear any previous map state
-    map_clear "MAJORITY_VOTES"
+    local -a approaches=()
+    local -a votes=()
 
     for f in "$responses_dir"/*.json; do
         if _is_consultant_response_file "$f"; then
-            local approach current_votes
+            local approach index i
             approach=$(jq -r '.response.approach // "unknown"' "$f" 2>/dev/null)
-            current_votes=$(map_get "MAJORITY_VOTES" "$approach")
-            map_set "MAJORITY_VOTES" "$approach" "$((${current_votes:-0} + 1))"
+            index=-1
+            for ((i=0; i<${#approaches[@]}; i++)); do
+                if [[ "${approaches[$i]}" == "$approach" ]]; then
+                    index=$i
+                    break
+                fi
+            done
+            if [[ $index -lt 0 ]]; then
+                approaches+=("$approach")
+                votes+=(1)
+            else
+                votes[$index]=$(( votes[$index] + 1 ))
+            fi
         fi
     done
 
-    # Find approach with most votes using map_keys
     local winner=""
     local max_votes=0
-    local approach votes
-
-    for approach in $(map_keys "MAJORITY_VOTES"); do
-        votes=$(map_get "MAJORITY_VOTES" "$approach")
-        votes="${votes:-0}"
-        if [[ $votes -gt $max_votes ]]; then
-            max_votes=$votes
-            winner="$approach"
+    local i
+    for ((i=0; i<${#approaches[@]}; i++)); do
+        if [[ ${votes[$i]} -gt $max_votes ]]; then
+            max_votes=${votes[$i]}
+            winner="${approaches[$i]}"
         fi
     done
 

package/scripts/peer_review.sh

@@ -141,7 +141,9 @@ run_consultant_review() {
     local prompt
     prompt=$(generate_review_prompt "$(cat "$anonymous_file")")
 
-    local timeout_var="${consultant^^}_TIMEOUT_SECONDS"
+    local consultant_upper timeout_var
+    consultant_upper=$(to_upper "$consultant")
+    timeout_var="${consultant_upper}_TIMEOUT_SECONDS"
     local timeout="${!timeout_var:-180}"
 
     log_debug "Running peer review by $consultant..."
@@ -382,8 +384,9 @@ main() {
     for reviewer in "${reviewers[@]}"; do
         local review_output="$reviews_dir/review_${reviewer}.json"
         run_consultant_review "$reviewer" "$output_dir/anonymous_responses.md" "$review_output" &
-        pids+=($!)
-        log_debug "Started review by $reviewer (PID: ${pids[-1]})"
+        local review_pid=$!
+        pids+=("$review_pid")
+        log_debug "Started review by $reviewer (PID: $review_pid)"
     done
 
     # Wait for all reviews

package/scripts/query_gemini.sh

@@ -99,7 +99,14 @@ END_TIME=$(get_timestamp_ms)
 LATENCY_MS=$((END_TIME - START_TIME))
 
 # --- Configuration for response building ---
-MODEL_USED="$GEMINI_MODEL"
+# Record the identifier actually sent to the provider so cost lookup uses the
+# matching rate table entry. CLI and API mode intentionally use different model
+# namespaces.
+if is_api_mode "gemini"; then
+    MODEL_USED="$GEMINI_API_MODEL"
+else
+    MODEL_USED="$GEMINI_MODEL"
+fi
 PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
 
 # --- Post-processing: use shared helper ---