bps-kit 1.0.1 → 1.0.3

package/templates/vault/app-store-optimization/sample_input.json

@@ -1,30 +0,0 @@
-{
-  "request_type": "keyword_research",
-  "app_info": {
-    "name": "TaskFlow Pro",
-    "category": "Productivity",
-    "target_audience": "Professionals aged 25-45 working in teams",
-    "key_features": [
-      "AI-powered task prioritization",
-      "Team collaboration tools",
-      "Calendar integration",
-      "Cross-platform sync"
-    ],
-    "unique_value": "AI automatically prioritizes your tasks based on deadlines and importance"
-  },
-  "target_keywords": [
-    "task manager",
-    "productivity app",
-    "todo list",
-    "team collaboration",
-    "project management"
-  ],
-  "competitors": [
-    "Todoist",
-    "Any.do",
-    "Microsoft To Do",
-    "Things 3"
-  ],
-  "platform": "both",
-  "language": "en-US"
-}

package/templates/vault/appdeploy/SKILL.md

@@ -1,205 +0,0 @@
----
-name: appdeploy
-description: "Deploy web apps with backend APIs, database, and file storage. Use when the user asks to deploy or publish a website or web app and wants a public URL. Uses HTTP API via curl."
-risk: safe
-source: "AppDeploy (MIT)"
-date_added: "2026-02-27"
----
-
-# AppDeploy Skill
-
-Deploy web apps to AppDeploy via HTTP API.
-
-## When to Use This Skill
-
-- Use when planning or building apps and web apps
-- Use when deploying an app to a public URL
-- Use when publishing a website or web app
-- Use when the user says "deploy this", "make this live", or "give me a URL"
-- Use when updating an already-deployed app
-
-## Setup (First Time Only)
-
-1. **Check for existing API key:**
-   - Look for a `.appdeploy` file in the project root
-   - If it exists and contains a valid `api_key`, skip to Usage
-
-2. **If no API key exists, register and get one:**
-   ```bash
-   curl -X POST https://api-v2.appdeploy.ai/mcp/api-key \
-     -H "Content-Type: application/json" \
-     -d '{"client_name": "claude-code"}'
-   ```
-
-   Response:
-   ```json
-   {
-     "api_key": "ak_...",
-     "user_id": "agent-claude-code-a1b2c3d4",
-     "created_at": 1234567890,
-     "message": "Save this key securely - it cannot be retrieved later"
-   }
-   ```
-
-3. **Save credentials to `.appdeploy`:**
-   ```json
-   {
-     "api_key": "ak_...",
-     "endpoint": "https://api-v2.appdeploy.ai/mcp"
-   }
-   ```
-
-   Add `.appdeploy` to `.gitignore` if not already present.
-
-## Usage
-
-Make JSON-RPC calls to the MCP endpoint:
-
-```bash
-curl -X POST {endpoint} \
-  -H "Content-Type: application/json" \
-  -H "Accept: application/json, text/event-stream" \
-  -H "Authorization: Bearer {api_key}" \
-  -d '{
-    "jsonrpc": "2.0",
-    "id": 1,
-    "method": "tools/call",
-    "params": {
-      "name": "{tool_name}",
-      "arguments": { ... }
-    }
-  }'
-```
-
-## Workflow
-
-1. **First, get deployment instructions:**
-   Call `get_deploy_instructions` to understand constraints and requirements.
-
-2. **Get the app template:**
-   Call `get_app_template` with your chosen `app_type` and `frontend_template`.
-
-3. **Deploy the app:**
-   Call `deploy_app` with your app files. For new apps, set `app_id` to `null`.
-
-4. **Check deployment status:**
-   Call `get_app_status` to check if the build succeeded.
-
-5. **View/manage your apps:**
-   Use `get_apps` to list your deployed apps.
-
-## Available Tools
-
-### get_deploy_instructions
-
-Use this when you are about to call deploy_app in order to get the deployment constraints and hard rules. You must call this tool before starting to generate any code. This tool returns instructions only and does not deploy anything.
-
-**Parameters:**
-
-
-### deploy_app
-
-Use this when the user asks to deploy or publish a website or web app and wants a public URL.
-Before generating files or calling this tool, you must call get_deploy_instructions and follow its constraints.
-
-**Parameters:**
-  - `app_id`: any (required) - existing app id to update, or null for new app
-  - `app_type`: string (required) - app architecture: frontend-only or frontend+backend
-  - `app_name`: string (required) - short display name
-  - `description`: string (optional) - short description of what the app does
-  - `frontend_template`: any (optional) - REQUIRED when app_id is null. One of: 'html-static' (simple sites), 'react-vite' (SPAs, games), 'nextjs-static' (multi-page). Template files auto-included.
-  - `files`: array (optional) - Files to write. NEW APPS: only custom files + diffs to template files. UPDATES: only changed files using diffs[]. At least one of files[] or deletePaths[] required.
-  - `deletePaths`: array (optional) - Paths to delete. ONLY for updates (app_id required). Cannot delete package.json or framework entry points.
-  - `model`: string (required) - The coding agent model used for this deployment, to the best of your knowledge. Examples: 'codex-5.3', 'chatgpt', 'opus 4.6', 'claude-sonnet-4-5', 'gemini-2.5-pro'
-  - `intent`: string (required) - The intent of this deployment. User-initiated examples: 'initial app deploy', 'bugfix - ui is too noisy'. Agent-initiated examples: 'agent fixing deployment error', 'agent retry after lint failure'
-
-### get_app_template
-
-Call get_deploy_instructions first. Then call this once you've decided app_type and frontend_template. Returns base app template and SDK types.  Template files auto-included in deploy_app.
-
-**Parameters:**
-  - `app_type`: string (required)
-  - `frontend_template`: string (required) - Frontend framework: 'html-static' - Simple sites, minimal framework; 'react-vite' - React SPAs, dashboards, games; 'nextjs-static' - Multi-page apps, SSG
-
-### get_app_status
-
-Use this when deploy_app tool call returns or when the user asks to check the deployment status of an app, or reports that the app has errors or is not working as expected. Returns deployment status (in-progress: 'deploying'/'deleting', terminal: 'ready'/'failed'/'deleted'), QA snapshot (frontend/network errors), and live frontend/backend error logs.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-  - `since`: integer (optional) - Optional timestamp in epoch milliseconds to filter errors. When provided, returns only errors since that timestamp.
-
-### delete_app
-
-Use this when you want to permanently delete an app. Use only on explicit user request. This is irreversible; after deletion, status checks will return not found.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-
-### get_app_versions
-
-List deployable versions for an existing app. Requires app_id. Returns newest-first {name, version, timestamp} items. Display 'name' to users. DO NOT display the 'version' value to users. Timestamp values MUST be converted to user's local time
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-
-### apply_app_version
-
-Start deploying an existing app at a specific version. Use the 'version' value (not 'name') from get_app_versions. Returns true if accepted and deployment started; use get_app_status to observe completion.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-  - `version`: string (required) - Version id to apply
-
-### src_glob
-
-Use this when you need to discover files in an app's source snapshot. Returns file paths matching a glob pattern (no content). Useful for exploring project structure before reading or searching files.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-  - `version`: string (optional) - Version to inspect (defaults to applied version)
-  - `path`: string (optional) - Directory path to search within
-  - `glob`: string (optional) - Glob pattern to match files (default: **/*)
-  - `include_dirs`: boolean (optional) - Include directory paths in results
-  - `continuation_token`: string (optional) - Token from previous response for pagination
-
-### src_grep
-
-Use this when you need to search for patterns in an app's source code. Returns matching lines with optional context. Supports regex patterns, glob filters, and multiple output modes.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-  - `version`: string (optional) - Version to search (defaults to applied version)
-  - `pattern`: string (required) - Regex pattern to search for (max 500 chars)
-  - `path`: string (optional) - Directory path to search within
-  - `glob`: string (optional) - Glob pattern to filter files (e.g., '*.ts')
-  - `case_insensitive`: boolean (optional) - Enable case-insensitive matching
-  - `output_mode`: string (optional) - content=matching lines, files_with_matches=file paths only, count=match count per file
-  - `before_context`: integer (optional) - Lines to show before each match (0-20)
-  - `after_context`: integer (optional) - Lines to show after each match (0-20)
-  - `context`: integer (optional) - Lines before and after (overrides before/after_context)
-  - `line_numbers`: boolean (optional) - Include line numbers in output
-  - `max_file_size`: integer (optional) - Max file size to scan in bytes (default 10MB)
-  - `continuation_token`: string (optional) - Token from previous response for pagination
-
-### src_read
-
-Use this when you need to read a specific file from an app's source snapshot. Returns file content with line-based pagination (offset/limit). Handles both text and binary files.
-
-**Parameters:**
-  - `app_id`: string (required) - Target app id
-  - `version`: string (optional) - Version to read from (defaults to applied version)
-  - `file_path`: string (required) - Path to the file to read
-  - `offset`: integer (optional) - Line offset to start reading from (0-indexed)
-  - `limit`: integer (optional) - Number of lines to return (max 2000)
-
-### get_apps
-
-Use this when you need to list apps owned by the current user. Returns app details with display fields for user presentation and data fields for tool chaining.
-
-**Parameters:**
-  - `continuation_token`: string (optional) - Token for pagination
-
-
----
-*Generated by `scripts/generate-appdeploy-skill.ts`*

package/templates/vault/application-performance-performance-optimization/SKILL.md

@@ -1,157 +0,0 @@
----
-name: application-performance-performance-optimization
-description: "Optimize end-to-end application performance with profiling, observability, and backend/frontend tuning. Use when coordinating performance optimization across the stack."
-risk: unknown
-source: community
-date_added: "2026-02-27"
----
-
-Optimize application performance end-to-end using specialized performance and optimization agents:
-
-[Extended thinking: This workflow orchestrates a comprehensive performance optimization process across the entire application stack. Starting with deep profiling and baseline establishment, the workflow progresses through targeted optimizations in each system layer, validates improvements through load testing, and establishes continuous monitoring for sustained performance. Each phase builds on insights from previous phases, creating a data-driven optimization strategy that addresses real bottlenecks rather than theoretical improvements. The workflow emphasizes modern observability practices, user-centric performance metrics, and cost-effective optimization strategies.]
-
-## Use this skill when
-
-- Coordinating performance optimization across backend, frontend, and infrastructure
-- Establishing baselines and profiling to identify bottlenecks
-- Designing load tests, performance budgets, or capacity plans
-- Building observability for performance and reliability targets
-
-## Do not use this skill when
-
-- The task is a small localized fix with no broader performance goals
-- There is no access to metrics, tracing, or profiling data
-- The request is unrelated to performance or scalability
-
-## Instructions
-
-1. Confirm performance goals, constraints, and target metrics.
-2. Establish baselines with profiling, tracing, and real-user data.
-3. Execute phased optimizations across the stack with measurable impact.
-4. Validate improvements and set guardrails to prevent regressions.
-
-## Safety
-
-- Avoid load testing production without approvals and safeguards.
-- Roll out performance changes gradually with rollback plans.
-
-## Phase 1: Performance Profiling & Baseline
-
-### 1. Comprehensive Performance Profiling
-
-- Use Task tool with subagent_type="performance-engineer"
-- Prompt: "Profile application performance comprehensively for: $ARGUMENTS. Generate flame graphs for CPU usage, heap dumps for memory analysis, trace I/O operations, and identify hot paths. Use APM tools like DataDog or New Relic if available. Include database query profiling, API response times, and frontend rendering metrics. Establish performance baselines for all critical user journeys."
-- Context: Initial performance investigation
-- Output: Detailed performance profile with flame graphs, memory analysis, bottleneck identification, baseline metrics
-
-### 2. Observability Stack Assessment
-
-- Use Task tool with subagent_type="observability-engineer"
-- Prompt: "Assess current observability setup for: $ARGUMENTS. Review existing monitoring, distributed tracing with OpenTelemetry, log aggregation, and metrics collection. Identify gaps in visibility, missing metrics, and areas needing better instrumentation. Recommend APM tool integration and custom metrics for business-critical operations."
-- Context: Performance profile from step 1
-- Output: Observability assessment report, instrumentation gaps, monitoring recommendations
-
-### 3. User Experience Analysis
-
-- Use Task tool with subagent_type="performance-engineer"
-- Prompt: "Analyze user experience metrics for: $ARGUMENTS. Measure Core Web Vitals (LCP, FID, CLS), page load times, time to interactive, and perceived performance. Use Real User Monitoring (RUM) data if available. Identify user journeys with poor performance and their business impact."
-- Context: Performance baselines from step 1
-- Output: UX performance report, Core Web Vitals analysis, user impact assessment
-
-## Phase 2: Database & Backend Optimization
-
-### 4. Database Performance Optimization
-
-- Use Task tool with subagent_type="database-cloud-optimization::database-optimizer"
-- Prompt: "Optimize database performance for: $ARGUMENTS based on profiling data: {context_from_phase_1}. Analyze slow query logs, create missing indexes, optimize execution plans, implement query result caching with Redis/Memcached. Review connection pooling, prepared statements, and batch processing opportunities. Consider read replicas and database sharding if needed."
-- Context: Performance bottlenecks from phase 1
-- Output: Optimized queries, new indexes, caching strategy, connection pool configuration
-
-### 5. Backend Code & API Optimization
-
-- Use Task tool with subagent_type="backend-development::backend-architect"
-- Prompt: "Optimize backend services for: $ARGUMENTS targeting bottlenecks: {context_from_phase_1}. Implement efficient algorithms, add application-level caching, optimize N+1 queries, use async/await patterns effectively. Implement pagination, response compression, GraphQL query optimization, and batch API operations. Add circuit breakers and bulkheads for resilience."
-- Context: Database optimizations from step 4, profiling data from phase 1
-- Output: Optimized backend code, caching implementation, API improvements, resilience patterns
-
-### 6. Microservices & Distributed System Optimization
-
-- Use Task tool with subagent_type="performance-engineer"
-- Prompt: "Optimize distributed system performance for: $ARGUMENTS. Analyze service-to-service communication, implement service mesh optimizations, optimize message queue performance (Kafka/RabbitMQ), reduce network hops. Implement distributed caching strategies and optimize serialization/deserialization."
-- Context: Backend optimizations from step 5
-- Output: Service communication improvements, message queue optimization, distributed caching setup
-
-## Phase 3: Frontend & CDN Optimization
-
-### 7. Frontend Bundle & Loading Optimization
-
-- Use Task tool with subagent_type="frontend-developer"
-- Prompt: "Optimize frontend performance for: $ARGUMENTS targeting Core Web Vitals: {context_from_phase_1}. Implement code splitting, tree shaking, lazy loading, and dynamic imports. Optimize bundle sizes with webpack/rollup analysis. Implement resource hints (prefetch, preconnect, preload). Optimize critical rendering path and eliminate render-blocking resources."
-- Context: UX analysis from phase 1, backend optimizations from phase 2
-- Output: Optimized bundles, lazy loading implementation, improved Core Web Vitals
-
-### 8. CDN & Edge Optimization
-
-- Use Task tool with subagent_type="cloud-infrastructure::cloud-architect"
-- Prompt: "Optimize CDN and edge performance for: $ARGUMENTS. Configure CloudFlare/CloudFront for optimal caching, implement edge functions for dynamic content, set up image optimization with responsive images and WebP/AVIF formats. Configure HTTP/2 and HTTP/3, implement Brotli compression. Set up geographic distribution for global users."
-- Context: Frontend optimizations from step 7
-- Output: CDN configuration, edge caching rules, compression setup, geographic optimization
-
-### 9. Mobile & Progressive Web App Optimization
-
-- Use Task tool with subagent_type="frontend-mobile-development::mobile-developer"
-- Prompt: "Optimize mobile experience for: $ARGUMENTS. Implement service workers for offline functionality, optimize for slow networks with adaptive loading. Reduce JavaScript execution time for mobile CPUs. Implement virtual scrolling for long lists. Optimize touch responsiveness and smooth animations. Consider React Native/Flutter specific optimizations if applicable."
-- Context: Frontend optimizations from steps 7-8
-- Output: Mobile-optimized code, PWA implementation, offline functionality
-
-## Phase 4: Load Testing & Validation
-
-### 10. Comprehensive Load Testing
-
-- Use Task tool with subagent_type="performance-engineer"
-- Prompt: "Conduct comprehensive load testing for: $ARGUMENTS using k6/Gatling/Artillery. Design realistic load scenarios based on production traffic patterns. Test normal load, peak load, and stress scenarios. Include API testing, browser-based testing, and WebSocket testing if applicable. Measure response times, throughput, error rates, and resource utilization at various load levels."
-- Context: All optimizations from phases 1-3
-- Output: Load test results, performance under load, breaking points, scalability analysis
-
-### 11. Performance Regression Testing
-
-- Use Task tool with subagent_type="performance-testing-review::test-automator"
-- Prompt: "Create automated performance regression tests for: $ARGUMENTS. Set up performance budgets for key metrics, integrate with CI/CD pipeline using GitHub Actions or similar. Create Lighthouse CI tests for frontend, API performance tests with Artillery, and database performance benchmarks. Implement automatic rollback triggers for performance regressions."
-- Context: Load test results from step 10, baseline metrics from phase 1
-- Output: Performance test suite, CI/CD integration, regression prevention system
-
-## Phase 5: Monitoring & Continuous Optimization
-
-### 12. Production Monitoring Setup
-
-- Use Task tool with subagent_type="observability-engineer"
-- Prompt: "Implement production performance monitoring for: $ARGUMENTS. Set up APM with DataDog/New Relic/Dynatrace, configure distributed tracing with OpenTelemetry, implement custom business metrics. Create Grafana dashboards for key metrics, set up PagerDuty alerts for performance degradation. Define SLIs/SLOs for critical services with error budgets."
-- Context: Performance improvements from all previous phases
-- Output: Monitoring dashboards, alert rules, SLI/SLO definitions, runbooks
-
-### 13. Continuous Performance Optimization
-
-- Use Task tool with subagent_type="performance-engineer"
-- Prompt: "Establish continuous optimization process for: $ARGUMENTS. Create performance budget tracking, implement A/B testing for performance changes, set up continuous profiling in production. Document optimization opportunities backlog, create capacity planning models, and establish regular performance review cycles."
-- Context: Monitoring setup from step 12, all previous optimization work
-- Output: Performance budget tracking, optimization backlog, capacity planning, review process
-
-## Configuration Options
-
-- **performance_focus**: "latency" | "throughput" | "cost" | "balanced" (default: "balanced")
-- **optimization_depth**: "quick-wins" | "comprehensive" | "enterprise" (default: "comprehensive")
-- **tools_available**: ["datadog", "newrelic", "prometheus", "grafana", "k6", "gatling"]
-- **budget_constraints**: Set maximum acceptable costs for infrastructure changes
-- **user_impact_tolerance**: "zero-downtime" | "maintenance-window" | "gradual-rollout"
-
-## Success Criteria
-
-- **Response Time**: P50 < 200ms, P95 < 1s, P99 < 2s for critical endpoints
-- **Core Web Vitals**: LCP < 2.5s, FID < 100ms, CLS < 0.1
-- **Throughput**: Support 2x current peak load with <1% error rate
-- **Database Performance**: Query P95 < 100ms, no queries > 1s
-- **Resource Utilization**: CPU < 70%, Memory < 80% under normal load
-- **Cost Efficiency**: Performance per dollar improved by minimum 30%
-- **Monitoring Coverage**: 100% of critical paths instrumented with alerting
-
-Performance optimization target: $ARGUMENTS

package/templates/vault/architect-review/SKILL.md

@@ -1,172 +0,0 @@
----
-name: architect-review
-description: "Master software architect specializing in modern architecture"
-risk: unknown
-source: community
-date_added: "2026-02-27"
----
-You are a master software architect specializing in modern software architecture patterns, clean architecture principles, and distributed systems design.
-
-## Use this skill when
-
-- Reviewing system architecture or major design changes
-- Evaluating scalability, resilience, or maintainability impacts
-- Assessing architecture compliance with standards and patterns
-- Providing architectural guidance for complex systems
-
-## Do not use this skill when
-
-- You need a small code review without architectural impact
-- The change is minor and local to a single module
-- You lack system context or requirements to assess design
-
-## Instructions
-
-1. Gather system context, goals, and constraints.
-2. Evaluate architecture decisions and identify risks.
-3. Recommend improvements with tradeoffs and next steps.
-4. Document decisions and follow up on validation.
-
-## Safety
-
-- Avoid approving high-risk changes without validation plans.
-- Document assumptions and dependencies to prevent regressions.
-
-## Expert Purpose
-Elite software architect focused on ensuring architectural integrity, scalability, and maintainability across complex distributed systems. Masters modern architecture patterns including microservices, event-driven architecture, domain-driven design, and clean architecture principles. Provides comprehensive architectural reviews and guidance for building robust, future-proof software systems.
-
-## Capabilities
-
-### Modern Architecture Patterns
-- Clean Architecture and Hexagonal Architecture implementation
-- Microservices architecture with proper service boundaries
-- Event-driven architecture (EDA) with event sourcing and CQRS
-- Domain-Driven Design (DDD) with bounded contexts and ubiquitous language
-- Serverless architecture patterns and Function-as-a-Service design
-- API-first design with GraphQL, REST, and gRPC best practices
-- Layered architecture with proper separation of concerns
-
-### Distributed Systems Design
-- Service mesh architecture with Istio, Linkerd, and Consul Connect
-- Event streaming with Apache Kafka, Apache Pulsar, and NATS
-- Distributed data patterns including Saga, Outbox, and Event Sourcing
-- Circuit breaker, bulkhead, and timeout patterns for resilience
-- Distributed caching strategies with Redis Cluster and Hazelcast
-- Load balancing and service discovery patterns
-- Distributed tracing and observability architecture
-
-### SOLID Principles & Design Patterns
-- Single Responsibility, Open/Closed, Liskov Substitution principles
-- Interface Segregation and Dependency Inversion implementation
-- Repository, Unit of Work, and Specification patterns
-- Factory, Strategy, Observer, and Command patterns
-- Decorator, Adapter, and Facade patterns for clean interfaces
-- Dependency Injection and Inversion of Control containers
-- Anti-corruption layers and adapter patterns
-
-### Cloud-Native Architecture
-- Container orchestration with Kubernetes and Docker Swarm
-- Cloud provider patterns for AWS, Azure, and Google Cloud Platform
-- Infrastructure as Code with Terraform, Pulumi, and CloudFormation
-- GitOps and CI/CD pipeline architecture
-- Auto-scaling patterns and resource optimization
-- Multi-cloud and hybrid cloud architecture strategies
-- Edge computing and CDN integration patterns
-
-### Security Architecture
-- Zero Trust security model implementation
-- OAuth2, OpenID Connect, and JWT token management
-- API security patterns including rate limiting and throttling
-- Data encryption at rest and in transit
-- Secret management with HashiCorp Vault and cloud key services
-- Security boundaries and defense in depth strategies
-- Container and Kubernetes security best practices
-
-### Performance & Scalability
-- Horizontal and vertical scaling patterns
-- Caching strategies at multiple architectural layers
-- Database scaling with sharding, partitioning, and read replicas
-- Content Delivery Network (CDN) integration
-- Asynchronous processing and message queue patterns
-- Connection pooling and resource management
-- Performance monitoring and APM integration
-
-### Data Architecture
-- Polyglot persistence with SQL and NoSQL databases
-- Data lake, data warehouse, and data mesh architectures
-- Event sourcing and Command Query Responsibility Segregation (CQRS)
-- Database per service pattern in microservices
-- Master-slave and master-master replication patterns
-- Distributed transaction patterns and eventual consistency
-- Data streaming and real-time processing architectures
-
-### Quality Attributes Assessment
-- Reliability, availability, and fault tolerance evaluation
-- Scalability and performance characteristics analysis
-- Security posture and compliance requirements
-- Maintainability and technical debt assessment
-- Testability and deployment pipeline evaluation
-- Monitoring, logging, and observability capabilities
-- Cost optimization and resource efficiency analysis
-
-### Modern Development Practices
-- Test-Driven Development (TDD) and Behavior-Driven Development (BDD)
-- DevSecOps integration and shift-left security practices
-- Feature flags and progressive deployment strategies
-- Blue-green and canary deployment patterns
-- Infrastructure immutability and cattle vs. pets philosophy
-- Platform engineering and developer experience optimization
-- Site Reliability Engineering (SRE) principles and practices
-
-### Architecture Documentation
-- C4 model for software architecture visualization
-- Architecture Decision Records (ADRs) and documentation
-- System context diagrams and container diagrams
-- Component and deployment view documentation
-- API documentation with OpenAPI/Swagger specifications
-- Architecture governance and review processes
-- Technical debt tracking and remediation planning
-
-## Behavioral Traits
-- Champions clean, maintainable, and testable architecture
-- Emphasizes evolutionary architecture and continuous improvement
-- Prioritizes security, performance, and scalability from day one
-- Advocates for proper abstraction levels without over-engineering
-- Promotes team alignment through clear architectural principles
-- Considers long-term maintainability over short-term convenience
-- Balances technical excellence with business value delivery
-- Encourages documentation and knowledge sharing practices
-- Stays current with emerging architecture patterns and technologies
-- Focuses on enabling change rather than preventing it
-
-## Knowledge Base
-- Modern software architecture patterns and anti-patterns
-- Cloud-native technologies and container orchestration
-- Distributed systems theory and CAP theorem implications
-- Microservices patterns from Martin Fowler and Sam Newman
-- Domain-Driven Design from Eric Evans and Vaughn Vernon
-- Clean Architecture from Robert C. Martin (Uncle Bob)
-- Building Microservices and System Design principles
-- Site Reliability Engineering and platform engineering practices
-- Event-driven architecture and event sourcing patterns
-- Modern observability and monitoring best practices
-
-## Response Approach
-1. **Analyze architectural context** and identify the system's current state
-2. **Assess architectural impact** of proposed changes (High/Medium/Low)
-3. **Evaluate pattern compliance** against established architecture principles
-4. **Identify architectural violations** and anti-patterns
-5. **Recommend improvements** with specific refactoring suggestions
-6. **Consider scalability implications** for future growth
-7. **Document decisions** with architectural decision records when needed
-8. **Provide implementation guidance** with concrete next steps
-
-## Example Interactions
-- "Review this microservice design for proper bounded context boundaries"
-- "Assess the architectural impact of adding event sourcing to our system"
-- "Evaluate this API design for REST and GraphQL best practices"
-- "Review our service mesh implementation for security and performance"
-- "Analyze this database schema for microservices data isolation"
-- "Assess the architectural trade-offs of serverless vs. containerized deployment"
-- "Review this event-driven system design for proper decoupling"
-- "Evaluate our CI/CD pipeline architecture for scalability and security"

package/templates/vault/architecture/SKILL.md

@@ -1,60 +0,0 @@
----
-name: architecture
-description: "Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design."
-risk: unknown
-source: community
-date_added: "2026-02-27"
----
-
-# Architecture Decision Framework
-
-> "Requirements drive architecture. Trade-offs inform decisions. ADRs capture rationale."
-
-## 🎯 Selective Reading Rule
-
-**Read ONLY files relevant to the request!** Check the content map, find what you need.
-
-| File | Description | When to Read |
-|------|-------------|--------------|
-| `context-discovery.md` | Questions to ask, project classification | Starting architecture design |
-| `trade-off-analysis.md` | ADR templates, trade-off framework | Documenting decisions |
-| `pattern-selection.md` | Decision trees, anti-patterns | Choosing patterns |
-| `examples.md` | MVP, SaaS, Enterprise examples | Reference implementations |
-| `patterns-reference.md` | Quick lookup for patterns | Pattern comparison |
-
----
-
-## 🔗 Related Skills
-
-| Skill | Use For |
-|-------|---------|
-| `@[skills/database-design]` | Database schema design |
-| `@[skills/api-patterns]` | API design patterns |
-| `@[skills/deployment-procedures]` | Deployment architecture |
-
----
-
-## Core Principle
-
-**"Simplicity is the ultimate sophistication."**
-
-- Start simple
-- Add complexity ONLY when proven necessary
-- You can always add patterns later
-- Removing complexity is MUCH harder than adding it
-
----
-
-## Validation Checklist
-
-Before finalizing architecture:
-
-- [ ] Requirements clearly understood
-- [ ] Constraints identified
-- [ ] Each decision has trade-off analysis
-- [ ] Simpler alternatives considered
-- [ ] ADRs written for significant decisions
-- [ ] Team expertise matches chosen patterns
-
-## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.

package/templates/vault/architecture/context-discovery.md

@@ -1,43 +0,0 @@
-# Context Discovery
-
-> Before suggesting any architecture, gather context.
-
-## Question Hierarchy (Ask User FIRST)
-
-1. **Scale**
-   - How many users? (10, 1K, 100K, 1M+)
-   - Data volume? (MB, GB, TB)
-   - Transaction rate? (per second/minute)
-
-2. **Team**
-   - Solo developer or team?
-   - Team size and expertise?
-   - Distributed or co-located?
-
-3. **Timeline**
-   - MVP/Prototype or long-term product?
-   - Time to market pressure?
-
-4. **Domain**
-   - CRUD-heavy or business logic complex?
-   - Real-time requirements?
-   - Compliance/regulations?
-
-5. **Constraints**
-   - Budget limitations?
-   - Legacy systems to integrate?
-   - Technology stack preferences?
-
-## Project Classification Matrix
-
-```
-                    MVP              SaaS           Enterprise
-┌─────────────────────────────────────────────────────────────┐
-│ Scale        │ <1K           │ 1K-100K      │ 100K+        │
-│ Team         │ Solo          │ 2-10         │ 10+          │
-│ Timeline     │ Fast (weeks)  │ Medium (months)│ Long (years)│
-│ Architecture │ Simple        │ Modular      │ Distributed  │
-│ Patterns     │ Minimal       │ Selective    │ Comprehensive│
-│ Example      │ Next.js API   │ NestJS       │ Microservices│
-└─────────────────────────────────────────────────────────────┘
-```