feat(workflow): 更新 lite-lite-lite 和 tdd-plan 文档，增强描述和工具支持

2026-02-04 01:40:45 +08:00 · 2026-01-20 11:59:06 +08:00
parent c1d12384c3
commit 1376dc71d9
2 changed files with 176 additions and 11 deletions
--- a/.claude/commands/workflow/lite-lite-lite.md
+++ b/.claude/commands/workflow/lite-lite-lite.md
@@ -1,8 +1,8 @@
 ---
 name: workflow:lite-lite-lite
-description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts, auto tool selection based on task analysis, user-driven iteration via AskUser.
+description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.
 argument-hint: "<task description>"
-allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp__ace-tool__search_context(*)
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__write_file(*)
 ---

 # Ultra-Lite Multi-Tool Workflow
@@ -14,22 +14,23 @@ allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp_
 /workflow:lite-lite-lite "Refactor payment module for multi-gateway support"
 ```

-**Core Philosophy**: Minimal friction, maximum velocity. No files, no artifacts - just analyze and execute.
+**Core Philosophy**: Minimal friction, maximum velocity. Simple tasks = no artifacts. Complex tasks = lightweight planning doc in `.workflow/.scratchpad/`.

 ## Overview

-**Zero-artifact workflow**: Clarify → Select Tools → Multi-Mode Analysis → Decision → Direct Execution
+**Complexity-aware workflow**: Clarify → Assess Complexity → Select Tools → Multi-Mode Analysis → Decision → Direct Execution

-**vs multi-cli-plan**: No IMPL_PLAN.md, plan.json, synthesis.json - all state in memory.
+**vs multi-cli-plan**: No IMPL_PLAN.md, plan.json, synthesis.json - state in memory or lightweight scratchpad doc for complex tasks.

 ## Execution Flow

 ```
 Phase 1: Clarify Requirements → AskUser for missing details
+Phase 1.5: Assess Complexity → Determine if planning doc needed
 Phase 2: Select Tools (CLI → Mode → Agent) → 3-step selection
 Phase 3: Multi-Mode Analysis → Execute with --resume chaining
 Phase 4: User Decision → Execute / Refine / Change / Cancel
-Phase 5: Direct Execution → No plan files, immediate implementation
+Phase 5: Direct Execution → No plan files (simple) or scratchpad doc (complex)
 ```

 ## Phase 1: Clarify Requirements
@@ -58,6 +59,25 @@ mcp__ace-tool__search_context({
 })
 ```

+## Phase 1.5: Assess Complexity
+
+| Level | Creates Plan Doc | Trigger Keywords |
+|-------|------------------|------------------|
+| **simple** | ❌ | (default) |
+| **moderate** | ✅ | module, system, service, integration, multiple |
+| **complex** | ✅ | refactor, migrate, security, auth, payment, database |
+
+```javascript
+// Complexity detection (after ACE query)
+const isComplex = /refactor|migrate|security|auth|payment|database/i.test(taskDescription)
+const isModerate = /module|system|service|integration|multiple/i.test(taskDescription) || aceContext?.relevant_files?.length > 2
+
+if (isComplex || isModerate) {
+  const planPath = `.workflow/.scratchpad/lite3-${taskSlug}-${dateStr}.md`
+  // Create planning doc with: Task, Status, Complexity, Analysis Summary, Execution Plan, Progress Log
+}
+```
+
 ## Phase 2: Select Tools

 ### Tool Definitions
@@ -308,6 +328,8 @@ function aggregateResults(mode, results) {
        critiques: parseCritiques(results.find(r => r.phase === 'challenge')?.result), riskScore: calculateRiskScore(results) }
  }
 }
+
+// If planPath exists: update Analysis Summary & Execution Plan sections
 ```

 ## Phase 4: User Decision
@@ -348,13 +370,14 @@ AskUserQuestion({
    multiSelect: false
  }]
 })
+// If planPath exists: record decision to Decisions Made table
 // Routing: Execute → Phase 5 | Refine → Phase 3 | Change → Phase 2 | Cancel → End
 ```

 ## Phase 5: Direct Execution

 ```javascript
-// No IMPL_PLAN.md, no plan.json - direct implementation
+// Simple tasks: No artifacts | Complex tasks: Update scratchpad doc
 const executionAgents = agents.filter(a => a.canExecute)
 const executionTool = selectedAgent.canExecute ? selectedAgent : selectedCLIs[0]

@@ -378,6 +401,7 @@ CONSTRAINTS: Follow existing patterns
    run_in_background: false
  })
 }
+// If planPath exists: update Status to completed/failed, append to Progress Log
 ```

 ## TodoWrite Structure
