agentsys 5.0.3 → 5.1.0

package/plugins/consult/skills/consult/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: consult
 description: "Cross-tool AI consultation. Use when user asks to 'consult gemini', 'ask codex', 'get second opinion', 'cross-check with claude', 'consult another AI', 'ask opencode', 'copilot opinion', or wants a second opinion from a different AI tool."
-version: 5.0.3
+version: 5.1.0
 argument-hint: "[question] [--tool] [--effort] [--model] [--context] [--continue]"
 ---
 
@@ -60,33 +60,34 @@ Command: gemini -p "QUESTION" --output-format json -m "MODEL"
 Session resume: --resume "SESSION_ID"
 ```
 
-Models: gemini-2.5-flash, gemini-2.5-pro, gemini-3-flash-preview, gemini-3-pro-preview
+Models: gemini-2.5-flash, gemini-2.5-pro, gemini-3-flash, gemini-3-pro
 
 | Effort | Model |
 |--------|-------|
 | low | gemini-2.5-flash |
-| medium | gemini-2.5-pro |
-| high | gemini-3-flash-preview |
-| max | gemini-3-pro-preview |
+| medium | gemini-3-flash |
+| high | gemini-3-pro |
+| max | gemini-3-pro |
 
 **Parse output**: `JSON.parse(stdout).response`
+**Session ID**: `JSON.parse(stdout).session_id`
 **Continuable**: Yes (via `--resume`)
 
 ### Codex
 
 ```
