ai-consultants 3.2.0 → 3.3.0

package/CLAUDE.md

@@ -6,7 +6,7 @@ AI Consultants is a multi-model coverage system that queries up to 11 AI consult
 
 **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**: 3.2.0
+**Version**: 3.3.0
 
 ## Distribution
 
@@ -787,6 +787,12 @@ curl -fsSL https://raw.githubusercontent.com/matteoscurati/ai-consultants/main/s
 
 ## Changelog
 
+### v3.3.0
+- **Grok and Kimi compatibility is now established from capabilities, not inferred from an installed binary or its version string.** `grok_cli_supports_required_interface` validates the complete headless parser surface inside the same isolated HOME/CWD boundary used for dispatch, while `grok_cli_exposes_requested_model` verifies both usable authentication and the exact `GROK_MODEL` in the CLI inventory (`scripts/query_grok.sh:85-154`). Kimi similarly checks prompt mode, `stream-json`, the provider inventory, and `KIMI_MODEL` before any request (`scripts/query_kimi.sh:45-79`). Compatible future and vendor-custom versions therefore continue to work without a release-specific allowlist; an interface that cannot enforce the adapter's contract fails before a model call.
+- **The observed CLI version is provenance only.** Successful Grok and Kimi responses add `metadata.cli_version` and `metadata.cli_compatibility="capability-probed"`; the shared schema documents both fields without making either required for other transports (`scripts/query_grok.sh:319-336`, `scripts/query_kimi.sh:126-138`, `scripts/lib/schema.json:169-180`). This deliberately does not introduce a blessed-version range: the version is useful for diagnosis, while compatibility is decided by the exercised command, output, and model surfaces.
+- **Optional capabilities remain optional.** Grok's `--no-auto-update` is used when the help surface advertises it, but its absence does not reject an otherwise compatible CLI. The capability probe itself uses `--help` and model/provider inventory commands; it does not send a consultation. Grok preserves its existing narrowly classified API fallback when the required CLI route is unavailable, while Kimi continues to fail closed because it has no API transport.
+- **Regression coverage pins the compatibility contract rather than today's binaries.** Grok's suite accepts an alternate compatible version, rejects an incomplete interface before dispatch, checks requested-model availability, and preserves the post-launch/API-fallback boundary (32 checks). Kimi's suite covers an alternate compatible version, an incomplete interface, and a missing requested model (8 checks). Full release gate: 17/17 suites; core suite: 299/299; ShellCheck green. Installed Grok 0.2.114 and Kimi 0.27.0 also passed no-model-call probes.
+
 ### v3.2.0
 - **Claude premium upgraded from Opus 4.8 to Opus 5.** The default `CLAUDE_MODEL`, premium/max/best tier, standalone adapter fallback, configuration examples, model table, and cost catalog now resolve to the canonical `claude-opus-5` ID (`scripts/config.sh:274`, `scripts/query_claude.sh:29`). Pricing remains $5/$25 per million tokens; `claude-opus-4-8` stays in the legacy catalog for historical responses and intentional pins.
 - **Opus 5 adaptive thinking is accounted for end to end.** Claude CLI mode now requests the JSON result envelope, extracts visible `.result`, aggregates provider usage across `modelUsage`, and persists the provider's exact `costUSD` (`scripts/query_claude.sh:72-126`, `scripts/lib/common.sh:904-980`, `scripts/lib/costs.sh:307-354`). This fixes the review finding that pricing only the visible answer undercounted hidden thinking and cache charges. The implementation deliberately prefers provider cost over reconstructing cache pricing from token totals.

package/README.md

@@ -1,8 +1,8 @@
-# AI Consultants v3.2.0
+# AI Consultants v3.3.0
 
 > **Coverage, not a single guess.** A panel of up to 11 frontier models from different vendors fans out on your question in parallel and hands you the *union* of what they collectively see — the risks, edge cases, and approaches a single model misses.
 
