@cat-factory/app 0.197.0 → 0.198.0

package/i18n/locales/de.json

@@ -5956,12 +5956,42 @@
             "title": "Board-Steuerung",
             "body": "Mit diesen Steuerelementen zoomst du hinein und heraus oder bringst das ganze Board ins Bild."
           },
+          "interfaceTier": {
+            "title": "Einfach und erweitert",
+            "body": "Die Oberfläche startet im einfachen Modus, der die alltäglichen Arbeitsflächen zeigt. Wechsle hier auf erweitert, wenn du zusätzlich die Flächen für Experimente, Bootstrap und Betrieb brauchst."
+          },
           "finish": {
             "title": "Das war die Übersicht",
             "body": "Jetzt kennst du dich aus. Probiere die nächste Tour, um deine erste Aufgabe zu erstellen und auszuführen, oder komm später über die Befehlspalette zurück."
           }
         }
       },
+      "addService": {
+        "title": "Erstes Repository hinzufügen",
+        "description": "Verknüpfe ein Repository, damit das Board einen Service hat, für den du Arbeit planen kannst.",
+        "steps": {
+          "intro": {
+            "title": "Beginne mit einem Repository",
+            "body": "Arbeit passiert am Code, also braucht ein Board mindestens einen Service, bevor ein Agent irgendwo arbeiten kann. Diese Tour verknüpft einen."
+          },
+          "open": {
+            "title": "Service aus Repository",
+            "body": "Das öffnet die Repository-Auswahl. Sie listet die Repositories, die die Verbindung dieses Workspace sehen kann."
+          },
+          "search": {
+            "title": "Repository auswählen",
+            "body": "Suche nach einem deiner eigenen Repositories. Wenn du lieber an etwas Kleinem üben möchtest: {repo} ist ein Beispiel-Service, der für diese Touren absichtlich unfertig bleibt."
+          },
+          "add": {
+            "title": "Hinzufügen",
+            "body": "Das Repository wird zu einem Service-Rahmen auf dem Board. Später kannst du weitere hinzufügen, in einem Monorepo auch einen Service pro Ordner."
+          },
+          "finish": {
+            "title": "Du hast einen Service",
+            "body": "In diesem Rahmen leben die Aufgaben. Die nächste Tour legt eine hinein."
+          }
+        }
+      },
       "firstTask": {
         "title": "Erstelle deine erste Aufgabe",
         "description": "Füge einem Service eine Aufgabe hinzu und sieh zu, wie sie auf dem Board erscheint.",
@@ -5991,6 +6021,96 @@
             "body": "Das ist der Kernablauf: Aufgabe beschreiben, ausführen, Ergebnis prüfen. Entdecke die weiteren Touren, wann immer du magst."
           }
         }
