@wipal/agent-team 1.0.0

package/.claude/skills/domain/architecture/tech-selection/references/build-vs-buy.md

@@ -0,0 +1,258 @@
+# Build vs Buy Analysis
+
+## Framework Overview
+
+```
+┌─────────────────────────────────────────────────────┐
+│                BUILD VS BUY                          │
+├─────────────────────────────────────────────────────┤
+│                                                      │
+│   BUILD when:            BUY when:                  │
+│   - Core competency      - Commodity                │
+│   - Differentiation      - Time-critical            │
+│   - Control needed       - Team lacks expertise     │
+│   - Custom needs         - Mature solutions exist   │
+│                                                      │
+└─────────────────────────────────────────────────────┘
+```
+
+## Decision Matrix
+
+### Quick Assessment
+
+| Question | Build (+) | Buy (-) |
+|----------|-----------|---------|
+| Is this our core business? | Yes | No |
+| Does solution exist? | No | Yes |
+| Time to market critical? | No | Yes |
+| Team has expertise? | Yes | No |
+| Long-term maintenance OK? | Yes | No |
+| Customization needed? | Extensive | Minimal |
+| Budget available? | For dev | For license |
+| Integration complexity? | Custom | Standard |
+
+**Score**: If mostly (+), consider BUILD. If mostly (-), consider BUY.
+
+## Build Analysis
+
+### When to Build
+```
+STRATEGIC REASONS:
+✅ Competitive advantage
+   - Custom functionality
+   - Unique user experience
+   - Proprietary algorithms
+
+✅ Full control needed
+   - Data privacy requirements
+   - Custom SLA requirements
+   - Specific compliance needs
+
+✅ No suitable solution exists
+   - Novel problem domain
+   - Unique requirements
+   - Emerging technology
+
+PRACTICAL REASONS:
+✅ Existing expertise
+✅ Long-term cost advantage
+✅ Learning/development opportunity
+✅ Integration simplification
+```
+
+### Build Costs
+```
+DIRECT COSTS:
+- Development time: [hours] × [rate]
+- Infrastructure: [monthly] × [months]
+- Tools/licenses: [$]
+- Third-party services: [$]
+
+HIDDEN COSTS:
+- Requirements gathering: [$]
+- Design and architecture: [$]
+- Testing and QA: [$]
+- Documentation: [$]
+- Training: [$]
+- Ongoing maintenance: 15-25% of dev cost/year
+- Bug fixes and patches: [$]
+- Feature additions: [$]
+
+TOTAL BUILD COST (Year 1) = Direct + Hidden
+ONGOING COST (Year 2+) = Maintenance + Operations
+```
+
+### Build Risks
+```
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| Scope creep | High | High | Fixed scope MVP |
+| Schedule delay | High | Medium | Agile, buffer |
+| Quality issues | Medium | High | Code review, testing |
+| Team turnover | Medium | High | Documentation |
+| Tech debt | High | Medium | Refactoring time |
+```
+
+## Buy Analysis
+
+### When to Buy
+```
+STRATEGIC REASONS:
+✅ Commodity functionality
+   - Authentication (Auth0, Cognito)
+   - Payments (Stripe, PayPal)
+   - Email (SendGrid, Mailgun)
+   - Analytics (Mixpanel, Amplitude)
+
+✅ Time to market critical
+   - Startup phase
+   - Competitive pressure
+   - Market window
+
+✅ Complex domain
+   - Regulatory compliance
+   - Security requirements
+   - Specialized expertise needed
+
+PRACTICAL REASONS:
+✅ Team focus on core
+✅ Vendor expertise
+✅ Reduced maintenance
+✅ Faster deployment
+```
+
+### Buy Costs
+```
+DIRECT COSTS:
+- License/subscription: [monthly/yearly]
+- Implementation: [$]
+- Integration: [$]
+- Training: [$]
+- Support tier: [$]
+
+HIDDEN COSTS:
+- Customization limits: [$]
+- Workarounds needed: [$]
+- Vendor dependency: [risk cost]
+- Migration (future): [$]
+- Data export: [$]
+
+TOTAL BUY COST (Year 1) = Direct + Hidden
+ONGOING COST (Year 2+) = Subscription + Support
+```
+
+### Buy Risks
+```
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| Vendor lock-in | High | High | Exit strategy |
+| Price increases | Medium | Medium | Contract terms |
+| Feature gaps | Medium | Medium | Roadmap alignment |
+| Service outage | Low | High | SLA, backup plan |
+| Company failure | Low | High | Vendor assessment |
+```
+
+## Comparison Framework
+
+### 3-Year TCO Comparison
+
+```
+BUILD:
+                    Year 1      Year 2      Year 3
+Development         $300k       -           -
+Infrastructure       $20k       $25k       $30k
+Maintenance          -          $60k       $75k
+Operations           $10k       $15k       $20k
+Team (2 FTE)        $200k      $210k      $220k
+─────────────────────────────────────────────────
+TOTAL              $530k      $310k      $345k
+3-Year Total: $1,185k
+
+BUY:
+                    Year 1      Year 2      Year 3
+License/Subscription $150k     $160k      $170k
+Implementation        $50k       -          -
+Integration           $30k       -          -
+Operations            $5k       $10k       $15k
+─────────────────────────────────────────────────
+TOTAL               $235k      $170k      $185k
+3-Year Total: $590k
+```
+
+## Hybrid Approaches
+
+### Option 1: Buy Core, Build Extensions
+```
+Base: Commercial platform (Buy)
+Extensions: Custom features (Build)
+
+Example:
+- Buy: Shopify for e-commerce core
+- Build: Custom checkout flow, integrations
+```
+
+### Option 2: Build Core, Buy Components
+```
+Core: Custom application (Build)
+Components: Specialized services (Buy)
+
+Example:
+- Build: Main application logic
+- Buy: Auth (Auth0), Search (Algolia), Email (SendGrid)
+```
+
+### Option 3: Open Source + Customization
+```
+Base: Open source project (Free)
+Customization: Internal development
+
+Example:
+- Base: WordPress/WooCommerce
+- Custom: Theme, plugins, integrations
+```
+
+## Decision Checklist
+
+```
+Before deciding to BUILD:
+□ This is core to our business
+□ No suitable solution exists
+□ We have/will hire the expertise
+□ We can afford the timeline
+□ We're committed to long-term maintenance
+
+Before deciding to BUY:
+□ This is not a competitive advantage
+□ Mature solutions exist
+□ Time to market is critical
+□ TCO analysis favors buying
+□ We have an exit strategy
+```
+
+## Real-World Examples
+
+### Build Examples
+```
+Netflix recommendation engine
+- Core competitive advantage
+- Massive scale requirements
+- Proprietary algorithms
+
+Uber pricing engine
+- Real-time optimization
+- Complex business logic
+- Unique requirements
+```
+
+### Buy Examples
+```
+Stripe for payments
+- Complex regulatory compliance
+- Not core to most businesses
+- Excellent developer experience
+
+Auth0 for authentication
+- Security-critical
+- Complex to build correctly
+- Commodity functionality
+```

