Workflow Creator Skill

ROUTER UPDATE REQUIRED (CRITICAL - DO NOT SKIP)

### {Workflow Name}

**Path:** `.claude/workflows/{category}/{workflow-name}.md`

**When to use:** {Trigger conditions}

**Phases:**

1. **{Phase Name}** - {Description}
   ...

**Agents Involved:**

- `{agent-name}` - {Role in workflow}

grep "{workflow-name}" .claude/CLAUDE.md || echo "ERROR: CLAUDE.md SECTION 8.6 NOT UPDATED!"

When This Skill Is Triggered

1. User requests complex orchestration requiring multiple agents
2. Repeatable multi-phase process needs standardization
3. Router identifies workflow gap for common task pattern
4. Existing workflow needs enhancement or customization

Quick Reference

Glob: .claude/workflows/**/*.md

.claude/templates/workflows/workflow-template.md

Glob: .claude/agents/**/*.md

Glob: .claude/skills/*/SKILL.md

.claude/workflows/<category>/<name>.md

Workflow Types

.claude/workflows/enterprise/

.claude/workflows/operations/

.claude/workflows/rapid/

.claude/workflows/

Workflow-Agent Archetype Reference

.claude/docs/@WORKFLOW_AGENT_MAP.md

• Section 1: Full workflow-agent matrix
• Section 2: Archetype workflow sets (Router/Orchestrator, Implementer, Reviewer, Documenter, Researcher, Domain)

## Related Workflows

Workflow Creation Process

Step 0: Existence Check and Updater Delegation (MANDATORY - FIRST STEP)

1. Check if workflow already exists:
   bash

   test -f .claude/workflows/<category>/<workflow-name>.md && echo "EXISTS" || echo "NEW"

2. If workflow EXISTS:
   • DO NOT proceed with creation
   • Invoke artifact-updater workflow instead:
     javascript

     Skill({
       skill: 'artifact-updater',
       args: {
         name: '<workflow-name>',
         changes: '<description of requested changes>',
         justification: 'Update requested via workflow-creator',
       },
     });

   • Return updater result and STOP
3. If workflow is NEW:
   • Continue with Step 0.5 below

Step 0.5: Companion Check

1. Use

   companion-check.cjs

   from

   .claude/lib/creators/companion-check.cjs

2. Call

   checkCompanions("workflow", "{workflow-name}")

   to identify companion artifacts
3. Review the companion checklist — note which required/recommended companions are missing
4. Plan to create or verify missing companions after this artifact is complete
5. Include companion findings in post-creation integration notes

Step 1: Verify No Existing Workflow

# Search for relevant workflows
Glob: .claude/workflows/**/*.md
Grep: "<topic>" in .claude/workflows/

Step 2.5: Workflow Pattern Research (MANDATORY)

Glob: .claude/workflows/**/*.md

WebSearch({ query: '[workflow-type] orchestration best practices' });
WebSearch({ query: '[domain] multi-agent workflow patterns' });

Step 2: Identify Phases and Agents

Step 3: Define Agent Handoffs

### Phase 1 -> Phase 2 Handoff

**Output from Phase 1**: .claude/context/plans/phase1-output.md
**Input to Phase 2**: Read output from Phase 1
**Handoff validation**: [Check output exists and is valid]

Step 4: Generate Workflow Definition

.claude/workflows/<category>/<workflow-name>.md

---
name: { workflow-name }
description: { Brief description of workflow purpose }
version: 1.0.0
agents:
  - { agent-1 }
  - { agent-2 }
tags: [{ tag1 }, { tag2 }, workflow]
---

# {Workflow Title}

{Brief description of workflow purpose and when to use it.}

**Extended Thinking**: {Detailed explanation of workflow rationale, approach, and design decisions.}

## Overview

{Detailed description of what this workflow accomplishes.}

## Configuration Options

### {Option Category 1}

- **{value_1}**: {Description}
- **{value_2}**: {Description}

## Phase 1: {Phase Name}