-Command: codex exec "QUESTION" --json -m "MODEL" -a suggest -c model_reasoning_effort="LEVEL"
+Command: codex exec "QUESTION" --json -m "MODEL" -c model_reasoning_effort="LEVEL"
 Session resume: codex exec resume SESSION_ID "QUESTION" --json
 Session resume (latest): codex exec resume --last "QUESTION" --json
 ```
 
 Note: `codex exec` is the non-interactive/headless mode. There is no `-q` flag. The TUI mode is `codex` (no subcommand).
 
-Models: gpt-5.1-codex-mini, gpt-5-codex, gpt-5.1-codex, gpt-5.2-codex, gpt-5.3-codex, gpt-5.1-codex-max
+Models: gpt-5.3-codex-spark, gpt-5-codex, gpt-5.1-codex, gpt-5.2-codex, gpt-5.3-codex, gpt-5.1-codex-max
 
 | Effort | Model | Reasoning |
 |--------|-------|-----------|
-| low | gpt-5.1-codex-mini | low |
+| low | gpt-5.3-codex-spark | low |
 | medium | gpt-5.2-codex | medium |
 | high | gpt-5.3-codex | high |
 | max | gpt-5.3-codex | xhigh |
@@ -187,7 +188,7 @@ User-provided question text MUST NOT be interpolated into shell command strings.
 | Claude (resume) | `claude -p - --output-format json --model "MODEL" --max-turns TURNS --allowedTools "Read,Glob,Grep" --resume "SESSION_ID" < "{AI_STATE_DIR}/consult/question.tmp"` |
 | Gemini | `gemini -p - --output-format json -m "MODEL" < "{AI_STATE_DIR}/consult/question.tmp"` |
 | Gemini (resume) | `gemini -p - --output-format json -m "MODEL" --resume "SESSION_ID" < "{AI_STATE_DIR}/consult/question.tmp"` |
-| Codex | `codex exec "$(cat "{AI_STATE_DIR}/consult/question.tmp")" --json -m "MODEL" -a suggest` (Codex exec lacks stdin mode -- cat reads from platform-controlled path, not user input) |
+| Codex | `codex exec "$(cat "{AI_STATE_DIR}/consult/question.tmp")" --json -m "MODEL" -c model_reasoning_effort="LEVEL"` (Codex exec lacks stdin mode -- cat reads from platform-controlled path, not user input) |
 | Codex (resume) | `codex exec resume SESSION_ID "$(cat "{AI_STATE_DIR}/consult/question.tmp")" --json -m "MODEL"` |
 | Codex (resume latest) | `codex exec resume --last "$(cat "{AI_STATE_DIR}/consult/question.tmp")" --json -m "MODEL"` |
 | OpenCode | `opencode run - --format json --model "MODEL" --variant "VARIANT" < "{AI_STATE_DIR}/consult/question.tmp"` |
@@ -242,16 +243,26 @@ If session file not found, warn and proceed as fresh consultation.
 
 ## Output Sanitization
 
-Before returning the response, the invoking agent MUST scan for and redact API keys, tokens, and credentials that may appear in the consulted tool's output. At minimum, redact these patterns:
-
-- `sk-[a-zA-Z0-9_-]{20,}` and `sk-ant-*`, `sk-proj-*` (API keys)
-- `AIza[a-zA-Z0-9_-]{30,}` (Google API keys)
-- `AKIA*`, `ASIA*` (AWS access/session keys)
-- `ghp_*`, `gho_*`, `github_pat_*` (GitHub tokens)
-- `ANTHROPIC_API_KEY=*`, `OPENAI_API_KEY=*`, `GOOGLE_API_KEY=*`, `GEMINI_API_KEY=*` (env assignments)
-- `Bearer [a-zA-Z0-9_-]{20,}` (auth headers)
-
-See `consult-agent.md` for the complete redaction pattern table with replacements.
+Before including any consulted tool's response in the output, scan the response text and redact matches for these patterns:
+
+| Pattern | Description | Replacement |
+|---------|-------------|-------------|
+| `sk-[a-zA-Z0-9_-]{20,}` | Anthropic API keys | `[REDACTED_API_KEY]` |
+| `sk-proj-[a-zA-Z0-9_-]{20,}` | OpenAI project keys | `[REDACTED_API_KEY]` |
+| `sk-ant-[a-zA-Z0-9_-]{20,}` | Anthropic API keys (ant prefix) | `[REDACTED_API_KEY]` |
+| `AIza[a-zA-Z0-9_-]{30,}` | Google API keys | `[REDACTED_API_KEY]` |
+| `ghp_[a-zA-Z0-9]{36,}` | GitHub personal access tokens | `[REDACTED_TOKEN]` |
+| `gho_[a-zA-Z0-9]{36,}` | GitHub OAuth tokens | `[REDACTED_TOKEN]` |
+| `github_pat_[a-zA-Z0-9_]{20,}` | GitHub fine-grained PATs | `[REDACTED_TOKEN]` |
+| `ANTHROPIC_API_KEY=[^\s]+` | Key assignment in env output | `ANTHROPIC_API_KEY=[REDACTED]` |
+| `OPENAI_API_KEY=[^\s]+` | Key assignment in env output | `OPENAI_API_KEY=[REDACTED]` |
+| `GOOGLE_API_KEY=[^\s]+` | Key assignment in env output | `GOOGLE_API_KEY=[REDACTED]` |
+| `GEMINI_API_KEY=[^\s]+` | Key assignment in env output | `GEMINI_API_KEY=[REDACTED]` |
+| `AKIA[A-Z0-9]{16}` | AWS access keys | `[REDACTED_AWS_KEY]` |
+| `ASIA[A-Z0-9]{16}` | AWS session tokens | `[REDACTED_AWS_KEY]` |
+| `Bearer [a-zA-Z0-9_-]{20,}` | Authorization headers | `Bearer [REDACTED]` |
+
+Apply redaction to the full response text before inserting into the result JSON. If any redaction occurs, append a note: `[WARN] Sensitive tokens were redacted from the response.`
 
 ## Output Format
 
@@ -260,7 +271,7 @@ Return a plain JSON object to stdout (no markers or wrappers):
 ```json
 {
   "tool": "gemini",
-  "model": "gemini-3-pro-preview",
+  "model": "gemini-3-pro",
   "effort": "high",
   "duration_ms": 12300,
   "response": "The AI's response text here...",

package/plugins/debate/.claude-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "debate",
+  "version": "5.1.0",
+  "description": "Structured multi-round debate between AI tools with proposer/challenger roles and verdict",
+  "author": {
+    "name": "Avi Fenesh",
+    "email": "[email protected]",
+    "url": "https://github.com/avifenesh"
+  },
+  "homepage": "https://github.com/avifenesh/agentsys#debate",
+  "repository": "https://github.com/avifenesh/agentsys",
+  "license": "MIT",
+  "keywords": [
+    "debate",
+    "dialectic",
+    "cross-tool",
+    "multi-model",
+    "adversarial",
+    "second-opinion"
+  ]
+}

package/plugins/debate/agents/debate-orchestrator.md

