Output:
  category: feature-stage
  status: completed | blocked
  next_task_type: Code Implementation
  require_human_review: No
  auto_proceed: {from input Auto Proceed}
  task_output_links: [tests/]
  feature_id: FEATURE-XXX
  feature_title: {title}
  feature_version: {version}
  feature_phase: Test Generation
  
  # Test generation specific
  tests_created: [list of test files]
  test_count: {number}
  baseline_status: "X tests failing, 0 passing (TDD ready)"

CALL feature-stage+feature-board-management skill:
  operation: query_feature
  feature_id: {feature_id from task_data}

RECEIVE Feature Data Model:
  feature_id: FEATURE-XXX
  title: {Feature Title}
  version: v1.0
  status: Designed
  specification_link: x-ipe-docs/requirements/FEATURE-XXX/specification.md
  technical_design_link: x-ipe-docs/requirements/FEATURE-XXX/technical-design.md

1. READ {technical_design_link} from Feature Data Model
   Location: x-ipe-docs/requirements/FEATURE-XXX/technical-design.md

2. EXTRACT testable components from Part 1 (Agent-Facing Summary):
   - Components and their scope
   - Key interfaces and method signatures
   - Usage examples (basis for test cases)
   - Tags for context

3. EXTRACT test details from Part 2 (Implementation Guide):
   - Data models (fields to validate)
   - API endpoints (request/response to test)
   - Workflows (sequences to verify)
   - Edge cases and error handling (negative test cases)

4. CHECK Design Change Log for any updates

5. NOTE any references to architecture designs

6. **🎨 CHECK Technical Scope for mockup-based tests:**

IF technical design references architecture components:
  1. READ x-ipe-docs/architecture/technical-designs/{component}.md
  2. UNDERSTAND:
     - Common patterns that need testing
     - Shared utilities to mock/stub
     - Integration requirements to verify

COMMON REFERENCES:
  - Database patterns → Test data access
  - API standards → Test request/response formats
  - Error handling → Test error cases
  - Authentication → Test auth flows

1. READ {specification_link} from Feature Data Model
   Location: x-ipe-docs/requirements/FEATURE-XXX/specification.md

2. EXTRACT acceptance criteria:
   - Each criterion becomes at least one test
   - Note edge cases documented
   - Note business rules to verify

1. CATEGORIZE tests needed:

   UNIT TESTS (isolated components):
   - Each public method
   - Each data model validation
   - Each utility function
   
   INTEGRATION TESTS (component interactions):
   - Service → Repository
   - Controller → Service
   - Component A → Component B
   
   API TESTS (endpoint validation):
   - Each endpoint from technical design
   - Success responses
   - Error responses

2. PRIORITIZE:
   - Core functionality first
   - Happy path before edge cases
   - Critical paths before optional

3. DEFINE test data:
   - Mock data for unit tests
   - Fixtures for integration tests
   - Request/response samples for API tests

1. TEST happy path:
   - Valid inputs → Expected outputs
   - Normal conditions → Success

2. TEST edge cases:
   - Boundary values (min, max, zero)
   - Empty inputs
   - Maximum values

3. TEST error conditions:
   - Invalid inputs → Appropriate errors
   - Missing dependencies → Handled gracefully
   - Exception scenarios → Caught and reported

test_<function>_<scenario>_<expected_result>

Examples:
- test_authenticate_valid_credentials_returns_token
- test_authenticate_invalid_email_raises_error
- test_authenticate_expired_token_returns_401

def test_login_with_valid_credentials_returns_token(self):
    """AC: User receives JWT token on successful login"""
    # ARRANGE (Given)
    email = "user@test.com"
    password = "ValidPass123"
    
    # ACT (When)
    result = auth_service.authenticate(email, password)
    
    # ASSERT (Then)
    assert result.access_token is not None
    assert result.token_type == "Bearer"

1. IDENTIFY integration points from technical design:
   - Service → Database/Repository
   - Controller → Service
   - Feature → External service

2. FOR EACH integration:
   - Test successful flow end-to-end
   - Test failure handling and recovery
   - Test timeout/retry behavior (if applicable)

FOR EACH endpoint in technical design:

1. TEST success case:
   - Valid request → Expected response
   - Correct status code
   - Response body matches schema

2. TEST error cases:
   - Missing required fields → 400 Bad Request
   - Invalid data format → 400 Bad Request
   - Unauthorized → 401 Unauthorized
   - Not found → 404 Not Found

3. TEST edge cases:
   - Empty body
   - Extra fields (should be ignored or rejected)
   - Boundary values

1. CREATE test coverage documentation:

   | Component | Unit Tests | Integration | API Tests |
   |-----------|------------|-------------|-----------|
   | AuthService | 8 | 2 | - |
   | TokenManager | 5 | - | - |
   | UserRepository | 4 | 3 | - |
   | /login endpoint | - | - | 4 |
   | /logout endpoint | - | - | 3 |
   | **TOTAL** | **17** | **5** | **7** |

2. DOCUMENT test data:
   - Mock data definitions
   - Test fixtures created
   - Setup/teardown requirements

1. RUN all tests:
   pytest tests/ -v

2. VERIFY all tests FAIL:
   - Expected: X tests failing, 0 passing
   - Failure reason: Missing implementation (not test errors)

3. FIX any test syntax/setup issues:
   - Tests should fail because code doesn't exist
   - NOT because tests have bugs

4. RECORD baseline:
   baseline_status: "29 tests failing, 0 passing (TDD ready)"

1. Unit tests for service layer
2. Integration tests for full flow
3. API tests for each endpoint
4. Test auth and error responses

1. Unit tests for core logic
2. Mock external dependencies
3. Test timeout and retry behavior
4. Verify cleanup on failure

1. Test with valid input → expected output
2. Test with edge cases (empty, null, max)
3. Test with invalid input → proper errors
4. Use parameterized tests for variations

tests/
├── unit/                    # Unit tests (isolated)
│   ├── services/
│   │   └── auth_service_test.py
│   ├── models/
│   │   └── user_test.py
│   └── utils/
│       └── token_utils_test.py
├── integration/             # Integration tests
│   └── auth_flow_test.py
├── api/                     # API tests
│   └── auth_api_test.py
├── fixtures/                # Shared test data
│   └── users.py
└── conftest.py              # Test configuration