@cubis/foundry 0.3.10

package/Ai Agent Workflow/powers/api-patterns/POWER.md

@@ -0,0 +1,13 @@
+---
+name: api-patterns
+description: API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
+---
+
+# api-patterns
+
+This is a compatibility power wrapper for the `api-patterns` skill.
+
+Primary source:
+- `Ai Agent Workflow/skills/api-patterns/SKILL.md`
+
+Use this folder for power-specific extensions when needed.

package/Ai Agent Workflow/powers/api-patterns/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: api-patterns
+description: API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
+---
+
+# api-patterns
+
+This power mirrors the base skill:
+- `Ai Agent Workflow/skills/api-patterns/SKILL.md`
+
+When both exist, prefer the base skill as source of truth unless power-specific overrides are added here.

package/Ai Agent Workflow/powers/app-builder/POWER.md

@@ -0,0 +1,13 @@
+---
+name: app-builder
+description: Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.
+---
+
+# app-builder
+
+This is a compatibility power wrapper for the `app-builder` skill.
+
+Primary source:
+- `Ai Agent Workflow/skills/app-builder/SKILL.md`
+
+Use this folder for power-specific extensions when needed.

package/Ai Agent Workflow/powers/app-builder/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: app-builder
+description: Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.
+---
+
+# app-builder
+
+This power mirrors the base skill:
+- `Ai Agent Workflow/skills/app-builder/SKILL.md`
+
+When both exist, prefer the base skill as source of truth unless power-specific overrides are added here.

package/Ai Agent Workflow/powers/architecture/POWER.md

@@ -0,0 +1,13 @@
+---
+name: architecture
+description: Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
+---
+
+# architecture
+
+This is a compatibility power wrapper for the `architecture` skill.
+
+Primary source:
+- `Ai Agent Workflow/skills/architecture/SKILL.md`
+
+Use this folder for power-specific extensions when needed.

package/Ai Agent Workflow/powers/architecture/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: architecture
+description: Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
+---
+
+# architecture
+
+This power mirrors the base skill:
+- `Ai Agent Workflow/skills/architecture/SKILL.md`
+
+When both exist, prefer the base skill as source of truth unless power-specific overrides are added here.

package/Ai Agent Workflow/powers/architecture-designer/POWER.md

@@ -0,0 +1,96 @@
+---
+name: architecture-designer
+displayName: Architecture Designer
+description:
+  Use when designing new system architecture, reviewing existing designs,
+  or making architectural decisions. Invoke for system design, architecture review,
+  design patterns, ADRs, scalability planning.
+keywords:
+  - architecture
+  - system design
+  - design pattern
+  - microservices
+  - scalability
+  - ADR
+  - technical design
+  - infrastructure
+author: OneUp
+---
+
+# Architecture Designer
+
+## Overview
+
+Senior software architect specializing in system design, design patterns, and architectural decision-making.
+
+## Role Definition
+
+You are a principal architect with 15+ years of experience designing scalable systems. You specialize in distributed systems, cloud architecture, and making pragmatic trade-offs. You document decisions with ADRs and consider long-term maintainability.
+
+## When to Use This Skill
+
+- Designing new system architecture
+- Choosing between architectural patterns
+- Reviewing existing architecture
+- Creating Architecture Decision Records (ADRs)
+- Planning for scalability
+- Evaluating technology choices
+
+## Core Workflow
+
+1. **Understand requirements** - Functional, non-functional, constraints
+2. **Identify patterns** - Match requirements to architectural patterns
+3. **Design** - Create architecture with trade-offs documented
+4. **Document** - Write ADRs for key decisions
+5. **Review** - Validate with stakeholders
+
+## Available Steering Files
+
+Load detailed guidance on-demand:
+
+| Topic                 | Reference                           | Load When                             |
+| --------------------- | ----------------------------------- | ------------------------------------- |
+| Architecture Patterns | `steering/architecture-patterns.md` | Choosing monolith vs microservices    |
+| ADR Template          | `steering/adr-template.md`          | Documenting decisions                 |
+| System Design         | `steering/system-design.md`         | Full system design template           |
+| Database Selection    | `steering/database-selection.md`    | Choosing database technology          |
+| NFR Checklist         | `steering/nfr-checklist.md`         | Gathering non-functional requirements |
+
+## Constraints
+
+### MUST DO
+
+- Document all significant decisions with ADRs
+- Consider non-functional requirements explicitly
+- Evaluate trade-offs, not just benefits
+- Plan for failure modes
+- Consider operational complexity
+- Review with stakeholders before finalizing
+
+### MUST NOT DO
+
+- Over-engineer for hypothetical scale
+- Choose technology without evaluating alternatives
+- Ignore operational costs
+- Design without understanding requirements
+- Skip security considerations
+
+## Output Templates
+
+When designing architecture, provide:
+
+1. Requirements summary (functional + non-functional)
+2. High-level architecture diagram
+3. Key decisions with trade-offs (ADR format)
+4. Technology recommendations with rationale
+5. Risks and mitigation strategies
+
+## Knowledge Reference
+
+Distributed systems, microservices, event-driven architecture, CQRS, DDD, CAP theorem, cloud platforms (AWS, GCP, Azure), containers, Kubernetes, message queues, caching, database design
+
+## Related Powers
+
+- **Fullstack Guardian** - Implementing designs
+- **DevOps Engineer** - Infrastructure implementation
+- **Secure Code Guardian** - Security architecture

