agentic-code 0.5.1 → 0.6.1

package/.agents/context-maps/{task-rule-matrix.yaml → task-skills-matrix.yaml}

@@ -1,11 +1,11 @@
-# Task-Rule Mapping Matrix
-# Maps tasks to relevant rules based on metadata and tags
-# Used by task-analysis.md to recommend appropriate rules for each task type
-
-rules:
-  # Core Rules
-  core/metacognition:
-    path: ".agents/rules/core/metacognition.md"
+# Task-Skill Mapping Matrix
+# Maps tasks to relevant skills based on metadata and tags
+# Used by task-analysis.md to recommend appropriate skills for each task type
+
+skills:
+  # Core Skills
+  metacognition:
+    path: ".agents/skills/metacognition/SKILL.md"
     tags: [self-assessment, reflection, decision-checkpoint, quality-control]
     when_to_load:
       - "Task type changes (e.g., from design to implementation)"
@@ -17,8 +17,8 @@ rules:
     priority: always
     description: "Self-assessment and reflection protocols for maintaining quality"
 
-  core/ai-development-guide:
-    path: ".agents/rules/core/ai-development-guide.md"
+  ai-development-guide:
+    path: ".agents/skills/ai-development-guide/SKILL.md"
     tags: [anti-patterns, debugging, best-practices, rule-of-three, technical-debt, impact-analysis, unused-code, code-deletion, implementation-completeness]
     when_to_load:
       - "Starting new implementation"
@@ -31,8 +31,8 @@ rules:
     priority: high
     description: "Anti-patterns, debugging techniques, development best practices, and implementation completeness assurance"
 
-  core/documentation-criteria:
-    path: ".agents/rules/core/documentation-criteria.md"
+  documentation-criteria:
+    path: ".agents/skills/documentation-criteria/SKILL.md"
     tags: [documentation, adr, design-doc, decision-matrix, scale-assessment]
     when_to_load:
       - "Task scale assessment (Small/Medium/Large)"
@@ -44,8 +44,8 @@ rules:
     priority: medium
     description: "Criteria for when and how to create documentation"
 
-  core/testing-strategy:
-    path: ".agents/rules/core/testing-strategy.md"
+  testing-strategy:
+    path: ".agents/skills/testing-strategy/SKILL.md"
     tags: [testing, roi-calculation, test-selection, budget-enforcement, behavior-first]
     when_to_load:
       - "Generating acceptance tests from design documents"
@@ -57,8 +57,8 @@ rules:
     priority: high
     description: "ROI-based test selection framework with behavior-first filtering and budget enforcement"
 
-  core/integration-e2e-testing:
-    path: ".agents/rules/core/integration-e2e-testing.md"
+  integration-e2e-testing:
+    path: ".agents/skills/integration-e2e-testing/SKILL.md"
     tags: [testing, integration-test, e2e-test, behavior-first, mock-boundary, test-review]
     when_to_load:
       - "Generating integration/E2E test skeletons"
@@ -69,180 +69,168 @@ rules:
     priority: high
     description: "Integration and E2E test design, implementation rules, and review criteria"
 
-  # Language Rules (currently TypeScript, but concepts are universal)
-  language/rules:
-    path: ".agents/rules/language/rules.md"
-    tags: [implementation, coding-style, type-safety, error-handling, refactoring, clean-code, solid-principles]
+  # Architecture Skills
+  implementation-approach:
+    path: ".agents/skills/implementation-approach/SKILL.md"
+    tags: [strategy-selection, task-decomposition, verification-levels, integration-points]
+    when_to_load:
+      - "Medium/Large scale tasks (3+ files)"
+      - "Implementation strategy selection"
+      - "Task breakdown and planning"
+      - "Choosing between vertical/horizontal slicing"
+    typical_tasks: [planning, design, implementation]
+    size: medium
+    priority: conditional
+    description: "Strategy selection for implementation approaches (vertical/horizontal slicing)"
+
+  # Development Skills (with language-specific references)
+  coding-rules:
+    path: ".agents/skills/coding-rules/SKILL.md"
+    references:
+      typescript: ".agents/skills/coding-rules/references/typescript.md"
+    tags: [implementation, coding-style, error-handling, refactoring, clean-code, solid-principles]
     when_to_load:
       - "Writing or modifying code"
       - "Code review"
       - "Refactoring existing code"
       - "Implementing new features"
     typical_tasks: [implementation, refactoring]
