@cat-factory/app 0.196.1 → 0.198.0

package/i18n/locales/en.json

@@ -2154,7 +2154,8 @@
         "sandbox": "Open Sandbox",
         "shortcuts": "Keyboard shortcuts",
         "bugHunt": "Bug hunt",
-        "toggleUiMode": "Switch interface mode"
+        "toggleUiMode": "Switch interface mode",
+        "tutorial": "Take a tour"
       },
       "keywords": {
         "newPipeline": "pipeline agents chain",
@@ -2176,7 +2177,8 @@
         "sandbox": "sandbox prompt model test experiment judge fixture benchmark evaluate",
         "shortcuts": "keyboard shortcuts keys hotkeys cheatsheet help",
         "bugHunt": "bug hunt triage backlog issue tracker unassigned",
-        "toggleUiMode": "interface mode basic advanced simple expert show hide"
+        "toggleUiMode": "interface mode basic advanced simple expert show hide",
+        "tutorial": "tutorial onboarding tour guide help learn basics"
       }
     },
     "shortcuts": {
@@ -6110,5 +6112,216 @@
       "titleAny": "Connect cat-factory to your repositories",
       "intro": "cat-factory works by opening pull requests on your repositories. Connect your repository host to continue."
     }
+  },
+  "tutorial": {
+    "prompt": {
+      "title": "Take a quick tour?",
+      "intro": "Guided tours walk you through the app right on this screen: they highlight the actual controls and tell you what to click.",
+      "start": "Start",
+      "restart": "Repeat",
+      "completed": "Completed",
+      "decline": "No thanks",
+      "later": "Maybe later",
+      "empty": "No tours are available for your role on this board yet."
+    },
+    "overlay": {
+      "next": "Next",
+      "back": "Back",
+      "skip": "End tour",
+      "done": "Finish",
+      "progress": "Step {current} of {total}",
+      "ariaLabel": "Tutorial step",
+      "abridged": "1 step was skipped: that control is not part of this board. | {count} steps were skipped: those controls are not part of this board.",
+      "@abridged": {
+        "description": "Shown on a tour's final card when steps were skipped. Needs the plural forms of the target language (pl/uk take three: one | few | many); {count} is the number of skipped steps."
+      },
+      "searching": "Looking for the highlighted control...",
+      "clickHint": "Click the highlighted control to continue"
+    },
+    "tours": {
+      "boardBasics": {
+        "title": "Board basics",
+        "description": "Find your way around: the board, the sidebar, and the command palette.",
+        "steps": {
+          "welcome": {
+            "title": "Welcome!",
+            "body": "This is your delivery board: you plan work here, agents pick it up, and you review the results. This short tour points out the main controls."
+          },
+          "canvas": {
+            "title": "The board",
+            "body": "Services, modules, and tasks live on this canvas. Drag to pan, scroll to zoom, and click any card to inspect it."
+          },
+          "sidebar": {
+            "title": "The sidebar",
+            "body": "Everything else lives here: building pipelines, connecting repositories and integrations, and workspace settings."
+          },
+          "commandBar": {
+            "title": "The command palette",
+            "body": "The fastest way to reach any action: open it and start typing. You can restart this tutorial from there at any time."
+          },
+          "toolbar": {
+            "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.",
+        "steps": {
+          "intro": {
+            "title": "Let's create a task",
+            "body": "A task describes an outcome you want; an agent pipeline delivers it. This tour walks you through creating one for real."
+          },
+          "addTask": {
+            "title": "Add a task",
+            "body": "Every service frame has an add button in its header."
+          },
+          "describe": {
+            "title": "Describe the outcome",
+            "body": "Give the task a short title that says what should be true when it is done. Plain language is fine."
+          },
+          "create": {
+            "title": "Create it",
+            "body": "When the description feels right, create the task."
+          },
+          "card": {
+            "title": "Task cards",
+            "body": "This is a task card. From one you can start the pipeline, watch progress, and open the results."
+          },
+          "finish": {
+            "title": "Nice work",
+            "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

@@ -2072,7 +2072,8 @@
         "sandbox": "Abrir el entorno de pruebas",
         "shortcuts": "Atajos de teclado",
         "bugHunt": "Caza de errores",
-        "toggleUiMode": "Cambiar el modo de interfaz"
+        "toggleUiMode": "Cambiar el modo de interfaz",
+        "tutorial": "Hacer un recorrido"
       },
       "keywords": {
         "newPipeline": "canalización agentes cadena pipeline",
@@ -2094,7 +2095,8 @@
         "sandbox": "entorno de pruebas prompt modelo prueba experimento juez fixture benchmark evaluar",
         "shortcuts": "atajos teclado teclas ayuda",
         "bugHunt": "error bug caza triaje backlog incidencias sin asignar",
-        "toggleUiMode": "interfaz modo básico avanzado mostrar ocultar"
+        "toggleUiMode": "interfaz modo básico avanzado mostrar ocultar",
+        "tutorial": "tutorial recorrido guía ayuda aprender introducción"
       }
     },
     "integrationsHub": {
@@ -5894,5 +5896,210 @@
       "titleAny": "Conecta cat-factory con tus repositorios",
       "intro": "cat-factory funciona abriendo solicitudes de incorporación de cambios en tus repositorios. Conecta tu proveedor de repositorios para continuar."
     }
+  },
+  "tutorial": {
+    "prompt": {
+      "title": "¿Hacer un recorrido rápido?",
+      "intro": "Los recorridos guiados te muestran la aplicación directamente en esta pantalla: resaltan los controles reales y te dicen dónde hacer clic.",
+      "start": "Empezar",
+      "restart": "Repetir",
+      "completed": "Completado",
+      "decline": "No, gracias",
+      "later": "Quizás más tarde",
+      "empty": "Todavía no hay recorridos disponibles para tu rol en este tablero."
+    },
+    "overlay": {
+      "next": "Siguiente",
+      "back": "Atrás",
+      "skip": "Terminar recorrido",
+      "done": "Finalizar",
+      "progress": "Paso {current} de {total}",
+      "ariaLabel": "Paso del tutorial",
+      "abridged": "Se omitió 1 paso: ese control no forma parte de este tablero. | Se omitieron {count} pasos: esos controles no forman parte de este tablero.",
+      "searching": "Buscando el control resaltado...",
+      "clickHint": "Haz clic en el control resaltado para continuar"
+    },
+    "tours": {
+      "boardBasics": {
+        "title": "Conceptos básicos del tablero",
+        "description": "Orientación básica: el tablero, la barra lateral y la paleta de comandos.",
+        "steps": {
+          "welcome": {
+            "title": "Te damos la bienvenida",
+            "body": "Este es tu tablero de entrega: aquí planificas el trabajo, los agentes lo ejecutan y tú revisas los resultados. Este breve recorrido muestra los controles principales."
+          },
+          "canvas": {
+            "title": "El tablero",
+            "body": "Los servicios, módulos y tareas viven en este lienzo. Arrastra para desplazarte, usa la rueda para hacer zoom y haz clic en cualquier tarjeta para inspeccionarla."
+          },
+          "sidebar": {
+            "title": "La barra lateral",
+            "body": "Aquí está todo lo demás: crear canalizaciones, conectar repositorios e integraciones y los ajustes del espacio de trabajo."
+          },
+          "commandBar": {
+            "title": "La paleta de comandos",
+            "body": "La forma más rápida de llegar a cualquier acción: ábrela y empieza a escribir. Desde ahí puedes reiniciar este tutorial en cualquier momento."
+          },
+          "toolbar": {
+            "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.",
+        "steps": {
+          "intro": {
+            "title": "Vamos a crear una tarea",
+            "body": "Una tarea describe un resultado que quieres; una canalización de agentes lo entrega. Este recorrido te guía para crear una de verdad."
+          },
+          "addTask": {
+            "title": "Añadir una tarea",
+            "body": "Cada marco de servicio tiene un botón de añadir en su cabecera."
+          },
+          "describe": {
+            "title": "Describe el resultado",
+            "body": "Da a la tarea un título corto que diga qué debe cumplirse cuando esté terminada. El lenguaje normal es suficiente."
+          },
+          "create": {
+            "title": "Créala",
+            "body": "Cuando la descripción te convenza, crea la tarea."
+          },
+          "card": {
+            "title": "Tarjetas de tarea",
+            "body": "Esta es una tarjeta de tarea. Desde ella puedes iniciar la canalización, seguir el progreso y abrir los resultados."
+          },
+          "finish": {
+            "title": "Buen trabajo",
+            "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."
+          }
+        }
+      }
+    }
   }
 }