> ## Documentation Index > Fetch the complete documentation index at: https://avala.ai/docs/llms.txt > Use this file to discover all available pages before exploring further. # Schéma des métadonnées de séquence > L'étiquette de résultat de chaque séquence, la façon dont la validité technique est rapportée, et comment lire, écrire et exporter les deux Chaque séquence porte deux types de métadonnées distincts : * **Validité technique.** L'enregistrement est-il exploitable ? Avala la rapporte à partir des critères d'acceptation et des objectifs de qualité. Consultez la section Validité technique. * **Résultat comportemental.** Qu'a fait la personne ou le robot, et la tâche a-t-elle réussi ? Avala le stocke comme **étiquette de résultat** de la séquence. Une séquence peut être techniquement valide et montrer quand même une défaillance. Une séquence en échec est souvent la plus utile. Les deux axes restent séparés : un filtre sur les données propres ne supprime jamais une défaillance utile, et un filtre sur la réussite ne masque jamais un capteur défectueux. ## L'étiquette de résultat Chaque séquence a au plus une étiquette de résultat courante. Chaque écriture enregistre une nouvelle version. Les versions précédentes restent lisibles dans l'historique de l'étiquette. ### Exemple Voici l'étiquette d'une démonstration humaine avec un glissement et une récupération, telle que `GET .../sequences//outcome/` la renvoie : ```json theme={null} { "uid": "", "sequence_uid": "", "version": 2, "is_current": true, "outcome": "mistake_and_recovery", "progress": 1.0, "quality": 4, "speed": 3, "subtasks": [ { "label": "Load the plate into the lower rack", "start_ts": 0.0, "end_ts": 19.8, "outcome": "mistake_and_recovery" }, { "label": "Pull out the lower rack", "start_ts": 0.0, "end_ts": 6.2, "outcome": "expert_success" }, { "label": "Place the wet plate in a free slot", "start_ts": 6.2, "end_ts": 19.8, "outcome": "mistake_and_recovery" } ], "hand_actions": { "left": [ { "start_ts": 0.0, "end_ts": 6.2, "action": "pulling the lower rack out by its front edge", "object": "dishwasher rack", "verb": "pull", "contact": true }, { "start_ts": 6.2, "end_ts": 19.8, "action": "holding the rack steady", "object": "dishwasher rack", "verb": "hold", "contact": true } ], "right": [ { "start_ts": 6.2, "end_ts": 9.1, "action": "carrying the wet plate to the rack", "object": "plate", "verb": "carry", "contact": true }, { "start_ts": 9.1, "end_ts": 10.4, "action": "the plate slips out of the grasp", "object": "plate", "verb": null, "contact": false }, { "start_ts": 10.4, "end_ts": 14.7, "action": "regrasping the plate by its rim", "object": "plate", "verb": "grasp", "contact": true }, { "start_ts": 14.7, "end_ts": 19.8, "action": "placing the plate in a free slot", "object": "plate", "verb": "place", "contact": true } ] }, "mistake_type": "slip_during_place", "recovery_type": "regrasp", "failure_stage": "place", "autonomy_level": "human_demonstration", "model_version": "", "evaluation_membership": "train", "leakage_groups": { "location": "loc_8f2a", "object": "obj_set_31", "mechanism": "dishwasher_pull_rack_v2", "operator": "op_5c1e", "environment_family": "kitchen_galley" }, "source": "human", "source_metadata": {}, "labeled_by": "", "confidence": null, "created_at": "2026-09-30T17:42:11.204000Z", "updated_at": "2026-09-30T17:42:11.204000Z" } ``` Les valeurs illustrent la forme de l'étiquette. Elles ne décrivent pas une livraison réelle. ### Champs Tous les horodatages sont exprimés en secondes depuis le début de la séquence. | Champ | Type | Signification | | - | - | - | | `uid` | chaîne | Identifiant de cette version de l'étiquette. Lecture seule. | | `sequence_uid` | chaîne | La séquence à laquelle appartient l'étiquette. Lecture seule. | | `version` | entier | Version de l'étiquette, à partir de 1. Chaque écriture l'augmente de un. Lecture seule. | | `is_current` | booléen | `true` pour la version courante. Lecture seule. | | `outcome` | chaîne | Le résultat comportemental. Obligatoire. Consultez la section Valeurs de résultat. | | `progress` | nombre ou null | Progression de la tâche, de 0 à 1. | | `quality` | entier ou null | Qualité d'exécution, de 1 à 5. | | `speed` | entier ou null | Vitesse d'exécution, de 1 à 5. | | `subtasks` | liste | Plages temporelles étiquetées. Consultez la section Sous-tâches. | | `hand_actions` | objet | Flux d'actions par main, `left` et `right`. Consultez la section Actions des mains. | | `mistake_type` | chaîne | Votre libellé pour le type d'erreur. Jusqu'à 128 caractères. Vide lorsqu'il n'est pas défini. | | `recovery_type` | chaîne | Votre libellé pour le type de récupération. Jusqu'à 128 caractères. Vide lorsqu'il n'est pas défini. | | `failure_stage` | chaîne | Votre libellé pour l'étape où la défaillance s'est produite. Jusqu'à 128 caractères. Vide lorsqu'il n'est pas défini. | | `autonomy_level` | chaîne | Qui avait le contrôle. Consultez la section Niveau d'autonomie. Vide lorsqu'il n'est pas défini. | | `model_version` | chaîne | La version de la politique ou du modèle qui a piloté le robot. Jusqu'à 255 caractères. Vide pour les démonstrations humaines. | | `evaluation_membership` | chaîne | `train`, `held_out_eval` ou `none`. Vide lorsqu'il n'est pas défini. Consultez la section Appartenance à l'évaluation. | | `leakage_groups` | objet | Identifiants de groupe pour garder des séparations propres. Consultez la section Groupes de fuite. | | `source` | chaîne | Qui a écrit l'étiquette : `human`, `model` ou `imported`. Par défaut : `human`. | | `source_metadata` | objet | Provenance de l'import. Consultez la section Métadonnées de source. | | `labeled_by` | chaîne ou null | UID de l'utilisateur qui a écrit la version. Renvoyé uniquement aux appelants qui peuvent modifier le jeu de données. Lecture seule. | | `confidence` | nombre ou null | Confiance du modèle, de 0 à 1. Acceptée uniquement lorsque `source` vaut `model`. | | `created_at`, `updated_at` | chaîne | Horodatages de la version. Lecture seule. | `mistake_type`, `recovery_type` et `failure_stage` sont du texte libre. Utilisez les libellés de la taxonomie des défaillances de votre programme pour que les séquences se regroupent proprement. ### Valeurs de résultat | Résultat | Signification | | - | - | | `expert_success` | La tâche est terminée. L'exécution est fluide et à un rythme d'expert. | | `slow_success` | La tâche est terminée. L'exécution est correcte et nettement plus lente que le rythme d'expert. | | `partial_success` | Une partie de la tâche est terminée. L'état final visé n'est pas atteint. | | `mistake_and_recovery` | Une erreur survient, comme un glissement, un raté ou un mauvais placement. La personne ou le robot se rattrape sans aide extérieure et termine la tâche. | | `intervention` | Un humain intervient pour corriger ou terminer la tâche. | | `unsafe` | La séquence contient une action ou un état dangereux. | | `aborted` | La tentative s'arrête avant la fin de la tâche, sans récupération. | | `failure` | La tentative se termine sans que la tâche soit accomplie. | | `novel_strategy` | La tâche est résolue de manière valide, différente de la stratégie habituelle. | | `inefficient_strategy` | La tâche est résolue avec des mouvements superflus évitables, des tentatives répétées ou des détours. | Chaque sous-tâche peut porter son propre résultat, tiré de la même liste. ### Niveau d'autonomie | Valeur | Signification | | - | - | | `human_demonstration` | Une personne réalise la tâche. | | `teleoperation` | Une personne pilote le robot à distance. | | `autonomous` | Le robot fonctionne avec sa politique. | | `shared_autonomy` | La politique et une personne se partagent le contrôle. | | `intervention` | Une personne prend le relais de la politique pendant la séquence. | ### Sous-tâches Chaque sous-tâche a la forme `{label, start_ts, end_ts, outcome}`. | Champ | Règle | | - | - | | `label` | Description de la sous-tâche en langage naturel. Obligatoire. De 1 à 500 caractères. | | `start_ts`, `end_ts` | Nombres finis, supérieurs ou égaux à 0. `end_ts` est au moins égal à `start_ts`. | | `outcome` | Une valeur de résultat, ou `null`. | Une étiquette contient au plus 256 sous-tâches. La liste doit être triée par `start_ts`. Deux sous-tâches sont soit disjointes, soit l'une contient entièrement l'autre, comme une phase et ses étapes. Des extrémités qui se touchent comptent comme disjointes. Un chevauchement partiel est rejeté. Lorsque deux sous-tâches commencent au même instant, placez d'abord celle qui englobe l'autre. ### Actions des mains `hand_actions` contient deux flux indépendants, `left` et `right`. Chaque élément décrit ce que fait une main sur une plage temporelle. | Champ | Règle | | - | - | | `start_ts`, `end_ts` | Nombres finis, supérieurs ou égaux à 0. `end_ts` est au moins égal à `start_ts`. | | `action` | Description de l'action en langage naturel. Obligatoire. De 1 à 500 caractères. | | `object` | L'objet sur lequel la main agit. Facultatif. Jusqu'à 255 caractères. | | `verb` | Un verbe court pour l'action. Facultatif. Jusqu'à 64 caractères. | | `contact` | `true` lorsque la main touche l'objet, `false` lorsqu'elle ne le touche pas, `null` lorsque c'est inconnu. Seuls les booléens JSON sont acceptés. | * Pour une même main, les éléments sont triés par `start_ts` et ne doivent pas se chevaucher. Un élément commence à la fin du précédent ou après. Ils peuvent se toucher. * Les deux mains peuvent se chevaucher librement. * Chaque main contient au plus 3 600 éléments. Cela représente une heure à raison d'une étiquette par seconde. * `left` et `right` sont les seules clés. Vous pouvez omettre l'une ou l'autre. Une main omise est stockée comme une liste vide. * Un `object` ou un `verb` vide est stocké comme `null`. Chaque élément stocké possède les six champs. ### Durée de la séquence Lorsqu'Avala connaît la durée de la séquence, chaque `end_ts` de sous-tâche et chaque `end_ts` d'action de main doit être au plus égal à la durée plus 1 seconde. Cette seconde supplémentaire tient compte des étiquettes écrites à raison d'une par seconde. Avala connaît la durée lorsque la séquence a exactement un fichier MCAP extrait dont la durée est enregistrée. Pour les autres séquences, la vérification n'a pas lieu. ### Appartenance à l'évaluation `evaluation_membership` place la séquence dans une partition : | Valeur | Signification | | - | - | | `train` | La séquence peut servir à l'entraînement. | | `held_out_eval` | La séquence appartient à un ensemble d'évaluation mis de côté. Tenez-la à l'écart de l'entraînement. | | `none` | La séquence n'appartient à aucune des deux partitions. | Avala définit `held_out_eval` sur les séquences de chaque cohorte d'évaluation. Ces séquences n'apparaissent jamais dans une release d'entraînement. Consultez [Évaluation](/docs/fr/fleet-learning/evaluation.md). ### Groupes de fuite Les groupes de fuite empêchent des quasi-doublons de se retrouver des deux côtés d'une séparation entre entraînement et évaluation. `leakage_groups` accepte ces clés, chacune avec un identifiant de groupe de 255 caractères au plus : | Clé | Regroupe les séquences qui partagent | | - | - | | `location` | Le même logement, le même site ou la même pièce. | | `object` | Le même ensemble d'objets physiques. | | `mechanism` | Le même appareil ou la même unité de mécanisme. | | `operator` | Le même collecteur ou téléopérateur. | | `environment_family` | Le même type d'environnement et d'agencement, comme une cuisine en couloir. | Toute autre clé est rejetée. Chaque clé est facultative. Avala construit les cohortes d'évaluation de sorte qu'aucune valeur de groupe d'une cohorte n'apparaisse dans une release d'entraînement. Vous pouvez séparer vos propres données de la même façon : mettez de côté par groupe, jamais par séquence aléatoire. Les identifiants de groupe d'Avala sont pseudonymes : vous pouvez regrouper et séparer les séquences sans savoir qui ni où. ### Métadonnées de source `source_metadata` indique d'où vient une étiquette importée, par exemple `{"importer": "...", "run_id": "...", "task": "...", "log_path": "..."}`. * C'est un objet plat d'au plus 20 clés. * Chaque clé compte de 1 à 64 caractères. * Chaque valeur est une chaîne de 512 caractères au plus, un nombre fini ou un booléen. * Les objets imbriqués, les listes et les valeurs `null` sont rejetés. ### Fonctionnement des écritures * Une écriture remplace l'étiquette courante dans son ensemble et enregistre une nouvelle version. Tout champ facultatif que vous omettez est stocké comme non défini. Il n'est pas repris de la version précédente. * L'écriture nécessite un accès en modification au jeu de données. La lecture nécessite le même accès que la lecture de la séquence, y compris pour les jeux de données publics. * `confidence` est rejeté sauf si `source` vaut `model`. * La lecture d'une séquence sans étiquette renvoie `404`. ## Validité technique La validité technique ne fait pas partie de l'étiquette de résultat. Avala la rapporte à partir du moteur d'acceptation et des objectifs de qualité. Elle n'a pas de schéma JSON propre. **Critères d'acceptation.** Chaque capture d'une campagne de capture reçoit un verdict automatique : `accept`, `quarantine` ou `reject`. Le verdict découle de ces critères : | Critère | Ce qu'il vérifie | | - | - | | `capture_health` | Le fichier MCAP est valide et les canaux exigés par la campagne sont présents. | | `frame_rate` | La fréquence d'images de la caméra se maintient sur tout le clip, sans effondrement prolongé. | | `completeness` | La durée est proche de celle demandée par la campagne. | | `framing` | Les mains sont visibles pendant une part suffisante du temps observé par le détecteur. | | `shake` | La caméra ne tremble pas pendant la majeure partie du clip. | Chaque critère rapporte `pass`, `fail`, `insufficient_evidence` ou `skipped`. Un critère en échec enregistre un code de motif, comme `acceptance_frame_rate_drop` ou `hands_not_visible`. Un réviseur confirme ensuite le verdict ou le remplace. Les codes de motif sont listés dans [Heure acceptée](/docs/fr/fleet-learning/accepted-hour.md). Lisez l'acceptation avec les outils MCP `get_result_acceptance` pour une capture et `get_campaign_acceptance_summary` pour une campagne. `list_capture_submissions` inclut la synthèse d'acceptation automatique de chaque capture. **Objectifs de qualité.** Un projet peut fixer des seuils sur des métriques de qualité, comme le taux d'acceptation, le taux de rejet et le taux de problèmes. Avala émet une alerte lorsqu'une métrique franchit son seuil. Lisez-les avec l'outil MCP `list_quality_targets`. Les vérifications du programme qui ne sont pas des critères automatiques, comme la calibration, le consentement et la synchronisation des horodatages, sont rapportées comme motifs de rejet dans le [rapport de couverture](/docs/fr/fleet-learning/coverage.md). Consultez [Heure acceptée](/docs/fr/fleet-learning/accepted-hour.md). ## Lire et écrire les étiquettes de résultat Les endpoints REST se trouvent sous `https://api.avala.ai/api/v1` : | Méthode et chemin | Rôle | | - | - | | `GET /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/` | Étiquette courante d'une séquence. `404` si la séquence n'a pas d'étiquette. | | `PUT /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/` | Enregistre une nouvelle étiquette courante. | | `GET /datasets/{owner}/{slug}/sequences/{sequence_uid}/outcome/history/` | Toutes les versions de l'étiquette, de la plus récente à la plus ancienne. | | `GET /datasets/{owner}/{slug}/sequence-outcomes/` | Étiquettes courantes d'un jeu de données, paginées. | La liste du jeu de données accepte les filtres `outcome`, `evaluation_membership`, `source` et `autonomy_level`. Chacun prend une valeur ou une liste séparée par des virgules, et une séquence correspond si elle a l'une des valeurs de la liste. `model_version` correspond à une seule version exacte. Une valeur de filtre inconnue renvoie `400`. La liste des séquences, `GET /datasets/{owner}/{slug}/sequences/`, accepte `outcome` et `evaluation_membership` sous la même forme. Elle renvoie les séquences dont l'étiquette courante correspond. ### Écrire une étiquette ```bash cURL theme={null} curl -X PUT \ "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences//outcome/" \ -H "X-Avala-Api-Key: $AVALA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "outcome": "failure", "progress": 0.4, "subtasks": [ { "label": "Place the plate in the lower rack", "start_ts": 0.0, "end_ts": 21.5, "outcome": "failure" } ], "mistake_type": "slip_during_place", "failure_stage": "place", "autonomy_level": "autonomous", "model_version": "your-policy@2026-09-20", "evaluation_membership": "held_out_eval", "source": "imported", "source_metadata": { "importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher" } }' ``` ```python Python theme={null} from avala import Client client = Client() # reads AVALA_API_KEY label = client.sequence_outcomes.set( "your-org", "kitchen-rollouts", "", outcome="failure", progress=0.4, subtasks=[ {"label": "Place the plate in the lower rack", "start_ts": 0.0, "end_ts": 21.5, "outcome": "failure"}, ], mistake_type="slip_during_place", failure_stage="place", autonomy_level="autonomous", model_version="your-policy@2026-09-20", evaluation_membership="held_out_eval", source="imported", source_metadata={"importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher"}, ) print(label.version, label.outcome) ``` ```typescript TypeScript theme={null} import Avala from "@avala-ai/sdk"; const avala = new Avala(); // reads AVALA_API_KEY const label = await avala.sequenceOutcomes.set("your-org", "kitchen-rollouts", "", { outcome: "failure", progress: 0.4, subtasks: [{ label: "Place the plate in the lower rack", startTs: 0.0, endTs: 21.5, outcome: "failure" }], mistakeType: "slip_during_place", failureStage: "place", autonomyLevel: "autonomous", modelVersion: "your-policy@2026-09-20", evaluationMembership: "held_out_eval", source: "imported", sourceMetadata: { importer: "your-eval-harness", run_id: "r42", task: "load_dishwasher" }, }); console.log(label.version, label.outcome); ``` ```bash CLI theme={null} avala sequence-outcomes set your-org kitchen-rollouts \ --outcome failure \ --progress 0.4 \ --subtasks-file subtasks.json \ --mistake-type slip_during_place \ --failure-stage place \ --autonomy-level autonomous \ --model-version your-policy@2026-09-20 \ --evaluation-membership held_out_eval \ --source imported \ --source-metadata '{"importer": "your-eval-harness", "run_id": "r42", "task": "load_dishwasher"}' ``` Le SDK TypeScript prend des noms d'options en camelCase et envoie les champs en snake\_case de l'API. Les clés à l'intérieur de `sourceMetadata` sont envoyées telles quelles. Dans la CLI, `--hand-actions-file` prend un fichier JSON de la forme `{"left": [...], "right": [...]}`, et `--leakage-group KEY=ID` peut être répété. ### Lire les étiquettes ```bash cURL theme={null} # Current label of one sequence curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences//outcome/" \ -H "X-Avala-Api-Key: $AVALA_API_KEY" # Every version, newest first curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences//outcome/history/" \ -H "X-Avala-Api-Key: $AVALA_API_KEY" # Failed or aborted held-out sequences curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequence-outcomes/?outcome=failure,aborted&evaluation_membership=held_out_eval" \ -H "X-Avala-Api-Key: $AVALA_API_KEY" # The sequences themselves, filtered by their current label curl "https://api.avala.ai/api/v1/datasets/your-org/kitchen-rollouts/sequences/?outcome=mistake_and_recovery,intervention" \ -H "X-Avala-Api-Key: $AVALA_API_KEY" ``` ```python Python theme={null} from avala import Client client = Client() label = client.sequence_outcomes.get("your-org", "kitchen-rollouts", "") versions = client.sequence_outcomes.history("your-org", "kitchen-rollouts", "") page = client.sequence_outcomes.list( "your-org", "kitchen-rollouts", outcome=["failure", "aborted"], evaluation_membership="held_out_eval", model_version="your-policy@2026-09-20", ) for item in page: print(item.sequence_uid, item.outcome, item.progress) ``` ```typescript TypeScript theme={null} import Avala from "@avala-ai/sdk"; const avala = new Avala(); const label = await avala.sequenceOutcomes.get("your-org", "kitchen-rollouts", ""); const versions = await avala.sequenceOutcomes.history("your-org", "kitchen-rollouts", ""); const page = await avala.sequenceOutcomes.list("your-org", "kitchen-rollouts", { outcome: ["failure", "aborted"], evaluationMembership: "held_out_eval", modelVersion: "your-policy@2026-09-20", }); for (const item of page.items) { console.log(item.sequenceUid, item.outcome, item.progress); } ``` ```bash CLI theme={null} avala sequence-outcomes get your-org kitchen-rollouts avala sequence-outcomes history your-org kitchen-rollouts avala sequence-outcomes list your-org kitchen-rollouts \ --outcome failure,aborted \ --evaluation-membership held_out_eval ``` La liste du jeu de données renvoie jusqu'à 100 étiquettes par page. Passez le `cursor` de la page précédente pour continuer. ### Lire les étiquettes avec le serveur MCP Le serveur MCP lit les étiquettes de résultat. Il ne les écrit pas. * `get_sequence_outcome` prend `owner`, `slug` et `sequenceUid`. Il renvoie l'étiquette courante. * `list_sequence_outcomes` prend `owner` et `slug`, plus les filtres `outcome`, `evaluationMembership`, `source`, `autonomyLevel` et `modelVersion`, ainsi que `limit` et `cursor`. Les deux outils renvoient une forme courte par défaut. Passez `detail: "full"` pour inclure les sous-tâches, les actions des mains, les libellés d'erreur et de récupération, les groupes de fuite, les métadonnées de source et l'auteur de l'étiquette. Consultez [Utiliser Avala avec l'IA](/docs/fr/getting-started/mcp.md) pour vous connecter. ## Exporter les étiquettes de résultat avec LeRobot L'exportateur LeRobot peut écrire l'étiquette de résultat courante de chaque séquence à côté du jeu de données. Une séquence Avala devient un épisode LeRobot. ```bash CLI theme={null} avala lerobot export your-org/kitchen-rollouts \ --repo-id your-hf-user/kitchen-rollouts \ --output ./lerobot-out \ --include-outcomes ``` ```python Python theme={null} from avala import Client from avala.lerobot import export_dataset export_dataset( Client(), "your-org", "kitchen-rollouts", repo_id="your-hf-user/kitchen-rollouts", output_dir="./lerobot-out", include_outcomes=True, ) ``` Les étiquettes sont écrites dans `meta/avala_sequence_outcomes.jsonl`, avec un objet JSON par ligne et une ligne par épisode LeRobot enregistré. La table des épisodes de LeRobot n'a pas de place pour ces métadonnées, d'où ce fichier séparé. Chaque ligne contient ces clés : | Clé | Valeur | | - | - | | `episode_index` | L'indice de l'épisode LeRobot. | | `avala_sequence_uid` | La séquence Avala dont provient l'épisode. | | `outcome` | La valeur de résultat, ou `null` lorsque la séquence n'a pas d'étiquette. | | `outcome_version` | La version de l'étiquette qui a été exportée. | | `progress`, `quality`, `speed` | Comme dans l'étiquette. | | `subtasks`, `hand_actions` | Comme dans l'étiquette. Les horodatages sont exprimés en secondes depuis le début de l'épisode. | | `mistake_type`, `recovery_type`, `failure_stage`, `autonomy_level`, `model_version`, `evaluation_membership` | Comme dans l'étiquette, avec `null` à la place d'une valeur vide. | | `leakage_groups` | Comme dans l'étiquette. | | `outcome_source`, `outcome_source_metadata`, `outcome_confidence` | Les champs `source`, `source_metadata` et `confidence` de l'étiquette. | Une séquence sans étiquette reçoit une ligne avec seulement `episode_index`, `avala_sequence_uid` et `"outcome": null`. ## La voie défaillance et récupération Les défaillances récupérables sont livrées dans leur propre voie : les séquences dont le résultat est `mistake_and_recovery` ou `intervention`. Les sous-tâches et les actions des mains de chaque séquence indiquent où se produisent la défaillance et la récupération. La voie est livrée comme une slice distincte dans la release. Vous pouvez l'utiliser pour l'entraînement, la pondérer ou l'exclure. Vous pouvez aussi construire vous-même le même ensemble avec `?outcome=mistake_and_recovery,intervention`. Les séquences dangereuses ne font pas partie de la voie.