-    size: large
+    size: medium
     priority: high
-    description: "Language-specific coding standards and best practices"
-    universal_concepts:
-      - "YAGNI principle"
-      - "DRY principle"
-      - "Error handling patterns"
-      - "Dependency injection"
-      - "Clean code principles"
-      - "Type/static safety (for typed languages)"
-      - "Async/concurrent programming patterns"
-      - "Function composition over classes"
-
-  language/testing:
-    path: ".agents/rules/language/testing.md"
-    tags: [testing, tdd, quality-assurance, coverage, unit-tests, integration-tests, verify-phase, test-skeleton]
+    description: "Coding standards and best practices (includes language-specific references)"
+
+  testing:
+    path: ".agents/skills/testing/SKILL.md"
+    references:
+      typescript: ".agents/skills/testing/references/typescript.md"
+    tags: [testing, tdd, quality-assurance, coverage, unit-tests, integration-tests, verify-phase]
     when_to_load:
       - "Writing tests"
       - "Bug fixing (test-first)"
       - "Quality checks"
       - "Refactoring (ensuring safety)"
       - "VERIFY phase execution (mandatory)"
-      - "Test skeleton generation from acceptance criteria"
     typical_tasks: [implementation, debugging, quality-check, test_generation]
     size: medium
     priority: always
-    description: "Testing standards, TDD practices, and mandatory quality checks"
-    universal_concepts:
-      - "Red-Green-Refactor cycle"
-      - "Test independence"
-      - "AAA pattern (Arrange-Act-Assert)"
-      - "Coverage requirements (70%+)"
-      - "Mock/stub patterns"
-      - "Unit vs Integration testing"
-      - "Test-first development"
-
-  contextual/architecture/implementation-approach:
-    path: ".agents/rules/contextual/architecture/implementation-approach.md"
-    tags: [strategy-selection, task-decomposition, verification-levels, integration-points]
-    when_to_load:
-      - "Medium/Large scale tasks (3+ files)"
-      - "Implementation strategy selection"
-      - "Task breakdown and planning"
-      - "Choosing between vertical/horizontal slicing"
-    typical_tasks: [planning, design, implementation]
-    size: medium
-    priority: conditional
-    description: "Strategy selection for implementation approaches (vertical/horizontal slicing)"
+    description: "Testing standards and TDD practices (includes language-specific references)"
 
 
-# Task Type to Rule Mapping
+# Task Type to Skill Mapping
 task_mappings:
   prd_creation:
     required:
-      - "core/documentation-criteria"
+      - "documentation-criteria"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
 
   implementation:
     required:
-      - "language/rules"
-      - "language/testing"  # TDD is mandatory
-      - "core/ai-development-guide"
+      - "coding-rules"
+      - "testing"  # TDD is mandatory
+      - "ai-development-guide"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
     conditional:
-      - "contextual/architecture/implementation-approach"  # For Medium/Large scale
+      - "implementation-approach"  # For Medium/Large scale
 
   debugging:
     required:
-      - "core/ai-development-guide"
-      - "language/testing"
+      - "ai-development-guide"
+      - "testing"
     recommended:
-      - "language/rules"
-      - "core/metacognition"
+      - "coding-rules"
+      - "metacognition"
 
   design:
     required:
-      - "core/documentation-criteria"
+      - "documentation-criteria"
     conditional:
-      - "contextual/architecture/implementation-approach"  # Required for Medium/Large scale (3+ files)
+      - "implementation-approach"  # Required for Medium/Large scale (3+ files)
 
   documentation:
     required:
-      - "core/documentation-criteria"
+      - "documentation-criteria"
 
   refactoring:
     required:
-      - "language/rules"
-      - "language/testing"
-      - "core/ai-development-guide"
+      - "coding-rules"
+      - "testing"
+      - "ai-development-guide"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
 
   research:
     recommended:
-      - "core/metacognition"
+      - "metacognition"
 
   test_generation:
     required:
-      - "language/testing"  # Test framework patterns and conventions
-      - "core/documentation-criteria"  # Design document analysis
-      - "core/testing-strategy"  # ROI-based test selection
-      - "core/integration-e2e-testing"  # Integration/E2E test design rules
+      - "testing"
+      - "documentation-criteria"
+      - "testing-strategy"
+      - "integration-e2e-testing"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
 
   integration_test_review:
     required:
