workflow-router

Use this skill when:

• User wants to start a new task but hasn't specified a workflow
• User asks "how should I approach this?"
• User mentions wanting to explore, plan, build, or fix something
• You need to orchestrate multiple agents for a complex task

Step 1: Goal Selection

First, determine the user's primary goal. Use the AskUserQuestion tool:

```

questions=[{

"question": "What's your primary goal for this task?",

"header": "Goal",

"options": [

{"label": "Research", "description": "Understand/explore something - investigate unfamiliar code, libraries, or concepts"},

{"label": "Plan", "description": "Design/architect a solution - create implementation plans, break down complex problems"},

{"label": "Build", "description": "Implement/code something - write new features, create components, implement from a plan"},

{"label": "Fix", "description": "Debug/fix an issue - investigate and resolve bugs, debug failing tests"}

],

"multiSelect": false

}]

```

If the user's intent is clear from context, you may infer the goal. Otherwise, ask explicitly using the tool above.

Step 2: Plan Detection

Before proceeding, check for existing plans:

```bash

ls thoughts/shared/plans/*.md 2>/dev/null

```

If plans exist:

• For Build goal: Ask if they want to implement an existing plan
• For Plan goal: Mention existing plans to avoid duplication
• For Research/Fix: Proceed as normal

Step 3: Resource Allocation

Determine how many agents to use. Use the AskUserQuestion tool:

```

questions=[{

"question": "How would you like me to allocate resources?",

"header": "Resources",

"options": [

{"label": "Conservative", "description": "1-2 agents, sequential execution - minimal context usage, best for simple tasks"},

{"label": "Balanced (Recommended)", "description": "Appropriate agents for the task, some parallelism - best for most tasks"},

{"label": "Aggressive", "description": "Max parallel agents working simultaneously - best for time-critical tasks"},

{"label": "Auto", "description": "System decides based on task complexity"}

],

"multiSelect": false

}]

```

Default to Balanced if not specified or if user selects Auto.

Step 4: Specialist Mapping

Route to the appropriate specialist based on goal:

| Goal | Primary Agent | Alias | Description |

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

| Research | oracle | Librarian | Comprehensive research using MCP tools (nia, perplexity, repoprompt, firecrawl) |

| Plan | plan-agent | Oracle | Create implementation plans with phased approach |

| Build | kraken | Kraken | Implementation agent - handles coding tasks via Task tool |

| Fix | debug-agent | Sentinel | Investigate issues using codebase exploration and logs |

Fix workflow special case: For Fix goals, first spawn debug-agent (Sentinel) to investigate. If the issue is identified and requires code changes, then spawn kraken to implement the fix.

Step 5: Confirmation

Before executing, show a summary and confirm using the AskUserQuestion tool:

First, display the execution summary:

```

Goal: [Research/Plan/Build/Fix]

Resource Allocation: [Conservative/Balanced/Aggressive]

Agent(s) to spawn: [agent names]

What will happen:

• [Brief description of what the agent(s) will do]
• [Expected output/deliverable]

```

Then use the AskUserQuestion tool for confirmation:

```

questions=[{

"question": "Ready to proceed with this workflow?",

"header": "Confirm",

"options": [

{"label": "Yes, proceed", "description": "Run the workflow with the settings above"},

{"label": "Adjust settings", "description": "Go back and modify goal or resource allocation"}

],

"multiSelect": false

}]

```

Wait for user confirmation before spawning agents. If user selects "Adjust settings", return to the relevant step.

Research (Librarian)

```

Task(

subagent_type="oracle",

prompt="""

Research: [topic]

Scope: [what to investigate]

Output: Create a handoff with findings at thoughts/handoffs//

"""

)

```

Plan (Oracle)

```

Task(

subagent_type="plan-agent",

prompt="""

Create implementation plan for: [feature/task]

Context: [relevant context]

Output: Save plan to thoughts/shared/plans/

"""

)

```

Build (Kraken)

If plan exists: Run pre-mortem before implementation:

```

/premortem deep

```

This identifies risks and blocks if HIGH severity issues found. User can accept, mitigate, or research solutions.

After premortem passes:

```

Task(

subagent_type="kraken",

prompt="""

Implement: [task]

Plan location: [if applicable]

Tests: Run tests after implementation

"""

)

```

Fix (Sentinel then Kraken)

```

# Step 1: Investigate

Task(

subagent_type="debug-agent",

prompt="""

Investigate: [issue description]

Symptoms: [what's failing]

Output: Diagnosis and recommended fix

"""

)

# Step 2: If fix identified, spawn kraken

Task(

subagent_type="kraken",

prompt="""

Fix: [issue based on Sentinel's diagnosis]

"""

)

```

• Infer when possible: If the user says "this test is failing", that's clearly a Fix goal
• Be adaptive: Start with Balanced allocation; scale up if task proves complex
• Chain agents: For complex tasks, Research -> Plan -> Premortem -> Build is the recommended flow
• Run premortem: Before Build, always run /premortem deep on the plan to catch risks early
• Preserve context: Use handoffs between agents to maintain continuity