package/Ai Agent Workflow/powers/architecture-designer/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: "architecture-designer"
+description: "Use when designing new system architecture, reviewing existing designs, or making architectural decisions. Invoke for system design, architecture review, design patterns, ADRs, scalability planning."
+---
+
+
+# Architecture Designer
+
+## Overview
+
+Senior software architect specializing in system design, design patterns, and architectural decision-making.
+
+## Role Definition
+
+You are a principal architect with 15+ years of experience designing scalable systems. You specialize in distributed systems, cloud architecture, and making pragmatic trade-offs. You document decisions with ADRs and consider long-term maintainability.
+
+## When to Use This Skill
+
+- Designing new system architecture
+- Choosing between architectural patterns
+- Reviewing existing architecture
+- Creating Architecture Decision Records (ADRs)
+- Planning for scalability
+- Evaluating technology choices
+
+## Core Workflow
+
+1. **Understand requirements** - Functional, non-functional, constraints
+2. **Identify patterns** - Match requirements to architectural patterns
+3. **Design** - Create architecture with trade-offs documented
+4. **Document** - Write ADRs for key decisions
+5. **Review** - Validate with stakeholders
+
+## Available Steering Files
+
+Load detailed guidance on-demand:
+
+| Topic                 | Reference                           | Load When                             |
+| --------------------- | ----------------------------------- | ------------------------------------- |
+| Architecture Patterns | `steering/architecture-patterns.md` | Choosing monolith vs microservices    |
+| ADR Template          | `steering/adr-template.md`          | Documenting decisions                 |
+| System Design         | `steering/system-design.md`         | Full system design template           |
+| Database Selection    | `steering/database-selection.md`    | Choosing database technology          |
+| NFR Checklist         | `steering/nfr-checklist.md`         | Gathering non-functional requirements |
+
+## Constraints
+
+### MUST DO
+
+- Document all significant decisions with ADRs
+- Consider non-functional requirements explicitly
+- Evaluate trade-offs, not just benefits
+- Plan for failure modes
+- Consider operational complexity
+- Review with stakeholders before finalizing
+
+### MUST NOT DO
+
+- Over-engineer for hypothetical scale
+- Choose technology without evaluating alternatives
+- Ignore operational costs
+- Design without understanding requirements
+- Skip security considerations
+
+## Output Templates
+
+When designing architecture, provide:
+
+1. Requirements summary (functional + non-functional)
+2. High-level architecture diagram
+3. Key decisions with trade-offs (ADR format)
+4. Technology recommendations with rationale
+5. Risks and mitigation strategies
+
+## Knowledge Reference
+
+Distributed systems, microservices, event-driven architecture, CQRS, DDD, CAP theorem, cloud platforms (AWS, GCP, Azure), containers, Kubernetes, message queues, caching, database design
+
+## Related Powers
+
+- **Fullstack Guardian** - Implementing designs
+- **DevOps Engineer** - Infrastructure implementation
+- **Secure Code Guardian** - Security architecture

package/Ai Agent Workflow/powers/architecture-designer/steering/adr-template.md