-      - "language/testing"
-      - "core/integration-e2e-testing"
+      - "testing"
+      - "integration-e2e-testing"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
     description: "Review integration and E2E test implementations"
 
   code_review:
     required:
-      - "language/rules"
-      - "core/ai-development-guide"
+      - "coding-rules"
+      - "ai-development-guide"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
     description: "Review implementation against Design Doc compliance"
 
   technical_document_review:
     required:
-      - "core/documentation-criteria"
+      - "documentation-criteria"
     conditional:
-      - "core/testing-strategy"
-      - "language/rules"
+      - "testing-strategy"
+      - "coding-rules"
     recommended:
-      - "core/metacognition"
+      - "metacognition"
     description: "Review technical documents (Design Docs, ADRs)"
 
-# Scale-based Rule Loading
+# Scale-based Skill Loading
 scale_mappings:
   small:  # 1-2 files
     load_immediately:
-      - "language/rules"
+      - "coding-rules"
     load_on_demand: []
 
   medium:  # 3-5 files
     load_immediately:
-      - "language/rules"
-      - "language/testing"  # TDD is mandatory
-      - "core/documentation-criteria"
-      - "contextual/architecture/implementation-approach"  # Required for approach selection
+      - "coding-rules"
+      - "testing"  # TDD is mandatory
+      - "documentation-criteria"
+      - "implementation-approach"  # Required for approach selection
     load_on_demand:
-      - "core/ai-development-guide"
+      - "ai-development-guide"
 
   large:  # 6+ files
     load_immediately:
-      - "core/documentation-criteria"
-      - "contextual/architecture/implementation-approach"
+      - "documentation-criteria"
+      - "implementation-approach"
     load_on_demand:
-      - "language/rules"
-      - "language/testing"
-      - "core/ai-development-guide"
+      - "coding-rules"
+      - "testing"
+      - "ai-development-guide"
 
-# Metadata for rule selection algorithm
+# Metadata for skill selection algorithm
 selection_rules:
-  - "Always load core/metacognition at session start"
-  - "Load language/rules when any code modification is involved"
-  - "Load language/testing for ALL implementation tasks (TDD mandatory)"
+  - "Always load metacognition at session start"
+  - "Load coding-rules when any code modification is involved"
+  - "Load testing for ALL implementation tasks (TDD mandatory)"
   - "Load implementation-approach for Medium/Large scale (3+ files)"
   - "Execute ALL quality check commands in VERIFY phase with 0 errors"
   - "Progressive loading: start with minimum, add as needed"
-  - "Unload task-specific rules after task completion"
+  - "Unload task-specific skills after task completion"
+  - "For TypeScript projects, also read references/typescript.md in coding-rules and testing skills"

package/.agents/{rules/core/ai-development-guide.md → skills/ai-development-guide/SKILL.md}

@@ -1,3 +1,10 @@
+---
+name: ai-development-guide
+description: |
+  Technical anti-pattern detection, fail-fast design principles, debugging techniques, and implementation completeness guidelines.
+  Use when: implementing features, reviewing code quality, debugging errors, refactoring code, or detecting code smells.
+---
+
 # AI Developer Guide
 
 ## Technical Anti-patterns (Red Flag Patterns)
@@ -253,7 +260,7 @@ Complete these stages sequentially before any implementation:
 
 **Critical**: Do not implement until all 3 stages are documented
 
-**Relationship to Pattern 5**: This process provides the structured methodology to avoid "Insufficient Existing Code Investigation" (see .agents/rules/core/ai-development-guide.md:150-158)
+**Relationship to Pattern 5**: This process provides the structured methodology to avoid "Insufficient Existing Code Investigation"
 
 ### Unused Code Deletion
 