-[![Version](https://img.shields.io/badge/version-3.2.0-blue.svg)](https://github.com/matteoscurati/ai-consultants)
+[![Version](https://img.shields.io/badge/version-3.3.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)
@@ -388,7 +388,10 @@ to the xAI API only when the CLI is missing, cannot launch, or has no usable
 authentication and `GROK_API_KEY` is configured; post-launch request failures
 are surfaced without a silent API charge. Qwen3 and MiniMax can also switch
 from their CLI to API transport. Gemini, Codex, Claude, and Mistral are
-CLI/API switchable.
+CLI/API switchable. Grok and Kimi compatibility is capability-probed before
+dispatch: the requested model, headless arguments, and structured-output
+surface must be available. Any CLI version is accepted when those checks pass;
+the observed version is response provenance only.
 
 ### API-Only 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: 3.2.0
+  version: 3.3.0
 ---
 
-# AI Consultants v3.2.0 - AI Expert Panel
+# AI Consultants v3.3.0 - AI Expert Panel
 
 **Coverage, not a single guess.** Convene a panel of AI "consultants" from different vendors for coding questions: they fan out in parallel and you get the *union* of what they collectively see — the risks, edge cases, and approaches a single model misses. Each consultant has a **configurable persona** that decorrelates its analysis.
 
@@ -45,6 +45,11 @@ Configuration (presets, strategies, features, personas, API keys) can be managed
 
 **CLI/API Mode**: Gemini, Codex, Claude, Mistral, Qwen, Grok, and MiniMax can switch between CLI and API mode via `*_USE_API` environment variables. Grok is CLI-first on Grok Build with `grok-4.5` and falls back to the xAI API when the CLI cannot run. Gemini auto-selects API mode when `GEMINI_API_KEY` is set (no `agy` install needed) and the CLI otherwise.
 
+Grok and Kimi are compatible by capability rather than by CLI version. Before
+dispatch, their adapters verify the required headless arguments, requested
+model, and structured-output surface. Compatible version changes are accepted;
+the observed version is recorded only as response provenance.
+
 **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.
 
 ## Requirements

package/docs/COST_RATES.md

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

package/docs/JSON_SCHEMA.md

@@ -37,6 +37,8 @@ The schema is defined in `scripts/lib/schema.json` following JSON Schema Draft-0
     "tokens_output": 300,
     "latency_ms": 2345,
     "model_version": "gemini-3.1-pro-preview",
+    "cli_version": "0.27.0",
+    "cli_compatibility": "capability-probed",
     "timestamp": "2024-01-14T12:34:56Z"
   }
 }
@@ -209,6 +211,8 @@ Present only if Multi-Agent Debate is enabled (round >= 2):
 | `tokens_output` | integer | Completion tokens, when the provider reported them (API mode only) |
 | `latency_ms` | integer | Response time in ms |
 | `model_version` | string | Exact model version |
+| `cli_version` | string | Observed CLI version for provenance; never a compatibility gate |
+| `cli_compatibility` | string | Capability-probe result: `capability-probed` or `incompatible` |
 | `timestamp` | string | ISO 8601 timestamp |
 
 ## Enum Values

package/docs/cost_rates.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.0",
   "updated": "2026-07-25",
   "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/v3.3.0.md

@@ -0,0 +1,80 @@
+# Release v3.3.0
+
+**Date:** 2026-07-29
+**Type:** Minor — capability-based Grok and Kimi CLI compatibility
+**Previous:** v3.2.0
+
+## Highlights
+
+- Grok and Kimi now prove CLI compatibility from the interface they actually need, not from a version string.
+- Compatible future and vendor-custom CLI versions are accepted without a release-specific allowlist.
+- Incomplete interfaces and missing requested models are rejected before a model request begins.
+- Responses expose the observed CLI version as provenance alongside the capability-probe result.
+
+## What's New
+
+### Capability-based CLI compatibility
+
+Before dispatch, the Grok adapter validates its complete headless argument
+surface, strict sandbox controls, structured output, authentication state, and
+the requested model. The probe runs inside an isolated environment and does not
+send a consultation.
+
+Kimi now validates prompt mode, `stream-json`, provider inventory, and the exact
+configured model before dispatch. A CLI with a different version number remains
+compatible when these capabilities are present; a CLI that cannot satisfy the
+contract fails before a model call.
+
+Grok's `--no-auto-update` flag remains optional. It is enabled when the installed
+CLI advertises it and omitted otherwise, so a useful automation control does not
+become an accidental version constraint.
+
+### Diagnostic provenance
+
+Successful Grok and Kimi CLI responses now include:
+
+| Field | Meaning |
+|---|---|
+| `metadata.cli_version` | The version reported by the CLI, retained for diagnosis and provenance |
+| `metadata.cli_compatibility` | `capability-probed` when the required interface passed |
+
+These fields are additive. Existing response consumers and non-CLI transports
+do not need to provide them.
+
+### Verification
+
+- Full repository gate: 17/17 suites
+- Core suite: 299/299 checks
+- Grok adapter suite: 32/32 checks
+- Kimi adapter suite: 8/8 checks
+- ShellCheck: green
+- Installed Grok 0.2.114 and Kimi 0.27.0: no-model-call capability probes passed
+
+## Breaking Changes
+
+None — this release is backwards-compatible. No configuration changes are
+required.
+
+An installed Grok or Kimi CLI that lacks the adapter's required command,
+structured-output, or requested-model surface will now be rejected before
+dispatch instead of failing later during a consultation.
+
+## Upgrade Guide
+
+```bash
+# npx (no install)
+npx ai-consultants@latest "your question"
+
+# git clone install
+cd ~/.claude/skills/ai-consultants && git pull
+
+# curl | bash install
+curl -fsSL https://raw.githubusercontent.com/matteoscurati/ai-consultants/main/scripts/install.sh | bash
+```
+
+No configuration changes are required. If an adapter reports an incompatible
+CLI, update that CLI and run `ai-consultants doctor` before retrying.
+
+## Commits
+
+- `c7bad95` Harden CLI capability checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-consultants",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "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/references/configuration.md

@@ -263,10 +263,15 @@ tool-free strict sandbox. If the CLI is missing, cannot execute, or has no
 usable authentication, the same query and model fall back to `GROK_API_URL`
 when `GROK_API_KEY` is set. Failures after a request launches (including
 timeouts, model errors, and empty output) are returned without API fallback.
-Set `GROK_USE_API=true` only to force the API path.
+Set `GROK_USE_API=true` only to force the API path. The adapter accepts any CLI
+version that exposes the complete required headless interface and requested
+model; `metadata.cli_version` is provenance, not a version pin.
 
 `KIMI_MODEL` is passed directly to `kimi --model`, so `kimi-code/k3` overrides
-any older default stored in the user's Kimi CLI configuration.
+any older default stored in the user's Kimi CLI configuration. Kimi CLI
+compatibility is also capability-probed: prompt mode, `stream-json`, provider
+inventory, and the requested model must be present. No numeric CLI version is
+used as a gate.
 
 ## Model Quality Tiers (v2.5)
 

package/scripts/config.sh

@@ -779,4 +779,4 @@ EOF
 # VERSION
 # =============================================================================
 
-AI_CONSULTANTS_VERSION="3.2.0"
+AI_CONSULTANTS_VERSION="3.3.0"

package/scripts/lib/schema.json

@@ -167,6 +167,15 @@
           "type": "string",
           "description": "Exact model version string"
         },
+        "cli_version": {
+          "type": "string",
+          "description": "Observed consultant CLI version for provenance only; compatibility is not decided from this string."
+        },
+        "cli_compatibility": {
+          "type": "string",
+          "enum": ["capability-probed", "incompatible"],
+          "description": "Result of checking the CLI's required command, model, and structured-output capabilities before dispatch."
+        },
         "timestamp": {
           "type": "string",
           "format": "date-time",

package/scripts/query_grok.sh

@@ -36,6 +36,9 @@ START_TIME=$(get_timestamp_ms)
 TEMP_OUTPUT=$(mktemp)
 GROK_RUNTIME_DIR=""
 TRANSPORT="cli"
+GROK_CLI_VERSION=""
+GROK_CLI_COMPATIBILITY=""
+GROK_SUPPORTS_NO_AUTO_UPDATE=false
 exit_code=1
 
 cleanup() {
@@ -67,6 +70,93 @@ run_grok_api() {
     fi
 }
 
+observe_grok_cli_version() {
+    local version
+    version=$("$GROK_CMD" --version 2>/dev/null | head -1 || true)
+    if [[ "$version" =~ ^grok[[:space:]]+([^[:space:]]+) ]]; then
+        printf '%s\n' "${BASH_REMATCH[1]}"
+    elif [[ -n "$version" ]]; then
+        printf '%s\n' "$version"
+    else
+        printf 'unknown\n'
+    fi
+}
+
+grok_cli_supports_required_interface() {
+    local probe_home="$1"
+    local probe_grok_home="$2"
+    local probe_workspace="$3"
+    local help flag
+
+    help=$(env HOME="$probe_home" GROK_HOME="$probe_grok_home" \
+        "$GROK_CMD" --help 2>&1 || true)
+    for flag in \
+        --prompt-file --model --cwd --output-format --no-plan --no-subagents \
+        --no-memory --disable-web-search --max-turns --permission-mode \
+        --sandbox --tools --deny --verbatim; do
+        grep -q -- "$flag" <<< "$help" || return 1
+    done
+    grep -Eq '^[[:space:]]+models([[:space:]]|$)' <<< "$help" || return 1
+
+    # Exercise the complete headless argument surface under --help. This checks
+    # parser compatibility without starting a session or sending a prompt.
+    env HOME="$probe_home" GROK_HOME="$probe_grok_home" \
+        "$GROK_CMD" \
+        --prompt-file /dev/null \
+        -m "$GROK_MODEL" \
+        --cwd "$probe_workspace" \
+        --output-format plain \
+        --no-plan \
+        --no-subagents \
+        --no-memory \
+        --disable-web-search \
+        --max-turns 1 \
+        --permission-mode dontAsk \
+        --sandbox strict \
+        --tools "" \
+        --deny Bash \
+        --deny Edit \
+        --deny Read \
+        --deny Grep \
+        --deny MCPTool \
+        --deny WebFetch \
+        --deny WebSearch \
+        --verbatim \
+        --help >/dev/null 2>&1 || return 1
+
+    if grep -q -- '--no-auto-update' <<< "$help"; then
+        GROK_SUPPORTS_NO_AUTO_UPDATE=true
+    else
+        GROK_SUPPORTS_NO_AUTO_UPDATE=false
+    fi
+    GROK_CLI_COMPATIBILITY="capability-probed"
+}
+
+grok_cli_exposes_requested_model() {
+    local isolated_home="$1"
+    local isolated_grok_home="$2"
+    local models
+
+    if ! models=$(env HOME="$isolated_home" GROK_HOME="$isolated_grok_home" \
+            "$GROK_CMD" models 2>&1); then
+        printf '%s\n' "$models"
+        return 1
+    fi
+    grep -Fq "You are logged in with grok.com." <<< "$models" || {
+        printf '%s\n' "$models"
+        return 1
+    }
+    awk -v requested="$GROK_MODEL" '
+        {
+            line = $0
+            sub(/^[[:space:]*]+/, "", line)
+            split(line, fields, /[[:space:]]+/)
+            if (fields[1] == requested) found = 1
+        }
+        END { exit(found ? 0 : 1) }
+    ' <<< "$models"
+}
+
 grok_cli_is_unavailable() {
     local cli_exit_code="$1"
     local error_file="$2"
@@ -85,7 +175,7 @@ grok_cli_is_unavailable() {
     # model errors, timeouts, empty output, or other post-launch failures here;
     # those must surface instead of silently creating a billable API request.
     grep -Eiq \
-        'not authenticated|authentication( is)? required|authentication failed|unauthorized|run .?grok login|please .*log ?in|no (valid )?(credentials|access token)|missing .*credential|token.*expired|(^|[^0-9])401([^0-9]|$)|permission denied|cannot execute|exec format error|no such file or directory|failed to (start|launch|spawn)|could not (start|launch|spawn)' \
+        'not authenticated|authentication( is)? required|authentication failed|unauthorized|run .?grok login|please .*log ?in|no (valid )?(credentials|access token)|missing .*credential|token.*expired|(^|[^0-9])401([^0-9]|$)|permission denied|cannot execute|exec format error|no such file or directory|failed to (start|launch|spawn)|could not (start|launch|spawn)|lacks the required capabilities|does not expose the requested model' \
         "$error_file"
 }
 
@@ -128,51 +218,66 @@ else
             fi
         fi
 
-        # Official Grok Build headless contract:
-        #   --prompt-file avoids argv size/process-list exposure, -m pins the
-        #   model, and plain output contains the final assistant text.
-        #   dontAsk + strict sandbox make every unapproved tool fail closed.
-        GROK_ARGS=(
-            env
-            HOME="$isolated_home"
-            GROK_HOME="$isolated_grok_home"
-            "$GROK_CMD"
-            --prompt-file "$prompt_file"
-            -m "$GROK_MODEL"
-            --cwd "$isolated_workspace"
-            --output-format plain
-            --no-plan
-            --no-subagents
-            --no-memory
-            --disable-web-search
-            --max-turns 1
-            --permission-mode dontAsk
-            --sandbox strict
-            --tools ""
-            --deny Bash
-            --deny Edit
-            --deny Read
-            --deny Grep
-            --deny MCPTool
-            --deny WebFetch
-            --deny WebSearch
-            --verbatim
-        )
-
-        # Newer Grok Build releases document --no-auto-update for automation;
-        # keep compatibility with older installed builds that do not expose it.
-        if "$GROK_CMD" --help 2>&1 | grep -q -- '--no-auto-update'; then
-            GROK_ARGS+=("--no-auto-update")
-        fi
-
-        if run_query \
-                "$CONSULTANT_NAME" \
-                "$TEMP_OUTPUT" \
-                "$GROK_TIMEOUT_SECONDS" \
-                "${GROK_ARGS[@]}" </dev/null; then
-            exit_code=0
+        GROK_CLI_VERSION=$(observe_grok_cli_version)
+        if ! grok_cli_supports_required_interface \
+                "$isolated_home" "$isolated_grok_home" "$isolated_workspace"; then
+            GROK_CLI_COMPATIBILITY="incompatible"
+            printf 'Grok Build CLI lacks the required capabilities\n' > "${TEMP_OUTPUT}.err"
+            log_warn "[$CONSULTANT_NAME] Grok Build CLI is capability-incompatible (reported version: $GROK_CLI_VERSION)"
+            exit_code=69
+        elif ! grok_cli_exposes_requested_model \
+                "$isolated_home" "$isolated_grok_home" > "${TEMP_OUTPUT}.err"; then
+            printf 'Grok Build CLI does not expose the requested model %s\n' \
+                "$GROK_MODEL" >> "${TEMP_OUTPUT}.err"
+            log_warn "[$CONSULTANT_NAME] Grok Build CLI does not expose $GROK_MODEL"
+            exit_code=69
         else
-            exit_code=$?
+            # Official Grok Build headless contract:
+            #   --prompt-file avoids argv size/process-list exposure, -m pins the
+            #   model, and plain output contains the final assistant text.
+            #   dontAsk + strict sandbox make every unapproved tool fail closed.
+            GROK_ARGS=(
+                env
+                HOME="$isolated_home"
+                GROK_HOME="$isolated_grok_home"
+                "$GROK_CMD"
+                --prompt-file "$prompt_file"
+                -m "$GROK_MODEL"
+                --cwd "$isolated_workspace"
+                --output-format plain
+                --no-plan
+                --no-subagents
+                --no-memory
+                --disable-web-search
+                --max-turns 1
+                --permission-mode dontAsk
+                --sandbox strict
+                --tools ""
+                --deny Bash
+                --deny Edit
+                --deny Read
+                --deny Grep
+                --deny MCPTool
+                --deny WebFetch
+                --deny WebSearch
+                --verbatim
+            )
+
+            # --no-auto-update is a useful optional capability, not a version
+            # requirement. Compatible older or vendor-custom builds may omit it.
+            if [[ "$GROK_SUPPORTS_NO_AUTO_UPDATE" == "true" ]]; then
+                GROK_ARGS+=("--no-auto-update")
+            fi
+
+            if run_query \
+                    "$CONSULTANT_NAME" \
+                    "$TEMP_OUTPUT" \
+                    "$GROK_TIMEOUT_SECONDS" \
+                    "${GROK_ARGS[@]}" </dev/null; then
+                exit_code=0
+            else
+                exit_code=$?
+            fi
         fi
     else
         log_warn "[$CONSULTANT_NAME] Grok Build CLI not found: $GROK_CMD"
@@ -214,7 +319,17 @@ fi
 # Preserve which route actually answered without changing the shared schema.
 if [[ -s "$OUTPUT_FILE" ]]; then
     response_tmp=$(mktemp)
-    if jq --arg transport "$TRANSPORT" '.metadata.transport = $transport' \
+    if jq --arg transport "$TRANSPORT" \
+            --arg cli_version "$GROK_CLI_VERSION" \
+            --arg cli_compatibility "$GROK_CLI_COMPATIBILITY" '
+            .metadata.transport = $transport |
+            if $transport == "cli" and $cli_version != "" then
+                .metadata.cli_version = $cli_version |
+                .metadata.cli_compatibility = $cli_compatibility
+            else
+                .
+            end
+        ' \
             "$OUTPUT_FILE" > "$response_tmp"; then
         mv "$response_tmp" "$OUTPUT_FILE"
     else

package/scripts/query_kimi.sh

@@ -40,9 +40,43 @@ START_TIME=$(get_timestamp_ms)
 
 # --- Execution ---
 TEMP_OUTPUT=$(mktemp)
+KIMI_CLI_VERSION=""
+
+observe_kimi_cli_version() {
+    local version
+    version=$("$KIMI_CMD" --version 2>/dev/null | head -1 || true)
+    printf '%s\n' "${version:-unknown}"
+}
+
+kimi_cli_supports_required_interface() {
+    local help providers flag
+
+    help=$("$KIMI_CMD" --help 2>&1 || true)
+    for flag in --model --prompt --output-format; do
+        grep -q -- "$flag" <<< "$help" || return 1
+    done
+    grep -Eq '^[[:space:]]+provider([[:space:]]|$)' <<< "$help" || return 1
+
+    # Check the complete prompt-mode parser without running a model request.
+    "$KIMI_CMD" \
+        --model "$KIMI_MODEL" \
+        --prompt "" \
+        --output-format stream-json \
+        --help >/dev/null 2>&1 || return 1
+
+    providers=$("$KIMI_CMD" provider list --json 2>/dev/null || true)
+    jq -e --arg model "$KIMI_MODEL" '
+        .models[$model] != null
+    ' <<< "$providers" >/dev/null 2>&1
+}
 
 # Check CLI prerequisite
 check_command "$KIMI_CMD" "Kimi CLI" "curl -L code.kimi.com/install.sh | bash" || exit 1
+KIMI_CLI_VERSION=$(observe_kimi_cli_version)
+kimi_cli_supports_required_interface || {
+    log_error "[Kimi] Kimi CLI lacks the required capabilities for model $KIMI_MODEL (reported version: $KIMI_CLI_VERSION)"
+    exit 1
+}
 
 # Kimi takes the prompt as the -p argument (it does NOT read stdin). The old
 # `--quiet --input-format text` were NOT real flags on kimi 0.23.6 — commander
@@ -89,5 +123,17 @@ PERSONA_NAME=$(get_persona_name "$CONSULTANT_NAME")
 process_consultant_response "$CONSULTANT_NAME" "$MODEL_USED" "$PERSONA_NAME" \
     "$TEMP_OUTPUT" "$OUTPUT_FILE" "$exit_code" "$LATENCY_MS" "" "$FULL_QUERY"
 
+if [[ -s "$OUTPUT_FILE" ]]; then
+    response_tmp=$(mktemp)
+    if jq --arg cli_version "$KIMI_CLI_VERSION" '
+            .metadata.cli_version = $cli_version |
+            .metadata.cli_compatibility = "capability-probed"
+        ' "$OUTPUT_FILE" > "$response_tmp"; then
+        mv "$response_tmp" "$OUTPUT_FILE"
+    else
+        rm -f "$response_tmp"
+    fi
+fi
+
 cat "$OUTPUT_FILE"
 exit $exit_code