@ask-llm/plugin 0.14.0 → 0.16.2

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,9 @@ 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.
+
+The plugin's `ask-gemini-run`, Gemini reviewer agent/skill, and Pi `ask-gemini` tool all delegate to the canonical Gemini executor: `gemini-3.1-pro-preview` remains primary and quota errors fall back to `gemini-3.8-flash` unless `ASK_GEMINI_FALLBACK_MODEL` overrides it.
 
 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 +82,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 +116,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 +166,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,12 +226,12 @@ 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=$!
 
 # 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" &
+ollama run "${ASK_OLLAMA_MODEL:-qwen3.8:27b}" < "$workdir/prompt.md" > "$workdir/ollama.out" 2> "$workdir/ollama.err" &
 pid_ollama=$!
 
 # Wait for each by PID so we capture per-provider exit codes independently.
@@ -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/agents/gemini-reviewer.md

@@ -14,7 +14,7 @@ tools:
 <!-- PORTABLE-CONTRACT:START -->
 ## Portable contract
 
-Review only the supplied changes and context. Ask Gemini for concrete correctness, security, and regression concerns; validate every candidate against source; require file/line evidence and reproduction for behavior claims; omit style-only or speculative findings; report provider failures explicitly.
+Review only the supplied changes and context. Ask Gemini for concrete correctness, security, and regression concerns; validate every candidate against source; require file/line evidence and reproduction for behavior claims; omit style-only or speculative findings; report provider failures explicitly. Preserve the canonical `gemini-3.1-pro-preview` → `gemini-3.8-flash` quota fallback and disclose when fallback occurs.
 <!-- PORTABLE-CONTRACT:END -->
 
 <!-- HOST-ADAPTER:CLAUDE-CODE:START -->

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