+      },
+      "runTask": {
+        "title": "Aufgabe ausführen",
+        "description": "Öffne eine Aufgabe, wähle ihre Pipeline und lass die Agenten loslegen.",
+        "steps": {
+          "intro": {
+            "title": "Von der Aufgabe zum Lauf",
+            "body": "Eine Aufgabe auf dem Board ist eine Anfrage. Wenn du sie öffnest, siehst du die Pipeline, die sie liefert, und die Bedienelemente, die sie starten."
+          },
+          "openTask": {
+            "title": "Aufgabe öffnen",
+            "body": "Ein Klick auf eine Karte öffnet ihren Inspektor, in dem alles zu dieser Aufgabe steht."
+          },
+          "inspector": {
+            "title": "Der Inspektor",
+            "body": "Status, Repository, Pipeline und der Lauf selbst: dieses Panel ist die ganze Geschichte der Aufgabe."
+          },
+          "pipeline": {
+            "title": "Pipeline wählen",
+            "body": "Eine Pipeline ist die Abfolge von Agenten, die die Arbeit erledigen: Spezifikation schreiben, umsetzen, prüfen, Checks laufen lassen, mergen. Wähle die, die zur Aufgabe passt."
+          },
+          "start": {
+            "title": "Einen Lauf starten",
+            "body": "Das startet die Pipeline wirklich, und Agenten verbrauchen Modellbudget. Deshalb bleibt der Klick bei dir: drücke ihn, wann du bereit bist, während dieser Tour oder danach."
+          },
+          "steps": {
+            "title": "Beim Arbeiten zusehen",
+            "body": "Jeder Schritt meldet seinen Fortschritt hier, live übertragen. Klicke einen Schritt an, um zu lesen, was der Agent tatsächlich produziert hat."
+          },
+          "finish": {
+            "title": "Das ist der Kreislauf",
+            "body": "Aufgabe planen, Pipeline wählen, starten, zusehen. Wenn ein Lauf etwas von dir braucht, hält er an und sagt es, was die nächste Tour behandelt."
+          }
+        }
+      },
+      "answerPark": {
+        "title": "Wartenden Lauf beantworten",
+        "description": "Ein Lauf pausiert und wartet auf einen Menschen. Sieh, wo er fragt und wie du antwortest.",
+        "steps": {
+          "intro": {
+            "title": "Ein Lauf wartet auf dich",
+            "body": "Manche Schritte halten an und fragen: eine Rückfrage zu den Anforderungen, ein Plan zur Freigabe, eine Wahl zwischen Ansätzen. Ein pausierter Lauf wartet unbegrenzt auf eine Antwort, also bewegt sich nichts, bis du antwortest."
+          },
+          "resolve": {
+            "title": "Wo er fragt",
+            "body": "Eine Aufgabe, die auf einen Menschen wartet, zeigt das auf ihrer Karte und bietet diese Aktion an. Sie bringt dich direkt zu dem, was gefragt wird."
+          },
+          "decide": {
+            "title": "Eine Antwort wählen",
+            "body": "Jede Option ist eine echte Anweisung an den Lauf: wähle eine, und die Pipeline macht mit deiner Wahl weiter."
+          },
+          "approve": {
+            "title": "Die Arbeit freigeben",
+            "body": "Gib frei, damit der Lauf weitergeht, oder fordere Änderungen an, um den Schritt mit deinen Anmerkungen zurückzuschicken. Beides sind Antworten, und der Lauf läuft so oder so weiter."
+          },
+          "finish": {
+            "title": "Nichts wartet stillschweigend",
+            "body": "Wartende Aufgaben sind auf dem Board markiert und in der Werkzeugleiste gezählt, damit du sie findest, ohne zu suchen."
+          }
+        }
+      },
+      "reviewMerge": {
+        "title": "Prüfen und mergen",
+        "description": "Lies, was ein fertiger Lauf produziert hat, und bring es in den Hauptzweig.",
+        "steps": {
+          "intro": {
+            "title": "Ein Lauf ist fertig",
+            "body": "Fertig ist nicht dasselbe wie ausgeliefert. Eine Aufgabe ist erledigt, wenn ihr Pull Request gemergt ist, also geht es hier um die letzte Meile."
+          },
+          "openTask": {
+            "title": "Aufgabe öffnen",
+            "body": "Öffne eine Aufgabe, deren Lauf fertig ist. Ihr Inspektor enthält die vollständige Schrittliste."
+          },
+          "openStep": {
+            "title": "Schritt öffnen",
+            "body": "Ein Klick auf einen Schritt zeigt, was dieser Agent produziert hat: seinen Bericht, seine Befunde und was er geändert hat."
+          },
+          "result": {
+            "title": "Das Ergebnis lesen",
+            "body": "Das ist die eigene Darstellung des Agenten. Review-Schritte listen Befunde, ein Tester meldet Urteile, der Merger erklärt, wie er die Änderung bewertet hat."
+          },
+          "merge": {
+            "title": "Mergen",
+            "body": "Wenn ein Lauf einen Pull Request öffnet, bietet der Inspektor hier den Merge an. Eine Pipeline mit Merger-Schritt kann auch selbst mergen, wenn die Änderung über deinem Schwellenwert liegt."
+          },
+          "finish": {
+            "title": "Ausgeliefert",
+            "body": "Gemergte Arbeit markiert die Aufgabe auf dem Board als erledigt. Das ist der ganze Kreislauf: planen, ausführen, antworten, prüfen, mergen."
+          }
+        }
       }
     }
   }

