feat: elevate 4 community MCP skills to first-party

- skill-forge: mcp-cloudflare-builder (Cloudflare Workers MCP with McpAgent, OAuth, Wrangler)
- skill-forge: mcp-server-builder (OpenAPI→MCP scaffold, Python/TypeScript, quality gates)
- continuous-learning: web-research-external (library/best-practices/general research, chat/doc/handoff output)
- agent-orchestration: workflow-router (Research/Plan/Build/Fix classifier with resource allocation)

All four generalized from community source, structured with canonical sections and typed frontmatter.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: TresPies-source

plugins/agent-orchestration/skills/workflow-router/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: workflow-router
+model: sonnet
+description: Routes user goals to the appropriate specialist agent workflow with resource allocation confirmation. Use when: the user wants to start a task but hasn't specified a workflow, asks "how should I approach this?", or needs orchestration across research → plan → build → fix stages.
+category: agent-orchestration
+
+inputs:
+  - name: goal
+    type: string
+    description: User's stated goal or task description — the router will classify and route it
+    required: false
+outputs:
+  - name: routed_workflow
+    type: string
+    description: Confirmation of the agent(s) dispatched and their assigned tasks, with handoff paths
+---
+
+# Workflow Router
+
+Routes user goals to the appropriate specialist agent workflow with explicit resource allocation and confirmation before dispatch.
+
+## Description
+
+Classifies an incoming goal into one of four categories (Research, Plan, Build, Fix), maps it to the appropriate specialist agent(s), confirms resource allocation with the user, and dispatches. Handles the Fix workflow as a two-stage process (investigate first, then implement). Preserves context across agent handoffs using shared handoff documents. This skill is the entry point for multi-agent orchestration when the user knows what they want to accomplish but not which agent or workflow to use.
+
+## When to Use
+
+- User wants to start a non-trivial task without specifying a workflow
+- User asks "how should I approach this?" or "what's the best way to tackle X?"
+- A task requires multiple sequential agents (Research → Plan → Build)
+- You need explicit resource allocation agreement before spawning agents
+
+## Workflow
+
+### Step 1: Classify the Goal
+
+If the goal is not provided or is ambiguous, ask:
+
+```
+What's your primary goal for this task?
+
+- Research — Understand/explore something (unfamiliar code, libraries, concepts)
+- Plan — Design/architect a solution (implementation plans, problem decomposition)
+- Build — Implement/code something (new features, components, implementation from a plan)
+- Fix — Debug/fix an issue (investigate and resolve bugs, failing tests)
+```
+
+If intent is clear from context (e.g., "this test is failing" → Fix), infer without asking.
+
+### Step 2: Check for Existing Plans
+
+```bash
+ls thoughts/shared/plans/*.md 2>/dev/null || ls docs/plans/*.md 2>/dev/null
+```
+
+- **Build goal:** Ask if implementing an existing plan; load it to avoid duplication
+- **Plan goal:** Surface existing plans to prevent redundant work
+- **Research / Fix:** Proceed without plan check
+
+### Step 3: Confirm Resource Allocation
+
+Present options and confirm before spawning:
+
+```
+How would you like to allocate resources?
+
+- Conservative — 1-2 agents, sequential (minimal context, simple tasks)
+- Balanced (recommended) — appropriate agents for the task, some parallelism
+- Aggressive — max parallel agents (time-critical tasks)
+- Auto — system decides based on complexity
+```
+
+Default to **Balanced** for unspecified or Auto selection.
+
+### Step 4: Map Goal to Agent
+
+| Goal | Primary Agent Type | Description |
+|------|-------------------|-------------|
+| Research | general-purpose (research mode) | Multi-source research using web and documentation tools |
+| Plan | Plan | Create phased implementation plans with architectural trade-offs |
+| Build | general-purpose (implementation mode) | Coding tasks, feature implementation, component creation |
+| Fix | general-purpose (debug mode) → then implementation | Investigate first, implement fix after diagnosis |
+
+**Fix workflow (two stages):**
+1. Spawn debug agent to investigate: produce diagnosis and recommended fix
+2. If fix requires code changes, spawn implementation agent with the diagnosis as context
+
+### Step 5: Show Execution Summary and Confirm
+
+```
+## Execution Summary
+
+Goal: [Research / Plan / Build / Fix]
+Resource Allocation: [Conservative / Balanced / Aggressive]
+Agent(s) to dispatch: [agent descriptions]
+
+What will happen:
+- [Brief description of each agent's task]
+- [Expected output / deliverable and where it will be written]
+
+Proceed? [Yes / Adjust settings]
+```
+
+Wait for confirmation before dispatching. If "Adjust settings", return to the relevant step.
+
+### Step 6: Dispatch Agents
+
+#### Research
+
+```
+Dispatch: general-purpose agent (research mode)
+
+Prompt:
+  Research: [topic]
+  Scope: [what to investigate — libraries, APIs, patterns, concepts]
+  Output: Write findings to research/[topic-slug].md and summarize key points
+```
+
+#### Plan
+
+```
+Dispatch: Plan agent
+
+Prompt:
+  Create implementation plan for: [feature/task]
+  Context: [relevant codebase context, constraints, goals]
+  Output: Save plan to docs/plans/[plan-slug].md with phased breakdown and trade-offs
+```
+
+#### Build
+
+If a plan exists, summarize risks before dispatching:
+- Identify any HIGH severity blockers (missing dependencies, ambiguous interfaces)
+- Surface them to the user before proceeding
+
+```
+Dispatch: general-purpose agent (implementation mode)
+
+Prompt:
+  Implement: [task]
+  Plan: [path to plan, if applicable]
+  Constraints: [language, framework, test requirements]
+  Output: Working implementation with tests passing; write handoff to handoffs/[session]/
+```
+
+#### Fix (two stages)
+
+```
+Stage 1 — Dispatch: general-purpose agent (debug mode)
+
+Prompt:
+  Investigate: [issue description]
+  Symptoms: [what's failing, error messages, test output]
+  Output: Diagnosis document with root cause and recommended fix path
+
+Stage 2 — (after diagnosis) Dispatch: general-purpose agent (implementation mode)
+
+Prompt:
+  Fix: [issue as diagnosed]
+  Diagnosis: [diagnosis document path]
+  Output: Working fix with tests passing
+```
+
+## Handoff Preservation
+
+Each dispatched agent should write a handoff before completing:
+```
+handoffs/{session-id}/{agent-type}-{timestamp}.md
+```
+
+The handoff captures: what was accomplished, what was found, decisions made, open questions, and what the next agent needs to know.
+
+## Output
+
+A confirmation message showing:
+- Which agent(s) were dispatched
+- Their assigned prompts
+- Expected output locations
+- Status after dispatch completes