kiro-agent-team 1.0.0

package/.kiro/guides/PIV Loop.md

@@ -0,0 +1,122 @@
+# PIV Loop
+
+The following is a guideline for the development process -> Plan ➡️Implement ➡️Verify / Validate (PIV Loop)
+
+## Planning
+
+### Phase 1
+
+During phase 1 of Planning, the user "vibe codes" and either generates a markdown summary OR the user will use the context / session as the summary of what it is the user is trying to create.  
+
+This is where the user is trying to undersatand:
+
+- Tech stack decisions
+
+- Architectural patterns
+
+- Constraints and conventions
+
+- Creating stable resources
+
+When the user has a clear idea of what the overall plan is, a Product Requirements Document (PRD) is created.  The @create-prd prompt can be used to generate this from the context or from a markdown:
+
+```bash
+@create-prd    # create the PRD from the context
+
+# OR
+
+@create-prd ./[vibe-plan-documnet.md]    # create the PRD from a markdown
+User: "Use @PRD.md to execute @quickstart"
+```
+
+### Phase 2
+
+This is where the PIV loop iteration begins.  The user now begins planning out the features of the application:
+
+- Codebase analysis
+
+- Documentation analysis
+
+- Integration points
+
+- Task specific rules
+
+```bash
+# Very SIMPLE example of how to proceed.  Feel free to add more details
+
+User: "What feature do you recommend I work on?"
+
+Agent: "I recommend you work on feature [XYZ]"
+
+@create-plan [XYZ]
+```
+
+The user could also ask for the top 5 features to implement and recommend which one(s) to start with an why.  Use your judgement.
+
+## Implementation
+
+Once the feature planning document(s) are created, the next step in the process is to execute, or implement, the plan.  The user makes sure to review the plan before proceeding - it is IMPORTANT that the user understands the plan.  This is the user's opportunity to converse with the agent to clarify and make any changes.
+
+Some things the user looks out for:
+
+- Ensuring tools are being used correctly
+
+- The correct files are being read and written to
+
+- Tasks are being managed properly (is Archon being used?)
+
+- "Thinking" tokens are being produced showing the coding agent understands the plan of attack.
+
+```bash
+User: "I reviewed the plan and noticed you did not 
+include [ABC] as part of the tech stack - please update 
+my system documents to include this (tech.md and feature plan)"
+Agent: "You are absolutely right! I will update the tech.md file
+and test plan to reflect the use of [ABC]"
+```
+
+Once the user is satisfied that the plan is robust, they can execute the implementation:
+
+```bash
+# Begin feature implementation
+
+@execute [plan relative path].md    # copy the relative path of the file
+```
+
+## Validation
+
+Once the feature has been implemented, it is the time to validate the code.  The user performs a code review to ensure that it is functioning as expected:
+
+```bash
+# Review the code
+@code-review
+```
+
+The coding assistant will have run the applicable unit and integration tests.  The user may need to conduct manual verification tests as well.
+
+This is also an opportunity to verify what went well and what didn't.  A system review takes place to identify areas where the "system" can be improved - the agent can identify what parts of the system need to be updated, and how.
+
+```bash
+# Create an execution report to identify issues
+@execution-report
+@system-review [file generated from execution report]
+```
+
+## Next Feature...
+
+Now it is time for the user to move onto the next feature.  To know what that is:
+
+```bash
+# ask for the next feature
+User: "What feature do you recommend on next.  Give me 5 tops features
+and recommend which one you think I should do and why"
+Agent: "Ok, here are the top 5 features you should work on..."
+Agent: "I recommend you proceed with [XYZ] because..."
+User: "Ok great, @create-plan [XYZ]"
+```
+
+The user keeps looping through the process until the MVP is completed.
+
+![](C:\test\kiro-agent-team\PIV%20Loop.png)
+
+

package/.kiro/guides/QUICK_REFERENCE.md