package/.claude/skills/domain/architecture/tech-selection/references/evaluation-framework.md

@@ -0,0 +1,203 @@
+# Technology Evaluation Framework
+
+## Comprehensive Evaluation Template
+
+### 1. Requirements Gathering
+
+#### Business Requirements
+- [ ] Budget constraints defined
+- [ ] Timeline requirements documented
+- [ ] Business impact understood
+- [ ] Stakeholder input collected
+
+#### Technical Requirements
+- [ ] Performance requirements quantified
+- [ ] Scalability requirements defined
+- [ ] Security requirements listed
+- [ ] Integration requirements mapped
+
+#### Team Requirements
+- [ ] Current expertise assessed
+- [ ] Learning capacity evaluated
+- [ ] Hiring market analyzed
+
+### 2. Option Identification
+
+#### Sources
+```
+- Industry reports (Gartner, Forrester)
+- Tech radar (ThoughtWorks, your company)
+- Community recommendations
+- Case studies from similar companies
+- Consultant advice
+```
+
+#### Long List Creation
+```
+Step 1: Cast wide net (5-10 options)
+Step 2: Quick filter (must-have requirements)
+Step 3: Short list (2-3 options)
+Step 4: Deep evaluation
+```
+
+### 3. Evaluation Criteria
+
+#### Must-Have Criteria (Pass/Fail)
+```
+Examples:
+- Must support >100k concurrent users
+- Must be GDPR compliant
+- Must run on AWS
+- Must have <10ms p99 latency
+```
+
+#### Weighted Scoring Criteria
+```
+Category: Performance (25%)
+├── Throughput: 10%
+├── Latency: 10%
+└── Resource efficiency: 5%
+
+Category: Scalability (20%)
+├── Horizontal scaling: 10%
+└── Vertical scaling: 10%
+
+Category: Developer Experience (15%)
+├── Ease of use: 10%
+└── Documentation: 5%
+
+Category: Operations (15%)
+├── Monitoring: 8%
+└── Debugging: 7%
+
+Category: Cost (15%)
+├── Licensing: 8%
+└── Infrastructure: 7%
+
+Category: Risk (10%)
+├── Maturity: 5%
+└── Community: 5%
+```
+
+### 4. Scoring Guide
+
+```
+5/5 - Excellent
+- Exceeds requirements significantly
+- Best-in-class
+- No concerns
+
+4/5 - Good
+- Meets requirements well
+- Minor concerns
+
+3/5 - Adequate
+- Meets minimum requirements
+- Some concerns
+
+2/5 - Poor
+- Partially meets requirements
+- Significant concerns
+
+1/5 - Inadequate
+- Does not meet requirements
+- Disqualifying concerns
+```
+
+### 5. Risk Assessment
+
+#### Technical Risks
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| Performance degradation | M | H | Load testing |
+| Security vulnerability | L | H | Security audit |
+| Scalability limits | M | M | Architecture review |
+
+#### Organizational Risks
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| Team resistance | H | M | Training, involvement |
+| Skill gap | M | H | Training plan |
+| Vendor lock-in | M | M | Exit strategy |
+
+### 6. Total Cost of Ownership
+
+```
+Direct Costs:
+├── Licensing/Subscription: $/year
+├── Infrastructure: $/year
+├── Support contracts: $/year
+└── Training: $ (one-time)
+
+Indirect Costs:
+├── Development time: $ (setup, learning)
+├── Maintenance: $/year
+├── Migration: $ (one-time)
+└── Opportunity cost: $
+
+3-Year TCO = Direct + Indirect
+```
+
+### 7. POC Checklist
+
+```
+POC Goals:
+- [ ] Primary use case validated
+- [ ] Performance requirements met
+- [ ] Integration points tested
+- [ ] Team feedback collected
+- [ ] Operational concerns addressed
+
+POC Scope:
+- [ ] Time-boxed (2-4 weeks)
+- [ ] Limited to key requirements
+- [ ] Representative workload
+- [ ] Real data (or realistic test data)
+
+POC Success Criteria:
+- [ ] Must pass: [criteria]
+- [ ] Should pass: [criteria]
+```
+
+### 8. Decision Matrix Example
+
+```
+Project: E-commerce Platform Database
+Date: 2024-01-15
+Decision Makers: Team A
+
+| Criteria | Weight | PostgreSQL | MongoDB | DynamoDB |
+|----------|--------|------------|---------|----------|
+| ACID Compliance | 20% | 5 (1.0) | 2 (0.4) | 3 (0.6) |
+| JSON Support | 15% | 4 (0.6) | 5 (0.75) | 4 (0.6) |
+| Scalability | 15% | 3 (0.45) | 4 (0.6) | 5 (0.75) |
+| Query Flexibility | 15% | 5 (0.75) | 4 (0.6) | 3 (0.45) |
+| Managed Service | 10% | 5 (0.5) | 4 (0.4) | 5 (0.5) |
+| Cost | 15% | 4 (0.6) | 3 (0.45) | 3 (0.45) |
+| Team Expertise | 10% | 4 (0.4) | 3 (0.3) | 2 (0.2) |
+|----------|--------|------------|---------|----------|
+| TOTAL | 100% | 4.30 | 3.50 | 3.55 |
+
+Recommendation: PostgreSQL
+Rationale: Best fit for ACID + JSON requirements, team expertise
+```
+
+### 9. Post-Decision Actions
+
+```
+Immediate:
+- [ ] Announce decision to stakeholders
+- [ ] Create ADR
+- [ ] Plan implementation timeline
+
+Short-term:
+- [ ] Acquire licenses/access
+- [ ] Set up development environment
+- [ ] Begin team training
+- [ ] Create migration plan (if applicable)
+
+Long-term:
+- [ ] Schedule regular reviews
+- [ ] Monitor for new alternatives
+- [ ] Track actual vs expected benefits
+```