package/i18n/locales/en.json

@@ -6163,12 +6163,45 @@
             "title": "Board controls",
             "body": "Zoom in and out or fit the whole board into view with these controls."
           },
+          "interfaceTier": {
+            "title": "Basic and advanced",
+            "body": "The interface starts in basic mode, which shows the everyday delivery surfaces. Switch to advanced here when you also want the experimentation, bootstrap and operator surfaces."
+          },
           "finish": {
             "title": "That's the layout",
             "body": "You know your way around now. Try the next tour to create and run your first task, or come back later via the command palette."
           }
         }
       },
+      "addService": {
+        "title": "Add your first repository",
+        "description": "Link a repository so the board has a service to plan work against.",
+        "steps": {
+          "intro": {
+            "title": "Start with a repository",
+            "body": "Work happens against code, so a board needs at least one service before an agent has anywhere to do it. This tour links one."
+          },
+          "open": {
+            "title": "Add service from repo",
+            "body": "This opens the repository picker. It lists the repositories this workspace's connection can see."
+          },
+          "search": {
+            "title": "Pick a repository",
+            "body": "Search for one of your own repositories. If you would rather practise on something small, {repo} is a sample service kept deliberately unfinished for these tours.",
+            "@body": {
+              "description": "{repo} is a repository slug (owner/name). Keep it verbatim, do not translate or reformat it."
+            }
+          },
+          "add": {
+            "title": "Add it",
+            "body": "The repository becomes a service frame on the board. You can add more later, including one service per folder of a monorepo."
+          },
+          "finish": {
+            "title": "You have a service",
+            "body": "That frame is where tasks live. The next tour puts one in it."
+          }
+        }
+      },
       "firstTask": {
         "title": "Create your first task",
         "description": "Add a task to a service and see it appear on the board.",
@@ -6198,6 +6231,96 @@
             "body": "That is the core loop: describe a task, run it, review the result. Explore the other tours whenever you like."
           }
         }
+      },
+      "runTask": {
+        "title": "Run a task",
+        "description": "Open a task, choose its pipeline and start the agents working.",
+        "steps": {
+          "intro": {
+            "title": "From task to run",
+            "body": "A task on the board is a request. Opening it shows the pipeline that will deliver it and the controls that start it."
+          },
+          "openTask": {
+            "title": "Open a task",
+            "body": "Clicking a card opens its inspector, which is where everything about that task lives."
+          },
+          "inspector": {
+            "title": "The inspector",
+            "body": "Status, repository, pipeline and the run itself: this panel is the task's whole story."
+          },
+          "pipeline": {
+            "title": "Choose a pipeline",
+            "body": "A pipeline is the sequence of agents that will do the work: write a spec, build it, review it, run the checks, merge it. Pick the one that fits the task."
+          },
+          "start": {
+            "title": "Starting a run",
+            "body": "This starts the pipeline for real, and agents spend model budget. So the click is yours to make: press it whenever you are ready, during this tour or after it."
+          },
+          "steps": {
+            "title": "Watching it work",
+            "body": "Every step reports its own progress here as it runs, pushed live. Click a step to read what the agent actually produced."
+          },
+          "finish": {
+            "title": "That is the loop",
+            "body": "Plan a task, pick a pipeline, start it, watch it. When a run needs something from you it pauses and says so, which the next tour covers."
+          }
+        }
+      },
+      "answerPark": {
+        "title": "Answer a waiting run",
+        "description": "A run has paused for a human. See where it asks, and how to reply.",
+        "steps": {
+          "intro": {
+            "title": "A run is waiting for you",
+            "body": "Some steps stop and ask: a question about the requirements, a plan to approve, a choice between approaches. A paused run waits for an answer indefinitely, so nothing moves until you reply."
+          },
+          "resolve": {
+            "title": "Where it asks",
+            "body": "A task waiting on a human says so on its card and offers this action. It takes you straight to whatever is being asked."
+          },
+          "decide": {
+            "title": "Choosing an answer",
+            "body": "Each option is a real instruction to the run: pick one and the pipeline carries on from there with your choice."
+          },
+          "approve": {
+            "title": "Approving the work",
+            "body": "Approve to let the run continue, or request changes to send the step back with your notes. Both are answers, and the run resumes either way."
+          },
+          "finish": {
+            "title": "Nothing waits silently",
+            "body": "Waiting tasks are marked on the board and counted in the toolbar, so you can find them without hunting."
+          }
+        }
+      },
+      "reviewMerge": {
+        "title": "Review and merge",
+        "description": "Read what a finished run produced, and get it merged.",
+        "steps": {
+          "intro": {
+            "title": "A run finished",
+            "body": "Finished is not the same as shipped. A task is done when its pull request is merged, so this tour is the last mile."
+          },
+          "openTask": {
+            "title": "Open the task",
+            "body": "Open a task whose run has finished. Its inspector holds the full step list."
+          },
+          "openStep": {
+            "title": "Open a step",
+            "body": "Clicking a step opens what that agent produced: its report, its findings and what it changed."
+          },
+          "result": {
+            "title": "Reading the result",
+            "body": "This is the agent's own account of the work. Review steps list findings, a tester reports verdicts, the merger explains how it scored the change."
+          },
+          "merge": {
+            "title": "Merging",
+            "body": "When a run opens a pull request, the inspector offers the merge here. A pipeline with a merger step can also merge for itself when the change scores above your threshold."
+          },
+          "finish": {
+            "title": "Shipped",
+            "body": "Merged work marks the task done on the board. That is the whole loop: plan, run, answer, review, merge."
+          }
+        }
       }
     }
   }

