# CODEX.md - Testing & Boilerplate Sub-Agent

This file defines Codex's role as a **Sub-Agent** specializing in testing, models, and repetitive patterns.

## Role: Testing & Boilerplate Specialist

Codex serves as a specialized agent for:

| Domain | Responsibilities |
|--------|------------------|
| **Testing** | Unit tests, integration tests, test fixtures |
| **Models** | Pydantic models, dataclasses, type definitions |
| **Docstrings** | Google-style documentation for functions |
| **Boilerplate** | Repetitive patterns, similar class implementations |

## Hierarchy Position

```
        ┌─────────────────┐
        │   Claude Code   │ ← Lead Agent
        │  (Orchestrator) │
        └────────┬────────┘
                 │
    ┌────────────┼────────────┐
    ▼            ▼            ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│  Gemini  │ │  Codex   │ │  Human   │
│          │ │  (YOU)   │ │          │
└──────────┘ └──────────┘ └──────────┘
```

## Primary Ownership

| Pattern | Description |
|---------|-------------|
| `CODEX.md` | This directive file |
| `tests/` | All test files |
| `src/*/models.py` | Data models |
| `src/*/utils/` | Utility functions |

## Workflow

### Receiving Tasks from Claude

Claude will delegate tasks using this format:

```markdown
## Task for Codex

**Type:** [Tests | Models | Docstrings | Boilerplate]

### Pattern to Follow
```python
# Claude provides the first example
class ExampleClass(BaseClass):
    def method(self, arg: str) -> Result:
        ...
```

### Generate
- [ ] SimilarClass1 (same pattern)
- [ ] SimilarClass2 (same pattern)
- [ ] Tests for all classes
```

### Completing Tasks

1. **Claim task** in `.agent-state/tasks.yaml`
2. **Acquire locks** for files you'll modify
3. **Generate** following Claude's pattern
4. **Test** your implementation
5. **Return to Claude** for review

### Escalation to Claude

Escalate back to Claude when:
- Logic beyond simple patterns
- Complex mocking or fixtures needed
- Unclear requirements

```markdown
## Escalation to Claude

**Reason:** [Complexity | Unclear | Dependencies]

### Completed Work
[What you finished]

### Question
[What you need clarification on]
```

## Code Standards

Follow these standards:

| Standard | Value |
|----------|-------|
| Line length | 100 characters |
| Formatter | Black (Python) |
| Test framework | pytest |
| Type hints | Required |

### Example Test Style

```python
import pytest
from mypackage.models import MyModel


class TestMyModel:
    """Tests for MyModel class."""

    @pytest.fixture
    def sample_data(self) -> dict:
        """Provide sample data for tests."""
        return {
            "name": "test",
            "value": 42,
        }

    def test_creation(self, sample_data: dict) -> None:
        """Test model creation with valid data."""
        model = MyModel(**sample_data)
        assert model.name == "test"
        assert model.value == 42

    def test_validation_error(self) -> None:
        """Test model raises error on invalid data."""
        with pytest.raises(ValueError):
            MyModel(name="", value=-1)

    @pytest.mark.parametrize(
        "value,expected",
        [
            (0, True),
            (100, True),
            (-1, False),
        ],
    )
    def test_is_valid(self, value: int, expected: bool) -> None:
        """Test is_valid method with various inputs."""
        model = MyModel(name="test", value=value)
        assert model.is_valid() == expected
```

### Example Model Style

```python
from typing import Optional
from pydantic import BaseModel, Field, validator


class MyModel(BaseModel):
    """
    Represents a data entity.

    Attributes:
        name: The entity name
        value: The numeric value
        description: Optional description
    """

    name: str = Field(..., min_length=1, description="Entity name")
    value: int = Field(..., ge=0, description="Numeric value")
    description: Optional[str] = Field(None, description="Optional description")

    @validator("name")
    def validate_name(cls, v: str) -> str:
        """Ensure name is properly formatted."""
        return v.strip()

    def is_valid(self) -> bool:
        """Check if the model data is valid."""
        return self.value >= 0
```

## Commit Format

Always use this commit format:

```
[Codex] type(scope): description

Examples:
[Codex] test(models): add unit tests for MyModel
[Codex] feat(models): add NewModel with validation
[Codex] refactor(utils): add type hints to helpers
```

## Before Starting Work

1. Set environment variable:
   ```bash
   export SEO_AGENT_AUTHOR=codex
   ```

2. Check for existing locks:
   ```bash
   python tools/check-ownership.py --list-expired
   ```

3. Claim your task in `.agent-state/tasks.yaml`

## References

| Document | Purpose |
|----------|---------|
| `AGENTS.md` | Collaboration rules |
| `GUARDRAILS.md` | Ownership matrix |
| `CLAUDE.md` | Lead agent directive |

---

*Codex operates under Claude Code's orchestration. Always follow the provided patterns exactly.*
