@ask-llm/plugin 0.14.0 → 0.15.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-llm",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "AI-to-AI collaboration — review code and debate plans across Codex, Grok, Antigravity, Ollama, and Gemini",
   "author": {
     "name": "Anton Lykhoyda",

package/.cursor-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "ask-llm",
+  "displayName": "Ask LLM",
+  "version": "0.15.0",
+  "description": "Portable AI-to-AI review and pairing workflows for Cursor Agent with explicit provider transports.",
+  "author": {
+    "name": "Anton Lykhoyda"
+  },
+  "license": "MIT",
+  "keywords": [
+    "cursor",
+    "codex",
+    "grok",
+    "pair-programming",
+    "code-review"
+  ],
+  "skills": [
+    "./skills/codex-pair",
+    "./skills/grok-pair"
+  ],
+  "agents": [],
+  "commands": [],
+  "hooks": {},
+  "mcpServers": "./mcp.json"
+}

package/README.md

@@ -2,11 +2,11 @@
 
 <div align="center">
 
-**Canonical Claude Code + Pi host package for AI-to-AI collaboration**
+**Canonical Claude Code, Cursor Agent, and Pi host package for AI-to-AI collaboration**
 
 </div>
 
-One publishable package that adds multi-provider code review, comparison, brainstorming, verification, image, and pairing workflows to [Claude Code](https://code.claude.com/docs/en/plugins) and [Pi](https://pi.dev). Both hosts consume one skill corpus and package version; host-specific behavior is kept in explicit adapters.
+One publishable package that adds multi-provider code review, comparison, brainstorming, verification, image, and pairing workflows to [Claude Code](https://code.claude.com/docs/en/plugins), [Cursor Agent](https://cursor.com/docs/skills), and [Pi](https://pi.dev). The hosts consume one skill corpus and package version; host-specific behavior is kept in explicit adapters.
 
 Part of the [Ask LLM](https://github.com/Lykhoyda/ask-llm) monorepo.
 
@@ -23,9 +23,16 @@ Part of the [Ask LLM](https://github.com/Lykhoyda/ask-llm) monorepo.
 
 ### 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.
+The plugin bundles only the 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. `/sol-review` selects `ask-codex`.
 
-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:
+`/grok-pair` does not add servers to the plugin. Register the unified Ask LLM server at user scope (the recommended install: it exposes `ask-cursor-agent` for the Cursor Agent route plus the unified `ask-llm` tool, which pair skills call only fully pinned) and, optionally, the split Grok server for the `ask-grok` leaf:
+
+```bash
+claude mcp add --scope user ask-llm -- npx -y @ask-llm/mcp
+claude mcp add --scope user grok -- npx -y @ask-llm/grok-mcp
+```
+
+Existing user-scoped Codex registrations remain compatible and keep their shorter names. Other providers are registered explicitly at user scope:
 
 ```bash
 claude mcp add --scope user gemini -- npx -y @ask-llm/gemini-mcp
@@ -33,6 +40,16 @@ claude mcp add --scope user ollama -- npx -y @ask-llm/ollama-mcp
 claude mcp add --scope user antigravity -- npx -y @ask-llm/antigravity-mcp
 ```
 
+### Cursor Agent
+
+Cursor's supported Agent Skills surface exposes exactly `/codex-pair` and `/grok-pair` (the manifest sets `agents: []`, `commands: []`, and `hooks: {}` so Claude agents and the Claude-format hooks file are never auto-discovered, and the other skills stay Claude/Pi-only until they get Cursor adapters); its MCP surface is `mcp.json`, which bundles only the unified `ask-llm` server. For a source checkout:
+
+```bash
+agent --plugin-dir ./packages/claude-plugin
+```
+
+`/codex-pair` requires explicit `model=` and `effort=` values before consent, then uses a separately user-installed `ask-codex` leaf when exposed, otherwise the bundled unified `ask-llm` fully pinned (`provider: "codex"`, model, effort, include directories, session), with resumable Thread ID, cancellation, and result relay. It never guesses MCP-process environment defaults and does not pretend Claude-only hooks are active. `/grok-pair` gives Cursor-native `.cursor/mcp.json` and Tools & MCP reload guidance; it never sends Cursor users to `claude mcp add`. If installing only MCP configuration, the recommended minimal entry is `ask-llm` → `npx -y @ask-llm/mcp` in project `.cursor/mcp.json` or user `~/.cursor/mcp.json` (keep one registration per server — do not duplicate it when the plugin is loaded); add `codex` → `@ask-llm/codex-mcp` or `grok` → `@ask-llm/grok-mcp` only when you specifically want their `ask-codex`/`ask-grok` leaves, then reload MCP/restart Cursor Agent. When Cursor hosts `/grok-pair`, it never recursively invokes Cursor Agent.
+
 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
@@ -42,7 +59,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-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.
+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` and `grok-pair` are excluded from Pi discovery; Grok pairing currently has Claude/Cursor adapters, while Pi retains its dedicated Codex pairing lifecycle.
 
 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.
 
@@ -63,11 +80,31 @@ See the [Pi host guide](https://lykhoyda.github.io/ask-llm/plugin/pi) for securi
 | `/fable-review` | Isolated, read-only review requesting native Fable, with runtime verification limits disclosed |
 | `/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` | Explicit multi-model brainstorm (default external: Antigravity + Codex); supports an exact no-Gemini Grok + GPT-5.6 Sol panel through Cursor Agent |
 | `/grok-review` | Grok review through explicit xAI API or Grok CLI harness; no fallback |
+| `/grok-pair` | Consent-gated iterative Grok reviewer through exact Cursor Agent, xAI API, or Grok CLI route; no fallback |
+| `/codex-pair` | Claude/Pi per-edit pairing dashboard; Cursor on-demand session adapter with explicit Thread ID continuity |
 | `/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) |
 
+### Exact Grok + GPT-5.6 Sol brainstorm
+
+The preferred architect panel routes both models through the model-neutral Cursor Agent harness with provider and exact account-catalog ID kept separate:
+
+```text
+/brainstorm grok@cursor-agent:cursor-grok-4.6-high,codex@cursor-agent:gpt-5.6-sol-high "review this architecture"
+```
+
+This panel calls exactly Grok and GPT-5.6 Sol—never Gemini. Cursor `Auto`, model rewriting, and harness/provider fallback are forbidden. If one participant fails, the result is partial and cannot be presented as two-model consensus. Catalogs are account-specific; confirm these exact IDs with `agent --list-models` and replace an unavailable ID explicitly.
+
+Official Grok Build remains an explicit alternative when its installed headless contract is supported:
+
+```text
+/brainstorm grok@grok-cli:grok-build,codex@cursor-agent:gpt-5.6-sol-high "review this architecture"
+```
+
+A Grok CLI failure remains a Grok CLI failure; the workflow does not pivot to Cursor or xAI.
+
 ## Agents
 
 | Agent | Color | Description |
@@ -77,7 +114,7 @@ See the [Pi host guide](https://lykhoyda.github.io/ask-llm/plugin/pi) for securi
 | fable-reviewer | purple | Fable-requested review with source-verified findings |
 | sol-reviewer | blue | GPT-5.6 Sol review through Codex with source validation |
 | ollama-reviewer | yellow | 4-phase: context, prompt, synthesis, validation (local) |
-| brainstorm-coordinator | magenta | Claude Opus research + parallel multi-LLM consultation with synthesis; verified findings weighted higher than inferred |
+| brainstorm-coordinator | magenta | Source-grounded research + parallel multi-model consultation; exact two-model mode keeps the host non-voting and partial failures out of consensus |
 
 ## Hooks
 
@@ -127,10 +164,11 @@ To disable:
 
 ## Requirements
 
-- **Claude Code or Pi 0.83.0+** installed
+- **Claude Code, Cursor Agent, or Pi 0.83.0+** installed
 - **Claude Code** installed for marketplace agents, hooks, independent Fable review, and the blocking Stop gate
 - **Gemini CLI** authenticated — required for hooks and Gemini features
-- **Codex CLI** — required for `/codex-review` and brainstorm with Codex
+- **Codex CLI** — required for `/codex-review` and direct-Codex brainstorm routes
+- **Cursor Agent CLI** authenticated with exact catalog IDs — required only for `@cursor-agent` brainstorm routes
 - **Ollama** running locally — required for `/ollama-review`
 
 ## Documentation

package/agents/brainstorm-coordinator.md

@@ -32,18 +32,20 @@ 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, 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.
+1. **Research independently before dispatch.** Perform deep analysis of the topic — read the actual files, trace real code paths, and factor in framework-specific semantics. In standard mode this is a peer participant. In the exact Grok + GPT-5.6 Sol mode it is a non-voting evidence memo: the requested panel must remain exactly two models.
+2. **Orchestrate explicit consultations.** Dispatch only the selected external participants (Antigravity, Codex, Grok, Ollama, Gemini — default: antigravity,codex) via a **single blocking foreground Bash call**, collect responses, and synthesize with provider, harness, requested model, independently observed served model (direct xAI API / Grok CLI only), and Cursor display label kept separate; a harness-echoed requested ID is selected-only and is never presented as the actual model.
 
-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.
+You run on Opus and have filesystem access. Never skip the independent research phase, but never count it as a third panel vote in exact two-model mode.
 
 ## Core Principles
 
-1. **Sequential phases, internal parallelism** — Phase 3B (Claude research) runs first, then Phase 3A (external dispatch) runs via a single blocking Bash call that parallelizes providers *internally* via `&` + `wait`. This is not a stylistic choice — sub-agents cannot own background processes that outlive their turn (see the "Critical: Sub-Agent Background Job Lifecycle" section below).
+1. **Sequential phases, internal parallelism** — Phase 3B (Claude research) runs first, then Phase 3A (external dispatch) runs via one blocking Bash call. Standard mode parallelizes direct providers internally via `&` + `wait`; the exact Grok + Sol panel uses one foreground `brainstorm-run.js` process that owns both concurrent Cursor/direct children. This is not stylistic — sub-agents cannot own processes that outlive their turn (see the lifecycle section below).
 2. **Blindness to external responses is load-bearing** — Phase 3B must complete *before* Phase 3A dispatches external providers, otherwise Claude will anchor on external findings and stop being an independent participant. The sequential ordering enforces this structurally.
 3. **Verified findings outrank inferred ones** — when Claude has Read the actual files and traced real code, those findings carry more weight than an external LLM pattern-matching from a topic description alone.
-4. **Preserve unique perspectives** — don't flatten differences; highlight where participants disagree.
-5. **Actionable synthesis** — the output should help the user make decisions, not just list opinions.
+4. **Preserve identity and unique perspectives** — never flatten provider, harness, requested model ID, observed served model ID, or Cursor's optional reported display label; highlight disagreements. Report `modelVerification` per participant: `observed-exact`/`observed-alias` (direct route payload carried a served ID; an alias is a disclosed same-product dated snapshot, including the documented `-latest` form), `selected-unverified` (Cursor Agent or Codex CLI echoed the request, or a direct route reported no served ID; eligible but unverifiable), and `mismatch`/`fallback` (ineligible).
+5. **Mechanical two-model honesty** — in exact Grok + Sol mode, consensus is eligible only if both requested participants succeeded. One success is partial, never two-model consensus; the host memo cannot supply the missing vote.
+6. **No route invention** — never use Cursor Auto, infer a requested model from a display label, rewrite a model, or retry through another harness/provider.
+7. **Actionable synthesis** — the output should help the user make decisions, not just list opinions.
 
 ## How to Operate
 
@@ -62,7 +64,8 @@ Understand what needs brainstorming:
 Intent:
 - User request:
 - Brainstorm mode:
-- Providers:
+- Participants: <provider via harness, exact requested model for each>
+- Explicitly excluded:
 
 Scope:
 - Changed/referenced files:
@@ -102,8 +105,8 @@ Your own deep research phase. Do NOT skip this. Do NOT delegate it to a sub-agen
 1. **Read the actual artifacts.** If the topic references specific files, skills, or code, Read them. Don't reason about what you assume they contain — verify. Use Glob and Grep to find supporting context.
 2. **Trace through the real behavior.** If the topic involves a pipeline, effect, state machine, or control flow, mentally execute the code with the repo's actual conventions in mind. Factor in framework-specific semantics (React Compiler, XState, RTK Query, etc.) that a generic reviewer might miss.
 3. **Use WebFetch/WebSearch when the topic references external docs.** If the topic mentions a library, framework, RFC, or public URL, fetch the current docs — don't rely on training data.
-4. **Form independent findings** structured identically to the external providers' output: numbered points, pros/cons, priorities.
-5. **Update the Context Brief.** Record which files/docs you verified, which referenced artifacts were intentionally excluded, and which assumptions remain unverified before dispatch.
+4. **Form independent findings** structured identically to external output: numbered points, pros/cons, priorities. In exact Grok + Sol mode label this a **non-voting verification memo**, not a participant answer.
+5. **Update the Context Brief.** Record verified files/docs, intentionally excluded artifacts, unverified assumptions, and every exact participant identity before dispatch. For exact mode, explicitly record Gemini and all unselected routes as excluded.
 6. **Record confidence per finding.** Mark each finding as:
    - **Verified** — backed by an actual file Read, code trace, or fetched document (highest confidence)
    - **Inferred** — reasoned from the topic description without direct verification (lower confidence)
@@ -118,9 +121,43 @@ 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
+- `grok` — bare Grok remains the compatible canonical-runner path with explicit `ASK_GROK_HARNESS` (`xai-api` default or `grok-cli`); routed Grok uses the exact selected harness/model and never falls back
 - `ollama` — Local Ollama (private, no data leaves machine) via the `ollama` CLI
 
+Participant specs use `provider@harness:exact-model-id`. The preferred Grok route is Cursor Agent. The supported exact architect panel is:
+
+- `grok@cursor-agent:cursor-grok-4.6-high`
+- `codex@cursor-agent:gpt-5.6-sol-high`
+
+Account catalogs can change; an unavailable exact ID is a clear failure, not permission to choose Auto or another ID. Grok Build remains explicit as `grok@grok-cli:grok-build` when the installed CLI supports the canonical contract. The exact panel contains no Gemini and must never launch a Gemini process/tool.
+
+A list that mixes routed specs with bare provider names (for example `grok@cursor-agent:cursor-grok-4.6-high,antigravity`) is unsupported: stop before Phase 3A, report `Mixed brainstorm participant lists are not supported: routed "<spec>" cannot be combined with bare "<provider>". Use either an all-bare provider list or the exact routed Grok + GPT-5.6 Sol panel. No participant was substituted, rerouted, or dispatched.`, and dispatch nothing. Never downgrade a routed spec to `grok-run.js`/`codex-run.js` or promote a bare name into a routed spec; `brainstorm-run.js` refuses such lists with the same error. Generalized mixed panels are deferred to a future ADR.
+
+**Exact Grok + GPT-5.6 Sol branch (preferred architect workflow):**
+
+Use this branch instead of the generic template whenever the selected providers are exactly Grok and Codex with explicit route specs. Validate both specs first, then make one foreground call:
+
+```bash
+set +e
+workdir=$(mktemp -d /tmp/brainstorm-XXXXXX)
+trap 'rm -rf "$workdir"' EXIT
+cat > "$workdir/prompt.md" <<'PROMPT_EOF'
+<INSERT THE PHASE 2 PROMPT HERE>
+PROMPT_EOF
+
+node "${CLAUDE_PLUGIN_ROOT}/dist/brainstorm-run.js" \
+  --participant 'grok@cursor-agent:cursor-grok-4.6-high' \
+  --participant 'codex@cursor-agent:gpt-5.6-sol-high' \
+  < "$workdir/prompt.md" > "$workdir/panel.json" 2> "$workdir/panel.err"
+rc_panel=$?
+echo "===== GROK + GPT-5.6 SOL PANEL (rc=$rc_panel) ====="
+cat "$workdir/panel.json"
+echo "===== PANEL STDERR ====="
+cat "$workdir/panel.err"
+```
+
+Substitute only user-supplied, grammar-validated exact specs. For the explicit Grok Build alternative, substitute only the Grok spec with `grok@grok-cli:grok-build`; do not change the Sol route. `brainstorm-run.js` starts both participants concurrently, preserves input order and identity, returns `complete | partial | failed`, and exits 2 for partial/failed participant execution. Parse its JSON even when rc=2. It does not know or support Gemini, and it does not pivot routes.
+
 **Required Bash tool call parameters:**
 - `timeout: 600000` — 10 minutes, the Bash tool maximum. The default 2 minutes will kill Codex at high reasoning effort mid-response, recreating the same silent-failure class this phase is designed to avoid.
 - Do NOT set `run_in_background: true`. This call MUST be foreground-blocking.
@@ -189,7 +226,7 @@ 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.
+# served-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=$!
 
@@ -236,7 +273,14 @@ cat "$workdir/ollama.err" 2>/dev/null
 
 ### Phase 4: Synthesis
 
-Now, and only now, parse the Phase 3A Bash output and combine it with your Phase 3B findings. Produce a structured synthesis.
+Now, and only now, parse the Phase 3A output and combine it with Phase 3B evidence. In exact Grok + Sol mode, first apply the runner's deterministic gate:
+
+- `complete` + `consensusEligible:true`: both exact participants answered; a point may be called two-model consensus only if both independently stated it. Carry each participant's `requestedModel`, `observedModel` (direct routes only), `reportedModel` (Cursor label), `modelVerification`, and `attributionNote` into the participant list verbatim.
+- `partial`: name the failed participant with provider/harness/requested model/error, attribute surviving insights only to the successful participant, and do not create a Consensus section claiming panel agreement.
+- `failed`: report both failures and provide no panel-derived synthesis.
+- The non-voting Claude evidence memo may verify, reject, or contextualize a claim, but cannot turn one external answer into two-model consensus.
+
+Then produce the structured synthesis.
 
 **Cross-check high-confidence external claims first.** Before promoting any external-provider finding to "Consensus," spot-check it against the source if it cites a specific file/line/symbol. External providers can return high-confidence claims that are factually wrong — for example, on 2026-04-17 Gemini returned two findings at 95/100 confidence that were contradicted by the actual `.d.ts` and an existing fallback path. A 30-second `Read` or `Grep` is the difference between recommending a real fix and recommending a non-fix. Mark each cross-checked finding as **Verified** (matches source), **Rejected** (false positive — exclude from synthesis), or **Unverifiable** (no source citation or external-only knowledge — present as-is with a note).
 
@@ -267,22 +311,21 @@ Surface this grade as the first line of the synthesis output (see Output Format
 **Synthesis confidence:** [PERFECT | VERIFIED | PARTIAL | FAILED] — [one-line reason citing what was/wasn't verified]
 
 ### Participants Consulted
-- ✅ Claude Opus: researched (verified against real files: path/to/a, path/to/b)
-- ✅ Gemini: responded
-- ✅ Codex: responded
-- ⏭️ Ollama: not available
+- ℹ️ Claude Opus: non-voting evidence verifier (exact two-model mode; verified against real files: path/to/a, path/to/b)
+- ✅ Grok via Cursor Agent — requested `cursor-grok-4.6-high` (selected-unverified: Cursor echoes the requested ID); reported display label `Cursor Grok 4.6` (label, not a catalog ID)
+- ✅ Codex via Cursor Agent — requested `gpt-5.6-sol-high` (selected-unverified); reported display label `GPT-5.6 Sol 1M High`
+- (direct route example) ✅ Grok via xAI API — requested `grok-4.6`; observed served `grok-4.6-<snapshot>` (observed-alias, disclosed same-product resolution)
+- 🚫 Gemini: explicitly excluded (not called)
 
-### Consensus (high confidence)
-1. [Point] — agreed by Claude (verified), Gemini, Codex
-2. [Point] — agreed by Gemini and Codex
+### Consensus (high confidence; omit for a partial exact panel)
+1. [Point] — independently agreed by <name both successful panel participants with provider/harness/model>
 
 ### Unique Insights
-- **Claude Opus** (verified): [Insight backed by actual file reads and why it matters]
-- **Gemini**: [Insight and why it matters]
-- **Codex**: [Insight and why it matters]
+- **<Provider via harness — exact model>**: [Insight and why it matters]
+- **Claude Opus evidence memo** (non-voting in exact mode): [Source-backed verification or rejection]
 
 ### Contradictions
-- [Topic]: Claude (verified against src/foo.ts) says X, Gemini (inferred) says Y. Assessment: Claude's view is more likely correct because [evidence].
+- [Topic]: <participant A identity> says X; <participant B identity> says Y. Evidence assessment: [verified source and conclusion].
 
 ### Recommendations
 1. [Highest priority action]
@@ -310,7 +353,9 @@ The only place background jobs persist across turns is the **main conversation c
 - **Never skip Phase 3B.** It's what makes you a participant instead of a relay. If you skip it, the user gets exactly the same result they'd get from calling the providers directly — the Opus budget is wasted.
 - **Phase 3B runs BEFORE Phase 3A.** The ordering is how blindness is enforced *and* how the sub-agent background-job lifecycle bug is avoided. Do not reorder.
 - **Phase 3A is a single foreground blocking Bash call** with `timeout: 600000` — see the "Critical: Sub-Agent Background Job Lifecycle" section. Violating this reintroduces issue #23 silently.
-- **Never fabricate a provider's response.** If a provider exits non-zero or produces empty output, report it honestly in the Participants Consulted section.
+- **Never fabricate a provider's response.** If a participant exits non-zero or produces empty output, report provider, harness, requested model, and error honestly.
+- **Never misstate partial consensus.** One successful member of a two-model panel is one perspective, even when Claude's evidence agrees.
+- **Never route implicitly.** Cursor Auto, display-label inference, model rewriting, and cross-harness/provider retries are forbidden.
 - **Don't bias the prompt toward any particular answer** — let participants form independent opinions.
 - **Verified findings outrank inferred ones in consensus scoring** — but external providers can still win when they catch domain patterns from their training data that aren't in the local repo.
 - **Keep the synthesis concise and actionable.** The user wants decisions, not essays.

package/dist/brainstorm-panel.d.ts

@@ -0,0 +1,46 @@
+export declare const BRAINSTORM_PANEL_PROVIDERS: readonly ["grok", "codex"];
+export type BrainstormPanelProvider = (typeof BRAINSTORM_PANEL_PROVIDERS)[number];
+export type BrainstormPanelHarness = "cursor-agent" | "grok-cli" | "xai-api" | "codex-cli";
+export declare const BARE_BRAINSTORM_PROVIDERS: readonly ["gemini", "codex", "grok", "ollama", "antigravity"];
+export type BareBrainstormProvider = (typeof BARE_BRAINSTORM_PROVIDERS)[number];
+export type BrainstormParticipantList = {
+    mode: "bare";
+    providers: BareBrainstormProvider[];
+} | {
+    mode: "exact";
+    participants: BrainstormParticipant[];
+};
+export type BrainstormModelVerification = "observed-exact" | "observed-alias" | "selected-unverified" | "mismatch" | "fallback";
+export interface BrainstormParticipant {
+    provider: BrainstormPanelProvider;
+    harness: BrainstormPanelHarness;
+    model: string;
+}
+export interface BrainstormParticipantResult extends BrainstormParticipant {
+    status: "fulfilled" | "rejected";
+    requestedModel: string;
+    observedModel?: string;
+    reportedModel?: string;
+    modelVerification?: BrainstormModelVerification;
+    attributionNote?: string;
+    response?: string;
+    error?: string;
+}
+export interface BrainstormPanelReport {
+    panel: "grok+gpt-5.6-sol";
+    status: "complete" | "partial" | "failed";
+    consensusEligible: boolean;
+    synthesisRule: string;
+    participants: BrainstormParticipantResult[];
+}
+export declare function parseBrainstormParticipant(spec: string): BrainstormParticipant;
+export declare function parseBrainstormParticipantList(specs: string[]): BrainstormParticipantList;
+export declare function validateBrainstormPanel(participants: BrainstormParticipant[]): void;
+export declare function isSameProductResolution(requested: string, observed: string): boolean;
+export declare function runBrainstormPanel(options: {
+    prompt: string;
+    participants: BrainstormParticipant[];
+    signal?: AbortSignal;
+    onProgress?: (message: string) => void;
+}): Promise<BrainstormPanelReport>;
+//# sourceMappingURL=brainstorm-panel.d.ts.map

package/dist/brainstorm-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brainstorm-panel.d.ts","sourceRoot":"","sources":["../src/brainstorm-panel.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B,YAAI,MAAM,EAAE,OAAO,CAAU,CAAC;AACrE,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAClF,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;AAC3F,eAAO,MAAM,yBAAyB,YAAI,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,CAAU,CAAC;AACvG,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhF,MAAM,MAAM,yBAAyB,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,sBAAsB,EAAE,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,qBAAqB,EAAE,CAAA;CAAE,CAAC;AAE7D,MAAM,MAAM,2BAA2B,GACnC,gBAAgB,GAChB,gBAAgB,GAChB,qBAAqB,GACrB,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,OAAO,EAAE,sBAAsB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,2BAA4B,SAAQ,qBAAqB;IACxE,MAAM,EAAE,WAAW,GAAG,UAAU,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,2BAA2B,CAAC;IAChD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC1C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,2BAA2B,EAAE,CAAC;CAC7C;AAYD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAqB9E;AAMD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,yBAAyB,CAoBzF;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,qBAAqB,EAAE,GAAG,IAAI,CA4BnF;AAID,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CASpF;AAuLD,wBAAsB,kBAAkB,CAAC,OAAO,EAAE;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,qBAAqB,EAAE,CAAC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAiBjC"}

package/dist/brainstorm-panel.js

@@ -0,0 +1,247 @@
+import { executeCodexCLI } from "@ask-llm/codex-mcp/executor";
+import { executeGrok } from "@ask-llm/grok-mcp/executor";
+import { executeCursorAgent } from "@ask-llm/mcp/cursor";
+export const BRAINSTORM_PANEL_PROVIDERS = ["grok", "codex"];
+export const BARE_BRAINSTORM_PROVIDERS = ["gemini", "codex", "grok", "ollama", "antigravity"];
+const SYNTHESIS_RULE = "Call a point two-model consensus only when both requested participants fulfilled successfully and independently stated it. On any participant failure, label the run partial and attribute surviving insights to that participant only.";
+function routeAllowed(participant) {
+    if (participant.provider === "grok") {
+        return ["cursor-agent", "grok-cli", "xai-api"].includes(participant.harness);
+    }
+    return ["cursor-agent", "codex-cli"].includes(participant.harness);
+}
+export function parseBrainstormParticipant(spec) {
+    const match = spec.match(/^(grok|codex)@(cursor-agent|grok-cli|xai-api|codex-cli):(.+)$/);
+    if (!match) {
+        throw new Error(`Invalid brainstorm participant "${spec}". Use provider@harness:exact-model-id (for example grok@cursor-agent:cursor-grok-4.6-high).`);
+    }
+    const participant = {
+        provider: match[1],
+        harness: match[2],
+        model: match[3].trim(),
+    };
+    if (!participant.model || participant.model.toLowerCase() === "auto") {
+        throw new Error(`Participant "${spec}" requires an exact non-Auto model ID from the selected harness catalog.`);
+    }
+    if (!routeAllowed(participant)) {
+        throw new Error(`Unsupported brainstorm route ${participant.provider}@${participant.harness}. Harness, provider, and model are not interchangeable; no substitute route was selected.`);
+    }
+    return participant;
+}
+function isBareProvider(spec) {
+    return BARE_BRAINSTORM_PROVIDERS.includes(spec);
+}
+export function parseBrainstormParticipantList(specs) {
+    const trimmed = specs.map((spec) => spec.trim()).filter(Boolean);
+    if (trimmed.length === 0)
+        throw new Error("The brainstorm participant list is empty.");
+    const bare = trimmed.filter((spec) => !spec.includes("@"));
+    const routed = trimmed.filter((spec) => spec.includes("@"));
+    if (bare.length > 0 && routed.length > 0) {
+        throw new Error(`Mixed brainstorm participant lists are not supported: routed ${routed.map((spec) => `"${spec}"`).join(", ")} cannot be combined with bare ${bare.map((spec) => `"${spec}"`).join(", ")}. Use either an all-bare provider list or the exact routed Grok + GPT-5.6 Sol panel. No participant was substituted, rerouted, or dispatched.`);
+    }
+    if (routed.length > 0) {
+        return { mode: "exact", participants: routed.map(parseBrainstormParticipant) };
+    }
+    const unknown = bare.find((spec) => !isBareProvider(spec));
+    if (unknown) {
+        throw new Error(`Unknown brainstorm provider "${unknown}". Supported bare providers: ${BARE_BRAINSTORM_PROVIDERS.join(", ")}; routed participants use provider@harness:exact-model-id. No substitute was selected.`);
+    }
+    return { mode: "bare", providers: bare.filter(isBareProvider) };
+}
+export function validateBrainstormPanel(participants) {
+    if (participants.length !== 2) {
+        throw new Error("The Grok + GPT-5.6 Sol panel requires exactly two participants.");
+    }
+    const providers = participants.map(({ provider }) => provider);
+    if (new Set(providers).size !== providers.length) {
+        throw new Error("The Grok + GPT-5.6 Sol panel requires one Grok participant and one Codex participant.");
+    }
+    for (const required of BRAINSTORM_PANEL_PROVIDERS) {
+        if (!providers.includes(required)) {
+            throw new Error(`The Grok + GPT-5.6 Sol panel is missing provider "${required}".`);
+        }
+    }
+    for (const participant of participants) {
+        if (!participant.model.trim() || participant.model.toLowerCase() === "auto") {
+            throw new Error(`${participant.provider}@${participant.harness} requires an exact non-Auto model ID.`);
+        }
+        if (!routeAllowed(participant)) {
+            throw new Error(`Unsupported brainstorm route ${participant.provider}@${participant.harness}. No provider or harness fallback was attempted.`);
+        }
+        if (participant.provider === "codex" && !participant.model.toLowerCase().includes("gpt-5.6-sol")) {
+            throw new Error(`The Codex participant must request an exact GPT-5.6 Sol model ID; received "${participant.model}". No model substitution was attempted.`);
+        }
+    }
+}
+const LATEST_ALIAS_SUFFIX = "-latest";
+export function isSameProductResolution(requested, observed) {
+    const requestedId = requested.trim().toLowerCase();
+    const observedId = observed.trim().toLowerCase();
+    if (requestedId === observedId)
+        return true;
+    const productId = requestedId.endsWith(LATEST_ALIAS_SUFFIX)
+        ? requestedId.slice(0, -LATEST_ALIAS_SUFFIX.length)
+        : requestedId;
+    if (!productId || !observedId.startsWith(`${productId}-`))
+        return false;
+    return /^[0-9][0-9.-]*$/.test(observedId.slice(productId.length + 1));
+}
+function classifyObservedModel(participant, observedModel) {
+    const identity = `${participant.provider} via ${participant.harness}`;
+    if (observedModel.trim().toLowerCase() === participant.model.trim().toLowerCase()) {
+        return {
+            modelVerification: "observed-exact",
+            attributionNote: `${identity} reported served model "${observedModel}", matching the requested ID.`,
+        };
+    }
+    if (isSameProductResolution(participant.model, observedModel)) {
+        return {
+            modelVerification: "observed-alias",
+            attributionNote: `${identity} served "${observedModel}" for requested "${participant.model}" (disclosed provider-side alias/snapshot resolution of the same model; the requested ID was sent unchanged and was not rewritten).`,
+        };
+    }
+    throw new Error(`${identity} requested exact model "${participant.model}" but reported "${observedModel}". The response is excluded from two-model consensus; no additional route was attempted.`);
+}
+function selectedOnlyNote(participant, detail) {
+    return `${participant.provider} via ${participant.harness} ran the requested ID "${participant.model}" (${detail}); the harness does not independently confirm the served catalog model, so this attribution is selected-only and unverifiable, not an observed actual model.`;
+}
+async function invokeParticipant(participant, prompt, signal, onProgress) {
+    const identity = `${participant.provider} via ${participant.harness} (${participant.model})`;
+    const progress = onProgress ? (message) => onProgress(`[${identity}] ${message}`) : undefined;
+    const base = { ...participant, requestedModel: participant.model };
+    let observedModel;
+    let reportedModel;
+    let modelVerification;
+    try {
+        if (participant.harness === "cursor-agent") {
+            const result = await executeCursorAgent({
+                provider: participant.provider,
+                model: participant.model,
+                prompt,
+                signal,
+                onProgress: progress,
+            });
+            reportedModel = result.reportedModel;
+            if (result.usage.fellBack) {
+                modelVerification = "fallback";
+                throw new Error(`Cursor Agent reported a model fallback for requested "${participant.model}". The response is excluded from two-model consensus.`);
+            }
+            if (result.model !== participant.model) {
+                modelVerification = "mismatch";
+                throw new Error(`Cursor Agent ran "${result.model}" instead of requested "${participant.model}". The response is excluded from two-model consensus; no additional route was attempted.`);
+            }
+            modelVerification = "selected-unverified";
+            return {
+                ...base,
+                reportedModel,
+                modelVerification,
+                attributionNote: selectedOnlyNote(participant, reportedModel
+                    ? `Cursor echoed the requested ID and reported display label "${reportedModel}", which is a label and not a catalog ID`
+                    : "Cursor echoed the requested ID and reported no display label"),
+                response: result.response,
+                status: "fulfilled",
+            };
+        }
+        if (participant.provider === "grok") {
+            if (participant.harness !== "grok-cli" && participant.harness !== "xai-api") {
+                throw new Error(`Unsupported brainstorm route ${participant.provider}@${participant.harness}. No fallback was attempted.`);
+            }
+            const result = await executeGrok({
+                prompt,
+                model: participant.model,
+                harness: participant.harness,
+                reasoningEffort: "high",
+                signal,
+                onProgress: progress,
+            });
+            if (result.usage?.fellBack) {
+                modelVerification = "fallback";
+                throw new Error(`${participant.harness} reported a model fallback for requested "${participant.model}". The response is excluded from two-model consensus.`);
+            }
+            if (!result.reportedModel) {
+                if (result.model !== participant.model) {
+                    modelVerification = "mismatch";
+                    throw new Error(`${participant.provider} via ${participant.harness} ran "${result.model}" instead of requested "${participant.model}". The response is excluded from two-model consensus; no additional route was attempted.`);
+                }
+                modelVerification = "selected-unverified";
+                return {
+                    ...base,
+                    modelVerification,
+                    attributionNote: selectedOnlyNote(participant, `${participant.harness} reported no served model ID, so only the requested ID is known`),
+                    response: result.response,
+                    status: "fulfilled",
+                };
+            }
+            observedModel = result.reportedModel;
+            let observed;
+            try {
+                observed = classifyObservedModel(participant, observedModel);
+            }
+            catch (error) {
+                modelVerification = "mismatch";
+                throw error;
+            }
+            modelVerification = observed.modelVerification;
+            return {
+                ...base,
+                observedModel,
+                modelVerification,
+                attributionNote: observed.attributionNote,
+                response: result.response,
+                status: "fulfilled",
+            };
+        }
+        const result = await executeCodexCLI({
+            prompt,
+            model: participant.model,
+            reasoningEffort: "high",
+            sandbox: "read-only",
+            signal,
+            onProgress: progress,
+        });
+        if (result.usage?.fellBack) {
+            modelVerification = "fallback";
+            throw new Error(`Codex CLI reported a model fallback to "${result.usage.model}" for requested "${participant.model}". The response is excluded from two-model consensus.`);
+        }
+        if (result.usage && result.usage.model !== participant.model) {
+            modelVerification = "mismatch";
+            throw new Error(`Codex CLI ran "${result.usage.model}" instead of requested "${participant.model}". The response is excluded from two-model consensus; no additional route was attempted.`);
+        }
+        modelVerification = "selected-unverified";
+        return {
+            ...base,
+            modelVerification,
+            attributionNote: selectedOnlyNote(participant, result.usage
+                ? "Codex CLI echoed the requested ID with no fallback"
+                : "served from the Codex response cache keyed by the requested ID, which stores only no-fallback responses"),
+            response: result.response,
+            status: "fulfilled",
+        };
+    }
+    catch (error) {
+        return {
+            ...base,
+            observedModel,
+            reportedModel,
+            modelVerification,
+            status: "rejected",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function runBrainstormPanel(options) {
+    if (!options.prompt.trim())
+        throw new Error("The brainstorm panel requires a non-empty prompt.");
+    validateBrainstormPanel(options.participants);
+    const participants = await Promise.all(options.participants.map((participant) => invokeParticipant(participant, options.prompt, options.signal, options.onProgress)));
+    const successCount = participants.filter(({ status }) => status === "fulfilled").length;
+    return {
+        panel: "grok+gpt-5.6-sol",
+        status: successCount === 2 ? "complete" : successCount === 1 ? "partial" : "failed",
+        consensusEligible: successCount === 2,
+        synthesisRule: SYNTHESIS_RULE,
+        participants,
+    };
+}
+//# sourceMappingURL=brainstorm-panel.js.map

package/dist/brainstorm-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brainstorm-panel.js","sourceRoot":"","sources":["../src/brainstorm-panel.ts"],"names":[],"mappings":"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"}

package/dist/brainstorm-run.d.ts

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

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

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

package/dist/brainstorm-run.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { parseBrainstormParticipantList, runBrainstormPanel } from "./brainstorm-panel.js";
+function parseArgs(argv) {
+    const participants = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--participant") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("--participant requires provider@harness:exact-model-id");
+            participants.push(value);
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument "${arg}". Only repeated --participant arguments are supported.`);
+    }
+    return participants;
+}
+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();
+}
+async function main() {
+    try {
+        const specs = parseArgs(process.argv.slice(2));
+        const list = parseBrainstormParticipantList(specs);
+        if (list.mode !== "exact") {
+            throw new Error(`ask-brainstorm-run executes only the exact routed Grok + GPT-5.6 Sol panel; bare providers (${list.providers.join(", ")}) use the standard coordinator dispatch. No participant was dispatched.`);
+        }
+        const prompt = await readStdin();
+        const report = await runBrainstormPanel({
+            prompt,
+            participants: list.participants,
+            onProgress: (message) => console.error(message),
+        });
+        console.log(JSON.stringify(report, null, 2));
+        if (report.status !== "complete")
+            process.exitCode = 2;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`ask-brainstorm-run failed: ${message}`);
+        process.exitCode = 1;
+    }
+}
+main();
+//# sourceMappingURL=brainstorm-run.js.map

package/dist/brainstorm-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brainstorm-run.js","sourceRoot":"","sources":["../src/brainstorm-run.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,8BAA8B,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3F,SAAS,SAAS,CAAC,IAAc;IAC/B,MAAM,YAAY,GAAa,EAAE,CAAC;IAClC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,GAAG,KAAK,eAAe,EAAE,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,KAAK;gBAAE,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;YACtF,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,KAAK,IAAI,CAAC,CAAC;YACX,SAAS;QACX,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,qBAAqB,GAAG,yDAAyD,CAAC,CAAC;IACrG,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,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;AAC1C,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,8BAA8B,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,+FAA+F,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,yEAAyE,CAClM,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC;YACtC,MAAM;YACN,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;SAChD,CAAC,CAAC;QACH,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC7C,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;YAAE,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACzD,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,8BAA8B,OAAO,EAAE,CAAC,CAAC;QACvD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC"}

package/mcp.json

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

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ask-llm/plugin",
-  "version": "0.14.0",
-  "description": "Ask LLM review, comparison, brainstorming, image, verification, and pairing workflows for Claude Code and Pi",
+  "version": "0.15.0",
+  "description": "Ask LLM review, comparison, brainstorming, image, verification, and pairing workflows for Claude Code, Cursor Agent, and Pi",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
     "ask-antigravity-run": "dist/antigravity-run.js",
+    "ask-brainstorm-run": "dist/brainstorm-run.js",
     "ask-codex-run": "dist/codex-run.js",
     "ask-gemini-run": "dist/run.js",
     "ask-grok-run": "dist/grok-run.js",
@@ -43,7 +44,9 @@
   "homepage": "https://github.com/Lykhoyda/ask-llm#readme",
   "files": [
     ".claude-plugin/",
+    ".cursor-plugin/",
     ".mcp.json",
+    "mcp.json",
     "agents/",
     "codex-pair-defaults.json",
     "dist/",
@@ -83,8 +86,8 @@
     "@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/grok-mcp": "^0.1.2",
+    "@ask-llm/mcp": "^0.8.0",
     "@ask-llm/ollama-mcp": "^0.5.7"
   },
   "peerDependencies": {

package/pi/extensions/provider-tools.ts

@@ -87,6 +87,10 @@ const cursorAgentSchema = Type.Object({
     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.",
   }),
+  includeDirs: Type.Optional(relativeDirs),
+  sessionId: Type.Optional(
+    Type.String({ description: "Prior Cursor conversation ID to resume; omit first, then reuse the returned ID." }),
+  ),
 });
 
 const askMultiSchema = Type.Object({
@@ -239,6 +243,8 @@ export function registerProviderTools(pi: ExtensionAPI): void {
         prompt: params.prompt,
         provider: params.provider,
         model: params.model,
+        includeDirs: params.includeDirs,
+        sessionId: params.sessionId,
         signal,
         onProgress: progressForwarder(onUpdate, params.provider),
       });
@@ -250,6 +256,7 @@ export function registerProviderTools(pi: ExtensionAPI): void {
           harness: result.harness,
           model: result.model,
           reportedModel: result.reportedModel,
+          sessionId: result.sessionId,
           askLlmUsage: result.usage,
           outputTruncated: text.truncated,
         },

package/skills/brainstorm/SKILL.md

@@ -1,63 +1,89 @@
 ---
 name: brainstorm
-description: Send a topic to multiple LLM providers concurrently after the current host model forms an independent view, then synthesize all findings. Usage /brainstorm [providers] <topic>. External providers default to antigravity,codex. Example /brainstorm antigravity,codex,ollama "review this architecture"
+description: Send a topic to an explicit multi-model panel, then synthesize findings with truthful provider, harness, and model attribution. Usage /brainstorm [participants] <topic>. Defaults to antigravity,codex. Preferred Grok route uses Cursor Agent with an exact catalog ID.
 ---
 
 <!-- PORTABLE-CONTRACT:START -->
 ## Portable contract
 
-The current host model must form and record an independent analysis before seeing external answers. Then send the same bounded topic and Context Brief concurrently to the selected providers, cross-check claims against source where possible, and synthesize consensus, unique insights, contradictions, rejected false positives, and confidence. Report the actual host model/providers and disclose possible same-family overlap.
+For the standard workflow, the current host model records an independent analysis before seeing external answers, then sends the same bounded topic and Context Brief concurrently to the selected providers. For the exact Grok + GPT-5.6 Sol workflow, the host is a non-voting evidence verifier/synthesizer: the brainstorming panel has exactly those two requested participants. Cross-check source where possible and synthesize consensus, unique insights, contradictions, rejected false positives, failures, and confidence. Keep provider, harness, requested model ID, independently observed served model ID, and Cursor's reported display label separate. Only direct xAI API / Grok CLI routes can report a served ID, and only when the provider/CLI payload actually carries one; a disclosed same-product alias/snapshot resolution (for example `grok-4.6` or `grok-4-latest` served as a dated `grok-4-<snapshot>`) stays eligible, while a different model is a mismatch and ineligible. A direct route whose payload omits the model stays selected-only. Cursor Agent and Codex CLI echo the requested ID, so that attribution is selected-only and unverifiable—never call a requested or selected ID the actual model. Never select Cursor Auto, infer a requested ID from a display label, silently change a model, or pivot to another harness/provider.
 <!-- PORTABLE-CONTRACT:END -->
 
 ## Host adapters
 
 ### Pi adapter
 
-The current Pi host model completes its independent view first, records its actual provider/model, and only then calls native `ask-multi`. Do not claim the host is Claude Opus or that the coordinator has an isolated context.
+The current Pi host model completes its independent evidence memo first. Standard provider lists use native `ask-multi`. A routed participant uses the matching native tool instead: `provider@cursor-agent:model` calls `ask-cursor-agent` with separate `provider` and exact `model`; direct Grok calls `ask-grok` with the explicit `harness` and exact model. A participant list mixing routed `provider@harness:exact-model-id` entries with bare provider names is refused before any tool call; nothing is dispatched or substituted. For the exact Grok + Sol panel, issue only these two consultations (concurrently when the host supports it):
+
+- `ask-cursor-agent({ provider: "grok", model: "cursor-grok-4.6-high", prompt })`
+- `ask-cursor-agent({ provider: "codex", model: "gpt-5.6-sol-high", prompt })`
+
+Do not call `ask-multi` for that panel because it cannot express Cursor harness identity, and do not call Gemini. Treat the host memo as non-voting verification evidence, not a third panel answer. If either participant fails, label the run partial and do not claim two-model consensus.
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:START -->
 ### Claude Code adapter
 
 The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP, hook, `CLAUDE_PLUGIN_ROOT`, and `AskUserQuestion` mechanics apply only on Claude Code; they do not override the Pi adapter above.
 
-
-
 # Multi-LLM Brainstorm
 
-Consult multiple external LLM providers simultaneously on a topic while Claude Opus performs its own independent research in parallel, then synthesize the findings from all participants.
+Consult an explicitly selected panel on a topic, then synthesize the responses against source-grounded host research.
 
 ## Instructions
 
-### Phase 1: Parse arguments
+### Phase 1: Parse arguments and freeze participant identity
+
+- The first argument may be a comma-separated participant list.
+- Compatible bare provider names remain supported: `gemini`, `codex`, `grok`, `ollama`, `antigravity`. If omitted, default to `antigravity,codex`.
+- Bare `grok` retains the existing direct canonical runner and its explicit `ASK_GROK_HARNESS` selection (`xai-api` default or `grok-cli`) for compatibility. That direct route never falls back.
+- Preferred explicit syntax is `provider@harness:exact-model-id`. Supported routed participants are:
+  - `grok@cursor-agent:<exact ID from agent --list-models>` (preferred Grok route)
+  - `codex@cursor-agent:<exact GPT-5.6 Sol ID from agent --list-models>`
+  - `grok@grok-cli:<exact ID from grok models>` (explicit Grok Build alternative)
+  - `grok@xai-api:<exact ID from GET /v1/models>`
+  - `codex@codex-cli:gpt-5.6-sol` (explicit direct Codex alternative; any reported fallback makes the exact panel partial)
+- Never accept `Auto`, map a display label to an ID, or substitute a route. A missing registration/harness, unavailable model, auth failure, or unsupported provider/harness pair is a participant failure with its actionable error preserved.
+- A participant list must be either all bare provider names or all routed `provider@harness:exact-model-id` specs. A mixed list (for example `grok@cursor-agent:cursor-grok-4.6-high,antigravity`) is refused before any dispatch with the "Mixed brainstorm participant lists are not supported" error; no participant is rerouted to a bare runner, substituted, or dispatched. Generalized mixed panels are deferred to a future ADR.
+- Everything after the participant list is the topic.
+- In standard mode, Claude Opus remains a participant. In the exact Grok + Sol mode below, Claude is only the non-voting evidence verifier/synthesizer so the panel has exactly two participants.
+
+**Architect workflow — exactly Grok + GPT-5.6 Sol, no Gemini:**
+
+```text
+/brainstorm grok@cursor-agent:cursor-grok-4.6-high,codex@cursor-agent:gpt-5.6-sol-high "review this architecture"
+```
+
+These IDs are exact catalog examples verified for this workflow; account catalogs can change, so use `agent --list-models` and replace an unavailable ID explicitly. The coordinator must not call Gemini, the direct Grok runner, xAI API, Grok Build, or Codex CLI for this invocation.
+
+**Explicit Grok Build alternative (still no Gemini):**
 
-- 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`, `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
+```text
+/brainstorm grok@grok-cli:grok-build,codex@cursor-agent:gpt-5.6-sol-high "review this architecture"
+```
+
+This route is valid only when the installed Grok Build contract supports Ask LLM's headless JSON/read-only flags. Failure is terminal for the Grok participant; do not pivot to Cursor or xAI.
 
 ### Phase 2: Determine and prepare the brainstorm topic
 
-- If the user provided a topic directly, use it
-- If the context is about code changes, gather the relevant diff:
-  - `git status --short` first to see what's modified/added/deleted
-  - `git add -N <new-files>` for untracked files the user wants included
-  - `git diff` + `git diff --cached` combined
-  - **Filter noise**: exclude `:!docs/` `:!apps/docs/` `:!*.md` `:!yarn.lock` `:!*.lock` `:!*.png` from the pathspec — providers don't need to review your ADR/doc additions
-  - **Size-check**: if combined diff > 150KB, ask the user before sending (the providers will take 5–15 min on payloads that large)
-- If the context is a design/plan, gather the relevant documentation or conversation context
-- If no topic is clear, ask the user what they'd like to brainstorm about
-- Create a compact **Context Brief** before launching the coordinator. Keep it tiny for simple topics; add detail when the request is architecture/design/security/concurrency/migration related, spans packages, references external specs, or depends on conversation context external providers cannot see.
+- If the user provided a topic directly, use it.
+- For code changes, gather relevant context:
+  - Run `git status --short` first.
+  - Use `git add -N <new-files>` for untracked files the user wants included.
+  - Combine `git diff` and `git diff --cached`.
+  - Exclude noise with `:!docs/` `:!apps/docs/` `:!*.md` `:!yarn.lock` `:!*.lock` `:!*.png`.
+  - If the combined diff exceeds 150KB, ask before sending.
+- For a design/plan, gather relevant documentation and conversation context.
+- If no topic is clear, ask what to brainstorm.
+- Create a compact **Context Brief**. It must list the exact requested participant identities, not just display names:
 
 ```markdown
 ## Context Brief
 
 Intent:
 - User request:
-- Brainstorm mode:
-- Providers: <list the selected providers for this run>
+- Brainstorm mode: <standard | exact-grok-sol>
+- Participants: <provider via harness, exact requested model for each>
+- Explicitly excluded: <for exact-grok-sol: Gemini and every unselected route>
 
 Scope:
 - Changed/referenced files:
@@ -83,24 +109,21 @@ Open questions:
 
 ### Phase 3: Launch the brainstorm-coordinator agent
 
-Launch with: the topic, the selected external providers list, the Context Brief, and any gathered context (diff/files/docs).
+Pass the topic, exact participant specs, Context Brief, and gathered context. The coordinator:
 
-The coordinator handles:
-- Phase 3B: its own Claude Opus research (reads actual files, traces code, uses WebFetch/WebSearch on referenced external docs) — runs FIRST so Claude doesn't anchor on external responses
-- Context Brief update: after Phase 3B, records verified files/docs and unverified assumptions before external dispatch
-- Phase 3A: external provider dispatch via a single blocking foreground Bash call (ADR-050 dispatch pattern)
-- Phase 4: synthesis — consensus, unique insights, contradictions across all participants
-- Verified findings (backed by Claude's file reads) are weighted higher than inferred ones
-- Failed providers are surfaced inline with their stderr, not silently dropped
+- researches independently before dispatch and records any unverified assumptions;
+- treats that research as non-voting verification evidence in exact two-model mode;
+- uses the packaged `dist/brainstorm-run.js` for the exact Grok + Sol panel so both requests start concurrently within one blocking foreground process;
+- uses only the selected routes and exact IDs;
+- surfaces every failure and preserves provider/harness/model attribution; and
+- synthesizes only after dispatch completes.
 
-### Phase 4: Present the coordinator's synthesis
+### Phase 4: Present synthesis truthfully
 
-Pass through the coordinator's structured output. If the coordinator returned a partial result (some providers failed), present what landed and explicitly note what's missing — don't paraphrase or hide compromises.
+Pass through the coordinator's structured output. Attribute each participant by provider, harness, and requested ID; add the observed served ID only for direct xAI API / Grok CLI routes (noting a disclosed alias/snapshot), and describe Cursor and Codex CLI attributions as selected-only and unverifiable with any Cursor display label shown as a label, not a catalog ID. A two-model consensus exists only when both requested participants succeeded and independently support the point. If one fails, label the run **partial**, attribute surviving insights to the model that produced them, and never describe them as consensus. If both fail, report failure and provide no panel synthesis. The host's verification memo may verify or reject claims, but it cannot turn one participant's answer into two-model agreement.
 
 ## Important — verification matters
 
-Confidence scores are not an oracle. The coordinator's Phase 3B exists specifically because external LLMs can return high-confidence findings that turn out to be factually wrong (a real example from 2026-04-17: Gemini returned 95/100-confidence claims that were contradicted by the actual `.d.ts` file). Claude's "Verified" findings carry more weight than external "Inferred" findings precisely for this reason.
-
-If you want a code-review-specific version of this with explicit per-finding source verification, use `/multi-review` instead.
+Confidence scores are not an oracle. External LLMs can return high-confidence claims contradicted by source. Verified findings carry more weight than inferred findings, while participant counts and consensus eligibility remain mechanical and cannot be upgraded by confidence. For code-review-specific per-finding verification, use `/multi-review`.
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/codex-pair/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: codex-pair
-description: Show codex-pair status and set up the per-edit Codex review hook for this project. Detects whether codex-pair is active, paused, or not yet configured. On first run (no marker), offers interactive setup with auto-detected project context. On subsequent runs, shows current state, recent review activity, and toggle instructions. The per-edit hook itself runs automatically; this command is the human-facing dashboard for it.
+description: Pair with Codex using the host's supported lifecycle. On Claude Code and Pi, manages the proven opt-in per-edit review flow; on Cursor Agent, runs an explicit consent-gated iterative reviewer session through an exact ask-codex leaf or fully pinned unified ask-llm without assuming Claude hooks or namespaces.
 ---
 
 <!-- PORTABLE-CONTRACT:START -->
 ## Portable contract
 
-Set up and report status for recall-first per-edit Codex review. The repository marker carries review context but is not, by itself, authorization on Pi. Preserve bounded file context, debounce, pause/resume, acknowledgement, deduplication, failure disclosure, and explicit host lifecycle limitations.
+Use Codex as an explicit read-only reviewer while the host remains the editor. Apply `../pairing-contract.md`. Where the host supports the established per-edit integration, set up and report its status: the repository marker carries review context but is not, by itself, authorization on Pi. Preserve bounded file context, include-directory handling, reasoning effort, session continuity where supported, consent, cancellation, actionable relay, failure disclosure, and explicit host lifecycle limitations.
 <!-- PORTABLE-CONTRACT:END -->
 
 ## Host adapters
@@ -15,6 +15,48 @@ Set up and report status for recall-first per-edit Codex review. The repository
 
 Pi requires project trust, this repository marker, and explicit user-owned allowlist consent through `/codex-pair`. Pairing is asynchronous in TUI/RPC/long-lived JSON modes, uses `tool_result`, and surfaces findings non-blockingly. One-shot print mode, blocking Stop-gate parity, and nested Fable execution are unsupported.
 
+### Cursor Agent adapter
+
+Cursor discovers this `SKILL.md` through its supported Agent Skills surface; `/codex-pair` attaches it as an explicit command. Do **not** use Claude Code's `PostToolUse`, `Stop`, `SessionStart`, `SessionEnd`, `CLAUDE_PLUGIN_ROOT`, `AskUserQuestion`, or plugin tool namespaces. This adapter is an on-demand iterative pairing session, not a claim that Claude hooks were registered in Cursor.
+
+1. Read `../pairing-contract.md`. The Cursor plugin bundle registers only the unified `ask-llm` server; if the user separately installed `@ask-llm/codex-mcp`, prefer that deterministic `ask-codex` leaf. Resolve an exposed MCP tool whose exact leaf is `ask-codex`; do not assume its server prefix. When only the unified `ask-llm` leaf is registered, it may serve as the transport with `provider: "codex"` and every option (model, reasoning effort, include directories, session) pinned explicitly; its schema rejects unsupported combinations instead of stripping them and Codex runs read-only by default. Never make an unpinned generic call. If neither tool is exposed, stop with the recommended user-installed unified server:
+   ```json
+   {"mcpServers":{"ask-llm":{"command":"npx","args":["-y","@ask-llm/mcp"]}}}
+   ```
+   Save that as project `.cursor/mcp.json` or user `~/.cursor/mcp.json`, ensure `codex` is authenticated, reload the server from Cursor Settings → Tools & MCP or restart Cursor Agent, and invoke `/codex-pair` again. A split `codex` entry using `@ask-llm/codex-mcp` is an explicit user-installed alternative when only the `ask-codex` leaf is desired; keep one registration per server (the plugin already provides `ask-llm`, so do not add a second `ask-llm` entry merely to duplicate it).
+2. Require both `model=<exact ID>` and `effort=low|medium|high|xhigh|max`; parse optional `include=dir1,dir2`. If model or effort is omitted, ask the user to choose it and stop before reading extra context, requesting consent, or calling a provider. Do not infer either value from the Cursor host environment: the MCP server may resolve different `ASK_CODEX_MODEL` or `ASK_CODEX_REASONING_EFFORT` values. Reject absolute, `..`, and `~` include paths; cap at 32. Build a bounded context manifest (20 KB/file, 100 KB/request) from task requirements, relevant project instructions, changed files, and tests. Do not send secrets or unrelated files.
+3. Before the first provider call, show host=`Cursor Agent`, reviewer provider=`codex`, selected transport=`ask-codex` or unified `ask-llm`, exact user-supplied model, exact user-supplied reasoning effort, include directories, read-only behavior, data/quota boundary, and fresh persisted-session intent. Ask for explicit confirmation using Cursor's normal conversational approval surface. Refusal ends `cancelled` with no provider call.
+4. First call exactly one of these protocol shapes, substituting the already disclosed explicit choices:
+   ```json
+   [
+     {
+       "tool": "ask-codex",
+       "arguments": {
+         "prompt": "<bounded reviewer prompt>",
+         "model": "<required exact ID>",
+         "reasoningEffort": "<required effort>",
+         "includeDirs": ["<validated relative directory>"],
+         "sessionId": "",
+         "sandbox": "read-only"
+       }
+     },
+     {
+       "tool": "ask-llm",
+       "arguments": {
+         "provider": "codex",
+         "prompt": "<bounded reviewer prompt>",
+         "model": "<required exact ID>",
+         "reasoningEffort": "<required effort>",
+         "includeDirs": ["<validated relative directory>"],
+         "sessionId": ""
+       }
+     }
+   ]
+   ```
+   The prompt assigns Codex the independent reviewer role and requests actionable severity/file/line evidence. Capture the returned structured `sessionId`/Thread ID and actual model. Relay feedback before changing code; verify every finding against source and label it accepted, rejected, or deferred.
+5. At meaningful checkpoints, call the same tool with the captured `sessionId`, same model/effort, and bounded delta. On `ask-codex`, keep `sandbox: "read-only"`; unified `ask-llm` has no sandbox input and is read-only by default, so do not send an unsupported sandbox field. Omit `includeDirs` on resumed calls because `codex exec resume` does not support them (every Codex transport — split `ask-codex`, unified `ask-llm`, and Pi — rejects that combination at the shared executor instead of dropping the directories); never silently strip them from the first call. If no session ID was returned, stop with a session diagnostic instead of pretending continuity.
+6. A Cursor interrupt cancels the MCP request. Report `cancelled` and never retry another tool/model/provider. Preserve earlier feedback on later failure and report `failed (partial)`. On success report `completed` with host, provider, requested/actual model, effort, session reuse count, context/include directories, accepted/rejected/deferred actions, and any reported Codex quota fallback. Never conceal fallback or rewrite a model.
+
 <!-- HOST-ADAPTER:CLAUDE-CODE:START -->
 ### Claude Code adapter
 

package/skills/grok-pair/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: grok-pair
+description: Pair with Grok as an explicit independent reviewer while the host edits. Use when the user asks for /grok-pair, Grok pair programming, iterative Grok feedback, or Grok through Cursor Agent. Selects one exact route/model with consent and never falls back.
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Apply `../pairing-contract.md`. The host is the editor and Grok is the explicit read-only reviewer. Share bounded context only after consent, relay and verify actionable feedback at checkpoints, preserve exact route/model attribution, reuse a returned Cursor session where supported, propagate cancellation, and terminate clearly without silent provider, harness, or model fallback.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Cursor Agent adapter
+
+When Cursor itself hosts this skill, do not recursively launch `ask-cursor-agent`. Offer only the explicit direct routes (`xai-api` or `grok-cli`) through an exact `ask-grok` leaf or a fully pinned unified `ask-llm` leaf, and follow the same consent and no-fallback contract. The Cursor plugin bundle registers only the unified `ask-llm` server; a separately user-installed `grok` entry (`@ask-llm/grok-mcp`) exposes the deterministic `ask-grok` leaf and is preferred when exposed. A unified call must specify `provider: "grok"`, exact `harness`, exact `model`, and `reasoningEffort`; direct Grok is one-shot and does not accept include directories or sessions.
+
+If neither leaf is exposed, stop and give this Cursor-native setup (never `claude mcp add`):
+
+```json
+{"mcpServers":{"ask-llm":{"command":"npx","args":["-y","@ask-llm/mcp"]}}}
+```
+
+Save it as project `.cursor/mcp.json` or user `~/.cursor/mcp.json`. For `xai-api`, ensure `XAI_API_KEY` is present in the MCP server process environment; keep any literal secret in the user-level config and never commit it. For `grok-cli`, install/authenticate Grok Build and verify `grok --help` advertises headless JSON support. Reload the server from **Cursor Settings → Tools & MCP** or restart Cursor Agent, verify that `ask-llm` is exposed, then invoke `/grok-pair` again. The split alternative is the same entry named `grok` with package `@ask-llm/grok-mcp`, which exposes `ask-grok`; keep one registration per server and do not configure both merely to create fallback.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+# `/grok-pair`
+
+Run an iterative pair-programming session in which Claude remains the sole editor and Grok is the independent reviewer.
+
+## 1. Parse and lock the route
+
+Accept optional command text in this form (ask for any missing choice):
+
+```text
+/grok-pair route=cursor-agent model=cursor-grok-4.6-high include=packages/api,packages/shared <task>
+/grok-pair route=xai-api model=grok-4.6 effort=xhigh <task>
+/grok-pair route=grok-cli model=grok-build effort=high <task>
+```
+
+Supported routes:
+
+1. `cursor-agent` — preferred **only when** an `ask-cursor-agent` MCP tool is actually exposed and the user supplies an exact Grok-family ID from `agent --list-models`. Use `provider: "grok"`; never use Auto. Reasoning effort remains part of the exact Cursor catalog ID, not a separate generic option.
+2. `xai-api` — call `ask-grok` with `harness: "xai-api"`, exact model, and explicit `reasoningEffort`. Requires `XAI_API_KEY`; metered xAI API pricing is separate from consumer subscriptions.
+3. `grok-cli` — call `ask-grok` with `harness: "grok-cli"`, an exact ID from `grok models`, and explicit `reasoningEffort`. Uses the authenticated official Grok Build plan.
+
+Inspect the current tool surface by leaf capability. The Claude plugin bundles only Codex; Cursor and Grok tools come from user-scoped registrations such as `mcp__ask-llm__ask-cursor-agent`, `mcp__ask-llm__ask-llm`, or `mcp__grok__ask-grok`, so match on the `__ask-cursor-agent`, `__ask-grok`, or `__ask-llm` leaf and never on one assumed prefix. When no `ask-grok` leaf exists but the unified `ask-llm` leaf does, a direct route may use `ask-llm({ provider: "grok", harness, model, reasoningEffort, prompt })` only with every one of those fields pinned explicitly; the unified schema rejects unsupported combinations instead of stripping them. An unpinned generic call or a raw CLI never replaces a missing selected tool.
+
+If both Cursor and direct tools exist and no route was given, recommend Cursor Agent and show the direct alternatives, then use `AskUserQuestion` to obtain an explicit selection. Once selected, route/model/effort are immutable. A failure is terminal for that route.
+
+## 2. Bound context and obtain consent
+
+Read `../pairing-contract.md`. Determine the task, changed files, project instructions, tests, and requested relative include directories. Reject absolute, `..`, and `~` paths and cap the list at 32. Prepare a context manifest before reading extra directories:
+
+```text
+Host: Claude Code
+Reviewer provider: grok
+Harness: cursor-agent | xai-api | grok-cli
+Requested model: <exact ID>
+Reported model: pending
+Reasoning: <exact Cursor model ID carries tier | low|medium|high|xhigh>
+Shared context: <files/directories and byte bounds>
+Session: fresh resumable Cursor conversation | one-shot
+Cost/credential boundary: <Cursor plan/spend | xAI API | Grok Build plan>
+```
+
+Use `AskUserQuestion` with **Start pairing** and **Cancel**. Do not invoke a tool or widen filesystem reads on refusal. For direct API/CLI routes, `includeDirs` is unsupported: offer to inline bounded excerpts or omit them; never silently discard the request.
+
+## 3. First reviewer checkpoint
+
+Build a prompt under 100 KB containing the reviewer role, task/acceptance criteria, relevant project invariants, bounded diff/excerpts, tests already run, and focused questions. Require concise findings with severity, file/line evidence, consequence, and a proposed next action; require `NO CONCERNS` when appropriate.
+
+Call exactly one selected tool:
+
+- Cursor: `ask-cursor-agent({ provider: "grok", model, prompt, includeDirs })`.
+- Direct: `ask-grok({ harness, model, reasoningEffort, prompt })`, or the fully pinned `ask-llm({ provider: "grok", harness, model, reasoningEffort, prompt })` when only the unified tool is registered.
+
+For Cursor, capture `sessionId`, exact `model`, `harness`, and optional `reportedModel` from structured output. Treat a cross-provider label, a requested Auto/noncanonical ID, a changed exact model, or an absent final result as failure. If an unclassifiable display label such as `Auto` is merely reported, preserve it separately and flag the uncertainty; do not guess that it replaced the exact requested ID. Direct Grok transports are one-shot and return no session.
+
+## 4. Relay, act, and re-check
+
+Relay Grok's feedback before editing. Verify each finding against source and label it accepted, rejected, or deferred with reason. Claude makes the edits. At meaningful checkpoints, send only the bounded delta plus outcomes of prior findings:
+
+- Cursor route: reuse the returned `sessionId`, preserving the same provider/model and include directories.
+- Direct route: make a new one-shot call through the same harness/model/effort and disclose that continuity comes from the bounded recap, not a provider session.
+
+Do not hide partial success. If checkpoint 1 succeeded and checkpoint 2 fails, retain checkpoint 1's feedback and report `failed (partial)` with the failed stage.
+
+## 5. Cancellation and final report
+
+If the user cancels or interrupts, stop the in-flight MCP call and report `cancelled`; never retry another route. On completion report:
+
+```text
+grok-pair completed | cancelled | failed | failed (partial)
+Host / provider / harness: Claude Code / grok / <route>
+Requested model: <exact ID>
+Reported model: <label or not reported>
+Reasoning: <explicit effort semantics>
+Session: <ID reused N times | one-shot>
+Context shared: <bounded files/include dirs>
+Accepted / rejected / deferred findings: <counts and actions>
+Fallback: none
+```
+
+## Setup failures
+
+Give guidance for the selected route only:
+
+- Missing Cursor tool: `claude mcp add --scope user ask-llm -- npx -y @ask-llm/mcp` (exposes `ask-cursor-agent` and the unified `ask-llm` tool); authenticate `agent`, run `agent --list-models`, and restart Claude Code.
+- Missing direct tool: `claude mcp add --scope user grok -- npx -y @ask-llm/grok-mcp` for the `ask-grok` leaf, or the same `@ask-llm/mcp` registration for the fully pinned unified form, then restart.
+- Cursor unavailable/trust/model errors: follow the returned `agent --version`, explicit workspace trust, or `agent --list-models` guidance. Never pass `--trust` automatically.
+- xAI/API or Grok CLI auth/model/quota errors: preserve the redacted diagnostic and state that no fallback was attempted.
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/pairing-contract.md

@@ -0,0 +1,40 @@
+# Portable pair-programming contract
+
+This contract is shared by `/codex-pair` on Cursor Agent and `/grok-pair` on Claude Code. Host adapters may use different registration and lifecycle APIs, but must preserve these guarantees.
+
+## Roles and lifecycle
+
+The host remains the only editor. The consulted model is an explicit, read-only reviewer that challenges correctness, tests assumptions, and returns actionable findings. Run one state machine:
+
+`idle -> consented -> active -> completed | cancelled | failed`
+
+Before `active`, resolve and show the user the provider, harness, exact requested model, reasoning effort, directories/files to be shared, credential/cost boundary, and whether a resumable provider session will be created. If the host cannot read the provider process's configured model and effort deterministically, require the user to supply both rather than inferring defaults that may differ across environments. Missing choices stop before extra context reads, consent, or provider invocation. Refusal returns `cancelled` without creating a marker, reading extra directories, or invoking a provider.
+
+During `active`, relay each reviewer response before acting on it, verify findings against source, state accepted/rejected/deferred actions, and send only the bounded delta needed for the next checkpoint. The user or host interrupt cancels the in-flight MCP call; do not retry it under another tool, harness, model, or provider. End with one explicit `completed`, `cancelled`, or `failed` report.
+
+## Bounded context and include directories
+
+Default bounds are 20 KB per file and 100 KB per provider request. Prefer diffs, task requirements, project instructions, relevant tests, and narrow excerpts over whole repositories. Never send secrets, credential files, unrelated untracked files, or ignored paths.
+
+Additional directories must be explicit relative workspace paths: no absolute paths, `..`, or `~`; at most 32. Pass `includeDirs` only to a tool that supports it. If a selected route cannot expose extra directories, say so and ask whether to inline bounded excerpts or continue without them. Never silently drop a requested directory.
+
+## Transport, options, and attribution
+
+Select one route before the first call and keep it immutable for the run. Resolve tools by their exact leaf capability (`ask-codex`, `ask-grok`, or `ask-cursor-agent`), not by assuming a Claude plugin namespace. The unified `ask-llm` tool is an acceptable transport only when the call pins provider, harness where applicable, exact model, reasoning effort, include directories, and session explicitly and its schema rejects unsupported combinations rather than stripping them; it is never an unpinned generic call and never a fallback for a failed split tool. A missing tool is a setup failure, never permission to use a generic call.
+
+Every call and final report must keep these separate:
+
+- host harness;
+- provider;
+- execution harness/transport;
+- exact requested model ID;
+- provider-native reasoning effort (or, for Cursor catalogs, the exact effort-bearing model ID);
+- optional upstream display label (`reportedModel`).
+
+Never choose Cursor Auto, rewrite a model ID, suppress a requested option, or claim fallback when none occurred. Any cross-provider reported label is terminal.
+
+## Sessions, partial failure, and diagnostics
+
+Create and reuse a provider session only when the selected tool returns a session ID. Capture the ID from structured output, never scrape prose. On resumed Codex calls, omit `includeDirs` because `codex exec resume` does not support them; the initial call must establish that context. One-shot transports receive bounded deltas and are reported as one-shot.
+
+Preserve successful feedback if a later checkpoint fails, label the run `failed (partial)`, and report the failed checkpoint. Distinguish tool missing, provider unavailable, authentication, model unavailable, quota/spend, trust, timeout, cancellation, malformed output, and cross-provider substitution. Include exact setup guidance for the selected route and explicitly say that no fallback was attempted.