package/i18n/locales/es.json

@@ -5944,12 +5944,42 @@
             "title": "Controles del tablero",
             "body": "Con estos controles acercas, alejas o ajustas todo el tablero a la vista."
           },
+          "interfaceTier": {
+            "title": "Básico y avanzado",
+            "body": "La interfaz arranca en modo básico, que muestra las superficies del trabajo diario. Cambia aquí a avanzado cuando también quieras las de experimentación, arranque de repositorios y operación."
+          },
           "finish": {
             "title": "Eso es todo",
             "body": "Ya sabes orientarte. Prueba el siguiente recorrido para crear y ejecutar tu primera tarea, o vuelve más tarde desde la paleta de comandos."
           }
         }
       },
+      "addService": {
+        "title": "Añade tu primer repositorio",
+        "description": "Vincula un repositorio para que el tablero tenga un servicio sobre el que planificar trabajo.",
+        "steps": {
+          "intro": {
+            "title": "Empieza por un repositorio",
+            "body": "El trabajo ocurre sobre código, así que un tablero necesita al menos un servicio antes de que un agente tenga dónde trabajar. Este recorrido vincula uno."
+          },
+          "open": {
+            "title": "Añadir servicio desde repositorio",
+            "body": "Esto abre el selector de repositorios. Lista los repositorios que la conexión de este espacio de trabajo puede ver."
+          },
+          "search": {
+            "title": "Elige un repositorio",
+            "body": "Busca uno de tus propios repositorios. Si prefieres practicar con algo pequeño, {repo} es un servicio de ejemplo que se mantiene sin terminar a propósito para estos recorridos."
+          },
+          "add": {
+            "title": "Añádelo",
+            "body": "El repositorio pasa a ser un marco de servicio en el tablero. Después puedes añadir más, incluido un servicio por carpeta en un monorrepo."
+          },
+          "finish": {
+            "title": "Ya tienes un servicio",
+            "body": "En ese marco viven las tareas. El siguiente recorrido coloca una dentro."
+          }
+        }
+      },
       "firstTask": {
         "title": "Crea tu primera tarea",
         "description": "Añade una tarea a un servicio y mírala aparecer en el tablero.",
@@ -5979,6 +6009,96 @@
             "body": "Ese es el ciclo principal: describir una tarea, ejecutarla y revisar el resultado. Explora los demás recorridos cuando quieras."
           }
         }
