Enhance 5 agent prompts, 3 project-type prompts, add troubleshooting guide

Co-authored-by: Rtur2003 <111705644+Rtur2003@users.noreply.github.com>

Author: Copilot

prompts/english/agents/architecture-patterns-prompt.md

@@ -378,15 +378,129 @@ Use this when making significant architecture decisions:
 | **Anemic domain model** | Logic in services, not entities | Move logic to domain objects |
 | **Over-engineering** | Complex for simple problem | Match architecture to scale |
 
+## Serverless Architecture
+
+### When to Use Serverless
+| Use Case | Serverless Fit | Alternative |
+|----------|---------------|-------------|
+| Variable traffic (0 to spike) | ✅ Excellent | - |
+| Long-running processes (>15 min) | ❌ Poor | Containers/ECS |
+| Low-latency (<50ms cold start) | ⚠️ Depends | Always-on containers |
+| Event-driven processing | ✅ Excellent | - |
+| Cost-sensitive, low traffic | ✅ Excellent | - |
+| High-throughput, steady load | ⚠️ Expensive | Reserved instances |
+
+### Serverless Patterns
+```
+Event Sources → Functions → Integrations
+
+┌──────────┐    ┌──────────┐    ┌──────────┐
+│ API GW   │───→│ Lambda   │───→│ DynamoDB │
+│ S3 Event │    │ Function │    │ SQS      │
+│ SQS      │    │          │    │ S3       │
+│ Schedule  │    │          │    │ SNS      │
+│ EventBridge│   │          │    │ Step Fn  │
+└──────────┘    └──────────┘    └──────────┘
+```
+
+## Event Sourcing & CQRS Deep Dive
+
+### Event Sourcing Implementation
+```typescript
+// Events as the source of truth
+interface DomainEvent {
+  eventId: string;
+  aggregateId: string;
+  eventType: string;
+  version: number;
+  timestamp: Date;
+  data: Record<string, unknown>;
+}
+
+// Event store — append-only
+class EventStore {
+  async append(aggregateId: string, events: DomainEvent[], expectedVersion: number): Promise<void> {
+    // Optimistic concurrency check
+    const currentVersion = await this.getVersion(aggregateId);
+    if (currentVersion !== expectedVersion) {
+      throw new ConcurrencyError(`Expected version ${expectedVersion}, got ${currentVersion}`);
+    }
+    await this.db.insert('events', events);
+  }
+  
+  async getEvents(aggregateId: string, fromVersion?: number): Promise<DomainEvent[]> {
+    return this.db.query(
+      'SELECT * FROM events WHERE aggregate_id = ? AND version >= ? ORDER BY version',
+      [aggregateId, fromVersion || 0]
+    );
+  }
+}
+
+// Rebuild state from events
+class OrderAggregate {
+  private state: OrderState = { status: 'new', items: [], total: 0 };
+  
+  static fromEvents(events: DomainEvent[]): OrderAggregate {
+    const order = new OrderAggregate();
+    for (const event of events) {
+      order.apply(event);
+    }
+    return order;
+  }
+  
+  private apply(event: DomainEvent): void {
+    switch (event.eventType) {
+      case 'OrderCreated':
+        this.state = { ...this.state, status: 'created', ...event.data };
+        break;
+      case 'ItemAdded':
+        this.state.items.push(event.data.item);
+        this.state.total += event.data.item.price;
+        break;
+      case 'OrderCompleted':
+        this.state.status = 'completed';
+        break;
+    }
+  }
+}
+```
+
+### Saga Pattern (Distributed Transactions)
+```
+Order Saga — Choreography:
+
+┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
+│  Order   │───→│ Payment  │───→│ Inventory│───→│ Shipping │
+│  Service │    │ Service  │    │ Service  │    │ Service  │
+└──────────┘    └──────────┘    └──────────┘    └──────────┘
+     │               │               │               │
+     │  OrderCreated  │ PaymentOK     │ Reserved      │ Shipped
+     │               │               │               │
+     │← ─ ─ ─ ─ ─ ─ ┤← ─ ─ ─ ─ ─ ─┤← ─ ─ ─ ─ ─ ─┤
+     │  (compensate)  │  (refund)     │  (release)    │
+     
+Compensation = Reverse each step on failure
+```
+
+### Data Consistency Patterns
+| Pattern | Consistency | Performance | Use Case |
+|---------|------------|-------------|----------|
+| **Strong (2PC)** | Immediate | Slow | Financial transactions |
+| **Eventual (Saga)** | Delayed | Fast | E-commerce orders |
+| **CQRS** | Read lag | Very fast reads | Analytics, dashboards |
+| **Outbox** | Reliable | Medium | Event publishing |
+
 ---
 
 ## Remember
 
-> **Architecture is about trade-offs. There are no silver bullets, only trade-offs you can live with.**
-
-Architecture priorities:
-1. **Solve the current problem**: Don't architect for imaginary scale
-2. **Keep it simple**: Complexity is a liability
-3. **Make it evolvable**: Design for change, not perfection
-4. **Measure before optimizing**: Profile, don't guess
-5. **Document decisions**: Future you will thank you (ADRs)
+```
+✦ TRADE-OFFS: Architecture is about trade-offs — there are no silver bullets
+✦ START SIMPLE: Don't architect for imaginary scale — grow as needed
+✦ EVOLVE: Design for change, not perfection — modularize boundaries
+✦ DOCUMENT: ADRs capture why, not just what — future you will thank you
+✦ EVENT SOURCING: Events are facts — they tell the full story of your system
+✦ SAGA PATTERN: Compensating transactions for distributed consistency
+✦ SERVERLESS: Pay-per-use is powerful but understand cold starts and limits
+✦ MEASURE: Profile before optimizing — data beats intuition
+```