### Step 1: {Step Name}

**Agent**: {agent-name}

**Task Spawn**:

```javascript
Task({
  task_id: 'task-1',
  subagent_type: 'general-purpose',
  description: '{Task description}',
  prompt: `You are the {AGENT_NAME} agent.

## Task
{Task description}

## Instructions
1. Read your agent definition: .claude/agents/{category}/{agent}.md
2. **Invoke skills**: Skill({ skill: "{skill-name}" })
3. {Additional instructions}
4. Save output to: .claude/context/{output-path}

## Context
- {Context item 1}
- {Context item 2}

## Memory Protocol
1. Read .claude/context/memory/learnings.md first
2. Record decisions to .claude/context/memory/decisions.md
`,
});
```

Phase 2: {Phase Name}

Step 2: {Step Name} (Parallel)

// Spawn both agents in parallel for efficiency
Task({
  task_id: 'task-2',
  subagent_type: 'general-purpose',
  description: '{Agent A task}',
  prompt: `You are {AGENT_A}...`,
});

Task({
  task_id: 'task-3',
  subagent_type: 'general-purpose',
  description: '{Agent B task}',
  prompt: `You are {AGENT_B}...`,
});

Error Recovery

If Phase 1 fails:

1. {Recovery step}
2. Restart Phase 1

If Phase 2 review finds blockers:

1. {Recovery step}
2. Re-run reviews

Success Criteria

• {Criterion 1}
• {Criterion 2}
• All agents completed their phases
• Memory files updated

Usage Example

// Router spawning workflow orchestrator
Task({
  task_id: 'task-4',
  subagent_type: 'general-purpose',
  description: 'Orchestrating {workflow-name} workflow',
  prompt: `Execute {workflow-name} workflow.

## Parameters
- {Parameter 1}
- {Parameter 2}

## Instructions
Follow the phased workflow in: .claude/workflows/{category}/{workflow-name}.md
`,
});

### Step 5: Validate Workflow References (BLOCKING)

**Before writing workflow file, verify ALL references are valid:**

| Reference | Validation |
|-----------|-----------|
| Agent files | All agents in `agents:` array exist in `.claude/agents/` |
| Skills | All skills referenced in prompts exist in `.claude/skills/` |
| Output paths | All output directories exist or will be created |
| Context files | All context files referenced are accessible |

**Validation checklist before writing:**

**BLOCKING**: Do not write workflow file if any reference is invalid.

### Step 5.5: Model and Tool Validation (CRITICAL)

**Model Validation for Agent Spawns (CRITICAL):**

When workflow templates spawn agents via Task tool:
- model field MUST be base name only: `haiku`, `sonnet`, or `opus`
- DO NOT use dated versions like `claude-opus-4-5-20251101`
- Choose model based on task complexity:
  - `haiku`: Quick validation, simple tasks
  - `sonnet`: Standard work (default)
  - `opus`: Complex reasoning, architecture

