agentic-code 0.5.1

package/.agents/tasks/quality-assurance.md

@@ -0,0 +1,219 @@
+# Quality Assurance
+
+## Required Rules [MANDATORY - MUST BE ACTIVE]
+
+**RULE AVAILABILITY VERIFICATION:**
+1. [LOAD IF NOT ACTIVE] `.agents/rules/language/rules.md`
+2. [LOAD IF NOT ACTIVE] `.agents/rules/language/testing.md`
+
+**LOADING PROTOCOL:**
+- STEP 1: CHECK if language/rules.md is active in working memory
+- STEP 2: If language/rules.md NOT active → Execute BLOCKING READ
+- STEP 3: CHECK if testing.md is active in working memory
+- STEP 4: If testing.md NOT active → Execute BLOCKING READ
+- STEP 5: CONFIRM all rules active before executing quality gates
+
+**CRITICAL**: Cannot execute quality checks until ALL required rules confirmed active
+
+## Plan Injection Requirement [MANDATORY]
+
+**Upon reading this file, IMMEDIATELY inject to work plan:**
+1. All BLOCKING READs identified in Loading Protocol above:
+   - `.agents/rules/language/rules.md` (if not active)
+   - `.agents/rules/language/testing.md` (if not active)
+2. Mark each with "[From quality-assurance.md]" source tag
+3. Show evidence of injection:
+   ```
+   [PLAN INJECTION FROM quality-assurance.md]
+   Injected to work plan:
+   ✓ BLOCKING READ: language/rules.md - quality standards
+   ✓ BLOCKING READ: language/testing.md - testing requirements
+   Status: VERIFIED
+   ```
+
+**ENFORCEMENT:** Cannot proceed without Plan Injection evidence
+
+**EVIDENCE REQUIRED:**
+```
+Rule Status Verification:
+✓ language/rules.md - ACTIVE (loaded/verified)
+✓ testing.md - ACTIVE (loaded/verified)
+```
+
+## Task Completion Gate [STRICT ENFORCEMENT - NO EXCEPTIONS]
+
+**CANNOT mark task as complete until ALL quality checks pass:**
+□ Plan Injection completed (from quality-assurance.md Plan Injection Requirement)
+□ Work plan contains ALL BLOCKING READs from this file
+□ Build process succeeds
+□ Tests pass (or no tests if not applicable)
+□ Linting: 0 errors
+□ Static analysis passes (if applicable)
+□ Manual testing performed (if applicable)
+□ Changes committed to git (for implementation tasks)
+□ Task tracking updated (work plan checkbox if using workflow)
+
+**If any check fails:**
+→ Fix issues before proceeding
+→ Do NOT skip or mark task complete
+→ Do NOT commit with failing checks
+
+## Purpose
+
+Ensure code quality through systematic verification and testing.
+
+## When to Use [MANDATORY TIMING]
+
+- **After every implementation** (required)
+- **Before marking any task done** (mandatory)
+- When quality issues suspected
+- During code review
+- Before deployment
+
+## Completion Conditions
+
+□ Build process succeeds
+□ All tests pass
+□ Linting reports 0 errors
+□ Code formatting verified
+□ Static analysis passes (if applicable)
+□ Test coverage meets requirements
+□ Performance acceptable
+□ Security checks pass
+□ Documentation updated
+
+## Execution Guidelines
+
+### 1. Build Verification
+
+Run project build:
+- Ensure compilation succeeds
+- Check for warnings
+- Verify output artifacts
+- Confirm dependencies resolved
+
+*Note: Build commands are language-specific. Check language/testing.md*
+
+### 2. Test Execution
+
+**Test Categories**
+- Unit tests: Individual functions
+- Integration tests: Component interactions
+- End-to-end tests: Full workflows
+- Performance tests: Speed and resources
+- Security tests: Vulnerability checks
+
+**Test Coverage**
+- Minimum: 80% code coverage
+- Critical paths: 100% coverage
+- Edge cases: Documented and tested
+
+### 3. Code Quality Checks
+
+**Static Analysis**
+- Linting: 0 errors required
+- Code formatting: Consistent style
+- Language checks: No errors (static typing, style, etc.)
+- Complexity: Within limits
+
+**Code Review Criteria**
+- Readability: Self-documenting
+- Maintainability: Easy to modify
+- Efficiency: No obvious issues
+- Security: Best practices followed
+
+### 4. Quality Standards
+
+| Aspect | Standard |
+|--------|----------|
+| Functions | ≤ 30 lines |
+| Complexity | ≤ 10 cyclomatic |
+| Duplication | < 5% |
+| Test time | < 30 seconds total |
+| Build time | < 2 minutes |
+| Comments | For non-obvious only |
+
+### 5. Security Validation
+
+Check for:
+- Input validation present
+- SQL injection prevention
+- XSS protection
+- Authentication properly implemented
+- Authorization checks in place
+- Sensitive data encrypted
+- Secrets not hardcoded
+
+### 6. Performance Validation
+
+Verify:
+- Response times acceptable
+- Memory usage reasonable
+- Database queries optimized
+- Caching implemented where needed
+- No unnecessary loops
+- Async operations proper
+
+### 7. Documentation Check
+
+Ensure:
+- README updated if needed
+- API documentation current
+- Complex logic explained
+- Configuration documented
+- Setup instructions clear
+- Breaking changes noted
+
+## Quality Process
+
+```
+1. Run build → Must succeed
+2. Run tests → All must pass
+3. Check coverage → Meet minimums
+4. Run linter → 0 errors
+5. Check formatting → Consistent
+6. Review security → No issues
+7. Test performance → Acceptable
+8. Update docs → Current
+```
+
+## Common Issues and Fixes
+
+| Issue | Likely Cause | Fix |
+|-------|-------------|-----|
+| Build fails | Missing dependency | Install dependencies |
+| Tests fail | Logic error | Debug and fix |
+| Lint errors | Style violations | Apply formatting |
+| Static analysis errors | Language violations | Fix definitions/signatures |
+| Slow tests | No mocking | Add test doubles |
+| Security warning | Old dependency | Update packages |
+
+## Tools by Language
+
+Reference `.agents/rules/language/testing.md` for:
+- Language-specific test commands
+- Coverage tools
+- Linting configuration
+- Build processes
+- Security scanners
+
+## Pre-Deployment Checklist
+
+□ All automated tests pass
+□ Manual testing complete
+□ Code reviewed
+□ Documentation updated
+□ Performance verified
+□ Security validated
+□ Rollback plan exists
+□ Monitoring configured
+
+## Anti-Patterns
+
+Avoid:
+- Skipping tests to save time
+- Ignoring warnings
+- Accepting "good enough" quality
+- Testing only happy path
+- Ignoring performance
+- Assuming security is fine