+      },
+      "runTask": {
+        "title": "Ejecutar una tarea",
+        "description": "Abre una tarea, elige su pipeline y pon a trabajar a los agentes.",
+        "steps": {
+          "intro": {
+            "title": "De la tarea a la ejecución",
+            "body": "Una tarea en el tablero es una petición. Al abrirla verás el pipeline que la entregará y los controles que lo arrancan."
+          },
+          "openTask": {
+            "title": "Abre una tarea",
+            "body": "Al hacer clic en una tarjeta se abre su inspector, donde está todo lo relativo a esa tarea."
+          },
+          "inspector": {
+            "title": "El inspector",
+            "body": "Estado, repositorio, pipeline y la propia ejecución: este panel es la historia completa de la tarea."
+          },
+          "pipeline": {
+            "title": "Elige un pipeline",
+            "body": "Un pipeline es la secuencia de agentes que hará el trabajo: escribir una especificación, construirla, revisarla, pasar las comprobaciones y fusionarla. Elige el que encaje con la tarea."
+          },
+          "start": {
+            "title": "Arrancar una ejecución",
+            "body": "Esto arranca el pipeline de verdad, y los agentes gastan presupuesto de modelo. Por eso el clic es tuyo: púlsalo cuando quieras, durante este recorrido o después."
+          },
+          "steps": {
+            "title": "Ver cómo avanza",
+            "body": "Cada paso informa aquí de su propio progreso, en directo. Haz clic en un paso para leer lo que el agente produjo realmente."
+          },
+          "finish": {
+            "title": "Ese es el ciclo",
+            "body": "Planificar una tarea, elegir un pipeline, arrancarla y seguirla. Cuando una ejecución necesita algo de ti se detiene y lo dice, que es lo que cubre el siguiente recorrido."
+          }
+        }
+      },
+      "answerPark": {
+        "title": "Responder a una ejecución en espera",
+        "description": "Una ejecución se ha detenido a esperar a una persona. Mira dónde pregunta y cómo responder.",
+        "steps": {
+          "intro": {
+            "title": "Una ejecución te está esperando",
+            "body": "Algunos pasos se detienen y preguntan: una duda sobre los requisitos, un plan que aprobar, una elección entre enfoques. Una ejecución en pausa espera respuesta indefinidamente, así que nada avanza hasta que contestes."
+          },
+          "resolve": {
+            "title": "Dónde pregunta",
+            "body": "Una tarea que espera a una persona lo indica en su tarjeta y ofrece esta acción. Te lleva directo a lo que se está preguntando."
+          },
+          "decide": {
+            "title": "Elegir una respuesta",
+            "body": "Cada opción es una instrucción real para la ejecución: elige una y el pipeline continúa desde ahí con tu decisión."
+          },
+          "approve": {
+            "title": "Aprobar el trabajo",
+            "body": "Aprueba para que la ejecución siga, o pide cambios para devolver el paso con tus notas. Ambas son respuestas, y la ejecución se reanuda en cualquier caso."
+          },
+          "finish": {
+            "title": "Nada espera en silencio",
+            "body": "Las tareas en espera se marcan en el tablero y se cuentan en la barra de herramientas, para que las encuentres sin buscarlas."
+          }
+        }
+      },
+      "reviewMerge": {
+        "title": "Revisar y fusionar",
+        "description": "Lee lo que produjo una ejecución terminada y consigue fusionarlo.",
+        "steps": {
+          "intro": {
+            "title": "Una ejecución ha terminado",
+            "body": "Terminado no es lo mismo que entregado. Una tarea está hecha cuando su pull request se fusiona, así que este recorrido es la última milla."
+          },
+          "openTask": {
+            "title": "Abre la tarea",
+            "body": "Abre una tarea cuya ejecución haya terminado. Su inspector contiene la lista completa de pasos."
+          },
+          "openStep": {
+            "title": "Abre un paso",
+            "body": "Al hacer clic en un paso se abre lo que produjo ese agente: su informe, sus hallazgos y lo que cambió."
+          },
+          "result": {
+            "title": "Leer el resultado",
+            "body": "Este es el relato del propio agente. Los pasos de revisión listan hallazgos, un tester informa de veredictos y el fusionador explica cómo puntuó el cambio."
+          },
+          "merge": {
+            "title": "Fusionar",
+            "body": "Cuando una ejecución abre una pull request, el inspector ofrece aquí la fusión. Un pipeline con paso de fusión también puede fusionar por su cuenta si el cambio supera tu umbral."
+          },
+          "finish": {
+            "title": "Entregado",
+            "body": "El trabajo fusionado marca la tarea como hecha en el tablero. Ese es el ciclo completo: planificar, ejecutar, responder, revisar y fusionar."
+          }
+        }
       }
     }
   }

