diff --git a/.gitignore b/.gitignore
index c644f148..b9697054 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,9 @@ build/*.txt
.DS_Store
Thumbs.db
+# BMAD workflow lock files
+.git/bmad-commit.lock
+
# Development tools and configs
.prettierrc
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f5c1d51f..9b5e710c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,12 +37,103 @@ development_status:
- New entries automatically add progress
- Gradual migration as stories are worked
+### ⚡ Semaphore Pattern for Parallel Execution
+
+**NEW:** Worker pool pattern replaces batch-and-wait for maximum throughput.
+
+**Previously (Batch-and-Wait):**
+```
+Batch 1: Start 5 agents → wait for ALL 5 to finish
+Batch 2: Start 5 agents → wait for ALL 5 to finish
+Problem: If 4 finish quickly, slots sit idle waiting for slow 5th
+```
+
+**Now (Semaphore Pattern):**
+```
+Initialize: Fill 5 worker slots
+Worker 1 finishes → immediately start next story in that slot
+Worker 3 finishes → immediately start next story in that slot
+Maintain constant 5 concurrent agents until queue empty
+```
+
+**Benefits:**
+- 20-40% faster completion (eliminates idle time)
+- Constant utilization of all worker slots
+- More predictable completion times
+- Live progress dashboard every 30 seconds
+
+### 🔒 Git Commit Queue (Parallel-Safe)
+
+**NEW:** File-based locking prevents concurrent commit conflicts in parallel mode.
+
+**Problem Solved:**
+```
+Worker 1: git commit → acquires .git/index.lock
+Worker 2: git commit → ERROR: Another git process is running
+Worker 3: git commit → ERROR: Another git process is running
+Workers 2 & 3: HALT - manual intervention needed ❌
+```
+
+**Solution with Commit Queue:**
+```
+Worker 1: acquire .git/bmad-commit.lock → commit → release
+Worker 2: wait for lock → acquire → commit → release
+Worker 3: wait for lock → acquire → commit → release
+All workers: SUCCESS ✅
+```
+
+**Features:**
+- Automatic retry with exponential backoff (1s → 30s)
+- Stale lock cleanup (>5 min old locks auto-removed)
+- Timeout protection (max 5 min wait)
+- Lock file tracking: who holds lock, when acquired, worker ID
+- Serializes commits while keeping implementations parallel
+- No user intervention needed for lock conflicts
+
+**Lock File:** `.git/bmad-commit.lock` (auto-generated, auto-cleaned, gitignored)
+
+### 🛡️ Stricter Story Validation
+
+**NEW:** Minimum 3-task requirement prevents invalid/incomplete stories from being processed.
+
+**Validation Rules:**
+- **0-2 tasks:** INVALID - Story is stub/incomplete (rejected in Step 2.5)
+- **3 tasks:** Minimum valid (MICRO classification threshold)
+- **4-15 tasks:** STANDARD story size
+- **16+ tasks:** COMPLEX story, consider splitting
+
+**What Happens to Invalid Stories:**
+- Step 2.5: Rejected during validation with clear error message
+- Step 2.6: Marked as INVALID during complexity scoring (double-check)
+- Filtered out before user selection step
+- User prompted to run /validate-create-story to fix
+
+**Example (Real-World Issue Fixed):**
+```
+Before v1.3.0:
+- Story "11-4-classes-workshops-advanced": 0 tasks, high-risk keywords
+- Classified as COMPLEX (because keywords)
+- Proceeds to implementation
+- Agent has nothing to implement → fails
+
+After v1.3.0:
+- Story "11-4-classes-workshops-advanced": 0 tasks
+- Rejected in Step 2.5: "INVALID - Only 0 tasks (need ≥3)"
+- Skipped from selection
+- User told to run /validate-create-story
+```
+
### Files Modified
-- `dev-story/instructions.xml` (BMM + BMGD): Added mandatory task-level updates with CRITICAL enforcement
-- `sprint-status/instructions.md` (BMM + BMGD): Added progress parsing and display
-- `batch-super-dev/step-4.5-reconcile-story-status.md`: Added progress to reconciliation
-- `docs/HOW-TO-VALIDATE-SPRINT-STATUS.md`: Documented new format and update frequency
+- `batch-super-dev/instructions.md`: Semaphore pattern, 3-task minimum, INVALID filtering
+- `batch-super-dev/README.md`: Updated to v1.3.0, documented all new features
+- `super-dev-pipeline/steps/step-06-complete.md`: Added commit queue with file-based locking
+- `super-dev-pipeline/steps/step-06a-queue-commit.md`: NEW file for commit queue documentation
+- `dev-story/instructions.xml` (BMM + BMGD): Mandatory task-level sprint-status updates with CRITICAL enforcement
+- `sprint-status/instructions.md` (BMM + BMGD): Progress parsing and display
+- `batch-super-dev/step-4.5-reconcile-story-status.md`: Progress in reconciliation
+- `docs/HOW-TO-VALIDATE-SPRINT-STATUS.md`: Semaphore pattern documentation
+- `.gitignore`: Added `.git/bmad-commit.lock`
---
diff --git a/src/modules/bmm/workflows/4-implementation/batch-super-dev/README.md b/src/modules/bmm/workflows/4-implementation/batch-super-dev/README.md
index 6ef8080d..c3f66521 100644
--- a/src/modules/bmm/workflows/4-implementation/batch-super-dev/README.md
+++ b/src/modules/bmm/workflows/4-implementation/batch-super-dev/README.md
@@ -448,6 +448,11 @@ reconciliation:
- As soon as worker completes → immediately refill slot with next story
- Maintain constant N concurrent agents until queue empty
- Execute reconciliation after each story completes
+- **Commit Queue:** File-based locking prevents git lock conflicts
+ - Workers acquire `.git/bmad-commit.lock` before committing
+ - Automatic retry with exponential backoff (1s → 30s)
+ - Stale lock cleanup (>5 min)
+ - Serialized commits, parallel implementation
- No idle time waiting for batch synchronization
- **20-40% faster** than old batch-and-wait pattern
@@ -591,17 +596,30 @@ See: `step-4.5-reconcile-story-status.md` for detailed algorithm
- Smart pipeline selection: micro → lightweight, complex → enhanced
- 50-70% token savings for micro stories
- Deterministic classification with mutually exclusive thresholds
+ - **CRITICAL:** Rejects stories with <3 tasks as INVALID (prevents 0-task stories from being processed)
- **NEW:** Semaphore Pattern for Parallel Execution
- Worker pool maintains constant N concurrent agents
- As soon as worker completes → immediately start next story
- No idle time waiting for batch synchronization
- 20-40% faster than old batch-and-wait pattern
- Non-blocking task polling with live progress dashboard
+- **NEW:** Git Commit Queue (Parallel-Safe)
+ - File-based locking prevents concurrent commit conflicts
+ - Workers acquire `.git/bmad-commit.lock` before committing
+ - Automatic retry with exponential backoff (1s → 30s max)
+ - Stale lock cleanup (>5 min old locks auto-removed)
+ - Eliminates "Another git process is running" errors
+ - Serializes commits while keeping implementations parallel
- **NEW:** Continuous Sprint-Status Tracking
- sprint-status.yaml updated after EVERY task completion
- Real-time progress: "# 7/10 tasks (70%)"
- CRITICAL enforcement with HALT on update failure
- Immediate visibility into story progress
+- **NEW:** Stricter Story Validation
+ - Step 2.5 now rejects stories with <3 tasks
+ - Step 2.6 marks stories with <3 tasks as INVALID
+ - Prevents incomplete/stub stories from being processed
+ - Requires /validate-create-story to fix before processing
### v1.2.0 (2026-01-06)
- **NEW:** Smart Story Validation & Auto-Creation (Step 2.5)
diff --git a/src/modules/bmm/workflows/4-implementation/batch-super-dev/instructions.md b/src/modules/bmm/workflows/4-implementation/batch-super-dev/instructions.md
index c341a8f6..ed87759c 100644
--- a/src/modules/bmm/workflows/4-implementation/batch-super-dev/instructions.md
+++ b/src/modules/bmm/workflows/4-implementation/batch-super-dev/instructions.md
@@ -168,16 +168,47 @@ Run `/bmad:bmm:workflows:sprint-status` to see current status.
Count sections present: sections_found
Check Current State content length (word count)
- Check Acceptance Criteria item count
- Check Tasks item count
+ Check Acceptance Criteria item count: ac_count
+ Count unchecked tasks ([ ]) in Tasks/Subtasks: task_count
Look for gap analysis markers (✅/❌) in Current State
-
+
+
+ Mark story for removal from selection
+ Add to skipped_stories list with reason: "INVALID - Only {{task_count}} tasks (need ≥3)"
+
+
+
+
Regenerate story with codebase scan? (yes/no):
@@ -271,6 +302,20 @@ Run `/bmad:bmm:workflows:sprint-status` to see status.
Count unchecked tasks ([ ]) at top level only in Tasks/Subtasks section → task_count
(See workflow.yaml complexity.task_counting.method = "top_level_only")
+
+
+
+ Set {{story_key}}.complexity = {level: "INVALID", score: 0, task_count: {{task_count}}, reason: "Insufficient tasks ({{task_count}}/3 minimum)"}
+ Continue to next story
+
+
Extract file paths mentioned in tasks → file_count
Scan story title and task descriptions for risk keywords using rules from workflow.yaml:
- Case insensitive matching (require_word_boundaries: true)
@@ -310,6 +355,21 @@ Run `/bmad:bmm:workflows:sprint-status` to see status.
Group stories by complexity level
+ Filter out INVALID stories (those with level="INVALID"):
+ For each INVALID story, add to skipped_stories with reason from complexity object
+ Remove INVALID stories from complexity_groups and ready_for_dev_stories
+
+
+
+
+
+
+
+
+ Exit workflow
+
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06-complete.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06-complete.md
index ebfde16f..d92f71a8 100644
--- a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06-complete.md
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06-complete.md
@@ -98,17 +98,87 @@ Files changed:
Story: {story_file}
```
-### 6. Create Commit
+### 6. Create Commit (With Queue for Parallel Mode)
+
+**Check execution mode:**
+```
+If mode == "batch" AND parallel execution:
+ use_commit_queue = true
+Else:
+ use_commit_queue = false
+```
+
+**If use_commit_queue == true:**
```bash
+# Commit queue with file-based locking
+lock_file=".git/bmad-commit.lock"
+max_wait=300 # 5 minutes
+wait_time=0
+retry_delay=1
+
+while [ $wait_time -lt $max_wait ]; do
+ if [ ! -f "$lock_file" ]; then
+ # Acquire lock
+ echo "locked_by: {{story_key}}
+locked_at: $(date -u +%Y-%m-%dT%H:%M:%SZ)
+worker_id: {{worker_id}}
+pid: $$" > "$lock_file"
+
+ echo "🔒 Commit lock acquired for {{story_key}}"
+
+ # Execute commit
+ git commit -m "$(cat <<'EOF'
+{commit_message}
+EOF
+)"
+
+ commit_result=$?
+
+ # Release lock
+ rm -f "$lock_file"
+ echo "🔓 Lock released"
+
+ if [ $commit_result -eq 0 ]; then
+ git log -1 --oneline
+ break
+ else
+ echo "❌ Commit failed"
+ exit $commit_result
+ fi
+ else
+ # Lock exists, check if stale
+ lock_age=$(( $(date +%s) - $(date -r "$lock_file" +%s) ))
+ if [ $lock_age -gt 300 ]; then
+ echo "⚠️ Stale lock detected (${lock_age}s old) - removing"
+ rm -f "$lock_file"
+ continue
+ fi
+
+ locked_by=$(grep "locked_by:" "$lock_file" | cut -d' ' -f2-)
+ echo "⏳ Waiting for commit lock... (held by $locked_by, ${wait_time}s elapsed)"
+ sleep $retry_delay
+ wait_time=$(( wait_time + retry_delay ))
+ retry_delay=$(( retry_delay < 30 ? retry_delay * 3 / 2 : 30 )) # Exponential backoff, max 30s
+ fi
+done
+
+if [ $wait_time -ge $max_wait ]; then
+ echo "❌ TIMEOUT: Could not acquire commit lock after 5 minutes"
+ echo "Lock holder: $(cat $lock_file)"
+ exit 1
+fi
+```
+
+**If use_commit_queue == false (sequential mode):**
+
+```bash
+# Direct commit (no queue needed)
git commit -m "$(cat <<'EOF'
{commit_message}
EOF
)"
-```
-Verify commit created:
-```bash
git log -1 --oneline
```
diff --git a/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06a-queue-commit.md b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06a-queue-commit.md
new file mode 100644
index 00000000..6c72ee2b
--- /dev/null
+++ b/src/modules/bmm/workflows/4-implementation/super-dev-pipeline/steps/step-06a-queue-commit.md
@@ -0,0 +1,279 @@
+---
+name: 'step-06a-queue-commit'
+description: 'Queued git commit with file-based locking for parallel safety'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/super-dev-pipeline'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06a-queue-commit.md'
+nextStepFile: '{workflow_path}/steps/step-07-summary.md'
+
+# Role
+role: dev
+requires_fresh_context: false
+---
+
+# Step 6a: Queued Git Commit (Parallel-Safe)
+
+## STEP GOAL
+
+Execute git commit with file-based locking to prevent concurrent commit conflicts in parallel batch mode.
+
+**Problem Solved:**
+- Multiple parallel agents trying to commit simultaneously
+- Git lock file conflicts (.git/index.lock)
+- "Another git process seems to be running" errors
+- Commit failures requiring manual intervention
+
+**Solution:**
+- File-based commit queue using .git/bmad-commit.lock
+- Automatic retry with exponential backoff
+- Lock cleanup on success or failure
+- Maximum wait time enforcement
+
+## EXECUTION SEQUENCE
+
+### 1. Check if Commit Queue is Needed
+
+```
+If mode == "batch" AND execution_mode == "parallel":
+ use_commit_queue = true
+ Display: "🔒 Using commit queue (parallel mode)"
+Else:
+ use_commit_queue = false
+ Display: "Committing directly (sequential mode)"
+ goto Step 3 (Direct Commit)
+```
+
+### 2. Acquire Commit Lock (Parallel Mode Only)
+
+**Lock file:** `.git/bmad-commit.lock`
+
+**Acquisition algorithm:**
+```
+max_wait_time = 300 seconds (5 minutes)
+retry_delay = 1 second (exponential backoff)
+start_time = now()
+
+WHILE elapsed_time < max_wait_time:
+
+ IF lock file does NOT exist:
+ Create lock file with content:
+ locked_by: {{story_key}}
+ locked_at: {{timestamp}}
+ worker_id: {{worker_id}}
+ pid: {{process_id}}
+
+ Display: "🔓 Lock acquired for {{story_key}}"
+ BREAK (proceed to commit)
+
+ ELSE:
+ Read lock file to check who has it
+ Display: "⏳ Waiting for commit lock... (held by {{locked_by}}, {{wait_duration}}s elapsed)"
+
+ Sleep retry_delay seconds
+ retry_delay = min(retry_delay * 1.5, 30) # Exponential backoff, max 30s
+
+ Check if lock is stale (>5 minutes old):
+ IF lock_age > 300 seconds:
+ Display: "⚠️ Stale lock detected ({{lock_age}}s old) - removing"
+ Delete lock file
+ Continue (try again)
+```
+
+**Timeout handling:**
+```
+IF elapsed_time >= max_wait_time:
+ Display:
+ ❌ TIMEOUT: Could not acquire commit lock after 5 minutes
+
+ Lock held by: {{locked_by}}
+ Lock age: {{lock_age}} seconds
+
+ Possible causes:
+ - Another agent crashed while holding lock
+ - Commit taking abnormally long
+ - Lock file not cleaned up
+
+ HALT - Manual intervention required:
+ - Check if lock holder is still running
+ - Delete .git/bmad-commit.lock if safe
+ - Retry this story
+```
+
+### 3. Execute Git Commit
+
+**Stage changes:**
+```bash
+git add {files_changed_for_this_story}
+```
+
+**Generate commit message:**
+```
+feat: implement story {{story_key}}
+
+{{implementation_summary_from_dev_agent_record}}
+
+Files changed:
+{{#each files_changed}}
+- {{this}}
+{{/each}}
+
+Tasks completed: {{checked_tasks}}/{{total_tasks}}
+Story status: {{story_status}}
+```
+
+**Commit:**
+```bash
+git commit -m "$(cat <<'EOF'
+{commit_message}
+EOF
+)"
+```
+
+**Verification:**
+```bash
+git log -1 --oneline
+```
+
+Confirm commit SHA returned.
+
+### 4. Release Commit Lock (Parallel Mode Only)
+
+```
+IF use_commit_queue == true:
+ Delete lock file: .git/bmad-commit.lock
+
+ Verify lock removed:
+ IF lock file still exists:
+ Display: "⚠️ WARNING: Could not remove lock file"
+ Try force delete
+ ELSE:
+ Display: "🔓 Lock released for {{story_key}}"
+```
+
+**Error handling:**
+```
+IF commit failed:
+ Release lock (if held)
+ Display:
+ ❌ COMMIT FAILED: {{error_message}}
+
+ Story implemented but not committed.
+ Changes are staged but not in git history.
+
+ HALT - Fix commit issue before continuing
+```
+
+### 5. Update State
+
+Update state file:
+- Add `6a` to `stepsCompleted`
+- Set `lastStep: 6a`
+- Record `commit_sha`
+- Record `committed_at` timestamp
+
+### 6. Present Summary
+
+Display:
+```
+✅ Story {{story_key}} Committed
+
+Commit: {{commit_sha}}
+Files: {{files_count}} changed
+{{#if use_commit_queue}}Lock wait: {{lock_wait_duration}}s{{/if}}
+```
+
+**Interactive Mode Menu:**
+```
+[C] Continue to Summary
+[P] Push to remote
+[H] Halt pipeline
+```
+
+**Batch Mode:** Auto-continue to step-07-summary.md
+
+## CRITICAL STEP COMPLETION
+
+Load and execute `{nextStepFile}` for summary.
+
+---
+
+## SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS
+- Changes committed to git
+- Commit SHA recorded
+- Lock acquired and released cleanly (parallel mode)
+- No lock file remaining
+- State updated
+
+### ❌ FAILURE
+- Commit timed out
+- Lock acquisition timed out (>5 min)
+- Lock not released (leaked lock)
+- Commit command failed
+- Stale lock not cleaned up
+
+---
+
+## LOCK FILE FORMAT
+
+`.git/bmad-commit.lock` contains:
+```yaml
+locked_by: "2-7-image-file-handling"
+locked_at: "2026-01-07T18:45:32Z"
+worker_id: 3
+pid: 12345
+story_file: "docs/sprint-artifacts/2-7-image-file-handling.md"
+```
+
+This allows debugging if lock gets stuck.
+
+---
+
+## QUEUE BENEFITS
+
+**Before (No Queue):**
+```
+Worker 1: git commit → acquires .git/index.lock
+Worker 2: git commit → ERROR: index.lock exists
+Worker 3: git commit → ERROR: index.lock exists
+Worker 2: retries → ERROR: index.lock exists
+Worker 3: retries → ERROR: index.lock exists
+Workers 2 & 3: HALT - manual intervention needed
+```
+
+**After (With Queue):**
+```
+Worker 1: acquires bmad-commit.lock → git commit → releases lock
+Worker 2: waits for lock → acquires → git commit → releases
+Worker 3: waits for lock → acquires → git commit → releases
+All workers: SUCCESS ✅
+```
+
+**Throughput Impact:**
+- Implementation: Fully parallel (no blocking)
+- Commits: Serialized (necessary to prevent conflicts)
+- Overall: Still much faster than sequential mode (implementation is 90% of the time)
+
+---
+
+## STALE LOCK RECOVERY
+
+**Automatic cleanup:**
+- Locks older than 5 minutes are considered stale
+- Automatically removed before retrying
+- Prevents permanent deadlock from crashed agents
+
+**Manual recovery:**
+```bash
+# If workflow stuck on lock acquisition:
+rm .git/bmad-commit.lock
+
+# Check if any git process is actually running:
+ps aux | grep git
+
+# If no git process, safe to remove lock
+```