feat: Async-First Webhook Architecture & Idempotency Hardening

apps/api/src/routes/whatsapp.ts

@@ -1,5 +1,4 @@
 import { FastifyInstance } from 'fastify';
-import { WhatsAppService } from '../services/whatsapp';
 import crypto from 'crypto';
 import { z } from 'zod';
 
@@ -160,25 +159,26 @@ export async function whatsappRoutes(fastify: FastifyInstance) {
                     return reply.code(200).send('EVENT_RECEIVED');
                 } catch (error: unknown) {
                     request.log.error(`[WEBHOOK] Forward throwing error: ${(error instanceof Error ? error.message : String(error))}`);
-                    return reply.code(500).send({ error: 'Gateway forwarding failed' });
+                    // Still return 200 to Meta to avoid retries, even if gateway forward failed internally
+                    return reply.code(200).send('EVENT_RECEIVED_FW_ERR');
                 }
             }
         }
 
-        // ── 3. Return 200 IMMEDIATELY to satisfy Meta's < 20s timeout ───────
-        if (reply.sent) return; // safety check
-        reply.code(200).send('EVENT_RECEIVED');
+        // ── 3. DETACH IMMEDIATELY ──
+        // Respond 200 OK right now to release the HF Gateway connection.
+        // We do this BEFORE any parsing or work.
+        if (!reply.sent) {
+            reply.code(200).send('EVENT_RECEIVED');
+        }
 
-        // ── 3. Validate payload with Zod (async, after reply sent) ──────────
+        // ── 4. Background Processing (enqueue to Worker) ──
         setImmediate(async () => {
             try {
                 const parsed = WebhookPayloadSchema.safeParse(request.body);
+                if (!parsed.success) return;
 
-                if (!parsed.success) {
-                    fastify.log.warn(`[WEBHOOK] Invalid payload schema: ${JSON.stringify(parsed.error.flatten())}`);
-                    return;
-                }
-
+                const { scheduleInboundMessage } = await import('../services/queue');
                 const payload = parsed.data;
 
                 for (const entry of payload.entry) {
@@ -187,25 +187,22 @@ export async function whatsappRoutes(fastify: FastifyInstance) {
 
                         for (const message of messages) {
                             const phone = message.from;
-                            let text = '';
+                            const messageId = message.id;
 
                             if (message.type === 'text' && message.text) {
-                                text = message.text.body;
+                                await scheduleInboundMessage({ phone, text: message.text.body, messageId });
 
                             } else if (message.type === 'interactive' && message.interactive) {
-                                // Handle both button_reply and list_reply
+                                let text = '';
                                 if (message.interactive.type === 'button_reply' && message.interactive.button_reply) {
                                     text = message.interactive.button_reply.id;
-                                    fastify.log.info(`[WEBHOOK] Button reply: ${text}`);
                                 } else if (message.interactive.type === 'list_reply' && message.interactive.list_reply) {
                                     text = message.interactive.list_reply.id;
-                                    fastify.log.info(`[WEBHOOK] List reply: ${text}`);
                                 }
+                                if (text) await scheduleInboundMessage({ phone, text, messageId });
 
                             } else if (message.type === 'audio' && message.audio) {
-                                // ─── Audio inbound: delegate download to Railway worker ────────────
-                                // HF cannot reach graph.facebook.com — enqueue a high-priority job.
-                                // Media IDs expire in ~5 minutes so the job is marked priority: 1.
+                                // Existing audio logic (queues download-media)
                                 const accessToken = process.env.WHATSAPP_ACCESS_TOKEN || undefined;
                                 const { Queue } = await import('bullmq');
                                 const Redis = (await import('ioredis')).default;
@@ -213,6 +210,7 @@ export async function whatsappRoutes(fastify: FastifyInstance) {
                                     ? new Redis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
                                     : new Redis({ host: process.env.REDIS_HOST || 'localhost', port: parseInt(process.env.REDIS_PORT || '6379'), maxRetriesPerRequest: null });
                                 const q = new Queue('whatsapp-queue', { connection: conn as any });
+                                
                                 await q.add('download-media', {
                                     mediaId: message.audio.id,
                                     mimeType: message.audio.mime_type || 'audio/ogg',
@@ -224,20 +222,12 @@ export async function whatsappRoutes(fastify: FastifyInstance) {
                                     phone,
                                     text: "⏳ J'analyse ton audio..."
                                 });
-
-                                fastify.log.info(`[WEBHOOK] Audio ${message.audio.id} enqueued for Railway download`);
-                                // Don't process further — Railway will call handleIncomingMessage after download
-                                continue;
-                            }
-
-                            if (phone && text) {
-                                await WhatsAppService.handleIncomingMessage(phone, text);
                             }
                         }
                     }
                 }
             } catch (error) {
-                fastify.log.error(`[WEBHOOK] Async processing error: ${String(error)}`);
+                fastify.log.error(`[WEBHOOK] Detached processing error: ${String(error)}`);
             }
         });
     });