package/.claude/skills/domain/architecture/tech-selection/references/tech-radar.md

@@ -0,0 +1,257 @@
+# Technology Radar
+
+## Overview
+A Technology Radar visualizes technology decisions across categories and adoption stages.
+
+## Radar Structure
+
+### Rings (Adoption Stages)
+```
+┌─────────────────────────────────────────────┐
+│                  ADOPT                       │
+│  ┌───────────────────────────────────────┐  │
+│  │              TRIAL                     │  │
+│  │  ┌─────────────────────────────────┐  │  │
+│  │  │           ASSESS                │  │  │
+│  │  │  ┌───────────────────────────┐  │  │  │
+│  │  │  │        HOLD               │  │  │  │
+│  │  │  └───────────────────────────┘  │  │  │
+│  │  └─────────────────────────────────┘  │  │
+│  └───────────────────────────────────────┘  │
+└─────────────────────────────────────────────┘
+
+ADOPT: Proven, ready for production use
+TRIAL: Worth pursuing, use in non-critical
+ASSESS: Worth exploring, needs evaluation
+HOLD: Proceed with caution, or avoid
+```
+
+### Quadrants (Categories)
+```
+┌──────────────────┬──────────────────┐
+│   TECHNIQUES     │   PLATFORMS      │
+│   - Practices    │   - Cloud        │
+│   - Methods      │   - Services     │
+│   - Patterns     │   - Infrastructure│
+├──────────────────┼──────────────────┤
+│   TOOLS          │   LANGUAGES      │
+│   - Libraries    │   - Programming  │
+│   - Frameworks   │   - Frameworks   │
+│   - Applications │   - Runtimes     │
+└──────────────────┴──────────────────┘
+```
+
+## Example Radar
+
+### Techniques
+```
+ADOPT:
+- Continuous Integration
+- Trunk-based Development
+- Infrastructure as Code
+- Containerization
+
+TRIAL:
+- Feature Flags
+- Contract Testing
+- Chaos Engineering
+- Event Storming
+
+ASSESS:
+- Platform Engineering
+- FinOps
+- Green Software Engineering
+
+HOLD:
+- Manual Deployments
+- Waterfall Planning
+```
+
+### Platforms
+```
+ADOPT:
+- AWS/Azure/GCP (multi-cloud strategy)
+- Kubernetes
+- Terraform
+- PostgreSQL
+
+TRIAL:
+- Serverless Containers
+- Managed Kafka
+- GraphQL Services
+
+ASSESS:
+- Edge Computing
+- WebAssembly Runtimes
+
+HOLD:
+- Data Centers (for most)
+- VM-only Deployments
+```
+
+### Tools
+```
+ADOPT:
+- Git
+- Docker
+- VS Code
+- Prometheus/Grafana
+
+TRIAL:
+- Terraform Cloud
+- Backstage
+- ArgoCD
+
+ASSESS:
+- AI Coding Assistants
+- New Relic One
+
+HOLD:
+- Jenkins (use modern alternatives)
+- SVN
+```
+
+### Languages & Frameworks
+```
+ADOPT:
+- TypeScript
+- Python
+- Go
+- React
+- Node.js
+
+TRIAL:
+- Rust (for performance-critical)
+- Deno
+- Svelte
+
+ASSESS:
+- Bun
+- Swift on Server
+
+HOLD:
+- CoffeeScript
+- jQuery (for new projects)
+```
+
+## Creating Your Radar
+
+### Step 1: Gather Input
+```
+Sources:
+- Team experience
+- Industry trends
+- Conference talks
+- Tech blogs
+- Consultant advice
+- Community feedback
+```
+
+### Step 2: Categorize
+```
+For each technology:
+1. Identify quadrant
+2. Determine ring
+3. Document rationale
+4. Add move date
+```
+
+### Step 3: Review Regularly
+```
+Cadence:
+- Quarterly reviews
+- Annual major updates
+- Ad-hoc for significant changes
+
+Process:
+1. Review existing placements
+2. Discuss new technologies
+3. Vote on ring changes
+4. Document decisions
+```
+
+## Movement Rules
+
+### Moving Outward (Adopt → Trial → Assess)
+```
+Technologies move outward when:
+- Proven in production
+- Team expertise grown
+- Community adoption increased
+- Risks mitigated
+```
+
+### Moving Inward (Assess → Trial → Adopt → Hold)
+```
+Technologies move inward when:
+- Security vulnerabilities found
+- Better alternatives emerge
+- Maintenance issues
+- Community decline
+```
+
+## Radar as Decision Tool
+
+### For New Projects
+```
+1. Check radar first
+2. Use ADOPT technologies for core
+3. Use TRIAL for experiments
+4. Avoid HOLD technologies
+```
+
+### For Technology Selection
+```
+If technology in ADOPT:
+→ Proceed with confidence
+
+If technology in TRIAL:
+→ Use in non-critical paths
+→ Have fallback plan
+
+If technology in ASSESS:
+→ POC required
+→ Document decision
+
+If technology in HOLD:
+→ Need strong justification
+→ Executive approval needed
+```
+
+## Radar Tools
+```
+- ThoughtWorks Tech Radar (open source viz)
+- radar.thoughtworks.com
+- Custom HTML/JS visualizations
+- Confluence/Notion tables
+- Miro/Figma diagrams
+```
+
+## Maintenance
+
+### Quarterly Review Agenda
+```
+1. Review technologies that moved
+   - What changed in the ecosystem?
+   - What did we learn?
+
+2. Discuss new candidates
+   - What's emerging?
+   - What's relevant to us?
+
+3. Vote on changes
+   - Consensus-based decisions
+   - Document rationale
+
+4. Update radar
+   - Publish changes
+   - Communicate to teams
+```
+
+### Metrics to Track
+```
+- Technologies per ring (balance)
+- Time in each ring (velocity)
+- Adoption success rate
+- Regret rate (moved to hold after adopt)
+```