feat: Expand fleet to 23 skills across all domains

New skills (14):
- nestjs-best-practices: 40 priority-ranked rules (kadajett)
- fastapi: Pydantic v2, async SQLAlchemy, JWT auth (jezweb)
- architecture-patterns: Clean Architecture, Hexagonal, DDD (wshobson)
- python-performance-optimization: Profiling and optimization (wshobson)
- ai-sdk: Vercel AI SDK streaming and agent patterns (vercel)
- create-agent: Modular agent architecture with OpenRouter (openrouterteam)
- proactive-agent: WAL Protocol, compaction recovery, self-improvement (halthelobster)
- brand-guidelines: Brand identity enforcement (anthropics)
- ui-animation: Motion design with accessibility (mblode)
- marketing-ideas: 139 ideas across 14 categories (coreyhaines31)
- pricing-strategy: SaaS pricing and tier design (coreyhaines31)
- programmatic-seo: SEO at scale with playbooks (coreyhaines31)
- competitor-alternatives: Comparison page architecture (coreyhaines31)
- referral-program: Referral and affiliate programs (coreyhaines31)

README reorganized by domain: Code Quality, Frontend, Backend,
Auth, AI/Agent Building, Marketing, Design, Meta.

Mosaic Stack is not limited to coding — the Orchestrator serves
coding, business, design, marketing, writing, logistics, and analysis.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

skills/nestjs-best-practices/rules/error-handle-async-errors.md

@@ -0,0 +1,125 @@
+---
+title: Handle Async Errors Properly
+impact: HIGH
+impactDescription: Prevents process crashes from unhandled rejections
+tags: error-handling, async, promises
+---
+
+## Handle Async Errors Properly
+
+NestJS automatically catches errors from async route handlers, but errors from background tasks, event handlers, and manually created promises can crash your application. Always handle async errors explicitly and use global handlers as a safety net.
+
+**Incorrect (fire-and-forget without error handling):**
+
+```typescript
+// Fire-and-forget without error handling
+@Injectable()
+export class UsersService {
+  async createUser(dto: CreateUserDto): Promise<User> {
+    const user = await this.repo.save(dto);
+
+    // Fire and forget - if this fails, error is unhandled!
+    this.emailService.sendWelcome(user.email);
+
+    return user;
+  }
+}
+
+// Unhandled promise in event handler
+@Injectable()
+export class OrdersService {
+  @OnEvent('order.created')
+  handleOrderCreated(event: OrderCreatedEvent) {
+    // This returns a promise but it's not awaited!
+    this.processOrder(event);
+    // Errors will crash the process
+  }
+
+  private async processOrder(event: OrderCreatedEvent): Promise<void> {
+    await this.inventoryService.reserve(event.items);
+    await this.notificationService.send(event.userId);
+  }
+}
+
+// Missing try-catch in scheduled tasks
+@Cron('0 0 * * *')
+async dailyCleanup(): Promise<void> {
+  await this.cleanupService.run();
+  // If this throws, no error handling
+}
+```
+
+**Correct (explicit async error handling):**
+
+```typescript
+// Handle fire-and-forget with explicit catch
+@Injectable()
+export class UsersService {
+  private readonly logger = new Logger(UsersService.name);
+
+  async createUser(dto: CreateUserDto): Promise<User> {
+    const user = await this.repo.save(dto);
+
+    // Explicitly catch and log errors
+    this.emailService.sendWelcome(user.email).catch((error) => {
+      this.logger.error('Failed to send welcome email', error.stack);
+      // Optionally queue for retry
+    });
+
+    return user;
+  }
+}
+
+// Properly handle async event handlers
+@Injectable()
+export class OrdersService {
+  private readonly logger = new Logger(OrdersService.name);
+
+  @OnEvent('order.created')
+  async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
+    try {
+      await this.processOrder(event);
+    } catch (error) {
+      this.logger.error('Failed to process order', { event, error });
+      // Don't rethrow - would crash the process
+      await this.deadLetterQueue.add('order.created', event);
+    }
+  }
+}
+
+// Safe scheduled tasks
+@Injectable()
+export class CleanupService {
+  private readonly logger = new Logger(CleanupService.name);
+
+  @Cron('0 0 * * *')
+  async dailyCleanup(): Promise<void> {
+    try {
+      await this.cleanupService.run();
+      this.logger.log('Daily cleanup completed');
+    } catch (error) {
+      this.logger.error('Daily cleanup failed', error.stack);
+      // Alert or retry logic
+    }
+  }
+}
+
+// Global unhandled rejection handler in main.ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  const logger = new Logger('Bootstrap');
+
+  process.on('unhandledRejection', (reason, promise) => {
+    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  });
+
+  process.on('uncaughtException', (error) => {
+    logger.error('Uncaught Exception:', error);
+    process.exit(1);
+  });
+
+  await app.listen(3000);
+}
+```
+
+Reference: [Node.js Unhandled Rejections](https://nodejs.org/api/process.html#event-unhandledrejection)