Auto Mode
When --yes or -y : Skip all confirmations, use defaults, auto-verify, auto-continue to execute if PROCEED.
Workflow TDD Plan
Usage
Plan mode (default)
$workflow-tdd-plan "Build authentication system with JWT and OAuth" $workflow-tdd-plan -y "Add rate limiting to API endpoints" $workflow-tdd-plan --session WFS-auth "Extend with 2FA support"
Verify mode
$workflow-tdd-plan verify --session WFS-auth $workflow-tdd-plan verify
Flags:
-
-y, --yes : Skip all confirmations (auto mode)
-
--session ID : Use specific session
Overview
Multi-mode TDD planning pipeline using subagent coordination. Plan mode runs 6 sequential phases with conditional branching; verify mode operates on existing plans with TDD compliance validation.
Core Principle: NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
┌──────────────────────────────────────────────────────────────────┐ │ WORKFLOW TDD PLAN PIPELINE │ ├──────────────────────────────────────────────────────────────────┤ │ │ │ Mode Detection: plan | verify │ │ │ │ ═══ Plan Mode (default) ═══ │ │ │ │ Phase 1: Session Discovery │ │ ├─ Create or find workflow session │ │ └─ Initialize planning-notes.md with TDD context │ │ │ │ Phase 2: Context Gathering (spawn_agent: context-search-agent) │ │ ├─ Codebase analysis → context-package.json │ │ └─ Conflict risk assessment │ │ │ │ Phase 3: Test Coverage Analysis (spawn_agent: cli-explore-agent)│ │ ├─ Detect test framework and conventions │ │ ├─ Analyze existing test coverage │ │ └─ Output: test-context-package.json │ │ │ │ Phase 4: Conflict Resolution (conditional: risk ≥ medium) │ │ ├─ CLI-driven conflict analysis │ │ └─ User-selected resolution strategies │ │ │ │ Phase 5: TDD Task Generation (spawn_agent: action-planning-agent)│ │ ├─ Generate tasks with Red-Green-Refactor cycles │ │ └─ Output: IMPL_PLAN.md + task JSONs + TODO_LIST.md │ │ │ │ Phase 6: TDD Structure Validation │ │ ├─ Validate Red-Green-Refactor structure │ │ └─ Present Plan Confirmation Gate │ │ │ │ Plan Confirmation Gate │ │ ├─ "Verify TDD Compliance" → Phase 7 │ │ ├─ "Start Execution" → workflow-execute │ │ └─ "Review Status" → Display inline │ │ │ │ ═══ Verify Mode ═══ │ │ Phase 7: TDD Verification (spawn_agent: cli-explore-agent) │ │ └─ 4-dimension TDD compliance → TDD_COMPLIANCE_REPORT.md │ │ │ └──────────────────────────────────────────────────────────────────┘
Data Flow
User Input (task description) │ ↓ [Convert to TDD Structured Format] │ TDD: [Feature Name] │ GOAL: [objective] │ SCOPE: [boundaries] │ CONTEXT: [background] │ TEST_FOCUS: [test scenarios] │ Phase 1 ──→ sessionId, planning-notes.md │ Phase 2 ──→ context-package.json, conflictRisk │ Phase 3 ──→ test-context-package.json │ ├── conflictRisk ≥ medium ──→ Phase 4 ──→ conflict-resolution.json └── conflictRisk < medium ──→ skip Phase 4 │ Phase 5 ──→ IMPL_PLAN.md (with Red-Green-Refactor), task JSONs, TODO_LIST.md │ Phase 6 ──→ TDD structure validation │ ├── Verify → Phase 7 → TDD_COMPLIANCE_REPORT.md ├── Execute → workflow-execute skill └── Review → inline display
Session Structure
.workflow/active/WFS-{session}/ ├── workflow-session.json # Session metadata ├── planning-notes.md # Accumulated context across phases ├── IMPL_PLAN.md # Implementation plan with TDD cycles ├── plan.json # Structured plan overview ├── TODO_LIST.md # Task checklist ├── .task/ # Task definitions with TDD phases │ ├── IMPL-1.json # Each task has Red-Green-Refactor steps │ └── IMPL-N.json └── .process/ ├── context-package.json # Phase 2 output ├── test-context-package.json # Phase 3 output ├── conflict-resolution.json # Phase 4 output (conditional) └── TDD_COMPLIANCE_REPORT.md # Phase 7 output
Implementation
Session Initialization
const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
// Parse flags const AUTO_YES = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y') const sessionMatch = $ARGUMENTS.match(/--session\s+(\S+)/) const existingSessionId = sessionMatch ? sessionMatch[1] : null
// Mode detection const cleanArgs = $ARGUMENTS .replace(/--yes|-y|--session\s+\S+/g, '').trim()
let mode = 'plan' if (cleanArgs.startsWith('verify')) mode = 'verify'
const taskDescription = cleanArgs .replace(/^verify\s*/, '') .replace(/^["']|["']$/g, '') .trim()
// Convert to TDD structured format
function toTddStructured(desc) {
const featureName = desc.split(/\s+/).slice(0, 3).join(' ')
return TDD: ${featureName} GOAL: ${desc} SCOPE: Core implementation CONTEXT: New development TEST_FOCUS: Unit tests, integration tests, edge cases
}
const structuredDesc = toTddStructured(taskDescription)
Phase 1: Session Discovery (Plan Mode)
Objective: Create or find workflow session, initialize planning notes with TDD context.
if (mode !== 'plan') { // verify: locate existing session // → Jump to Phase 7 }
let sessionId, sessionFolder
if (existingSessionId) {
sessionId = existingSessionId
sessionFolder = .workflow/active/${sessionId}
if (!Bash(test -d "${sessionFolder}" && echo yes).trim()) {
console.log(ERROR: Session ${sessionId} not found)
return
}
} else {
// Auto-detect from .workflow/active/ or create new
const sessions = Bash(ls -d .workflow/active/WFS-* 2>/dev/null).trim().split('\n').filter(Boolean)
if (sessions.length === 0 || taskDescription) {
// Create new session
const slug = taskDescription.toLowerCase()
.replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-').substring(0, 40)
sessionId = WFS-${slug}
sessionFolder = .workflow/active/${sessionId}
Bash(mkdir -p "${sessionFolder}/.task" "${sessionFolder}/.process")
Write(`${sessionFolder}/workflow-session.json`, JSON.stringify({
session_id: sessionId,
status: 'planning',
workflow_type: 'tdd',
created_at: getUtc8ISOString(),
task_description: taskDescription
}, null, 2))
} else if (sessions.length === 1) {
sessionId = sessions[0].split('/').pop()
sessionFolder = sessions[0]
} else {
// Multiple sessions — ask user
if (AUTO_YES) {
sessionFolder = sessions[0]
sessionId = sessions[0].split('/').pop()
} else {
const answer = AskUserQuestion({
questions: [{
question: "Multiple sessions found. Select one:",
header: "Session",
multiSelect: false,
options: sessions.slice(0, 4).map(s => ({
label: s.split('/').pop(),
description: s
}))
}]
})
sessionId = answer.Session
sessionFolder = .workflow/active/${sessionId}
}
}
}
// Initialize planning-notes.md with TDD context
Write(${sessionFolder}/planning-notes.md, `# TDD Planning Notes
User Intent
${structuredDesc}
TDD Principles
- NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
- Red-Green-Refactor cycle for all tasks
- Test-first forces edge case discovery before implementation `)
console.log(Session: ${sessionId})
Phase 2: Context Gathering (spawn_agent)
Objective: Gather project context, assess conflict risk.
console.log(\n## Phase 2: Context Gathering\n)
const ctxAgent = spawn_agent({
agent: ~/.codex/agents/context-search-agent.md,
instruction: `
Gather implementation context for TDD planning.
Session: ${sessionFolder} Task: ${taskDescription} Mode: TDD_PLAN
Steps
- Analyze project structure (package.json, tsconfig, etc.)
- Search for existing similar implementations
- Identify integration points and dependencies
- Assess conflict risk with existing code
- Generate context package
Output
Write context package to: ${sessionFolder}/.process/context-package.json Format: { "critical_files": [...], "patterns": [...], "dependencies": [...], "integration_points": [...], "conflict_risk": "none" | "low" | "medium" | "high", "conflict_areas": [...], "constraints": [...] } ` })
wait({ id: ctxAgent }) close_agent({ id: ctxAgent })
// Parse outputs
const contextPkg = JSON.parse(Read(${sessionFolder}/.process/context-package.json) || '{}')
const conflictRisk = contextPkg.conflict_risk || 'none'
// Update planning-notes.md
Edit(${sessionFolder}/planning-notes.md, {
oldText: '## User Intent',
newText: `## Context Findings
- Critical files: ${(contextPkg.critical_files || []).join(', ')}
- Conflict risk: ${conflictRisk}
- Constraints: ${(contextPkg.constraints || []).join('; ')}
User Intent`
})
console.log( Context gathered. Conflict risk: ${conflictRisk})
Phase 3: Test Coverage Analysis (spawn_agent)
Objective: Analyze existing test patterns and coverage.
console.log(\n## Phase 3: Test Coverage Analysis\n)
const testAgent = spawn_agent({
agent: ~/.codex/agents/cli-explore-agent.md,
instruction: `
Analyze test coverage and framework for TDD planning.
Session: ${sessionFolder} Context: ${sessionFolder}/.process/context-package.json
Steps
- Detect test framework (Jest, Vitest, Mocha, etc.)
- Identify test file patterns and conventions
- Analyze existing test coverage
- Identify coverage gaps
- Extract test utilities and helpers
Output
Write test context to: ${sessionFolder}/.process/test-context-package.json Format: { "test_framework": "jest" | "vitest" | "mocha" | "other", "test_patterns": { "unit": "/*.test.ts", "integration": "/*.integration.test.ts" }, "coverage_summary": { "lines": 75.5, "branches": 68.2, "functions": 80.1 }, "coverage_gaps": [...], "test_utilities": [...], "conventions": { "naming": "describe/it", "mocking": "jest.mock", "assertions": "expect" } } ` })
wait({ id: testAgent }) close_agent({ id: testAgent })
const testContext = JSON.parse(Read(${sessionFolder}/.process/test-context-package.json) || '{}')
// Update planning-notes
Edit(${sessionFolder}/planning-notes.md, {
oldText: '## TDD Principles',
newText: `## Test Context
- Framework: ${testContext.test_framework || 'unknown'}
- Coverage: ${testContext.coverage_summary?.lines || 'N/A'}% lines
- Gaps: ${(testContext.coverage_gaps || []).join(', ')}
TDD Principles`
})
console.log( Test framework: ${testContext.test_framework})
Phase 4: Conflict Resolution (Conditional)
Objective: Detect and resolve conflicts when risk ≥ medium.
if (['medium', 'high'].includes(conflictRisk)) {
console.log(\n## Phase 4: Conflict Resolution (risk: ${conflictRisk})\n)
Bash({ command: `ccw cli -p "PURPOSE: Analyze and resolve conflicts between planned changes and existing codebase. TASK: • Read context package for conflict areas • Analyze each conflict area in detail • Propose resolution strategies (refactor, adapt, isolate, defer) • For each conflict: assess impact and recommend approach MODE: analysis CONTEXT: @**/* EXPECTED: JSON: {conflicts: [{area, severity, description, strategy, impact}], summary: string} CONSTRAINTS: Focus on ${(contextPkg.conflict_areas || []).join(', ')}
TASK DESCRIPTION: ${taskDescription}" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause`, run_in_background: true }) // Wait for CLI → conflicts[]
if (!AUTO_YES && conflicts.length > 0) {
// Present conflicts and let user select strategies
console.log(\n### Conflicts Found: ${conflicts.length}\n)
conflicts.forEach((c, i) => {
console.log(${i + 1}. [${c.severity}] ${c.area}: ${c.description})
console.log( Strategy: ${c.strategy} | Impact: ${c.impact})
})
const answer = AskUserQuestion({
questions: [{
question: "Accept conflict resolution strategies?",
header: "Conflicts",
multiSelect: false,
options: [
{ label: "Accept All", description: "Apply all recommended strategies" },
{ label: "Review Each", description: "Approve strategies individually" },
{ label: "Skip", description: "Proceed without resolving" }
]
}]
})
}
// Write resolution
Write(${sessionFolder}/.process/conflict-resolution.json,
JSON.stringify({ conflicts, resolved_at: getUtc8ISOString() }, null, 2))
} else {
console.log( Conflict risk: ${conflictRisk} — skipping Phase 4)
}
Phase 5: TDD Task Generation (spawn_agent)
Objective: Generate IMPL_PLAN.md with Red-Green-Refactor cycles, task JSONs, TODO_LIST.md.
console.log(\n## Phase 5: TDD Task Generation\n)
const planAgent = spawn_agent({
agent: ~/.codex/agents/action-planning-agent.md,
instruction: `
Generate TDD implementation plan with Red-Green-Refactor cycles.
Session: ${sessionFolder}
Task: ${taskDescription}
Context: ${sessionFolder}/.process/context-package.json
Test Context: ${sessionFolder}/.process/test-context-package.json
Planning Notes: ${sessionFolder}/planning-notes.md
${conflictRisk === 'medium' || conflictRisk === 'high'
? **Conflict Resolution**: ${sessionFolder}/.process/conflict-resolution.json : ''}
TDD Requirements
Each task MUST include Red-Green-Refactor cycle:
- Red Phase: Write failing test first
- Define test cases
- Verify test fails (proves test is valid)
- Document expected failure
- Green Phase: Implement minimal code to pass
- Write simplest implementation
- Run tests until passing
- Max 3 test-fix iterations (auto-revert if exceeded)
- Refactor Phase: Improve code quality
- Refactor with tests as safety net
- Maintain passing tests
- Document improvements
Output Requirements
- IMPL_PLAN.md at ${sessionFolder}/IMPL_PLAN.md
- Section 1: Requirements Summary
- Section 2: Test Strategy (framework, patterns, coverage goals)
- Section 3: Task Breakdown with TDD cycles
- Section 4: Implementation Strategy
- Section 5: Risk Assessment
- plan.json at ${sessionFolder}/plan.json
- {task_ids[], recommended_execution, complexity, tdd_compliance: true}
- Task JSONs at ${sessionFolder}/.task/IMPL-{N}.json
- Each task has "implementation" array with 3 steps: [ {step: 1, tdd_phase: "red", description: "Write failing test", ...}, {step: 2, tdd_phase: "green", description: "Implement code", test_fix_cycle: {max_iterations: 3, auto_revert: true}}, {step: 3, tdd_phase: "refactor", description: "Refactor code", ...} ]
- TODO_LIST.md at ${sessionFolder}/TODO_LIST.md
- Checkbox format: - [ ] IMPL-{N}: {title} (TDD) ` })
wait({ id: planAgent }) close_agent({ id: planAgent })
console.log( TDD tasks generated)
Phase 6: TDD Structure Validation
Objective: Validate Red-Green-Refactor structure in all tasks.
console.log(\n## Phase 6: TDD Structure Validation\n)
// Read all task JSONs
const taskFiles = Bash(ls ${sessionFolder}/.task/IMPL-*.json 2>/dev/null).trim().split('\n').filter(Boolean)
const tasks = taskFiles.map(f => JSON.parse(Read(f)))
// Validate TDD structure const validationErrors = [] for (const task of tasks) { const impl = task.implementation || []
// Check 3-step structure
if (impl.length !== 3) {
validationErrors.push(${task.id}: Expected 3 steps, found ${impl.length})
continue
}
// Check Red phase
if (impl[0].tdd_phase !== 'red') {
validationErrors.push(${task.id}: Step 1 must be Red phase)
}
// Check Green phase with test-fix-cycle
if (impl[1].tdd_phase !== 'green') {
validationErrors.push(${task.id}: Step 2 must be Green phase)
}
if (!impl[1].test_fix_cycle || !impl[1].test_fix_cycle.max_iterations) {
validationErrors.push(${task.id}: Green phase missing test-fix-cycle config)
}
// Check Refactor phase
if (impl[2].tdd_phase !== 'refactor') {
validationErrors.push(${task.id}: Step 3 must be Refactor phase)
}
}
if (validationErrors.length > 0) {
console.log(\n### TDD Structure Validation Errors:\n)
validationErrors.forEach(e => console.log( - ${e}))
if (!AUTO_YES) { const answer = AskUserQuestion({ questions: [{ question: "TDD structure validation failed. Continue anyway?", header: "Validation", multiSelect: false, options: [ { label: "Fix and Retry", description: "Regenerate tasks with correct structure" }, { label: "Continue", description: "Proceed despite errors" }, { label: "Abort", description: "Stop planning" } ] }] })
if (answer.Validation === "Fix and Retry") {
// Re-run Phase 5
// → goto Phase 5
} else if (answer.Validation === "Abort") {
return
}
}
} else {
console.log( ✓ All tasks have valid Red-Green-Refactor structure)
}
// Plan Confirmation Gate
const taskCount = tasks.length
console.log(\n## Plan Generated\n)
console.log( Tasks: ${taskCount})
console.log( Plan: ${sessionFolder}/IMPL_PLAN.md)
if (AUTO_YES) {
console.log( [--yes] Auto-verifying TDD compliance...)
// → Fall through to Phase 7
} else {
const nextStep = AskUserQuestion({
questions: [{
question: "TDD plan generated. What's next?",
header: "Next Step",
multiSelect: false,
options: [
{ label: "Verify TDD Compliance (Recommended)", description: "Run full TDD compliance verification" },
{ label: "Start Execution", description: "Proceed to workflow-execute" },
{ label: "Review Status", description: "Display plan summary inline" }
]
}]
})
if (nextStep['Next Step'] === 'Start Execution') {
console.log(\nReady to execute. Run: $workflow-execute --session ${sessionId})
return
}
if (nextStep['Next Step'] === 'Review Status') {
const plan = Read(${sessionFolder}/IMPL_PLAN.md)
console.log(plan)
return
}
// Verify → continue to Phase 7
}
Phase 7: TDD Verification (Verify Mode)
Objective: Full TDD compliance verification with quality gate.
if (mode === 'verify' || /* auto-verify from Phase 6 */) {
console.log(\n## Phase 7: TDD Verification\n)
// Find session if in verify mode entry if (mode === 'verify' && !sessionFolder) { // Session discovery (same logic as Phase 1) }
const verifyAgent = spawn_agent({
agent: ~/.codex/agents/cli-explore-agent.md,
instruction: `
Verify TDD compliance across 4 dimensions.
Session: ${sessionFolder}
Verification Dimensions
A. Test-First Structure
- Every task has Red-Green-Refactor cycle
- Red phase defines failing tests
- Green phase implements code
- Refactor phase improves quality
B. Test Coverage
- All critical paths have tests
- Edge cases covered
- Integration points tested
- Coverage meets project standards
C. Cycle Integrity
- Red phase: test fails before implementation
- Green phase: minimal code to pass
- Refactor phase: maintains passing tests
- No production code without failing test first
D. Quality Gates
- Test-fix-cycle configured (max 3 iterations)
- Auto-revert on iteration limit
- Clear acceptance criteria
- Testable convergence conditions
Output
Write report to: ${sessionFolder}/.process/TDD_COMPLIANCE_REPORT.md
Format:
TDD Compliance Report
Summary
- Quality Gate: APPROVED | CONDITIONAL | BLOCKED
- Tasks Analyzed: N
- Compliance Score: X%
Dimension Scores
- A. Test-First Structure: PASS/WARN/FAIL
- B. Test Coverage: PASS/WARN/FAIL
- C. Cycle Integrity: PASS/WARN/FAIL
- D. Quality Gates: PASS/WARN/FAIL
Issues Found
[List specific issues with task IDs]
Recommendations
[Actionable recommendations]
Quality Gate Decision
APPROVED: All dimensions PASS, ready for execution CONDITIONAL: Minor warnings, can proceed with caution BLOCKED: Critical failures, must fix before execution ` })
wait({ id: verifyAgent }) close_agent({ id: verifyAgent })
const report = Read(${sessionFolder}/.process/TDD_COMPLIANCE_REPORT.md)
const qualityGate = report.match(/Quality Gate: (\w+)/)?.[1] || 'UNKNOWN'
console.log( Quality gate: ${qualityGate})
console.log( Report: ${sessionFolder}/.process/TDD_COMPLIANCE_REPORT.md)
if (AUTO_YES && qualityGate === 'APPROVED') {
console.log( [--yes] TDD compliance verified. Ready for execution.)
console.log( Run: $workflow-execute --session ${sessionId})
}
}
Error Handling
Error Recovery
No active session Guide: run $workflow-tdd-plan "description" first
Context gathering timeout Retry with reduced scope
Test framework detection failed Manual specification in test-context-package.json
TDD structure validation failed Regenerate tasks or fix manually
Conflict analysis failure Skip Phase 4, proceed with warning
Task generation failure Retry agent with simplified context
Verification failure Display partial results
Session not found (verify) List available sessions
TDD Compliance Requirements
The Iron Law
NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
Red-Green-Refactor Cycle
Every task must have:
-
Red: Write failing test (proves test is valid)
-
Green: Implement minimal code to pass (with test-fix-cycle)
-
Refactor: Improve code quality (maintain passing tests)
Quality Gates
-
Test-fix-cycle: max 3 iterations
-
Auto-revert: triggered when max iterations reached
-
Coverage goals: defined per project
-
Acceptance criteria: testable and measurable
Compact Protection
COMPACT DIRECTIVE: If context compression occurs:
-
Re-read planning-notes.md for accumulated context
-
Re-read workflow-session.json for session state
-
Phase 5 is the most token-intensive — if compressed, re-read task JSONs on demand