**Example:**
```javascript
// CORRECT
Task({
  task_id: 'task-5',
  model: 'sonnet',
  // ...
});

// WRONG - causes validation failures
Task({
  task_id: 'task-6',
  model: 'claude-sonnet-4-20250514',
  // ...
});

• Use standard tools: Read, Write, Edit, Bash, TaskUpdate, TaskList, etc.
• DO NOT include MCP tools (mcp__*) unless whitelisted in routing-table.cjs
• MCP tools cause router enforcement failures

allowed_tools: [
  'Read',
  'Write',
  'Edit',
  'Bash',
  'TaskUpdate',
  'TaskList',
  'TaskCreate',
  'TaskGet',
  'Skill',
];

• mcp__Exa__*

  - Only for evolution-orchestrator

• mcp__github__*

  - Only for specific GitHub operations
• Other MCP tools - Must be whitelisted in routing-table.cjs

[ ] Model field uses base name (haiku/sonnet/opus)
[ ] allowed_tools contains only standard tools OR explicitly whitelisted MCP tools
[ ] No dated model versions (e.g., claude-opus-4-5-20251101)

Step 6: Update CLAUDE.md Section 8.6 (MANDATORY - BLOCKING)

1. Find Section 8.6 ("ENTERPRISE WORKFLOWS")
2. Generate workflow entry in this format:

### {Workflow Name}

**Path:** `.claude/workflows/{category}/{workflow-name}.md`

**When to use:** {Trigger conditions - be specific}

**Phases:**

1. **{Phase 1 Name}** - {Brief description}
2. **{Phase 2 Name}** - {Brief description}
   ...

**Configuration Options:**

- {Option category}: `{values}`

**Agents Involved:**

- `{agent-name}` - {Role description}

1. Insert in appropriate location (alphabetical or at end of section)
2. Verify with:

grep "{workflow-name}" .claude/CLAUDE.md || echo "ERROR: CLAUDE.md NOT UPDATED - BLOCKING!"

Step 7: System Impact Analysis (BLOCKING)

[WORKFLOW-CREATOR] System Impact Analysis for: <workflow-name>

1. CLAUDE.md UPDATE (MANDATORY)
   - Add entry to Section 8.6 (Enterprise Workflows)
   - Add to Section 3 (Multi-Agent Workflows) if referenced by Router
   - Verify with grep

2. AGENT COORDINATION CHECK
   - Do all agents referenced exist?
   - Do agents need new skills for this workflow?
   - Should any agent's definition reference this workflow?

3. SKILL AVAILABILITY CHECK
   - Are all skills referenced available?
   - Does this workflow need new skills? -> Invoke skill-creator
   - Should existing skills be enhanced?

4. MEMORY INTEGRATION CHECK
   - Does workflow use Memory Protocol?
   - Are output paths writable?
   - Will artifacts be properly persisted?

5. RELATED WORKFLOW CHECK
   - Does this duplicate existing workflow functionality?
   - Should existing workflows reference this one?
   - Are there workflow dependencies to document?

6. WORKFLOW-AGENT MAP UPDATED (MANDATORY)
   - Added new workflow to @WORKFLOW_AGENT_MAP.md Section 1 matrix
   - Determined which agent archetypes use this workflow
   - Updated affected agents' `## Related Workflows` sections
   - Verified: `grep "<workflow-name>" .claude/docs/@WORKFLOW_AGENT_MAP.md || echo "ERROR: Workflow not in agent map!"`

Validation Checklist (Run After Every Creation) - BLOCKING

# Validate workflow file exists
ls .claude/workflows/<category>/<workflow-name>.md

# Verify all referenced agents exist
for agent in $(grep -oE '\\.claude/agents/[^"]+\\.md' .claude/workflows/<category>/<workflow>.md); do
  [ -f "$agent" ] || echo "BROKEN: $agent"
done

# Verify all referenced skills exist
for skill in $(grep -oE 'skill: "[^"]+"' .claude/workflows/<category>/<workflow>.md | cut -d'"' -f2); do
  [ -f ".claude/skills/$skill/SKILL.md" ] || echo "BROKEN: $skill"
done

# Check CLAUDE.md has workflow entry - MANDATORY
grep "<workflow-name>" .claude/CLAUDE.md || echo "ERROR: Not in CLAUDE.md - WORKFLOW CREATION INCOMPLETE"

[ ] Workflow pattern research completed (Step 2.5)
[ ] Workflow file created at .claude/workflows/<category>/<name>.md
[ ] All referenced agents exist in .claude/agents/
[ ] All referenced skills exist in .claude/skills/
[ ] Model fields use base names only (haiku/sonnet/opus)
[ ] allowed_tools arrays contain only standard or whitelisted tools
[ ] CLAUDE.md Section 8.6 updated
[ ] Workflow entry verified with grep
[ ] Memory Protocol included in all agent prompts

Step 8: Post-Creation Workflow Registration (Phase 3 Integration)