@@ -0,0 +1,202 @@
+# Kiro-CLI Agent Team Quick Reference
+
+## Essential Commands
+
+### 🚀 Core Development Flow
+```bash
+@prime                    # Load project context (Project Manager)
+@plan-feature [name]      # Create implementation plan (Project Manager)  
+@execute                  # Systematic task execution (All Agents)
+@code-review             # Quality assurance review (Test Orchestrator)
+@execution-report        # Implementation documentation (Test Orchestrator)
+```
+
+### 🔧 Specialized Workflows
+```bash
+@create-prd [feature]     # Product requirements doc (Project Manager)
+@rca [issue-id]          # Root cause analysis (Security Specialist)
+@implement-fix [issue-id] # Fix implementation (Security Specialist)
+@system-review [plan] [report] # Process improvement (Development Logger)
+@code-review-hackathon   # Project evaluation (Test Orchestrator)
+```
+
+## Agent Responsibilities
+
+| Agent | Primary Role | Key Prompts | Best For |
+|-------|-------------|-------------|----------|
+| **Project Manager** | Coordination & Planning | `@prime`, `@plan-feature`, `@create-prd` | Project setup, feature planning, team coordination |
+| **Backend Engineer** | Server-side Development | `@execute` | APIs, business logic, database integration |
+| **Frontend Architect** | Client-side Development | `@execute` | UI components, state management, user experience |
+| **Database Specialist** | Data Layer Management | `@execute` | Schema design, migrations, query optimization |
+| **DevOps Engineer** | Infrastructure & Deployment | `@execute` | CI/CD, containerization, cloud deployment |
+| **Security Specialist** | Application Security | `@rca`, `@implement-fix` | Vulnerability assessment, security fixes |
+| **Test Orchestrator** | Quality Assurance | `@code-review`, `@execution-report`, `@code-review-hackathon` | Testing strategy, quality gates, project evaluation |
+| **UI/UX Designer** | User Experience Design | `@execute` | Interface design, usability, accessibility |
+| **Development Logger** | Process Documentation | `@system-review` | Workflow analysis, process improvement |
+
+## Common Workflow Patterns
+
+### 🎯 New Feature Development
+```
+1. @prime (load context)
+2. @plan-feature [name] (create plan)
+3. @execute (implement by assigned agents)
+4. @code-review (quality check)
+5. @execution-report (document results)
+```
+
+### 🐛 Bug Fix Process
+```
+1. @rca [issue-id] (analyze problem)
+2. @implement-fix [issue-id] (fix implementation)
+3. @code-review (validate fix)
+4. @system-review (improve process)
+```
+
+### 🏆 Project Evaluation
+```
+1. @code-review-hackathon (comprehensive evaluation)
+2. @create-prd [project] (complete documentation)
+3. @system-review (process analysis)
+```
+
+## Quality Gates Checklist
+
+### ✅ Before Implementation
+- [ ] Project context loaded with `@prime`
+- [ ] Feature planned with `@plan-feature`
+- [ ] Tasks assigned to appropriate agents
+- [ ] Dependencies identified and resolved
+
+### ✅ During Implementation
+- [ ] All agents following `@execute` framework
+- [ ] Regular progress updates and coordination
+- [ ] Issues documented and addressed promptly
+- [ ] Quality standards maintained throughout
+
+### ✅ Before Deployment
+- [ ] Code review completed with `@code-review`
+- [ ] All tests passing and coverage adequate
+- [ ] Security validation completed
+- [ ] Performance benchmarks met
+- [ ] Documentation updated and complete
+
+### ✅ After Deployment
+- [ ] Implementation report generated with `@execution-report`
+- [ ] Process review conducted with `@system-review`
+- [ ] Lessons learned documented and shared
+- [ ] Process improvements identified and planned
+
+## Emergency Procedures
+
+### 🚨 Critical Security Issue
+```bash
+1. @rca [issue-id]           # Immediate analysis
+2. @implement-fix [issue-id] # Emergency fix
+3. @code-review             # Rapid validation
+4. Deploy with monitoring
+```
+
+### ⚡ Production Incident
+```bash
+1. Assess impact and contain issue
+2. @rca [incident-id] for systematic analysis
+3. @implement-fix [incident-id] for resolution
+4. @system-review for prevention measures
+```
+
+### 🔄 Process Breakdown
+```bash
+1. Identify specific workflow issues
+2. @system-review [current-process] [issues]
+3. Update agent configurations and workflows
+4. Test improved process with small feature
+```
+
+## Best Practices
+
+### 🎯 Do's
+- ✅ Always start with `@prime` for context
+- ✅ Use `@plan-feature` before major development
+- ✅ Follow `@execute` framework consistently
+- ✅ Run `@code-review` before deployment
+- ✅ Generate `@execution-report` for documentation
+- ✅ Conduct `@system-review` for improvement
+
+### ❌ Don'ts
+- ❌ Skip planning phase - leads to scope creep
+- ❌ Ignore quality gates - creates technical debt
+- ❌ Work without coordination - causes conflicts
+- ❌ Skip documentation - loses valuable insights
+- ❌ Avoid process review - misses improvement opportunities
+
+## Troubleshooting
+
+### Issue: Agent Coordination Problems
+**Solution**: Use Project Manager as central coordinator
+```bash
+@prime  # Establish shared context
+@plan-feature [name]  # Clear task assignments
+```
+
+### Issue: Quality Issues
+**Solution**: Implement systematic quality gates
+```bash
+@code-review  # Before any deployment
+@execution-report  # Document quality metrics
+```
+
+### Issue: Process Inefficiency
+**Solution**: Regular process analysis and improvement
+```bash
+@system-review [plan] [report]  # Identify bottlenecks
+Update agent configurations based on findings
+```
+
+### Issue: Knowledge Loss
+**Solution**: Comprehensive documentation workflow
+```bash
+@execution-report  # After major implementations
+@system-review  # For process insights
+Regular DEVLOG updates
+```
+
+## Success Metrics
+
+### 📊 Development Velocity
+- Time from feature request to deployment
+- Number of features delivered per sprint
+- Reduction in rework and bug fixes
+
+### 🎯 Quality Metrics  
+- Code review pass rate
+- Test coverage percentage
+- Production incident frequency
+- Security vulnerability count
+
+### 🔄 Process Effectiveness
+- Agent coordination efficiency
+- Knowledge retention and reuse
+- Process improvement implementation rate
+- Team satisfaction with workflows
+
+## Getting Help
+
+### 📚 Documentation
+- `AGENT_WORKFLOW_GUIDE.md` - Comprehensive workflow documentation
+- `IMPLEMENTATION_EXAMPLES.md` - Real-world usage examples
+- Individual agent specifications in `agents/` directory
+
+### 🔧 Configuration
+- Agent hooks in `agents/hooks/` directory
+- System prompts in `agents/prompts/` directory
+- Project steering documents in `.kiro/steering/`
+
+### 🎯 Support
+- Use agent consultation triggers for guidance
+- Review implementation examples for patterns
+- Analyze system reviews for process improvements
+
+---
+
+*Keep this reference handy for quick access to essential commands and workflows!*