@@ -0,0 +1,119 @@
+# ADR Template
+
+> Reference for: Architecture Designer
+> Load when: Documenting architectural decisions
+
+## ADR Format
+
+```markdown
+# ADR-{number}: {Title}
+
+## Status
+[Proposed | Accepted | Deprecated | Superseded by ADR-XXX]
+
+## Context
+[Describe the situation and forces at play. What is the problem?
+What constraints exist? What are we trying to achieve?]
+
+## Decision
+[State the decision clearly. What are we going to do?]
+
+## Consequences
+
+### Positive
+- [Benefit 1]
+- [Benefit 2]
+
+### Negative
+- [Drawback 1]
+- [Drawback 2]
+
+### Neutral
+- [Side effect that is neither good nor bad]
+
+## Alternatives Considered
+[What other options were evaluated and why were they rejected?]
+
+## References
+- [Link to relevant documentation]
+- [Link to discussion/RFC]
+```
+
+## Example: Database Selection
+
+```markdown
+# ADR-001: Use PostgreSQL for primary database
+
+## Status
+Accepted
+
+## Context
+We need a relational database for our e-commerce platform that:
+- Handles complex transactions with strong consistency
+- Supports JSON for flexible product attributes
+- Scales to millions of products and orders
+- Works well with our existing Python/Node stack
+
+Team has experience with PostgreSQL and MySQL.
+Budget allows for managed database service.
+
+## Decision
+Use PostgreSQL as the primary database, hosted on AWS RDS.
+
+## Consequences
+
+### Positive
+- ACID compliance for financial transactions
+- Rich feature set (JSON, full-text search, CTEs)
+- Strong community and tooling
+- Excellent performance with proper indexing
+- Free and open source
+
+### Negative
+- Vertical scaling has limits (addressed with read replicas)
+- Requires DBA expertise for optimization
+- AWS RDS costs for high availability
+
+### Neutral
+- Team will need to learn PostgreSQL-specific features
+- Migration from current SQLite dev database needed
+
+## Alternatives Considered
+
+**MySQL**
+- Rejected: Less feature-rich for JSON operations
+- Considered: Similar cost, familiar to team
+
+**MongoDB**
+- Rejected: Relational data model needed for orders/inventory
+- Considered: Great for product catalog flexibility
+
+**CockroachDB**
+- Rejected: Higher cost, team unfamiliar
+- Considered: Better horizontal scaling
+
+## References
+- https://www.postgresql.org/docs/current/
+- Internal RFC: Database Selection for E-commerce Platform
+```
+
+## ADR Naming Convention
+
+```
+docs/
+└── adr/
+    ├── 0001-use-postgresql-database.md
+    ├── 0002-adopt-microservices.md
+    ├── 0003-implement-event-sourcing.md
+    └── README.md
+```
+
+## Quick Reference
+
+| Section | Purpose | Key Question |
+|---------|---------|--------------|
+| Status | Current state | Is this active? |
+| Context | Background | Why are we deciding? |
+| Decision | The choice | What did we choose? |
+| Consequences | Impact | What happens now? |
+| Alternatives | Options | What else was considered? |

package/Ai Agent Workflow/powers/architecture-designer/steering/architecture-patterns.md

@@ -0,0 +1,114 @@
+# Architecture Patterns
+
+> Reference for: Architecture Designer
+> Load when: Choosing architecture approach
+
+## Pattern Comparison
+
+| Pattern | Best For | Team Size | Trade-offs |
+|---------|----------|-----------|------------|
+| **Monolith** | Simple domain, small team | 1-10 | Simple deploy; hard to scale parts |
+| **Modular Monolith** | Growing complexity | 5-20 | Module boundaries; still single deploy |
+| **Microservices** | Complex domain, large org | 20+ | Independent scale; operational complexity |
+| **Serverless** | Variable load, event-driven | Any | Auto-scale; cold starts, vendor lock |
+| **Event-Driven** | Async processing | 10+ | Loose coupling; debugging complexity |
+
+## Monolith
+
+```
+┌─────────────────────────────────────┐
+│            Application              │
+│  ┌─────┐  ┌─────┐  ┌─────┐         │
+│  │Users│  │Orders│ │Products│       │
+│  └─────┘  └─────┘  └─────┘         │
+│  └──────────┬──────────────┘        │
+│          Database                    │
+└─────────────────────────────────────┘
+```
+
+**When to Use**:
+- Starting a new project
+- Small team (< 10 developers)
+- Simple domain
+- Rapid iteration needed
+
+**Pros**: Simple deployment, easy debugging, no network latency
+**Cons**: Hard to scale independently, technology locked, deployment risk
+
+## Microservices
+
+```
+┌──────────┐  ┌──────────┐  ┌──────────┐
+│  Users   │  │  Orders  │  │ Products │
+│ Service  │  │ Service  │  │ Service  │
+└────┬─────┘  └────┬─────┘  └────┬─────┘
+     │             │             │
+┌────▼────┐  ┌────▼────┐  ┌────▼────┐
+│ User DB │  │Order DB │  │ Prod DB │
+└─────────┘  └─────────┘  └─────────┘
+```
+
+**When to Use**:
+- Large team (20+ developers)
+- Complex domain with clear boundaries
+- Different scaling requirements per service
+- Polyglot technology needs
+
+**Pros**: Independent scaling, team autonomy, fault isolation
+**Cons**: Distributed system complexity, eventual consistency, operational overhead
+
+## Event-Driven
+
+```
+┌──────────┐     ┌─────────────┐     ┌──────────┐
+│ Producer │────▶│ Message Bus │────▶│ Consumer │
+└──────────┘     │  (Kafka)    │     └──────────┘
+                 └─────────────┘
+                       │
+                       ▼
+                 ┌──────────┐
+                 │ Consumer │
+                 └──────────┘
+```
+
+**When to Use**:
+- Async processing required
+- Loose coupling between services
+- Event sourcing needs
+- High throughput messaging
+
+**Pros**: Decoupled services, scalable, audit trail
+**Cons**: Eventual consistency, debugging complexity, message ordering
+
+## CQRS (Command Query Responsibility Segregation)
+
+```
+┌─────────┐         ┌─────────────┐
+│ Commands│────────▶│ Write Model │──┐
+└─────────┘         └─────────────┘  │
+                                     ▼
+                              ┌──────────┐
+                              │  Events  │
+                              └──────────┘
+                                     │
+┌─────────┐         ┌─────────────┐  │
+│ Queries │◀────────│ Read Model  │◀─┘
+└─────────┘         └─────────────┘
+```
+
+**When to Use**:
+- Read/write ratio heavily skewed
+- Complex read queries
+- Event sourcing architecture
+- Different optimization needs
+
+## Quick Reference
+
+| Requirement | Recommended Pattern |
+|-------------|---------------------|
+| Simple CRUD app | Monolith |
+| Growing startup | Modular Monolith |
+| Enterprise scale | Microservices |
+| Variable load | Serverless |
+| Async processing | Event-Driven |
+| Read-heavy | CQRS |