1. Create/Update Workflow Registry Entry in appropriate location:
   If registry doesn't exist, create

   .claude/context/artifacts/catalogs/workflow-registry.json

   :
   json

   {
     "workflows": [
       {
         "name": "{workflow-name}",
         "id": "{workflow-name}",
         "description": "{Brief description from workflow}",
         "category": "{enterprise|core|operations}",
         "version": "1.0.0",
         "triggerConditions": ["{Condition 1}", "{Condition 2}"],
         "participatingAgents": ["{agent-1}", "{agent-2}"],
         "phases": [
           { "name": "{Phase 1 Name}", "description": "{Brief description}" },
           { "name": "{Phase 2 Name}", "description": "{Brief description}" }
         ],
         "filePath": ".claude/workflows/{category}/{workflow-name}.md",
         "orchestratorReferences": []
       }
     ]
   }

2. Register with Appropriate Orchestrator:
   Update the orchestrator that should use this workflow:
   • master-orchestrator.md: Meta-workflows coordinating other workflows
   • evolution-orchestrator.md: EVOLVE phase workflows (research, creation, validation)
   • party-orchestrator.md: Consensus/voting workflows
   • swarm-coordinator.md: Coordination workflows
   Add to orchestrator's workflow references:
   markdown

   ## Available Workflows
   
   - `{workflow-name}` (.claude/workflows/{category}/{workflow-name}.md)

3. Document in

   .claude/docs/WORKFLOW_CATALOG.md

   :
   If catalog doesn't exist, create it. Add entry:
   markdown

   ### {Workflow Title}
   
   **Path:** `.claude/workflows/{category}/{workflow-name}.md`
   
   **When to use:** {Trigger conditions - specific scenarios}
   
   **Participating Agents:**
   
   - {agent-1}: {role in workflow}
   - {agent-2}: {role in workflow}
   
   **Phases:**
   
   1. **{Phase 1 Name}** - {Description}
   2. **{Phase 2 Name}** - {Description}
   
   **Orchestrator Integration:**
   
   - Invoked by: {orchestrator-name}
   - Trigger: {How orchestrator discovers/triggers this}