package/.agents/tasks/task-analysis.md

@@ -0,0 +1,263 @@
+# Task Analysis
+
+## Required Rules [MANDATORY - MUST BE ACTIVE]
+
+**RULE AVAILABILITY VERIFICATION:**
+1. [VERIFY ACTIVE] `.agents/rules/core/metacognition.md` (loaded at session start)
+2. [LOAD IF NOT ACTIVE] `.agents/context-maps/task-rule-matrix.yaml`
+
+**LOADING PROTOCOL:**
+- STEP 1: VERIFY metacognition.md is active from initial session setup
+- STEP 2: CHECK if task-rule-matrix.yaml is active in working memory
+- STEP 3: If task-rule-matrix.yaml NOT active → Execute BLOCKING READ
+- STEP 4: CONFIRM all rules active before proceeding with task analysis
+
+**EVIDENCE REQUIRED:**
+```
+Rule Status Verification:
+✓ metacognition.md - ACTIVE (from session setup)
+✓ task-rule-matrix.yaml - ACTIVE (loaded/verified)
+```
+
+## Purpose
+
+Determine task type, scale, and required resources.
+
+## When to Use
+
+- At the start of any user request
+- When task scope is unclear
+- When switching to a different type of work
+
+## Completion Conditions
+
+□ Task type identified (implementation/research/design/documentation/debugging/review/other)
+□ Task scale determined:
+  - Small: 1-2 files affected
+  - Medium: 3-5 files affected
+  - Large: 6+ files affected
+□ Required resources identified:
+  - Rules needed
+  - External dependencies
+  - Existing code to reference
+□ Success criteria defined (measurable)
+□ Constraints and assumptions documented
+
+## Mandatory Execution Order [STRICT COMPLIANCE REQUIRED]
+
+### Step 0: Initial Setup [BLOCKING - CANNOT SKIP]
+If SESSION_BASELINE_DATE not established:
+1. [IMMEDIATE] Execute `date` command
+2. [STORE] Result as SESSION_BASELINE_DATE for ENTIRE session
+3. [ENFORCE] ALL "current/latest/recent" references MUST use SESSION_BASELINE_DATE year
+
+VIOLATION EXAMPLE: Using "2024" in web research when SESSION_BASELINE_DATE shows "2025" = CRITICAL ERROR
+
+### Step 1: Understand Request Essence
+
+- What is the user trying to achieve?
+- Is this a symptom or the actual goal?
+- What similar tasks have been done before?
+
+### Step 2: Classify Task Type [REQUIRED]
+
+**Implementation**: Creating or modifying code
+- New features
+- Bug fixes
+- Refactoring
+- Performance optimization
+
+**Research**: Information gathering
+- Code exploration
+- Architecture analysis
+- Feasibility studies
+
+**Design**: Planning and documentation
+- Technical specifications
+- Architecture decisions
+- API design
+
+**Documentation**: Writing docs
+- README updates
+- API documentation
+- User guides
+
+**Debugging**: Problem solving
+- Error investigation
+- Performance analysis
+- Behavior diagnosis
+
+**Review**: Evaluation and verification
+- Technical document review (design docs, ADRs)
+- Code review
+- Test review (integration/E2E tests)
+
+### Step 3: Estimate Scale [REQUIRED]
+
+Count affected components:
+- Number of files to create/modify
+- Number of systems/modules involved
+- Integration complexity
+- Testing requirements
+
+### Step 4: Execute Rule Selection [BLOCKING CHECKPOINT]
+
+**EXECUTION GATES - System HALTS if any step skipped:**
+1. [BLOCKING READ] `task-rule-matrix.yaml` from `.agents/context-maps/`
+2. [MANDATORY MATCHING] Task type + scale against matrix
+3. [CLASSIFICATION OUTPUT]:
+   - Required rules: IMMEDIATE BLOCKING READ
+   - Recommended rules: EVALUATE context, then BLOCKING READ if applicable
+   - Conditional rules: CHECK conditions, then BLOCKING READ if met
+4. [VERIFICATION GATE] CANNOT PROCEED until ALL required rules loaded
+5. [PROOF OF COMPLIANCE] Output must list:
+   ```
+   Rules Successfully Loaded:
+   ✓ [filepath] - [reason for loading]
+   ✓ [filepath] - [applied to which aspect]
+   ```
+6. [PLAN INJECTION] IMMEDIATELY inject all identified BLOCKING READs to work plan:
+   ```
+   [PLAN INJECTION FROM task-analysis - Rule Selection]
+   Injected BLOCKING READs from rule selection:
+   ✓ [filepath] - required rule
+   ✓ [filepath] - conditional rule (condition met)
+   ```
+
+### Step 5: Identify Additional Resources
+
+Determine what's needed:
+- Which rule files apply
+- External libraries/tools
+- Reference implementations
+- Documentation sources
+
+### Step 6: Define Success Criteria
+
+- Specific functionality works
+- Tests pass
+- Performance metrics met
+- Documentation complete
+
+### Step 7: Workflow Recommendation
+
+Based on scale and complexity:
+- **Small Scale (1-2 files)**: Direct task execution, no workflow needed
+- **Medium/Large Scale (3+ files)**: RECOMMEND agentic-coding.md workflow
+  - Ask: "This task would benefit from a structured workflow with design document and work plan. Proceed? [Y/n]"
+  - If YES: Load and follow agentic-coding.md
+  - If NO: Execute individual task definitions directly
+
+### Step 8: Mandatory Plan Injection [BLOCKING - AUTOMATIC EXECUTION]
+
+**FOR ALL TASKS WITH BLOCKING READ REQUIREMENTS:**
+
+1. **[SCAN FOR BLOCKING READS]** Identify ALL files requiring BLOCKING READ:
+   - From selected workflow (if Medium/Large scale)
+   - From task definitions to be executed
+   - From rules that will be loaded
+
+2. **[AUTOMATIC INJECTION]** Add ALL identified BLOCKING READs to work plan:
+   ```
+   Plan Injection Required:
+   □ BLOCKING READ: [file path] - [reason/phase]
+   □ BLOCKING READ: [file path] - [reason/phase]
+   □ Rule Status Verification after each BLOCKING READ
+   ```
+
+3. **[EVIDENCE REQUIRED]** Show plan injection confirmation:
+   ```
+   [PLAN INJECTION COMPLETED]
+   Identified BLOCKING READs from:
+   ✓ Workflow phases: [list files]
+   ✓ Task definitions: [list files]
+   ✓ Required rules: [list files]
+
+   Injected to plan:
+   ✓ Total BLOCKING READs: [count]
+   ✓ Verification gates: [count]
+   ```
+
+4. **[ENFORCEMENT]** CANNOT proceed without:
+   - ALL BLOCKING READs identified and injected
+   - Plan injection evidence shown above
+   - Each BLOCKING READ as explicit task in work plan
+
+**VIOLATION HANDLING:**
+- Missing any BLOCKING READ from plan = IMMEDIATE HALT
+- Skipping any BLOCKING READ during execution = CRITICAL ERROR
+- Proceeding without verification = RETURN TO TASK ANALYSIS
+
+## Deliverables
+
+- Task classification output
+- Path recommendation
+
+## Common Patterns
+
+### Feature Request
+1. Identify core functionality
+2. Estimate component changes
+3. Consider edge cases
+4. Plan testing approach
+
+### Bug Fix
+1. Understand expected vs actual behavior
+2. Identify affected components
+3. Determine root cause approach
+4. Plan verification method
+
+### Refactoring
+1. Identify improvement goals
+2. Assess current structure
+3. Estimate change scope
+4. Plan incremental approach
+
+### Review
+1. Identify review target (document/code/tests)
+2. Load appropriate review task definition
+3. Apply review criteria from task definition
+4. Document findings and recommendations
+
+## Decision Tree
+
+**Code-related?**
+- YES → Creating new code?
+  - YES: Implementation task
+  - NO → Fixing issues?
+    - YES: Debugging task
+    - NO: Refactoring task
+- NO → Evaluating existing work?
+  - YES: Review task → Determine target:
+    - Document (design/ADR) → technical-document-review
+    - Code → code-review
+    - Tests → integration-test-review
+  - NO → Information gathering?
+    - YES: Research task
+    - NO → Planning?
+      - YES: Design task
+      - NO: Documentation task
+
+## Rule Selection Output Format [SYSTEM VERIFICATION REQUIRED]
+
+### BLOCKING OUTPUT - Cannot proceed without this exact format:
+```
+[RULE SELECTION CHECKPOINT]
+Task Type: [type]
+Task Scale: [scale]
+SESSION_BASELINE_DATE: [stored date from initial setup]
+
+Path Recommendation:
+- [Direct execution of task definitions] OR
+- [Workflow recommended: agentic-coding.md]
+
+Required Rules [BLOCKING READS - MUST BE LOADED]:
+✓ [path/to/rule1.md] - LOADED - [applying to: specific aspect]
+✓ [path/to/rule2.md] - LOADED - [applying to: specific aspect]
+
+Conditional Rules [LOAD IF CONDITION MET]:
+✓ [path/to/rule3.md] - LOADED - [trigger: "test" keyword found in task]
+✗ [path/to/rule4.md] - NOT LOADED - [trigger not met: no performance requirements]
+
+VERIFICATION: All required rules active in working memory
+```