package/i18n/locales/fr.json

@@ -5944,12 +5944,42 @@
             "title": "Contrôles du tableau",
             "body": "Ces contrôles permettent de zoomer ou d'ajuster tout le tableau à la vue."
           },
+          "interfaceTier": {
+            "title": "Simple et avancé",
+            "body": "L'interface démarre en mode simple, qui montre les surfaces de travail quotidiennes. Passez en avancé ici lorsque vous voulez aussi les surfaces d'expérimentation, d'amorçage et d'exploitation."
+          },
           "finish": {
             "title": "Voilà pour la disposition",
             "body": "Vous savez maintenant vous repérer. Essayez la visite suivante pour créer et lancer votre première tâche, ou revenez plus tard via la palette de commandes."
           }
         }
       },
+      "addService": {
+        "title": "Ajoutez votre premier dépôt",
+        "description": "Liez un dépôt pour que le tableau ait un service sur lequel planifier du travail.",
+        "steps": {
+          "intro": {
+            "title": "Commencez par un dépôt",
+            "body": "Le travail se fait sur du code, donc un tableau a besoin d'au moins un service avant qu'un agent ait un endroit où travailler. Cette visite en lie un."
+          },
+          "open": {
+            "title": "Ajouter un service depuis un dépôt",
+            "body": "Ceci ouvre le sélecteur de dépôts. Il liste les dépôts que la connexion de cet espace de travail peut voir."
+          },
+          "search": {
+            "title": "Choisissez un dépôt",
+            "body": "Cherchez l'un de vos propres dépôts. Si vous préférez vous entraîner sur quelque chose de petit, {repo} est un service d'exemple laissé volontairement inachevé pour ces visites."
+          },
+          "add": {
+            "title": "Ajoutez-le",
+            "body": "Le dépôt devient un cadre de service sur le tableau. Vous pourrez en ajouter d'autres plus tard, y compris un service par dossier dans un monorepo."
+          },
+          "finish": {
+            "title": "Vous avez un service",
+            "body": "C'est dans ce cadre que vivent les tâches. La visite suivante y en place une."
+          }
+        }
+      },
       "firstTask": {
         "title": "Créez votre première tâche",
         "description": "Ajoutez une tâche à un service et regardez-la apparaître sur le tableau.",
@@ -5979,6 +6009,96 @@
             "body": "C'est la boucle principale : décrire une tâche, la lancer, vérifier le résultat. Explorez les autres visites quand vous voulez."
           }
         }