prompts/english/agents/fullstack-development-prompt.md

@@ -396,15 +396,159 @@ const { data } = trpc.users.list.useQuery({ page: 1 });
 - [ ] Monitoring alerts configured
 ```
 
+## WebSocket & Real-Time Patterns
+
+### Server-Sent Events (Simple Real-Time)
+```typescript
+// Server — SSE endpoint (lightweight alternative to WebSocket)
+app.get('/api/events', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+  });
+
+  const sendEvent = (event: string, data: unknown) => {
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+
+  // Subscribe to updates
+  const unsubscribe = eventBus.subscribe('task:updated', (task) => {
+    sendEvent('task-update', task);
+  });
+
+  req.on('close', () => {
+    unsubscribe();
+    res.end();
+  });
+});
+
+// Client — EventSource API
+const events = new EventSource('/api/events');
+events.addEventListener('task-update', (e) => {
+  const task = JSON.parse(e.data);
+  updateTaskInUI(task);
+});
+```
+
+### WebSocket with Socket.io
+```typescript
+// Server
+import { Server } from 'socket.io';
+
+const io = new Server(server, {
+  cors: { origin: process.env.CLIENT_URL },
+  connectionStateRecovery: {
+    maxDisconnectionDuration: 2 * 60 * 1000, // 2 minutes
+  },
+});
+
+// Authentication middleware
+io.use(async (socket, next) => {
+  const token = socket.handshake.auth.token;
+  try {
+    const user = await verifyToken(token);
+    socket.data.user = user;
+    next();
+  } catch (err) {
+    next(new Error('Authentication failed'));
+  }
+});
+
+io.on('connection', (socket) => {
+  // Join user-specific room
+  socket.join(`user:${socket.data.user.id}`);
+  
+  // Join project rooms
+  socket.on('join:project', async (projectId) => {
+    const hasAccess = await checkProjectAccess(socket.data.user.id, projectId);
+    if (hasAccess) socket.join(`project:${projectId}`);
+  });
+  
+  // Broadcast updates to project members
+  socket.on('task:update', async (data) => {
+    const task = await updateTask(data);
+    io.to(`project:${task.projectId}`).emit('task:updated', task);
+  });
+});
+
+// Client (React hook)
+function useSocket(projectId: string) {
+  const [socket, setSocket] = useState<Socket | null>(null);
+
+  useEffect(() => {
+    const s = io(process.env.NEXT_PUBLIC_WS_URL!, {
+      auth: { token: getAuthToken() },
+    });
+    s.emit('join:project', projectId);
+    setSocket(s);
+    return () => { s.disconnect(); };
+  }, [projectId]);
+
+  return socket;
+}
+```
+
+## Background Jobs & Task Queues
+
+### BullMQ (Node.js)
+```typescript
+import { Queue, Worker } from 'bullmq';
+
+// Producer — Add jobs to queue
+const emailQueue = new Queue('emails', {
+  connection: { host: 'redis', port: 6379 },
+  defaultJobOptions: {
+    attempts: 3,
+    backoff: { type: 'exponential', delay: 2000 },
+    removeOnComplete: { count: 1000 },
+    removeOnFail: { count: 5000 },
+  },
+});
+
+await emailQueue.add('welcome-email', {
+  to: user.email,
+  template: 'welcome',
+  data: { name: user.name },
+});
+
+// Scheduled/recurring jobs
+await emailQueue.add('daily-digest', { type: 'digest' }, {
+  repeat: { pattern: '0 9 * * *' }, // Every day at 9 AM
+});
+
+// Consumer — Process jobs
+const worker = new Worker('emails', async (job) => {
+  switch (job.name) {
+    case 'welcome-email':
+      await sendEmail(job.data);
+      break;
+    case 'daily-digest':
+      await generateAndSendDigest();
+      break;
+  }
+}, {
+  connection: { host: 'redis', port: 6379 },
+  concurrency: 5,
+  limiter: { max: 10, duration: 1000 }, // 10 jobs/second
+});
+
+worker.on('failed', (job, error) => {
+  logger.error(`Job ${job?.id} failed:`, error);
+});
+```
+
 ---
 
 ## Remember
 
-> **Full-stack development is about reducing the distance between idea and working product.**
-
-Priorities:
-1. **Type safety end-to-end**: Catch errors at compile time
-2. **Convention over configuration**: Use framework defaults
-3. **Ship fast, iterate**: Get feedback early
-4. **Shared validation**: Same rules on client and server
-5. **Progressive enhancement**: Works without JS, better with it
+```
+✦ TYPE SAFETY END-TO-END: Catch errors at compile time — tRPC, Zod, Prisma
+✦ REAL-TIME: SSE for simple updates, WebSocket for bidirectional communication
+✦ BACKGROUND JOBS: Never process long tasks in request handlers — use queues
+✦ CONVENTION OVER CONFIG: Use framework defaults — Next.js, Nuxt, SvelteKit
+✦ SHARED VALIDATION: Same Zod schemas on client and server — single source of truth
+✦ PROGRESSIVE ENHANCEMENT: Works without JS, better with it
+✦ SHIP FAST: Get feedback early — iterate based on real usage
+✦ PRODUCTION READY: Health checks, monitoring, graceful shutdown, auto-scaling
+```