@@ -0,0 +1,175 @@
+---
+name: debate-orchestrator
+description: "Orchestrate multi-round debates between AI tools. Manages proposer/challenger rounds, builds cross-tool prompts, and delivers a verdict. Use when the /debate command dispatches a structured debate."
+tools:
+  - Skill
+  - Bash(claude:*)
+  - Bash(gemini:*)
+  - Bash(codex:*)
+  - Bash(opencode:*)
+  - Bash(copilot:*)
+  - Bash(git:*)
+  - Bash(where.exe:*)
+  - Bash(which:*)
+  - Read
+  - Write
+model: opus
+---
+
+# Debate Orchestrator
+
+## Role
+
+You are the judge and orchestrator of a structured debate between two AI tools. You manage the round-by-round exchange, build prompts that carry context between tools, and deliver a final verdict that picks a winner.
+
+You are spawned by the /debate command with all parameters pre-resolved.
+
+## Why Opus Model
+
+This is the most judgment-intensive agent in agentsys. You must: evaluate argument quality, detect when a tool dodges a challenge, summarize complex multi-turn reasoning, and ultimately decide which side argued better. This requires deep reasoning.
+
+## Workflow
+
+### 1. Parse Input
+
+Extract from prompt (ALL pre-resolved by the /debate command):
+
+**Required:**
+- **topic**: The debate question
+- **proposer**: Tool name for the proposer role (claude, gemini, codex, opencode, copilot)
+- **challenger**: Tool name for the challenger role (must differ from proposer)
+- **effort**: Effort level for all tool invocations (low, medium, high, max)
+- **rounds**: Number of rounds (1-5)
+
+**Optional:**
+- **model_proposer**: Specific model for proposer
+- **model_challenger**: Specific model for challenger
+- **context**: Context mode to pass through to consult skill (diff, file=PATH, none). Default: none. When set, each consult skill invocation includes `--context={value}` so both tools see the same codebase context.
+
+If any required param is missing, return:
+```json
+{"error": "Missing required parameter: [param]. The /debate command must resolve all parameters before spawning this agent."}
+```
+
+### 2. Invoke Debate Skill
+
+MUST invoke the `debate` skill to load prompt templates, context assembly rules, and synthesis format:
+
+```
+Skill: debate
+Args: "[topic]" --proposer=[proposer] --challenger=[challenger] --rounds=[rounds] --effort=[effort]
+```
+
+The skill returns the prompt templates and rules. Use them for all subsequent steps.
+
+### 3. Execute Debate Rounds
+
+For each round (1 through N):
+
+#### 3a. Build Proposer Prompt
+
+- **Round 1**: Use the "Round 1: Proposer Opening" template from the skill. Substitute {topic}.
+- **Round 2+**: Use the "Round 2+: Proposer Defense" template. Substitute {topic}, {context_summary}, {challenger_previous_response}, {round}.
+
+For context assembly:
+- **Rounds 1-2**: Include full text of all prior exchanges per the skill's context format.
+- **Round 3+**: Summarize rounds 1 through N-2 yourself (you have the full exchange history). Include only the most recent round's responses in full.
+
+#### 3b. Invoke Proposer via Consult Skill
+
+Only include `--model=[model_proposer]` if the caller provided a specific model. If model is "omit", empty, or "auto", do NOT pass --model to the consult skill.
+
+```
+Skill: consult
+Args: "{proposer_prompt}" --tool=[proposer] --effort=[effort] [--model=[model_proposer]] [--context=[context]]
+```
+
+Parse the JSON result. Extract the response text. Record: round, role="proposer", tool, response, duration_ms.
+
+Display to user immediately:
+```
+--- Round {N}: {proposer_tool} (Proposer) ---
+
+{proposer_response}
+```
+
+If the proposer fails on round 1, abort: `[ERROR] Debate aborted: proposer ({tool}) failed on opening round. {error}`
+
+If the proposer fails on round 2+, synthesize from completed rounds (skip to Step 4).
+
+#### 3c. Build Challenger Prompt
+
+- **Round 1**: Use the "Round 1: Challenger Response" template. Substitute {topic}, {proposer_tool}, {proposer_round1_response}.
+- **Round 2+**: Use the "Round 2+: Challenger Follow-up" template. Substitute {topic}, {context_summary}, {proposer_tool}, {proposer_previous_response}, {round}.
+
+#### 3d. Invoke Challenger via Consult Skill
+
+Only include `--model=[model_challenger]` if the caller provided a specific model. If model is "omit", empty, or "auto", do NOT pass --model to the consult skill.
+
+```
+Skill: consult
+Args: "{challenger_prompt}" --tool=[challenger] --effort=[effort] [--model=[model_challenger]] [--context=[context]]
+```
+
+Parse the JSON result. Record: round, role="challenger", tool, response, duration_ms.
+
+Display to user immediately:
+```
+--- Round {N}: {challenger_tool} (Challenger) ---
+
+{challenger_response}
+```
+
+If the challenger fails on round 1, show the proposer's uncontested position and proceed to synthesis with a note.
+
+If the challenger fails on round 2+, synthesize from completed rounds.
+
+### 4. Synthesize and Deliver Verdict
+
+After all rounds complete (or after a partial failure), produce the synthesis.
+
+You are the JUDGE. Read all exchanges carefully. Use the synthesis format from the debate skill. Your verdict:
+
+1. **Pick a winner.** Which tool made the stronger argument overall? Why? Cite specific exchanges.
+2. **List agreements.** What did both tools agree on?
+3. **List disagreements.** Where do they still diverge? What's each side's position?
+4. **List unresolved questions.** What did neither side address adequately?
+5. **Make a recommendation.** What should the user DO? Be specific and actionable.
+
+**Verdict rules (from the debate skill):**
+- You MUST pick a side. "Both approaches have merit" is NOT acceptable.
+- Cite specific arguments from the debate as evidence.
+- The recommendation must be actionable.
+- Be honest about what wasn't resolved.
+
+Display the full synthesis using the format from the debate skill's Synthesis Format section.
+
+### 5. Save State
+
+Write the debate state to `{AI_STATE_DIR}/debate/last-debate.json` using the schema from the debate skill.
+
+Platform state directory:
+- Claude Code: `.claude/`
+- OpenCode: `.opencode/`
+- Codex CLI: `.codex/`
+
+Create the `debate/` subdirectory if it doesn't exist.
+
+## Output Sanitization
+
+Apply the FULL redaction pattern table from the consult skill (`plugins/consult/skills/consult/SKILL.md`, Output Sanitization section). The skill is the canonical source with all 14 patterns. Do NOT maintain a separate subset here.
+
+The consult skill's table covers: Anthropic keys (`sk-*`, `sk-ant-*`, `sk-proj-*`), Google keys (`AIza*`), GitHub tokens (`ghp_*`, `gho_*`, `github_pat_*`), AWS keys (`AKIA*`, `ASIA*`), env assignments (`ANTHROPIC_API_KEY=*`, `OPENAI_API_KEY=*`, `GOOGLE_API_KEY=*`, `GEMINI_API_KEY=*`), and auth headers (`Bearer *`).
+
+Read the consult skill file to get the exact patterns and replacements.
+
+## Critical Constraints
+
+- NEVER expose API keys in commands or output
+- NEVER run with permission-bypassing flags
+- MUST invoke the debate skill before starting rounds (for templates)
+- MUST invoke the consult skill for each tool call (for provider configs)
+- MUST set 120s timeout on each Bash execution
+- MUST display each round progressively as it completes
+- MUST pick a winner in the verdict - no diplomatic non-answers
+- MUST sanitize all tool output before displaying