@@ -385,6 +409,7 @@ CONSTRAINTS: Follow existing patterns
 ```javascript
 TodoWrite({ todos: [
  { content: "Phase 1: Clarify requirements", status: "in_progress", activeForm: "Clarifying requirements" },
+  { content: "Phase 1.5: Assess complexity", status: "pending", activeForm: "Assessing complexity" },
  { content: "Phase 2: Select tools", status: "pending", activeForm: "Selecting tools" },
  { content: "Phase 3: Multi-mode analysis", status: "pending", activeForm: "Running analysis" },
  { content: "Phase 4: User decision", status: "pending", activeForm: "Awaiting decision" },
@@ -409,16 +434,19 @@ TodoWrite({ todos: [
 | Task unclear | Default to first CLI + code-developer |
 | Ambiguous task | Force clarification via AskUser |
 | Execution fails | Present error, ask user for direction |
+| Plan doc write fails | Continue without doc (degrade to zero-artifact mode) |
+| Scratchpad dir missing | Auto-create `.workflow/.scratchpad/` |

 ## Comparison with multi-cli-plan

 | Aspect | lite-lite-lite | multi-cli-plan |
 |--------|----------------|----------------|
-| **Artifacts** | None | IMPL_PLAN.md, plan.json, synthesis.json |
+| **Artifacts** | Conditional (scratchpad doc for complex tasks) | Always (IMPL_PLAN.md, plan.json, synthesis.json) |
 | **Session** | Stateless (--resume chaining) | Persistent session folder |
 | **Tool Selection** | 3-step (CLI → Mode → Agent) | Config-driven fixed tools |
 | **Analysis Modes** | 5 modes with --resume | Fixed synthesis rounds |
-| **Best For** | Quick analysis, adversarial validation | Complex multi-step implementations |
+| **Complexity** | Auto-detected (simple/moderate/complex) | Assumed complex |
+| **Best For** | Quick analysis, simple-to-moderate tasks | Complex multi-step implementations |

 ## Post-Completion Expansion

--- a/.claude/commands/workflow/tdd-plan.md
+++ b/.claude/commands/workflow/tdd-plan.md
@@ -37,6 +37,44 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 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
@@ -183,7 +221,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
  {"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": "  → Present conflicts to user", "status": "pending", "activeForm": "Presenting 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"}
@@ -251,6 +289,13 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
 - Task count ≤10 (compliance with task limit)

+**Red Flag Detection** (Non-Blocking Warnings):
+- Task count >10: `⚠️ High task count may indicate insufficient decomposition`
+- Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration`
+- Generic task names: `⚠️ Vague task names suggest unclear TDD cycles`
+
+**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)**:
@@ -302,6 +347,42 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations
 6. Task count: Total tasks ≤10 (simple + subtasks)

+**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, 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 |
+| TDD structure | jq sample extraction | Shows red/green/refactor |
+| Warning log | Check tdd-warnings.log | Logged (may be empty) |
+
 **Return Summary**:
 ```
 TDD Planning complete for session: [sessionId]
@@ -333,6 +414,9 @@ TDD Configuration:
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached

+⚠️ 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:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
 2. /workflow:execute --session [sessionId]  # Start TDD execution
@@ -400,7 +484,7 @@ TDD Workflow Orchestrator
 │  IF conflict_risk ≥ medium:
 │  └─ /workflow:tools:conflict-resolution             ← ATTACHED (3 tasks)
 │     ├─ Phase 4.1: Detect conflicts with CLI
-│     ├─ Phase 4.2: Present conflicts to user
+│     ├─ Phase 4.2: Log and analyze detected conflicts
 │     └─ Phase 4.3: Apply resolution strategies
 │     └─ Returns: conflict-resolution.json            ← COLLAPSED
 │  ELSE:
@@ -439,6 +523,34 @@ Convert user input to TDD-structured format:
 - **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 |
+| High task count (>10) | Count validation | Log warning, continue (non-blocking) |
+| Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` |
+| Phase timeout | No response | Retry phase, check CLI connectivity |
+
 ## Related Commands

 **Prerequisite Commands**:
@@ -458,3 +570,28 @@ Convert user input to TDD-structured format:
 - `/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:action-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:action-plan-verify (recommended)
+        ↓
+[Verified/Ready] ─────→ /workflow:execute
+        ↓
+[Implementation] ─────→ /workflow:tdd-verify (post-execution)
+        ↓
+[Quality Report] ─────→ Done or iterate
+```