omgkit 2.2.0 → 2.3.0

package/plugin/skills/omega/omega-architecture/SKILL.md

@@ -1,113 +1,71 @@
 ---
-name: omega-architecture
-description: System architecture design with 7 Omega principles for scalable, resilient, and future-proof systems
+name: architecting-omega-systems
+description: Designs scalable, resilient architectures using the 7 Omega principles. Use when building systems that need to scale to millions of users or designing platform-level infrastructure.
 category: omega
 triggers:
   - omega architecture
   - system design
   - scalable architecture
   - distributed systems
-  - microservices design
-  - platform architecture
-  - infrastructure design
 ---
 
-# Omega Architecture
+# Architecting Omega Systems
 
-Design **scalable, resilient, and future-proof systems** following the 7 Omega Principles. This skill provides architectural patterns, decision frameworks, and production-ready blueprints for building systems that scale to millions of users.
+Build **scalable, resilient, and future-proof systems** following the 7 Omega Principles for platform-grade architecture.
 
-## Purpose
+## Quick Start
 
-Build systems that transcend conventional architecture:
+```yaml
+# 1. Define architectural requirements
+Architecture:
+  Name: "E-commerce Platform"
+  Scale: "1M+ concurrent users"
+  Principles: [leverage, abstraction, agentic, antifragile]
 
-- Apply Omega principles to architectural decisions
-- Design for 1000x scale from day one
-- Create self-healing, autonomous systems
-- Build platforms, not just applications
-- Eliminate single points of failure
-- Achieve zero-marginal-cost scaling
-- Future-proof through abstraction layers
+# 2. Apply Omega decision framework
+Decision:
+  Question: "Monolith or microservices?"
+  Omega_Check:
+    - Leverage: "Does this multiply capability?"
+    - Scale: "Zero-marginal-cost at 1000x?"
+    - Resilience: "Self-healing under stress?"
 
-## Features
+# 3. Design with antifragility
+Pattern: Event-Driven + Circuit Breakers + Auto-Scaling
+```
 
-### 1. The 7 Omega Principles in Architecture
+## Features
 
-```markdown
-## Omega Architectural Principles
-
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    7 OMEGA ARCHITECTURE PRINCIPLES                       │
-├─────────────────────────────────────────────────────────────────────────┤
-│                                                                         │
-│  Ω1. LEVERAGE MULTIPLICATION                                            │
-│      → Build systems that amplify effort, not add to it                 │
-│      → Every component should be a force multiplier                     │
-│                                                                         │
-│  Ω2. TRANSCENDENT ABSTRACTION                                           │
-│      → Solve classes of problems, not individual instances              │
-│      → Build frameworks that spawn solutions                            │
-│                                                                         │
-│  Ω3. AGENTIC DECOMPOSITION                                              │
-│      → Autonomous components with clear boundaries                      │
-│      → Self-managing, self-healing subsystems                           │
-│                                                                         │
-│  Ω4. RECURSIVE IMPROVEMENT                                              │
-│      → Systems that optimize themselves over time                       │
-│      → Feedback loops that compound improvements                        │
-│                                                                         │
-│  Ω5. ZERO-MARGINAL-COST SCALING                                         │
-│      → No additional cost per user/request at scale                     │
-│      → Platform economics, not service economics                        │
-│                                                                         │
-│  Ω6. ANTIFRAGILE DESIGN                                                 │
-│      → Systems that grow stronger under stress                          │
-│      → Chaos becomes catalyst for improvement                           │
-│                                                                         │
-│  Ω7. COMPOSABLE PRIMITIVES                                              │
-│      → Lego-block components that combine infinitely                    │
-│      → New capabilities emerge from composition                         │
-│                                                                         │
-└─────────────────────────────────────────────────────────────────────────┘
-```
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| 7 Omega Principles | Core architectural tenets for scalable systems | Apply all 7 to every decision |
+| Leverage Architecture | Systems that amplify effort, not add to it | Build frameworks, not features |
+| Agentic Services | Autonomous, self-healing microservices | Circuit breakers + health monitors |
+| Zero-Marginal-Cost | Platform economics at scale | Edge compute + aggressive caching |
+| Event-Driven Design | Loose coupling via event bus | Kafka/Redis streams + sagas |
+| Antifragile Patterns | Systems that strengthen under stress | Chaos engineering + adaptive config |
+| Decision Framework | Systematic architecture evaluation | Omega checklist for every choice |
 
