Claude-Code-Workflow/.claude/commands/workflow/brainstorm/auto-parallel.md

name: auto-parallel description: Parallel brainstorming automation with dynamic role selection and concurrent execution argument-hint: "topic or challenge description" [--count N] allowed-tools: SlashCommand(), Task(), TodoWrite(), Read(), Write(), Bash(), Glob(*)

Workflow Brainstorm Parallel Auto Command

Usage

/workflow:brainstorm:auto-parallel "<topic>" [--count N]

Parameters:

• topic (required): Topic or challenge description
• --count N (optional): Number of roles to auto-select (default: 3, max: 9)

Role Selection Logic

• Technical & Architecture: architecture|system|performance|database|security → system-architect, data-architect, security-expert, subject-matter-expert
• API & Backend: api|endpoint|rest|graphql|backend|interface|contract|service → api-designer, system-architect, data-architect
• Product & UX: user|ui|ux|interface|design|product|feature|experience → ui-designer, user-researcher, product-manager, ux-expert, product-owner
• Business & Process: business|process|workflow|cost|innovation|testing → business-analyst, innovation-lead, test-strategist
• Agile & Delivery: agile|sprint|scrum|team|collaboration|delivery → scrum-master, product-owner
• Domain Expertise: domain|standard|compliance|expertise|regulation → subject-matter-expert
• Multi-role: Complex topics automatically select N complementary roles (N specified by --count, default 3)
• Default: product-manager if no clear match
• Count Parameter: --count N determines number of roles to auto-select (default: 3, max: 9)

Template Loading: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/<role-name>.md")) Template Source: .claude/workflows/cli-templates/planning-roles/ Available Roles: api-designer, data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert

Example:

bash($(cat "~/.claude/workflows/cli-templates/planning-roles/system-architect.md"))
bash($(cat "~/.claude/workflows/cli-templates/planning-roles/ui-designer.md"))

Core Workflow

Structured Topic Processing → Role Analysis → Synthesis

The command follows a structured three-phase approach with dedicated document types:

Phase 1: Framework Generation ⚠️ COMMAND EXECUTION

• Role selection: Auto-select N roles based on topic keywords and --count parameter (default: 3, see Role Selection Logic)
• Call artifacts command: Execute /workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,...,roleN}" using SlashCommand tool
• Role-specific framework: Generate framework with sections tailored to selected roles

Phase 2: Role Analysis Execution ⚠️ PARALLEL AGENT ANALYSIS

• Parallel execution: Multiple roles execute simultaneously for faster completion
• Independent agents: Each role gets dedicated conceptual-planning-agent running in parallel
• Shared framework: All roles reference the same topic framework for consistency
• Concurrent generation: Role-specific analysis documents generated simultaneously
• Progress tracking: Parallel agents update progress independently

Phase 3: Synthesis Generation ⚠️ COMMAND EXECUTION

• Call synthesis command: Execute /workflow:brainstorm:synthesis using SlashCommand tool

Implementation Standards

Simplified Command Orchestration ⚠️ STREAMLINED

Auto command coordinates independent specialized commands:

Command Sequence:

1. Role Selection: Auto-select N relevant roles based on topic keywords and --count parameter (default: 3)
2. Generate Role-Specific Framework: Use SlashCommand to execute /workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,...,roleN}"
3. Parallel Role Analysis: Execute selected role agents in parallel, each reading their specific framework section
4. Generate Synthesis: Use SlashCommand to execute /workflow:brainstorm:synthesis

SlashCommand Integration:

1. artifacts command: Called via SlashCommand tool with --roles parameter for role-specific framework generation
2. role agents: Each agent reads its dedicated section in the role-specific framework
3. synthesis command: Called via SlashCommand tool for final integration with role-targeted insights
4. Command coordination: SlashCommand handles execution and validation

Role Selection Logic:

• Technical: architecture|system|performance|database → system-architect, data-architect, subject-matter-expert
• API & Backend: api|endpoint|rest|graphql|backend|interface|contract|service → api-designer, system-architect, data-architect
• Product & UX: user|ui|ux|interface|design|product|feature|experience → ui-designer, ux-expert, product-manager, product-owner
• Agile & Delivery: agile|sprint|scrum|team|collaboration|delivery → scrum-master, product-owner
• Domain Expertise: domain|standard|compliance|expertise|regulation → subject-matter-expert
• Auto-select: N most relevant roles based on topic analysis (N from --count parameter, default: 3)

Parameter Parsing

Count Parameter Handling:

# Parse --count parameter from user input
IF user_input CONTAINS "--count":
    EXTRACT count_value FROM "--count N" pattern
    IF count_value > 9:
        count_value = 9  # Cap at maximum 9 roles
    END IF
ELSE:
    count_value = 3  # Default to 3 roles
