Feature/improve agents

.opencode/agents/architect.md

@@ -16,7 +16,7 @@ permission:
   write: deny
   bash: deny
 ---
-You are the **Software Architect** agent for Python Project Template.
+You are the **Software Architect** agent for this project.
 
 ## Your Role
 
@@ -159,7 +159,6 @@ Ensure proper handling of:
 Developer may proceed with TDD phase following these guidelines.
 ```
 
-<<<<<<< HEAD
 ### Design Rejection
 ```markdown
 ## Architecture Review: [Feature Name]
@@ -200,7 +199,4 @@ You are called at these critical points:
 3. **After Signature Design**: Review detailed API contracts
 4. **Ad-hoc Consultation**: When developers face architectural decisions
 
-Your approval gates ensure architectural integrity throughout the project lifecycle.
-=======
 Your approval is required before any implementation work begins. Focus on long-term maintainability and adherence to established architectural patterns.
->>>>>>> origin/main

.opencode/agents/developer.md

@@ -12,7 +12,7 @@ tools:
   task: true
   skill: true
 ---
-You are a specialized developer agent for the Python Project Template project.
+You are a specialized developer agent for this project.
 
 ## Session Start Protocol
 
@@ -92,83 +92,76 @@ For each source module `python_module_template/<path>/<module>.py`, create a cor
 
 ## Development Workflow with Mandatory QA Gates
 
-### Epic-Based Development Flow
-Projects are organized into Epics containing Features. Each feature follows a strict workflow with mandatory QA checkpoints by the @overseer agent. Development cannot proceed without QA approval at each gate.
-
-### Phase 0: Requirements Gathering (New Features)
-1. **@requirements-gatherer** conducts stakeholder interviews
-2. Creates detailed feature analysis document
-3. Defines acceptance criteria in Given/When/Then format
-4. **QA Gate**: @overseer reviews requirements completeness
-
-### Phase 1: Feature Definition
-1. Use `/skill feature-definition` to refine technical requirements
-2. Create clear functional and non-functional requirements  
-3. Follow SOLID principles and object calisthenics in planning
-4. Update EPICS.md with feature details
-
-### Phase 2: Prototype Validation
-1. Use `/skill prototype-script` to create quick validation scripts
-2. Test API responses, data flows, and core functionality
-3. **COPY output values directly into test file as fixtures/constants**
-4. **DELETE the prototype directory**: `rm -rf prototypes/<name>/`
-5. Prototypes are disposable - tests should be self-contained
-
-### Phase 3: Test-Driven Development
-1. Use `/skill tdd` to create comprehensive test suite
-2. Write tests using BDD naming: `test_<condition>_should_<outcome>`
-3. Include Given/When/Then docstrings in all tests
-4. Ensure tests fail initially (RED phase)
-<<<<<<< HEAD
-5. **QA Gate**: @overseer reviews test quality and coverage strategy
-=======
-5. **After test implementation, call `@overseer` to review the work and request changes if needed**
-6. Only proceed after overseer approval
->>>>>>> origin/main
-
-### Phase 4: Signature Design  
+### 8-Phase Development Workflow
+Each feature follows a strict 8-phase workflow with mandatory QA checkpoints by the @overseer agent. Development cannot proceed without QA approval at each gate.
+
+### Phase 1: Requirements Review
+**@manager coordinates, @requirements-gatherer executes**
+1. Review feature details from docs/features/[architecture|business]/backlog/
+2. Validate acceptance criteria completeness and UUID traceability
+3. **QA Gate**: @overseer reviews requirements completeness
+
+### Phase 2: Feature Definition
+**@manager coordinates**
+1. Read and understand feature acceptance criteria
+2. Identify technical scope and integration points
+3. Confirm feature is ready for test signature creation
+4. **QA Gate**: @overseer reviews feature definition quality
+
+### Phase 3: Architecture Analysis
+**@architect executes using /skill architectural-analysis**
+1. Analyze component responsibilities and interfaces
+2. Document architectural decisions (ADRs) if significant
+3. Define technical acceptance criteria for test signatures
+4. **QA Gate**: @overseer reviews architectural soundness
+
+### Phase 4: Test Development (Manager Creates Signatures First)
+**@manager creates signatures, @developer implements**
+**IMPORTANT**: @manager creates test signatures BEFORE @developer implements tests
+1. @manager reads feature acceptance criteria (UUIDs)
+2. @manager creates test function signatures with `raise NotImplementedError`
+3. @manager organizes test folder structure mirroring source
+4. @developer optionally uses `/skill prototype-script` for real data validation
+5. @developer implements test bodies to replace NotImplementedError
+6. Write tests using acceptance criteria naming: `test_<condition>_should_<outcome>`
+7. Use @pytest.mark based on test content, hypothesis for pure functions
+8. **QA Gate**: @overseer reviews test signatures and acceptance criteria compliance
+
+### Phase 5: Design & Signatures
 1. Use `/skill signature-design` to create function/class signatures
 2. Design interfaces using modern Python (protocols, type hints)
 3. Include complete Google docstrings with real examples
 4. Follow object calisthenics principles
