sc-mcp

```bash

# PAL-powered analysis

/sc:mcp analyze --pal consensus --question "Should we use microservices?"

# Rube-powered automation

/sc:mcp automate --rube --apps slack,github --workflow "notify on PR"

# Combined orchestration

/sc:mcp orchestrate --pal thinkdeep --rube --full-validation

```

Available Tools

| Tool | Invocation | Purpose |

|------|------------|---------|

| chat | mcp__pal__chat | Collaborative thinking, brainstorming |

| thinkdeep | mcp__pal__thinkdeep | Multi-stage investigation, complex analysis |

| planner | mcp__pal__planner | Sequential planning with branching |

| consensus | mcp__pal__consensus | Multi-model voting on decisions |

| codereview | mcp__pal__codereview | Systematic code quality analysis |

| precommit | mcp__pal__precommit | Git change validation |

| debug | mcp__pal__debug | Root cause analysis |

| challenge | mcp__pal__challenge | Force critical thinking |

| apilookup | mcp__pal__apilookup | Current API/SDK documentation |

| listmodels | mcp__pal__listmodels | Available AI models |

| clink | mcp__pal__clink | External CLI integration |

PAL Workflows

#### Consensus Decision Making

```

Use consensus for:

• Architectural decisions (2-3 models)
• Security validations (security-focused models)
• Technology choices (diverse perspectives)
• Complex trade-off analysis

```

Recommended model combinations:

• Architectural: gpt-5.2 (for), gemini-3-pro (against), deepseek (neutral)
• Security: gpt-5.2 (security focus), gemini-3-pro (attack surface)
• Performance: gpt-5.2 (optimization), deepseek (efficiency)

#### Debug Investigation

```

Use debug for:

• Complex bugs with unclear causes
• Performance issues
• Race conditions
• Memory leaks
• Integration problems

```

Debug confidence levels: exploring -> low -> medium -> high -> very_high -> almost_certain -> certain

#### Code Review

```

Use codereview for:

• Pre-merge validation
• Security audits
• Performance reviews
• Architecture compliance

```

Review types: full, security, performance, quick

Available Tools

| Tool | Invocation | Purpose |

|------|------------|---------|

| SEARCH_TOOLS | mcp__rube__RUBE_SEARCH_TOOLS | Discover available integrations |

| CREATE_PLAN | mcp__rube__RUBE_CREATE_PLAN | Generate execution plans |

| MULTI_EXECUTE | mcp__rube__RUBE_MULTI_EXECUTE_TOOL | Parallel tool execution |

| REMOTE_BASH | mcp__rube__RUBE_REMOTE_BASH_TOOL | Remote shell commands |

| REMOTE_WORKBENCH | mcp__rube__RUBE_REMOTE_WORKBENCH | Python sandbox execution |

| CREATE_RECIPE | mcp__rube__RUBE_CREATE_UPDATE_RECIPE | Save reusable workflows |

| EXECUTE_RECIPE | mcp__rube__RUBE_EXECUTE_RECIPE | Run saved recipes |

| FIND_RECIPE | mcp__rube__RUBE_FIND_RECIPE | Search existing recipes |

| MANAGE_CONNECTIONS | mcp__rube__RUBE_MANAGE_CONNECTIONS | App authentication |

| GET_SCHEMAS | mcp__rube__RUBE_GET_TOOL_SCHEMAS | Tool input schemas |

| MANAGE_SCHEDULE | mcp__rube__RUBE_MANAGE_RECIPE_SCHEDULE | Recipe scheduling |

Rube Workflows

#### External Integration Flow

```

1. SEARCH_TOOLS - Find relevant tools for use case
2. GET_SCHEMAS - Get input requirements (if schemaRef returned)
3. MANAGE_CONNECTIONS - Verify/create auth
4. MULTI_EXECUTE - Execute tools
5. CREATE_RECIPE - Save for reuse (optional)

```

#### Bulk Processing Flow

```

1. SEARCH_TOOLS - Find data source/destination tools
2. REMOTE_WORKBENCH - Process with Python helpers:

- run_composio_tool() - Execute Composio tools

- invoke_llm() - AI processing

- upload_local_file() - Export results

- proxy_execute() - Direct API calls

```

Supported Apps (500+)

Communication: Slack, Discord, Teams, Gmail, Outlook, WhatsApp, Telegram

Development: GitHub, GitLab, Jira, Linear, Asana, Vercel

