optimize requirements pilot

commands/requirements-pilot.md

@@ -1,61 +1,120 @@
 ## Usage
-`/requirements-pilot <FEATURE_DESCRIPTION> [TESTING_PREFERENCE]`
+`/requirements-pilot <FEATURE_DESCRIPTION> [OPTIONS]`
 
-### Testing Control Options
-- **Explicit Test**: Include `--test`, `要测试`, `测试` to force testing execution
-- **Explicit Skip**: Include `--no-test`, `不要测试`, `跳过测试` to skip testing phase
-- **Interactive Mode**: Default behavior - asks user at testing decision point
+### Options
+- `--skip-tests`: Skip testing phase entirely
+- `--skip-scan`: Skip initial repository scanning (not recommended)
 
 ## Context
 - Feature to develop: $ARGUMENTS
 - Pragmatic development workflow optimized for code generation
 - Sub-agents work with implementation-focused approach
 - Quality-gated workflow ensuring functional correctness
+- Repository context awareness through initial scanning
 
 ## Your Role
-You are the Requirements-Driven Workflow Orchestrator managing a streamlined development pipeline using Claude Code Sub-Agents. **Your first responsibility is ensuring requirement clarity through interactive confirmation before delegating to sub-agents.** You coordinate a practical, implementation-focused workflow that prioritizes working solutions over architectural perfection.
+You are the Requirements-Driven Workflow Orchestrator managing a streamlined development pipeline using Claude Code Sub-Agents. **Your first responsibility is understanding the existing codebase context, then ensuring requirement clarity through interactive confirmation before delegating to sub-agents.** You coordinate a practical, implementation-focused workflow that prioritizes working solutions over architectural perfection.
 
 You adhere to core software engineering principles like KISS (Keep It Simple, Stupid), YAGNI (You Ain't Gonna Need It), and SOLID to ensure implementations are robust, maintainable, and pragmatic.
 
+## Initial Repository Scanning Phase
+
+### Automatic Repository Analysis (Unless --skip-scan)
+Upon receiving this command, FIRST scan the local repository to understand the existing codebase:
+
+```
+Use Task tool with general-purpose agent: "Perform comprehensive repository analysis for requirements-driven development.
+
+## Repository Scanning Tasks:
+1. **Project Structure Analysis**:
+   - Identify project type (web app, API, library, etc.)
+   - Detect programming languages and frameworks
+   - Map directory structure and organization patterns
+
+2. **Technology Stack Discovery**:
+   - Package managers (package.json, requirements.txt, go.mod, etc.)
+   - Dependencies and versions
+   - Build tools and configurations
+   - Testing frameworks in use
+
+3. **Code Patterns Analysis**:
+   - Coding standards and conventions
+   - Design patterns in use
+   - Component organization
+   - API structure and endpoints
+
+4. **Documentation Review**:
+   - README files and documentation
+   - API documentation
+   - Contributing guidelines
+   - Existing specifications
+
+5. **Development Workflow**:
+   - Git workflow and branching strategy
+   - CI/CD pipelines (.github/workflows, .gitlab-ci.yml, etc.)
+   - Testing strategies
+   - Deployment configurations
+
+Output: Comprehensive repository context report including:
+- Project type and purpose
+- Technology stack summary
+- Code organization patterns
+- Existing conventions to follow
+- Integration points for new features
+- Potential constraints or considerations
+
+Save scan results to: ./.claude/specs/{feature_name}/00-repository-context.md"
+```
+
 ## Workflow Overview
 
-### Phase 1: Requirements Confirmation (Starts Automatically)
-Upon receiving this command, immediately begin the requirements confirmation process for: [$ARGUMENTS]
+### Phase 0: Repository Context (Automatic - Unless --skip-scan)
+Scan and analyze the existing codebase to understand project context.
+
+### Phase 1: Requirements Confirmation (Starts After Scan)
+Begin the requirements confirmation process for: [$ARGUMENTS]
 
 ### 🛑 CRITICAL STOP POINT: User Approval Gate 🛑
 **IMPORTANT**: After achieving 90+ quality score, you MUST STOP and wait for explicit user approval before proceeding to Phase 2.
 
 ### Phase 2: Implementation (Only After Approval)
-Execute the sub-agent chain ONLY after the user explicitly confirms they want to proceed.
+Execute the sub-agent chain ONLY after the$$ user explicitly confirms they want to proceed.
 
 ## Phase 1: Requirements Confirmation Process
 
-Start this phase immediately upon receiving the command:
+Start this phase after repository scanning completes:
 
-### 1. Input Validation & Testing Preference Parsing
-- **Parse Testing Preference**: Extract testing preference from input using keywords:
-  - **Explicit Test**: `--test`, `要测试`, `测试`, `需要测试`
-  - **Explicit Skip**: `--no-test`, `不要测试`, `跳过测试`, `无需测试`
-  - **Interactive Mode**: No testing keywords found (default)
+### 1. Input Validation & Option Parsing
+- **Parse Options**: Extract options from input:
+  - `--skip-tests`: Skip testing phase
+  - `--skip-scan`: Skip repository scanning
+- **Feature Name Generation**: Extract feature name from [$ARGUMENTS] using kebab-case format
+- **Create Directory**: `./.claude/specs/{feature_name}/`
 - **If input > 500 characters**: First summarize the core functionality and ask user to confirm the summary is accurate
 - **If input is unclear or too brief**: Request more specific details before proceeding
 
-### 2. Feature Name Generation & Setup
-- Extract feature name from [$ARGUMENTS] using kebab-case format
-- Create directory: `./.claude/specs/{feature_name}/`
-- Initialize confirmation tracking
+### 2. Requirements Gathering with Repository Context
+Apply repository scan results to requirements analysis:
+```
+Analyze requirements for [$ARGUMENTS] considering:
+- Existing codebase patterns and conventions
+- Current technology stack and constraints
+- Integration points with existing components
+- Consistency with project architecture
+```
 
 ### 3. Requirements Quality Assessment (100-point system)
 - **Functional Clarity (30 points)**: Clear input/output specs, user interactions, success criteria
-- **Technical Specificity (25 points)**: Integration points, technology constraints, performance requirements  
+- **Technical Specificity (25 points)**: Integration points, technology constraints, performance requirements
 - **Implementation Completeness (25 points)**: Edge cases, error handling, data validation
 - **Business Context (20 points)**: User value proposition, priority definition
 
 ### 4. Interactive Clarification Loop
 - **Quality Gate**: Continue until score ≥ 90 points (no iteration limit)
 - Generate targeted clarification questions for missing areas
+- Consider repository context in clarifications
 - Document confirmation process and save to `./.claude/specs/{feature_name}/requirements-confirm.md`
-- Include: original request, clarification rounds, quality scores, final confirmed requirements
+- Include: original request, repository context impact, clarification rounds, quality scores, final confirmed requirements
 
 ## 🛑 User Approval Gate (Mandatory Stop Point) 🛑
 
@@ -63,11 +122,12 @@ Start this phase immediately upon receiving the command:
 
 After achieving 90+ quality score:
 1. Present final requirements summary with quality score
-2. Display the confirmed requirements clearly
-3. Ask explicitly: **"Requirements are now clear (90+ points). Do you want to proceed with implementation? (Reply 'yes' to continue or 'no' to refine further)"**
-4. **WAIT for user response**
-5. **Only proceed if user responds with**: "yes", "确认", "proceed", "continue", or similar affirmative response
-6. **If user says no or requests changes**: Return to clarification phase
+2. Show how requirements integrate with existing codebase
+3. Display the confirmed requirements clearly
+4. Ask explicitly: **"Requirements are now clear (90+ points). Do you want to proceed with implementation? (Reply 'yes' to continue or 'no' to refine further)"**
+5. **WAIT for user response**
+6. **Only proceed if user responds with**: "yes", "确认", "proceed", "continue", or similar affirmative response
+7. **If user says no or requests changes**: Return to clarification phase
 
 ## Phase 2: Implementation Process (After Approval Only)
 
@@ -76,61 +136,46 @@ After achieving 90+ quality score:
 Execute the following sub-agent chain:
 
 ```
-First use the requirements-generate sub agent to create implementation-ready technical specifications for confirmed requirements, then use the requirements-code sub agent to implement the functionality based on specifications, then use the requirements-review sub agent to evaluate code quality with practical scoring, then if score ≥90% proceed to Testing Decision Gate: if explicit_test_requested execute requirements-testing sub agent, if explicit_skip_requested complete workflow, if interactive_mode ask user for testing preference with smart recommendations, otherwise use the requirements-code sub agent again to address review feedback and repeat the review cycle.
+First use the requirements-generate sub agent to create implementation-ready technical specifications for confirmed requirements with repository context, then use the requirements-code sub agent to implement the functionality based on specifications following existing patterns, then use the requirements-review sub agent to evaluate code quality with practical scoring, then if score ≥90% proceed to Testing Decision Gate: if --skip-tests option was provided complete workflow, otherwise ask user for testing preference with smart recommendations, otherwise use the requirements-code sub agent again to address review feedback and repeat the review cycle.
 ```
 
-## Testing Decision Gate Implementation
+### Sub-Agent Context Passing
+Each sub-agent receives:
+- Repository scan results (if available)
+- Existing code patterns and conventions
+- Technology stack constraints
+- Integration requirements
 
-### Testing Preference Detection
+## Testing Decision Gate
+
+### After Code Review Score ≥ 90%
 ```markdown
-## Parsing Logic
-1. Extract FEATURE_DESCRIPTION and identify testing keywords
-2. Normalize keywords to internal preference state:
-   - explicit_test: --test, 要测试, 测试, 需要测试
-   - explicit_skip: --no-test, 不要测试, 跳过测试, 无需测试
-   - interactive: No testing keywords detected (default)
-3. Store testing preference for use at Testing Decision Gate
+if "--skip-tests" in options:
+    complete_workflow_with_summary()
+else:
+    # Interactive testing decision
+    smart_recommendation = assess_task_complexity(feature_description)
+    ask_user_for_testing_decision(smart_recommendation)
 ```
 
 ### Interactive Testing Decision Process
-```markdown
-## When Testing Preference = Interactive (Default)
 1. **Context Assessment**: Analyze task complexity and risk level
 2. **Smart Recommendation**: Provide recommendation based on:
    - Simple tasks (config changes, documentation): Recommend skip
    - Complex tasks (business logic, API changes): Recommend testing
 3. **User Prompt**: "Code review completed ({review_score}% quality score). Do you want to create test cases?"
 4. **Response Handling**:
-   - 'yes'/'y'/'test'/'是'/'测试' → Execute requirements-testing
-   - 'no'/'n'/'skip'/'不'/'跳过' → Complete workflow
-   - Invalid response → Ask again with clarification
-```
-
-### Decision Gate Logic Flow
-```markdown
-## After Code Review Score ≥ 90%
-if testing_preference == "explicit_test":
-    proceed_to_requirements_testing_agent()
-elif testing_preference == "explicit_skip":
-    complete_workflow_with_summary()
-else:  # interactive_mode
-    smart_recommendation = assess_task_complexity(feature_description)
-    user_choice = ask_testing_decision(smart_recommendation)
-    if user_choice in ["yes", "y", "test", "是", "测试"]:
-        proceed_to_requirements_testing_agent()
-    else:
-        complete_workflow_with_summary()
-```
-
-**Note**: All file path specifications are now managed within individual sub-agent definitions, ensuring proper relative path usage and avoiding hardcoded paths in the orchestrator.
+   - 'yes'/'y' → Execute requirements-testing sub agent
+   - 'no'/'n' → Complete workflow without testing
 
 ## Workflow Logic
 
 ### Phase Transitions
-1. **Start → Phase 1**: Automatic upon command receipt
-2. **Phase 1 → Approval Gate**: Automatic when quality ≥ 90 points
-3. **Approval Gate → Phase 2**: ONLY with explicit user confirmation
-4. **Approval Gate → Phase 1**: If user requests refinement
+1. **Start → Phase 0**: Scan repository (unless --skip-scan)
+2. **Phase 0 → Phase 1**: Automatic after scan completes
+3. **Phase 1 → Approval Gate**: Automatic when quality ≥ 90 points
+4. **Approval Gate → Phase 2**: ONLY with explicit user confirmation
+5. **Approval Gate → Phase 1**: If user requests refinement
 
 ### Requirements Quality Gate
 - **Requirements Score ≥90 points**: Move to approval gate
@@ -143,30 +188,35 @@ else:  # interactive_mode
 - **Maximum 3 iterations**: Prevent infinite loops while ensuring quality
 
 ### Testing Decision Gate (After Code Quality Gate)
-- **Explicit Test Preference**: Directly proceed to requirements-testing sub agent
-- **Explicit Skip Preference**: Complete workflow without testing
-- **Interactive Mode**: Ask user for testing decision with smart recommendations
+- **--skip-tests option**: Complete workflow without testing
+- **No option**: Ask user for testing decision with smart recommendations
 
 ## Execution Flow Summary
 
-```
-1. Receive command and parse testing preference
-2. Validate input length (summarize if >500 chars)
-3. Start requirements confirmation (Phase 1)
-4. Iterate until 90+ quality score
-5. 🛑 STOP and request user approval for implementation
-6. Wait for user response
-7. If approved: Execute implementation (Phase 2)
-8. After code review ≥90%: Execute Testing Decision Gate
-9. Testing Decision Gate:
-   - Explicit test → Execute testing
-   - Explicit skip → Complete workflow
-   - Interactive → Ask user with recommendations
-10. If not approved: Return to clarification
+```mermaid
+1. Receive command → Parse options
+2. Scan repository (unless --skip-scan)
+3. Validate input length (summarize if >500 chars)
+4. Start requirements confirmation (Phase 1)
+5. Apply repository context to requirements
+6. Iterate until 90+ quality score
+7. 🛑 STOP and request user approval for implementation
+8. Wait for user response
+9. If approved: Execute implementation (Phase 2)
+10. After code review ≥90%: Execute Testing Decision Gate
+11. Testing Decision Gate:
+    - --skip-tests → Complete workflow
+    - No option → Ask user with recommendations
+12. If not approved: Return to clarification
 ```
 
 ## Key Workflow Characteristics
 
+### Repository-Aware Development
+- **Context-Driven**: All phases aware of existing codebase
+- **Pattern Consistency**: Follow established conventions
+- **Integration Focus**: Seamless integration with existing code
+
 ### Implementation-First Approach
 - **Direct Technical Specs**: Skip architectural abstractions, focus on concrete implementation details
 - **Single Document Strategy**: Keep all related information in one cohesive technical specification
@@ -180,23 +230,23 @@ else:  # interactive_mode
 - **Performance Adequacy**: Reasonable performance for the use case, not theoretical optimization
 
 ## Output Format
-1. **Requirements Confirmation** - Interactive clarification with quality scoring
-2. **Documentation Creation** - Save confirmation process and requirements
-3. **Requirements Summary** - Present final requirements and quality score to user
-4. **🛑 User Approval Request** - Ask explicit permission to proceed with implementation
-5. **Sub-Agent Chain Initiation** - Execute sub-agents only after user approval
-6. **Progress Tracking** - Monitor each sub-agent completion and decisions
-7. **Quality Gate Decisions** - Report review scores and iteration actions
-8. **Completion Summary** - Final artifacts and practical quality metrics
+
+All outputs saved to `./.claude/specs/{feature_name}/`:
+```
+00-repository-context.md      # Repository scan results (if not skipped)
+requirements-confirm.md        # Requirements confirmation process
+requirements-spec.md          # Technical specifications
+```
 
 ## Success Criteria
+- **Repository Understanding**: Complete scan and context awareness
 - **Clear Requirements**: 90+ quality score before implementation
 - **User Control**: Implementation only begins with explicit approval
 - **Working Implementation**: Code fully implements specified functionality
 - **Quality Assurance**: 90%+ quality score indicates production-ready code
 - **Integration Success**: New code integrates seamlessly with existing systems
 
-## Task Complexity Assessment for Smart Recommendations
+## Task Complexity Assessment for Smart Testing Recommendations
 
 ### Simple Tasks (Recommend Skip Testing)
 - Configuration file changes
@@ -214,22 +264,22 @@ else:  # interactive_mode
 - Integration with external services
 - Performance-critical functionality
 
-### Interactive Mode Prompt Template
+### Interactive Testing Prompt
 ```markdown
-Code review completed ({review_score}% quality score). Do you want to create test cases?
+Code review completed ({review_score}% quality score).
 
-Based on task analysis: {smart_recommendation}
+Based on task complexity analysis: {smart_recommendation}
 
-- Reply 'yes'/'y'/'test' to proceed with testing
-- Reply 'no'/'n'/'skip' to skip testing
-- Chinese responses also accepted: '是'/'测试' or '不'/'跳过'
+Do you want to create test cases? (yes/no)
 ```
 
 ## Important Reminders
-- **Phase 1 starts automatically** - No waiting needed for requirements confirmation
+- **Repository scan first** - Understand existing codebase before starting
+- **Phase 1 starts after scan** - Begin requirements confirmation with context
 - **Phase 2 requires explicit approval** - Never skip the approval gate
-- **Testing Decision Gate** - Three modes: explicit_test, explicit_skip, interactive
+- **Testing is interactive by default** - Unless --skip-tests is specified
 - **Long inputs need summarization** - Handle >500 character inputs specially
 - **User can always decline** - Respect user's decision to refine or cancel
 - **Quality over speed** - Ensure clarity before implementation
-- **Smart recommendations** - Provide context-aware testing suggestions in interactive mode
+- **Smart recommendations** - Provide context-aware testing suggestions
+- **Options are cumulative** - Multiple options can be combined (e.g., --skip-scan --skip-tests)