Généré le 14/10/2026 14:09

Analyse de faisabilité — Extraction temps réel de multiples instructions dans le flux de parole continu, sans activation manuelle d'un mode

Demande de Raphaël : étudier la faisabilité pour que Jarvis analyse en temps réel le flux de parole, identifie et extraie de manière autonome de multiples instructions, et les traite séquentiellement — sans qu'il ait besoin d'activer manuellement un mode spécifique.

Périmètre par rapport au travail déjà livré le 13/10/2026 : ce sujet touche directement à ce qui a déjà été analysé puis implémenté le 13/10 (ANALYSE_FAISABILITE_ENCHAINEMENT_SEQUENTIEL_ACTIONS_VOCALES_MULTI_ETAPES_20261013.md, mémoires project_jarvis_enchainement_sequentiel_actions_vocales_analyse_13102026 et project_jarvis_sequenceur_plan_actions_vocales_implemente_13102026). Code réellement relu aujourd'hui (pas supposé) dans JARVIS_LIVE_VOICE/server.py pour vérifier ce qui est déjà acquis avant de proposer quoi que ce soit de nouveau.


1. Ce qui est DÉJÀ acquis et vérifié (ne pas redévelopper)

1.1 Décomposition automatique, sans aucun mode à activer

decompose_voice_steps() (l.7094-7146) et _run_mission_auto() (l.7225-7235) sont déjà le point d'entrée unique de dispatch_mission() — vérifié par lecture directe du code, pas supposé. Concrètement : dès qu'une consigne vocale complète contient plusieurs actions réellement séquentielles ("lance la chasse, puis quand c'est fini lance le Juge"), un LLM léger (Gemini 3.5 Flash Lite, ~1s) les découpe et _run_plan() (l.7164-7222) les exécute l'une après l'autre, jamais en parallèle, avec injection du résultat de l'étape précédente dans la suivante.

Point important pour la demande d'aujourd'hui : ce mécanisme ne dépend d'aucun mode à activer. Il est câblé directement dans _run_mission_auto, lui-même appelé par tous les points d'entrée vocaux existants — confirmé par grep : la voie Live (/ws/audio) et le mode "robuste" (process_robuste_turn, l.7914) en bénéficient tous les deux automatiquement. Et "robuste" n'est pas un mode optionnel que Raphaël doit activer : c'est le mode par défaut du système ("active_voice_mode": "robuste", l.127, et repli par défaut l.256). Donc la partie "sans activation manuelle d'un mode spécifique" de la demande est déjà remplie pour le cas qu'elle couvre.

1.2 Barge-in : le micro n'est jamais coupé pendant que Jarvis parle

Autre acquis vérifié : Jarvis écoute en permanence, y compris pendant qu'il parle lui-même. Le mécanisme de "barge-in" (l.4828, 5055-5068, 5667, 8842-8859, 9402) interrompt la lecture audio en cours si Raphaël parle par-dessus. Ce n'est pas un système half-duplex qui coupe le micro pendant la réponse — donc rien n'empêche structurellement Raphaël de donner une nouvelle instruction pendant que Jarvis exécute ou annonce la précédente.

1.3 Le dispatch est non-bloquant, donc rien n'est perdu pendant qu'une mission tourne

dispatch_mission() lance chaque mission via asyncio.create_task(...) (fire-and-forget, l.6683) sous un sémaphore _MISSION_MAX_PARALLEL = 4 (l.6719-6720). La boucle de réception WebSocket reste donc libre d'accepter immédiatement un nouveau tour de parole pendant qu'une mission précédente tourne en arrière-plan — aucune instruction donnée pendant l'exécution d'une autre n'est perdue ou ignorée. C'est déjà "plus réactif" que ce qu'on pourrait craindre.


2. Le vrai écart par rapport à la demande d'aujourd'hui

La décomposition du 13/10 ne fonctionne que dans les limites d'un seul tour de parole — c'est-à-dire le texte produit par UNE SEULE transcription, après qu'un silence VAD a été détecté (silence_duration_ms=1500 en mode robuste, l.9087 ; VAD serveur équivalent côté Live). Deux limites techniques précises, vérifiées dans le code :

2.1 Le STT est un appel bloc entier, jamais un flux incrémental

transcribe_pcm_audio() (l.3714-3727) envoie tout le buffer PCM accumulé depuis la dernière détection de silence en un seul appel REST — ElevenLabs Scribe v2 en priorité (l.3608-3657), repli Google Cloud STT synchrone (l.3660-3710, plafonné à 55s de buffer l.3669). Aucun des deux n'est un flux de reconnaissance avec résultats partiels/intermédiaires (interim results) — recherche de code confirmée négative sur tout server.py. Conséquence concrète : il est aujourd'hui techniquement impossible d'extraire une instruction "au milieu d'une phrase", avant que Raphaël ait fini de parler et qu'un silence de 1,5s ait été détecté. Le mot "temps réel" au sens strict (pendant l'énonciation, mot par mot) demanderait de remplacer toute la chaîne STT par une API à transcription continue en flux (ex. Google STT en mode streaming, ou équivalent côté ElevenLabs/Deepgram si disponible) — un chantier de taille significative, pas une extension du code existant.

