agentsys 5.0.0

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

@@ -0,0 +1,129 @@
+---
+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."
+tools:
+  - Skill
+  - Bash(claude:*)
+  - Bash(gemini:*)
+  - Bash(codex:*)
+  - Bash(opencode:*)
+  - Bash(copilot:*)
+  - Bash(git:*)
+  - Bash(where.exe:*)
+  - Bash(which:*)
+  - Read
+  - Write
+model: sonnet
+---
+
+# Consult Agent
+
+## Role
+
+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.
+
+Use this agent when the /consult command is not available (e.g., from other agents or automated workflows that need a second opinion).
+
+## Why Sonnet Model
+
+Orchestration work: parse config, invoke skill, execute CLI command, parse output. No complex reasoning needed.
+
+## Workflow
+
+### 1. Parse Input
+
+Extract from prompt. ALL parameters MUST be pre-resolved by the caller (the /consult command or direct Task invocation). This agent runs as a subagent and cannot interact with the user.
+
+**Required** (caller must provide):
+- **tool**: Target tool (claude, gemini, codex, opencode, copilot)
+- **question**: The consultation question
+- **effort**: Thinking effort level (low, medium, high, max)
+
+**Optional**:
+- **model**: Specific model override (or null for auto from effort)
+- **context**: Context mode (diff, file, none) - default: none
+- **continueSession**: Session ID or true/false
+- **sessionFile**: Path to session state file
+
+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)
+
+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.
+
+```
+Skill: consult
+Args: [question] --tool=[tool] --effort=[effort] [--model=[model]] [--context=[context]] [--continue=[session]]
+
+Example: "Review this function" --tool=claude --effort=high --model=opus
+```
+
+### 3. Execute Command
+
+Run the CLI command returned by the skill via Bash with a 120-second timeout.
+
+### 4. 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:
+
+```
+Tool: {tool}, Model: {model}, Effort: {effort}, Duration: {duration_ms}ms.
+
+The results of the consultation are:
+{response}
+```
+
+Set `continuable: true` only for Claude and Gemini (tools with session resumption support).
+
+### 5. Save Session State
+
+Write session state to the sessionFile path provided by the command for continuity.
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Tool not installed | Return error with install command (see skill for install instructions) |
+| Command timeout (>120s) | Kill process, return partial output. Do NOT retry automatically. |
+| JSON parse failure | Return raw text as response |
+| Session file missing | Start fresh (ignore --continue) |
+| Empty response | Return error suggesting retry with higher effort |
+
+## 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.`
+
+## Critical Constraints
+
+- NEVER expose API keys in commands or output. Keys in logs can be captured and exploited.
+- NEVER run commands with `--dangerously-skip-permissions` or `bypassPermissions`. These bypass safety checks.
+- MUST invoke the `consult` skill before executing any command. The skill is the single source of truth for provider configs.
+- MUST set a 120-second timeout on Bash execution. Prevents hanging processes and resource exhaustion.
+- MUST use safe-mode defaults for all tool invocations (skill defines per-provider flags). Prevents unintended writes or destructive actions.
+- MUST sanitize tool output before returning. Consulted tools may echo environment variables or API keys in their response.

package/plugins/consult/commands/consult.md

