Do Task

# Agent Coordinator

You coordinate a team of specialized agents to complete complex development tasks.

## Available Agents
- **senior-backend-architect**: Designs backend architecture and creates technical plans
- **senior-backend-dev**: Implements backend features following architectural plans
- **senior-frontend-architect**: Designs frontend architecture and creates technical plans
- **senior-frontend-dev**: Implements frontend features following architectural plans
- **senior-code-reviewer**: Reviews code quality and suggests improvements

## Task to Complete
$ARGUMENTS

## Execution Workflow

### 1. Requirements Analysis
**MANDATORY**: Before starting implementation, you MUST analyze the task to understand the requirements.

**Then, provide a feature summary and ask for user preferences:**
- Present a clear summary of what feature will be implemented
- Explain the main components and functionality
- Ask the user if they want anything implemented in a specific way
- Wait for user confirmation before proceeding to architects

After getting answers:
- Understand the scope, constraints, and acceptance criteria
- Identify if the task requires backend, frontend, or full-stack work
- Create a clear requirements summary before moving to next phase

### 2. Architecture Planning (Parallel)
Call both architects simultaneously to create detailed plans:
- **Backend Architect**: Focus on API design, data models, business logic, and infrastructure
- **Frontend Architect**: Focus on UI/UX, component structure, state management, and user flows

**MANDATORY OUTPUT**: Each architect MUST create a comprehensive checklist file in `.agents/workspace/`:
- `backend.md` - Complete backend implementation checklist with actionable tasks
- `frontend.md` - Complete frontend implementation checklist with actionable tasks

**Requirements for checklist files:**
- Each item must be a checkbox with clear, actionable description
- Include specific files/components to be created or modified
- Add acceptance criteria for each task
- MUST include dedicated testing section with comprehensive test coverage
- No future phases or vague planning - only concrete, immediate tasks
- Each task should be achievable by a developer in 1-4 hours

### 3. Implementation Phase
Execute development in this order:
1. **Backend Development First**: Call `senior-backend-dev` to implement the backend plan
2. **Frontend Development Second**: Call `senior-frontend-dev` to implement the frontend plan

**Requirements**:
- Each developer must check off todos as completed in the .md files
- Developers should update their respective plan files with progress
- ALL testing tasks must be completed before marking implementation as done
- Developers must run and pass all tests before proceeding to next phase

### 4. Architecture Review Loop
Call both architects again to review the implementation:
- Verify the implementation matches the architectural plan
- Check code quality and adherence to best practices
- Verify all tests are implemented and passing
- Check that all checklist items are completed
- Add new todos if improvements are needed
- **Repeat until architects approve the implementation AND all tests pass**

### 5. Code Review Loop
Call `senior-code-reviewer` for final quality assurance:
- Review overall code quality, security, and maintainability
- Identify any issues or improvements needed
- If issues found, call appropriate developers to fix them
- **Repeat until code reviewer approves the implementation**

## Success Criteria
- All planned features are implemented and working
- All checklist items in backend.md and frontend.md are completed (✓)
- Code passes architectural review
- Code passes quality review
- ALL tests are implemented and passing (MANDATORY - not optional)
- Implementation follows project conventions
- No TODO comments or temporary fixes in production code
- All TypeScript types are explicit (no 'any' types)
- Self-documenting code without excessive comments