Demande de Raphaël : étudier pourquoi Jarvis n'arrive pas à enchaîner correctement plusieurs actions données dans une seule consigne vocale (ex. "lance la chasse, puis quand c'est fini envoie-moi le rapport, puis lance le juge"), et proposer une architecture de file d'attente / mémoire séquentielle pour que chaque étape s'exécute l'une après l'autre sans perdre le fil.
Périmètre par rapport à l'analyse du jour déjà produite : ANALYSE_FAISABILITE_PARALLELISATION_MISSIONS_MEMOIRE_SEQUENTIELLE_20261013.md traite un sujet voisin mais distinct — la mémoire entre missions séparées (plusieurs instructions vocales successives) et le parallélisme de haut niveau. Cette analyse-ci traite un problème plus étroit et plus concret : une seule et même phrase vocale qui contient déjà, en elle-même, plusieurs actions ordonnées. C'est un défaut structurel différent, localisé en amont de dispatch_mission(), avant même que la question de la mémoire inter-missions ne se pose. Code vérifié directement (pas supposé) : JARVIS_LIVE_VOICE/server.py.
dispatch_mission(instruction, brain, deliver_cb) (l.6613) est appelé à exactement 3 endroits dans tout server.py (l.1620, l.5080, l.7262), et dans les 3 cas, instruction est le texte brut de la consigne vocale, intégral, non découpé. Aucune étape de pré-analyse ne cherche les connecteurs séquentiels ("puis", "ensuite", "quand c'est fini", "après ça") pour scinder la phrase en actions atomiques — recherche de code confirmée négative (puis n'apparaît dans server.py que dans des commentaires et du texte français non structurant, jamais comme logique de découpage).
Conséquence : une consigne à 3 étapes produit un seul mission_id, un seul appel subprocess, un seul résultat final. Le découpage A→B→C, s'il a lieu, dépend entièrement de la capacité de l'agent externe (claude.exe/agy.exe lancé en -p) à comprendre et dérouler lui-même les 3 étapes en autonomie totale, sans aucun garde-fou ni visibilité côté serveur.
_run_mission() (l.6317-6454) fait un unique appel call_ai_brain(instruction + JARVIS_REPORT_FORMAT_INSTRUCTION, brain, False, True) (l.6348). Le continue_session=False est volontaire : le commentaire l.6346-6347 précise "chaque mission est un sous-agent isolé, jamais de contexte hérité d'une mission précédente" — une protection anti-contamination qui a corrigé un incident réel (échec de la mission "schéma pyramidal" du 20/09/2026, cité dans l'analyse du jour).
Problème : cette isolation, qui est une bonne protection entre missions distinctes, s'applique aussi à l'intérieur même d'une seule consigne à 3 étapes, puisque le serveur ne voit l'instruction que comme un bloc unique. Le processus externe reçoit "fais A puis B puis C" en un seul prompt et doit tout faire avant de rendre la main — le serveur n'a aucun point de contrôle entre A et B, aucune vérification réelle que A s'est bien terminée avant que B démarre, aucune capacité d'arrêter la chaîne si A échoue.
Le cas "quand c'est fini" (attendre la fin réelle d'une tâche asynchrone avant de déclencher la suivante) est le plus révélateur. dispatch_mission() crée un asyncio.create_task(_run_mission(...)) (l.6683) fire-and-forget : rien n'observe la fin d'une mission pour en déclencher une autre. Il n'existe aucun champ depends_on / after_mission_id dans l'objet mission (champs réels : id, instruction, brain, status, started_at, completed_at, success, result, report — l.6321-6333), et aucune table d'abonnement de callbacks de complétion. Si Raphaël dit "lance la chasse, et quand c'est fini lance le juge", ces deux actions n'ont structurellement aucun lien côté serveur : soit l'agent externe les enchaîne lui-même dans son unique appel (ce qui peut réussir ou échouer silencieusement), soit — si elles doivent être 2 missions Jarvis distinctes — rien ne les relie.
En mode léger (is_shared_session=False, cerveau sans accès réel aux outils), la délégation d'action passe par une balise textuelle unique [DELEGUER: ...] que le LLM doit générer, et que le serveur extrait (commentaire explicite l.3012-3018 : "pas de function-calling natif ici... la délégation passe par une balise textuelle parsée par l'appelant").
Le point critique : l'extraction (l.5067-5074) utilise re.search(r"\[D[EÉ]L[EÉ]GUER\s*:\s*(.+?)\]", jarvis_reply, ...). re.search ne renvoie que la PREMIÈRE occurrence. Si le LLM léger génère effectivement 3 balises [DELEGUER: A][DELEGUER: B][DELEGUER: C] pour une consigne à 3 étapes, seule la première est extraite et exécutée — les deux autres restent du texte mort dans la réponse (le nettoyage l.5058 est en plus ancré en début de chaîne ^\s*\[...\], donc il ne retire même pas proprement une 2ᵁ balise au milieu du texte). C'est un bug concret et vérifiable, pas une supposition.
Recherche de code confirmée négative : aucune structure pending_action, task_queue, action_plan ou todo_list orientée séquencement de mission n'existe dans server.py ni tools/. La seule fidélité séquentielle qui existe réellement est le patron pipelines/<slug>/state.json à phases nommées (ex. pipelines/coussin-gel-ergonomique/state.json), mais il est construit à la main par l'agent qui suit le skill orchestrer-mission-antigravity, jamais généré automatiquement à partir d'une instruction vocale brute. Et ce skill documente lui-même (section 1bis) que "la mission part en un bloc... pas un découpage phase par phase" — un choix de conception cohérent une fois la mission lancée, mais qui ne règle rien pour le découpage en amont d'une consigne à plusieurs actions.
Si le découpage se fait sur 2 tours de parole séparés ("fais A" ... puis plus tard "fais B maintenant"), le lien entre les deux repose sur get_persisted_session_context() (l.2778-2867) et get_quick_missions_snapshot() (l.2869-2894), qui ne réinjectent qu'un résumé texte tronqué (missions passées coupées à 100-200 caractères, échanges coupés à 2000 caractères) — pas un registre structuré "étape A = terminée, résultat clé = X". Une information décisive peut littéralement être coupée au milieu.
mission_id part avec les deux actions en texte. Selon l'humeur de l'agent externe ce jour-là : soit il enchaîne correctement en interne (ça peut marcher par chance), soit il lance le Juge sur un tableau vide parce que la chasse n'a pas eu le temps de produire ses lignes, soit il s'arrête après la chasse en considérant la consigne remplie. Le serveur ne peut ni détecter ni corriger ces cas, puisqu'il ne reçoit qu'un texte final unique en fin de course.re.search ci-dessus) ; B disparaît silencieusement.Principe directeur : réutiliser au maximum les briques existantes (dispatch_mission, _global_missions, is_mission_success, deliver_audio_mission_result, le patron de persistance JSON déjà validé pour les pipelines) plutôt qu'inventer un nouveau sous-système parallèle. Coût technique visé : modéré, localisé, pas de nouvelle dépendance externe.
Avant d'appeler dispatch_mission(), insérer une étape de classification : la consigne contient-elle plusieurs actions ordonnées, ou une seule ? Ne pas faire ça par regex sur "puis"/"ensuite" — un piège déjà identifié ailleurs dans l'écosystème (mémoire feedback_workflow_architect_faux_positif_navigator_browser : une détection par mot-clé brut produit des faux positifs, ex. "achète des tomates, des oignons, puis du riz" est une liste, pas une séquence d'actions à exécuter l'une après l'autre). Utiliser à la place un appel LLM léger dédié (le même cerveau que Dialogue Rapide, coût quasi nul), qui renvoie une structure JSON stricte :
{"steps": [
{"action": "lance la chasse produit sur les coussins ergonomiques", "wait_for_previous": false},
{"action": "lance le Juge Produit sur les résultats de la chasse ci-dessus", "wait_for_previous": true}
]}
Si un seul step est détecté, comportement actuel inchangé (zéro régression pour l'écrasante majorité des consignes, qui sont déjà atomiques).
_global_missionsNouvelle structure _global_plans[plan_id] avec un steps_ledger — c'est exactement le champ déjà recommandé dans l'analyse du jour sur la mémoire inter-missions, mais appliqué ici à l'intérieur d'une seule consigne :
{
"id": "plan_...",
"steps_ledger": [
{"action": "...", "mission_id": null, "status": "pending", "resultat_cle": null, "ts": null},
{"action": "...", "mission_id": null, "status": "pending", "resultat_cle": null, "ts": null}
],
"current_step": 0
}
Persisté sur disque selon le même patron que _save_persisted_missions() (déjà en place) — donc une coupure serveur ou une reconnexion vocale en plein milieu de l'étape A n'efface pas le plan : au redémarrage, le step déjà marqué "done" n'est pas rejoué, le séquenceur reprend directement à l'étape suivante.
deliver_cb, pas de nouvelle boucle d'attente active_run_mission(mission_id, instruction, brain, deliver_cb) appelle déjà deliver_cb à la toute fin (section "4. RESTITUTION VOCALE" et le _deliver passé en l.5078-5080 pour la livraison audio). Il suffit de brancher un deliver_cb spécifique au séquenceur : à la complétion du step i (succès vérifié via is_mission_success(), déjà existant), le callback :
1. Met à jour steps_ledger[i] (statut, résultat clé — pas le texte tronqué, le résultat structuré du rapport si présent),
2. Annonce vocalement la transition ("Étape 1 terminée : chasse produit, 5 candidats trouvés. Je lance maintenant le Juge.") — conforme à la règle 11 du CLAUDE.md sur la restitution vocale,
3. Si échec : arrête la chaîne, annonce l'échec de l'étape précisément, n'enchaîne jamais B à l'aveugle sur un A raté,
4. Si succès et qu'il reste un step : appelle dispatch_mission() pour le step i+1, en injectant dans son instruction le résultat clé du step précédent (pas tout l'historique brut) : "Le Juge doit évaluer les produits suivants, trouvés par la chasse précédente : [liste]."
Pas de polling, pas de thread d'attente actif consommant des ressources — le déclenchement du step suivant est événementiel, porté par le callback de fin de mission qui existe déjà dans l'architecture.
Remplacer le re.search unique (l.5067) par un re.finditer qui capture toutes les balises [DELEGUER: ...] dans leur ordre d'apparition, et nettoyer chaque occurrence du texte final (pas seulement une balise ancrée en tête, l.5058). Chaque balise capturée devient un step du même séquenceur décrit en 3.3 plutôt que d'exécuter la première et de perdre les suivantes.
feedback_rafale_sous_agents_lourds_epuise_quota) : une consigne vocale ne doit pas pouvoir générer une chaîne de missions non bornée qui épuise le quota de session partagé._global_missions à part entière (visible, annulable, traçable dans le dashboard existant) — le plan n'est qu'une couche d'orchestration par-dessus, pas un nouveau système opaque.workflow_architect (règle 14 du CLAUDE.md) pour arbitrer la forme technique exacte (nouvelle fonction MCP dédiée, extension de dispatch_mission, ou pipeline DAG) — non fait ici, il s'agit d'une étude, pas d'un chantier engagé.Effort technique : modéré. Aucune nouvelle dépendance externe ; réutilise dispatch_mission, is_mission_success, _global_missions, le patron de persistance JSON et le mécanisme deliver_cb déjà en place. Le travail réel se concentre sur : (a) l'étape de décomposition LLM légère, (b) l'objet _global_plans + sa persistance, (c) le séquenceur événementiel qui enchaîne les dispatch_mission(), (d) le fix ponctuel re.search→re.finditer en Dialogue Rapide.
Risque principal : les faux positifs/négatifs de la décomposition (confondre une liste simple avec une vraie séquence d'actions) — à mitiger par un LLM classifieur plutôt qu'une heuristique regex, et par une confirmation vocale explicite du plan détecté avant de le lancer ("Je vais d'abord lancer la chasse, puis le Juge une fois les résultats prêts — c'est bien ça ?") pour les plans à 2+ étapes, évitant qu'un mauvais découpage parte en exécution sans supervision.
Aucune action engagée — cette analyse attend la décision de Raphaël, puis l'arbitrage workflow_architect, avant toute ligne de code.