-### 2. Ω1 Leverage Multiplication Architecture
+## Common Patterns
 
-```typescript
-/**
- * Leverage Multiplication: Build systems, not features
- * Every architectural decision should multiply capability
- */
-
-// ❌ Linear Architecture (effort grows with features)
-class LinearApproach {
-  createUser() { /* specific implementation */ }
-  createProduct() { /* specific implementation */ }
-  createOrder() { /* specific implementation */ }
-  // Each new entity = new implementation = linear growth
-}
+### The 7 Omega Principles
 
-// ✅ Leverage Architecture (effort stays constant)
-interface Entity {
-  id: string;
-  type: string;
-  data: Record<string, unknown>;
-  metadata: EntityMetadata;
-}
+```
+1. LEVERAGE MULTIPLICATION   - Build systems that amplify effort
+2. TRANSCENDENT ABSTRACTION  - Solve classes of problems
+3. AGENTIC DECOMPOSITION     - Autonomous, self-managing services
+4. RECURSIVE IMPROVEMENT     - Systems that optimize themselves
+5. ZERO-MARGINAL-COST        - No cost per user at scale
+6. ANTIFRAGILE DESIGN        - Grow stronger under stress
+7. COMPOSABLE PRIMITIVES     - Lego blocks that combine infinitely
+```
 
-interface EntityMetadata {
-  createdAt: Date;
-  updatedAt: Date;
-  version: number;
-  audit: AuditTrail[];
-}
+### Leverage Architecture Pattern
 
+```typescript
+// ONE implementation handles ALL entity types
 class LeveragedEntitySystem {
-  private validators: Map<string, Validator>;
-  private hooks: Map<string, Hook[]>;
-  private storage: UnifiedStorage;
-
-  async create<T extends Entity>(type: string, data: T): Promise<T> {
-    // One implementation handles ALL entity types
+  async create<T>(type: string, data: T): Promise<T> {
     const validated = await this.validators.get(type)?.validate(data);
     await this.runHooks(type, 'beforeCreate', validated);
     const result = await this.storage.create(type, validated);
@@ -115,50 +73,17 @@ class LeveragedEntitySystem {
     return result as T;
   }
 
-  // Adding new entity type = configuration, not code
+  // New entity = configuration, not code
   registerEntityType(type: string, config: EntityConfig): void {
     this.validators.set(type, createValidator(config.schema));
-    this.hooks.set(type, config.hooks);
   }
 }
-
-// Now ANY new entity is just configuration:
-entitySystem.registerEntityType('user', {
-  schema: userSchema,
-  hooks: [auditHook, notificationHook]
-});
-
-entitySystem.registerEntityType('product', {
-  schema: productSchema,
-  hooks: [inventoryHook, searchIndexHook]
-});
 ```
 
-### 3. Ω3 Agentic Decomposition Pattern
+### Agentic Service Pattern
 
 ```typescript
-/**
- * Agentic Decomposition: Autonomous, self-managing services
- * Each service operates independently with clear contracts
- */
-
-// Service Contract Definition
-interface ServiceContract {
-  name: string;
-  version: string;
-  capabilities: string[];
-  dependencies: ServiceDependency[];
-  healthCheck: () => Promise<HealthStatus>;
-  metrics: () => MetricsSnapshot;
-}
-
-// Self-Healing Service Base
-abstract class AgenticService implements ServiceContract {
-  abstract name: string;
-  abstract version: string;
-  abstract capabilities: string[];
-  dependencies: ServiceDependency[] = [];
-
+abstract class AgenticService {
   private circuitBreaker: CircuitBreaker;
   private healthMonitor: HealthMonitor;
   private autoScaler: AutoScaler;
@@ -166,24 +91,14 @@ abstract class AgenticService implements ServiceContract {
   constructor() {
     // Self-monitoring
     this.healthMonitor = new HealthMonitor({
-      checkInterval: 5000,
       onUnhealthy: () => this.selfHeal()
     });
 
     // Self-protecting
     this.circuitBreaker = new CircuitBreaker({
       failureThreshold: 5,
-      resetTimeout: 30000,
       onOpen: () => this.notifyDegradation()
     });
-
-    // Self-scaling
-    this.autoScaler = new AutoScaler({
-      minInstances: 2,
-      maxInstances: 100,
-      targetCPU: 70,
-      targetMemory: 80
-    });
   }
 
   protected async executeWithResilience<T>(
@@ -192,667 +107,91 @@ abstract class AgenticService implements ServiceContract {
   ): Promise<T> {
     return this.circuitBreaker.execute(operation, fallback);
   }
-
-  private async selfHeal(): Promise<void> {
-    console.log(`[${this.name}] Self-healing initiated`);
-    await this.clearCaches();
-    await this.reconnectDependencies();
-    await this.reloadConfiguration();
-  }
-
-  async healthCheck(): Promise<HealthStatus> {
-    const dependencyHealth = await Promise.all(
-      this.dependencies.map(dep => dep.checkHealth())
-    );
-
-    return {
-      service: this.name,
-      status: dependencyHealth.every(h => h.healthy) ? 'healthy' : 'degraded',
-      dependencies: dependencyHealth,
-      metrics: this.metrics()
-    };
-  }
-
-  abstract metrics(): MetricsSnapshot;
-  protected abstract clearCaches(): Promise<void>;
-  protected abstract reconnectDependencies(): Promise<void>;
-  protected abstract reloadConfiguration(): Promise<void>;
-}
-
-// Example: Autonomous Order Service
-class OrderService extends AgenticService {
-  name = 'order-service';
-  version = '2.1.0';
-  capabilities = ['create-order', 'process-payment', 'track-fulfillment'];
-
-  async createOrder(request: CreateOrderRequest): Promise<Order> {
-    return this.executeWithResilience(
-      async () => {
-        const validated = await this.validateOrder(request);
-        const order = await this.persistOrder(validated);
-        await this.emitEvent('order.created', order);
-        return order;
-      },
-      () => this.queueForRetry(request) // Fallback: queue for later
-    );
-  }
 }
 ```
 
-### 4. Ω5 Zero-Marginal-Cost Architecture
+### Zero-Marginal-Cost Pattern
 
 ```typescript
-/**
- * Zero-Marginal-Cost Scaling: Platform architecture
- * Cost per user/request approaches zero at scale
- */
-
-// Platform Architecture Blueprint
-interface PlatformArchitecture {
-  // Compute: Serverless (pay per execution, not capacity)
-  compute: ServerlessConfig;
-
-  // Storage: Object storage with CDN (infinite scale, usage-based)
-  storage: EdgeStorageConfig;
-
-  // Data: Distributed with automatic sharding
-  database: DistributedDBConfig;
-
-  // Caching: Edge caching eliminates repeated computation
-  cache: EdgeCacheConfig;
-}
-
-const platformConfig: PlatformArchitecture = {
-  compute: {
-    provider: 'cloudflare-workers',
-    // Runs at the edge - 0ms cold start
-    // Pay per request, not per hour
-    pricing: 'per-invocation',
-    limits: {
-      cpuTime: '50ms',
-      memory: '128MB'
-    }
-  },
-
-  storage: {
-    provider: 'r2', // S3-compatible, zero egress fees
-    cdn: {
-      enabled: true,
-      ttl: '1y', // Immutable assets cached forever
-      purgeOnDeploy: true
-    }
-  },
-
-  database: {
-    provider: 'planetscale', // MySQL-compatible, auto-sharding
-    // Or: cockroachdb, vitess, yugabyte
-    sharding: 'automatic',
-    replicas: {
-      read: 'multi-region',
-      write: 'primary-with-failover'
-    }
-  },
-
+// Edge-first architecture
+const platformConfig = {
+  compute: { provider: 'cloudflare-workers', pricing: 'per-invocation' },
+  storage: { provider: 'r2', cdn: { enabled: true, ttl: '1y' } },
+  database: { provider: 'planetscale', sharding: 'automatic' },
   cache: {
     layers: [
       { type: 'browser', ttl: '1h' },
       { type: 'cdn-edge', ttl: '24h' },
-      { type: 'regional', ttl: '1h' },
       { type: 'origin', ttl: '5m' }
     ]
   }
 };
-
-// Implementation: Compute moves to data, not vice versa
-class ZeroMarginalCostAPI {
-  // Edge function - runs in 300+ locations worldwide
-  async handleRequest(request: Request): Promise<Response> {
-    const cacheKey = this.generateCacheKey(request);
-
-    // Layer 1: Edge cache (0 compute cost)
-    const cached = await this.edgeCache.get(cacheKey);
-    if (cached) return cached;
-
-    // Layer 2: Regional compute (minimal latency)
-    const result = await this.processAtEdge(request);
-
-    // Cache for future requests (amortize cost)
-    await this.edgeCache.set(cacheKey, result, { ttl: 3600 });
-
-    return result;
-  }
-
-  private async processAtEdge(request: Request): Promise<Response> {
-    // Use read replicas closest to user
-    const db = this.getRegionalReplica(request.cf?.colo);
-
-    // Streaming response - start sending immediately
-    const stream = new TransformStream();
-    const writer = stream.writable.getWriter();
-
-    // Process in chunks - constant memory usage
-    this.streamResults(db, writer);
-
-    return new Response(stream.readable);
-  }
-}
 ```
 
-### 5. Event-Driven Architecture Pattern
+### Event-Driven Saga Pattern
 
 ```typescript
-/**
- * Event-Driven: Loose coupling, infinite scalability
- * Services communicate through events, not direct calls
- */
-
-// Event Schema with Versioning
-interface DomainEvent<T = unknown> {
-  id: string;
-  type: string;
-  version: number;
-  timestamp: Date;
-  source: string;
-  correlationId: string;
-  causationId?: string;
-  data: T;
-  metadata: EventMetadata;
-}
-
-// Event Bus Implementation
-class EventBus {
-  private handlers: Map<string, EventHandler[]> = new Map();
-  private deadLetterQueue: DeadLetterQueue;
-  private eventStore: EventStore;
-
-  async publish<T>(event: DomainEvent<T>): Promise<void> {
-    // 1. Persist event (event sourcing)
-    await this.eventStore.append(event);
-
-    // 2. Dispatch to handlers
-    const handlers = this.handlers.get(event.type) || [];
-
-    await Promise.allSettled(
-      handlers.map(handler =>
-        this.executeHandler(handler, event)
-      )
-    );
-  }
-
-  private async executeHandler(
-    handler: EventHandler,
-    event: DomainEvent
-  ): Promise<void> {
-    const maxRetries = 3;
-    let attempt = 0;
-
-    while (attempt < maxRetries) {
-      try {
-        await handler.handle(event);
-        return;
-      } catch (error) {
-        attempt++;
-        if (attempt >= maxRetries) {
-          await this.deadLetterQueue.add(event, error);
-        }
-        await this.delay(Math.pow(2, attempt) * 1000);
-      }
-    }
-  }
-
-  subscribe(eventType: string, handler: EventHandler): Unsubscribe {
-    const handlers = this.handlers.get(eventType) || [];
-    handlers.push(handler);
-    this.handlers.set(eventType, handlers);
-
-    return () => {
-      const index = handlers.indexOf(handler);
-      if (index > -1) handlers.splice(index, 1);
-    };
-  }
-}
-
-// Saga Pattern for Distributed Transactions
 class OrderSaga {
-  private eventBus: EventBus;
-
   constructor(eventBus: EventBus) {
-    this.eventBus = eventBus;
-
-    // React to events
     eventBus.subscribe('order.created', this.handleOrderCreated);
-    eventBus.subscribe('payment.completed', this.handlePaymentCompleted);
     eventBus.subscribe('payment.failed', this.handlePaymentFailed);
-    eventBus.subscribe('inventory.reserved', this.handleInventoryReserved);
   }
 
-  handleOrderCreated = async (event: DomainEvent<Order>): Promise<void> => {
-    // Start saga - reserve inventory
+  handleOrderCreated = async (event: DomainEvent<Order>) => {
     await this.eventBus.publish({
       type: 'inventory.reserve',
-      data: {
-        orderId: event.data.id,
-        items: event.data.items
-      },
-      correlationId: event.correlationId,
-      causationId: event.id
+      data: { orderId: event.data.id, items: event.data.items },
+      correlationId: event.correlationId
     });
   };
 
-  handlePaymentFailed = async (event: DomainEvent): Promise<void> => {
-    // Compensating action - release inventory
-    await this.eventBus.publish({
-      type: 'inventory.release',
-      data: { orderId: event.data.orderId },
-      correlationId: event.correlationId,
-      causationId: event.id
-    });
-
-    // Update order status
-    await this.eventBus.publish({
-      type: 'order.cancelled',
-      data: {
-        orderId: event.data.orderId,
-        reason: 'payment_failed'
-      },
-      correlationId: event.correlationId,
-      causationId: event.id
-    });
+  handlePaymentFailed = async (event: DomainEvent) => {
+    // Compensating action
+    await this.eventBus.publish({ type: 'inventory.release', ... });
+    await this.eventBus.publish({ type: 'order.cancelled', ... });
   };
 }
 ```
 
-### 6. Antifragile System Design
-
-```typescript
-/**
- * Ω6 Antifragile: Systems that grow stronger under stress
- * Embrace failure as a catalyst for improvement
- */
-
-// Chaos Engineering Integration
-class AntifragileSystem {
-  private chaosEngine: ChaosEngine;
-  private adaptiveConfig: AdaptiveConfiguration;
-  private learningSystem: LearningSystem;
-
-  constructor() {
-    this.chaosEngine = new ChaosEngine({
-      // Inject controlled failures
-      experiments: [
-        { type: 'latency', probability: 0.01, maxDelay: 500 },
-        { type: 'failure', probability: 0.001, services: ['non-critical'] },
-        { type: 'resource-pressure', probability: 0.01 }
-      ],
-      // Automatically disable during incidents
-      safetyLimits: {
-        errorRate: 0.05,
-        p99Latency: 1000
-      }
-    });
-
-    this.learningSystem = new LearningSystem();
-  }
-
-  // Adaptive Circuit Breaker - learns optimal thresholds
-  private createAdaptiveBreaker(serviceName: string): CircuitBreaker {
-    return new AdaptiveCircuitBreaker({
-      serviceName,
-      // Initial conservative settings
-      initialThreshold: 5,
-      initialTimeout: 30000,
-      // Learn from traffic patterns
-      adaptationRate: 0.1,
-      onStateChange: (from, to, metrics) => {
-        this.learningSystem.recordTransition(serviceName, from, to, metrics);
-      }
-    });
-  }
-
-  // Automatic fallback escalation
-  async executeWithEscalation<T>(
-    primary: () => Promise<T>,
-    fallbacks: Array<() => Promise<T>>,
-    options: ExecutionOptions
-  ): Promise<T> {
-    // Try primary
-    try {
-      return await this.withTimeout(primary(), options.timeout);
-    } catch (primaryError) {
-      // Learn from failure
-      this.learningSystem.recordFailure('primary', primaryError);
-    }
-
-    // Escalate through fallbacks
-    for (let i = 0; i < fallbacks.length; i++) {
-      try {
-        const result = await this.withTimeout(
-          fallbacks[i](),
-          options.timeout * (i + 2) // Progressively longer timeouts
-        );
-        // Record successful fallback
-        this.learningSystem.recordFallbackSuccess(i);
-        return result;
-      } catch (error) {
-        this.learningSystem.recordFailure(`fallback-${i}`, error);
-      }
-    }
-
-    throw new AllFallbacksExhaustedError();
-  }
-
-  // Self-improving configuration
-  async adaptConfiguration(): Promise<void> {
-    const insights = await this.learningSystem.getInsights();
-
-    for (const insight of insights) {
-      switch (insight.type) {
-        case 'timeout-too-short':
-          await this.adaptiveConfig.increase(insight.key, 1.5);
-          break;
-        case 'retry-ineffective':
-          await this.adaptiveConfig.decrease(`${insight.service}.retries`, 0.5);
-          break;
-        case 'cache-miss-pattern':
-          await this.adaptiveConfig.set(
-            `${insight.key}.preload`,
-            insight.suggestedKeys
-          );
-          break;
-      }
-    }
-  }
-}
-
-// Bulkhead Pattern - Isolate failures
-class BulkheadExecutor {
-  private pools: Map<string, ResourcePool>;
-
-  constructor(config: BulkheadConfig) {
-    // Separate pools for different concerns
-    this.pools = new Map([
-      ['critical', new ResourcePool({ size: 20, queue: 100 })],
-      ['standard', new ResourcePool({ size: 10, queue: 50 })],
-      ['background', new ResourcePool({ size: 5, queue: 1000 })]
-    ]);
-  }
-
-  async execute<T>(
-    priority: 'critical' | 'standard' | 'background',
-    task: () => Promise<T>
-  ): Promise<T> {
-    const pool = this.pools.get(priority)!;
-
-    // Critical operations never affected by standard/background load
-    return pool.acquire(async (resource) => {
-      return task();
-    });
-  }
-}
-```
-
-### 7. Architecture Decision Framework
+### Architecture Decision Template
 
 ```markdown
-## Omega Architecture Decision Template
+## Omega Architecture Decision
 
 ### Context
-What problem are we solving?
-What constraints exist?
+[Problem and constraints]
 
 ### Omega Principles Check
-For EVERY architecture decision, verify:
-
 | Principle | Question | Assessment |
 |-----------|----------|------------|
-| Ω1 Leverage | Does this multiply our capability? | |
-| Ω2 Abstraction | Are we solving a class of problems? | |
-| Ω3 Agentic | Can this operate autonomously? | |
-| Ω4 Recursive | Will this improve itself over time? | |
-| Ω5 Zero-Marginal | Does cost scale sub-linearly? | |
-| Ω6 Antifragile | Does it grow stronger under stress? | |
-| Ω7 Composable | Can it combine with other components? | |
-
-### Scale Questions
-1. What happens at 10x current load?
-2. What happens at 100x?
-3. What happens at 1000x?
-4. What's the cost curve at each level?
-
-### Failure Analysis
-1. What's the blast radius of failure?
-2. How do we detect it?
-3. How do we recover?
-4. How do we prevent recurrence?
+| Leverage | Does this multiply capability? | |
+| Abstraction | Solving class of problems? | |
+| Agentic | Can it operate autonomously? | |
+| Recursive | Will it self-improve? | |
+| Zero-Marginal | Sub-linear cost scaling? | |
+| Antifragile | Stronger under stress? | |
+| Composable | Combines with other components? | |
+
+### Scale Analysis
+- 10x load: [Impact]
+- 100x load: [Impact]
+- 1000x load: [Impact]
 
 ### Decision
-[The chosen approach]
-
-### Consequences
-- Benefits:
-- Risks:
-- Technical debt incurred:
-```
-
-## Use Cases
-
-### E-commerce Platform Architecture
-
-```typescript
-/**
- * Complete e-commerce platform following Omega principles
- */
-
-// Domain Events
-type EcommerceEvent =
-  | { type: 'product.created'; data: Product }
-  | { type: 'cart.updated'; data: Cart }
-  | { type: 'order.placed'; data: Order }
-  | { type: 'payment.processed'; data: Payment }
-  | { type: 'inventory.updated'; data: InventoryChange }
-  | { type: 'shipment.dispatched'; data: Shipment };
-
-// Service Boundaries (Agentic Decomposition)
-const serviceArchitecture = {
-  // Each service is autonomous with clear boundaries
-  catalog: {
-    responsibilities: ['product-management', 'search', 'recommendations'],
-    data: ['products', 'categories', 'reviews'],
-    events: ['product.*'],
-    scaling: 'read-heavy, edge-cached'
-  },
-
-  cart: {
-    responsibilities: ['cart-management', 'pricing', 'promotions'],
-    data: ['carts', 'promotions'],
-    events: ['cart.*'],
-    scaling: 'session-based, regional'
-  },
-
-  order: {
-    responsibilities: ['order-processing', 'fulfillment-coordination'],
-    data: ['orders', 'order-items'],
-    events: ['order.*'],
-    scaling: 'write-heavy, strongly-consistent'
-  },
-
-  payment: {
-    responsibilities: ['payment-processing', 'refunds', 'fraud-detection'],
-    data: ['transactions', 'payment-methods'],
-    events: ['payment.*'],
-    scaling: 'PCI-compliant, isolated'
-  },
-
-  inventory: {
-    responsibilities: ['stock-management', 'reservations', 'alerts'],
-    data: ['inventory', 'warehouses'],
-    events: ['inventory.*'],
-    scaling: 'real-time, multi-region sync'
-  },
-
-  shipping: {
-    responsibilities: ['carrier-integration', 'tracking', 'returns'],
-    data: ['shipments', 'carriers'],
-    events: ['shipment.*'],
-    scaling: 'async, event-driven'
-  }
-};
-
-// Infrastructure Blueprint
-const infrastructureConfig = `
-# Kubernetes Architecture
-
-┌─────────────────────────────────────────────────────────────────┐
-│                         EDGE LAYER                               │
-│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐            │
-│  │ CDN     │  │ CDN     │  │ CDN     │  │ CDN     │            │
-│  │ US-EAST │  │ EU-WEST │  │ AP-SOUTH│  │ AP-NORTH│            │
-│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘            │
-└───────┼────────────┼────────────┼────────────┼──────────────────┘
-        │            │            │            │
-┌───────┴────────────┴────────────┴────────────┴──────────────────┐
-│                    API GATEWAY (Global)                          │
-│  ┌──────────────────────────────────────────────────────────┐   │
-│  │ Rate Limiting │ Auth │ Routing │ Load Balancing          │   │
-│  └──────────────────────────────────────────────────────────┘   │
-└─────────────────────────────┬───────────────────────────────────┘
-                              │
-┌─────────────────────────────┴───────────────────────────────────┐
-│                    SERVICE MESH (Istio)                          │
-│                                                                  │
-│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐   │
-│  │ Catalog │ │  Cart   │ │  Order  │ │ Payment │ │Inventory│   │
-│  │ Service │ │ Service │ │ Service │ │ Service │ │ Service │   │
-│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘   │
-│       │          │          │          │          │            │
-└───────┼──────────┼──────────┼──────────┼──────────┼────────────┘
-        │          │          │          │          │
-┌───────┴──────────┴──────────┴──────────┴──────────┴────────────┐
-│                      EVENT BUS (Kafka)                          │
-│  ┌──────────────────────────────────────────────────────────┐   │
-│  │ Topics: products│carts│orders│payments│inventory│shipments│  │
-│  └──────────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────┘
-`;
-```
-
-### SaaS Multi-Tenant Architecture
-
-```typescript
-/**
- * Multi-tenant SaaS following Zero-Marginal-Cost principles
- */
-
-// Tenant Isolation Strategies
-type IsolationStrategy =
-  | 'shared-database' // Cost-efficient, row-level isolation
-  | 'schema-per-tenant' // Balance of isolation and cost
-  | 'database-per-tenant'; // Maximum isolation, higher cost
-
-interface TenantConfig {
-  id: string;
-  tier: 'free' | 'pro' | 'enterprise';
-  isolation: IsolationStrategy;
-  customDomain?: string;
-  dataRegion: string;
-}
-
-class MultiTenantArchitecture {
-  // Tenant-aware query builder
-  createQueryContext(tenantId: string): QueryContext {
-    return {
-      // Automatic tenant filtering on all queries
-      defaultFilters: { tenant_id: tenantId },
-      // Connection pooling by tenant tier
-      pool: this.getPoolForTenant(tenantId),
-      // Read replica routing
-      readPreference: this.getReadPreference(tenantId)
-    };
-  }
-
-  // Dynamic resource allocation by tier
-  private getResourceLimits(tier: string): ResourceLimits {
-    const limits: Record<string, ResourceLimits> = {
-      free: {
-        requestsPerMinute: 60,
-        storageGB: 1,
-        computeUnits: 10,
-        features: ['core']
-      },
-      pro: {
-        requestsPerMinute: 600,
-        storageGB: 50,
-        computeUnits: 100,
-        features: ['core', 'advanced', 'integrations']
-      },
-      enterprise: {
-        requestsPerMinute: 6000,
-        storageGB: 500,
-        computeUnits: 1000,
-        features: ['core', 'advanced', 'integrations', 'sso', 'audit']
-      }
-    };
-    return limits[tier];
-  }
-}
-
-// Feature Flag System (Composable)
-class FeatureFlagSystem {
-  async isEnabled(
-    flag: string,
-    context: { tenant: string; user?: string }
-  ): Promise<boolean> {
-    // Layered evaluation
-    const checks = [
-      this.checkGlobalOverride(flag),
-      this.checkTenantOverride(flag, context.tenant),
-      this.checkUserOverride(flag, context.user),
-      this.checkPercentageRollout(flag, context),
-      this.checkDefaultValue(flag)
-    ];
-
-    for (const check of checks) {
-      const result = await check;
-      if (result !== undefined) return result;
-    }
-
-    return false;
-  }
-}
+[Chosen approach with rationale]
 ```
 
 ## Best Practices
 
-### Do's
-
-- **Apply all 7 Omega principles** to every architectural decision
-- **Design for 1000x scale** from the beginning
-- **Use event-driven patterns** for loose coupling
-- **Implement circuit breakers** at all service boundaries
-- **Build self-healing capabilities** into every service
-- **Measure and optimize** cost per transaction
-- **Document decisions** using the ADR template
-- **Test failure scenarios** with chaos engineering
-- **Use infrastructure as code** for reproducibility
-- **Implement observability** (logs, metrics, traces) everywhere
-
-### Don'ts
-
-- Don't build monoliths that can't be decomposed
-- Don't create tight coupling between services
-- Don't ignore failure modes in design
-- Don't scale vertically when horizontal is possible
-- Don't hardcode configuration
-- Don't skip capacity planning
-- Don't deploy without health checks
-- Don't rely on synchronous calls for non-critical paths
-- Don't ignore data consistency requirements
-- Don't underestimate the cost of distributed systems
-
-## References
-
-- [Designing Data-Intensive Applications](https://dataintensive.net/)
-- [Building Microservices](https://www.oreilly.com/library/view/building-microservices-2nd/9781492034018/)
-- [Release It!](https://pragprog.com/titles/mnee2/release-it-second-edition/)
-- [Site Reliability Engineering](https://sre.google/sre-book/table-of-contents/)
-- [Cloud Design Patterns](https://docs.microsoft.com/en-us/azure/architecture/patterns/)
+| Do | Avoid |
+|----|-------|
+| Apply all 7 Omega principles to every decision | Building monoliths that cannot decompose |
+| Design for 1000x scale from day one | Tight coupling between services |
+| Use event-driven patterns for loose coupling | Ignoring failure modes in design |
+| Implement circuit breakers at all boundaries | Scaling vertically when horizontal is possible |
+| Build self-healing capabilities into services | Hardcoding configuration values |
+| Measure and optimize cost per transaction | Skipping capacity planning |
+| Document decisions using ADR template | Deploying without health checks |
+| Test failure scenarios with chaos engineering | Synchronous calls for non-critical paths |
+| Use infrastructure as code | Ignoring data consistency requirements |
+| Implement observability everywhere | Underestimating distributed system complexity |