END IF

Role Selection with Count:

1. Analyze topic keywords: Identify relevant role categories
2. Rank roles by relevance: Score based on keyword matches
3. Select top N roles: Pick N most relevant roles (N = count_value)
4. Ensure diversity: Balance across different expertise areas
5. Minimum guarantee: Always include at least one role (default to product-manager if no matches)

Simplified Processing Standards

Core Principles:

1. Minimal preprocessing - Only workflow-session.json and basic role selection
2. Agent autonomy - Agents handle their own context and validation
3. Parallel execution - Multiple agents can work simultaneously
4. Post-processing synthesis - Integration happens after agent completion
5. TodoWrite control - Progress tracking throughout all phases

Implementation Rules:

• Role count: N roles auto-selected based on --count parameter (default: 3, max: 9) and keyword mapping
• No upfront validation: Agents handle their own context requirements
• Parallel execution: Each agent operates concurrently without dependencies
• Synthesis at end: Integration only after all agents complete

Agent Self-Management (Agents decide their own approach):

• Context gathering: Agents determine what questions to ask
• Template usage: Agents load and apply their own role templates
• Analysis depth: Agents determine appropriate level of detail
• Documentation: Agents create their own file structure and content

Session Management ⚠️ CRITICAL

• ⚡ FIRST ACTION: Check for all .workflow/.active-* markers before role processing
• Multiple sessions support: Different Claude instances can have different active brainstorming sessions
• User selection: If multiple active sessions found, prompt user to select which one to work with
• Auto-session creation: WFS-[topic-slug] only if no active session exists
• Session continuity: MUST use selected active session for all role processing
• Context preservation: Each role's context and agent output stored in session directory
• Session isolation: Each session maintains independent brainstorming state and role assignments

Document Generation

Command Coordination Workflow: artifacts → parallel role analysis → synthesis

Output Structure: Coordinated commands generate framework, role analyses, and synthesis documents as defined in their respective command specifications.

Agent Prompt Templates

Task Agent Invocation Template

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: {role-name} perspective for {topic}

     ## Role Assignment
     **ASSIGNED_ROLE**: {role-name}
     **TOPIC**: {user-provided-topic}
     **OUTPUT_LOCATION**: .workflow/WFS-{topic}/.brainstorming/{role}/

     ## Execution Instructions
     [FLOW_CONTROL]

     ### Flow Control Steps
     **AGENT RESPONSIBILITY**: Execute these pre_analysis steps sequentially with context accumulation:

     1. **load_topic_framework**
        - Action: Load structured topic discussion framework
        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/topic-framework.md 2>/dev/null || echo 'Topic framework not found')
        - Output: topic_framework

     2. **load_role_template**
        - Action: Load {role-name} planning template
        - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
        - Output: role_template

     3. **load_session_metadata**
        - Action: Load session metadata and topic description
        - Command: bash(cat .workflow/WFS-{topic}/workflow-session.json 2>/dev/null || echo '{}')
        - Output: session_metadata

     ### Implementation Context
     **Topic Framework**: Use loaded topic-framework.md for structured analysis
     **Role Focus**: {role-name} domain expertise and perspective
     **Analysis Type**: Address framework discussion points from role perspective
     **Template Framework**: Combine role template with topic framework structure
     **Structured Approach**: Create analysis.md addressing all topic framework points

     ### Session Context
     **Workflow Directory**: .workflow/WFS-{topic}/.brainstorming/
     **Output Directory**: .workflow/WFS-{topic}/.brainstorming/{role}/
     **Session JSON**: .workflow/WFS-{topic}/workflow-session.json

     ### Dependencies & Context
     **Topic**: {user-provided-topic}
     **Role Template**: "~/.claude/workflows/cli-templates/planning-roles/{role}.md"
     **User Requirements**: To be gathered through interactive questioning

     ## Completion Requirements
     1. Execute all flow control steps in sequence (load topic framework, role template, session metadata)
     2. **Address Topic Framework**: Respond to all discussion points in topic-framework.md from role perspective
     3. Apply role template guidelines within topic framework structure
     4. Generate structured role analysis addressing framework points
     5. Create single comprehensive deliverable in OUTPUT_LOCATION:
        - analysis.md (structured analysis addressing all topic framework points with role-specific insights)
     6. Include framework reference: @../topic-framework.md in analysis.md
     7. Update workflow-session.json with completion status",
     description="Execute {role-name} brainstorming analysis")

Parallel Role Agent调用示例

# Execute N roles in parallel using single message with multiple Task calls
# (N determined by --count parameter, default 3, shown below with 3 roles as example)

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: {role-1} perspective for {topic}...",
     description="Execute {role-1} brainstorming analysis")

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: {role-2} perspective for {topic}...",
     description="Execute {role-2} brainstorming analysis")

