@@ -82,13 +98,16 @@ export function TaskSelector({ type, plan, simulationsUsed, isLoading, onSelect
{cards.map((card) => {
- const locked = card.tache === null || quotaBlocked
+ const isT2Live = card.tache === 'EO_T2_LIVE'
+ // T2 Live ne consomme pas le quota Free (plan Premium uniquement, illimité).
+ // Verrouillage : T2 Live → hasAccess(plan, 'oral_t2_live') ; autres → quota.
+ const locked = isT2Live ? !t2LiveUnlocked : card.tache === null || quotaBlocked
const abbrev = card.tache ? card.tache.split('_')[0] : 'EO'
if (locked) {
return (
- {card.tache === null && (
+ {(card.tache === null || isT2Live) && (
@@ -108,7 +127,12 @@ export function TaskSelector({ type, plan, simulationsUsed, isLoading, onSelect
variant="interactive"
className={cn('relative flex flex-col p-4', isLoading && 'cursor-wait')}
onClick={() => {
- if (!isLoading && card.tache) {
+ if (isLoading) return
+ if (isT2Live && onT2LiveSelect) {
+ onT2LiveSelect()
+ return
+ }
+ if (card.tache && card.tache !== 'EO_T2_LIVE') {
onSelect({ tache: card.tache, mode: 'entrainement' })
}
}}
diff --git a/src/features/simulations/lib/simulationConfig.ts b/src/features/simulations/lib/simulationConfig.ts
index ade996d..610560e 100644
--- a/src/features/simulations/lib/simulationConfig.ts
+++ b/src/features/simulations/lib/simulationConfig.ts
@@ -45,6 +45,15 @@ const SIMULATION_CONFIG: Record = {
dureeRecommandeeSecondes: 120,
enregistrementMinSecondes: EO_MIN_RECORDING_SECONDS,
},
+ EO_T2_LIVE: {
+ dureeMinutes: 6,
+ motsMin: 0,
+ motsCibleMin: 0,
+ motsCibleMax: 0,
+ // 2 min prépa + 3 min 30 dialogue (Sprint 6c).
+ dureeRecommandeeSecondes: 330,
+ enregistrementMinSecondes: EO_MIN_RECORDING_SECONDS,
+ },
EO_T3: {
dureeMinutes: 5,
motsMin: 0,
diff --git a/src/features/simulations/pages/SimulationEOPage.tsx b/src/features/simulations/pages/SimulationEOPage.tsx
index e969515..0b25087 100644
--- a/src/features/simulations/pages/SimulationEOPage.tsx
+++ b/src/features/simulations/pages/SimulationEOPage.tsx
@@ -9,6 +9,7 @@
* Règle H : aucune logique métier — délègue au provider.
*/
+import { useNavigate } from 'react-router-dom'
import { usePlan } from '@/features/dashboard/hooks/usePlan'
import { Button } from '@/shared/ui/Button'
import { TaskSelector } from '../components/TaskSelector'
@@ -36,6 +37,7 @@ export function SimulationEOPage() {
} = usePlan()
const { isCreating, taskUnavailableMessage, selectTask } = useSimulationFlow()
+ const navigate = useNavigate()
return (
@@ -61,6 +63,7 @@ export function SimulationEOPage() {
simulationsUsed={planData.simulations_used}
isLoading={isCreating}
onSelect={selectTask}
+ onT2LiveSelect={() => navigate('/simulation/eo/t2')}
/>
{taskUnavailableMessage && (
diff --git a/src/features/t2-live/hooks/useT2LiveSession.ts b/src/features/t2-live/hooks/useT2LiveSession.ts
new file mode 100644
index 0000000..0d8cd60
--- /dev/null
+++ b/src/features/t2-live/hooks/useT2LiveSession.ts
@@ -0,0 +1,376 @@
+/**
+ * useT2LiveSession — Hook orchestrateur du dialogue T2 Live (Sprint 6c).
+ *
+ * Responsabilités :
+ * 1. Ouvre la WebSocket vers `wss://${API_URL}/t2/live?token=
&sujet=`
+ * au démarrage du dialogue (PAS pendant la prépa).
+ * 2. Branche les hooks audio :
+ * - useAudioCapture → onChunk → ws.send + addCandidateChunk(recording)
+ * - useAudioPlayback → playChunk(base64 IA reçu)
+ * - useAudioRecording → buffer chronologique pour exportWAV
+ * 3. Parse les messages WS :
+ * - Frames Gemini natifs forwardés (serverContent.modelTurn.parts.inlineData)
+ * - Messages applicatifs backend (warning, report, error)
+ * 4. Pilote la state machine T2 (ready → speaking → listening → processing → ended).
+ * 5. Timer 210 s côté frontend (redondant avec le timer backend, ceinture+bretelles).
+ * 6. Gère les close codes (1000, 4001, 4003, 4004, 4005, 4006).
+ *
+ * Validation : test manuel uniquement (WebSocket + AudioContext non testables en jsdom).
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { env } from '@/shared/config/env'
+import { getAccessToken } from '@/shared/lib/auth-client'
+import { useAudioCapture } from './useAudioCapture'
+import { useAudioPlayback } from './useAudioPlayback'
+import { useAudioRecording } from './useAudioRecording'
+import { transition, T2_INITIAL_STATE, type T2State, type T2Event } from '../state/t2-machine'
+
+const DIALOGUE_TIMEOUT_MS = 210_000 // 3 min 30
+const WS_PING_INTERVAL_MS = 30_000
+
+export interface UseT2LiveSessionOptions {
+ sujetId: string
+ /** Appelé quand le rapport est reçu — l'appelant décide de la navigation. */
+ onReportReady?: (simulationId: string) => void
+}
+
+export interface UseT2LiveSessionResult {
+ state: T2State
+ startDialogue: () => Promise
+ endDialogue: () => void
+ warning: boolean
+ errorMessage: string | null
+ simulationId: string | null
+ recording: ReturnType
+ /** Secondes écoulées depuis l'ouverture du WS — pour le timer affiché. */
+ elapsedSeconds: number
+}
+
+interface GeminiPart {
+ inlineData?: { data?: string; mimeType?: string }
+}
+interface GeminiServerContent {
+ modelTurn?: { parts?: GeminiPart[] }
+ inputTranscription?: { text?: string }
+ outputTranscription?: { text?: string }
+ interrupted?: boolean
+ turnComplete?: boolean
+}
+interface GeminiMessage {
+ serverContent?: GeminiServerContent
+}
+interface AppMessage {
+ type: 'warning' | 'report' | 'error' | 'audio'
+ data?: { simulation_id?: string } & Record
+ message?: string
+ code?: string
+}
+
+function buildWsUrl(token: string, sujetId: string): string {
+ const base = env.VITE_API_URL.replace(/^http/, 'ws')
+ return `${base}/t2/live?token=${encodeURIComponent(token)}&sujet=${encodeURIComponent(sujetId)}`
+}
+
+export function useT2LiveSession(opts: UseT2LiveSessionOptions): UseT2LiveSessionResult {
+ const { sujetId, onReportReady } = opts
+ const navigate = useNavigate()
+
+ const [state, setState] = useState(T2_INITIAL_STATE)
+ const [warning, setWarning] = useState(false)
+ const [errorMessage, setErrorMessage] = useState(null)
+ const [simulationId, setSimulationId] = useState(null)
+ const [elapsedSeconds, setElapsedSeconds] = useState(0)
+
+ const wsRef = useRef(null)
+ const sessionEndedRef = useRef(false)
+ const timeoutTimerRef = useRef | null>(null)
+ const elapsedTimerRef = useRef | null>(null)
+ const pingTimerRef = useRef | null>(null)
+ const userSpeakingTimerRef = useRef | null>(null)
+
+ const playback = useAudioPlayback()
+ const recording = useAudioRecording()
+
+ // Capture branchée à l'envoi WS + au buffer recording.
+ const capture = useAudioCapture({
+ onChunk: (base64: string) => {
+ const ws = wsRef.current
+ if (ws && ws.readyState === WebSocket.OPEN) {
+ ws.send(JSON.stringify({ type: 'audio', data: base64 }))
+ }
+ // Décoder pour le buffer recording — base64 → ArrayBuffer 16k Int16 LE.
+ try {
+ const binary = atob(base64)
+ const bytes = new Uint8Array(binary.length)
+ for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+ recording.addCandidateChunk(bytes.buffer)
+ } catch {
+ /* ignore */
+ }
+ },
+ })
+
+ const dispatch = useCallback((event: T2Event) => {
+ setState((prev) => transition(prev, event))
+ }, [])
+
+ const cleanupTimers = useCallback(() => {
+ if (timeoutTimerRef.current !== null) {
+ clearTimeout(timeoutTimerRef.current)
+ timeoutTimerRef.current = null
+ }
+ if (elapsedTimerRef.current !== null) {
+ clearInterval(elapsedTimerRef.current)
+ elapsedTimerRef.current = null
+ }
+ if (pingTimerRef.current !== null) {
+ clearInterval(pingTimerRef.current)
+ pingTimerRef.current = null
+ }
+ if (userSpeakingTimerRef.current !== null) {
+ clearTimeout(userSpeakingTimerRef.current)
+ userSpeakingTimerRef.current = null
+ }
+ }, [])
+
+ const closeAll = useCallback(() => {
+ sessionEndedRef.current = true
+ cleanupTimers()
+ capture.stop()
+ if (wsRef.current && wsRef.current.readyState !== WebSocket.CLOSED) {
+ try {
+ wsRef.current.close()
+ } catch {
+ /* ignore */
+ }
+ }
+ // playback continue jusqu'à fin de file pour ne pas couper la dernière phrase IA.
+ }, [capture, cleanupTimers])
+
+ const handleAudioReceived = useCallback(
+ (base64: string) => {
+ // Heuristique d'activité IA = on est en 'listening' (l'IA parle).
+ // L'évènement USER_SPEAKING est inféré côté capture micro plutôt — ici on
+ // signale au moins qu'on quitte 'speaking' si on y était.
+ playback.playChunk(base64)
+ recording.addAIChunk(base64)
+ },
+ [playback, recording],
+ )
+
+ const handleGeminiMessage = useCallback(
+ (msg: GeminiMessage) => {
+ const sc = msg.serverContent
+ if (!sc) return
+ if (sc.modelTurn?.parts) {
+ for (const part of sc.modelTurn.parts) {
+ if (part.inlineData?.data) {
+ handleAudioReceived(part.inlineData.data)
+ }
+ }
+ }
+ // Les transcriptions sont accumulées côté backend pour la correction
+ // finale — le frontend n'en a pas besoin pour l'UI temps réel.
+ },
+ [handleAudioReceived],
+ )
+
+ const handleAppMessage = useCallback(
+ (msg: AppMessage) => {
+ if (msg.type === 'warning') {
+ setWarning(true)
+ return
+ }
+ if (msg.type === 'report' && msg.data) {
+ const simId = (msg.data.simulation_id as string | undefined) ?? null
+ if (simId) setSimulationId(simId)
+ dispatch({ type: 'REPORT_READY' })
+ if (simId && onReportReady) onReportReady(simId)
+ return
+ }
+ if (msg.type === 'error') {
+ setErrorMessage(msg.message ?? 'Une erreur est survenue.')
+ dispatch({ type: 'ERROR', message: msg.message })
+ }
+ },
+ [dispatch, onReportReady],
+ )
+
+ const handleWsMessage = useCallback(
+ (evt: MessageEvent) => {
+ // Les chunks audio Gemini peuvent arriver en binary ou en JSON
+ // (selon proxy). Le backend Sprint 6a forward les frames Gemini telles
+ // quelles — donc majoritairement string JSON.
+ let text: string
+ if (typeof evt.data === 'string') {
+ text = evt.data
+ } else if (evt.data instanceof ArrayBuffer) {
+ text = new TextDecoder().decode(evt.data)
+ } else if (evt.data instanceof Blob) {
+ // Fallback async — ignorer ce frame, log seulement.
+ console.warn('[T2] Frame Blob reçu, attendu string/ArrayBuffer')
+ return
+ } else {
+ return
+ }
+
+ try {
+ const parsed = JSON.parse(text) as GeminiMessage & AppMessage
+ if (parsed.type === 'warning' || parsed.type === 'report' || parsed.type === 'error') {
+ handleAppMessage(parsed as AppMessage)
+ } else if (parsed.serverContent) {
+ handleGeminiMessage(parsed as GeminiMessage)
+ }
+ } catch {
+ /* JSON malformé — ignorer */
+ }
+ },
+ [handleAppMessage, handleGeminiMessage],
+ )
+
+ const handleWsClose = useCallback(
+ (evt: CloseEvent) => {
+ if (sessionEndedRef.current) return
+ sessionEndedRef.current = true
+ cleanupTimers()
+ capture.stop()
+
+ switch (evt.code) {
+ case 1000:
+ // Fermeture normale — si on n'a pas reçu le rapport, c'est anormal.
+ if (state !== 'ended') {
+ dispatch({ type: 'ERROR', message: 'Session interrompue' })
+ }
+ break
+ case 4001:
+ setErrorMessage('Authentification expirée.')
+ dispatch({ type: 'ERROR', code: 4001 })
+ navigate('/login')
+ break
+ case 4003:
+ setErrorMessage('La Tâche 2 Live est réservée au plan Premium.')
+ dispatch({ type: 'ERROR', code: 4003 })
+ break
+ case 4004:
+ setErrorMessage('Sujet introuvable.')
+ dispatch({ type: 'ERROR', code: 4004 })
+ break
+ case 4005:
+ setErrorMessage('Service temporairement indisponible.')
+ dispatch({ type: 'ERROR', code: 4005 })
+ break
+ case 4006:
+ setErrorMessage('Connexion à l’examinateur perdue.')
+ dispatch({ type: 'ERROR', code: 4006 })
+ break
+ default:
+ setErrorMessage('Une erreur est survenue. Réessayez dans quelques instants.')
+ dispatch({ type: 'ERROR', code: evt.code })
+ }
+ },
+ [capture, cleanupTimers, dispatch, navigate, state],
+ )
+
+ const startDialogue = useCallback(async () => {
+ if (wsRef.current) return
+ setErrorMessage(null)
+ setWarning(false)
+ sessionEndedRef.current = false
+ dispatch({ type: 'START_DIALOGUE' })
+
+ const token = await getAccessToken()
+ if (!token) {
+ setErrorMessage('Authentification requise.')
+ dispatch({ type: 'ERROR', code: 4001 })
+ navigate('/login')
+ return
+ }
+
+ let ws: WebSocket
+ try {
+ ws = new WebSocket(buildWsUrl(token, sujetId))
+ ws.binaryType = 'arraybuffer'
+ } catch (err) {
+ const message = err instanceof Error ? err.message : 'Connexion impossible'
+ setErrorMessage(message)
+ dispatch({ type: 'ERROR' })
+ return
+ }
+ wsRef.current = ws
+
+ ws.onopen = () => {
+ dispatch({ type: 'WS_OPENED' })
+ // Démarrer la capture micro UNE FOIS le WS ouvert.
+ void capture.start()
+
+ // Timer écoulé pour l'UI.
+ const startTime = Date.now()
+ elapsedTimerRef.current = setInterval(() => {
+ setElapsedSeconds(Math.floor((Date.now() - startTime) / 1000))
+ }, 250)
+
+ // Timeout dur côté frontend (redondance avec le 210 s backend).
+ timeoutTimerRef.current = setTimeout(() => {
+ if (sessionEndedRef.current) return
+ if (ws.readyState === WebSocket.OPEN) {
+ try {
+ ws.send(JSON.stringify({ type: 'end' }))
+ } catch {
+ /* ignore */
+ }
+ }
+ dispatch({ type: 'END_REQUESTED' })
+ }, DIALOGUE_TIMEOUT_MS)
+
+ // Keep-alive ping (certains proxies coupent à 30s d'inactivité).
+ pingTimerRef.current = setInterval(() => {
+ if (ws.readyState === WebSocket.OPEN) {
+ try {
+ ws.send(JSON.stringify({ type: 'ping' }))
+ } catch {
+ /* ignore */
+ }
+ }
+ }, WS_PING_INTERVAL_MS)
+ }
+ ws.onmessage = handleWsMessage
+ ws.onclose = handleWsClose
+ ws.onerror = () => {
+ // 'close' suit toujours 'error' — gestion centralisée dans handleWsClose.
+ }
+ }, [capture, dispatch, handleWsClose, handleWsMessage, navigate, sujetId])
+
+ const endDialogue = useCallback(() => {
+ if (sessionEndedRef.current) return
+ cleanupTimers()
+ capture.stop()
+ if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
+ try {
+ wsRef.current.send(JSON.stringify({ type: 'end' }))
+ } catch {
+ /* ignore */
+ }
+ }
+ dispatch({ type: 'END_REQUESTED' })
+ }, [capture, cleanupTimers, dispatch])
+
+ // Cleanup au démontage.
+ useEffect(() => {
+ return () => {
+ closeAll()
+ }
+ }, [closeAll])
+
+ return {
+ state,
+ startDialogue,
+ endDialogue,
+ warning,
+ errorMessage,
+ simulationId,
+ recording,
+ elapsedSeconds,
+ }
+}
diff --git a/src/features/t2-live/pages/T2DialoguePage.tsx b/src/features/t2-live/pages/T2DialoguePage.tsx
new file mode 100644
index 0000000..6a7c036
--- /dev/null
+++ b/src/features/t2-live/pages/T2DialoguePage.tsx
@@ -0,0 +1,212 @@
+/**
+ * Page /simulation/eo/t2/dialogue — phase de dialogue live (Sprint 6c).
+ *
+ * Démarre la session WS au mount, pilote l'UI selon l'état machine T2, affiche
+ * le timer 3:30 et l'indicateur d'état. À la fin (REPORT_READY), affiche un
+ * écran terminal avec deux boutons : "Télécharger l'audio" et "Voir le rapport".
+ */
+
+import { useEffect, useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { Mic, Download, FileText, Loader2 } from 'lucide-react'
+import { Button } from '@/shared/ui/Button'
+import { Card } from '@/shared/ui/Card'
+import { useT2LiveContext } from '../state/T2LiveContext'
+import { useT2LiveSession } from '../hooks/useT2LiveSession'
+
+const DIALOGUE_SECONDS = 210 // 3:30
+
+function formatMmSs(totalSeconds: number): string {
+ const remaining = Math.max(0, totalSeconds)
+ const m = Math.floor(remaining / 60)
+ const s = remaining % 60
+ return `${m}:${s.toString().padStart(2, '0')}`
+}
+
+export function T2DialoguePage() {
+ const navigate = useNavigate()
+ const { sujet, reset: resetContext } = useT2LiveContext()
+ const [autoStarted, setAutoStarted] = useState(false)
+
+ const session = useT2LiveSession({
+ sujetId: sujet?.id ?? '',
+ })
+
+ // Garde-fou : pas de sujet → retour à la sélection.
+ useEffect(() => {
+ if (!sujet) navigate('/simulation/eo/t2', { replace: true })
+ }, [sujet, navigate])
+
+ // Démarrer le dialogue automatiquement au mount (la prépa est déjà finie).
+ useEffect(() => {
+ if (!sujet) return
+ if (autoStarted) return
+ setAutoStarted(true)
+ void session.startDialogue()
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, [sujet, autoStarted])
+
+ const remaining = DIALOGUE_SECONDS - session.elapsedSeconds
+ const stateLabel = (() => {
+ switch (session.state) {
+ case 'idle':
+ case 'connecting':
+ return 'Connexion à l’examinateur…'
+ case 'ready':
+ return 'À vous — prenez la parole.'
+ case 'speaking':
+ return 'L’examinateur écoute…'
+ case 'listening':
+ return 'L’examinateur répond…'
+ case 'processing':
+ return 'Évaluation en cours…'
+ case 'ended':
+ return 'Session terminée.'
+ case 'error':
+ return 'Erreur.'
+ case 'preparing':
+ return 'Préparation…'
+ }
+ })()
+
+ function handleDownload() {
+ const blob = session.recording.exportWAV()
+ const url = URL.createObjectURL(blob)
+ const a = document.createElement('a')
+ a.href = url
+ a.download = `expria-t2-${new Date().toISOString().slice(0, 10)}.wav`
+ document.body.appendChild(a)
+ a.click()
+ document.body.removeChild(a)
+ URL.revokeObjectURL(url)
+ }
+
+ function handleViewReport() {
+ if (!session.simulationId) return
+ resetContext()
+ navigate(`/rapport/${session.simulationId}`)
+ }
+
+ function handleBackToSujets() {
+ resetContext()
+ navigate('/simulation/eo/t2')
+ }
+
+ if (!sujet) return null
+
+ // ── État terminal : rapport prêt ─────────────────────────────────────────
+ if (session.state === 'ended') {
+ return (
+
+
+ Session terminée
+
+
+ Votre dialogue a été évalué. Vous pouvez télécharger l'enregistrement audio avant de
+ consulter le rapport.
+
+
+ Durée enregistrée :{' '}
+
+ {session.recording.durationSeconds.toFixed(1)} s
+
+
+
+
+
+
+
+
+ Erreur
+
+ {session.errorMessage ?? 'Une erreur est survenue.'}
+
+
+
+ Retour aux sujets
+
+
+
+
+
+
+
Dialogue en cours
+
+ {formatMmSs(remaining)}
+
+
+
+ {session.warning && (
+
+ ⏱ 30 secondes restantes.
+
+ )}
+
+
+
+ {session.state === 'processing' ? (
+
+ ) : (
+
+ )}
+
{stateLabel}
+
{sujet.consigne}
+
+
+
+ session.endDialogue()}
+ disabled={session.state === 'processing'}
+ >
+ Terminer le dialogue
+
+
+
+
(null)
+ const expiredRef = useRef(false)
+
+ const idees = useIdees()
+
+ // Garde-fou : pas de sujet → retour à la sélection.
+ useEffect(() => {
+ if (!sujet) navigate('/simulation/eo/t2', { replace: true })
+ }, [sujet, navigate])
+
+ // Pré-warm permission micro (le hook useAudioCapture le fera de toute façon
+ // au start, mais on demande la permission ici pour éviter la latence à 0:00).
+ useEffect(() => {
+ let cancelled = false
+ let stream: MediaStream | null = null
+ void navigator.mediaDevices
+ .getUserMedia({
+ audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true },
+ })
+ .then((s) => {
+ stream = s
+ if (cancelled) {
+ s.getTracks().forEach((t) => t.stop())
+ return
+ }
+ // Permission acquise — on relâche le stream pour ne pas bloquer le micro.
+ s.getTracks().forEach((t) => t.stop())
+ setMicWarmed(true)
+ })
+ .catch(() => {
+ if (!cancelled) setMicWarmed(false)
+ })
+ return () => {
+ cancelled = true
+ if (stream) stream.getTracks().forEach((t) => t.stop())
+ }
+ }, [])
+
+ // Timer countdown 2 min.
+ useEffect(() => {
+ const id = setInterval(() => {
+ setSecondsLeft((s) => {
+ if (s <= 1) {
+ clearInterval(id)
+ if (!expiredRef.current) {
+ expiredRef.current = true
+ // Auto-navigation à la fin de la prépa.
+ queueMicrotask(() => navigate('/simulation/eo/t2/dialogue'))
+ }
+ return 0
+ }
+ return s - 1
+ })
+ }, 1000)
+ return () => clearInterval(id)
+ }, [navigate])
+
+ function handleReady() {
+ navigate('/simulation/eo/t2/dialogue')
+ }
+
+ function handleIdees() {
+ if (!sujet) return
+ // Pas de seuil MIN_WORDS pour T2 prép : on passe la consigne + contexte
+ // comme contenu_partiel pour respecter la validation backend (≥ 30 mots).
+ // Le mécanisme DeepSeek génère des idées de questions à poser.
+ const consigne = sujet.consigne ?? 'Tâche 2 — interaction de service'
+ const contexte = (sujet as { contexte?: string | null }).contexte ?? consigne
+ setShowIdees(true)
+ idees.fetchIdees({ consigne, contenu: contexte })
+ }
+
+ if (!sujet) return null
+
+ return (
+
+
+
+
Préparation — Tâche 2 Live
+
+ {formatMmSs(secondsLeft)}
+
+
+
+
+
+ Consigne
+
+ {sujet.consigne}
+ {(sujet as { contexte?: string | null }).contexte && (
+ <>
+
+ Contexte
+
+
+ {(sujet as { contexte?: string | null }).contexte}
+
+
+ )}
+
+
+
+
+ Comment ça se passe : c'est à vous de
+ prendre la parole en premier pour initier la conversation, comme à l'examen réel.
+ L'examinateur IA attend que vous lui posiez vos questions.
+
+
+
+
+
+ Vos notes (locales — non sauvegardées)
+
+