apps/api/src/services/queue.ts

@@ -66,3 +66,13 @@ export async function scheduleInteractiveList(
     await whatsappQueue.add('send-interactive-list', { userId, headerText, bodyText, buttonLabel, sections });
 }
 
+/** 🚨 ASYNC HANDOVER: Send inbound message for background processing in the worker. */
+export async function scheduleInboundMessage(payload: { phone: string, text: string, audioUrl?: string, imageUrl?: string, messageId?: string }) {
+    await whatsappQueue.add('handle-inbound', payload, {
+        attempts: 3,
+        backoff: { type: 'exponential', delay: 1000 },
+        removeOnComplete: true,
+        removeOnFail: false
+    });
+}
+

apps/whatsapp-worker/src/index.ts

@@ -9,6 +9,7 @@ import { sendLessonDay } from './pedagogy';
 import { updateBehavioralScore } from './scoring';
 import { normalizeWolof } from './normalizeWolof';
 import { getApiUrl, getAdminApiKey, validateEnvironment, isFeatureEnabled } from './config';
+import { WhatsAppLogic } from './services/whatsapp-logic';
 
 dotenv.config();
 
@@ -47,6 +48,21 @@ const worker = new Worker('whatsapp-queue', async (job: Job) => {
             const { phone, text } = job.data;
             await sendTextMessage(phone, text);
         }
+        else if (job.name === 'handle-inbound') {
+            const { phone, text, audioUrl, imageUrl, messageId } = job.data;
+            
+            // 🚨 Idempotence Lock for Inbound Messages
+            if (messageId) {
+                const lockKey = `lock:inbound:${messageId}`;
+                const isLocked = await connection.set(lockKey, "1", "EX", 300, "NX");
+                if (!isLocked) {
+                    console.log(`[WORKER] 🔒 Lock inbound activé : message ${messageId} déjà traité.`);
+                    return;
+                }
+            }
+
+            await WhatsAppLogic.handleIncomingMessage(phone, text, audioUrl, imageUrl);
+        }
         else if (job.name === 'generate-feedback') {
             const { userId, text, trackId, exercisePrompt, lessonText, exerciseCriteria, currentDay, totalDays, language, userActivity, userRegion, previousResponses, isDeepDive, iterationCount, imageUrl } = job.data;
             const user = await prisma.user.findUnique({
@@ -66,8 +82,8 @@ const worker = new Worker('whatsapp-queue', async (job: Job) => {
             const textHash = text ? text.substring(0, 10).replace(/[^a-z0-9]/gi, '') : '';
             const lockKey = `lock:feedback:${userId}:${currentDay}:${textHash}`;
             
-            // EX 60 : Le verrou expire dans 60 secondes. S'il existe déjà, NX retourne null (ou 0).
-            const isLocked = await redis.set(lockKey, "1", "EX", 60, "NX");
+            // 🚨 HARDENING: Le verrou expire dans 300 secondes (5 minutes).
+            const isLocked = await redis.set(lockKey, "1", "EX", 300, "NX");
             if (!isLocked) {
                 console.log(`[WORKER] 🔒 Lock activé : ignorer ce job de feedback en double (User ${userId}, Day ${currentDay})`);
                 return;
@@ -671,37 +687,12 @@ const worker = new Worker('whatsapp-queue', async (job: Job) => {
                     }
 
                     // Process the transcribed text as a normal incoming message via API
+                    // ─── Routing: Process transcribed text ─────────
                     if (transcribedText) {
                         const traceId = `[STT-FLOW-${phone.slice(-4)}]`;
-                        console.log(`${traceId} Forwarding to API handle-message...`);
-
-                        // ─── Port Hardening: Handle HF Space 7860 vs Local 8080 ─────────
-                        let finalApiUrl = AI_API_BASE_URL.replace(/\/$/, "");
-                        if (finalApiUrl.includes('localhost:8080')) {
-                            try {
-                                // Quick check if 8080 is up, if not assume 7860 (Hugging Face)
-                                const pingRes = await fetch('http://localhost:8080/health').catch(() => null);
-                                if (!pingRes || !pingRes.ok) {
-                                    console.log(`${traceId} Local port 8080 not responding, trying 7860 (HF Default)...`);
-                                    finalApiUrl = finalApiUrl.replace('8080', '7860');
-                                }
-                            } catch (e) {
-                                finalApiUrl = finalApiUrl.replace('8080', '7860');
-                            }
-                        }
-
-                        const handleRes = await fetch(`${finalApiUrl}/v1/internal/handle-message`, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-                            body: JSON.stringify({ phone, text: transcribedText, audioUrl })
-                        });
-
-                        if (!handleRes.ok) {
-                            const errText = await handleRes.text();
-                            console.error(`${traceId} API handle-message failed (HTTP ${handleRes.status}): ${errText}`);
-                            throw new Error(`API handle-message failed: ${handleRes.status}`);
-                        }
-                        console.log(`${traceId} API handle-message success.`);
+                        console.log(`${traceId} Processing transcribed text via WhatsAppLogic...`);
+                        await WhatsAppLogic.handleIncomingMessage(phone, transcribedText, audioUrl);
+                        console.log(`${traceId} Inbound audio processing complete.`);
                     }
                 } else if (transcribeRes.status === 429) {
                     // OpenAI quota exceeded — send fallback and do NOT requeue
@@ -721,34 +712,11 @@ const worker = new Worker('whatsapp-queue', async (job: Job) => {
                 }
             } else if (mimeType.startsWith('image/')) {
                 // 📸 VISION FLOW (Lead AI Architect Requirement)
-                console.log(`${traceId} Image detected. Forwarding to API handle-message...`);
-                
-                // ─── Port Hardening: Handle HF Space 7860 vs Local 8080 ─────────
-                let finalApiUrl = AI_API_BASE_URL.replace(/\/$/, "");
-                if (finalApiUrl.includes('localhost:8080')) {
-                    try {
-                        const pingRes = await fetch('http://localhost:8080/health').catch(() => null);
-                        if (!pingRes || !pingRes.ok) {
-                            console.log(`${traceId} Local port 8080 not responding, trying 7860 (HF Default)...`);
-                            finalApiUrl = finalApiUrl.replace('8080', '7860');
-                        }
-                    } catch (e) {
-                        finalApiUrl = finalApiUrl.replace('8080', '7860');
-                    }
-                }
-
-                const handleRes = await fetch(`${finalApiUrl}/v1/internal/handle-message`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-                    body: JSON.stringify({ phone, text: 'Image reçue', imageUrl: audioUrl }) // text: 'Image reçue' to pass gibberish guardrail
-                });
-
-                if (!handleRes.ok) {
-                    const errText = await handleRes.text();
-                    console.error(`${traceId} API handle-message (IMAGE) failed: ${errText}`);
-                    throw new Error(`API handle-message failed: ${handleRes.status}`);
-                }
-                console.log(`${traceId} API handle-message (IMAGE) success.`);
+                console.log(`${traceId} Image detected. Processing via WhatsAppLogic...`);
+                // Provide a placeholder text or attempt vision analysis if desired.
+                // For now, consistent with older logic: text = 'Image reçue'
+                await WhatsAppLogic.handleIncomingMessage(phone, 'Image reçue', undefined, audioUrl);
+                console.log(`${traceId} Inbound image processing complete.`);
             }
         } catch (err: unknown) {
             console.error(`[WORKER] download-media failed:`, err);

apps/whatsapp-worker/src/services/whatsapp-logic.ts

@@ -0,0 +1,312 @@
+import { PrismaClient } from '@repo/database';
+import { Queue } from 'bullmq';
+import Redis from 'ioredis';
+
+const prisma = new PrismaClient();
+
+// Setup local queue access for the worker-side service
+const connection = process.env.REDIS_URL
+    ? new Redis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
+    : new Redis({
+        host: process.env.REDIS_HOST || 'localhost',
+        port: parseInt(process.env.REDIS_PORT || '6379'),
+        maxRetriesPerRequest: null
+    });
+
+const whatsappQueue = new Queue('whatsapp-queue', { connection: connection as any });
+
+async function scheduleMessage(userId: string, text: string, delayMs: number = 0) {
+    await whatsappQueue.add('send-message', { userId, text }, { delay: delayMs });
+}
+
+async function enrollUser(userId: string, trackId: string) {
+    await whatsappQueue.add('enroll-user', { userId, trackId });
+}
+
+export class WhatsAppLogic {
+    private static normalizeCommand(text: string): string {
+        return text
+            .trim()
+            .toLowerCase()
+            .replace(/[.,!?;:]+$/, "")
+            .toUpperCase();
+    }
+
+    private static detectIntent(text: string): 'YES' | 'NO' | 'UNKNOWN' {
+        const normalized = text.trim().toLowerCase().replace(/[.,!?;:]+$/, "");
+        const yesWords = ['oui', 'ouais', 'wi', 'waaw', 'yes', 'yep', 'ok', 'd’accord', 'daccord', 'da’accord'];
+        const noWords = ['non', 'déet', 'deet', 'no', 'nah', 'nein'];
+
+        if (yesWords.some(w => normalized.includes(w))) return 'YES';
+        if (noWords.some(w => normalized.includes(w))) return 'NO';
+        return 'UNKNOWN';
+    }
+
+    private static levenshteinDistance(a: string, b: string): number {
+        const matrix: number[][] = [];
+        for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+        for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                } else {
+                    matrix[i][j] = Math.min(
+                        matrix[i - 1][j - 1] + 1,
+                        matrix[i][j - 1] + 1,
+                        matrix[i - 1][j] + 1
+                    );
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+
+    private static isFuzzyMatch(text: string, target: string, threshold = 0.8): boolean {
+        const normalized = text.trim().toUpperCase();
+        const tar = target.toUpperCase();
+        if (normalized === tar) return true;
+        if (normalized.includes(tar) || tar.includes(normalized)) return true;
+
+        const distance = this.levenshteinDistance(normalized, tar);
+        const maxLength = Math.max(normalized.length, tar.length);
+        const similarity = 1 - distance / maxLength;
+        return similarity >= threshold;
+    }
+
+    static async handleIncomingMessage(phone: string, text: string, audioUrl?: string, imageUrl?: string) {
+        const traceId = audioUrl ? `[STT-FLOW-${phone.slice(-4)}]` : imageUrl ? `[IMG-FLOW-${phone.slice(-4)}]` : `[TXT-FLOW-${phone.slice(-4)}]`;
+        const normalizedText = this.normalizeCommand(text);
+        console.log(`${traceId} Processing Inbound (Async): ${normalizedText} (Audio: ${audioUrl || 'N/A'})`);
+
+        // 1. Find or Create User
+        let user = await prisma.user.findUnique({ where: { phone } });
+
+        if (!user) {
+            const isInscription = this.isFuzzyMatch(normalizedText, 'INSCRIPTION') || normalizedText.includes('INSCRI');
+
+            if (isInscription) {
+                user = await prisma.user.create({ data: { phone } });
+                await whatsappQueue.add('send-interactive-buttons', {
+                    userId: user.id,
+                    bodyText: "Dalal jàmm! Xamle ngay tàmbali. ⏳ 30s.\n(FR) Ton cours se prépare (30s).",
+                    buttons: [
+                        { id: 'LANG_FR', title: 'Français 🇫🇷' },
+                        { id: 'LANG_WO', title: 'Wolof 🇸🇳' }
+                    ]
+                });
+                return;
+            } else {
+                await whatsappQueue.add('send-message-direct', {
+                    phone,
+                    text: "🎓 Bienvenue chez XAMLÉ !\nPour commencer ta formation gratuite, envoie le mot : *INSCRIPTION*\n\n(WO) Dalal jàmm ! Ngir tàmbali sa njàng mburu, bindal : *INSCRIPTION*"
+                });
+                return;
+            }
+        }
+
+        // 1.2 Log message
+        try {
+            await prisma.message.create({
+                data: {
+                    content: text,
+                    mediaUrl: audioUrl || imageUrl,
+                    direction: 'INBOUND',
+                    userId: user.id
+                }
+            });
+        } catch (err) {}
+
+        // 1.5. Testing / Cheat Codes
+        if (this.isFuzzyMatch(normalizedText, 'INSCRIPTION')) {
+            await prisma.enrollment.deleteMany({ where: { userId: user.id } });
+            await prisma.userProgress.deleteMany({ where: { userId: user.id } });
+            await prisma.response.deleteMany({ where: { userId: user.id } });
+            await prisma.message.deleteMany({ where: { userId: user.id } });
+            await (prisma as any).businessProfile.deleteMany({ where: { userId: user.id } });
+            user = await prisma.user.update({
+                where: { id: user.id },
+                data: { city: null, activity: null }
+            });
+            await whatsappQueue.add('send-interactive-buttons', {
+                userId: user.id,
+                bodyText: "Réinitialisation réussie – choisissez votre langue / Tànnal sa làkk :",
+                buttons: [
+                    { id: 'LANG_FR', title: 'Français 🇫🇷' },
+                    { id: 'LANG_WO', title: 'Wolof 🇸🇳' }
+                ]
+            });
+            return;
+        }
+
+        const systemCommands = ['1', '2', 'SUITE', 'APPROFONDIR', 'INSCRIPTION', 'SEED'];
+        const isSystemCommand = systemCommands.some(cmd => this.isFuzzyMatch(normalizedText, cmd)) || normalizedText.includes('INSCRI');
+
+        if (text.length < 2 && !isSystemCommand) {
+             await scheduleMessage(user.id, user.language === 'WOLOF'
+                ? "Dama lay xaar nga wax ma lu gën a yaatu ci sa mbir. Waxtaanal ak man !"
+                : "Je n'ai pas bien compris. Peux-tu me réexpliquer en quelques mots ?");
+             return;
+        }
+
+        if (this.isFuzzyMatch(normalizedText, 'SEED')) {
+            try {
+                // @ts-ignore
+                const { seedDatabase } = await import('@repo/database/seed');
+                const result = await seedDatabase(prisma);
+                await (prisma as any).businessProfile.deleteMany({ where: { userId: user!.id } });
+                await prisma.user.update({ where: { id: user!.id }, data: { activity: null } });
+
+                await scheduleMessage(user.id, result.seeded
+                    ? "✅ Seeding terminé ! Le Cache Cognitif a été réinitialisé.\nEnvoie INSCRIPTION pour commencer."
+                    : "ℹ️ Les données existent déjà. Cache Cognitif purgé. Envoie INSCRIPTION."
+                );
+            } catch (err) {
+                await scheduleMessage(user.id, `❌ Erreur seed`);
+            }
+            return;
+        }
+
+        // Handle Interactive LIST menu (REPLAY, EXERCISE, etc.)
+        const dayActionMatch = normalizedText.match(/^DAY(\d+)_(EXERCISE|REPLAY|CONTINUE|PROMPT)$/);
+        if (dayActionMatch) {
+            const action = dayActionMatch[2];
+            const enrollment = await prisma.enrollment.findFirst({ where: { userId: user.id, status: 'ACTIVE' } });
+            
+            if (action === 'REPLAY' && enrollment) {
+                await whatsappQueue.add('send-content', { userId: user.id, trackId: enrollment.trackId, dayNumber: enrollment.currentDay });
+                return;
+            } else if (action === 'EXERCISE') {
+                await scheduleMessage(user.id, user.language === 'WOLOF' ? "🎙️ Yónnee sa tontu :" : "🎙️ Envoie ta réponse :");
+                return;
+            }
+        }
+
+        // Language selection
+        if (normalizedText === 'LANG_FR' || normalizedText === 'LANG_WO') {
+            const newLang = normalizedText === 'LANG_FR' ? 'FR' : 'WOLOF';
+            user = await prisma.user.update({ where: { id: user.id }, data: { language: newLang } });
+            const promptText = newLang === 'FR' ? "Parfait ! Dans quel domaine te trouves-tu ?" : "Baax na ! Ci ban mbir ngay yëngu ?";
+            
+            await whatsappQueue.add('send-interactive-list', {
+                userId: user.id,
+                headerText: newLang === 'FR' ? "Ton secteur" : "Sa Mbir",
+                bodyText: promptText,
+                buttonLabel: newLang === 'FR' ? "Secteurs" : "Tànn",
+                sections: [{
+                    title: newLang === 'FR' ? 'Liste' : 'Mbir',
+                    rows: [
+                        { id: 'SEC_COMMERCE', title: newLang === 'FR' ? 'Commerce / Vente' : 'Njaay' },
+                        { id: 'SEC_AGRI', title: newLang === 'FR' ? 'Agri / Élevage' : 'Mbay / Samm' },
+                        { id: 'SEC_FOOD', title: newLang === 'FR' ? 'Alimentation / Rest.' : 'Lekk / Restauration' },
+                        { id: 'SEC_COUTURE', title: newLang === 'FR' ? 'Couture / Mode' : 'Couture' },
+                        { id: 'SEC_BEAUTE', title: newLang === 'FR' ? 'Beauté / Bien-être' : 'Rafet' },
+                        { id: 'SEC_TRANSPORT', title: newLang === 'FR' ? 'Transport / Livr.' : 'Transport / Yëgël' },
+                        { id: 'SEC_TECH', title: newLang === 'FR' ? 'Tech / Digital' : 'Tech / Digital' },
+                        { id: 'SEC_AUTRE', title: newLang === 'FR' ? 'Autre secteur' : 'Beneen mbir' }
+                    ]
+                }]
+            });
+            return;
+        }
+
+        const SECTOR_LABELS: Record<string, { fr: string; wo: string }> = {
+            SEC_COMMERCE: { fr: 'Commerce / Vente', wo: 'Njaay' },
+            SEC_AGRI: { fr: 'Agriculture / Élevage', wo: 'Mbay' },
+            SEC_FOOD: { fr: 'Alimentation / Restauration', wo: 'Lekk / Restauration' },
+            SEC_TECH: { fr: 'Tech / Digital', wo: 'Tech / Digital' },
+            SEC_BEAUTE: { fr: 'Beauté / Bien-être', wo: 'Rafet' },
+            SEC_COUTURE: { fr: 'Couture / Mode', wo: 'Couture' },
+            SEC_TRANSPORT: { fr: 'Transport / Livraison', wo: 'Transport / Yëgël' },
+        };
+
+        const sectorLabel = SECTOR_LABELS[normalizedText];
+        const activeEnrollment = await prisma.enrollment.findFirst({
+            where: { userId: user.id, status: 'ACTIVE' },
+            include: { track: true }
+        });
+
+        if (activeEnrollment && (sectorLabel || normalizedText.startsWith('SEC_'))) return;
+
+        if (!activeEnrollment && (sectorLabel || (!user.activity && text.length > 2))) {
+            const activity = sectorLabel ? (user.language === 'WOLOF' ? sectorLabel.wo : sectorLabel.fr) : text.trim();
+            user = await prisma.user.update({ where: { id: user.id }, data: { activity } });
+            await scheduleMessage(user.id, user.language === 'FR' ? `Secteur noté : *${activity}*` : `Bind nanu la ci: *${activity}*`);
+            const trackId = user.language === 'FR' ? "T1-FR" : "T1-WO";
+            await enrollUser(user.id, trackId);
+            return;
+        }
+
+        if (activeEnrollment) {
+            this.detectIntent(text); // Scan for intent (log purposes or future use)
+            const isSuite = this.isFuzzyMatch(normalizedText, 'SUITE') || normalizedText === '2';
+            const isApprofondir = this.isFuzzyMatch(normalizedText, 'APPROFONDIR') || normalizedText === '1';
+
+            if (isSuite) {
+                const userProgress = await prisma.userProgress.findUnique({ where: { userId_trackId: { userId: user.id, trackId: activeEnrollment.trackId } } });
+                const lastResponse = await prisma.response.findFirst({ where: { userId: user.id, dayNumber: activeEnrollment.currentDay }, orderBy: { createdAt: 'desc' } });
+
+                if (userProgress?.exerciseStatus !== 'COMPLETED' && userProgress?.exerciseStatus !== 'PENDING_DEEPDIVE' && !lastResponse) {
+                    await scheduleMessage(user.id, user.language === 'WOLOF' ? "Dafa laaj nga tontu !" : "Tu dois d'abord répondre !");
+                    return;
+                }
+                const nextDay = activeEnrollment.currentDay % 1 !== 0 ? Math.floor(activeEnrollment.currentDay) + 1 : activeEnrollment.currentDay + 1;
+                await prisma.enrollment.update({ where: { id: activeEnrollment.id }, data: { currentDay: nextDay } });
+                await prisma.userProgress.update({ where: { userId_trackId: { userId: user.id, trackId: activeEnrollment.trackId } }, data: { exerciseStatus: 'PENDING', iterationCount: 0 } });
+                await whatsappQueue.add('send-content', { userId: user.id, trackId: activeEnrollment.trackId, dayNumber: nextDay });
+                return;
+            }
+
+            if (isApprofondir) {
+                const userProgress = await prisma.userProgress.findUnique({ where: { userId_trackId: { userId: user.id, trackId: activeEnrollment.trackId } } });
+                const lastResponse = await prisma.response.findFirst({ where: { userId: user.id, dayNumber: activeEnrollment.currentDay }, orderBy: { createdAt: 'desc' } });
+
+                if (userProgress?.exerciseStatus === 'COMPLETED' || (userProgress?.exerciseStatus === 'PENDING' && lastResponse)) {
+                    await prisma.userProgress.update({ where: { id: userProgress!.id }, data: { exerciseStatus: 'PENDING_DEEPDIVE' } });
+                    await scheduleMessage(user.id, user.language === 'WOLOF' ? "Wax ma ndox mi..." : "Très bien ! Quelle info ?");
+                    return;
+                }
+            }
+
+            const pendingProgress = await prisma.userProgress.findFirst({
+                where: { userId: user.id, exerciseStatus: { in: ['PENDING', 'PENDING_REMEDIATION', 'PENDING_DEEPDIVE'] }, trackId: activeEnrollment.trackId },
+            });
+
+            if (pendingProgress) {
+                const trackDay = await prisma.trackDay.findFirst({ where: { trackId: activeEnrollment.trackId, dayNumber: activeEnrollment.currentDay } });
+                if (trackDay) {
+                    const isDeepDiveAction = pendingProgress.exerciseStatus === 'PENDING_DEEPDIVE';
+                    const wordCount = (text || '').trim().split(/\s+/).length;
+                    if (wordCount < 3) {
+                         await scheduleMessage(user.id, user.language === 'WOLOF' ? "Tontu bi gatt na..." : "Ta réponse est un peu courte.");
+                         return;
+                    }
+
+                    await scheduleMessage(user.id, user.language === 'WOLOF' ? "⏳ Defar ak sa tontu..." : "⏳ Analyse de votre réponse...");
+
+                    let currentIterationCount = pendingProgress.iterationCount || 0;
+                    if (isDeepDiveAction) {
+                        currentIterationCount += 1;
+                        await prisma.userProgress.update({ where: { id: pendingProgress.id }, data: { iterationCount: currentIterationCount } });
+                    }
+
+                    await prisma.response.create({ data: { enrollmentId: activeEnrollment.id, userId: user.id, dayNumber: activeEnrollment.currentDay, content: text } });
+
+                    const previousResponsesData = await prisma.response.findMany({ where: { userId: user.id, enrollmentId: activeEnrollment.id }, orderBy: { dayNumber: 'asc' }, take: 5 });
+                    const previousResponses = previousResponsesData.map(r => ({ day: r.dayNumber, response: r.content }));
+
+                    await whatsappQueue.add('generate-feedback', {
+                        userId: user.id, text, trackId: activeEnrollment.trackId, trackDayId: trackDay.id,
+                        exercisePrompt: trackDay.exercisePrompt || '', lessonText: trackDay.lessonText || '',
+                        exerciseCriteria: trackDay.exerciseCriteria, pendingProgressId: pendingProgress.id,
+                        dayNumber: activeEnrollment.currentDay, totalDays: activeEnrollment.track.duration, language: user.language,
+                        userActivity: user.activity, userRegion: user.city, previousResponses,
+                        isDeepDive: isDeepDiveAction, iterationCount: currentIterationCount, imageUrl: imageUrl
+                    }, { attempts: 3, backoff: { type: 'exponential', delay: 2000 } });
+                    return;
+                }
+            }
+        }
+    }
+}