2.2 Plusieurs instructions séparées par une vraie pause partent comme missions indépendantes, pas comme un plan unique

Si Raphaël dit "lance la chasse" puis, après une pause de plus de 1,5s (ex. il réfléchit, ou attend confusément une confirmation), ajoute "et aussi fais-moi un rapport Ysenra" — ce sont deux tours VAD distincts, donc deux appels séparés à dispatch_mission(). Chacun passe par decompose_voice_steps() individuellement, qui ne voit qu'UNE instruction à la fois et renvoie [instruction] (pas de découpage, rien à découper). Les deux finissent par tourner en parallèle sous le même sémaphore à 4, sans aucun lien de séquence ni de dépendance entre elles — alors que l'intention de Raphaël était peut-être qu'elles s'enchaînent dans l'ordre, ou que la deuxième attende la fin de la première.

C'est l'écart réel entre "ce qui existe" (découpage intra-tour, déjà acquis) et "ce qui est demandé" (capture inter-tours, à travers un flux continu de parole, sans que Raphaël ait besoin de tout dire d'un seul souffle ni d'activer quoi que ce soit).


3. Architecture proposée pour combler cet écart

3.1 Option retenue — fusion différée des tours proches dans le temps (recommandée)

Ne pas toucher au STT (trop risqué, trop lourd pour le bénéfice réel — voir §2.1). À la place, étendre la logique déjà en place au niveau de l'enchaînement entre tours, pas à l'intérieur d'un tour :

  1. Quand un nouveau tour arrive alors qu'un plan/mission issu d'un tour précédent de la même session est encore "running" (ou terminé depuis moins de ~8-10s), ne pas le dispatcher immédiatement comme mission indépendante.
  2. Soumettre ce nouveau texte à un classifieur LLM léger (réutilisation directe du même modèle que decompose_voice_steps, coût quasi nul) avec pour contexte l'instruction du plan en cours : "Est-ce que cette nouvelle phrase est (a) la suite logique de la même intention en cours, à exécuter après elle, ou (b) une demande nouvelle et indépendante ?"
  3. Si (a) : append de l'étape dans _global_plans[plan_id]["steps_ledger"] (déjà la structure existante, _run_plan sait déjà itérer dessus — il suffit de lui permettre d'accepter un ajout dynamique pendant qu'il tourne, plutôt que de ne lire que la liste figée au lancement). Toujours plafonné à _MAX_PLAN_STEPS (garde-fou anti-rafale déjà en place).
  4. Si (b) : comportement actuel inchangé, nouvelle mission indépendante, exécutée en parallèle comme aujourd'hui.

Avantages : zéro changement d'architecture STT/VAD, réutilise à 90% ce qui a été livré le 13/10 (_global_plans, _run_plan, le classifieur LLM léger), zéro mode à activer (c'est automatique et invisible, exactement l'exigence de la demande), risque de régression faible car le chemin "une seule instruction isolée" (l'écrasante majorité des cas) n'est pas modifié.

Limite assumée : ça ne capte pas une instruction donnée "au milieu d'un mot" — seulement des instructions données en tours successifs rapprochés dans le temps. C'est un compromis délibéré : couvre le scénario réellement décrit par Raphaël (parler naturellement, donner plusieurs instructions sans les empaqueter dans une seule phrase ni activer un mode) sans le risque et le coût du streaming STT complet.

3.2 Option écartée — vraie transcription en flux continu (mot par mot)

Techniquement possible mais à coût et risque disproportionnés par rapport au gain : remplacement complet de la chaîne STT (ElevenLabs Scribe v2 + Google STT, tous deux des appels REST bloc-entier) par une API à résultats partiels, plus un reclassement incrémental du texte partiel à chaque nouveau mot — avec un risque réel de déclencher une action sur une phrase encore incomplète ("lance la ch..." mal interprété avant que "...asse produit" n'arrive). Pas recommandé en premier temps ; à ne reconsidérer que si l'option 3.1 s'avère insuffisante en usage réel.


4. Recommandation

Implémenter l'option 3.1 (fusion différée des tours proches), qui répond à la demande de Raphaël ("sans activation manuelle d'un mode spécifique", "traite séquentiellement") avec un risque et un coût de développement modérés, en réutilisant la quasi-totalité de la mécanique déjà livrée le 13/10/2026. Avant de coder, passer par workflow_architect (règle 14 du CLAUDE.md) comme pour toute nouvelle brique — cette étude est volontairement arrêtée à l'analyse, l'implémentation reste à trancher par Raphaël.