package/plugins/debate/commands/debate.md

@@ -0,0 +1,221 @@
+---
+name: debate
+description: Structured debate between two AI tools to stress-test ideas. Proposer/Challenger format with a verdict.
+codex-description: 'Use when user asks to "debate", "argue about", "compare perspectives", "stress test idea", "devil advocate", "codex vs gemini". Runs structured multi-round debate between two AI tools with proposer/challenger roles.'
+argument-hint: "[topic] [--tools=tool1,tool2] [--rounds=N] [--effort=low|medium|high|max]"
+allowed-tools: Task, Skill, Bash(where.exe:*), Bash(which:*), Read, Write, AskUserQuestion
+---
+
+# /debate - Structured AI Dialectic
+
+You are executing the /debate command. Your job is to parse the user's request, resolve missing parameters interactively, and spawn the debate orchestrator.
+
+## Constraints
+
+- NEVER expose API keys in commands or output
+- NEVER run with permission-bypassing flags
+- MUST validate tool names against allow-list: gemini, codex, claude, opencode, copilot
+- Proposer and challenger MUST be different tools
+- Rounds MUST be 1-5 (default: 2)
+
+## Execution
+
+### Phase 1: Parse Input (Flags + Natural Language)
+
+Parse `$ARGUMENTS` using both explicit flags and natural language. Flags take priority.
+
+#### Step 1a: Extract explicit flags
+
+1. `--tools=TOOL1,TOOL2` (comma-separated pair, first is proposer, second is challenger)
+2. `--rounds=N` where N is 1-5
+3. `--effort=VALUE` where VALUE is one of: low, medium, high, max
+4. `--model-proposer=VALUE` (any string)
+5. `--model-challenger=VALUE` (any string)
+6. `--context=VALUE` where VALUE is: diff, file=PATH, or none (passed through to consult skill for each tool invocation)
+
+Remove matched flags from `$ARGUMENTS`.
+
+#### Step 1b: Natural language extraction
+
+**Tool pair extraction** (case-insensitive):
+- "{tool} vs {tool}" (e.g., "codex vs gemini") -> proposer, challenger
+- "{tool} and {tool}" -> proposer, challenger
+- "with {tool} and {tool}" -> proposer, challenger
+- "between {tool} and {tool}" -> proposer, challenger
+- Tool names: claude, gemini, codex, opencode, copilot
+
+**Rounds extraction**:
+- "{N} rounds" -> rounds=N
+- "single round" / "one round" -> rounds=1
+- "deep" / "extended" -> rounds=3
+
+**Effort extraction** (same as consult):
+- "quick" / "fast" -> effort=low
+- "thorough" / "deep" / "carefully" -> effort=high
+- "maximum" / "max effort" -> effort=max
+
+**Topic extraction**:
+- Text after "about" is the topic
+- If no "about" pattern, remaining text after removing tool/rounds/effort markers
+
+**Validation**: rounds must be 1-5. Proposer and challenger must differ. If same tool specified for both, show: `[ERROR] Proposer and challenger must be different tools.`
+
+If no topic found: `[ERROR] Usage: /debate "your topic" or /debate codex vs gemini about your topic`
+
+### Phase 2: Interactive Parameter Resolution
+
+MUST resolve ALL missing parameters. Do NOT silently default.
+
+#### Step 2a: Detect installed tools
+
+Run all 5 checks **in parallel** via Bash:
+- `which <tool> 2>/dev/null && echo FOUND || echo NOTFOUND` (Unix)
+- `where.exe <tool> 2>nul && echo FOUND || echo NOTFOUND` (Windows)
+
+Check for: claude, gemini, codex, opencode, copilot.
+
+If fewer than 2 tools installed: `[ERROR] Debate requires at least 2 AI CLI tools. Install more: npm i -g @anthropic-ai/claude-code, npm i -g @openai/codex`
+
+#### Step 2b: Batch selection for missing params
+
+Use a SINGLE AskUserQuestion call for all missing params:
+
+```
+AskUserQuestion:
+  questions:
+    - id: "debate-proposer"
+      header: "Proposer"                         # SKIP if proposer resolved
+      question: "Which tool should PROPOSE (argue for)?"
+      multiSelect: false
+      options (only installed tools):
+        - label: "Claude"       description: "Deep code reasoning"
+        - label: "Gemini"       description: "Fast multimodal analysis"
+        - label: "Codex"        description: "Agentic coding"
+        - label: "OpenCode"     description: "Flexible model choice"
+        - label: "Copilot"      description: "GitHub-integrated AI"
+
+    - id: "debate-challenger"
+      header: "Challenger"                       # SKIP if challenger resolved
+      question: "Which tool should CHALLENGE (find flaws)?"
+      multiSelect: false
+      options (only installed, excluding proposer):
+        [same list minus the proposer tool]
+
+    - id: "debate-effort"
+      header: "Effort"                           # SKIP if effort resolved
+      question: "What thinking effort level?"
+      multiSelect: false
+      options:
+        - label: "High (Recommended)"    description: "Thorough analysis for debate"
+        - label: "Medium"                description: "Balanced speed and quality"
+        - label: "Low"                   description: "Fast, minimal reasoning"
+        - label: "Max"                   description: "Maximum reasoning depth"
+
+    - id: "debate-rounds"
+      header: "Rounds"                           # SKIP if rounds resolved
+      question: "How many debate rounds?"
+      multiSelect: false
+      options:
+        - label: "2 (Recommended)"       description: "Propose + challenge + defend + respond"
+        - label: "1 (Quick)"             description: "Single propose + challenge"
+        - label: "3 (Extended)"          description: "Three full exchanges"
+        - label: "5 (Exhaustive)"        description: "Five rounds, deep exploration"
+
+    - id: "debate-context"
+      header: "Context"                          # SKIP if --context resolved
+      question: "Include codebase context for both tools?"
+      multiSelect: false
+      options:
+        - label: "None (Recommended)"    description: "No extra context, just the topic"
+        - label: "Diff"                  description: "Include current git diff"
+        - label: "File"                  description: "Include a specific file (will ask path)"
+```
+
+Map choices: "Claude" -> "claude", "High (Recommended)" -> "high", "2 (Recommended)" -> 2, "None (Recommended)" -> "none", "Diff" -> "diff", "File" -> "file" (then ask for path). Strip " (Recommended)" suffix.
+
+If context resolved to "file":
+  Use a follow-up AskUserQuestion to ask for the file path:
+  ```
+  AskUserQuestion:
+    questions:
+      - id: "debate-file-path"
+        header: "File path"
+        question: "Which file should both tools see?"
+        multiSelect: false
+        options:
+          - label: "src/"               description: "Source directory file"
+          - label: "README.md"          description: "Project readme"
+  ```
+  The user can type any path via "Other".
+  After getting the path:
+  1. Reject absolute paths outside the current working directory
+  2. Reject paths containing `..` that escape the project root
+  3. Reject UNC paths (`\\` or `//` prefix)
+  4. Validate the file exists using the Read tool
+  If the path escapes the project: `[ERROR] Context file must be within the project directory`
+  If the file doesn't exist: `[ERROR] Context file not found: {PATH}`
+  If valid, set context to `file={user_provided_path}`.
+
+If proposer and challenger resolve to the same tool after selection, show error and re-ask for challenger.
+
+### Phase 3: Spawn Debate Orchestrator
+
+With all parameters resolved, spawn the debate orchestrator agent:
+
+```
+Task:
+  subagent_type: "debate:debate-orchestrator"
+  model: opus
+  prompt: |
+    Execute a structured debate with these pre-resolved parameters:
+    - topic: [topic]
+    - proposer: [proposer tool]
+    - challenger: [challenger tool]
+    - effort: [effort]
+    - rounds: [rounds]
+    - model_proposer: [model or "omit"]
+    - model_challenger: [model or "omit"]
+
+    If model is "omit" or empty, do NOT include --model in consult skill invocations. The consult skill will use effort-based defaults.
+    - context: [context or "none"]
+
+    Follow the debate skill templates. Display each round progressively.
+    Deliver a verdict that picks a winner.
+```
+
+### Phase 4: Present Results
+
+Display the orchestrator's output directly. It includes:
+- Progressive round-by-round output (displayed as each round completes)
+- Final synthesis with verdict, agreements, disagreements, and recommendation
+
+On failure: `[ERROR] Debate Failed: {specific error message}`
+
+## Error Handling
+
+| Error | Output |
+|-------|--------|
+| No topic provided | `[ERROR] Usage: /debate "your topic" or /debate codex vs gemini about your topic` |
+| Tool not installed | `[ERROR] {tool} is not installed. Install with: {install command}` |
+| Fewer than 2 tools | `[ERROR] Debate requires at least 2 AI CLI tools installed.` |
+| Same tool for both | `[ERROR] Proposer and challenger must be different tools.` |
+| Rounds out of range | `[ERROR] Rounds must be 1-5. Got: {rounds}` |
+| Context file not found | `[ERROR] Context file not found: {PATH}` |
+| Orchestrator fails | `[ERROR] Debate failed: {error}` |
+
+## Example Usage
+
+```bash
+# Natural language
+/debate codex vs gemini about microservices vs monolith
+/debate with claude and codex about our auth implementation
+/debate thoroughly gemini vs codex about database schema design
+/debate codex vs gemini 3 rounds about event sourcing
+
+# Explicit flags
+/debate "Should we use event sourcing?" --tools=claude,gemini --rounds=3 --effort=high
+/debate "Redis vs PostgreSQL for caching" --tools=codex,opencode
+
+# Mixed
+/debate codex vs gemini --effort=max about performance optimization strategies
+```