Productivity: Google Workspace, Notion, Airtable, Trello

Data: Snowflake, BigQuery, Datadog, Amplitude

AI: OpenAI, Anthropic, Replicate

Pattern 1: Research + Decide + Execute

```

1. PAL thinkdeep - Investigate problem deeply
2. PAL consensus - Get multi-model decision
3. Rube SEARCH_TOOLS - Find execution tools
4. Rube MULTI_EXECUTE - Implement decision

```

Pattern 2: Review + Validate + Notify

```

1. PAL codereview - Review code changes
2. PAL precommit - Validate git changes
3. Rube MULTI_EXECUTE - Send notifications (Slack, email)
4. Rube CREATE_RECIPE - Save for CI/CD

```

Pattern 3: Debug + Fix + Verify

```

1. PAL debug - Root cause analysis
2. Implement fix locally
3. PAL codereview - Validate fix
4. Rube MULTI_EXECUTE - Update tickets, notify team

```

Pattern 4: Plan + Consensus + Automate

```

1. PAL planner - Create implementation plan
2. PAL consensus - Validate approach with multiple models
3. Rube CREATE_PLAN - Generate execution plan
4. Rube MULTI_EXECUTE - Execute across apps
5. Rube CREATE_RECIPE - Save as reusable workflow

```

| Flag | Type | Default | Description |

|------|------|---------|-------------|

| --pal | string | - | PAL tool: chat, thinkdeep, planner, consensus, codereview, precommit, debug |

| --rube | bool | false | Enable Rube MCP integration |

| --apps | string | - | Comma-separated apps for Rube |

| --models | string | auto | Models for consensus (comma-separated) |

| --full-validation | bool | false | Run all PAL validators |

| --save-recipe | bool | false | Save workflow as Rube recipe |

| --schedule | string | - | Cron expression for recipe scheduling |

1. Analyze - Understand what MCP capabilities are needed
2. Discover - Use RUBE_SEARCH_TOOLS for external needs, listmodels for PAL
3. Plan - Create execution plan (PAL planner or RUBE_CREATE_PLAN)
4. Validate - Use consensus for critical decisions
5. Execute - Run PAL analysis and/or Rube tools
6. Persist - Save recipes, store memory for continuity
7. Report - Present findings with tool attribution

PAL Continuation

Use continuation_id to maintain context across PAL tool calls:

```python

# First call returns continuation_id

result = mcp__pal__thinkdeep(...)

continuation_id = result["continuation_id"]

# Subsequent calls reuse it

result = mcp__pal__thinkdeep(..., continuation_id=continuation_id)

```

Rube Session & Memory

Use session_id and memory for Rube continuity:

```python

# First search generates session_id

result = mcp__rube__RUBE_SEARCH_TOOLS(..., session={"generate_id": True})

session_id = result["session_id"]

# Subsequent calls reuse session and build memory

result = mcp__rube__RUBE_MULTI_EXECUTE_TOOL(

...,

session_id=session_id,

memory={"slack": ["Channel general is C123"]}

)

```

Multi-Model Architecture Review

```bash

/sc:mcp analyze --pal consensus --models "gpt-5.2,gemini-3-pro,deepseek" \

--question "Is event sourcing appropriate for this use case?"

```

Automated PR Workflow

```bash

/sc:mcp automate --rube --apps github,slack \

--workflow "On PR merge, post summary to #releases"

--save-recipe --schedule "0 9 1-5"

```

Full Investigation Pipeline

```bash

/sc:mcp orchestrate --pal debug --rube \

--issue "Memory leak in production" \

--notify slack,jira --full-validation

```

• Always search tools before executing unknown integrations
• Use consensus for decisions with >$1000 impact
• Validate schemas before multi-execute
• Store memory for frequently used IDs
• Check connection status before automation
• Use thinking_mode=high for complex PAL analysis

| Error | Recovery |

|-------|----------|

| PAL model unavailable | Fall back to different model |

| Rube connection missing | Prompt MANAGE_CONNECTIONS |

| Tool schema unknown | Call GET_SCHEMAS first |

| Rate limited | Use backoff in REMOTE_WORKBENCH |

| Recipe not found | Search or create new |

• PAL MCP: codereview, debug, consensus, thinkdeep, precommit, planner, chat, challenge, apilookup
• Rube MCP: 500+ app integrations via Composio
• Trait: mcp-pal-enabled - Apply PAL to any agent
• Trait: mcp-rube-enabled - Apply Rube to any agent