@@ -269,4 +276,4 @@ In use? No → Delete
                      Yes → Fix/Extend
 ```
 
-**Principle**: Prefer clean implementation over patching broken code
+**Principle**: Prefer clean implementation over patching broken code

package/.agents/{rules/language/general/rules.md → skills/coding-rules/SKILL.md}

@@ -1,4 +1,16 @@
-# General Development Rules
+---
+name: coding-rules
+description: |
+  Coding principles for maintainability, readability, and quality.
+  Use when: implementing features, refactoring code, reviewing code quality, or establishing coding standards.
+---
+
+# Development Rules
+
+## Language-Specific References
+
+For language-specific rules, also read:
+- **TypeScript**: [references/typescript.md](references/typescript.md)
 
 ## Basic Principles
 
@@ -114,4 +126,4 @@ Never include sensitive information in logs:
 - Write small, focused modules/functions
 - Minimize dependencies between modules
 - Use clear interfaces between components
-- Follow single responsibility principle
+- Follow single responsibility principle

package/.agents/{rules/language/typescript/rules.md → skills/coding-rules/references/typescript.md}

@@ -1,15 +1,4 @@
-# TypeScript Development Rules
-
-## Basic Principles
-
-✅ **Aggressive Refactoring**
-❌ **Unused "Just in Case" Code** - YAGNI principle
-
-## Comment Writing Rules
-- **Function Description Focus**: Describe what the code "does"
-- **No Historical Information**: Do not record development history
-- **Timeless**: Write only content that remains valid whenever read
-- **Conciseness**: Keep explanations to necessary minimum
+# TypeScript-Specific Rules
 
 ## Type Safety
 
@@ -25,7 +14,7 @@
 ```typescript
 // Safely validate external input
 function isUser(value: unknown): value is User {
-  return typeof value === 'object' && value !== null && 
+  return typeof value === 'object' && value !== null &&
     'id' in value && 'name' in value
 }
 // Usage: if (isUser(data)) { /* data is typed as User */ }
@@ -75,7 +64,7 @@ Input Layer (`unknown`) → Type Guard → Business Layer (Type Guaranteed) →
 **Class Usage Criteria**
 - **Recommended: Implementation with Functions and Interfaces**
   - Rationale: Improves testability and flexibility of function composition
-- **Classes Allowed**: 
+- **Classes Allowed**:
   - Framework requirements (NestJS Controller/Service, TypeORM Entity, etc.)
   - Custom error class definitions
   - When state and business logic are tightly coupled (e.g., ShoppingCart, Session, StateMachine)
@@ -89,22 +78,20 @@ Input Layer (`unknown`) → Type Guard → Business Layer (Type Guaranteed) →
   ```
 
 **Function Design**
-- **0-2 parameters maximum**: Use object for 3+ parameters
-  ```typescript
-  // ✅ Object parameter
-  function createUser({ name, email, role }: CreateUserParams) {}
-  // ❌ Multiple parameters
-  function createUser(name: string, email: string, role: string) {}
-  ```
+```typescript
+// ✅ Object parameter
+function createUser({ name, email, role }: CreateUserParams) {}
+// ❌ Multiple parameters
+function createUser(name: string, email: string, role: string) {}
+```
 
 **Dependency Injection**
-- **Inject external dependencies as parameters**: Ensure testability and modularity
-  ```typescript
-  // ✅ Receive dependency as parameter
-  function createService(repository: Repository) { return {...} }
-  // ❌ Direct import dependency
-  import { userRepository } from './infrastructure/repository'
-  ```
+```typescript
+// ✅ Receive dependency as parameter
+function createService(repository: Repository) { return {...} }
+// ❌ Direct import dependency
+import { userRepository } from './infrastructure/repository'
+```
 
 **Asynchronous Processing**
 - Promise Handling: Always use `async/await`
@@ -116,16 +103,8 @@ Input Layer (`unknown`) → Type Guard → Business Layer (Type Guaranteed) →
 - Types in `PascalCase`, variables/functions in `camelCase`
 - Imports use absolute paths (`src/`)
 
-**Clean Code Principles**
-- ✅ Delete unused code immediately
-- ✅ Delete debug `console.log()`
-- ❌ Commented-out code (manage history with version control)
-- ✅ Comments explain "why" (not "what")
-
 ## Error Handling
 
-**Absolute Rule**: Error suppression prohibited. All errors must have log output and appropriate handling.
-
 **Result Type Pattern**: Express errors with types for explicit handling
 ```typescript
 type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }
