Bring to life: Daedalus, Talos, Icarus - TekDek Development Team

2026-04-11 18:44:02 -04:00
parent bf531d4739
commit cbd92e20a8
4 changed files with 1317 additions and 0 deletions
--- a/knowledge/agents/Team-Coordination.md
+++ b/knowledge/agents/Team-Coordination.md
@@ -0,0 +1,375 @@
+# TekDek Development Team Coordination
+
+**Team**: Daedalus (Architect) + Talos (Coder) + Icarus (Designer)  
+**Coordinator**: ParzivalTD  
+**Owner**: Glytcht
+
+---
+
+## The Team
+
+| Role | Agent | Model | Focus | Speed |
+|------|-------|-------|-------|-------|
+| **Architect** | Daedalus | Claude Opus 4.6 | System design, specs, blueprints | Thoughtful |
+| **Coder** | Talos | Claude Sonnet 4.6 | Implementation, APIs, databases | Fast & reliable |
+| **Designer** | Icarus | Claude Haiku 4.5 | UX/UI, dashboards, polish | Rapid iteration |
+
+---
+
+## Workflow: From Requirement to Delivery
+
+### Phase 1: Requirements → Daedalus
+
+**Input**: Feature request or requirement from ParzivalTD  
+**Agent**: Daedalus  
+**Output**: Architecture spec + implementation blueprint
+
+```
+ParzivalTD: "We need a system to track which narrative arcs 
+different personas are involved in."
+
+Daedalus: 
+1. Design database schema (personas, arcs, relationships)
+2. Define API endpoints (GET/POST/PATCH)
+3. Write implementation spec for Talos
+4. Define data models for Icarus
+5. Document trade-offs and assumptions
+```
+
+---
+
+### Phase 2: Spec → Talos
+
+**Input**: Daedalus's architecture spec  
+**Agent**: Talos  
+**Output**: Working APIs + database + tests
+
+```
+Talos receives:
+- Database schema (exact CREATE TABLE statements)
+- API endpoints to implement (request/response format)
+- Validation rules
+- Performance targets
+
+Talos delivers:
+- MySQL/PostgreSQL database migrations
+- REST API endpoints (tested)
+- Input validation
+- PHPUnit test suite (100% pass)
+- API documentation (OpenAPI spec)
+```
+
+**Checklist before delivery:**
+- [ ] All endpoints implemented per spec
+- [ ] All tests pass (100%)
+- [ ] Input validation complete
+- [ ] Performance targets met
+- [ ] Code reviewed
+- [ ] Documentation complete
+- [ ] Ready for Icarus
+
+---
+
+### Phase 3: APIs → Icarus
+
+**Input**: Talos's APIs + Daedalus's data models  
+**Agent**: Icarus  
+**Output**: Beautiful, responsive UI
+
+```
+Icarus receives:
+- API endpoints (from Talos)
+- Data models (from Daedalus)
+- Layout/interaction specs
+- Visual direction
+
+Icarus delivers:
+- HTML/CSS/JavaScript dashboard
+- Responsive design (mobile → desktop)
+- Accessible (WCAG 2.1 AA)
+- Interactive components
+- Pixel-perfect implementation
+```
+
+**Checklist before delivery:**
+- [ ] UI matches spec
+- [ ] Responsive tested (320px, 768px, 1920px)
+- [ ] Accessibility tested (WCAG 2.1 AA)
+- [ ] Performance tested (Lighthouse 90+)
+- [ ] Interactions polished
+- [ ] Code documented
+- [ ] Ready for deployment
+
+---
+
+## Collaboration Model
+
+### Daily Workflow
+
+```
+Morning Standup (async):
+├── Daedalus: What's in progress? Any blockers?
+├── Talos: What's in progress? Any blockers?
+└── Icarus: What's in progress? Any blockers?
+
+Mid-day Check:
+├── Talos asks Daedalus: "Is this interpretation of the spec correct?"
+└── Icarus asks Talos: "Does the API return this format?"
+
+End-of-day Sync:
+├── Daedalus: "Here's the next spec, ready for Talos"
+├── Talos: "APIs ready, Icarus can start building"
+└── Icarus: "UI ready for review"
+```
+
+### Weekly Sync (Full Team)
+
+**Attendees**: Daedalus + Talos + Icarus + ParzivalTD  
+**Time**: 1 hour  
+**Agenda**:
+1. **Progress**: What's done? What's blockers?
+2. **Handoffs**: Specs ready? APIs ready? UI ready?
+3. **Quality**: Code reviews, architecture fit, performance
+4. **Next week**: Priorities, dependencies, timeline
+
+---
+
+## Communication Protocols
+
+### Daedalus → Talos
+
+**When specs are ready**:
+- Daedalus writes: "Spec ready: [feature name]"
+- Includes: Database schema, API endpoints, implementation notes
+- Talos asks clarifying questions immediately
+- No ambiguity = fast execution
+
+**During implementation**:
+- Talos asks: "Should this endpoint return X or Y?"
+- Daedalus responds: "Return X per spec, here's why"
+- Talos implements per clarification
+
+**After implementation**:
+- Talos: "APIs ready, tests passing, ready for Icarus"
+- Daedalus: Code review (architecture fit)
+- Daedalus: Approval to proceed or feedback
+
+### Talos → Icarus
+
+**When APIs are ready**:
+- Talos writes: "APIs ready: [feature name]"
+- Includes: OpenAPI spec, example requests/responses, data formats
+- Icarus tests APIs, confirms they work as documented
+- No surprises = fast UI building
+
+**During UI development**:
+- Icarus: "API returns nested objects, should I flatten for UI?"
+- Talos: "Don't flatten, here's why it's structured that way"
+- Icarus: Implements per response
+
+**After UI delivery**:
+- Icarus: "UI ready, responsive, accessible, ready for deployment"
+- Talos: QA (does it consume APIs correctly?)
+- Talos: Approval to proceed
+
+### Icarus → Daedalus (UX Questions)
+
+**Layout/interaction clarity**:
+- Icarus: "Should this dashboard show X, Y, or Z?"
+- Daedalus: "Show X, here's the data model"
+- Icarus: Implements per specification
+
+**Visual questions**:
+- Icarus: "Should the form validation be inline or tooltip?"
+- Daedalus: "Your call, prioritize clarity"
+- Icarus: Decides and implements
+
+---
+
+## Dependency Graph
+
+```
+Requirement
+    ↓ (Daedalus designs)
+Architecture Spec
+    ↓ (Talos implements)
+Working APIs
+    ↓ (Icarus builds UI)
+Delivered Feature
+    ↓ (Deployed)
+Users interact
+```
+
+### Critical Path
+
+For any feature:
+1. **Daedalus spec design** (3-5 days)
+2. **Talos implementation** (5-10 days)
+3. **Icarus UI build** (3-5 days)
+4. **QA & deployment** (1-2 days)
+
+**Total**: 12-22 days per feature (Phase 1)
+
+As the team gels and patterns emerge, this compresses significantly.
+
+---
+
+## Escalation Path
+
+### Blocked by API Issue
+```
+Icarus → Talos → Daedalus → (clarify) → Talos → Icarus
+```
+
+### Blocked by Architecture Unclear
+```
+Talos → Daedalus → (clarify) → Talos
+```
+
+### Blocked by External Dependency
+```
+[Any agent] → ParzivalTD → (resolve) → [Agent]
+```
+
+### Emergency Fix Needed
+```
+ParzivalTD → (pick agent) → (fix) → Deploy
+```
+
+---
+
+## Quality Gates
+
+### Before Talos Delivers to Icarus
+
+- [ ] All endpoints implemented per spec
+- [ ] 100% test coverage
+- [ ] No linting errors
+- [ ] API documentation complete
+- [ ] Performance targets met
+- [ ] Code reviewed by Daedalus
+- [ ] Ready for production
+
+### Before Icarus Delivers to Deployment
+
+- [ ] UI matches spec
+- [ ] Responsive tested (all breakpoints)
+- [ ] Accessibility tested (WCAG 2.1 AA)
+- [ ] Performance tested (Lighthouse 90+)
+- [ ] Cross-browser tested
+- [ ] All interactions polished
+- [ ] Ready for production
+
+---
+
+## Tools & Access
+
+### All Agents
+- Git repository access (code, specs, documentation)
+- Gitea for version control
+- OpenClaw for async communication
+- Access to task queue/kanban
+
+### Daedalus
+- Design tools (can create ASCII diagrams, database charts)
+- Documentation (markdown, structured specs)
+- Access to architecture decisions
+
+### Talos
+- PHP/MySQL development environment
+- Database migrations
+- API testing tools (Postman, curl)
+- Performance monitoring
+
+### Icarus
+- HTML/CSS/JavaScript environment
+- Browser dev tools
+- Responsive design testing
+- Accessibility testing tools (WAVE, axe)
+
+---
+
+## Success Metrics
+
+### Team Success
+- Features delivered on time
+- Quality gates passed consistently
+- Zero "surprise" issues between agents
+- Communication is clear and frequent
+- Velocity increases over time
+
+### Individual Agent Success
+
+**Daedalus**:
+- Specs are clear enough for Talos to implement without ambiguity
+- Architecture scales 10x without redesign
+- Technical debt stays minimal
+
+**Talos**:
+- APIs work as specified, every time
+- Tests cover all functionality
+- Performance meets targets
+- Icarus can build UI without issues
+
+**Icarus**:
+- UI is intuitive and delightful
+- Responsive and accessible
+- Performance is optimized
+- Users love interacting with it
+
+---
+
+## Continuous Improvement
+
+### Weekly Retrospective
+- What went well?
+- What didn't go well?
+- What should we change?
+- How do we speed up?
+
+### Monthly Architecture Review
+- Is the system holding up?
+- Are patterns emerging?
+- Should we refactor anything?
+- What's next?
+
+---
+
+## Notes for ParzivalTD
+
+**Your role as coordinator**:
+1. **Clarify requirements** for Daedalus
+2. **Set priorities** for the team
+3. **Unblock dependencies**
+4. **Review quality gates**
+5. **Facilitate communication**
+6. **Celebrate wins** (when features ship)
+
+**When to trust each agent**:
+- Trust Daedalus on architecture decisions
+- Trust Talos on implementation details
+- Trust Icarus on UX/design decisions
+- Trust the process (specs → code → UI → ship)
+
+**When to intervene**:
+- Requirements unclear (clarify with Daedalus)
+- Specs stuck (push Daedalus)
+- Code stuck (push Talos)
+- UI stuck (push Icarus)
+- Blockers across agents (unblock)
+
+---
+
+## The TekDek Development Machine
+
+This is your three-part engine:
+
+- **Daedalus** = Blueprint architect (think)
+- **Talos** = Execution machine (build)
+- **Icarus** = Experience designer (polish)
+
+Together, they turn requirements into beautiful, scalable systems.
+
+Your job is to feed them requirements and keep them in sync.
+
+Welcome to TekDek Development. Let's build something great.