Généré le 13/10/2026 18:10

Analyse de faisabilité — Enchaînement séquentiel de plusieurs actions dans une seule consigne vocale ("fais A, puis B, puis C")

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.


1. Diagnostic — pourquoi "fais A, puis B, puis C" échoue aujourd'hui

1.1 Zéro décomposition en amont : toute la phrase part comme UN seul bloc de texte

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.

1.2 Mode mission ("Projet Partagé") : un seul appel bloquant, isolé par conception

_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.

1.3 Chaînage conditionnel inter-missions : mécaniquement impossible

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.

1.4 Mode Dialogue Rapide : encore plus limité, bug concret identifié

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.

1.5 Aucune structure de plan/file d'attente d'actions persistante

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.

1.6 Mémoire inter-tours : résumé tronqué, pas un état d'avancement fidèle

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.


2. Scénarios d'échec concrets que ce diagnostic explique


3. Architecture proposée — Séquenceur de plan d'actions

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.

3.1 Étape 0 — détection et décomposition (avant tout dispatch)

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).

3.2 Objet "plan" persistant, miroir du patron _global_missions

Nouvelle 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.

3.3 Le séquenceur lui-même : réutilisation de 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.

3.4 Correction du bug Dialogue Rapide (indépendante, à corriger de toute façon)

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.

3.5 Garde-fous


4. Estimation et conclusion

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.