@@ -148,31 +127,16 @@ export class AppError extends Error {
 // Purpose-specific: ValidationError(400), BusinessRuleError(400), DatabaseError(500), ExternalServiceError(502)
 ```
 
-**Layer-Specific Error Handling**
-- API Layer: Convert to HTTP response, log output excluding sensitive information
-- Service Layer: Detect business rule violations, propagate AppError as-is
-- Repository Layer: Convert technical errors to domain errors
-
-**Structured Logging and Sensitive Information Protection**
-Never include sensitive information (password, token, apiKey, secret, creditCard) in logs
-
 **Asynchronous Error Handling**
 - Global handler setup mandatory: `unhandledRejection`, `uncaughtException`
 - Use try-catch with all async/await
 - Always log and re-throw errors
 
-## Refactoring Techniques
-
-**Basic Policy**
-- Small Steps: Maintain always-working state through gradual improvements
-- Safe Changes: Minimize the scope of changes at once
-- Behavior Guarantee: Ensure existing behavior remains unchanged while proceeding
-
-**Implementation Procedure**: Understand Current State → Gradual Changes → Behavior Verification → Final Validation
+## Refactoring Priority
 
-**Priority**: Duplicate Code Removal > Large Function Division > Complex Conditional Branch Simplification > Type Safety Improvement
+Duplicate Code Removal > Large Function Division > Complex Conditional Branch Simplification > **Type Safety Improvement**
 
 ## Performance Optimization
 
 - Streaming Processing: Process large datasets with streams
-- Memory Leak Prevention: Explicitly release unnecessary objects
+- Memory Leak Prevention: Explicitly release unnecessary objects

package/.agents/{rules/core/documentation-criteria.md → skills/documentation-criteria/SKILL.md}

@@ -1,3 +1,10 @@
+---
+name: documentation-criteria
+description: |
+  Documentation creation criteria including PRD, ADR, Design Doc, and Work Plan requirements with templates.
+  Use when: creating technical documents, determining which documents are required, reviewing document quality, or planning feature implementation.
+---
+
 # Documentation Creation Criteria
 
 ## Creation Decision Matrix
@@ -181,4 +188,4 @@ Required diagrams for each document (using mermaid notation):
 1. **At creation**: Identify common technical areas (logging, error handling, async processing, etc.), reference existing common ADRs
 2. **When missing**: Consider creating necessary common ADRs
 3. **Design Doc**: Specify common ADRs in "Prerequisite ADRs" section
-4. **Compliance check**: Verify design aligns with common ADR decisions
+4. **Compliance check**: Verify design aligns with common ADR decisions

package/.agents/{rules/contextual/architecture/implementation-approach.md → skills/implementation-approach/SKILL.md}

@@ -1,3 +1,10 @@
+---
+name: implementation-approach
+description: |
+  Implementation strategy selection framework with meta-cognitive approach, verification levels, and integration point definitions.
+  Use when: planning implementation strategy, selecting development approach (vertical/horizontal/hybrid), or defining verification criteria.
+---
+
 # Implementation Strategy Selection Framework (Meta-cognitive Approach)
 
 An implementation strategy selection framework based on meta-cognitive thinking. Derives optimal implementation approaches through a systematic decision process from understanding existing implementations to constraint compatibility.
@@ -199,4 +206,4 @@ Define integration points according to selected strategy:
 3. **Apply 5 Whys**: Pursue root causes to grasp essence
 4. **Multi-perspective Evaluation**: Comprehensively evaluate from each Step 1-4 perspective
 5. **Creative Thinking**: Consider sequential application of multiple strategies and designs leveraging project-specific constraints
-6. **Clarify Decision Rationale**: Make strategy selection rationale explicit in design documents
+6. **Clarify Decision Rationale**: Make strategy selection rationale explicit in design documents

package/.agents/{rules/core/integration-e2e-testing.md → skills/integration-e2e-testing/SKILL.md}

@@ -1,3 +1,10 @@
+---
+name: integration-e2e-testing
+description: |
+  Integration and E2E test design principles, behavior verification rules, mock boundaries, and review criteria.
+  Use when: designing integration tests, E2E tests, writing test skeletons, or reviewing test implementation quality.
+---
+
 # Integration Test & E2E Test Design/Implementation Rules
 
 ## Test Types and Limits

package/.agents/{rules/core/metacognition.md → skills/metacognition/SKILL.md}

@@ -1,3 +1,10 @@
+---
+name: metacognition
+description: |
+  Self-assessment checkpoints and protocol for AI agents.
+  Use when: task type changes, after completing tasks, encountering errors, before starting new features, or switching between phases.
+---
+
 # Metacognition Protocol
 
 ## Purpose
@@ -8,7 +15,7 @@ Self-assessment checkpoints.
 
 **BLOCKING METACOGNITION REQUIRED at:**
 - [CHECKPOINT] Task type changes → CANNOT proceed without assessment
-- [CHECKPOINT] After completing ANY task from work plan → MUST evaluate before next task
+- [CHECKPOINT] After completing ANY task from Work Plan document → MUST evaluate before next task
 - [CHECKPOINT] When encountering error or unexpected result → ASSESS approach immediately
 - [CHECKPOINT] Before writing first line of new feature → VALIDATE approach first
 - [CHECKPOINT] When switching between major phases → CONFIRM all gates passed
@@ -71,7 +78,7 @@ Note: Context management is user's responsibility. Ask for guidance if unsure.
 **GATE: CANNOT start coding if ANY unchecked**
 
 ### During Execution [PROGRESS GATES]
-☐ [VERIFY] Following work plan from `docs/design/work-plan.md`
+☐ [VERIFY] Following Work Plan from `docs/plans/`
 ☐ [VERIFY] Making measurable progress (list completed items)
 ☐ [EVALUATE] Additional rules needed? (load IMMEDIATELY if yes)
 ☐ [EVALUATE] Blocked for >10 minutes? (MUST ask for help)
@@ -150,4 +157,4 @@ Remember:
 - Regular reflection improves quality
 - It's okay to pause and think
 - Ask for help when genuinely stuck
-- Perfect is the enemy of good
+- Perfect is the enemy of good

package/.agents/{rules/language/general/testing.md → skills/testing/SKILL.md}

@@ -1,4 +1,16 @@
-# General Testing Rules
+---
+name: testing
+description: |
+  Testing principles including TDD process, test quality criteria, coverage standards, and mock usage guidelines.
+  Use when: writing tests, designing test strategies, reviewing test quality, or establishing testing standards.
+---
+
+# Testing Rules
+
+## Language-Specific References
+
+For language-specific rules, also read:
+- **TypeScript/Vitest**: [references/typescript.md](references/typescript.md)
 
 ## TDD Process [MANDATORY for all code changes]
 
@@ -29,6 +41,8 @@
 - Pure configuration files
 - Documentation only
 - Emergency fixes (but add tests immediately after)
+- Exploratory spikes (discard or rewrite with tests before merging)
+- Build/deployment scripts (unless they contain business logic)
 
 ## Basic Testing Policy
 
@@ -83,26 +97,6 @@
      - Unit test coverage sufficient
      - Smoke tests for integration points
 
-   **Verification Pattern**:
-   1. **Establish Baseline**
-      - Test and document existing feature behavior
-      - Capture performance metrics
-      - Record expected outputs
-
-   2. **Apply Changes**
-      - Deploy or enable new feature
-      - Maintain feature flags for rollback capability
-
-   3. **Verify Existing Features**
-      - Confirm existing features still function correctly
-      - Compare against baseline metrics
-      - Validate no unexpected side effects
-
-   4. **Measure Performance** (NOT long-term stability tests)
-      - Response times within acceptable limits (project-specific)
-      - Resource usage remains stable
-      - No memory leaks or degradation
-
    **Success Criteria**:
    - Zero breaking changes in existing workflows
    - Performance degradation within project-defined acceptable limits
@@ -110,10 +104,6 @@
    - All integration points maintain expected contracts
    - Backward compatibility preserved where required
 
-   **Documentation Requirements**:
-   - Map all integration points in Design Doc
-   - Document test coverage for each impact level
-
 ## Test Design Principles
 
 ### Test Case Structure
@@ -205,6 +195,7 @@
 
 1. **Boundary coverage**: Include empty/zero/max/error cases with happy paths
 2. **Literal expectations**: Use literal values in assertions, not computed expressions
+   - Expected value ≠ mock return value (implementation processes data)
 3. **Result verification**: Assert return values and state, not call order
 4. **Meaningful assertions**: Every test must have at least one assertion
 5. **Mock external I/O only**: Mock DB/API/filesystem, use real internal utilities
@@ -245,13 +236,7 @@ Your project MUST have mechanisms to verify:
    - Type checking passes
    - No type errors or warnings
 
-### Implementation Guidelines
-- **Identify Your Tools**: Use your project's existing quality tools (test runners, linters, formatters, type checkers)
-- **Zero Error Policy**: ALL quality checks must pass with 0 errors before task completion
-- **Document Execution**: Note which quality checks were run and their results
-- **Project-Specific**: Adapt to your specific language, framework, and tooling setup
-
 ### ENFORCEMENT
 - Cannot proceed with task completion if ANY quality check fails
 - Must fix all errors and warnings before marking task complete
-- If your project lacks certain quality tools, establish them or document the gap
+- If your project lacks certain quality tools, establish them or document the gap