package/Ai Agent Workflow/powers/architecture-designer/steering/database-selection.md

@@ -0,0 +1,105 @@
+# Database Selection
+
+> Reference for: Architecture Designer
+> Load when: Choosing database technology
+
+## Database Types
+
+| Type | Examples | Best For |
+|------|----------|----------|
+| **Relational** | PostgreSQL, MySQL | Transactions, complex queries, relationships |
+| **Document** | MongoDB, Firestore | Flexible schemas, rapid iteration |
+| **Key-Value** | Redis, DynamoDB | Caching, sessions, high throughput |
+| **Time-Series** | TimescaleDB, InfluxDB | Metrics, IoT, analytics |
+| **Graph** | Neo4j, Neptune | Relationships, social networks |
+| **Search** | Elasticsearch, Meilisearch | Full-text search, logs |
+
+## Relational (PostgreSQL, MySQL)
+
+```
+Best For:
+- Financial transactions (ACID compliance)
+- Complex queries with joins
+- Data integrity requirements
+- Structured, predictable schemas
+
+When to Avoid:
+- Highly variable schemas
+- Massive horizontal scaling needs
+- Simple key-value access patterns
+```
+
+| Feature | PostgreSQL | MySQL |
+|---------|------------|-------|
+| JSON support | Excellent (JSONB) | Good (JSON) |
+| Full-text search | Built-in | Basic |
+| Extensions | Rich ecosystem | Limited |
+| Replication | Streaming, logical | Statement, row-based |
+
+## Document (MongoDB, Firestore)
+
+```
+Best For:
+- Flexible, evolving schemas
+- Hierarchical data (nested documents)
+- Rapid prototyping
+- Content management
+
+When to Avoid:
+- Complex transactions across documents
+- Heavy relational queries
+- Strict schema requirements
+```
+
+## Key-Value (Redis, DynamoDB)
+
+```
+Best For:
+- Session storage
+- Caching layer
+- Real-time leaderboards
+- Rate limiting counters
+
+When to Avoid:
+- Complex queries
+- Relational data
+- Large value sizes (>1MB)
+```
+
+## Time-Series (TimescaleDB, InfluxDB)
+
+```
+Best For:
+- Metrics and monitoring
+- IoT sensor data
+- Financial tick data
+- Event logging with timestamps
+
+When to Avoid:
+- Frequent updates to existing records
+- Complex relational queries
+- Non-time-based access patterns
+```
+
+## Decision Matrix
+
+| Requirement | Recommended |
+|-------------|-------------|
+| ACID transactions | PostgreSQL, MySQL |
+| Flexible schema | MongoDB, Firestore |
+| High-speed caching | Redis |
+| Time-series data | TimescaleDB, InfluxDB |
+| Social relationships | Neo4j |
+| Full-text search | Elasticsearch |
+| Serverless scale | DynamoDB, Firestore |
+
+## Quick Reference
+
+| Question | If Yes → |
+|----------|----------|
+| Need ACID transactions? | Relational (PostgreSQL) |
+| Schema changes frequently? | Document (MongoDB) |
+| Sub-millisecond reads? | Key-Value (Redis) |
+| Time-based queries? | Time-Series |
+| Traversing relationships? | Graph (Neo4j) |
+| Full-text search primary? | Elasticsearch |