agentsys 5.0.3 → 5.1.0

package/lib/adapter-transforms.js

@@ -18,10 +18,30 @@ function transformBodyForOpenCode(content, repoRoot) {
   content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${PLUGIN_ROOT}');
   content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, '$PLUGIN_ROOT');
 
-  content = content.replace(/\.claude\//g, '.opencode/');
-  content = content.replace(/\.claude'/g, ".opencode'");
-  content = content.replace(/\.claude"/g, '.opencode"');
-  content = content.replace(/\.claude`/g, '.opencode`');
+  // Replace .claude/ paths with .opencode/ but preserve platform documentation lists
+  // that enumerate all three platforms (Claude Code: .claude/, OpenCode: .opencode/, Codex: .codex/)
+  // Also preserve {AI_STATE_DIR} references which are platform-agnostic
+  content = content.replace(/\.claude\//g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    // Skip if inside a platform enumeration (e.g., "Claude Code: `.claude/`")
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode/';
+  });
+  content = content.replace(/\.claude'/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return ".opencode'";
+  });
+  content = content.replace(/\.claude"/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode"';
+  });
+  content = content.replace(/\.claude`/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode`';
+  });
 
   const plugins = discovery.discoverPlugins(repoRoot);
   if (plugins.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsys",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "A modular runtime and orchestration system for AI agents - works with Claude Code, OpenCode, and Codex CLI",
   "main": "lib/platform/detect-platform.js",
   "type": "commonjs",

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

@@ -1,6 +1,6 @@
 {
   "name": "agnix",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Lint agent configurations before they break your workflow. Validates Skills, Hooks, MCP, Memory, Plugins.",
   "author": {
     "name": "Avi Fenesh",

package/plugins/agnix/skills/agnix/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agnix
 description: "Use when user asks to 'lint agent configs', 'validate skills', 'check CLAUDE.md', 'validate hooks', 'lint MCP'. Validates agent configuration files against 155 rules across 10+ AI tools."
-version: 5.0.3
+version: 5.1.0
 argument-hint: "[path] [--fix] [--strict] [--target=claude-code|cursor|codex]"
 ---
 

package/plugins/audit-project/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "audit-project",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Multi-agent iterative code review until zero issues remain",
   "author": {
     "name": "Avi Fenesh",

package/plugins/audit-project/lib/adapter-transforms.js

@@ -18,10 +18,30 @@ function transformBodyForOpenCode(content, repoRoot) {
   content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${PLUGIN_ROOT}');
   content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, '$PLUGIN_ROOT');
 
-  content = content.replace(/\.claude\//g, '.opencode/');
-  content = content.replace(/\.claude'/g, ".opencode'");
-  content = content.replace(/\.claude"/g, '.opencode"');
-  content = content.replace(/\.claude`/g, '.opencode`');
+  // Replace .claude/ paths with .opencode/ but preserve platform documentation lists
+  // that enumerate all three platforms (Claude Code: .claude/, OpenCode: .opencode/, Codex: .codex/)
+  // Also preserve {AI_STATE_DIR} references which are platform-agnostic
+  content = content.replace(/\.claude\//g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    // Skip if inside a platform enumeration (e.g., "Claude Code: `.claude/`")
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode/';
+  });
+  content = content.replace(/\.claude'/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return ".opencode'";
+  });
+  content = content.replace(/\.claude"/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode"';
+  });
+  content = content.replace(/\.claude`/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode`';
+  });
 
   const plugins = discovery.discoverPlugins(repoRoot);
   if (plugins.length > 0) {

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

@@ -1,6 +1,6 @@
 {
   "name": "consult",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Cross-tool AI consultation: get second opinions from Gemini, Codex, Claude, OpenCode, or Copilot CLI",
   "author": {
     "name": "Avi Fenesh",

package/plugins/consult/agents/consult-agent.md

@@ -1,6 +1,6 @@
 ---
 name: consult-agent
-description: "Execute cross-tool AI consultations via Task spawning. Use when agents or workflows need a second opinion from Gemini, Codex, Claude, OpenCode, or Copilot."
+description: "Execute cross-tool AI consultations via Task spawning. Use when agents or workflows need a second opinion from Gemini, Codex, Claude, OpenCode, or Copilot. Supports multi-instance parallel consultations (count > 1)."
 tools:
   - Skill
   - Bash(claude:*)
@@ -22,11 +22,13 @@ model: sonnet
 
 You are the programmatic interface for cross-tool AI consultations. The consult plugin follows the standard Command -> Agent -> Skill pattern:
 
-- **Command** (`/consult`): User-facing entry point. Handles interactive parameter selection (tool picker, effort picker, model picker via AskUserQuestion). Invokes the consult skill directly. Does NOT spawn this agent.
-- **Agent** (this file): Programmatic entry point for other agents and workflows via Task(). Requires all parameters pre-resolved by the caller. Invokes the consult skill, then executes the CLI command it returns via Bash.
-- **Skill** (`consult`): Implementation source of truth. Provides provider configurations, model mappings, command templates, context packaging, and output parsing logic. Both the command and this agent invoke the skill before executing anything.
+- **Command** (`/consult`): User-facing entry point. Handles natural language parsing and interactive parameter selection. For single instance (count=1), invokes the consult skill directly. For multi-instance (count>1), spawns this agent.
+- **Agent** (this file): Programmatic entry point. Requires all parameters pre-resolved by the caller. Handles both single-instance (invoke skill) and multi-instance (parallel execution). Used by the command for multi-instance and by other agents/workflows via Task().
+- **Skill** (`consult`): Implementation source of truth. Provides provider configurations, model mappings, command templates, context packaging, and output parsing logic.
 
-Use this agent when the /consult command is not available (e.g., from other agents or automated workflows that need a second opinion).
+Use this agent for:
+1. Multi-instance consultations (count > 1) dispatched by the /consult command
+2. Programmatic consultations from other agents or automated workflows
 
 ## Why Sonnet Model
 
@@ -48,13 +50,28 @@ Extract from prompt. ALL parameters MUST be pre-resolved by the caller (the /con
 - **context**: Context mode (diff, file, none) - default: none
 - **continueSession**: Session ID or true/false
 - **sessionFile**: Path to session state file
+- **count**: Number of parallel instances (1-5, default: 1)
 
 If any required parameter is missing, return an error as plain JSON:
 ```json
 {"error": "Missing required parameter: [param]. The caller must resolve all parameters before spawning this agent."}
 ```
 
-### 2. Invoke Consult Skill (MUST)
+### 2. Route: Single vs Multi-Instance
+
+If both `continueSession` is set and `count > 1`, return:
+```json
+{"error": "Cannot use --continue with count > 1. Session resume applies to a single tool session."}
+```
+
+Validate count: if provided, must be 1-5. If out of range, return `{"error": "Instance count must be 1-5. Got: [count]"}`.
+
+If `count` is 1 (or not provided), follow the **Single Instance** path (Step 3).
+If `count` is 2-5, follow the **Multi-Instance** path (Step 4).
+
+### 3. Single Instance (count=1)
+
+#### 3a. Invoke Consult Skill (MUST)
 
 You MUST invoke the `consult` skill using the Skill tool. Pass all parsed arguments. The skill is the authoritative source for provider configurations, model mappings, command building, context packaging, session loading, and output parsing. Do not bypass the skill.
 
@@ -65,11 +82,11 @@ Args: [question] --tool=[tool] --effort=[effort] [--model=[model]] [--context=[c
 Example: "Review this function" --tool=claude --effort=high --model=opus
 ```
 
-### 3. Execute Command
+#### 3b. Execute Command
 
 Run the CLI command returned by the skill via Bash with a 120-second timeout.
 
-### 4. Parse and Return Result
+#### 3c. Parse and Return Result
 
 Parse the response using the method specified by the skill for the target tool, then format and display the result as human-friendly text:
 
@@ -82,10 +99,105 @@ The results of the consultation are:
 
 Set `continuable: true` for Claude, Gemini, Codex, and OpenCode (tools with session resume support). Only Copilot is non-continuable. Each tool uses a different resume mechanism: Claude/Gemini use `--resume`, Codex uses `codex exec resume`, OpenCode uses `--session`/`--continue`.
 
-### 5. Save Session State
+#### 3d. Save Session State
 
 Write session state to the sessionFile path provided by the command for continuity.
 
+### 4. Multi-Instance (count > 1)
+
+When count > 1, execute N parallel consultations with the same tool and parameters.
+
+#### 4a. Invoke Consult Skill Once
+
+Invoke the `consult` skill once to get the resolved command template and provider configuration. This gives you the exact CLI command to run for this tool/model/effort combination. Do NOT execute the command from the skill response yet.
+
+#### 4b. Write Indexed Temp Files
+
+Write the question to N indexed temp files using the Write tool:
+- `{AI_STATE_DIR}/consult/question-1.tmp`
+- `{AI_STATE_DIR}/consult/question-2.tmp`
+- ... through `question-{count}.tmp`
+
+Platform state directory:
+- Claude Code: `.claude/`
+- OpenCode: `.opencode/`
+- Codex CLI: `.codex/`
+
+All temp files contain the same question text (with context prepended if applicable).
+
+#### 4c. Execute N Commands in Parallel
+
+Run N Bash commands **in parallel** (multiple Bash tool calls in a single message). Each command uses the template from Step 4a but points to its own indexed temp file. Set 120-second timeout on each.
+
+Example for 3 parallel Codex calls:
+```
+Bash: codex exec "$(cat "{AI_STATE_DIR}/consult/question-1.tmp")" --json -m "gpt-5.3-codex" -c model_reasoning_effort="high"
+Bash: codex exec "$(cat "{AI_STATE_DIR}/consult/question-2.tmp")" --json -m "gpt-5.3-codex" -c model_reasoning_effort="high"
+Bash: codex exec "$(cat "{AI_STATE_DIR}/consult/question-3.tmp")" --json -m "gpt-5.3-codex" -c model_reasoning_effort="high"
+```
+
+#### 4d. Parse and Format Results
+
+Parse each response using the skill's output parsing rules for the target tool. Format as numbered responses:
+
+```
+# Multi-Consultation Results
+
+Tool: {tool}, Model: {model}, Effort: {effort}, Instances: {count}
+
+---
+
+## Response 1 (Duration: {duration_ms}ms)
+
+{response_1}
+
+---
+
+## Response 2 (Duration: {duration_ms}ms)
+
+{response_2}
+
+---
+
+[... for each instance ...]
+
+---
+
+## Synthesis
+
+Key agreement points:
+- [Common themes across responses]
+
+Key differences:
+- [Where responses diverge]
+```
+
+If some instances failed but others succeeded, show the successful responses and note failures:
+`[WARN] Instance {N} failed: {error}. Showing {M} of {count} responses.`
+
+#### 4e. Clean Up and Save State
+
+1. Delete all indexed temp files (`question-1.tmp` through `question-{count}.tmp`)
+2. Save multi-session state to `{AI_STATE_DIR}/consult/last-multi-session.json`:
+
+```json
+{
+  "tool": "codex",
+  "model": "gpt-5.3-codex",
+  "effort": "high",
+  "count": 3,
+  "timestamp": "{ISO 8601 timestamp of execution}",
+  "question": "original question text",
+  "sessions": [
+    {"session_id": "abc-123", "continuable": true},
+    {"session_id": "def-456", "continuable": true},
+    {"session_id": "ghi-789", "continuable": true}
+  ]
+}
+```
+
+3. Also save the first session to `{AI_STATE_DIR}/consult/last-session.json` (standard format) so `--continue` works.
+
 ## Error Handling
 
 | Error | Action |
@@ -98,26 +210,7 @@ Write session state to the sessionFile path provided by the command for continui
 
 ## Output Sanitization
 
-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.`
+Apply the redaction patterns from the consult skill (`plugins/consult/skills/consult/SKILL.md`, Output Sanitization section). The skill is the canonical source for all redaction patterns.
 
 ## Critical Constraints
 

package/plugins/consult/commands/consult.md

@@ -1,61 +1,88 @@
 ---
 name: consult
 description: Consult another AI CLI tool for a second opinion. Use when you want to cross-check ideas, get alternative approaches, or validate decisions with Gemini, Codex, Claude, OpenCode, or Copilot.
-codex-description: 'Use when user asks to "consult gemini", "ask codex", "get second opinion", "cross-check with claude", "consult another AI", "ask opencode", "copilot opinion". Queries another AI CLI tool and returns the response.'
-argument-hint: "[question] [--tool=gemini|codex|claude|opencode|copilot] [--effort=low|medium|high|max] [--model=MODEL] [--context=diff|file=PATH|none] [--continue]"
-allowed-tools: Skill, Bash(git:*), Bash(claude:*), Bash(gemini:*), Bash(codex:*), Bash(opencode:*), Bash(copilot:*), Bash(where.exe:*), Bash(which:*), Read, Write, AskUserQuestion
+codex-description: 'Use when user asks to "consult gemini", "ask codex", "get second opinion", "cross-check with claude", "consult another AI", "ask opencode", "copilot opinion", "ask 3 codex", "multi-consult". Queries another AI CLI tool and returns the response.'
+argument-hint: "[natural language or flags] [--tool] [--effort] [--model] [--context] [--continue] [--count=N]"
+allowed-tools: Skill, Task, Bash(git:*), Bash(claude:*), Bash(gemini:*), Bash(codex:*), Bash(opencode:*), Bash(copilot:*), Bash(where.exe:*), Bash(which:*), Read, Write, AskUserQuestion
 ---
 
 # /consult - Cross-Tool AI Consultation
 
-You are executing the /consult command. Your job is to consult another AI CLI tool, get its response, and present the results to the user.
+You are executing the /consult command. Your job is to parse the user's request (natural language or flags), resolve missing parameters interactively, and execute the consultation.
 
 ## Constraints
 
 - NEVER expose API keys in commands or output
 - NEVER run with permission-bypassing flags (`--dangerously-skip-permissions`, `bypassPermissions`)
-- MUST use safe-mode defaults (`-a suggest` for Codex, `--allowedTools "Read,Glob,Grep"` for Claude)
+- MUST use safe-mode defaults (`--allowedTools "Read,Glob,Grep"` for Claude, `-c model_reasoning_effort` for Codex)
 - MUST enforce 120s timeout on all tool executions
-- MUST validate `--tool` against allow-list: gemini, codex, claude, opencode, copilot (reject all others)
+- MUST validate tool names against allow-list: gemini, codex, claude, opencode, copilot (reject all others)
 - MUST validate `--context=file=PATH` is within the project directory (reject absolute paths outside cwd)
 - MUST quote all user-provided values in shell commands to prevent injection
 - NEVER execute tools the user has not explicitly requested
 
-## Arguments
+## Execution
 
-Parse from $ARGUMENTS:
+### Phase 1: Parse Input (Flags + Natural Language)
 
-- **question**: What to ask the consulted tool (required unless --continue)
-- **--tool**: Target tool: `gemini`, `codex`, `claude`, `opencode`, `copilot` (interactive picker if omitted)
-- **--effort**: Thinking effort: `low`, `medium`, `high`, `max` (interactive picker if omitted)
-- **--model**: Specific model name (interactive picker if omitted). Free text.
-- **--context**: Auto-include context: `diff` (git diff), `file=PATH` (attach specific file), `none` (default)
-- **--continue**: Continue last consultation session, or `--continue=SESSION_ID` for specific session
+Parse `$ARGUMENTS` using both explicit flags and natural language extraction. Flags always take priority over NLP when both provide the same parameter.
 
-## Execution
+#### Step 1a: Extract explicit flags
+
+Look for and remove these flags from `$ARGUMENTS`:
+
+1. `--tool=VALUE` or `--tool VALUE` where VALUE is one of: gemini, codex, claude, opencode, copilot
+2. `--effort=VALUE` or `--effort VALUE` where VALUE is one of: low, medium, high, max
+3. `--model=VALUE` or `--model VALUE` (any string, including quoted)
+4. `--context=VALUE` where VALUE is: diff, file=PATH, or none
+5. `--continue` (optionally `--continue=SESSION_ID`)
+6. `--count=N` where N is 1-5
+
+Remove all matched flags and their values from `$ARGUMENTS`.
+
+#### Step 1b: Natural language extraction (on remaining text)
+
+After removing flags, parse the remaining text for these patterns:
 
-### Phase 1: Parse Arguments
+**Tool extraction** (case-insensitive):
+- "with {tool}" (e.g., "with codex") -> tool
+- "ask {tool}" (e.g., "ask gemini") -> tool
+- "consult {tool}" -> tool
+- "{tool} about" (e.g., "codex about") -> tool
+- Tool names: claude, gemini, codex, opencode, copilot
 
-Extract these values from `$ARGUMENTS`:
+**Count extraction**:
+- "ask {N} {tool}" (e.g., "ask 3 codex") -> count=N, tool
+- "{N} {tool}" (e.g., "3 codex") -> count=N, tool
+- "{N} instances" -> count=N
+- "few instances" / "multiple" / "several" -> count=ambiguous (ask user in Phase 2)
 
-1. Look for `--tool=VALUE` or `--tool VALUE` where VALUE MUST be one of: gemini, codex, claude, opencode, copilot (reject others)
-2. Look for `--effort=VALUE` or `--effort VALUE` where VALUE MUST be one of: low, medium, high, max
-3. Look for `--model=VALUE` or `--model VALUE` (any string, including quoted strings like `"my model"`)
-4. Look for `--context=VALUE` where VALUE is: diff, file=PATH, or none
-5. Look for `--continue` (optionally `--continue=SESSION_ID`)
-6. Remove all matched flags (including their values) from `$ARGUMENTS`. Handle quoted flag values (e.g., `--model "gpt 4"`) by removing the entire quoted string. Everything remaining is the **question**.
+**Count validation**: After extracting count (from flags or NLP), validate: 1 <= count <= 5. If count < 1 or count > 5, show `[ERROR] Instance count must be 1-5. Got: {count}` and stop.
 
-If no question text and no `--continue` flag found, show:
+**Effort extraction**:
+- "quick" / "fast" / "brief" -> effort=low
+- "thorough" / "deep" / "carefully" / "detailed" -> effort=high
+- "maximum" / "max effort" / "exhaustive" -> effort=max
+
+**Question extraction**:
+- Text after "about" is the question (e.g., "with codex about my auth approach" -> question="my auth approach")
+- If no "about" pattern, everything remaining after removing tool/count/effort markers is the question
+
+**Precedence rule**: Flags from Step 1a always override NLP from Step 1b.
+
+If no question text and no `--continue` flag found after both steps:
 ```
-[ERROR] Usage: /consult "your question" [--tool=gemini|codex|claude|opencode|copilot] [--effort=low|medium|high|max]
+[ERROR] Usage: /consult "your question" or /consult with gemini about your question
 ```
 
-### Phase 2: Interactive Parameter Selection
+### Phase 2: Interactive Parameter Resolution
 
-MUST resolve ALL missing parameters interactively before Phase 3. ONLY skip this phase if ALL of --tool, --effort, AND --model are explicitly provided by the user in $ARGUMENTS. Do NOT silently default any parameter.
+MUST resolve ALL missing parameters interactively. ONLY skip this phase if ALL required params (tool, effort, model) are resolved AND either a question exists or --continue is present. Do NOT silently default any parameter.
 
 #### Step 2a: Handle --continue
 
+**Note:** `--continue` and `--count > 1` are mutually exclusive. Session resume applies to a single tool session. If both are present, show `[ERROR] Cannot use --continue with --count > 1. Use --continue for single session resume.` and stop.
+
 If `--continue` is present:
 1. Read the session file at `{AI_STATE_DIR}/consult/last-session.json`
 
@@ -66,9 +93,9 @@ If `--continue` is present:
 2. If the file exists, restore the saved tool, session_id, and model from it
 3. If the file does not exist, show `[WARN] No previous session found` and proceed as a fresh consultation
 
-#### Step 2b: Batch Selection (tool + effort)
+#### Step 2b: Detect installed tools
 
-First, detect which tools are installed by running all 5 checks **in parallel** via Bash:
+Run all 5 checks **in parallel** via Bash:
 
 - `where.exe <tool> 2>nul && echo FOUND || echo NOTFOUND` (Windows)
 - `which <tool> 2>/dev/null && echo FOUND || echo NOTFOUND` (Unix)
@@ -77,12 +104,14 @@ Check for: claude, gemini, codex, opencode, copilot.
 
 If zero tools are installed: `[ERROR] No AI CLI tools found. Install at least one: npm i -g @anthropic-ai/claude-code, npm i -g @openai/codex, npm i -g opencode-ai`
 
-Then use a SINGLE AskUserQuestion call to ask all missing parameters at once. Include only the questions for parameters NOT already provided in $ARGUMENTS:
+#### Step 2c: Batch selection for missing params
+
+Use a SINGLE AskUserQuestion call to ask all missing parameters at once. Include ONLY questions for parameters NOT already resolved from Phase 1:
 
 ```
 AskUserQuestion:
   questions:
-    - header: "AI Tool"                          # SKIP if --tool provided
+    - header: "AI Tool"                          # SKIP if tool resolved
       question: "Which AI tool should I consult?"
       multiSelect: false
       options (only if installed):
@@ -92,7 +121,7 @@ AskUserQuestion:
         - label: "OpenCode"     description: "Flexible model choice"
         - label: "Copilot"      description: "GitHub-integrated AI"
 
-    - header: "Effort"                           # SKIP if --effort provided
+    - header: "Effort"                           # SKIP if effort resolved
       question: "What thinking effort level?"
       multiSelect: false
       options:
@@ -100,16 +129,29 @@ AskUserQuestion:
         - label: "Low"                   description: "Fast, minimal reasoning"
         - label: "High"                  description: "Thorough analysis"
         - label: "Max"                   description: "Maximum reasoning depth"
+
+    - header: "Instances"                        # SKIP if count resolved or not hinted
+      question: "How many parallel consultations?"
+      multiSelect: false
+      options:
+        - label: "1 (Single)"             description: "Standard single consultation"
+        - label: "2 (Compare)"            description: "Two responses to compare"
+        - label: "3 (Panel)"              description: "Three perspectives"
+        - label: "5 (Full spread)"        description: "Five diverse perspectives"
 ```
 
-Map tool choice to lowercase: "Claude" -> "claude", "Codex" -> "codex", etc.
-Map effort choice: "Medium (Recommended)" -> "medium", "Low" -> "low", "High" -> "high", "Max" -> "max".
+ONLY show the Instances question if:
+- The user explicitly mentioned multiple instances (e.g., "few", "multiple", "several")
+- The count was set but ambiguous
+Do NOT show Instances question for simple single-tool requests. Default count=1 silently when no multi-instance intent detected.
 
-IMPORTANT: Do NOT skip any missing parameter. Do NOT silently default --effort to "medium" or --tool to any value. Present pickers for ALL unresolved parameters.
+Map tool choice to lowercase: "Claude" -> "claude", "Codex" -> "codex", etc.
+Map effort choice: "Medium (Recommended)" -> "medium", "Low" -> "low", etc.
+Map count choice: "1 (Single)" -> 1, "2 (Compare)" -> 2, "3 (Panel)" -> 3.
 
-#### Step 2c: Model Selection (MUST ask if no --model)
+#### Step 2d: Model selection (MUST ask if no --model)
 
-After tool is resolved (from Step 2b or $ARGUMENTS), present a model picker with options specific to the selected tool. The user can always type a custom model name via the "Other" option.
+After tool is resolved, present a model picker with options specific to the selected tool. The user can always type a custom model name via the "Other" option.
 
 **For Claude:**
 ```
@@ -149,7 +191,7 @@ AskUserQuestion:
         - label: "gpt-5.3-codex"        description: "Latest, most capable coding model"
         - label: "gpt-5.2-codex"        description: "Strong coding model"
         - label: "gpt-5.2"              description: "General purpose GPT-5.2"
-        - label: "gpt-5-codex-mini"     description: "Cost-effective, 4x more usage"
+        - label: "gpt-5.3-codex-spark"   description: "Cost-effective, 4x more usage"
 ```
 
 **For OpenCode:**
@@ -176,17 +218,21 @@ AskUserQuestion:
       options:
         - label: "claude-sonnet-4-5"        description: "Default Copilot model"
         - label: "claude-opus-4-6"          description: "Most capable Claude model"
-        - label: "gpt-5.3-codex"              description: "OpenAI GPT-5.3 Codex"
+        - label: "gpt-5.3-codex"            description: "OpenAI GPT-5.3 Codex"
         - label: "gemini-3-pro"             description: "Google Gemini 3 Pro"
 ```
 
-Map the user's choice to the model string (strip " (Recommended)" suffix if present). Pass the selected model to the skill via `--model`.
+Map the user's choice to the model string (strip " (Recommended)" suffix if present).
 
-IMPORTANT: Do NOT skip this step. Do NOT silently use a default model. If --model was not explicitly provided in $ARGUMENTS, you MUST present this picker. The model lists above are current as of Feb 2026 - the user may type any model name supported by their tool via the "Other" option.
+IMPORTANT: Do NOT skip model selection. Do NOT silently use a default model. If --model was not explicitly provided, you MUST present this picker.
 
-### Phase 3: Invoke Consult Skill
+### Phase 3: Execute Consultation
 
-With all parameters resolved (tool, effort, model, question, and optionally context, continue), invoke the `consult` skill using the Skill tool:
+With all parameters resolved (tool, effort, model, question, count, and optionally context/continue):
+
+#### Single instance (count=1, the default)
+
+Invoke the `consult` skill directly using the Skill tool:
 
 ```
 Skill: consult
@@ -195,15 +241,35 @@ Args: "[question]" --tool=[tool] --effort=[effort] --model=[model] [--context=[c
 Example: "Is this the right approach?" --tool=gemini --effort=high --model=gemini-3-pro
 ```
 
-The skill handles the full consultation lifecycle: it resolves the model from the effort level, builds the CLI command, packages any context, executes the command via Bash with a 120-second timeout, and returns a plain JSON result.
+The skill handles the full consultation lifecycle: model resolution, command building, context packaging, execution with 120s timeout, and returns a plain JSON result.
 
-### Phase 4: Parse Skill Output
+#### Multi-instance (count > 1)
 
-The skill returns a plain JSON object containing: `tool`, `model`, `effort`, `duration_ms`, `response`, `session_id`, and `continuable`. Parse the JSON directly from the skill output.
+Spawn the `consult:consult-agent` via the Task tool with all resolved parameters:
 
-### Phase 5: Present Results
+```
+Task:
+  subagent_type: "consult:consult-agent"
+  prompt: |
+    Execute a multi-instance consultation with these pre-resolved parameters:
+    - tool: [tool]
+    - model: [model]
+    - effort: [effort]
+    - question: [question]
+    - count: [count]
+    - context: [context or none]
+
+    Run [count] parallel consultations with the same tool and parameters.
+    Return all responses formatted with numbered headers and a brief synthesis.
+```
+
+The agent handles parallel execution, temp file management, result parsing, and synthesis.
+
+### Phase 4: Present Results
 
-After parsing the JSON, format and display the result as human-friendly text:
+#### Single instance
+
+Parse the skill's plain JSON output and display:
 
 ```
 Tool: {tool}, Model: {model}, Effort: {effort}, Duration: {duration_ms}ms.
@@ -214,12 +280,11 @@ The results of the consultation are:
 
 For continuable tools (Claude, Gemini, Codex, OpenCode), display: `Session: {session_id} - use /consult --continue to resume`
 
-Save session state for continuable tools (Claude, Gemini, Codex, OpenCode) to `{AI_STATE_DIR}/consult/last-session.json`.
+Save session state to `{AI_STATE_DIR}/consult/last-session.json`.
+
+#### Multi-instance
 
-Platform state directory:
-- Claude Code: `.claude/`
-- OpenCode: `.opencode/`
-- Codex CLI: `.codex/`
+Display the agent's formatted output directly. The agent returns numbered responses with a synthesis section.
 
 On failure: `[ERROR] Consultation Failed: {specific error message}`
 
@@ -227,22 +292,34 @@ On failure: `[ERROR] Consultation Failed: {specific error message}`
 
 | Error | Output |
 |-------|--------|
-| No question provided | `[ERROR] Usage: /consult "your question" [--tool=gemini\|codex\|claude\|opencode\|copilot] [--effort=low\|medium\|high\|max]` |
+| No question provided | `[ERROR] Usage: /consult "your question" or /consult with gemini about your question` |
 | Tool not installed | `[ERROR] {tool} is not installed. Install with: {install command from skill}` |
 | Tool execution fails | `[ERROR] {tool} failed: {error}. Try a different tool with --tool=[other]` |
 | Timeout (>120s) | `[ERROR] {tool} timed out after 120s. Try --effort=low for faster response` |
 | No tools available | `[ERROR] No AI CLI tools found. Install: npm i -g @anthropic-ai/claude-code` |
 | Session not found | `[WARN] No previous session found. Starting fresh consultation.` |
 | API key missing | `[ERROR] {tool} requires API key. Set {env var} (see skill for details)` |
+| Count out of range | `[ERROR] Instance count must be 1-5. Got: {count}` |
+| Multi-instance partial failure | Show successful responses, note failures |
 
 ## Example Usage
 
 ```bash
-/consult "Is this the right approach for error handling?" --tool=gemini --effort=high
-/consult "Review this function for performance issues" --tool=codex
-/consult "What alternative patterns would you suggest?" --tool=claude --effort=max
+# Natural language (NLP parsing)
+/consult with codex about my auth approach
+/consult ask 3 codex about this design
+/consult gemini should I use redis or postgres
+/consult thoroughly ask claude about error handling
+/consult codex few instances about performance
+
+# Explicit flags (backward compatible)
+/consult "Is this the right approach?" --tool=gemini --effort=high
+/consult "Review this function" --tool=codex --count=3
 /consult "Suggest improvements" --tool=opencode --model=github-copilot/claude-opus-4-6
-/consult "Continue from where we left off" --continue
+/consult --continue
 /consult "Explain this error" --context=diff --tool=gemini
 /consult "Review this file" --context=file=src/index.js --tool=claude
+
+# Mixed (flags + natural language)
+/consult with gemini --effort=max about database schema design
 ```