# Story 3.1 : Enrichissement LLM post-soumission (FR18, FR18b, FR21) Status: done ## Story En tant que système, je veux enrichir automatiquement chaque idée soumise via LLM (titre, domaine, type IA, explication, scores), afin que le CDO découvre une fiche déjà structurée et qualifiée. ## Acceptance Criteria 1. **Given** une idée vient d'être créée (via formulaire web ou email) **When** le système déclenche l'enrichissement asynchrone post-soumission **Then** la Route Handler `POST /api/llm/enrich` est appelée avec `{ ideaId, workspaceId }` **And** l'idée est mise à jour en base avec : `llmTitle` (< 8 mots), `llmDomain`, `llmAiType`, `llmExplanation` (2-3 phrases), `llmScoreImpact` (1-5), `llmScoreFeasibility` (1-5), `llmScoreUrgency` (1-5), `llmEnrichedAt` **And** l'enrichissement s'effectue en moins de 10 secondes pour 90% des cas (NFR4) 2. **Given** l'appel LLM échoue (timeout 8s côté service, erreur API) ou dépasse 30 secondes **When** le fallback est activé **Then** l'idée est marquée `llmEnrichFailed = true` en base **And** aucune donnée LLM partielle n'est écrite (atomicité) **And** la fiche affiche l'indicateur "À qualifier manuellement" dans l'interface CDO (implémentation UI en Story 3.4) 3. **Given** l'idée est marquée `llmEnrichFailed = true` **When** le CDO clique sur "Relancer l'enrichissement" depuis la fiche (UI Story 3.4) **Then** la procédure tRPC `idea.retryEnrich` est appelée **And** la procédure vérifie que `llmEnrichFailed === true` avant de relancer **And** en cas de succès, `llmEnrichFailed` repasse à `false` et les champs LLM sont remplis 4. **Given** le workspace est en tier Free et a atteint 30 idées enrichies (NFR11) **When** une nouvelle soumission est créée **Then** l'enrichissement LLM est ignoré silencieusement (aucune erreur côté contributeur) **And** `llmEnrichFailed = true` n'est PAS écrit (l'idée est simplement créée sans enrichissement) **And** le compteur `llmCallsThisMonth` n'est pas incrémenté 5. **Given** le workspace dépasse 50 appels LLM/mois en tier Free (NFR12) **When** un enrichissement est demandé **Then** la route retourne `{ skipped: true, reason: "llm_limit_reached" }` sans appeler OpenAI 6. **Given** la Route Handler `POST /api/llm/enrich` est appelée **When** le handler traite la requête **Then** il vérifie que l'idée appartient bien au `workspaceId` fourni avant enrichissement (anti-IDOR, NFR14) **And** si l'idée n'appartient pas au workspace → `401 Unauthorized`, aucun enrichissement 7. **Given** l'enrichissement LLM réussit **When** le compteur est mis à jour **Then** `workspace.llmCallsThisMonth` est incrémenté de 1 (identique au pattern de Story 2.3) ## Tasks / Subtasks - [x] Task 1 : Fonction `enrichIdea` dans `services/llm.ts` (AC: #1, #2) - [x] Subtask 1.1 : Ajouter l'interface `EnrichIdeaParams` et `EnrichIdeaResult` dans `src/server/services/llm.ts` ```typescript export interface EnrichIdeaParams { ideaId: string; workspaceId: string; problemDescription: string; department: string; sector?: string | null; companySize?: number | null; } export interface EnrichIdeaResult { llmTitle: string; llmDomain: string; llmAiType: string; llmExplanation: string; llmScoreImpact: number; llmScoreFeasibility: number; llmScoreUrgency: number; } ``` - [x] Subtask 1.2 : Implémenter `enrichIdea(params: EnrichIdeaParams): Promise` avec : - AbortController timeout 8000ms (8s pour laisser 2s de marge réseau vs NFR4 10s) - Modèle `gpt-4o-mini` avec `response_format: { type: "json_object" }` - Prompt système en français, sans jargon technique (conforme FR18b) - Parse du JSON retourné avec validation Zod - Retourne `null` en cas d'erreur (le handler met à jour `llmEnrichFailed`) - [x] Subtask 1.3 : Prompt système à utiliser : ``` Tu enrichis une idée soumise par un collaborateur en entreprise. Tu réponds UNIQUEMENT en JSON valide. Tu écris UNIQUEMENT en français. Tu ne dois JAMAIS utiliser : NLP, OCR, ML, LLM, API, IA, algorithme, modèle dans l'explication. Décris ce que la technologie ferait concrètement, en langage métier accessible. ``` - [x] Subtask 1.4 : Prompt utilisateur à construire dynamiquement : ``` Idée soumise : {problemDescription} Département : {department} Secteur : {sectorLabel} - Taille : {sizeHint} Réponds en JSON avec exactement ces champs : { "llmTitle": "titre court en français (5 mots maximum, sans ponctuation finale)", "llmDomain": "domaine métier en 1-3 mots (ex: Supply Chain, Finance, RH)", "llmAiType": "type de solution en langage métier (ex: Automatisation, Analyse de données, Aide à la décision)", "llmExplanation": "2 à 3 phrases expliquant ce que la solution ferait concrètement pour ce problème", "llmScoreImpact": entier entre 1 et 5, "llmScoreFeasibility": entier entre 1 et 5, "llmScoreUrgency": entier entre 1 et 5 } ``` - [x] Subtask 1.5 : Schema Zod pour valider la réponse LLM (protège contre les hallucinations) : ```typescript const enrichResultSchema = z.object({ llmTitle: z.string().min(1).max(60), llmDomain: z.string().min(1).max(50), llmAiType: z.string().min(1).max(80), llmExplanation: z.string().min(10).max(600), llmScoreImpact: z.number().int().min(1).max(5), llmScoreFeasibility: z.number().int().min(1).max(5), llmScoreUrgency: z.number().int().min(1).max(5), }); ``` - [x] Task 2 : Route Handler `POST /api/llm/enrich` (AC: #1, #2, #4, #5, #6, #7) - [x] Subtask 2.1 : Créer `src/app/api/llm/enrich/route.ts` - route `POST` Next.js App Router - [x] Subtask 2.2 : Validation du body avec Zod : `{ ideaId: z.string().cuid(), workspaceId: z.string().cuid() }` - [x] Subtask 2.3 : Charger l'idée et valider l'appartenance au workspace (anti-IDOR) : ```typescript const idea = await db.idea.findUnique({ where: { id: ideaId }, select: { id: true, workspaceId: true, problemDescription: true, department: true }, }); if (!idea || idea.workspaceId !== workspaceId) { return NextResponse.json({ error: 'Unauthorized' }, { status: 401 }); } ``` - [x] Subtask 2.4 : Charger le workspace et vérifier les limites tier (NFR11, NFR12) : - Compter les idées enrichies du workspace : `db.idea.count({ where: { workspaceId, llmEnrichFailed: false, llmEnrichedAt: { not: null } } })` - Si count >= 30 (FREE_TIER_LIMITS.maxIdeasWithLlm) ET tier === FREE → `return { skipped: true, reason: "idea_limit_reached" }` - Si `!isLlmAllowed(workspace)` → `return { skipped: true, reason: "llm_limit_reached" }` - [x] Subtask 2.5 : Appeler `enrichIdea(params)` avec timeout global de 30s via `AbortController` externe (fallback NFR4) - [x] Subtask 2.6 : Si `enrichIdea` retourne `null` (erreur/timeout) : ```typescript await db.idea.update({ where: { id: ideaId }, data: { llmEnrichFailed: true }, }); return NextResponse.json({ success: false, enriched: false }); ``` - [x] Subtask 2.7 : Si succès, mettre à jour l'idée ET incrémenter le compteur en transaction : ```typescript await db.$transaction([ db.idea.update({ where: { id: ideaId }, data: { ...result, llmEnrichedAt: new Date(), llmEnrichFailed: false }, }), db.workspace.update({ where: { id: workspaceId }, data: { llmCallsThisMonth: { increment: 1 } }, }), ]); return NextResponse.json({ success: true, enriched: true }); ``` - [x] Task 3 : Déclenchement asynchrone post-soumission formulaire (AC: #1) - [x] Subtask 3.1 : Dans `src/server/api/routers/idea.ts`, après la transaction `idea.create`, ajouter un fire-and-forget : ```typescript // Fire-and-forget - pas d'await, ne bloque pas la réponse au contributeur void fetch(`${process.env.NEXT_PUBLIC_APP_URL}/api/llm/enrich`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ideaId: idea.id, workspaceId: workspace.id }), }).catch(() => { /* silencieux - le fallback llmEnrichFailed sera positionné par la route */ }); ``` - [x] Subtask 3.2 : Ajouter `NEXT_PUBLIC_APP_URL` dans `src/env.js` côté server (déjà dans `.env.example`) pour l'URL interne - [x] Task 4 : Déclenchement asynchrone post-soumission email (AC: #1) - [x] Subtask 4.1 : Dans `src/app/api/webhooks/email/route.ts`, après la transaction de création d'idée, ajouter le même fire-and-forget (identique à Subtask 3.1) avec `ideaId` et `workspace.id` - [x] Subtask 4.2 : Utiliser `after()` de `next/server` (Next.js 15 stable) plutôt que fire-and-forget brut si disponible dans ce contexte : ```typescript import { after } from 'next/server'; // après la création de l'idée : after(async () => { await fetch(`${process.env.NEXT_PUBLIC_APP_URL}/api/llm/enrich`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ideaId: idea.id, workspaceId: workspace.id }), }); }); ``` - [x] Task 5 : Procédure tRPC `idea.retryEnrich` pour relance manuelle (AC: #3) - [x] Subtask 5.1 : Ajouter dans `src/server/api/routers/idea.ts` (via `createWorkspaceProcedure` ou `protectedProcedure`) : ```typescript retryEnrich: protectedProcedure .input(z.object({ ideaId: z.string().cuid(), workspaceId: z.string().cuid() })) .mutation(async ({ ctx, input }) => { // Vérifier propriété idea → workspace → user (multi-tenant) // Vérifier que llmEnrichFailed === true // Appeler fetch vers /api/llm/enrich (ou service directement) // Retourner { queued: true } }) ``` - [x] Subtask 5.2 : Le handler vérifie que le workspace appartient à `ctx.session.user.id` (via Workspace.ownerId) - [x] Subtask 5.3 : Retourner `{ queued: true }` immédiatement - l'enrichissement s'exécute en arrière-plan - [x] Task 6 : Mise à jour `src/env.js` (AC: #1) - [x] Subtask 6.1 : Ajouter `NEXT_PUBLIC_APP_URL` dans la section `server` de `src/env.js` (pour les appels internes de `idea.submit`) : ```typescript NEXT_PUBLIC_APP_URL: z.string().url().optional().default('http://localhost:3000'), ``` - [x] Subtask 6.2 : Ajouter dans `runtimeEnv` : `NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL` - [x] Task 7 : Tests (AC: #1, #2, #3, #4, #5, #6) - [x] Subtask 7.1 : Créer `src/app/api/llm/enrich/route.test.ts` avec Vitest - mocker `db`, `enrichIdea` - [x] Subtask 7.2 : Test : body invalide → 400 - [x] Subtask 7.3 : Test : idée n'appartient pas au workspace → 401 - [x] Subtask 7.4 : Test : limite 30 idées Free atteinte → `{ skipped: true, reason: "idea_limit_reached" }` - [x] Subtask 7.5 : Test : limite 50 appels LLM atteinte → `{ skipped: true, reason: "llm_limit_reached" }` - [x] Subtask 7.6 : Test : enrichIdea retourne null (erreur LLM) → `llmEnrichFailed = true` en base - [x] Subtask 7.7 : Test : enrichissement réussi → idée mise à jour, llmCallsThisMonth incrémenté - [x] Subtask 7.8 : Créer `src/server/services/llm.enrich.test.ts` - tester `enrichIdea` avec mock OpenAI - [x] Subtask 7.9 : Test : réponse LLM JSON valide → champs Zod validés, résultat retourné - [x] Subtask 7.10 : Test : timeout AbortController (8s) → retourne `null` - [x] Subtask 7.11 : Test : réponse LLM JSON malformé → retourne `null` ## Dev Notes ### Architecture & décisions techniques **Déclenchement asynchrone - fire-and-forget :** - L'enrichissement NE BLOQUE PAS la réponse au contributeur (NFR2 : confirmation < 1 seconde) - Depuis le tRPC `idea.submit` : `void fetch(...)` sans await - la réponse `{ ideaId }` est retournée immédiatement au client - Depuis le webhook email (`api/webhooks/email/route.ts`) : utiliser `after()` de `next/server` (Next.js 15 stable) pour exécuter après la réponse 200 - `after()` est disponible dans les Route Handlers Next.js 15 - import : `import { after } from 'next/server'` - Vercel : `after()` utilise `waitUntil` sous le capot, garantissant l'exécution même après la réponse **Sécurité multi-tenant - CRITIQUE :** - Toujours valider `idea.workspaceId === input.workspaceId` AVANT l'appel LLM - Le prompt LLM ne doit contenir QUE les données de l'idée ciblée - jamais d'infos d'autres workspaces (NFR14) - Exemple anti-pattern à éviter : ne jamais inclure dans le prompt des exemples tirés d'autres idées du workspace **Gestion des limites tier (NFR11, NFR12) :** - Ordre de vérification dans la route : 1) validation body → 2) ownership idea → 3) limite idées enrichies (NFR11) → 4) limite appels LLM/mois (NFR12) → 5) appel LLM - `isLlmAllowed` est dans `~/lib/tier` (Pattern établi Story 2.3) - réutiliser - Compter les idées enrichies : `db.idea.count({ where: { workspaceId, llmEnrichedAt: { not: null } } })` - plus précis que de compter toutes les idées **OpenAI structured outputs - implémentation recommandée :** ```typescript const completion = await openai.chat.completions.create( { model: "gpt-4o-mini", messages: [ { role: "system", content: systemPrompt }, { role: "user", content: userPrompt }, ], response_format: { type: "json_object" }, // garantit un JSON valide max_tokens: 400, temperature: 0.3, // plus déterministe pour les scores }, { signal: controller.signal } ); const content = completion.choices[0]?.message?.content; if (!content) return null; const parsed = JSON.parse(content); const validated = enrichResultSchema.safeParse(parsed); if (!validated.success) return null; return validated.data; ``` **Timeout - deux niveaux :** 1. AbortController 8000ms dans `enrichIdea` (service) → pour les 90% de cas NFR4 2. Le fallback `llmEnrichFailed = true` couvre les cas > 30s (la route peut avoir un timeout Vercel de 30s en prod) - En dev : timeout Vercel = illimité, donc AbortController à 8s suffit - En prod : configurer la durée max de la fonction dans `vercel.json` si > 10s nécessaire pour la route `/api/llm/enrich` **Idempotence de la route `/api/llm/enrich` :** - Si l'idée a déjà `llmEnrichedAt !== null` → retourner `{ success: true, enriched: false, alreadyDone: true }` sans ré-appeler OpenAI - Protège contre les double-triggers (fire-and-forget peut s'exécuter deux fois) **Coût LLM - estimation par idée (NFR10) :** - gpt-4o-mini : ~$0.15/M tokens input, ~$0.60/M tokens output - Prompt enrichissement : ~200 tokens input + ~150 tokens output ≈ 0,00012$ = 0,0001€ par idée ✅ (< 0,05€) **Langue du contenu généré :** - Tout le contenu LLM est en FRANÇAIS (conforme au `document_output_language: French` de la config) - Les labels `llmDomain` et `llmAiType` sont en français dans les prompts - NFR18 : le label "Suggestion IA - à ajuster" est affiché dans l'UI (responsabilité Story 3.4) **Pattern `services/llm.ts` - extension :** - Le fichier existant contient `generateContextualExamples` (Story 2.3) - Ajouter `enrichIdea` dans le même fichier pour cohérence, OU créer `services/llm.enrich.ts` si le fichier devient trop long (> 150 lignes) - Recommandation : même fichier, ajouter après `generateContextualExamples` - L'instance OpenAI est construite dynamiquement (`const { OpenAI } = await import("openai")`) - même pattern que Story 2.3 **Retry manuelle (FR21) - procédure `idea.retryEnrich` :** - La procédure est dans `idea.ts` router (comme toutes les mutations sur les idées) - Elle appelle directement `fetch('/api/llm/enrich', ...)` - pas d'import direct du service pour éviter les dépendances circulaires avec le contexte Next.js - `createWorkspaceProcedure` n'est pas encore créé - utiliser `protectedProcedure` avec validation manuelle du workspace.ownerId ### Structure des fichiers | Fichier | Action | |---------|--------| | `src/server/services/llm.ts` | Modifier - ajouter `enrichIdea()`, interfaces `EnrichIdeaParams`, `EnrichIdeaResult` | | `src/app/api/llm/enrich/route.ts` | Créer - Route Handler POST /api/llm/enrich | | `src/app/api/llm/enrich/route.test.ts` | Créer - tests Vitest route handler | | `src/server/services/llm.enrich.test.ts` | Créer - tests Vitest service enrichIdea | | `src/server/api/routers/idea.ts` | Modifier - ajouter fire-and-forget + procédure `retryEnrich` | | `src/app/api/webhooks/email/route.ts` | Modifier - ajouter `after()` pour déclencher enrichissement | | `src/env.js` | Modifier - ajouter `NEXT_PUBLIC_APP_URL` côté serveur | ### Conventions architecture à respecter - **Import PrismaClient** : `import { db } from "~/server/db"` (singleton - jamais `new PrismaClient()`) - **Import Zod** : `import { z } from "zod"` - validation input ET output LLM - **tRPC errors** : `throw new TRPCError({ code: "UNAUTHORIZED", message: "..." })` dans les procédures - **Route Handlers errors** : `NextResponse.json({ error: "..." }, { status: 4xx })` - pas de TRPCError - **Multi-tenant** : toujours filtrer par `workspaceId` - voir anti-pattern dans `architecture.md` - **LLM fallback** : jamais d'erreur brute côté client - fallback silencieux, log serveur uniquement - **Loading states** : les skeletons et l'indicateur "À qualifier manuellement" sont en Story 3.4 (fiche détaillée) - **AIBadge / label LLM** : tout contenu LLM DOIT être affiché avec le label "Suggestion IA - à ajuster" dans l'UI (responsabilité Story 3.4, pas Story 3.1) ### Schéma Prisma - aucune migration requise Le schéma Prisma est **déjà complet** pour cette story. Tous les champs LLM ont été anticipés lors de la Story 1.2 : ```prisma // Sur le modèle Idea (déjà en base) : llmTitle String? llmDomain String? llmAiType String? llmExplanation String? @db.Text llmScoreImpact Int? llmScoreFeasibility Int? llmScoreUrgency Int? llmEnrichedAt DateTime? llmEnrichFailed Boolean @default(false) ``` **Aucun `prisma migrate` requis pour cette story.** ### Apprentissages des stories précédentes **Story 2.3 (exemples contextuels) - patterns à réutiliser :** - Pattern OpenAI avec AbortController : `const controller = new AbortController()` + `setTimeout(() => controller.abort(), LLM_TIMEOUT_MS)` - Import dynamique OpenAI : `const { OpenAI } = await import("openai")` (évite les problèmes SSR) - `isLlmAllowed(workspace)` de `~/lib/tier` - réutiliser tel quel - Incrément `llmCallsThisMonth` avec `{ increment: 1 }` - même pattern **Story 2.5 (webhook email) - patterns à réutiliser :** - Transaction Prisma : `await db.$transaction(async (tx) => { ... })` - Idempotence : vérifier l'existence avant de créer/modifier - `after()` import de `next/server` pour fire-and-forget post-response (dans les Route Handlers) **Story 2.4b (seed) - patterns de test :** - Mock Vitest : `vi.mock("~/server/db", () => ({ db: { idea: { update: mockUpdate } } }))` - Mock OpenAI : `vi.mock("openai", () => ({ OpenAI: vi.fn().mockImplementation(() => ({ chat: { completions: { create: mockCreate } } })) }))` ### Séquence de déclenchement complète ``` Contributeur soumet formulaire → idea.submit (tRPC) → idée créée en DB → void fetch('/api/llm/enrich', { ideaId, workspaceId }) [fire-and-forget] → réponse { ideaId } retournée au client immédiatement [async, ~2-10s plus tard] → POST /api/llm/enrich reçu → validation ownership idea → workspace → vérification limites tier → enrichIdea(params) appelé avec AbortController 8s → OpenAI gpt-4o-mini JSON mode → parse + Zod validate → db.$transaction([idea.update(llmFields), workspace.update(llmCallsThisMonth++)]) → { success: true, enriched: true } [si LLM échoue/timeout] → db.idea.update({ llmEnrichFailed: true }) → { success: false, enriched: false } ``` ### NFR concernés - **NFR4** : enrichissement < 10s pour 90% - assuré par AbortController 8s + fallback 30s - **NFR8** : taux d'échec < 5% - monitoring à ajouter côté ops (hors scope MVP) - **NFR10** : coût < 0,05€/idée - gpt-4o-mini ~0,0001€/idée ✅ - **NFR11** : tier Free limité à 30 idées avec enrichissement - vérification dans la route - **NFR12** : max 50 appels LLM/mois en tier Free - `isLlmAllowed()` réutilisé - **NFR14** : isolation workspace dans les prompts - PAS d'infos d'autres workspaces dans le prompt ### Project Structure Notes - `src/app/api/llm/enrich/` est prévu dans l'arborescence cible de `architecture.md` (§ Project Structure - api/llm/enrich/route.ts) - `src/server/services/llm.ts` contient déjà `generateContextualExamples` - étendre ce fichier - Mapping architecture : "Enrichissement & Scoring (FR18–FR21)" → `api/llm/enrich/`, `services/llm.ts`, `components/idea/ScoreSlider.tsx` (pour Story 3.4) - `src/server/api/routers/idea.ts` exporte déjà le router idea - ajouter `retryEnrich` sans rompre les exports existants ### References - [Source: epics.md#Story 3.1 - Enrichissement LLM post-soumission (FR18, FR18b, FR21)] - [Source: prd.md#FR18, FR18b, FR21, NFR4, NFR8, NFR10, NFR11, NFR12, NFR14] - [Source: architecture.md#API & Communication Patterns - Route Handlers : /api/llm/enrich] - [Source: architecture.md#Security Conventions - isolation workspace, anti-IDOR] - [Source: architecture.md#Requirements to Structure Mapping - Enrichissement & Scoring (FR18–FR21)] - [Source: architecture.md#Error Handling Patterns - LLM : fallback silencieux, log côté serveur] - [Source: prisma/schema.prisma - modèle Idea avec champs llm* déjà définis] - [Source: src/server/services/llm.ts - pattern OpenAI AbortController, generateContextualExamples] - [Source: src/app/api/llm/examples/route.ts - pattern isLlmAllowed, increment llmCallsThisMonth] - [Source: implementation-artifacts/2-5-soumission-didee-par-email-fr15.md - pattern after(), transaction Prisma, mock Vitest] - [Source: src/lib/tier.ts - isLlmAllowed(), FREE_TIER_LIMITS] - [Source: platform.openai.com/docs/guides/text-generation - response_format json_object, gpt-4o-mini] ## Dev Agent Record ### Agent Model Used {{agent_model_name_version}} ### Debug Log References ### Completion Notes List - ✅ Task 1 : `enrichIdea()` dans `services/llm.ts` avec interfaces, AbortController 8s, prompt JSON, validation Zod - ✅ Task 2 : Route `POST /api/llm/enrich` avec validation ownership, limites tier (NFR11/NFR12), idempotence, transaction atomique - ✅ Task 3 : Fire-and-forget fetch depuis `idea.submit` (tRPC) - ✅ Task 4 : `after()` depuis webhook email pour enrichissement post-réponse - ✅ Task 5 : Procédure `idea.retryEnrich` (protectedProcedure, vérification owner + llmEnrichFailed) - ✅ Task 6 : `NEXT_PUBLIC_APP_URL` dans `src/env.js` (section client - requis pour jsdom/Vitest) - ✅ Task 7 : 8 tests route enrich + 7 tests service enrichIdea ; mock `after` dans webhook test pour éviter fetch en test - ✅ Code review fixes (2026-02-28) : 6 issues corrigés ### Code Review Fixes (2026-02-28) | # | Sév | Finding | Correction appliquée | |---|-----|---------|---------------------| | 1 | High | `retryEnrich` : ownership check après `llmEnrichFailed` → information disclosure | Workspace `ownerId` vérifié AVANT exposition du statut `llmEnrichFailed` | | 2 | High | `enrichIdea` : catch silencieux, aucun log serveur (violation architecture) | `console.error` avec ideaId + raison (timeout vs erreur API) | | 3 | Med | Webhook : `req.method !== "POST"` dead code App Router | Bloc 405 supprimé | | 4 | Med | Route enrich : `request.json()` parse fail → 500 au lieu de 400 | Try/catch interne sur `request.json()` → 400 | | 5 | Low | Test succès : `expect(mockTransaction).toHaveBeenCalled()` insuffisant | Assertions sur `mockIdeaUpdate` et `mockWorkspaceUpdate` avec données exactes | | 6 | Low | Prompt LLM "5 mots" vs Zod "8 mots" pour `llmTitle` | Prompt aligné sur contrainte Zod réelle : "8 mots maximum" | ### File List - aimpact-hub/src/server/services/llm.ts (modifié - enrichIdea + refine Zod llmTitle ≤ 8 mots + logging catch) - aimpact-hub/src/app/api/llm/enrich/route.ts (créé - JSON parse error 400, isLlmAllowed dans bloc FREE, 401 anti-oracle) - aimpact-hub/src/app/api/llm/enrich/route.test.ts (créé - 11 tests : + JSON malformé 400, + assertions transaction détaillées) - aimpact-hub/src/server/services/llm.enrich.test.ts (créé - 7 tests) - aimpact-hub/src/server/api/routers/idea.ts (modifié - ordre vérifications retryEnrich sécurisé) - aimpact-hub/src/server/api/routers/idea.retryEnrich.test.ts (créé - 10 tests dont test anti-information-disclosure) - aimpact-hub/src/app/api/webhooks/email/route.ts (modifié - dead code supprimé, env) - aimpact-hub/src/app/api/webhooks/email/route.test.ts (modifié - mock after) - aimpact-hub/src/env.js (modifié - NEXT_PUBLIC_APP_URL section client) ### Change Log - 2026-02-28 : Implémentation complète Story 3.1 - enrichIdea LLM, route /api/llm/enrich, fire-and-forget, retryEnrich, env - 2026-02-28 : Code review fixes - sécurité retryEnrich, logging enrichIdea, dead code webhook, JSON parse 400, assertions tests