Task(subagent_type="conceptual-planning-agent",
     prompt="Execute brainstorming analysis: {role-3} perspective for {topic}...",
     description="Execute {role-3} brainstorming analysis")

# ... repeat for remaining N-3 roles if --count > 3

Direct Synthesis Process (Command-Driven)

Synthesis execution: Use SlashCommand to execute /workflow:brainstorm:synthesis after role completion

TodoWrite Control Flow ⚠️ CRITICAL

Workflow Progress Tracking

MANDATORY: Use Claude Code's built-in TodoWrite tool throughout entire brainstorming workflow:

// Phase 1: Create initial todo list for command-coordinated brainstorming workflow
TodoWrite({
  todos: [
    {
      content: "Initialize brainstorming session and detect active sessions",
      status: "pending",
      activeForm: "Initializing brainstorming session"
    },
    {
      content: "Parse --count parameter and select N roles based on topic keyword analysis",
      status: "pending",
      activeForm: "Parsing parameters and selecting roles for brainstorming"
    },
    {
      content: "Execute artifacts command with selected roles for role-specific framework",
      status: "pending",
      activeForm: "Generating role-specific topic framework"
    },
    {
      content: "Execute [role-1] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
      status: "pending",
      activeForm: "Executing [role-1] structured framework analysis"
    },
    {
      content: "Execute [role-2] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
      status: "pending",
      activeForm: "Executing [role-2] structured framework analysis"
    },
    // ... repeat for N roles (N determined by --count parameter, default 3)
    {
      content: "Execute [role-N] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
      status: "pending",
      activeForm: "Executing [role-N] structured framework analysis"
    },
    {
      content: "Execute synthesis command using SlashCommand for final integration",
      status: "pending",
      activeForm: "Executing synthesis command for integrated analysis"
    }
  ]
});

// Phase 2: Update status as workflow progresses - ONLY ONE task should be in_progress at a time
TodoWrite({
  todos: [
    {
      content: "Initialize brainstorming session and detect active sessions",
      status: "completed",  // Mark completed preprocessing
      activeForm: "Initializing brainstorming session"
    },
    {
      content: "Select roles for topic analysis and create workflow-session.json",
      status: "in_progress",  // Mark current task as in_progress
      activeForm: "Selecting roles and creating session metadata"
    },
    // ... other tasks remain pending
  ]
});

// Phase 3: Parallel agent execution tracking (N roles, N from --count parameter)
TodoWrite({
  todos: [
    // ... previous completed tasks
    {
      content: "Execute [role-1] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing [role-1] brainstorming analysis"
    },
    {
      content: "Execute [role-2] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing [role-2] brainstorming analysis"
    },
    // ... repeat for remaining N-2 roles
    {
      content: "Execute [role-N] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
      status: "in_progress",  // Executing in parallel
      activeForm: "Executing [role-N] brainstorming analysis"
    }
  ]
});

TodoWrite Integration Rules:

1. Create initial todos: All workflow phases at start
2. Mark in_progress: Multiple parallel tasks can be in_progress simultaneously
3. Update immediately: After each task completion
4. Track agent execution: Include [agent-type] and [FLOW_CONTROL] markers for parallel agents
5. Final synthesis: Mark synthesis as in_progress only after all parallel agents complete

Reference Information

Structured Processing Schema

Each role processing follows structured framework pattern:

• topic_framework: Structured discussion framework document
• role: Selected planning role name with framework reference
• agent: Dedicated conceptual-planning-agent instance
• structured_analysis: Agent addresses all framework discussion points
• output: Role-specific analysis.md addressing topic framework structure

File Structure Reference

Architecture: @/.claude/workflows/workflow-architecture.md Role Templates: @/.claude/workflows/cli-templates/planning-roles/

Execution Integration

Command coordination model: artifacts command → parallel role analysis → synthesis command

Error Handling

• Role selection failure: Default to product-manager with explanation
• Agent execution failure: Agent-specific retry with minimal dependencies
• Template loading issues: Agent handles graceful degradation
• Synthesis conflicts: Synthesis agent highlights disagreements without resolution

Quality Standards

Agent Autonomy Excellence

• Single role focus: Each agent handles exactly one role independently
• Self-contained execution: Agent manages own context, validation, and output
• Parallel processing: Multiple agents can execute simultaneously
• Complete ownership: Agent produces entire role-specific analysis package

Minimal Coordination Excellence

• Lightweight handoff: Only topic and role assignment provided
• Agent self-management: Agents handle their own workflow and validation
• Concurrent operation: No inter-agent dependencies enabling parallel execution
• Reference-based synthesis: Post-processing integration without content duplication
• TodoWrite orchestration: Progress tracking and workflow control throughout entire process