@@ -0,0 +1,248 @@
+---
+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
+---
+
+# /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.
+
+## 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 enforce 120s timeout on all tool executions
+- MUST validate `--tool` 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
+
+Parse from $ARGUMENTS:
+
+- **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
+
+## Execution
+
+### Phase 1: Parse Arguments
+
+Extract these values from `$ARGUMENTS`:
+
+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**.
+
+If no question text and no `--continue` flag found, show:
+```
+[ERROR] Usage: /consult "your question" [--tool=gemini|codex|claude|opencode|copilot] [--effort=low|medium|high|max]
+```
+
+### Phase 2: Interactive Parameter Selection
+
+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.
+
+#### Step 2a: Handle --continue
+
+If `--continue` is present:
+1. Read the session file at `{AI_STATE_DIR}/consult/last-session.json`
+
+   Platform state directory:
+   - Claude Code: `.claude/`
+   - OpenCode: `.opencode/`
+   - Codex CLI: `.codex/`
+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)
+
+First, detect which tools are installed by running 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)
+
+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:
+
+```
+AskUserQuestion:
+  questions:
+    - header: "AI Tool"                          # SKIP if --tool provided
+      question: "Which AI tool should I consult?"
+      multiSelect: false
+      options (only if installed):
+        - 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"
+
+    - header: "Effort"                           # SKIP if --effort provided
+      question: "What thinking effort level?"
+      multiSelect: false
+      options:
+        - label: "Medium (Recommended)"  description: "Balanced speed and quality"
+        - label: "Low"                   description: "Fast, minimal reasoning"
+        - label: "High"                  description: "Thorough analysis"
+        - label: "Max"                   description: "Maximum reasoning depth"
+```
+
+Map tool choice to lowercase: "Claude" -> "claude", "Codex" -> "codex", etc.
+Map effort choice: "Medium (Recommended)" -> "medium", "Low" -> "low", "High" -> "high", "Max" -> "max".
+
+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.
+
+#### Step 2c: 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.
+
+**For Claude:**
+```
+AskUserQuestion:
+  questions:
+    - header: "Model"
+      question: "Which Claude model?"
+      multiSelect: false
+      options:
+        - label: "sonnet (Recommended)"  description: "Sonnet 4.5 - balanced speed and intelligence"
+        - label: "opus"                  description: "Opus 4.6 - most capable, adaptive thinking"
+        - label: "haiku"                 description: "Haiku 4.5 - fastest, lightweight"
+```
+
+**For Gemini:**
+```
+AskUserQuestion:
+  questions:
+    - header: "Model"
+      question: "Which Gemini model?"
+      multiSelect: false
+      options:
+        - label: "gemini-3-pro"          description: "Most capable, strong reasoning"
+        - label: "gemini-3-flash"        description: "Fast, 78% SWE-bench"
+        - label: "gemini-2.5-pro"        description: "Previous gen pro model"
+        - label: "gemini-2.5-flash"      description: "Previous gen flash model"
+```
+
+**For Codex:**
+```
+AskUserQuestion:
+  questions:
+    - header: "Model"
+      question: "Which Codex model?"
+      multiSelect: false
+      options:
+        - 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"
+```
+
+**For OpenCode:**
+```
+AskUserQuestion:
+  questions:
+    - header: "Model"
+      question: "Which model? (type via Other for paid: anthropic/claude-opus-4-6, openai/gpt-5.3-codex)"
+      multiSelect: false
+      options:
+        - label: "opencode/big-pickle"             description: "Free - Zen stealth model, 200K context"
+        - label: "opencode/minimax-m2.1-free"      description: "Free - 230B MoE, strong multilingual coding"
+        - label: "opencode/kimi-k2.5-free"         description: "Free - 1T multimodal, strong coding and agentic"
+        - label: "opencode/trinity-large-preview"  description: "Free - 400B sparse MoE by Arcee AI, 512K context"
+```
+
+**For Copilot:**
+```
+AskUserQuestion:
+  questions:
+    - header: "Model"
+      question: "Which Copilot model?"
+      multiSelect: false
+      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: "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`.
+
+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.
+
+### Phase 3: Invoke Consult Skill
+
+With all parameters resolved (tool, effort, model, question, and optionally context, continue), invoke the `consult` skill using the Skill tool:
+
+```
+Skill: consult
+Args: "[question]" --tool=[tool] --effort=[effort] --model=[model] [--context=[context]] [--continue=[session_id]]
+
+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.
+
+### Phase 4: Parse Skill Output
+
+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.
+
+### Phase 5: Present Results
+
+After parsing the JSON, format and display the result as human-friendly text:
+
+```
+Tool: {tool}, Model: {model}, Effort: {effort}, Duration: {duration_ms}ms.
+
+The results of the consultation are:
+{response}
+```
+
+For continuable tools (Claude/Gemini), also display: `Session: {session_id} - use /consult --continue to resume`
+
+Save session state for continuable tools (Claude, Gemini) to `{AI_STATE_DIR}/consult/last-session.json`.
+
+Platform state directory:
+- Claude Code: `.claude/`
+- OpenCode: `.opencode/`
+- Codex CLI: `.codex/`
+
+On failure: `[ERROR] Consultation Failed: {specific error message}`
+
+## Error Handling
+
+| Error | Output |
+|-------|--------|
+| No question provided | `[ERROR] Usage: /consult "your question" [--tool=gemini\|codex\|claude\|opencode\|copilot] [--effort=low\|medium\|high\|max]` |
+| 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)` |
+
+## 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
+/consult "Suggest improvements" --tool=opencode --model=github-copilot/claude-opus-4-6
+/consult "Continue from where we left off" --continue
+/consult "Explain this error" --context=diff --tool=gemini
+/consult "Review this file" --context=file=src/index.js --tool=claude
+```

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

@@ -0,0 +1,285 @@
+---
+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.0
+argument-hint: "[question] [--tool] [--effort] [--model] [--context] [--continue]"
+---
+
+# consult
+
+Cross-tool AI consultation: query another AI CLI tool and return the response.
+
+## When to Use
+
+Invoke this skill when:
+- User wants a second opinion from a different AI tool
+- User asks to consult, ask, or cross-check with gemini/codex/claude/opencode/copilot
+- User needs to compare responses across AI tools
+- User wants to validate a decision with an external AI
+
+## Arguments
+
+Parse from `$ARGUMENTS`:
+
+| Flag | Values | Default | Description |
+|------|--------|---------|-------------|
+| `--tool` | gemini, codex, claude, opencode, copilot | (picker) | Target tool |
+| `--effort` | low, medium, high, max | medium | Thinking effort level |
+| `--model` | any model name | (from effort) | Override model selection |
+| `--context` | diff, file=PATH, none | none | Auto-include context |
+| `--continue` | (flag) or SESSION_ID | false | Resume previous session |
+
+Question text is everything in `$ARGUMENTS` except the flags above.
+
+## Provider Configurations
+
+### Claude
+
+```
+Command: claude -p "QUESTION" --output-format json --model "MODEL" --max-turns TURNS --allowedTools "Read,Glob,Grep"
+Session resume: --resume "SESSION_ID"
+```
+
+Models: haiku, sonnet, opus
+
+| Effort | Model | Max Turns |
+|--------|-------|-----------|
+| low | haiku | 1 |
+| medium | sonnet | 3 |
+| high | opus | 5 |
+| max | opus | 10 |
+
+**Parse output**: `JSON.parse(stdout).result`
+**Session ID**: `JSON.parse(stdout).session_id`
+**Continuable**: Yes
+
+### Gemini
+
+```
+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
+
+| Effort | Model |
+|--------|-------|
+| low | gemini-2.5-flash |
+| medium | gemini-2.5-pro |
+| high | gemini-3-flash-preview |
+| max | gemini-3-pro-preview |
+
+**Parse output**: `JSON.parse(stdout).response`
+**Continuable**: Yes (via `--resume`)
+
+### Codex
+
+```
+Command: codex -q "QUESTION" --json -m "MODEL" -a suggest -c model_reasoning_effort="LEVEL"
+```
+
+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
+
+| Effort | Model | Reasoning |
+|--------|-------|-----------|
+| low | gpt-5.1-codex-mini | low |
+| medium | gpt-5.2-codex | medium |
+| high | gpt-5.3-codex | high |
+| max | gpt-5.3-codex | xhigh |
+
+**Parse output**: `JSON.parse(stdout).message` or raw text
+**Continuable**: No
+
+### OpenCode
+
+```
+Command: opencode run "QUESTION" --format json --model "MODEL" --variant "VARIANT"
+With thinking: add --thinking flag
+```
+
+Models: 75+ via providers (format: provider/model). Top picks: claude-sonnet-4-5, claude-opus-4-5, gpt-5.2, gpt-5.1-codex, gemini-3-pro, minimax-m2.1
+
+| Effort | Model | Variant |
+|--------|-------|---------|
+| low | (user-selected or default) | low |
+| medium | (user-selected or default) | medium |
+| high | (user-selected or default) | high |
+| max | (user-selected or default) | high + --thinking |
+
+**Parse output**: Parse JSON events from stdout, extract final text response
+**Continuable**: No
+
+### Copilot
+
+```
+Command: copilot -p "QUESTION"
+```
+
+Models: claude-sonnet-4-5 (default), claude-opus-4-6, claude-haiku-4-5, claude-sonnet-4, gpt-5
+
+| Effort | Notes |
+|--------|-------|
+| all | No effort control available. Model selectable via --model flag. |
+
+**Parse output**: Raw text from stdout
+**Continuable**: No
+
+## Input Validation
+
+Before building commands, validate all user-provided arguments:
+
+- **--tool**: MUST be one of: gemini, codex, claude, opencode, copilot. Reject all other values.
+- **--effort**: MUST be one of: low, medium, high, max. Default to medium.
+- **--model**: Allow any string, but quote it in the command.
+- **--context=file=PATH**: MUST resolve within the project directory. Reject absolute paths outside cwd. Additional checks:
+  1. **Block UNC paths** (Windows): Reject paths starting with `\\` or `//` (network shares)
+  2. **Resolve canonical path**: Use the Read tool to read the file (do NOT use shell commands). Before reading, resolve the path: join `cwd + PATH`, then normalize (collapse `.`, `..`, resolve symlinks)
+  3. **Verify containment**: The resolved canonical path MUST start with the current working directory. If it escapes (via `..`, symlinks, or junction points), reject with: `[ERROR] Path escapes project directory: {PATH}`
+  4. **No shell access**: Read file content using the Read tool only. Never pass user-provided paths to shell commands (prevents injection via path values)
+
+## Command Building
+
+Given the parsed arguments, build the complete CLI command. All user-provided values MUST be quoted in the shell command to prevent injection.
+
+### Step 1: Resolve Model
+
+If `--model` is specified, use it directly. Otherwise, use the effort-based model from the provider table above.
+
+### Step 2: Build Command String
+
+Use the command template from the provider's configuration section. Substitute QUESTION, MODEL, TURNS, LEVEL, and VARIANT with resolved values.
+
+If continuing a session (Claude or Gemini): append `--resume SESSION_ID`.
+If OpenCode at max effort: append `--thinking`.
+
+### Step 3: Context Packaging
+
+If `--context=diff`: Run `git diff 2>/dev/null` and prepend output to the question.
+If `--context=file=PATH`: Read the file using the Read tool and prepend its content to the question.
+
+### Step 4: Safe Question Passing
+
+User-provided question text MUST NOT be interpolated into shell command strings. Shell escaping is insufficient -- `$()`, backticks, and other expansion sequences can execute arbitrary commands even inside double quotes.
+
+**Required approach -- pass question via stdin or temp file:**
+
+1. **Write the question** to a temporary file using the Write tool (e.g., `{AI_STATE_DIR}/consult/question.tmp`)
+
+   Platform state directory:
+   - Claude Code: `.claude/`
+   - OpenCode: `.opencode/`
+   - Codex CLI: `.codex/`
+2. **Build the command** using the temp file as input instead of inline text:
+
+| Provider | Safe command pattern |
+|----------|---------------------|
+| Claude | `claude -p - --output-format json --model "MODEL" --max-turns TURNS --allowedTools "Read,Glob,Grep" < "{AI_STATE_DIR}/consult/question.tmp"` |
+| Gemini | `gemini -p - --output-format json -m "MODEL" < "{AI_STATE_DIR}/consult/question.tmp"` |
+| Codex | `codex -q "$(cat "{AI_STATE_DIR}/consult/question.tmp")" --json -m "MODEL" -a suggest` (Codex lacks stdin mode -- cat reads from platform-controlled path, not user input) |
+| OpenCode | `opencode run - --format json --model "MODEL" --variant "VARIANT" < "{AI_STATE_DIR}/consult/question.tmp"` |
+| Copilot | `copilot -p - < "{AI_STATE_DIR}/consult/question.tmp"` |
+
+3. **Delete the temp file** after the command completes (success or failure). Always clean up to prevent accumulation.
+
+**Model and session ID values** are controlled strings (from pickers or saved state) and safe to quote directly in the command. Only the question contains arbitrary user text and requires the temp file approach. The temp file path (`{AI_STATE_DIR}/consult/question.tmp`) uses a platform-controlled directory and fixed filename -- no user input in the path.
+
+## Provider Detection
+
+Cross-platform tool detection:
+
+- **Windows**: `where.exe TOOL 2>nul` -- returns 0 if found
+- **Unix**: `which TOOL 2>/dev/null` -- returns 0 if found
+
+Check each tool (claude, gemini, codex, opencode, copilot) and return only the available ones.
+
+## Session Management
+
+### Save Session
+
+After successful consultation, save to `{AI_STATE_DIR}/consult/last-session.json`:
+
+```json
+{
+  "tool": "claude",
+  "model": "opus",
+  "effort": "high",
+  "session_id": "abc-123-def-456",
+  "timestamp": "2026-02-10T12:00:00Z",
+  "question": "original question text",
+  "continuable": true
+}
+```
+
+`AI_STATE_DIR` uses the platform state directory:
+- Claude Code: `.claude/`
+- OpenCode: `.opencode/`
+- Codex CLI: `.codex/`
+
+### Load Session
+
+For `--continue`, read the session file and restore:
+- tool (from saved state)
+- session_id (for --resume flag)
+- model (reuse same model)
+
+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.
+
+## Output Format
+
+Return a plain JSON object to stdout (no markers or wrappers):
+
+```json
+{
+  "tool": "gemini",
+  "model": "gemini-3-pro-preview",
+  "effort": "high",
+  "duration_ms": 12300,
+  "response": "The AI's response text here...",
+  "session_id": "abc-123",
+  "continuable": true
+}
+```
+
+## Install Instructions
+
+When a tool is not found, return these install commands:
+
+| Tool | Install |
+|------|---------|
+| Claude | `npm install -g @anthropic-ai/claude-code` |
+| Gemini | See https://gemini.google.com/cli for install instructions |
+| Codex | `npm install -g @openai/codex` |
+| OpenCode | `npm install -g opencode-ai` or `brew install anomalyco/tap/opencode` |
+| Copilot | `gh extension install github/copilot-cli` |
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| Tool not installed | Return install instructions from table above |
+| Tool execution timeout | Return `"response": "Timeout after 120s"` |
+| JSON parse error | Return raw text as response |
+| Empty output | Return `"response": "No output received"` |
+| Session file missing | Proceed without session resume |
+| API key missing | Return tool-specific env var instructions |
+
+## Integration
+
+This skill is invoked by:
+- `consult-agent` for `/consult` command
+- Direct invocation: `Skill('consult', '"question" --tool=gemini --effort=high')`
+
+Example: `Skill('consult', '"Is this approach correct?" --tool=gemini --effort=high --model=gemini-3-pro')`

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

@@ -0,0 +1,20 @@
+{
+  "name": "deslop",
+  "version": "5.0.0",
+  "description": "AI slop cleanup with minimal diffs and behavior preservation",
+  "author": {
+    "name": "Avi Fenesh",
+    "email": "[email protected]",
+    "url": "https://github.com/avifenesh"
+  },
+  "homepage": "https://github.com/avifenesh/agentsys#deslop",
+  "repository": "https://github.com/avifenesh/agentsys",
+  "license": "MIT",
+  "keywords": [
+    "code-quality",
+    "cleanup",
+    "refactoring",
+    "maintenance",
+    "slop-detection"
+  ]
+}