package/.kiro/guides/README.md

@@ -0,0 +1,149 @@
+# Kiro-CLI Agent Team Documentation
+
+## 🎯 **Your Complete Guide to Systematic Development**
+
+Welcome to the comprehensive documentation for our 9-agent development team with integrated prompt workflows. This guide system will help you leverage the full power of systematic, quality-driven development.
+
+## 🚀 **Quick Navigation**
+
+### **Getting Started (5 minutes)**
+- 📖 **[Quick Start Guide](quick-start.md)** - Essential setup and first workflows
+- 🎯 **[Core Workflows](core-workflows.md)** - The 4 fundamental development patterns
+
+### **Daily Operations (Choose Your Focus)**
+- 👥 **[Agent Coordination](agent-coordination.md)** - Multi-agent collaboration patterns
+- ✅ **[Quality Assurance](quality-assurance.md)** - Testing, review, and validation processes
+- 🆘 **[Emergency Procedures](emergency-procedures.md)** - Incident response and critical fixes
+
+### **Advanced Usage**
+- 🏆 **[Project Evaluation](project-evaluation.md)** - Assessment and optimization workflows
+- 🔧 **[Advanced Patterns](advanced-patterns.md)** - Complex workflows and customization
+- 🛠️ **[Troubleshooting](troubleshooting.md)** - Common issues and solutions
+
+## 🎭 **Meet Your Agent Team**
+
+| Agent | Expertise | Primary Prompts | Best For |
+|-------|-----------|----------------|----------|
+| **Project Manager** | Coordination & Planning | `@prime`, `@plan-feature`, `@create-prd` | Project setup, feature planning |
+| **Backend Engineer** | Server Development | `@execute` | APIs, business logic, databases |
+| **Frontend Architect** | Client Development | `@execute` | UI, state management, UX |
+| **Database Specialist** | Data Management | `@execute` | Schema, migrations, optimization |
+| **DevOps Engineer** | Infrastructure | `@execute` | Deployment, CI/CD, monitoring |
+| **Security Specialist** | Application Security | `@rca`, `@implement-fix` | Vulnerability assessment, fixes |
+| **Test Orchestrator** | Quality Assurance | `@code-review`, `@execution-report` | Testing, validation, evaluation |
+| **UI/UX Designer** | User Experience | `@execute` | Design, usability, accessibility |
+| **Development Logger** | Process Improvement | `@system-review` | Workflow analysis, optimization |
+
+## 🎯 **Essential Commands Quick Reference**
+
+### **Core Development Flow**
+```bash
+@prime                    # Load project context
+@plan-feature [name]      # Create implementation plan
+@execute                  # Systematic implementation
+@code-review             # Quality validation
+@execution-report        # Document results
+```
+
+### **Specialized Workflows**
+```bash
+@create-prd [feature]     # Requirements documentation
+@rca [issue-id]          # Root cause analysis
+@implement-fix [issue-id] # Systematic fixes
+@system-review           # Process improvement
+@code-review-hackathon   # Project evaluation
+```
+
+## 🏗️ **System Architecture**
+
+### **Quality Gate System**
+Our integrated system includes 5 mandatory quality gates:
+
+1. **Planning Gate**: `@prime` + `@plan-feature` before implementation
+2. **Implementation Gate**: `@execute` framework for all agents
+3. **Quality Gate**: `@code-review` before deployment
+4. **Documentation Gate**: `@execution-report` for major features
+5. **Improvement Gate**: `@system-review` for process optimization
+
+### **Workflow Patterns**
+- **Sequential**: Project Manager → Specialist Agent → Test Orchestrator
+- **Parallel**: Multiple agents working simultaneously with coordination
+- **Iterative**: Implementation → Review → Fix → Improve cycles
+- **Emergency**: Rapid response with maintained quality standards
+
+## 📊 **Success Metrics**
+
+### **Development Velocity**
+- Time from feature request to deployment
+- Agent coordination efficiency
+- Reduction in rework and conflicts
+
+### **Quality Metrics**
+- Code review pass rates
+- Test coverage and compliance
+- Security vulnerability prevention
+- Production incident reduction
+
+### **Process Effectiveness**
+- Knowledge retention and reuse
+- Process improvement implementation
+- Team workflow adoption
+- Continuous learning integration
+
+## 🎓 **Learning Path**
+
+### **Beginner (Week 1)**
+1. Read [Quick Start Guide](quick-start.md)
+2. Practice [Core Workflows](core-workflows.md)
+3. Try [Agent Coordination](agent-coordination.md) patterns
+
+### **Intermediate (Week 2-3)**
+1. Master [Quality Assurance](quality-assurance.md) processes
+2. Learn [Emergency Procedures](emergency-procedures.md)
+3. Explore [Project Evaluation](project-evaluation.md) methods
+
+### **Advanced (Week 4+)**
+1. Implement [Advanced Patterns](advanced-patterns.md)
+2. Customize workflows for your team
+3. Contribute improvements back to the system
+
+## 🆘 **Need Help?**
+
+### **Quick Solutions**
+- 🔍 **Can't find something?** Check [Troubleshooting](troubleshooting.md)
+- 🚨 **Emergency?** Go to [Emergency Procedures](emergency-procedures.md)
+- 🤔 **Not sure which workflow?** Start with [Core Workflows](core-workflows.md)
+
+### **Support Resources**
+- **Agent Specifications**: Detailed docs in `agents/` directory
+- **Hook Configurations**: Automation setup in `agents/hooks/`
+- **System Prompts**: Implementation details in `agents/prompts/`
+- **Development Log**: Process insights in `DEVLOG.md`
+
+## 🎯 **What Makes This System Special**
+
+### **Systematic Quality**
+Every aspect of development has built-in quality assurance through integrated prompts and agent coordination.
+
+### **Predictable Outcomes**
+Standardized workflows create consistent, reliable results across all project types and team sizes.
+
+### **Continuous Learning**
+Process improvement is built into every development cycle through systematic analysis and optimization.
+
+### **Scalable Excellence**
+The system handles everything from individual features to complete applications with the same level of quality and coordination.
+
+---
+
+## 🚀 **Ready to Get Started?**
+
+1. **New to the system?** → [Quick Start Guide](quick-start.md)
+2. **Ready to build?** → [Core Workflows](core-workflows.md)
+3. **Need specific help?** → Choose the relevant focused guide above
+
+**Transform your development process with systematic, quality-driven workflows!**
+
+---
+
+*Last updated: 2026-01-04 | System version: 1.0 | Agent team: 9 specialists + 12 integrated prompts*