@ask-llm/plugin 0.13.0 → 0.14.0

package/.claude-plugin/plugin.json

@@ -1,16 +1,19 @@
 {
   "name": "ask-llm",
-  "version": "0.13.0",
-  "description": "AI-to-AI collaboration — review code, brainstorm ideas, and debate plans across Codex, Antigravity, Ollama, and Gemini",
+  "version": "0.14.0",
+  "description": "AI-to-AI collaboration — review code and debate plans across Codex, Grok, Antigravity, Ollama, and Gemini",
   "author": {
     "name": "Anton Lykhoyda",
     "url": "https://github.com/Lykhoyda"
   },
   "repository": "https://github.com/Lykhoyda/ask-llm",
   "license": "MIT",
+  "mcpServers": "./.mcp.json",
   "keywords": [
     "gemini",
     "codex",
+    "grok",
+    "xai",
     "ollama",
     "antigravity",
     "code-review",

package/.mcp.json

@@ -1,3 +1,8 @@
 {
-  "mcpServers": {}
+  "mcpServers": {
+    "codex": {
+      "command": "npx",
+      "args": ["-y", "@ask-llm/codex-mcp"]
+    }
+  }
 }

package/README.md

@@ -21,14 +21,20 @@ Part of the [Ask LLM](https://github.com/Lykhoyda/ask-llm) monorepo.
 
 > **After installing or upgrading, fully restart Claude Code** (quit and reopen) so the codex-pair `PostToolUse` hook registers. Claude Code binds hooks at session start; `/reload-plugins` refreshes the plugin cache but does **not** re-register hooks in a pre-existing session, so codex-pair won't auto-fire on edits until you restart (see [#74](https://github.com/Lykhoyda/ask-llm/issues/74)). Run `/codex-pair` afterwards to confirm the hook is wired up.
 
-### MCP Servers (user scope for short tool names)
+### MCP Servers
+
+The plugin bundles the supported Codex MCP registration under Claude Code's plugin namespace. After installation or upgrade, fully restart Claude Code and run `/mcp`; `plugin:ask-llm:codex` should be connected and `/sol-review` will select its `ask-codex` tool automatically.
+
+Existing user-scoped Codex registrations remain compatible and keep the shorter `codex:ask-codex` name. The other provider servers are still registered explicitly at user scope:
 
 ```bash
 claude mcp add --scope user gemini -- npx -y @ask-llm/gemini-mcp
-claude mcp add --scope user codex -- npx -y @ask-llm/codex-mcp
 claude mcp add --scope user ollama -- npx -y @ask-llm/ollama-mcp
+claude mcp add --scope user antigravity -- npx -y @ask-llm/antigravity-mcp
 ```
 
+If Codex is missing entirely, register it explicitly with `claude mcp add --scope user codex -- npx -y @ask-llm/codex-mcp`. If `/mcp` shows the bundled registration but it is disconnected, run `npx -y @ask-llm/mcp doctor` and restart Claude Code. `/sol-review` preserves source-plugin and session-local MCP/settings context when reading the active `claude mcp list` inventory, reports missing and unavailable states separately, and discloses the explicit `codex exec` fallback after failed health or MCP transport failure.
+
 ### Pi
 
 ```bash
@@ -36,7 +42,7 @@ pi install npm:@ask-llm/plugin
 pi list
 ```
 
-Pi discovers the portable skills as `/skill:<name>` commands and registers native `ask-codex`, `ask-gemini`, `ask-ollama`, `ask-antigravity`, and bounded concurrent `ask-multi` tools. Pi intentionally has no built-in MCP client; do not configure these as MCP servers in Pi. `fable-review` remains Claude Code-only and is excluded from Pi discovery.
+Pi discovers the portable skills as `/skill:<name>` commands and registers native `ask-codex`, `ask-gemini`, `ask-grok`, `ask-ollama`, `ask-antigravity`, model-neutral `ask-cursor-agent`, and bounded concurrent `ask-multi` tools. Pi intentionally has no built-in MCP client; do not configure these as MCP servers in Pi. `fable-review` remains Claude Code-only and is excluded from Pi discovery.
 
 For codex-pair, create `.codex-pair/context.md`, ensure Pi trusts the project, then run interactive `/codex-pair` to grant user-owned canonical-project consent. The marker alone never authorizes data transfer/cost. Revoke with `/codex-pair revoke`. Pi findings are non-blocking; blocking Stop-gate and one-shot print parity are not available.
 
@@ -55,10 +61,11 @@ See the [Pi host guide](https://lykhoyda.github.io/ask-llm/plugin/pi) for securi
 | `/gemini-review` | Gemini-only code review with confidence filtering |
 | `/codex-review` | Codex-only code review (precision-first, ≥80 confidence — default for routine PR review) |
 | `/fable-review` | Isolated, read-only review requesting native Fable, with runtime verification limits disclosed |
-| `/sol-review` | Model-pinned GPT-5.6 Sol review through Codex. Uses the `ask-codex` MCP tool when available; subagent contexts without it fall back to the `codex` CLI, so keep the CLI installed and authenticated |
+| `/sol-review` | Model-pinned GPT-5.6 Sol review through the bundled `ask-codex` MCP tool; missing registration and service unavailability are diagnosed separately before the explicit CLI fallback |
 | `/ollama-review` | Local review — no data leaves your machine |
 | `/brainstorm` | Multi-LLM brainstorm with Claude Opus as a first-class research participant (default external: gemini,codex) |
-| `/brainstorm-all` | Brainstorm with all four external providers (Gemini, Codex, Ollama, Antigravity) + Claude Opus research |
+| `/grok-review` | Grok review through explicit xAI API or Grok CLI harness; no fallback |
+| `/brainstorm-all` | Brainstorm with all five external providers (Gemini, Codex, Grok, Ollama, Antigravity) + Claude Opus research |
 | `/compare` | Side-by-side raw responses from multiple providers (no synthesis, no consensus extraction) |
 
 ## Agents

package/agents/brainstorm-coordinator.md

@@ -12,6 +12,7 @@ tools:
   - WebSearch
   - mcp__gemini__ask-gemini
   - mcp__codex__ask-codex
+  - mcp__grok__ask-grok
   - mcp__ollama__ask-ollama
   - mcp__antigravity__ask-antigravity
 ---
@@ -32,7 +33,7 @@ The frontmatter and detailed implementation below define Claude Code subagent ex
 You are a brainstorming coordinator powered by Claude Opus. You have two jobs:
 
 1. **You are a first-class research participant.** Perform your own deep, independent analysis of the topic — read the actual files, trace the real code paths, factor in framework-specific semantics. Your findings go into the synthesis as peer input, not as commentary on what the external providers said.
-2. **You orchestrate external consultations.** Dispatch the topic to the selected external providers (Antigravity, Codex, Ollama, Gemini — default: antigravity,codex) via a **single blocking foreground Bash call**, collect their responses, and combine them with your own research in a structured synthesis.
+2. **You orchestrate external consultations.** Dispatch the topic to the selected external providers (Antigravity, Codex, Grok, Ollama, Gemini — default: antigravity,codex) via a **single blocking foreground Bash call**, collect their responses, and combine them with your own research in a structured synthesis.
 
 You run on Opus and you have filesystem access. Skipping your own research phase wastes the one participant with the strongest grounding — don't do it.
 
@@ -117,6 +118,7 @@ The user specifies which external providers to use. Default is `antigravity,code
 - `antigravity` — Google Antigravity, subscription-backed via your Google AI Pro/Ultra plan, via the `agy` CLI (experimental; requires `agy` >=1.1.5 installed + logged in)
 - `gemini` — Google Gemini (large context, strong at analysis) via the `gemini` CLI
 - `codex` — OpenAI Codex (strong at code reasoning) via `codex exec --sandbox read-only`
+- `grok` — Grok through the canonical runner and explicit `ASK_GROK_HARNESS` (`xai-api` default or `grok-cli`); may incur xAI API/plan usage and never falls back
 - `ollama` — Local Ollama (private, no data leaves machine) via the `ollama` CLI
 
 **Required Bash tool call parameters:**
@@ -185,6 +187,12 @@ esac
   > "$workdir/codex.out" 2> "$workdir/codex.err" &
 pid_codex=$!
 
+# Only include this block if grok was requested. The canonical runner preserves
+# explicit API-vs-CLI harness selection, key redaction, timeout/cancellation,
+# actual model attribution, and the no-fallback contract.
+node "${CLAUDE_PLUGIN_ROOT}/dist/grok-run.js" "$(cat "$workdir/prompt.md")" > "$workdir/grok.out" 2> "$workdir/grok.err" &
+pid_grok=$!
+
 # Only include this line if ollama was requested:
 ollama run "${ASK_OLLAMA_MODEL:-qwen3.6:27b}" < "$workdir/prompt.md" > "$workdir/ollama.out" 2> "$workdir/ollama.err" &
 pid_ollama=$!
@@ -196,6 +204,7 @@ pid_ollama=$!
 wait "$pid_antigravity" 2>/dev/null; rc_antigravity=$?
 wait "$pid_gemini" 2>/dev/null; rc_gemini=$?
 wait "$pid_codex"  2>/dev/null; rc_codex=$?
+wait "$pid_grok"   2>/dev/null; rc_grok=$?
 wait "$pid_ollama" 2>/dev/null; rc_ollama=$?
 
 # Dump everything so the tool result is self-contained for Phase 4.
@@ -211,6 +220,10 @@ echo "===== CODEX (rc=$rc_codex) ====="
 cat "$workdir/codex.out" 2>/dev/null
 echo "===== CODEX STDERR ====="
 cat "$workdir/codex.err" 2>/dev/null
+echo "===== GROK (rc=$rc_grok) ====="
+cat "$workdir/grok.out" 2>/dev/null
+echo "===== GROK STDERR ====="
+cat "$workdir/grok.err" 2>/dev/null
 echo "===== OLLAMA (rc=$rc_ollama) ====="
 cat "$workdir/ollama.out" 2>/dev/null
 echo "===== OLLAMA STDERR ====="

package/agents/codex-reviewer.md

@@ -9,6 +9,7 @@ tools:
   - Grep
   - Read
   - mcp__codex__ask-codex
+  - mcp__plugin_ask-llm_codex__ask-codex
 ---
 
 <!-- PORTABLE-CONTRACT:START -->

package/agents/grok-reviewer.md

@@ -0,0 +1,49 @@
+---
+name: grok-reviewer
+description: Runs a focused Grok review through the metered xAI API, then verifies findings against source. Never changes billing or substitutes another model.
+model: opus
+color: blue
+tools:
+  - Bash
+  - Glob
+  - Grep
+  - Read
+  - mcp__grok__ask-grok
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Review only the supplied changes and context with Grok through the xAI API. Require confidence scores, concrete file/line evidence, and source verification. Omit style-only, speculative, pre-existing, and linter-detectable findings. Preserve actual model attribution. Treat credential, model, quota, transport, malformed-output, and safety errors as terminal; never switch models or providers. Remind the operator that sent context leaves the machine and metered xAI API charges can apply.
+<!-- PORTABLE-CONTRACT:END -->
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+## Claude Code adapter
+
+You coordinate an independent Grok code review. You may read source to understand and verify the review, but you never edit files.
+
+### Context gathering
+
+1. Read the supplied diff and the relevant current source.
+2. Discover project instructions that apply to each changed file.
+3. Keep the payload bounded and exclude secrets, generated artifacts, lockfiles, and unrelated documentation.
+
+### Grok request
+
+Call `mcp__grok__ask-grok` with its model unset unless the user explicitly requested an exact xAI API model ID. Use `reasoningEffort: "high"` for review. Tell Grok to report only issues with confidence at least 80 and include:
+
+- confidence score
+- severity
+- file and line
+- concrete failure mode
+- evidence from the changed code
+- minimal remediation
+
+Explicitly exclude style preferences, unchanged-code findings, linter/type-checker findings, and claims that depend on unstated runtime assumptions.
+
+### Verification
+
+For every candidate, read the cited source and verify the claimed behavior. Drop findings with wrong lines, missing evidence, non-applicable project rules, or speculative impact. Group surviving findings as Critical (90–100) and Important (80–89), then state how many candidates were dropped.
+
+If the xAI request fails, report the Grok-specific diagnostic and stop. Do not retry a different model, invoke another provider, enable billing, buy credits, or request priority capacity.
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/agents/sol-reviewer.md

@@ -4,13 +4,10 @@ description: Coordinates an isolated, read-only code review explicitly pinned to
 model: opus
 effort: high
 color: blue
-tools:
-  - Bash
-  - Glob
-  - Grep
-  - Read
-  - mcp__codex__ask-codex
-  - mcp__plugin_ask-llm_codex__ask-codex
+disallowedTools:
+  - Edit
+  - Write
+  - NotebookEdit
 ---
 
 <!-- PORTABLE-CONTRACT:START -->
@@ -38,13 +35,13 @@ You are a code review coordinator for a model-pinned OpenAI GPT-5.6 Sol review.
    - `preferred` unset
    - a prompt containing the scoped conventions, relevant ADR summaries, and the diff
 
-   The tool name may be plugin-namespaced in some sessions (for example `mcp__plugin_ask-llm_codex__ask-codex`); any `ask-codex` MCP variant counts as the primary transport. If no `ask-codex` MCP tool is available in this subagent context, use the sanctioned CLI fallback, passing the same prompt on stdin:
+   The tool name may be plugin-namespaced in some sessions (for example `mcp__plugin_ask-llm_codex__ask-codex`). Treat a tool as authoritative only when its server identity maps to an active `@ask-llm/codex-mcp` registration. If no authoritative `ask-codex` tool is available in this subagent context, pass the same prompt on stdin to the shipped fallback runner:
 
    ```bash
-   codex exec -m gpt-5.6-sol -c model_reasoning_effort="high" -s read-only --ignore-user-config --ignore-rules --skip-git-repo-check
+   node "${CLAUDE_PLUGIN_ROOT}/scripts/sol-review-transport.mjs" --fallback --plugin-dir "${CLAUDE_PLUGIN_ROOT}" --cli-path "$(command -v codex || true)"
    ```
 
-   The `-m` pin, the reasoning-effort override, and the `-s read-only` sandbox are load-bearing; never drop or substitute them. The `--ignore-user-config --ignore-rules --skip-git-repo-check` flags are equally load-bearing: they mirror what the project's MCP executor always passes, so a local `~/.codex/config.toml` cannot silently override the pinned model or reasoning effort. If the Sol invocation fails with a quota or rate-limit error, retry once with `-m "${ASK_CODEX_FALLBACK_MODEL:-gpt-5.6-terra}"` and all other flags identical, matching the MCP executor's configurable quota ladder (`ASK_CODEX_FALLBACK_MODEL` overrides the `gpt-5.6-terra` default there too), and disclose the fallback model exactly as you would on the MCP path. If the `codex` CLI is also unavailable, stop and report that the Sol review could not run. Do not review on another transport, on any model outside the Sol-to-fallback ladder, or in another sandbox mode.
+   Before executing Codex, the runner queries the active Claude MCP inventory again with the active plugin preserved; mirror any session-local `--mcp-config`, `--settings`, `--setting-sources`, and `--strict-mcp-config` flags on the runner command. This makes a parent `preferred` result followed by an absent or disconnected subagent tool a registered-but-unavailable state with the corresponding remediation. If the MCP call itself fails at the transport/service boundary, rerun the same fallback command with `--mcp-failed`; do not use that flag for a provider/model response. The runner then executes `codex exec -m gpt-5.6-sol -c model_reasoning_effort="high" -s read-only --ignore-user-config --ignore-rules --skip-git-repo-check`. The model pin, reasoning-effort override, read-only sandbox, and isolation flags are load-bearing; never drop or substitute them. On a quota or rate-limit failure only, the runner retries once with `${ASK_CODEX_FALLBACK_MODEL:-gpt-5.6-terra}` and identical flags, matching the MCP executor's configurable quota ladder. It writes the review result to stdout unchanged so the validated findings can be relayed without loss. If the `codex` CLI is also unavailable, stop and report that the Sol review could not run. Do not review on another transport, on any model outside the Sol-to-fallback ladder, or in another sandbox mode.
 4. Ask Sol for concrete correctness, security, data-loss, concurrency, resource-lifecycle, and compatibility failures with confidence scores and reproduction conditions.
 5. Read the reported source locations and trace each reproduction path. Drop style preferences, speculative improvements, pre-existing issues, linter/type-checker findings, and behavior documented as intentional.
 6. Report only validated findings with confidence of at least 80/100. Never invent findings to fill a report.
@@ -53,7 +50,7 @@ You are a code review coordinator for a model-pinned OpenAI GPT-5.6 Sol review.
 
 Lead with the highest-severity finding. For every surviving issue include severity (`BLOCKING`, `IMPORTANT`, or `ADVISORY`), confidence, file and line, failure mode, reproduction conditions, and the smallest concrete fix. State clearly when no high-confidence findings survive validation.
 
-The explicit `model` argument is load-bearing: do not omit it or replace it with an environment-selected default. Disclose every fallback you take, not only model fallbacks: if the response reports a Terra quota fallback, disclose that the Sol review could not complete as pinned, and if you used the CLI transport fallback because no `ask-codex` MCP tool was available, state that the review ran through `codex exec` rather than MCP.
+The explicit `model` argument is load-bearing: do not omit it or replace it with an environment-selected default. Disclose every fallback you take, not only model fallbacks: if the response reports a Terra quota fallback, disclose that the Sol review could not complete as pinned. If you used the CLI transport fallback, state that the review ran through `codex exec` rather than MCP, report missing registration, registered-service unavailability, or an unreadable inventory from the preflight state without guessing, show its remediation, and relay the same validated findings.
 
 You have no edit tools. Remain read-only.
 

package/dist/grok-run.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=grok-run.d.ts.map

package/dist/grok-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-run.d.ts","sourceRoot":"","sources":["../src/grok-run.ts"],"names":[],"mappings":""}

package/dist/grok-run.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { executeGrok } from "@ask-llm/grok-mcp/executor";
+const prompt = process.argv.slice(2).join(" ");
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString().trim();
+}
+async function main() {
+    const stdin = await readStdin();
+    if (!prompt && !stdin) {
+        console.error("Usage: ask-grok-run <prompt>");
+        console.error("       echo 'diff' | ask-grok-run 'Review this diff'");
+        process.exit(1);
+    }
+    try {
+        const result = await executeGrok({ prompt: [prompt, stdin].filter(Boolean).join("\n\n") });
+        console.log(result.response);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`ask-grok-run failed: ${message}`);
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=grok-run.js.map

package/dist/grok-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-run.js","sourceRoot":"","sources":["../src/grok-run.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE/C,KAAK,UAAU,SAAS;IACtB,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACnC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK;QAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5D,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;AACjD,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,KAAK,GAAG,MAAM,SAAS,EAAE,CAAC;IAChC,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACtB,OAAO,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAC9C,OAAO,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;QACtE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC3F,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,OAAO,CAAC,KAAK,CAAC,wBAAwB,OAAO,EAAE,CAAC,CAAC;QACjD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7E;AAED,eAAO,MAAM,SAAS,EAAE,gBAAgB,EAqCvC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7E;AAED,eAAO,MAAM,SAAS,EAAE,gBAAgB,EA8CvC,CAAC"}

package/dist/index.js

@@ -17,6 +17,15 @@ export const providers = [
             return result.response;
         },
     },
+    {
+        name: "grok",
+        command: "xai-api",
+        async execute(prompt) {
+            const { executeGrok } = await import("@ask-llm/grok-mcp/executor");
+            const result = await executeGrok({ prompt });
+            return result.response;
+        },
+    },
     {
         name: "ollama",
         command: "ollama",

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,SAAS,GAAuB;IAC3C;QACE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,QAAQ;QACjB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;YAC1E,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAClD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,OAAO;QAChB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC;YACxE,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YACjD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,QAAQ;QACjB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;YAC1E,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAClD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,aAAa;QACnB,OAAO,EAAE,KAAK;QACd,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC;YACpF,MAAM,MAAM,GAAG,MAAM,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YACvD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;CACF,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,SAAS,GAAuB;IAC3C;QACE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,QAAQ;QACjB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;YAC1E,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAClD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,OAAO;QAChB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC;YACxE,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YACjD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,MAAM;QACZ,OAAO,EAAE,SAAS;QAClB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC,4BAA4B,CAAC,CAAC;YACnE,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAC7C,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,QAAQ;QACjB,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;YAC1E,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAClD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;IACD;QACE,IAAI,EAAE,aAAa;QACnB,OAAO,EAAE,KAAK;QACd,KAAK,CAAC,OAAO,CAAC,MAAc;YAC1B,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC;YACpF,MAAM,MAAM,GAAG,MAAM,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YACvD,OAAO,MAAM,CAAC,QAAQ,CAAC;QACzB,CAAC;KACF;CACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ask-llm/plugin",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Ask LLM review, comparison, brainstorming, image, verification, and pairing workflows for Claude Code and Pi",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,7 @@
     "ask-antigravity-run": "dist/antigravity-run.js",
     "ask-codex-run": "dist/codex-run.js",
     "ask-gemini-run": "dist/run.js",
+    "ask-grok-run": "dist/grok-run.js",
     "ask-ollama-run": "dist/ollama-run.js"
   },
   "scripts": {
@@ -21,6 +22,8 @@
     "claude-code-plugin",
     "codex",
     "gemini",
+    "grok",
+    "xai",
     "ollama",
     "antigravity",
     "code-review",
@@ -70,16 +73,19 @@
       "./skills/codex-verify/SKILL.md",
       "./skills/compare/SKILL.md",
       "./skills/gemini-review/SKILL.md",
+      "./skills/grok-review/SKILL.md",
       "./skills/multi-review/SKILL.md",
       "./skills/ollama-review/SKILL.md",
       "./skills/sol-review/SKILL.md"
     ]
   },
   "dependencies": {
-    "@ask-llm/antigravity-mcp": "^0.7.1",
-    "@ask-llm/codex-mcp": "^0.7.4",
-    "@ask-llm/gemini-mcp": "^1.7.1",
-    "@ask-llm/ollama-mcp": "^0.5.6"
+    "@ask-llm/antigravity-mcp": "^0.7.2",
+    "@ask-llm/codex-mcp": "^0.7.5",
+    "@ask-llm/gemini-mcp": "^1.7.2",
+    "@ask-llm/grok-mcp": "^0.1.1",
+    "@ask-llm/mcp": "^0.7.0",
+    "@ask-llm/ollama-mcp": "^0.5.7"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/pi/extensions/codex-pair.ts

@@ -52,6 +52,8 @@ const ALLOWLIST_LOCK_RETRY_MS = 25;
 const ALLOWLIST_LOCK_TIMEOUT_MS = 5_000;
 const ALLOWLIST_LOCK_STALE_MS = 30_000;
 const LOCK_CONTENTION_RETRY_MS = 100;
+const CLAIM_SUFFIX = ".claim";
+const CLAIM_STALE_MS = 30_000;
 const PI_PENDING_DIR = "pi-pending";
 const PI_REVIEWED_DIR = "pi-reviewed";
 const SKIP_PARTS = [
@@ -381,7 +383,7 @@ function sendFinding(pi: ExtensionAPI, finding: PairFinding): void {
 
 interface ClaimedFinding {
   claimPath: string;
-  originalPath: string;
+  pendingPath: string;
   finding: PairFinding;
 }
 
@@ -398,39 +400,57 @@ function processIsAlive(pid: number): boolean {
   }
 }
 
+function parseClaimOwner(content: string): number | undefined {
+  try {
+    const { pid } = JSON.parse(content) as { pid?: unknown };
+    return typeof pid === "number" && Number.isInteger(pid) ? pid : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function recoverAbandonedClaims(markerDir: string): Promise<void> {
   const root = pendingRoot(markerDir);
   try {
-    const names = (await readdir(root)).filter((name) => name.includes(".json.claim-")).sort();
+    const names = (await readdir(root)).filter((name) => name.endsWith(CLAIM_SUFFIX)).sort();
     for (const name of names) {
-      const pid = Number(name.match(/\.claim-(\d+)-/)?.[1]);
-      if (Number.isInteger(pid) && processIsAlive(pid)) continue;
       const claimPath = join(root, name);
-      const originalPath = join(root, name.slice(0, name.indexOf(".claim-")));
+      const content = await readFile(claimPath, "utf8").catch(() => undefined);
+      const info = await stat(claimPath).catch(() => undefined);
+      // A live session releases and recreates claims at this same path, so only age plus an
+      // unchanged-identity recheck can tell an abandoned claim from one that was just taken.
+      if (content === undefined || !info || Date.now() - info.mtimeMs < CLAIM_STALE_MS) continue;
+      const pid = parseClaimOwner(content);
+      if (pid !== undefined && processIsAlive(pid)) continue;
+      const recheck = await readFile(claimPath, "utf8").catch(() => undefined);
+      const recheckInfo = await stat(claimPath).catch(() => undefined);
+      if (recheck !== content || recheckInfo?.mtimeMs !== info.mtimeMs) continue;
       try {
-        await rename(claimPath, originalPath);
+        await unlink(claimPath);
       } catch {}
     }
   } catch {}
 }
 
 async function claimPending(path: string): Promise<ClaimedFinding | undefined> {
-  const claimPath = `${path}.claim-${process.pid}-${randomUUID()}`;
+  const claimPath = `${path}${CLAIM_SUFFIX}`;
   try {
-    await rename(path, claimPath);
+    await writeFile(claimPath, `${JSON.stringify({ pid: process.pid })}\n`, { flag: "wx", mode: 0o600 });
   } catch {
     return undefined;
   }
   try {
     return {
       claimPath,
-      originalPath: path,
-      finding: JSON.parse(await readFile(claimPath, "utf8")) as PairFinding,
+      pendingPath: path,
+      finding: JSON.parse(await readFile(path, "utf8")) as PairFinding,
     };
   } catch {
-    try {
-      await unlink(claimPath);
-    } catch {}
+    for (const target of [path, claimPath]) {
+      try {
+        await unlink(target);
+      } catch {}
+    }
     return undefined;
   }
 }
@@ -498,30 +518,39 @@ export function registerCodexPair(pi: ExtensionAPI): void {
     return false;
   };
 
+  const releaseClaim = async (claimed: ClaimedFinding) => {
+    try {
+      await unlink(claimed.claimPath);
+    } catch {}
+  };
+
+  const consumeClaimed = async (claimed: ClaimedFinding) => {
+    try {
+      await unlink(claimed.pendingPath);
+    } catch {}
+    await releaseClaim(claimed);
+  };
+
   const deliverClaimed = async (claimed: ClaimedFinding) => {
     if (closed) {
-      try {
-        await rename(claimed.claimPath, claimed.originalPath);
-      } catch {}
+      await releaseClaim(claimed);
       return;
     }
     try {
       const current = await readFile(claimed.finding.file);
       if (hash(current.toString("utf8")) !== claimed.finding.contentHash) {
-        await unlink(claimed.claimPath);
+        await consumeClaimed(claimed);
         return;
       }
       if (closed) {
-        await rename(claimed.claimPath, claimed.originalPath);
+        await releaseClaim(claimed);
         return;
       }
       sendFinding(pi, claimed.finding);
       await markReviewed(claimed.finding);
-      await unlink(claimed.claimPath);
+      await consumeClaimed(claimed);
     } catch (error) {
-      try {
-        await rename(claimed.claimPath, claimed.originalPath);
-      } catch {}
+      await releaseClaim(claimed);
       throw error;
     }
   };
@@ -531,8 +560,10 @@ export function registerCodexPair(pi: ExtensionAPI): void {
     while (!closed) {
       let names: string[];
       try {
-        names = (await readdir(pendingRoot(markerDir)))
-          .filter((name) => name.endsWith(".json"))
+        const entries = await readdir(pendingRoot(markerDir));
+        const claimedNames = new Set(entries.filter((name) => name.endsWith(CLAIM_SUFFIX)));
+        names = entries
+          .filter((name) => name.endsWith(".json") && !claimedNames.has(`${name}${CLAIM_SUFFIX}`))
           .sort()
           .slice(0, 8);
       } catch {
@@ -860,6 +891,7 @@ export const __testing = {
   activeConcerns,
   adaptiveContent,
   allowlistPath,
+  claimPending,
   deleteScheduledIfOwned,
   findMarkerUp,
   normalizeToolPath,

package/pi/extensions/provider-tools.ts

@@ -4,11 +4,14 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { executeTool as executeAntigravityTool } from "@ask-llm/antigravity-mcp/register";
 import { executeTool as executeCodexTool } from "@ask-llm/codex-mcp/register";
 import { executeTool as executeGeminiTool } from "@ask-llm/gemini-mcp/register";
+import { executeTool as executeGrokTool } from "@ask-llm/grok-mcp/register";
 import { executeTool as executeOllamaTool } from "@ask-llm/ollama-mcp/register";
+import { CURSOR_PROVIDERS, executeCursorAgent } from "@ask-llm/mcp/cursor";
 import { Type } from "typebox";
 
-const providerNames = ["codex", "gemini", "ollama", "antigravity"] as const;
+const providerNames = ["codex", "gemini", "grok", "ollama", "antigravity"] as const;
 type ProviderName = (typeof providerNames)[number];
+const cursorProviderNames = CURSOR_PROVIDERS;
 
 type CanonicalResult =
   | string
@@ -24,6 +27,7 @@ type CanonicalExecute = (
 const executors: Record<ProviderName, { tool: string; execute: CanonicalExecute }> = {
   codex: { tool: "ask-codex", execute: executeCodexTool as CanonicalExecute },
   gemini: { tool: "ask-gemini", execute: executeGeminiTool as CanonicalExecute },
+  grok: { tool: "ask-grok", execute: executeGrokTool as CanonicalExecute },
   ollama: { tool: "ask-ollama", execute: executeOllamaTool as CanonicalExecute },
   antigravity: { tool: "ask-antigravity", execute: executeAntigravityTool as CanonicalExecute },
 };
@@ -48,6 +52,12 @@ const geminiSchema = Type.Object({
   model: Type.Optional(Type.String({ minLength: 1 })),
   sessionId: Type.Optional(Type.String()),
 });
+const grokSchema = Type.Object({
+  prompt,
+  model: Type.Optional(Type.String({ minLength: 1 })),
+  harness: Type.Optional(StringEnum(["xai-api", "grok-cli"] as const)),
+  reasoningEffort: Type.Optional(StringEnum(["low", "medium", "high", "xhigh"] as const)),
+});
 const ollamaSchema = Type.Object({
   prompt,
   model: Type.Optional(Type.String({ minLength: 1 })),
@@ -61,21 +71,36 @@ const antigravitySchema = Type.Object({
 const providerOptionSchemas = {
   codex: Type.Omit(codexSchema, ["prompt"]),
   gemini: Type.Omit(geminiSchema, ["prompt"]),
+  grok: Type.Omit(grokSchema, ["prompt"]),
   ollama: Type.Omit(ollamaSchema, ["prompt"]),
   antigravity: Type.Omit(antigravitySchema, ["prompt"]),
 };
 
+const cursorAgentSchema = Type.Object({
+  prompt,
+  provider: StringEnum(cursorProviderNames, {
+    description:
+      "Canonical provider family of the Cursor model (claude, codex, gemini, grok); verified against the requested and CLI-reported model ID.",
+  }),
+  model: Type.String({
+    minLength: 1,
+    description:
+      "Exact ID from agent --list-models; echoed back as `model`, with the CLI display label in `reportedModel`. Auto and other noncanonical IDs are refused.",
+  }),
+});
+
 const askMultiSchema = Type.Object({
   prompt,
   providers: Type.Array(StringEnum(providerNames), {
     minItems: 2,
-    maxItems: 4,
-    description: "Two to four unique providers. Results preserve this input order.",
+    maxItems: 5,
+    description: "Two to five unique providers. Results preserve this input order.",
   }),
   options: Type.Optional(
     Type.Object({
       codex: Type.Optional(providerOptionSchemas.codex),
       gemini: Type.Optional(providerOptionSchemas.gemini),
+      grok: Type.Optional(providerOptionSchemas.grok),
       ollama: Type.Optional(providerOptionSchemas.ollama),
       antigravity: Type.Optional(providerOptionSchemas.antigravity),
     }),
@@ -128,7 +153,7 @@ type ProgressUpdate = {
   details: Record<string, unknown>;
 };
 
-function progressForwarder(onUpdate: ((result: ProgressUpdate) => void) | undefined, provider: ProviderName) {
+function progressForwarder(onUpdate: ((result: ProgressUpdate) => void) | undefined, provider: string) {
   return onUpdate
     ? (text: string) => {
         const output = bounded(text);
@@ -178,6 +203,14 @@ export function registerProviderTools(pi: ExtensionAPI): void {
     parameters: geminiSchema,
     provider: "gemini",
   });
+  registerProviderTool(pi, {
+    name: "ask-grok",
+    label: "Ask Grok",
+    description:
+      "Consult Grok through Ask LLM's canonical xAI API executor. Requires XAI_API_KEY and may incur metered API charges; no billing changes or model fallback are performed. Output is bounded to Pi's 50KB/2000-line limits.",
+    parameters: grokSchema,
+    provider: "grok",
+  });
   registerProviderTool(pi, {
     name: "ask-ollama",
     label: "Ask Ollama",
@@ -195,11 +228,40 @@ export function registerProviderTools(pi: ExtensionAPI): void {
     provider: "antigravity",
   });
 
+  pi.registerTool({
+    name: "ask-cursor-agent",
+    label: "Ask via Cursor Agent",
+    description:
+      "Use Cursor Agent as a model-neutral read-only harness. Provider (claude, codex, gemini, grok) and exact model ID are separate and must agree; Auto or noncanonical catalog IDs are refused. Prompts above 16KB are piped over stdin. Requires an authenticated Cursor CLI and may consume included usage or on-demand spend; no spend settings or fallback are changed.",
+    parameters: cursorAgentSchema,
+    async execute(_toolCallId, params, signal, onUpdate) {
+      const result = await executeCursorAgent({
+        prompt: params.prompt,
+        provider: params.provider,
+        model: params.model,
+        signal,
+        onProgress: progressForwarder(onUpdate, params.provider),
+      });
+      const text = bounded(result.response);
+      return {
+        content: [{ type: "text", text: text.text }],
+        details: {
+          provider: result.provider,
+          harness: result.harness,
+          model: result.model,
+          reportedModel: result.reportedModel,
+          askLlmUsage: result.usage,
+          outputTruncated: text.truncated,
+        },
+      };
+    },
+  });
+
   pi.registerTool({
     name: "ask-multi",
     label: "Ask Multiple Providers",
     description:
-      "Send exactly the same prompt to two to four Ask LLM providers concurrently. Dispatch is deterministic and bounded; results preserve provider input order and report every failure instead of silently dropping it.",
+      "Send exactly the same prompt to two to five Ask LLM providers concurrently. Dispatch is deterministic and bounded; results preserve provider input order and report every failure instead of silently dropping it.",
     parameters: askMultiSchema,
     async execute(_toolCallId, params, signal, onUpdate) {
       const unique = [...new Set(params.providers)];

package/scripts/lib/process.mjs

@@ -14,6 +14,23 @@ import { platform } from "node:process";
 
 export const IS_WINDOWS = platform === "win32";
 
+export function quoteArgsForWindows(args) {
+  return args.map((arg) => {
+    if (arg.includes(" ") || arg.includes('"') || arg.includes("&") || arg.includes("|") || arg.includes("^")) {
+      return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    return arg;
+  });
+}
+
+export function prepareCommandInvocation(args, options, runtimePlatform = platform) {
+  const isWindows = runtimePlatform === "win32";
+  return {
+    args: isWindows ? quoteArgsForWindows(args) : args,
+    options: { ...options, shell: isWindows },
+  };
+}
+
 export function terminateProcessTree(child, signal) {
   if (!child || typeof child.pid !== "number" || child.killed || child.exitCode !== null) {
     return;

package/scripts/sol-review-transport.mjs

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { prepareCommandInvocation } from "./lib/process.mjs";
+
+export const ASK_CODEX_PACKAGE = "@ask-llm/codex-mcp";
+export const ASK_CODEX_TOOL = "ask-codex";
+export const SOL_MODEL = "gpt-5.6-sol";
+export const TERRA_MODEL = "gpt-5.6-terra";
+
+const scriptPath = fileURLToPath(import.meta.url);
+const quotaSignals = [
+  "rate_limit_exceeded",
+  "quota_exceeded",
+  "429",
+  "insufficient_quota",
+  "out of credits",
+  "spend cap",
+  "usage limit",
+];
+
+export function isAskCodexToolName(name) {
+  return name === ASK_CODEX_TOOL || /^mcp__.+__ask-codex$/.test(name);
+}
+
+export function isAskCodexRegistration(server) {
+  if (!server || typeof server !== "object") return false;
+  const command = typeof server.command === "string" ? server.command : "";
+  const args = Array.isArray(server.args) ? server.args.filter((arg) => typeof arg === "string") : [];
+  const commandLine = typeof server.commandLine === "string" ? server.commandLine : "";
+  return (
+    /(?:^|[/\\])ask-codex-mcp(?:\.cmd|\.exe)?$/.test(command) ||
+    args.includes(ASK_CODEX_PACKAGE) ||
+    /(?:^|\s)@ask-llm\/codex-mcp(?:@[^\s]+)?(?:\s|$)/.test(commandLine) ||
+    /(?:^|[/\\])ask-codex-mcp(?:\.cmd|\.exe)?(?:\s|$)/.test(commandLine)
+  );
+}
+
+export function parseClaudeMcpList(output) {
+  const servers = {};
+  for (const line of output.split(/\r?\n/)) {
+    const separator = line.indexOf(": ");
+    if (separator <= 0) continue;
+    const name = line.slice(0, separator).trim();
+    const details = line.slice(separator + 2).trim();
+    const statusSeparator = details.search(/ - (?=(?:✔|✘|!|⏸|cached\b|not configured\b|disabled\b))/i);
+    servers[name] = {
+      commandLine: statusSeparator === -1 ? details : details.slice(0, statusSeparator).trim(),
+      status: statusSeparator === -1 ? "" : details.slice(statusSeparator + 3).trim(),
+    };
+  }
+  return servers;
+}
+
+export function readActiveMcpServers({
+  command = process.env.CLAUDE_BIN || "claude",
+  execute = spawnSync,
+  platform = process.platform,
+  contextArgs = [],
+} = {}) {
+  const invocation = prepareCommandInvocation(
+    [...contextArgs, "mcp", "list"],
+    {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      windowsHide: true,
+    },
+    platform,
+  );
+  const result = execute(command, invocation.args, invocation.options);
+  if (result.error || result.status !== 0) {
+    const detail = result.error?.message || result.stderr?.trim() || `exited ${result.status}`;
+    throw new Error(`Unable to inspect active Claude MCP registrations: ${detail}.`);
+  }
+  return parseClaudeMcpList(result.stdout || "");
+}
+
+function expectedToolName(serverName) {
+  return `mcp__${serverName.replaceAll(":", "_")}__${ASK_CODEX_TOOL}`;
+}
+
+function isAvailableMcpServer(server) {
+  const status = typeof server?.status === "string" ? server.status.trim() : "";
+  return !status || /^✔\s*Connected\b/i.test(status) || /^cached\b.*\bconnects on first use\b/i.test(status);
+}
+
+export function classifySolReviewTransport({
+  availableTools = [],
+  mcpServers = {},
+  cliPath = "",
+  inventoryError = null,
+  mcpFailed = false,
+}) {
+  if (inventoryError) {
+    const reason = `Ask LLM Codex MCP availability could not be determined because the active Claude MCP inventory could not be inspected: ${inventoryError}`;
+    const remediation = "Run `claude mcp list`, resolve the inventory failure, then fully restart Claude Code.";
+    if (!cliPath) {
+      return {
+        state: "inventory-unavailable",
+        transport: null,
+        toolName: null,
+        diagnostic: `${reason} The explicit CLI fallback is also unavailable.`,
+        remediation: `${remediation} Install the fallback with \`npm install -g @openai/codex\` if needed.`,
+        fallbackDisclosure: null,
+      };
+    }
+    return {
+      state: "inventory-unavailable",
+      transport: "cli",
+      toolName: null,
+      diagnostic: reason,
+      remediation,
+      fallbackDisclosure: `Transport disclosure: ${reason} Running the review through the explicit \`codex exec\` CLI fallback without claiming MCP registration or availability; validated findings will be relayed unchanged.`,
+    };
+  }
+
+  const registrations = Object.entries(mcpServers).filter(([, server]) => isAskCodexRegistration(server));
+  const availableRegistrations = registrations.filter(([, server]) => isAvailableMcpServer(server));
+  const registeredToolNames = new Set(availableRegistrations.map(([name]) => expectedToolName(name)));
+  const toolName = availableTools.find((name) => isAskCodexToolName(name) && registeredToolNames.has(name));
+  if (toolName && !mcpFailed) {
+    return {
+      state: "preferred",
+      transport: "mcp",
+      toolName,
+      diagnostic: `Ask LLM Codex transport available as ${toolName}.`,
+      remediation: null,
+      fallbackDisclosure: null,
+    };
+  }
+
+  const registered = registrations.length > 0;
+  const state = registered || mcpFailed ? "unavailable" : "missing-registration";
+  const remediation =
+    registered || mcpFailed
+      ? "Run `npx -y @ask-llm/mcp doctor`, inspect `/mcp`, then fully restart Claude Code."
+      : "Run `claude mcp add --scope user codex -- npx -y @ask-llm/codex-mcp`, fully restart Claude Code, then verify with `/mcp`.";
+  const unavailableRegistration = registrations.find(([, server]) => !isAvailableMcpServer(server));
+  const reason = mcpFailed
+    ? "Ask LLM Codex MCP invocation failed in this session, so the preferred transport is unavailable."
+    : unavailableRegistration
+      ? `Ask LLM Codex MCP is registered, but active inventory reports it unavailable: ${unavailableRegistration[1].status}.`
+      : registered
+        ? "Ask LLM Codex MCP is registered, but its `ask-codex` tool is unavailable in this session."
+        : "Ask LLM Codex MCP registration is missing from this Claude Code installation.";
+
+  if (!cliPath) {
+    return {
+      state,
+      transport: null,
+      toolName: null,
+      diagnostic: `${reason} The explicit CLI fallback is also unavailable.`,
+      remediation: `${remediation} Install the fallback with \`npm install -g @openai/codex\` if needed.`,
+      fallbackDisclosure: null,
+    };
+  }
+
+  return {
+    state,
+    transport: "cli",
+    toolName: null,
+    diagnostic: reason,
+    remediation,
+    fallbackDisclosure: `Transport disclosure: ${reason} Running the review through the explicit \`codex exec\` CLI fallback; validated findings will be relayed unchanged.`,
+  };
+}
+
+export function codexFallbackArgs(model) {
+  return [
+    "exec",
+    "-m",
+    model,
+    "-c",
+    'model_reasoning_effort="high"',
+    "-s",
+    "read-only",
+    "--ignore-user-config",
+    "--ignore-rules",
+    "--skip-git-repo-check",
+  ];
+}
+
+export function executeCodex({ command, model, prompt, spawnProcess = spawn, platform = process.platform }) {
+  return new Promise((resolveRun) => {
+    const invocation = prepareCommandInvocation(
+      codexFallbackArgs(model),
+      {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      },
+      platform,
+    );
+    const child = spawnProcess(command, invocation.args, invocation.options);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      resolveRun({ code: 127, stdout, stderr: `${stderr}${error.message}` });
+    });
+    child.on("close", (code) => {
+      resolveRun({ code: code ?? 1, stdout, stderr });
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(prompt);
+  });
+}
+
+export async function runCliFallback({
+  prompt,
+  command = process.env.ASK_CODEX_BIN || "codex",
+  fallbackModel = process.env.ASK_CODEX_FALLBACK_MODEL || TERRA_MODEL,
+  execute = executeCodex,
+}) {
+  const primary = await execute({ command, model: SOL_MODEL, prompt });
+  if (primary.code === 0) {
+    return { response: primary.stdout, diagnostics: primary.stderr, model: SOL_MODEL, fellBack: false };
+  }
+
+  const primaryOutput = `${primary.stderr}\n${primary.stdout}`;
+  const normalizedPrimaryOutput = primaryOutput.toLowerCase();
+  const quotaFailure = quotaSignals.some((signal) => normalizedPrimaryOutput.includes(signal));
+  if (!quotaFailure || fallbackModel === SOL_MODEL) {
+    throw new Error(primaryOutput.trim() || `codex exec exited ${primary.code}`);
+  }
+
+  const fallback = await execute({ command, model: fallbackModel, prompt });
+  if (fallback.code !== 0) {
+    const fallbackOutput = `${fallback.stderr}\n${fallback.stdout}`.trim();
+    throw new Error(`Sol review failed and ${fallbackModel} fallback also failed: ${fallbackOutput}`);
+  }
+
+  return {
+    response: fallback.stdout,
+    diagnostics: fallback.stderr,
+    model: fallbackModel,
+    fellBack: true,
+  };
+}
+
+function parseArgs(args) {
+  const parsed = {
+    tools: [],
+    cliPath: "",
+    mcpList: null,
+    fallback: false,
+    mcpFailed: false,
+    claudeContextArgs: [],
+  };
+  const claudeContextValueFlags = new Set(["--plugin-dir", "--mcp-config", "--settings", "--setting-sources"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--fallback") parsed.fallback = true;
+    else if (arg === "--mcp-failed") parsed.mcpFailed = true;
+    else if (arg === "--tool") parsed.tools.push(args[++index] ?? "");
+    else if (arg === "--cli-path") parsed.cliPath = args[++index] ?? "";
+    else if (arg === "--mcp-list") parsed.mcpList = args[++index] ?? "";
+    else if (arg === "--strict-mcp-config") parsed.claudeContextArgs.push(arg);
+    else if (claudeContextValueFlags.has(arg)) {
+      const value = args[++index];
+      if (value === undefined) throw new Error(`Missing value for ${arg}`);
+      parsed.claudeContextArgs.push(arg, value);
+    } else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return parsed;
+}
+
+function readMcpServers(parsed) {
+  if (parsed.mcpList !== null) {
+    return { mcpServers: parseClaudeMcpList(parsed.mcpList), inventoryError: null };
+  }
+  try {
+    return {
+      mcpServers: readActiveMcpServers({ contextArgs: parsed.claudeContextArgs }),
+      inventoryError: null,
+    };
+  } catch (error) {
+    return {
+      mcpServers: {},
+      inventoryError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const { mcpServers, inventoryError } = readMcpServers(parsed);
+  const decision = classifySolReviewTransport({
+    availableTools: parsed.tools,
+    mcpServers,
+    cliPath: parsed.cliPath,
+    inventoryError,
+    mcpFailed: parsed.mcpFailed,
+  });
+
+  if (parsed.fallback) {
+    if (decision.transport !== "cli") {
+      if (decision.transport === "mcp") {
+        throw new Error(`Ask LLM Codex MCP is available as ${decision.toolName}; CLI fallback was not started.`);
+      }
+      throw new Error(`${decision.diagnostic} ${decision.remediation}`);
+    }
+    process.stderr.write(`${decision.fallbackDisclosure}\nRemediation: ${decision.remediation}\n`);
+    let prompt = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) prompt += chunk;
+    if (!prompt.trim()) throw new Error("Sol review CLI fallback requires a prompt on stdin.");
+    const result = await runCliFallback({ prompt, command: parsed.cliPath });
+    process.stderr.write(
+      `Transport disclosure: review ran through codex exec (${result.model}, high effort, read-only).\n`,
+    );
+    if (result.fellBack) {
+      process.stderr.write(`Model fallback disclosure: Sol hit quota; review completed on ${result.model}.\n`);
+    }
+    if (result.diagnostics) process.stderr.write(result.diagnostics);
+    process.stdout.write(result.response);
+    return;
+  }
+
+  process.stdout.write(`${JSON.stringify(decision)}\n`);
+  if (!decision.transport) process.exitCode = 1;
+}
+
+if (resolve(process.argv[1] || "") === scriptPath) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/skills/brainstorm/SKILL.md

@@ -30,9 +30,10 @@ Consult multiple external LLM providers simultaneously on a topic while Claude O
 
 ### Phase 1: Parse arguments
 
-- If the first argument looks like a comma-separated provider list (e.g., `antigravity,codex` or `gemini,codex,ollama`), use those as the external providers
+- If the first argument looks like a comma-separated provider list (e.g., `antigravity,codex` or `gemini,codex,grok,ollama`), use those as the external providers
 - If no provider list is given, default to `antigravity,codex`
-- Valid external providers: `gemini`, `codex`, `ollama`, `antigravity`
+- Valid external providers: `gemini`, `codex`, `grok`, `ollama`, `antigravity`
+- `grok` requires `XAI_API_KEY` for the default API harness or official Grok Build auth with `ASK_GROK_HARNESS=grok-cli`; it may consume metered/plan usage and never falls back
 - `antigravity` requires `agy` installed + logged in; if it's unavailable the coordinator surfaces that and continues with the other providers
 - Everything after the provider list (or all args if no list) is the topic
 - Claude Opus is always a participant — it's not in the provider list because it runs inside the coordinator

package/skills/brainstorm-all/SKILL.md

@@ -1,19 +1,19 @@
 ---
 name: brainstorm-all
-description: Send a topic to all external providers (Gemini, Codex, Ollama, Antigravity) concurrently after the current host model forms an independent view. Use when the user wants an all-provider brainstorm with synthesis and explicit unavailable-provider reporting.
+description: Send a topic to all external providers (Gemini, Codex, Grok, Ollama, Antigravity) concurrently after the current host model forms an independent view. Use when the user wants an all-provider brainstorm with synthesis and explicit unavailable-provider reporting.
 ---
 
 <!-- PORTABLE-CONTRACT:START -->
 ## Portable contract
 
-Apply the brainstorm contract with all four external providers: Gemini, Codex, Ollama, and Antigravity. The current host model forms its independent view first; unavailable providers are reported, not silently omitted; synthesis distinguishes verified evidence from inference.
+Apply the brainstorm contract with all five external providers: Gemini, Codex, Grok, Ollama, and Antigravity. The current host model forms its independent view first; unavailable providers are reported, not silently omitted; synthesis distinguishes verified evidence from inference.
 <!-- PORTABLE-CONTRACT:END -->
 
 ## Host adapters
 
 ### Pi adapter
 
-Follow `/skill:brainstorm` semantics with `ask-multi` providers `gemini,codex,ollama,antigravity`, after the current Pi host model has committed its independent view.
+Follow `/skill:brainstorm` semantics with `ask-multi` providers `gemini,codex,grok,ollama,antigravity`, after the current Pi host model has committed its independent view.
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:START -->
 ### Claude Code adapter
@@ -24,7 +24,7 @@ The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP,
 
 # Multi-LLM Brainstorm (All Providers)
 
-Consult all available external LLM providers (Gemini, Codex, Ollama, Antigravity) simultaneously while Claude Opus performs its own independent research on the topic, then synthesize perspectives from all five participants.
+Consult all available external LLM providers (Gemini, Codex, Grok, Ollama, Antigravity) simultaneously while Claude Opus performs its own independent research on the topic, then synthesize perspectives from all six participants.
 
 ## Instructions
 
@@ -35,9 +35,9 @@ Consult all available external LLM providers (Gemini, Codex, Ollama, Antigravity
 
 2. If no topic is clear, ask the user what they'd like to brainstorm about.
 
-3. Launch the `brainstorm-coordinator` agent with the topic, external providers set to `gemini,codex,ollama,antigravity`, and any gathered context. The coordinator will:
+3. Launch the `brainstorm-coordinator` agent with the topic, external providers set to `gemini,codex,grok,ollama,antigravity`, and any gathered context. The coordinator will:
    - Run its own Claude Opus research phase in parallel with the external dispatches (Phase 3B — reads actual files, traces code, uses WebFetch/WebSearch on referenced external docs)
-   - Dispatch the topic to the four external providers in parallel (Phase 3A)
+   - Dispatch the topic to the five external providers in parallel (Phase 3A)
    - Synthesize all findings with Claude's verified findings weighted higher than inferred ones
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/compare/SKILL.md

@@ -1,19 +1,19 @@
 ---
 name: compare
-description: This skill should be used when the user asks to "compare LLMs", "see how each provider answers", "side-by-side response", "what do Gemini, Codex, Ollama, and Antigravity think", or wants raw responses from multiple providers without synthesis. Unlike /brainstorm (which synthesizes findings) or /multi-review (which validates code reviews), /compare just shows each provider's answer side-by-side.
+description: This skill should be used when the user asks to "compare LLMs", "see how each provider answers", "side-by-side response", "what do Gemini, Codex, Grok, Ollama, and Antigravity think", or wants raw responses from multiple providers without synthesis. Unlike /brainstorm (which synthesizes findings) or /multi-review (which validates code reviews), /compare just shows each provider's answer side-by-side.
 ---
 
 <!-- PORTABLE-CONTRACT:START -->
 ## Portable contract
 
-Send the exact same bounded prompt to two to four selected providers concurrently. Preserve input order in the result, show each response verbatim without synthesis or adjudication, and show every provider failure instead of silently dropping it. Never invoke raw provider CLIs when a canonical Ask LLM bridge is available.
+Send the exact same bounded prompt to two to five selected providers concurrently. Preserve input order in the result, show each response verbatim without synthesis or adjudication, and show every provider failure instead of silently dropping it. Never invoke raw provider CLIs when a canonical Ask LLM bridge is available.
 <!-- PORTABLE-CONTRACT:END -->
 
 ## Host adapters
 
 ### Pi adapter
 
-Use one native `ask-multi` call. Put the common prompt in `prompt` and two to four unique names in `providers`; its implementation, not model-emitted sibling calls, guarantees concurrent bounded dispatch and stable ordering.
+Use one native `ask-multi` call. Put the common prompt in `prompt` and two to five unique names in `providers`; its implementation, not model-emitted sibling calls, guarantees concurrent bounded dispatch and stable ordering.
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:START -->
 ### Claude Code adapter
@@ -41,8 +41,8 @@ If you're reviewing a code diff → use `/multi-review` instead.
 
 Extract from the user's message:
 1. **The question/prompt** to send to all providers (the meaningful payload)
-2. **Optional provider filter** — if the user says "compare gemini and codex", only those two; otherwise default to all four (gemini, codex, ollama, antigravity)
-3. **Optional context files** — if the user references files (`@path/to/file`), Read each referenced file and inline its contents into the shared provider prompt under a clearly labeled `<context_file path="...">` block. `@file` expansion is Gemini-only; passing the literal path to Codex, Ollama, or Antigravity silently drops the context. For a file too large to inline safely, include the relevant excerpts and state what was omitted.
+2. **Optional provider filter** — if the user says "compare gemini and codex", only those two; otherwise default to all five (gemini, codex, grok, ollama, antigravity)
+3. **Optional context files** — if the user references files (`@path/to/file`), Read each referenced file and inline its contents into the shared provider prompt under a clearly labeled `<context_file path="...">` block. `@file` expansion is Gemini-only; passing the literal path to Codex, Ollama, Grok, or Antigravity silently drops the context. For a file too large to inline safely, include the relevant excerpts and state what was omitted.
 
 If the question is missing or ambiguous, ask the user to clarify before dispatching.
 
@@ -61,6 +61,9 @@ gem_pid=$!
 GMCPT_TIMEOUT_MS=480000 node ${CLAUDE_PLUGIN_ROOT}/dist/codex-run.js "$PROMPT" > "$workdir/codex.out" 2> "$workdir/codex.err" &
 codex_pid=$!
 
+GMCPT_TIMEOUT_MS=480000 node ${CLAUDE_PLUGIN_ROOT}/dist/grok-run.js "$PROMPT" > "$workdir/grok.out" 2> "$workdir/grok.err" &
+grok_pid=$!
+
 GMCPT_TIMEOUT_MS=480000 node ${CLAUDE_PLUGIN_ROOT}/dist/ollama-run.js "$PROMPT" > "$workdir/ollama.out" 2> "$workdir/ollama.err" &
 ollama_pid=$!
 
@@ -69,6 +72,7 @@ antigravity_pid=$!
 
 gemini_rc=0; wait $gem_pid || gemini_rc=$?
 codex_rc=0; wait $codex_pid || codex_rc=$?
+grok_rc=0; wait $grok_pid || grok_rc=$?
 ollama_rc=0; wait $ollama_pid || ollama_rc=$?
 antigravity_rc=0; wait $antigravity_pid || antigravity_rc=$?
 
@@ -85,6 +89,7 @@ dump_provider() {
 
 dump_provider gemini "$gemini_rc"
 dump_provider codex "$codex_rc"
+dump_provider grok "$grok_rc"
 dump_provider ollama "$ollama_rc"
 dump_provider antigravity "$antigravity_rc"
 ```
@@ -110,6 +115,9 @@ Output structure:
 ### Codex
 > <verbatim provider response>
 
+### Grok
+> <verbatim provider response>
+
 ### Ollama
 > <verbatim provider response>
 

package/skills/grok-review/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: grok-review
+description: Get an independent Grok code review through the xAI API. Use when the user asks to review with Grok or wants a Grok second opinion. Requires XAI_API_KEY and explicit acceptance of metered xAI API pricing.
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Gather the relevant staged, unstaged, and untracked changes; build a bounded context brief; request an independent Grok review; verify every reported finding against source; and return only prioritized, source-supported findings. State that project context is sent to xAI and may incur API charges. Never enable billing, buy credits, use priority processing, substitute models, or retry on another model.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Pi adapter
+
+Call the native `ask-grok` tool and apply only the `Portable contract` section of `../../agents/grok-reviewer.md`; ignore that file's frontmatter and Claude Code adapter.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+Review current code changes by delegating to the `grok-reviewer` agent.
+
+1. Confirm the user configured `XAI_API_KEY` and understands xAI API usage is metered separately from any Grok consumer subscription. Do not configure billing or credits.
+2. Gather `git diff`, `git diff --cached`, and relevant untracked files. If there are no changes, say so.
+3. Launch the `grok-reviewer` agent with a bounded diff and relevant project instructions.
+4. If the Grok MCP tool is unavailable, explain how to register it without attempting another provider. For API use:
+   `claude mcp add --scope user grok -e XAI_API_KEY="$XAI_API_KEY" -- npx -y @ask-llm/grok-mcp`
+   For official Grok Build, install/authenticate `grok`, set `ASK_GROK_HARNESS=grok-cli` in the MCP environment, and register the same package without silently switching from API.
+5. Preserve provider/model/harness attribution and any xAI error verbatim after secret redaction. Never silently route to Codex, Gemini, or another model.
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/sol-review/SKILL.md

@@ -32,10 +32,14 @@ Run a read-only, precision-first review explicitly pinned to GPT-5.6 Sol at high
 2. Include untracked files the user wants reviewed with `git add -N <path>` so their contents appear in the diff without staging them.
 3. If the combined diff is empty, report that there are no changes to review.
 4. Read the root and file-scoped `CLAUDE.md` files plus any ADRs cited by changed code.
-5. Preflight the transport: check whether an `ask-codex` MCP tool is available in the current session (the name may be plugin-namespaced, e.g. `mcp__plugin_ask-llm_codex__ask-codex`). Subagents do not always inherit the session's MCP servers, so treat availability here as advisory only. If no MCP tool resolves, confirm the `codex` CLI is on `PATH` (`command -v codex`); if neither transport exists, stop and tell the user to install one instead of launching the agent.
-6. Launch the `sol-reviewer` agent with the diff and a compact context brief containing the changed files, applicable conventions, referenced ADRs, the user's requested review focus, and the preflight result (which transport to expect).
+5. Preflight the transport through the shipped executable contract:
+   - Search the current tool surface for the exact `ask-codex` leaf tool. The executable correlates its client-assigned server prefix with an active `@ask-llm/codex-mcp` registration; similarly named tools and tools from unrelated servers are not authoritative.
+   - Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/sol-review-transport.mjs" --plugin-dir "${CLAUDE_PLUGIN_ROOT}" --cli-path "$(command -v codex || true)"`, adding `--tool "<resolved tool name>"` only when the exact `ask-codex` tool resolved. Mirror any session-local `--mcp-config`, `--settings`, `--setting-sources`, and `--strict-mcp-config` flags so the nested inventory sees the same configuration as the active session.
+   - Preserve the returned `state`, `diagnostic`, `remediation`, and `fallbackDisclosure`. The executable reads `claude mcp list` with that session context: `missing-registration` means that active inventory has no supported registration; `unavailable` means it contains the registration but the current tool surface does not expose a usable tool, reports failed health, or the MCP invocation failed; `inventory-unavailable` means the active inventory could not be inspected, so registration and service health are unknown. Do not collapse those states into a generic "no MCP" message. If `transport` is null, stop and show the executable remediation instead of launching the agent.
+   - Parent availability remains advisory because subagents do not always inherit the session's MCP servers. The reviewer's fallback runner re-reads the active inventory and reclassifies the absent subagent tool before executing the CLI fallback.
+6. Launch the `sol-reviewer` agent with the diff and a compact context brief containing the changed files, applicable conventions, referenced ADRs, the user's requested review focus, and the complete preflight result.
 7. Return the agent's validated findings without adding unverified issues.
 
-The reviewer must call `ask-codex` with `model: "gpt-5.6-sol"` and `reasoningEffort: "high"`, or, when no `ask-codex` MCP tool is available in the subagent context, use the sanctioned CLI fallback defined in the agent (`codex exec -m gpt-5.6-sol -c model_reasoning_effort="high" -s read-only --ignore-user-config --ignore-rules --skip-git-repo-check`). This explicit pin distinguishes `/sol-review` from `/codex-review`, which follows the configured Codex default. Both fallback kinds must be disclosed in the report: a Terra quota fallback means the requested Sol review did not complete on Sol, and a CLI transport fallback means the review ran through `codex exec` rather than MCP.
+The reviewer must call `ask-codex` with `model: "gpt-5.6-sol"` and `reasoningEffort: "high"`, or use the shipped CLI fallback runner when no usable `ask-codex` MCP tool is available or its invocation fails at the transport/service boundary. That runner executes the sanctioned `codex exec -m gpt-5.6-sol -c model_reasoning_effort="high" -s read-only --ignore-user-config --ignore-rules --skip-git-repo-check` contract and relays its result unchanged. This explicit pin distinguishes `/sol-review` from `/codex-review`, which follows the configured Codex default. Both fallback kinds must be disclosed in the report: a Terra quota fallback means the requested Sol review did not complete on Sol, and a CLI transport fallback must report missing registration, registered-service unavailability, or an unreadable inventory without claiming a state that could not be determined.
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:END -->