feat: fix readme

Author: dori

README.md

@@ -57,10 +57,14 @@ It enforces evidence-based research, reuse over reinvention, and human-in-the-lo
 |------|-----------------|
 | `set_coding_task` | Creates/updates task metadata; classifies task_size; returns next-step workflow guidance |
 | `get_current_coding_task` | Recovers the latest task_id and metadata to resume work safely |
-| `judge_coding_plan` | Validates plan/design; requires library selection and internal reuse maps; flags risks |
-| `judge_code_change` | Reviews unified Git diffs for correctness, reuse, security, and code quality |
-| `judge_testing_implementation` | Validates tests using real runner output and optional coverage |
-| `judge_coding_task_completion` | Final gate ensuring plan, code, and tests approvals before completion |
+| `get_user_feedback` | **MANDATORY FIRST STEP**: Elicits requirements, technical decisions, and repository analysis |
+| `create_implementation_plan` | LLM creates detailed implementation plan with research and best practices |
+| `update_plan_with_llm_feedback` | Refines plans based on LLM technical validation feedback |
+| `get_user_approve_requirement` | **MANDATORY**: Gets user approval for implementation plans |
+| `judge_coding_plan` | LLM validates plan/design; requires library selection and internal reuse maps; flags risks |
+| `judge_code_change` | LLM reviews code for correctness, reuse, security, and code quality |
+| `judge_testing_implementation` | LLM validates tests using real runner output and coverage reports |
+| `judge_coding_task_completion` | Final LLM gate ensuring plan, code, and tests approvals before completion |
 | `raise_missing_requirements` | Elicits missing details and decisions to unblock progress |
 | `raise_obstacle` | Engages the user on trade‑offs, constraints, and enforced changes |
 
@@ -70,24 +74,30 @@ MCP as a Judge implements a sophisticated collaborative workflow that ensures hi
 
 ## 🔄 Enhanced Collaborative Workflow
 
-### **Phase 1: 🧠 Enhanced Brainstorming**
+### **Phase 1: 🧠 Requirements Brainstorming**
 ```
-📋 get_enhanced_user_feedback
+📋 get_user_feedback
 ├── Requirements gathering + clarifications
-├── Documentation & reference requests
-├── Success criteria definition
-├── Environment & deployment context
-└── Testing strategy preferences
+├── Technical decision areas (framework, database, etc.)
+├── Repository analysis for language/framework decisions
+├── Specific questions to clarify gaps
+└── Suggested options with pros/cons
 ```
 
-### **Phase 2: 📋 Comprehensive Plan Creation**
+### **Phase 2: 📋 Plan Creation & Refinement**
 ```
 🔬 create_implementation_plan
 ├── Technical research & analysis
 ├── Architecture & design patterns
-├── Test strategy & coverage requirements
-├── Implementation scope & milestones
-└── Risk assessment & mitigation
+├── Implementation scope & approach
+├── Language-specific best practices
+└── Risk assessment & considerations
+
+🔧 update_plan_with_llm_feedback (if needed)
+├── LLM identifies technical issues
+├── Creates improved plan version
+├── Addresses technical concerns
+└── Maintains user requirements
 ```
 
 ### **Phase 3: 🔄 Dual Approval Loop**
@@ -104,49 +114,45 @@ MCP as a Judge implements a sophisticated collaborative workflow that ensures hi
         └── ❌ Rejected → Back to Brainstorming
 ```
 
-### **Phase 4: 🚀 Enhanced Implementation**
+### **Phase 4: 🚀 Implementation & Validation**
 ```
 🧹 Clean History (delete brainstorming records)
     ↓
-🏗️ judge_code_change (Architecture + Security Review)
+🏗️ judge_code_change (Code Review & Validation)
     ├── LLM validates: Code structure & patterns
     ├── LLM checks: Security best practices
-    └── LLM ensures: Requirements compliance
+    ├── LLM ensures: Requirements compliance
+    ├── LLM reviews: Architecture decisions
+    └── LLM verifies: Best practice adherence
     ↓
-👤 User Code Review (Optional validation step)
-    ├── User validates: Business logic correctness
-    └── User approves: Implementation approach
-    ↓
-🧪 judge_testing_implementation (Tests + Coverage)
+🧪 judge_testing_implementation (Test Validation)
     ├── LLM validates: Test completeness & quality
-    ├── LLM checks: Coverage requirements met
-    └── LLM ensures: Edge cases covered
-    ↓
-📚 Documentation Review (Optional documentation check)
-    ├── LLM validates: Documentation completeness
-    ├── LLM checks: Code comments & clarity
-    └── LLM ensures: Usage examples provided
+    ├── LLM checks: Test execution results
+    ├── LLM ensures: Coverage requirements met
+    ├── LLM reviews: Test types implemented
+    └── LLM verifies: Edge cases covered
     ↓
-✅ judge_coding_task_completion (Final quality gate)
+✅ judge_coding_task_completion (Final Quality Gate)
     ├── LLM validates: All requirements implemented
-    ├── LLM checks: Best practices followed
+    ├── LLM checks: All approvals obtained
     ├── LLM ensures: Production readiness
+    ├── LLM verifies: Best practices followed
     └── LLM confirms: Task completion criteria met
     ↓
 🎉 Task Complete
 ```
 
-### **🔑 Key Quality Enhancements**
-- **📋 Comprehensive Requirements**: Documentation, success criteria, environment context
-- **🧪 Test-First Planning**: Test strategy integrated from planning phase
-- **🔄 Iterative Refinement**: Multiple approval loops ensure quality
-- **👤 User Involvement**: Optional code review for critical changes
-- **🤖 LLM Quality Gates**: Continuous validation of requirements, best practices, and completeness
-- **📚 Documentation Focus**: Optional documentation validation with LLM review
-- **🛡️ Multi-Layer Validation**: Architecture, security, testing, and completion gates
+### **🔑 Key Quality Features**
+- **📋 Structured Requirements**: Systematic gathering with technical decision support
+- **🔄 Dual Approval Process**: Both user and LLM must approve plans before implementation
+- **🤖 LLM Quality Gates**: Continuous validation at every implementation step
+- **🛡️ Multi-Layer Validation**: Plan validation, code review, testing, and completion gates
 - **✅ Requirements Traceability**: LLM ensures all original requirements are implemented
-- **🏆 Best Practice Enforcement**: LLM validates coding standards and patterns
-- **🔍 Comprehensive Coverage**: LLM checks edge cases, error handling, and production readiness
+- **🏆 Best Practice Enforcement**: LLM validates coding standards and security practices
+- **🔍 Comprehensive Testing**: Test execution results and coverage validation
+- **🧹 Context Management**: Automatic cleanup of brainstorming records for focused implementation
+- **📊 Progress Tracking**: Task state management with workflow guidance
+- **🔧 Plan Refinement**: Automatic plan improvement based on LLM technical feedback
 
 ### **🎯 Key Workflow Principles**