# Batch Super-Dev - Interactive Story Selector
## AKA: "Mend the Gap" 🚇

**Primary Use Case:** Gap analysis and reconciliation workflow

This workflow helps you "mind the gap" between story requirements and codebase reality, then "mend the gap" by building only what's truly missing.

### What This Workflow Does

1. **Scans codebase** to verify what's actually implemented vs what stories claim
2. **Finds the gap** between story requirements and reality
3. **Mends the gap** by building ONLY what's truly missing (no duplicate work)
4. **Updates tracking** to reflect actual completion status (check boxes, sprint-status)

### Common Use Cases

**Reconciliation Mode (Most Common):**
- Work was done but not properly tracked
- Stories say "build X" but X is 60-80% already done
- Need second set of eyes to find real gaps
- Update story checkboxes to match reality

**Greenfield Mode:**
- Story says "build X", nothing exists
- Build 100% from scratch with full quality gates

**Brownfield Mode:**
- Story says "modify X", X exists
- Refactor carefully, add only new requirements

### Execution Modes

**Sequential (Recommended for Gap Analysis):**
- Process stories ONE-BY-ONE in THIS SESSION
- After each story: verify existing code → build only gaps → check boxes → move to next
- Easier to monitor, can intervene if issues found
- Best for reconciliation work

**Parallel (For Greenfield Batch Implementation):**
- Spawn autonomous Task agents to process stories concurrently
- Faster completion but harder to monitor
- Best when stories are independent and greenfield

<critical>The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml</critical>
<critical>You MUST have already loaded and processed: {project-root}/_bmad/bmm/workflows/4-implementation/batch-super-dev/workflow.yaml</critical>

<workflow>

<step n="1" goal="Load and parse sprint-status.yaml">
  <action>Read {sprint_status} file</action>
  <action>Parse metadata: project, project_key, tracking_system</action>
  <action>Parse development_status map</action>

  <action>Filter stories with status = "ready-for-dev"</action>
  <action>Exclude entries that are epics (keys starting with "epic-") or retrospectives (keys ending with "-retrospective")</action>

  <check if="filter_by_epic is not empty">
    <action>Further filter stories to only include those starting with "{filter_by_epic}-"</action>
    <example>If filter_by_epic = "3", only include stories like "3-1-...", "3-2-...", etc.</example>
  </check>

  <action>Sort filtered stories by epic number, then story number (e.g., 1-1, 1-2, 2-1, 3-1)</action>
  <action>Store as: ready_for_dev_stories (list of story keys)</action>

  <check if="ready_for_dev_stories is empty">
    <output>✅ No ready-for-dev stories found.

All stories are either in-progress, review, or done!

Run `/bmad:bmm:workflows:sprint-status` to see current status.</output>
    <action>Exit workflow</action>
  </check>
</step>

<step n="2" goal="Display available stories with details">
  <action>Read comment field for each story from sprint-status.yaml (text after # on the same line)</action>

  <action>For each story, verify story file exists using multiple naming patterns:</action>
  <action>Try in order: 1) {sprint_artifacts}/{story_key}.md, 2) {sprint_artifacts}/story-{story_key}.md, 3) {sprint_artifacts}/{story_key_with_dots}.md</action>
  <action>Mark stories as: ✅ (file exists), ❌ (file missing), 🔄 (already implemented but not marked done)</action>

  <output>
## 📦 Ready-for-Dev Stories ({{count}})