4. Verify Workflow Discoverability:
   Test that the workflow can be discovered:
   bash

   # Check workflow registry exists and is valid JSON
   node -e "console.log(JSON.stringify(require('./.claude/context/artifacts/catalogs/workflow-registry.json'), null, 2))"
   
   # Verify orchestrator references it
   grep "{workflow-name}" .claude/agents/orchestrators/*-orchestrator.md

5. Update Memory:
   Append to

   .claude/context/memory/learnings.md

   :
   markdown

   ## Workflow: {workflow-name}
   
   - **Purpose:** {Workflow purpose}
   - **Orchestrator:** {Which orchestrator uses it}
   - **Key Pattern:** {Key pattern discovered}
   - **Integration Notes:** {Any special integration considerations}

• Orchestrators cannot discover available workflows
• Workflows cannot be dynamically selected for complex tasks
• System loses visibility into workflow network
• "Invisible artifact" pattern emerges

Step 9: Integration Verification (BLOCKING - DO NOT SKIP)

TaskUpdate({ status: "completed" })

1. Run the 10-item integration checklist:
   bash

   node .claude/tools/cli/validate-integration.cjs .claude/workflows/<category>/<workflow-name>.md

2. Verify exit code is 0 (all checks passed)
3. If exit code is 1 (one or more checks failed):
   • Read the error output for specific failures
   • Fix each failure:
     • Missing CLAUDE.md entry -> Add to Section 8.6
     • Missing workflow registry -> Create registry entry (Step 8)
     • Missing orchestrator reference -> Add to orchestrator definition
     • Missing memory update -> Update learnings.md
   • Re-run validation until exit code is 0
4. Only proceed when validation passes

.claude/workflows/core/post-creation-validation.md

Iron Laws of Workflow Creation

1. NO WORKFLOW WITHOUT AGENT VALIDATION
   - Every agent referenced must exist in .claude/agents/
   - Verify with: ls .claude/agents/<category>/<agent>.md

2. NO WORKFLOW WITHOUT SKILL VALIDATION
   - Every skill referenced must exist in .claude/skills/
   - Verify with: ls .claude/skills/<skill>/SKILL.md

3. NO PARALLEL EXECUTION WITHOUT INDEPENDENCE
   - Only spawn agents in parallel if their work is independent
   - Dependent work must be sequential

4. NO HANDOFF WITHOUT OUTPUT SPECIFICATION
   - Every phase must specify its output location
   - Every phase must specify what it reads from previous phases

5. NO WORKFLOW WITHOUT MEMORY PROTOCOL
   - Every agent prompt must include Memory Protocol section
   - Without it, learnings and decisions are lost

6. NO CREATION WITHOUT CLAUDE.MD UPDATE
   - After creating workflow, add to Section 8.6
   - Unregistered workflows are never invoked by Router

7. NO CREATION WITHOUT SYSTEM IMPACT ANALYSIS
   - Check if new agents are needed
   - Check if new skills are needed
   - Update @WORKFLOW_AGENT_MAP.md with new workflow row (MANDATORY)
   - Update affected agents' Related Workflows sections (MANDATORY)
   - Document all system changes made

8. NO AGENT SPAWN WITHOUT MODEL VALIDATION
   - model field MUST be base name only: haiku, sonnet, or opus
   - DO NOT use dated versions like claude-opus-4-5-20251101
   - Dated versions cause validation failures

9. NO AGENT SPAWN WITH UNRESTRICTED MCP TOOLS
   - Use standard tools: Read, Write, Edit, Bash, TaskUpdate, etc.
   - MCP tools (mcp__*) require explicit whitelisting
   - Unwhitelisted MCP tools cause router enforcement failures

10. NO WORKFLOW WITHOUT PATTERN RESEARCH
    - Research existing workflow patterns before creating new ones
    - Minimum 2 WebSearch queries for domain patterns
    - Document patterns found in workflow comments

Workflow Integration

.claude/workflows/core/router-decision.md

• How the Router discovers and invokes this skill's artifacts

.claude/workflows/core/skill-lifecycle.md

• Discovery, creation, update, deprecation phases
• Version management and registry updates
• CLAUDE.md integration requirements

.claude/workflows/core/external-integration.md

• Safe integration of external artifacts
• Security review and validation phases

Cross-Reference: Creator Ecosystem

.claude/agents/

Skill({ skill: 'agent-creator' })

.claude/skills/

Skill({ skill: 'skill-creator' })

.claude/hooks/

.claude/templates/

.claude/schemas/

Integration Workflow

// 1. Workflow created but needs new agent
Skill({ skill: 'agent-creator' });
// Create the agent, then update workflow's agents: array

// 2. Workflow needs new skill
Skill({ skill: 'skill-creator' });
// Create the skill, then reference in workflow prompts

// 3. Workflow needs hooks for critical steps
// Create hooks in .claude/hooks/workflows/<workflow-name>/
// Reference in workflow's hooks: section

Post-Creation Checklist for Ecosystem Integration

[ ] Does workflow need agents that don't exist? -> Use agent-creator
[ ] Does workflow need skills that don't exist? -> Use skill-creator
[ ] Does workflow need entry/exit hooks? -> Create hooks
[ ] Does workflow need input validation? -> Create schemas
[ ] Should workflow be part of larger orchestration? -> Update master-orchestrator
[ ] Run post-creation validation -> node .claude/tools/cli/validate-integration.cjs .claude/workflows/<category>/<workflow-name>.yaml

Examples

Example 1: Creating Feature Development Workflow

1. Identify phases: Discovery -> Architecture -> Implementation -> Testing -> Deployment
2. Assign agents: planner -> architect + security-architect -> developer -> qa -> devops
3. Define handoffs: Each phase outputs to

   .claude/context/plans/feature-<name>/

4. Reference: See

   .claude/workflows/enterprise/feature-development-workflow.md

Example 2: Creating Incident Response Workflow

1. Identify phases: Triage -> Investigation -> Resolution -> Post-mortem
2. Assign agents: incident-responder -> devops-troubleshooter + developer -> devops -> planner
3. Define handoffs: Each phase outputs to

   .claude/context/incidents/

4. Create:

   .claude/workflows/operations/incident-response.md

Example 3: Creating C4 Architecture Workflow

1. Identify phases: Code Analysis -> Component Synthesis -> Container Mapping -> Context Documentation
2. Assign agents: c4-code -> c4-component -> c4-container -> c4-context
3. Define handoffs: Bottom-up, each level builds on previous documentation
4. Reference: See

   .claude/workflows/enterprise/c4-architecture-workflow.md

Workflow Template Quick Reference

.claude/templates/workflows/workflow-template.md

1. YAML Frontmatter: name, description, version, agents, tags
2. Overview: Purpose and when to use
3. Configuration Options: Customizable parameters
4. Phases: Sequential or parallel execution blocks
5. Task Spawns: Actual Task() calls with full prompts
6. Error Recovery: What to do when phases fail
7. Success Criteria: How to verify workflow completed successfully
8. Usage Example: How Router should invoke the workflow

Architecture Compliance

File Placement (ADR-076)

• Workflows:

  .claude/workflows/{category}/

  (core, enterprise, operations, creators)
• Tests:

  tests/

  (NOT in .claude/)
• Related agents:

  .claude/agents/{category}/

• Related skills:

  .claude/skills/{name}/

• Related templates:

  .claude/templates/

Documentation References (CLAUDE.md v2.2.1)

• Reference files use @notation: @ENTERPRISE_WORKFLOWS.md, @AGENT_ROUTING_TABLE.md
• Located in:

  .claude/docs/@*.md

• See: CLAUDE.md Section 8.6 (ENTERPRISE WORKFLOWS reference)

Shell Security (ADR-077)

• Workflow spawn templates must include:

  cd "$PROJECT_ROOT" || exit 1

  for background tasks
• Environment variables control validators (block/warn/off mode)
• See: .claude/docs/SHELL-SECURITY-GUIDE.md
• Apply to: agent spawn prompts, task execution examples

Recent ADRs

• ADR-075: Router Config-Aware Model Selection
• ADR-076: File Placement Architecture Redesign
• ADR-077: Shell Command Security Architecture

File Placement & Standards

Output Location Rules

.claude/workflows/<category>/

• core/

  - Essential workflows (router-decision, skill-lifecycle)

• enterprise/

  - Complex multi-agent flows (feature-development)

• operations/

  - Operational procedures (incident-response)

• creators/

  - Creator workflow YAML files

Mandatory References

• File Placement: See

  .claude/docs/FILE_PLACEMENT_RULES.md

• Developer Workflow: See

  .claude/docs/DEVELOPER_WORKFLOW.md

• Artifact Naming: See

  .claude/docs/ARTIFACT_NAMING.md

Enforcement

file-placement-guard.cjs

Memory Protocol (MANDATORY)

cat .claude/context/memory/learnings.md

• Previously created workflows
• Workflow patterns that worked well
• Issues with existing workflows

• New workflow created -> Append to

  .claude/context/memory/learnings.md

• Workflow issue found -> Append to

  .claude/context/memory/issues.md

• Architecture decision -> Append to

  .claude/context/memory/decisions.md

ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.

Post-Creation Integration

1. Call

   runIntegrationChecklist(artifactType, artifactPath)

   from

   .claude/lib/creators/creator-commons.cjs

2. Call

   queueCrossCreatorReview(artifactType, artifactPath)

   from

   .claude/lib/creators/creator-commons.cjs

3. Review the impact report — address all

   mustHave

   items before marking task complete
4. Log any

   shouldHave

   items as follow-up tasks

• Workflow added to @WORKFLOW_AGENT_MAP.md
• Workflow referenced in CLAUDE.md (if enterprise workflow)
• Workflow assigned to at least one agent
• Workflow catalog entry added (if applicable)