claude-code-workflow 6.3.53 → 7.0.0

package/.claude/commands/workflow/tdd-plan.md

@@ -1,630 +0,0 @@
----
-name: tdd-plan
-description: TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking
-argument-hint: "\"feature description\"|file.md"
-allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
----
-
-# TDD Workflow Plan Command (/workflow:tdd-plan)
-
-## Coordinator Role
-
-**This command is a pure orchestrator**: Executes 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
-
-**CLI Tool Selection**: CLI tool usage is determined semantically from user's task description. Include "use Codex/Gemini/Qwen" in your request for CLI execution.
-
-**Task Attachment Model**:
-- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
-- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
-- Orchestrator **executes these attached tasks** sequentially
-- After completion, attached tasks are **collapsed** back to high-level phase summary
-- This is **task expansion**, not external delegation
-
-**Auto-Continue Mechanism**:
-- TodoList tracks current phase status and dynamically manages task attachment/collapse
-- When each phase finishes executing, automatically execute next pending phase
-- All phases run autonomously without user interaction
-- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
-
-## Core Rules
-
-1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1
-2. **No Preliminary Analysis**: Do not read files before Phase 1
-3. **Parse Every Output**: Extract required data for next phase
-4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
-5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **TDD Context**: All descriptions include "TDD:" prefix
-7. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
-
-## TDD Compliance Requirements
-
-### The Iron Law
-
-```
-NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
-```
-
-**Enforcement Method**:
-- Phase 5: `implementation_approach` includes test-first steps (Red → Green → Refactor)
-- Green phase: Includes test-fix-cycle configuration (max 3 iterations)
-- Auto-revert: Triggered when max iterations reached without passing tests
-
-**Verification**: Phase 6 validates Red-Green-Refactor structure in all generated tasks
-
-### TDD Compliance Checkpoint
-
-| Checkpoint | Validation Phase | Evidence Required |
-|------------|------------------|-------------------|
-| Test-first structure | Phase 5 | `implementation_approach` has 3 steps |
-| Red phase exists | Phase 6 | Step 1: `tdd_phase: "red"` |
-| Green phase with test-fix | Phase 6 | Step 2: `tdd_phase: "green"` + test-fix-cycle |
-| Refactor phase exists | Phase 6 | Step 3: `tdd_phase: "refactor"` |
-
-### Core TDD Principles (from ref skills)
-
-**Red Flags - STOP and Reassess**:
-- Code written before test
-- Test passes immediately (no Red phase witnessed)
-- Cannot explain why test should fail
-- "Just this once" rationalization
-- "Tests after achieve same goals" thinking
-
-**Why Order Matters**:
-- Tests written after code pass immediately → proves nothing
-- Test-first forces edge case discovery before implementation
-- Tests-after verify what was built, not what's required
-
-## 6-Phase Execution (with Conflict Resolution)
-
-### Phase 1: Session Discovery
-
-**Step 1.1: Execute** - Session discovery and initialization
-
-```javascript
-SlashCommand(command="/workflow:session:start --type tdd --auto \"TDD: [structured-description]\"")
-```
-
-**TDD Structured Format**:
-```
-TDD: [Feature Name]
-GOAL: [Objective]
-SCOPE: [Included/excluded]
-CONTEXT: [Background]
-TEST_FOCUS: [Test scenarios]
-```
-
-**Parse**: Extract sessionId
-
-**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
-
-**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
-
----
-
-### Phase 2: Context Gathering
-
-**Step 2.1: Execute** - Context gathering and analysis
-
-```javascript
-SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD: [structured-description]\"")
-```
-
-**Use Same Structured Description**: Pass the same structured format from Phase 1
-
-**Input**: `sessionId` from Phase 1
-
-**Parse Output**:
-- Extract: context-package.json path (store as `contextPath`)
-- Typical pattern: `.workflow/active/[sessionId]/.process/context-package.json`
-
-**Validation**:
-- Context package path extracted
-- File exists and is valid JSON
-
-**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
-
-**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3
-
----
-
-### Phase 3: Test Coverage Analysis
-
-**Step 3.1: Execute** - Test coverage analysis and framework detection
-
-```javascript
-SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]")
-```
-
-**Purpose**: Analyze existing codebase for:
-- Existing test patterns and conventions
-- Current test coverage
-- Related components and integration points
-- Test framework detection
-
-**Parse**: Extract testContextPath (`.workflow/active/[sessionId]/.process/test-context-package.json`)
-
-
-
-<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
-
-**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "in_progress", "activeForm": "Executing test coverage analysis"},
-  {"content": "  → Detect test framework and conventions", "status": "in_progress", "activeForm": "Detecting test framework"},
-  {"content": "  → Analyze existing test coverage", "status": "pending", "activeForm": "Analyzing test coverage"},
-  {"content": "  → Identify coverage gaps", "status": "pending", "activeForm": "Identifying coverage gaps"},
-  {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: SlashCommand execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
-
-**Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
-
-<!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
-
-**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: Phase 3 tasks completed and collapsed to summary.
-
-**After Phase 3**: Return to user showing test coverage results, then auto-continue to Phase 4/5 (depending on conflict_risk)
-
----
-
-### Phase 4: Conflict Resolution (Optional - auto-triggered by conflict risk)
-
-**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
-
-**Step 4.1: Execute** - Conflict detection and resolution
-
-```javascript
-SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
-```
-
-**Input**:
-- sessionId from Phase 1
-- contextPath from Phase 2
-- conflict_risk from context-package.json
-
-**Parse Output**:
-- Extract: Execution status (success/skipped/failed)
-- Verify: conflict-resolution.json file path (if executed)
-
-**Validation**:
-- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
-
-**Skip Behavior**:
-- If conflict_risk is "none" or "low", skip directly to Phase 5
-- Display: "No significant conflicts detected, proceeding to TDD task generation"
-
-<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
-
-**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 4: Conflict Resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"},
-  {"content": "  → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"},
-  {"content": "  → Log and analyze detected conflicts", "status": "pending", "activeForm": "Analyzing conflicts"},
-  {"content": "  → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"},
-  {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
-
-**Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
-
-<!-- TodoWrite: After Phase 4 tasks complete, REMOVE Phase 4.1-4.3, restore to orchestrator view -->
-
-**TodoWrite Update (Phase 4 completed - tasks collapsed)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 4: Conflict Resolution", "status": "completed", "activeForm": "Executing conflict resolution"},
-  {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: Phase 4 tasks completed and collapsed to summary.
-
-**After Phase 4**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 5
-
-**Memory State Check**:
-- Evaluate current context window usage and memory state
-- If memory usage is high (>110K tokens or approaching context limits):
-
-  **Step 4.5: Execute** - Memory compaction
-
-  ```javascript
-  SlashCommand(command="/compact")
-  ```
-
-  - This optimizes memory before proceeding to Phase 5
-- Memory compaction is particularly important after analysis phase which may generate extensive documentation
-- Ensures optimal performance and prevents context overflow
-
----
-
-### Phase 5: TDD Task Generation
-
-**Step 5.1: Execute** - TDD task generation via action-planning-agent with Phase 0 user configuration
-
-```javascript
-SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
-```
-
-**Note**: Phase 0 now includes:
-- Supplementary materials collection (file paths or inline content)
-- Execution method preference (Agent/Hybrid/CLI)
-- CLI tool preference (Codex/Gemini/Qwen/Auto)
-- These preferences are passed to agent for task generation
-
-**Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles), CLI execution IDs assigned
-
-**Validate**:
-- IMPL_PLAN.md exists (unified plan with TDD Implementation Tasks section)
-- IMPL-*.json files exist (one per feature, or container + subtasks for complex features)
-- TODO_LIST.md exists with internal TDD phase indicators
-- Each IMPL task includes:
-  - `meta.tdd_workflow: true`
-  - `meta.cli_execution_id: {session_id}-{task_id}`
-  - `meta.cli_execution: { "strategy": "new|resume|fork|merge_fork", ... }`
-  - `flow_control.implementation_approach` with exactly 3 steps (red/green/refactor)
-  - Green phase includes test-fix-cycle configuration
-  - `context.focus_paths`: absolute or clear relative paths (enhanced with exploration critical_files)
-  - `flow_control.pre_analysis`: includes exploration integration_points analysis
-- IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
-- User configuration applied:
-  - If executionMethod == "cli" or "hybrid": command field added to steps
-  - CLI tool preference reflected in execution guidance
-- Task count ≤18 (compliance with hard limit)
-
-**Red Flag Detection** (Non-Blocking Warnings):
-- Task count >18: `⚠️ Task count exceeds hard limit - request re-scope`
-- Missing cli_execution_id: `⚠️ Task lacks CLI execution ID for resume support`
-- Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration`
-- Generic task names: `⚠️ Vague task names suggest unclear TDD cycles`
-- Missing focus_paths: `⚠️ Task lacks clear file scope for implementation`
-
-**Action**: Log warnings to `.workflow/active/[sessionId]/.process/tdd-warnings.log` (non-blocking)
-
-<!-- TodoWrite: When task-generate-tdd executed, INSERT 3 task-generate-tdd tasks -->
-
-**TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 5: TDD Task Generation", "status": "in_progress", "activeForm": "Executing TDD task generation"},
-  {"content": "  → Discovery - analyze TDD requirements", "status": "in_progress", "activeForm": "Analyzing TDD requirements"},
-  {"content": "  → Planning - design Red-Green-Refactor cycles", "status": "pending", "activeForm": "Designing TDD cycles"},
-  {"content": "  → Output - generate IMPL tasks with internal TDD phases", "status": "pending", "activeForm": "Generating TDD tasks"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: SlashCommand execute **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
-
-**Next Action**: Tasks attached → **Execute Phase 5.1-5.3** sequentially
-
-<!-- TodoWrite: After Phase 5 tasks complete, REMOVE Phase 5.1-5.3, restore to orchestrator view -->
-
-**TodoWrite Update (Phase 5 completed - tasks collapsed)**:
-```json
-[
-  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 5: TDD Task Generation", "status": "completed", "activeForm": "Executing TDD task generation"},
-  {"content": "Phase 6: TDD Structure Validation", "status": "in_progress", "activeForm": "Validating TDD structure"}
-]
-```
-
-**Note**: Phase 5 tasks completed and collapsed to summary. Each generated IMPL task contains complete Red-Green-Refactor cycle internally.
-
-### Phase 6: TDD Structure Validation & Action Plan Verification (RECOMMENDED)
-**Internal validation first, then recommend external verification**
-
-**Internal Validation**:
-1. Each task contains complete TDD workflow (Red-Green-Refactor internally)
-2. Task structure validation:
-   - `meta.tdd_workflow: true` in all IMPL tasks
-   - `meta.cli_execution_id` present (format: {session_id}-{task_id})
-   - `meta.cli_execution` strategy assigned (new/resume/fork/merge_fork)
-   - `flow_control.implementation_approach` has exactly 3 steps
-   - Each step has correct `tdd_phase`: "red", "green", "refactor"
-   - `context.focus_paths` are absolute or clear relative paths
-   - `flow_control.pre_analysis` includes exploration integration analysis
-3. Dependency validation:
-   - Sequential features: IMPL-N depends_on ["IMPL-(N-1)"] if needed
-   - Complex features: IMPL-N.M depends_on ["IMPL-N.(M-1)"] for subtasks
-   - CLI execution strategies correctly assigned based on dependency graph
-4. Agent assignment: All IMPL tasks use @code-developer
-5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations
-6. Task count: Total tasks ≤18 (simple + subtasks hard limit)
-7. User configuration:
-   - Execution method choice reflected in task structure
-   - CLI tool preference documented in implementation guidance (if CLI selected)
-
-**Red Flag Checklist** (from TDD best practices):
-- [ ] No tasks skip Red phase (`tdd_phase: "red"` exists in step 1)
-- [ ] Test files referenced in Red phase (explicit paths, not placeholders)
-- [ ] Green phase has test-fix-cycle with `max_iterations` configured
-- [ ] Refactor phase has clear completion criteria
-
-**Non-Compliance Warning Format**:
-```
-⚠️ TDD Red Flag: [issue description]
-   Task: [IMPL-N]
-   Recommendation: [action to fix]
-```
-
-**Evidence Gathering** (Before Completion Claims):
-
-```bash
-# Verify session artifacts exist
-ls -la .workflow/active/[sessionId]/{IMPL_PLAN.md,TODO_LIST.md}
-ls -la .workflow/active/[sessionId]/.task/IMPL-*.json
-
-# Count generated artifacts
-echo "IMPL tasks: $(ls .workflow/active/[sessionId]/.task/IMPL-*.json 2>/dev/null | wc -l)"
-
-# Sample task structure verification (first task)
-jq '{id, tdd: .meta.tdd_workflow, cli_id: .meta.cli_execution_id, phases: [.flow_control.implementation_approach[].tdd_phase]}' \
-  "$(ls .workflow/active/[sessionId]/.task/IMPL-*.json | head -1)"
-```
-
-**Evidence Required Before Summary**:
-| Evidence Type | Verification Method | Pass Criteria |
-|---------------|---------------------|---------------|
-| File existence | `ls -la` artifacts | All files present |
-| Task count | Count IMPL-*.json | Count matches claims (≤18) |
-| TDD structure | jq sample extraction | Shows red/green/refactor + cli_execution_id |
-| CLI execution IDs | jq extraction | All tasks have cli_execution_id assigned |
-| Warning log | Check tdd-warnings.log | Logged (may be empty) |
-
-**Return Summary**:
-```
-TDD Planning complete for session: [sessionId]
-
-Features analyzed: [N]
-Total tasks: [M] (1 task per simple feature + subtasks for complex features)
-
-Task breakdown:
-- Simple features: [K] tasks (IMPL-1 to IMPL-K)
-- Complex features: [L] features with [P] subtasks
-- Total task count: [M] (within 18-task hard limit)
-
-Structure:
-- IMPL-1: {Feature 1 Name} (Internal: Red → Green → Refactor)
-- IMPL-2: {Feature 2 Name} (Internal: Red → Green → Refactor)
-- IMPL-3: {Complex Feature} (Container)
-  - IMPL-3.1: {Sub-feature A} (Internal: Red → Green → Refactor)
-  - IMPL-3.2: {Sub-feature B} (Internal: Red → Green → Refactor)
-[...]
-
-Plans generated:
-- Unified Implementation Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
-  (includes TDD Implementation Tasks section with workflow_type: "tdd")
-- Task List: .workflow/active/[sessionId]/TODO_LIST.md
-  (with internal TDD phase indicators and CLI execution strategies)
-- Task JSONs: .workflow/active/[sessionId]/.task/IMPL-*.json
-  (with cli_execution_id and execution strategies for resume support)
-
-TDD Configuration:
-- Each task contains complete Red-Green-Refactor cycle
-- Green phase includes test-fix cycle (max 3 iterations)
-- Auto-revert on max iterations reached
-- CLI execution strategies: new/resume/fork/merge_fork based on dependency graph
-
-User Configuration Applied:
-- Execution Method: [agent|hybrid|cli]
-- CLI Tool Preference: [codex|gemini|qwen|auto]
-- Supplementary Materials: [included|none]
-- Task generation follows cli-tools-usage.md guidelines
-
-⚠️ ACTION REQUIRED: Before execution, ensure you understand WHY each Red phase test is expected to fail.
-   This is crucial for valid TDD - if you don't know why the test fails, you can't verify it tests the right thing.
-
-Recommended Next Steps:
-1. /workflow:plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
-2. /workflow:execute --session [sessionId]  # Start TDD execution with CLI strategies
-3. /workflow:tdd-verify [sessionId]  # Post-execution TDD compliance check
-
-Quality Gate: Consider running /workflow:plan-verify to validate TDD task structure, dependencies, and CLI execution strategies
-```
-
-## TodoWrite Pattern
-
-**Core Concept**: Dynamic task attachment and collapse for TDD workflow with test coverage analysis and Red-Green-Refactor cycle generation.
-
-### Key Principles
-
-1. **Task Attachment** (when SlashCommand executed):
-   - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
-   - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 3.1, 3.2, 3.3)
-   - First attached task marked as `in_progress`, others as `pending`
-   - Orchestrator **executes** these attached tasks sequentially
-
-2. **Task Collapse** (after sub-tasks complete):
-   - Remove detailed sub-tasks from TodoWrite
-   - **Collapse** to high-level phase summary
-   - Example: Phase 3.1-3.3 collapse to "Execute test coverage analysis: completed"
-   - Maintains clean orchestrator-level view
-
-3. **Continuous Execution**:
-   - After collapse, automatically proceed to next pending phase
-   - No user intervention required between phases
-   - TodoWrite dynamically reflects current execution state
-
-**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
-
-### TDD-Specific Features
-
-- **Phase 3**: Test coverage analysis detects existing patterns and gaps
-- **Phase 5**: Generated IMPL tasks contain internal Red-Green-Refactor cycles
-- **Conditional Phase 4**: Conflict resolution only if conflict_risk ≥ medium
-
-
-
-**Note**: See individual Phase descriptions (Phase 3, 4, 5) for detailed TodoWrite Update examples with full JSON structures.
-
-## Execution Flow Diagram
-
-```
-TDD Workflow Orchestrator
-│
-├─ Phase 1: Session Discovery
-│  └─ /workflow:session:start --auto
-│     └─ Returns: sessionId
-│
-├─ Phase 2: Context Gathering
-│  └─ /workflow:tools:context-gather
-│     └─ Returns: context-package.json path
-│
-├─ Phase 3: Test Coverage Analysis                    ← ATTACHED (3 tasks)
-│  └─ /workflow:tools:test-context-gather
-│     ├─ Phase 3.1: Detect test framework
-│     ├─ Phase 3.2: Analyze existing test coverage
-│     └─ Phase 3.3: Identify coverage gaps
-│     └─ Returns: test-context-package.json           ← COLLAPSED
-│
-├─ Phase 4: Conflict Resolution (conditional)
-│  IF conflict_risk ≥ medium:
-│  └─ /workflow:tools:conflict-resolution             ← ATTACHED (3 tasks)
-│     ├─ Phase 4.1: Detect conflicts with CLI
-│     ├─ Phase 4.2: Log and analyze detected conflicts
-│     └─ Phase 4.3: Apply resolution strategies
-│     └─ Returns: conflict-resolution.json            ← COLLAPSED
-│  ELSE:
-│  └─ Skip to Phase 5
-│
-├─ Phase 5: TDD Task Generation                       ← ATTACHED (3 tasks)
-│  └─ /workflow:tools:task-generate-tdd
-│     ├─ Phase 5.1: Discovery - analyze TDD requirements
-│     ├─ Phase 5.2: Planning - design Red-Green-Refactor cycles
-│     └─ Phase 5.3: Output - generate IMPL tasks with internal TDD phases
-│     └─ Returns: IMPL-*.json, IMPL_PLAN.md           ← COLLAPSED
-│        (Each IMPL task contains internal Red-Green-Refactor cycle)
-│
-└─ Phase 6: TDD Structure Validation
-   └─ Internal validation + summary returned
-   └─ Recommend: /workflow:plan-verify
-
-Key Points:
-• ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
-• ← COLLAPSED: Sub-tasks executed and collapsed to phase summary
-• TDD-specific: Each generated IMPL task contains complete Red-Green-Refactor cycle
-```
-
-## Input Processing
-
-Convert user input to TDD-structured format:
-
-**Simple text** → Add TDD context
-**Detailed text** → Extract components with TEST_FOCUS
-**File/Issue** → Read and structure with TDD
-
-## Error Handling
-
-- **Parsing failure**: Retry once, then report
-- **Validation failure**: Report missing/invalid data
-- **Command failure**: Keep phase in_progress, report error
-- **TDD validation failure**: Report incomplete chains or wrong dependencies
-
-### TDD Warning Patterns
-
-| Pattern | Warning Message | Recommended Action |
-|---------|----------------|-------------------|
-| Task count >10 | High task count detected | Consider splitting into multiple sessions |
-| Missing test-fix-cycle | Green phase lacks auto-revert | Add `max_iterations: 3` to task config |
-| Red phase missing test path | Test file path not specified | Add explicit test file paths |
-| Generic task names | Vague names like "Add feature" | Use specific behavior descriptions |
-| No refactor criteria | Refactor phase lacks completion criteria | Define clear refactor scope |
-
-### Non-Blocking Warning Policy
-
-**All warnings are advisory** - they do not halt execution:
-1. Warnings logged to `.process/tdd-warnings.log`
-2. Summary displayed in Phase 6 output
-3. User decides whether to address before `/workflow:execute`
-
-### Error Handling Quick Reference
-
-| Error Type | Detection | Recovery Action |
-|------------|-----------|-----------------|
-| Parsing failure | Empty/malformed output | Retry once, then report |
-| Missing context-package | File read error | Re-run `/workflow:tools:context-gather` |
-| Invalid task JSON | jq parse error | Report malformed file path |
-| Task count exceeds 18 | Count validation ≥19 | Request re-scope, split into multiple sessions |
-| Missing cli_execution_id | All tasks lack ID | Regenerate tasks with phase 0 user config |
-| Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` |
-| Phase timeout | No response | Retry phase, check CLI connectivity |
-| CLI tool not available | Tool not in cli-tools.json | Fall back to alternative preferred tool |
-
-## Related Commands
-
-**Prerequisite Commands**:
-- None - TDD planning is self-contained (can optionally run brainstorm commands before)
-
-**Called by This Command** (6 phases):
-- `/workflow:session:start` - Phase 1: Create or discover TDD workflow session
-- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
-- `/workflow:tools:test-context-gather` - Phase 3: Analyze existing test patterns and coverage
-- `/workflow:tools:conflict-resolution` - Phase 4: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
-- `/compact` - Phase 4: Memory optimization (if context approaching limits)
-- `/workflow:tools:task-generate-tdd` - Phase 5: Generate TDD tasks (CLI tool usage determined semantically)
-
-**Follow-up Commands**:
-- `/workflow:plan-verify` - Recommended: Verify TDD plan quality and structure before execution
-- `/workflow:status` - Review TDD task breakdown
-- `/workflow:execute` - Begin TDD implementation
-- `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report
-
-## Next Steps Decision Table
-
-| Situation | Recommended Command | Purpose |
-|-----------|---------------------|---------|
-| First time planning | `/workflow:plan-verify` | Validate task structure before execution |
-| Warnings in tdd-warnings.log | Review log, refine tasks | Address Red Flags before proceeding |
-| High task count warning | Consider `/workflow:session:start` | Split into focused sub-sessions |
-| Ready to implement | `/workflow:execute` | Begin TDD Red-Green-Refactor cycles |
-| After implementation | `/workflow:tdd-verify` | Generate TDD compliance report |
-| Need to review tasks | `/workflow:status --session [id]` | Inspect current task breakdown |
-| Plan needs changes | `/task:replan` | Update task JSON with new requirements |
-
-### TDD Workflow State Transitions
-
-```
-/workflow:tdd-plan
-        ↓
-[Planning Complete] ──→ /workflow:plan-verify (recommended)
-        ↓
-[Verified/Ready] ─────→ /workflow:execute
-        ↓
-[Implementation] ─────→ /workflow:tdd-verify (post-execution)
-        ↓
-[Quality Report] ─────→ Done or iterate
-```