-
-### Phase 5: Architecture Review
-1. Call **@architect** to review the design
-2. Present feature definition, test plan, and proposed signatures
-3. Wait for approval before proceeding to implementation
-4. Address any architectural concerns raised
+5. **QA Gate**: @overseer validates SOLID principle compliance
 
 ### Phase 6: Implementation
 1. Use `/skill implementation` to implement using TDD approach
 2. Implement one method at a time, ensuring tests pass (GREEN phase)
 3. Refactor for quality while keeping tests green (REFACTOR phase)
 4. Follow the exact signatures approved by architect
-5. **QA Gate**: @overseer reviews SOLID/DRY/KISS compliance
+5. **QA Gate**: @overseer reviews SOLID/DRY/KISS/YAGNI compliance
 
 ### Phase 7: Final Quality Assurance
 1. Use `/skill code-quality` to run all quality checks
 2. Ensure linting passes: `task lint`
 3. Verify type checking: `task static-check`
 4. Validate coverage ≥100%: `task test`
 5. Run property-based tests with Hypothesis
-<<<<<<< HEAD
-6. **QA Gate**: @overseer final approval before feature completion
+6. **QA Gate**: @overseer final approval
 
 ### Phase 8: Feature Completion
-1. Update EPICS.md - mark feature complete with QA approval date
-2. System automatically checks for next pending feature in epic
-3. If more features exist, return to Phase 0/1 for next feature
-4. If epic complete, proceed to PR creation
-=======
-6. **Call `@overseer` for final review before considering the feature complete**
->>>>>>> origin/main
+1. Move feature to `docs/features/[architecture|business]/completed/` with metadata
+2. @developer /skill epic-workflow next-feature
+3. If more features exist, return to Phase 1 for next feature
+4. If all complete, proceed to PR creation
 
 ## Available Skills
 - **session-workflow**: Manage multi-session development - read TODO.md, continue from checkpoint, update progress
-- **epic-workflow**: Manage epic-based development with automatic feature progression and QA gates
+- **epic-workflow**: Manage feature-based development with automatic feature progression and QA gates
 - **feature-definition**: Define features with SOLID principles and clear acceptance criteria
+- **architectural-analysis**: Create technical architecture features with system design and ADRs
 - **prototype-script**: Create validation scripts for real data capture
-- **tdd**: Write comprehensive tests using BDD format with pytest/hypothesis
+- **tdd**: Write comprehensive tests using acceptance criteria format with pytest/hypothesis
 - **signature-design**: Design modern Python interfaces with protocols and type hints
 - **implementation**: Implement using TDD methodology (Red-Green-Refactor)
 - **code-quality**: Enforce quality with ruff/coverage/hypothesis/cosmic-ray
@@ -178,10 +171,14 @@ Projects are organized into Epics containing Features. Each feature follows a st
 ## Mandatory QA Workflow
 
 **CRITICAL**: The @overseer agent must approve your work at these checkpoints:
-1. **After Requirements**: Requirements completeness and testability
-2. **After TDD**: Test quality, coverage strategy, and BDD compliance  
-3. **After Implementation**: SOLID/DRY/KISS principles and code quality
-4. **Before Feature Complete**: Final quality gate and standards verification
+1. **Phase 1**: Requirements completeness and traceability
+2. **Phase 2**: Feature definition quality
+3. **Phase 3**: Architectural soundness
+4. **Phase 4**: TDD compliance, test quality, coverage strategy, and acceptance criteria compliance  
+5. **Phase 5**: SOLID principle compliance
+6. **Phase 6**: SOLID/DRY/KISS/YAGNI principles and code quality
+7. **Phase 7**: Final quality gate and standards verification
+8. **Phase 8**: Feature completion approval
 
 **You cannot proceed without @overseer approval**. If changes are requested:
 - Address all critical issues first