{{#if filter_by_epic}}
**Filtered by Epic {{filter_by_epic}}**
{{/if}}

{{#each ready_for_dev_stories}}
{{@index}}. **{{key}}** {{file_status_icon}}
   {{#if comment}}→ {{comment}}{{/if}}
   {{#if file_path}}   File: {{file_path}}{{/if}}
{{/each}}

---
**Legend:**
- ✅ Story file exists, ready to implement
- 🔄 Already implemented, just needs status update
- ❌ Story file missing, needs creation first

**Total:** {{count}} stories available
**Max batch size:** {{max_stories}} stories
  </output>
</step>

<step n="2.5" goal="Validate and create/regenerate stories as needed">
  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔍 VALIDATING STORY FILES
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>

  <iterate>For each story in ready_for_dev_stories:</iterate>

  <substep n="2.5a" title="Check story file existence and validity">
    <action>Check if story file exists (already done in Step 2)</action>

    <check if="file_status_icon == '❌' (file missing)">
      <output>
📝 Story {{story_key}}: File missing
      </output>

      <ask>Create story file with gap analysis? (yes/no):</ask>

      <check if="response == 'yes'">
        <output>
⚠️ STORY CREATION REQUIRES MANUAL WORKFLOW EXECUTION

**Story:** {{story_key}}
**Status:** File missing or incomplete

**Problem:**
Agents cannot invoke /create-story-with-gap-analysis workflow autonomously.
This workflow requires:
- Interactive user prompts
- Context-heavy codebase scanning
- Gap analysis decision-making

**Required Action:**

1. **Exit this batch execution:**
   - Remaining stories will be skipped
   - Batch will continue with valid stories only

2. **Regenerate story manually:**
   ```
   /create-story-with-gap-analysis
   ```
   When prompted, provide:
   - Story key: {{story_key}}
   - Epic: {epic from parent story}
   - Scope: {widget list or feature description}

3. **Validate story format:**
   ```
   ./scripts/validate-all-stories.sh
   ```
   Must show: "✅ All stories ready for batch execution!"

4. **Re-run batch-super-dev:**
   - Story will now be properly formatted
   - Can be executed in next batch run

**Skipping story {{story_key}} from current batch execution.**
        </output>

        <action>Mark story for removal from selection</action>
        <action>Add to skipped_stories list with reason: "Story creation requires manual workflow (agents cannot invoke /create-story)"</action>
        <action>Add to manual_actions_required list: "Regenerate {{story_key}} with /create-story-with-gap-analysis"</action>
      </check>

      <check if="response == 'no'">
        <output>⏭️ Skipping story {{story_key}} (file missing, user declined creation)</output>
        <action>Mark story for removal from selection</action>
        <action>Add to skipped_stories list with reason: "User declined story creation"</action>
      </check>
    </check>

    <check if="file_status_icon == '✅' (file exists)">
      <action>Read story file: {{file_path}}</action>
      <action>Parse sections and validate BMAD format</action>

      <action>Check for all 12 required sections:
        1. Business Context
        2. Current State
        3. Acceptance Criteria
        4. Tasks and Subtasks
        5. Technical Requirements
        6. Architecture Compliance
        7. Testing Requirements
        8. Dev Agent Guardrails
        9. Definition of Done
        10. References
        11. Dev Agent Record
        12. Change Log
      </action>

      <action>Count sections present: sections_found</action>
      <action>Check Current State content length (word count)</action>
      <action>Check Acceptance Criteria item count: ac_count</action>
      <action>Count unchecked tasks ([ ]) in Tasks/Subtasks: task_count</action>
      <action>Look for gap analysis markers (✅/❌) in Current State</action>

      <check if="task_count < 3">
        <output>
❌ Story {{story_key}}: INVALID - Insufficient tasks ({{task_count}}/3 minimum)

This story has TOO FEW TASKS to be a valid story (found {{task_count}}, need ≥3).

Analysis:
- 0 tasks: Story is a stub or empty
- 1-2 tasks: Too small to represent meaningful feature work
- ≥3 tasks: Minimum valid (MICRO threshold)

Possible causes:
- Story file is incomplete/stub
- Tasks section is empty or malformed
- Story needs proper task breakdown
- Story is too small and should be combined with another

Required action:
- Run /validate-create-story to regenerate with proper task breakdown
- Or manually add tasks to reach minimum of 3 tasks
- Or combine this story with a related story

This story will be SKIPPED.
        </output>
        <action>Mark story for removal from selection</action>
        <action>Add to skipped_stories list with reason: "INVALID - Only {{task_count}} tasks (need ≥3)"</action>
        <goto next iteration />
      </check>

      <check if="sections_found < 12 OR Current State < 100 words OR no gap analysis markers OR ac_count < 3">
        <output>
⚠️ Story {{story_key}}: File incomplete or invalid
   - Sections: {{sections_found}}/12
   {{#if Current State < 100 words}}- Current State: stub ({{word_count}} words, expected ≥100){{/if}}
   {{#if no gap analysis}}- Gap analysis: missing{{/if}}
   {{#if ac_count < 3}}- Acceptance Criteria: {{ac_count}} items (expected ≥3){{/if}}
   {{#if task_count < 3}}- Tasks: {{task_count}} items (expected ≥3){{/if}}
        </output>

        <ask>Regenerate story with codebase scan? (yes/no):</ask>

        <check if="response == 'yes'">
          <output>
⚠️ STORY REGENERATION REQUIRES MANUAL WORKFLOW EXECUTION

**Story:** {{story_key}}
**Status:** File incomplete or invalid ({{sections_found}}/12 sections)

**Problem:**
Agents cannot invoke /create-story-with-gap-analysis workflow autonomously.
Story regeneration requires:
- Interactive user prompts
- Context-heavy codebase scanning
- Gap analysis decision-making

**Required Action:**

1. **Exit this batch execution:**
   - This story will be skipped
   - Batch will continue with valid stories only

2. **Backup existing file (optional):**
   ```
   cp {{file_path}} {{file_path}}.backup
   ```

3. **Regenerate story manually:**
   ```
   /create-story-with-gap-analysis
   ```
   When prompted, provide:
   - Story key: {{story_key}}

4. **Validate story format:**
   ```
   ./scripts/validate-all-stories.sh
   ```

5. **Re-run batch-super-dev:**
   - Story will now be properly formatted

**Skipping story {{story_key}} from current batch execution.**
          </output>

          <action>Mark story for removal from selection</action>
          <action>Add to skipped_stories list with reason: "Story regeneration requires manual workflow (agents cannot invoke /create-story)"</action>
          <action>Add to manual_actions_required list: "Regenerate {{story_key}} with /create-story-with-gap-analysis"</action>
        </check>

        <check if="response == 'no'">
          <output>⏭️ Skipping story {{story_key}} (file incomplete)</output>
          <action>Mark story for removal from selection</action>
          <action>Add to skipped_stories list with reason: "User declined regeneration"</action>
        </check>
      </check>

      <check if="sections_found == 12 AND sufficient content">
        <output>✅ Story {{story_key}}: Valid (12/12 sections, gap analysis present)</output>
        <action>Mark story as validated</action>
      </check>
    </check>

    <check if="file_status_icon == '🔄' (already implemented)">
      <output>✅ Story {{story_key}}: Already implemented (will skip or reconcile only)</output>
      <action>Mark story as validated (already done)</action>
    </check>
  </substep>

  <action>Remove skipped stories from ready_for_dev_stories</action>
  <action>Update count of available stories</action>

  <check if="skipped_stories is not empty">
    <output>
⏭️ Skipped Stories ({{skipped_count}}):
{{#each skipped_stories}}
  - {{story_key}}: {{reason}}
{{/each}}
    </output>
  </check>

  <check if="ready_for_dev_stories is empty after validation">
    <output>
❌ No valid stories remaining after validation.

All stories were either:
- Missing files (user declined creation)
- Invalid/incomplete (user declined regeneration)
- Already implemented

Run `/bmad:bmm:workflows:sprint-status` to see status.
    </output>
    <action>Exit workflow</action>
  </check>

  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Story Validation Complete
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
**Validated:** {{validated_count}} stories ready to process
{{#if skipped_count > 0}}**Skipped:** {{skipped_count}} stories{{/if}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>
</step>

<step n="2.6" goal="Score story complexity for pipeline routing (NEW v1.3.0)">
  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 SCORING STORY COMPLEXITY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>

  <iterate>For each validated story:</iterate>

  <substep n="2.6a" title="Analyze story complexity">
    <action>Read story file: {{file_path}}</action>

    <action>Count unchecked tasks ([ ]) at top level only in Tasks/Subtasks section → task_count
      (See workflow.yaml complexity.task_counting.method = "top_level_only")
    </action>

    <check if="task_count < 3">
      <output>
⚠️ Story {{story_key}}: Cannot score complexity - INSUFFICIENT TASKS ({{task_count}}/3 minimum)

This story was not caught in Step 2.5 validation but has too few tasks.
It should have been rejected during validation.

Skipping complexity scoring for this story - marking as INVALID.
      </output>
      <action>Set {{story_key}}.complexity = {level: "INVALID", score: 0, task_count: {{task_count}}, reason: "Insufficient tasks ({{task_count}}/3 minimum)"}</action>
      <action>Continue to next story</action>
    </check>

    <action>Extract file paths mentioned in tasks → file_count</action>
    <action>Scan story title and task descriptions for risk keywords using rules from workflow.yaml:
      - Case insensitive matching (require_word_boundaries: true)
      - Include keyword variants (e.g., "authentication" matches "auth")
      - Scan: story_title, task_descriptions, subtask_descriptions
    </action>

    <action>Calculate complexity score:
      - Base score = task_count
      - Add 5 for each HIGH risk keyword match (auth, security, payment, migration, database, schema, encryption)
      - Add 2 for each MEDIUM risk keyword match (api, integration, external, third-party, cache)
      - Add 0 for LOW risk keywords (ui, style, config, docs, test)
      - Count each keyword only once (no duplicates)
    </action>

    <action>Assign complexity level using mutually exclusive decision tree (priority order):

      1. Check COMPLEX first (highest priority):
         IF (task_count ≥ 16 OR complexity_score ≥ 20 OR has ANY HIGH risk keyword)
         THEN level = COMPLEX

      2. Else check MICRO (lowest complexity):
         ELSE IF (task_count ≤ 3 AND complexity_score ≤ 5 AND file_count ≤ 5)
         THEN level = MICRO

      3. Else default to STANDARD:
         ELSE level = STANDARD

      This ensures no overlaps:
      - Story with HIGH keyword → COMPLEX (never MICRO or STANDARD)
      - Story with 4-15 tasks or >5 files → STANDARD (not MICRO or COMPLEX)
      - Story with ≤3 tasks, ≤5 files, no HIGH keywords → MICRO
    </action>

    <action>Store complexity_level for story: {{story_key}}.complexity = {level, score, task_count, risk_keywords}</action>
  </substep>

  <action>Group stories by complexity level</action>

  <action>Filter out INVALID stories (those with level="INVALID"):</action>
  <action>For each INVALID story, add to skipped_stories with reason from complexity object</action>
  <action>Remove INVALID stories from complexity_groups and ready_for_dev_stories</action>

  <check if="any INVALID stories found">
    <output>
❌ **Invalid Stories Skipped ({{invalid_count}}):**
{{#each invalid_stories}}
  - {{story_key}}: {{reason}}
{{/each}}

These stories need to be regenerated with /create-story or /validate-create-story before processing.
    </output>
  </check>

  <output>
📊 **Complexity Analysis Complete**

{{#each complexity_groups}}
**{{level}} Stories ({{count}}):**
{{#each stories}}
  - {{story_key}}: {{task_count}} tasks, score {{score}}{{#if risk_keywords}}, risk: {{risk_keywords}}{{/if}}
{{/each}}
{{/each}}

---
**Pipeline Routing:**
- 🚀 **MICRO** ({{micro_count}}): Lightweight path - skip gap analysis + code review
- ⚙️ **STANDARD** ({{standard_count}}): Full pipeline with all quality gates
- 🔒 **COMPLEX** ({{complex_count}}): Enhanced validation + consider splitting

{{#if complex_count > 0}}
⚠️ **Warning:** {{complex_count}} complex stories detected. Consider:
- Breaking into smaller stories before processing
- Running these separately with extra attention
{{/if}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>

  <check if="all stories are INVALID">
    <output>
❌ No valid stories remaining after complexity analysis.

All stories were either:
- Missing story files (Step 2.5)
- Invalid/incomplete (Step 2.5)
- Zero tasks (Step 2.6)

Run /create-story or /validate-create-story to create proper story files, then rerun /batch-super-dev.
    </output>
    <action>Exit workflow</action>
  </check>
</step>

<step n="3" goal="Get user selection">
  <ask>
**Select stories to process:**

Enter story numbers to process (examples):
  - Single: `1`
  - Multiple: `1,3,5`
  - Range: `1-5` (processes 1,2,3,4,5)
  - Mixed: `1,3-5,8` (processes 1,3,4,5,8)
  - All: `all` (processes all {{count}} stories)

Or:
  - `cancel` - Exit without processing

**Your selection:**
  </ask>

  <action>Parse user input</action>

  <check if="input == 'cancel'">
    <output>❌ Batch processing cancelled.</output>
    <action>Exit workflow</action>
  </check>

  <check if="input == 'all'">
    <action>Set selected_stories = all ready_for_dev_stories</action>
  </check>

  <check if="input is numeric selection">
    <action>Parse selection (handle commas, ranges)</action>
    <example>Input "1,3-5,8" → indexes [1,3,4,5,8] → map to story keys</example>
    <action>Map selected indexes to story keys from ready_for_dev_stories</action>
    <action>Store as: selected_stories</action>
  </check>

  <check if="selected_stories count > max_stories">
    <output>⚠️ You selected {{count}} stories, but max_stories is {{max_stories}}.

Only the first {{max_stories}} will be processed.</output>
    <action>Truncate selected_stories to first max_stories entries</action>
  </check>

  <action>Display confirmation</action>
  <output>
## 📋 Selected Stories ({{count}})

{{#each selected_stories}}
{{@index}}. {{key}}
{{/each}}

**Estimated time:** {{count}} stories × 30-60 min/story = {{estimated_hours}} hours
  </output>
</step>

<step n="3.5" goal="Choose execution strategy">
  <ask>
**How should these stories be processed?**

Options:
- **sequential**: Run stories one-by-one in this session (slower, easier to monitor)
- **parallel**: Spawn Task agents to process stories concurrently (faster, autonomous)

Enter: sequential or parallel
  </ask>

  <action>Capture response as: execution_mode</action>

  <check if="execution_mode == 'sequential'">
    <action>Set parallel_count = 1</action>
    <action>Set use_task_agents = false</action>
    <output>✅ Sequential mode selected - stories will be processed one-by-one in this session</output>
  </check>

  <check if="execution_mode == 'parallel'">
    <action>Set use_task_agents = true</action>

    <ask>
**How many agents should run in parallel?**

Options:
- **2**: Conservative (low resource usage, easier debugging)
- **4**: Moderate (balanced performance, recommended)
- **8**: Aggressive (higher throughput)
- **10**: Maximum (10 agent limit for safety)
- **all**: Use all stories (max 10 agents)

Enter number (2-10) or 'all':
    </ask>

    <action>Capture response as: parallel_count</action>
    <action>If parallel_count == 'all': set parallel_count = min(count of selected_stories, 10)</action>
    <action>If parallel_count > 10: set parallel_count = 10 (safety limit)</action>

    <check if="parallel_count was capped at 10">
      <output>⚠️ Requested {{original_count}} agents, capped at 10 (safety limit)</output>
    </check>
  </check>

  <output>
## ⚙️ Execution Plan

**Mode:** {{execution_mode}}
{{#if use_task_agents}}
**Task Agents:** {{parallel_count}} running concurrently
**Agent Type:** general-purpose (autonomous)
{{else}}
**Sequential processing** in current session
{{/if}}

**Stories to process:** {{count}}
**Estimated total time:**
{{#if use_task_agents}}
- With {{parallel_count}} agents: {{estimated_hours / parallel_count}} hours
{{else}}
- Sequential: {{estimated_hours}} hours
{{/if}}
  </output>

  <ask>Confirm execution plan? (yes/no):</ask>

  <check if="response != 'yes'">
    <output>❌ Batch processing cancelled.</output>
    <action>Exit workflow</action>
  </check>
</step>

<step n="4" goal="Process stories with super-dev-pipeline">
  <action>Initialize counters: completed=0, failed=0, failed_stories=[], reconciliation_warnings=[], reconciliation_warnings_count=0</action>
  <action>Set start_time = current timestamp</action>

  <check if="use_task_agents == true">
    <action>Jump to Step 4-Parallel (Task Agent execution)</action>
  </check>

  <check if="use_task_agents == false">
    <action>Continue to Step 4-Sequential (In-session execution)</action>
  </check>
</step>

<step n="4-Sequential" goal="Sequential processing in current session">
  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 SEQUENTIAL BATCH PROCESSING STARTED
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
**Stories:** {{count}}
**Mode:** super-dev-pipeline (batch, sequential)
**Continue on failure:** {{continue_on_failure}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>

  <iterate>For each story in selected_stories:</iterate>

  <substep n="4s-a" title="Process individual story">
    <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📦 Story {{current_index}}/{{total_count}}: {{story_key}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    </output>

    <action>Invoke workflow: /bmad:bmm:workflows:super-dev-pipeline</action>
    <action>Parameters: mode=batch, story_key={{story_key}}, complexity_level={{story_key}}.complexity.level</action>

    <check if="super-dev-pipeline succeeded">
      <output>✅ Implementation complete: {{story_key}}</output>

      <action>Execute Step 4.5: Smart Story Reconciliation</action>
      <action>Load reconciliation instructions: {installed_path}/step-4.5-reconcile-story-status.md</action>
      <action>Execute reconciliation with story_key={{story_key}}</action>

      <check if="reconciliation succeeded">
        <output>✅ COMPLETED: {{story_key}} (reconciled)</output>
        <action>Increment completed counter</action>
      </check>

      <check if="reconciliation failed">
        <output>⚠️ WARNING: {{story_key}} completed but reconciliation failed</output>
        <action>Increment completed counter (implementation was successful)</action>
        <action>Add to reconciliation_warnings: {story_key: {{story_key}}, warning_message: "Reconciliation failed - manual verification needed"}</action>
        <action>Increment reconciliation_warnings_count</action>
      </check>
    </check>

    <check if="super-dev-pipeline failed">
      <output>❌ FAILED: {{story_key}}</output>
      <action>Increment failed counter</action>
      <action>Add story_key to failed_stories list</action>

      <check if="continue_on_failure == false">
        <output>⚠️ Stopping batch due to failure (continue_on_failure=false)</output>
        <action>Jump to Step 5 (Summary)</action>
      </check>
    </check>

    <check if="display_progress == true">
      <output>
**Progress:** {{completed}} completed, {{failed}} failed, {{remaining}} remaining
      </output>
    </check>

    <check if="not last story AND pause_between_stories > 0">
      <output>⏸️ Pausing {{pause_between_stories}} seconds before next story...</output>
      <action>Wait {{pause_between_stories}} seconds</action>
    </check>
  </substep>

  <action>After all stories processed, jump to Step 5 (Summary)</action>
</step>

<step n="4-Parallel" goal="Parallel processing with semaphore pattern">
  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 PARALLEL PROCESSING STARTED (Semaphore Pattern)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
**Stories:** {{count}}
**Mode:** Task agents (autonomous, continuous)
**Max concurrent agents:** {{parallel_count}}
**Continue on failure:** {{continue_on_failure}}
**Pattern:** Worker pool with {{parallel_count}} slots
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 **Semaphore Pattern Benefits:**
- No idle time between batches
- Constant {{parallel_count}} agents running
- As soon as slot frees → next story starts immediately
- Faster completion (no batch synchronization delays)
  </output>

  <action>Initialize worker pool state:</action>
  <action>
    - story_queue = selected_stories (all stories to process)
    - active_workers = {} (map of worker_id → {story_key, task_id, started_at})
    - completed_stories = []
    - failed_stories = []
    - next_story_index = 0
    - max_workers = {{parallel_count}}
  </action>

  <substep n="4p-init" title="Fill initial worker slots">
    <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔧 Initializing {{max_workers}} worker slots...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    </output>

    <action>Spawn first {{max_workers}} agents (or fewer if less stories):</action>

    <iterate>While next_story_index < min(max_workers, story_queue.length):</iterate>

    <action>
      story_key = story_queue[next_story_index]
      worker_id = next_story_index + 1

      Spawn Task agent:
      - subagent_type: "general-purpose"
      - description: "Implement story {{story_key}}"
      - prompt: "Execute super-dev-pipeline workflow for story {{story_key}}.

                 CRITICAL INSTRUCTIONS:
                 1. Load workflow.xml: _bmad/core/tasks/workflow.xml
                 2. Load workflow config: _bmad/bmm/workflows/4-implementation/super-dev-pipeline/workflow.yaml
                 3. Execute in BATCH mode with story_key={{story_key}} and complexity_level={{story_key}}.complexity.level
                 4. Follow all 7 pipeline steps (init, pre-gap, implement, post-validate, code-review, complete, summary)
                 5. Commit changes when complete
                 6. Report final status (done/failed) with file list

                 Story file will be auto-resolved from multiple naming conventions."
      - run_in_background: true (non-blocking - critical for semaphore pattern)

      Store in active_workers[worker_id]:
        story_key: {{story_key}}
        task_id: {{returned_task_id}}
        started_at: {{timestamp}}
        status: "running"
    </action>

    <action>Increment next_story_index</action>

    <output>🚀 Worker {{worker_id}} started: {{story_key}}</output>

    <action>After spawning initial workers:</action>
    <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ {{active_workers.size}} workers active
📋 {{story_queue.length - next_story_index}} stories queued
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    </output>
  </substep>

  <substep n="4p-pool" title="Maintain worker pool until all stories complete">
    <critical>SEMAPHORE PATTERN: Keep {{max_workers}} agents running continuously</critical>

    <iterate>While active_workers.size > 0 OR next_story_index < story_queue.length:</iterate>

    <action>Poll for completed workers (check task outputs non-blocking):</action>

    <iterate>For each worker_id in active_workers:</iterate>

    <action>Check if worker task completed using TaskOutput(task_id, block=false)</action>

    <check if="worker task is still running">
      <action>Continue to next worker (don't wait)</action>
    </check>

    <check if="worker task completed successfully">
      <action>Get worker details: story_key = active_workers[worker_id].story_key</action>

      <output>✅ Worker {{worker_id}} completed: {{story_key}}</output>

      <action>Execute Step 4.5: Smart Story Reconciliation</action>
      <action>Load reconciliation instructions: {installed_path}/step-4.5-reconcile-story-status.md</action>
      <action>Execute reconciliation with story_key={{story_key}}</action>

      <check if="reconciliation succeeded">
        <output>✅ COMPLETED: {{story_key}} (reconciled)</output>
        <action>Add to completed_stories</action>
      </check>

      <check if="reconciliation failed">
        <output>⚠️ WARNING: {{story_key}} completed but reconciliation failed</output>
        <action>Add to completed_stories (implementation successful)</action>
        <action>Add to reconciliation_warnings: {story_key: {{story_key}}, warning_message: "Reconciliation failed - manual verification needed"}</action>
      </check>

      <action>Remove worker_id from active_workers (free the slot)</action>

      <action>IMMEDIATELY refill slot if stories remain:</action>
      <check if="next_story_index < story_queue.length">
        <action>story_key = story_queue[next_story_index]</action>

        <output>🔄 Worker {{worker_id}} refilled: {{story_key}}</output>

        <action>Spawn new Task agent for this worker_id (same parameters as init)</action>
        <action>Update active_workers[worker_id] with new task_id and story_key</action>
        <action>Increment next_story_index</action>
      </check>
    </check>

    <check if="worker task failed">
      <action>Get worker details: story_key = active_workers[worker_id].story_key</action>

      <output>❌ Worker {{worker_id}} failed: {{story_key}}</output>

      <action>Add to failed_stories</action>
      <action>Remove worker_id from active_workers (free the slot)</action>

      <check if="continue_on_failure == false">
        <output>⚠️ Stopping all workers due to failure (continue_on_failure=false)</output>
        <action>Kill all active workers</action>
        <action>Clear story_queue</action>
        <action>Break worker pool loop</action>
      </check>

      <check if="continue_on_failure == true AND next_story_index < story_queue.length">
        <action>story_key = story_queue[next_story_index]</action>

        <output>🔄 Worker {{worker_id}} refilled: {{story_key}} (despite previous failure)</output>

        <action>Spawn new Task agent for this worker_id</action>
        <action>Update active_workers[worker_id] with new task_id and story_key</action>
        <action>Increment next_story_index</action>
      </check>
    </check>

    <action>Display live progress every 30 seconds:</action>
    <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 Live Progress ({{timestamp}})
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Completed: {{completed_stories.length}}
❌ Failed: {{failed_stories.length}}
🔄 Active workers: {{active_workers.size}}
📋 Queued: {{story_queue.length - next_story_index}}

Active stories:
{{#each active_workers}}
  Worker {{@key}}: {{story_key}} (running {{duration}})
{{/each}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    </output>

    <action>Sleep 5 seconds before next poll (prevents tight loop)</action>

  </substep>

  <action>After worker pool drains (all stories processed), jump to Step 5 (Summary)</action>
</step>

<step n="5" goal="Display batch summary">
  <action>Calculate end_time and total_duration</action>
  <action>Calculate success_rate = (completed / total_count) * 100</action>

  <output>
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 BATCH SUMMARY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
**Total stories:** {{total_count}}
**✅ Completed:** {{completed}}
**❌ Failed:** {{failed}}
**⚠️ Reconciliation warnings:** {{reconciliation_warnings_count}}
**Success rate:** {{success_rate}}%
**Duration:** {{total_duration}}

{{#if failed > 0}}
**Failed stories:**
{{#each failed_stories}}
  - {{this}}
{{/each}}

**Retry failed stories:**
```bash
{{#each failed_stories}}
/bmad:bmm:workflows:super-dev-pipeline mode=batch story_key={{this}}
{{/each}}
```
{{/if}}

{{#if reconciliation_warnings_count > 0}}
**⚠️ Reconciliation warnings (stories completed but status may be inaccurate):**
{{#each reconciliation_warnings}}
  - {{story_key}}: {{warning_message}}
{{/each}}

**Manual reconciliation needed:**
Review these stories to ensure checkboxes and status are accurate.
Check Dev Agent Record vs Acceptance Criteria/Tasks/DoD sections.
{{/if}}

{{#if manual_actions_required.length > 0}}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ MANUAL ACTIONS REQUIRED
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**{{manual_actions_required.length}} stories require manual intervention:**

{{#each manual_actions_required}}
{{@index}}. **{{story_key}}**
   Action: Regenerate story with proper BMAD format
   Command: `/create-story-with-gap-analysis`
{{/each}}

**After completing these actions:**
1. Validate all stories: `./scripts/validate-all-stories.sh`
2. Re-run batch-super-dev for these stories
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
{{/if}}

**Next steps:**
1. Check sprint-status.yaml - stories should be marked "done" or "review"
2. Run tests: `pnpm test`
3. Check coverage: `pnpm test --coverage`
4. Review commits: `git log -{{completed}}`
5. Spot-check 2-3 stories for quality

**Run another batch?**
`/bmad:bmm:workflows:batch-super-dev`
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  </output>

  <action>Save batch log to {batch_log}</action>
  <action>Log contents: start_time, end_time, total_duration, selected_stories, completed_stories, failed_stories, success_rate</action>
</step>

</workflow>