+      },
+      "runTask": {
+        "title": "Lancer une tâche",
+        "description": "Ouvrez une tâche, choisissez son pipeline et mettez les agents au travail.",
+        "steps": {
+          "intro": {
+            "title": "De la tâche à l'exécution",
+            "body": "Une tâche sur le tableau est une demande. En l'ouvrant, vous voyez le pipeline qui la livrera et les commandes qui le démarrent."
+          },
+          "openTask": {
+            "title": "Ouvrez une tâche",
+            "body": "Cliquer sur une carte ouvre son inspecteur, où se trouve tout ce qui concerne cette tâche."
+          },
+          "inspector": {
+            "title": "L'inspecteur",
+            "body": "Statut, dépôt, pipeline et l'exécution elle-même : ce panneau raconte toute l'histoire de la tâche."
+          },
+          "pipeline": {
+            "title": "Choisissez un pipeline",
+            "body": "Un pipeline est la suite d'agents qui feront le travail : écrire une spécification, la réaliser, la relire, lancer les vérifications, fusionner. Prenez celui qui convient à la tâche."
+          },
+          "start": {
+            "title": "Démarrer une exécution",
+            "body": "Ceci démarre réellement le pipeline, et les agents consomment du budget de modèle. Le clic vous revient donc : appuyez quand vous êtes prêt, pendant cette visite ou après."
+          },
+          "steps": {
+            "title": "Suivre le travail",
+            "body": "Chaque étape rapporte ici sa propre progression, en direct. Cliquez sur une étape pour lire ce que l'agent a réellement produit."
+          },
+          "finish": {
+            "title": "Voilà la boucle",
+            "body": "Planifier une tâche, choisir un pipeline, la lancer, la suivre. Quand une exécution a besoin de vous, elle s'arrête et le dit, ce que couvre la visite suivante."
+          }
+        }
+      },
+      "answerPark": {
+        "title": "Répondre à une exécution en attente",
+        "description": "Une exécution s'est arrêtée pour attendre un humain. Voyez où elle demande, et comment répondre.",
+        "steps": {
+          "intro": {
+            "title": "Une exécution vous attend",
+            "body": "Certaines étapes s'arrêtent et posent une question : une précision sur les besoins, un plan à valider, un choix entre plusieurs approches. Une exécution en pause attend une réponse indéfiniment, donc rien n'avance tant que vous n'avez pas répondu."
+          },
+          "resolve": {
+            "title": "Où elle demande",
+            "body": "Une tâche qui attend un humain le signale sur sa carte et propose cette action. Elle vous emmène directement à ce qui est demandé."
+          },
+          "decide": {
+            "title": "Choisir une réponse",
+            "body": "Chaque option est une véritable instruction donnée à l'exécution : choisissez-en une et le pipeline repart avec votre choix."
+          },
+          "approve": {
+            "title": "Valider le travail",
+            "body": "Validez pour laisser l'exécution continuer, ou demandez des modifications pour renvoyer l'étape avec vos remarques. Les deux sont des réponses, et l'exécution repart dans les deux cas."
+          },
+          "finish": {
+            "title": "Rien n'attend en silence",
+            "body": "Les tâches en attente sont marquées sur le tableau et comptées dans la barre d'outils, pour que vous les trouviez sans chercher."
+          }
+        }
+      },
+      "reviewMerge": {
+        "title": "Relire et fusionner",
+        "description": "Lisez ce qu'une exécution terminée a produit, et faites-le fusionner.",
+        "steps": {
+          "intro": {
+            "title": "Une exécution est terminée",
+            "body": "Terminé n'est pas livré. Une tâche est faite quand sa pull request est fusionnée : cette visite est le dernier kilomètre."
+          },
+          "openTask": {
+            "title": "Ouvrez la tâche",
+            "body": "Ouvrez une tâche dont l'exécution est terminée. Son inspecteur contient la liste complète des étapes."
+          },
+          "openStep": {
+            "title": "Ouvrez une étape",
+            "body": "Cliquer sur une étape montre ce que cet agent a produit : son rapport, ses constats et ce qu'il a changé."
+          },
+          "result": {
+            "title": "Lire le résultat",
+            "body": "C'est le compte rendu de l'agent lui-même. Les étapes de relecture listent des constats, un testeur rend des verdicts, le fusionneur explique comment il a noté le changement."
+          },
+          "merge": {
+            "title": "Fusionner",
+            "body": "Quand une exécution ouvre une pull request, l'inspecteur propose la fusion ici. Un pipeline avec une étape de fusion peut aussi fusionner tout seul si le changement dépasse votre seuil."
+          },
+          "finish": {
+            "title": "Livré",
+            "body": "Le travail fusionné marque la tâche comme faite sur le tableau. Voilà la boucle entière : planifier, exécuter, répondre, relire, fusionner."
+          }
+        }
       }
     }
   }