@cat-factory/app 0.207.0 → 0.208.1

package/i18n/locales/de.json

@@ -6214,7 +6214,7 @@
       "intro": "Geführte Touren zeigen dir die App direkt auf diesem Bildschirm: Sie heben die echten Bedienelemente hervor und sagen dir, was du anklicken sollst.",
       "decline": "Nein danke",
       "later": "Vielleicht später",
-      "empty": "Für deine Rolle auf diesem Board sind noch keine Touren verfügbar.",
+      "empty": "Für deine Rolle auf diesem Board sind noch keine Einstiegstouren verfügbar, im vollständigen Katalog kann aber trotzdem eine für dich liegen.",
       "browse": "Alle Tutorials anzeigen"
     },
     "catalogue": {
@@ -6246,7 +6246,10 @@
       "service": "Ein Service auf dem Board",
       "task": "Eine Aufgabe auf dem Board",
       "waitingAnswer": "Ein Lauf, der auf deine Antwort wartet",
-      "finishedRun": "Ein erfolgreich abgeschlossener Lauf"
+      "finishedRun": "Ein erfolgreich abgeschlossener Lauf",
+      "integrationsManage": "Berechtigung, Integrationen zu verwalten",
+      "settingsManage": "Berechtigung, Workspace-Einstellungen zu verwalten",
+      "library": "Eine in diesem Deployment aktivierte Kontextfragment-Bibliothek"
     },
     "overlay": {
       "next": "Weiter",
@@ -6440,6 +6443,102 @@
             "body": "Gemergte Arbeit markiert die Aufgabe auf dem Board als erledigt. Das ist der ganze Kreislauf: planen, ausführen, antworten, prüfen, mergen."
           }
         }
+      },
+      "wireModels": {
+        "title": "Einen Modellanbieter verbinden",
+        "description": "Richte den Workspace auf die Engines aus, mit denen deine Agenten laufen.",
+        "steps": {
+          "intro": {
+            "title": "Agenten brauchen eine Engine",
+            "body": "Jeder Schritt jeder Pipeline ist ein Modellaufruf, also läuft nichts, solange dieser Workspace keinen Anbieter erreicht. Diese Tour zeigt, wo diese Verbindung liegt."
+          },
+          "open": {
+            "title": "Modellanbieter",
+            "body": "Das öffnet den Anbieter-Hub: jede Engine, die dieses Deployment verbinden kann, wobei die bereits eingerichteten als verbunden markiert sind."
+          },
+          "hub": {
+            "title": "Wähle, wie du verbindest",
+            "body": "Ein Gateway-Schlüssel schaltet auf einmal einen großen Katalog frei. Ein Anbieterschlüssel, ein persönlicher Plan oder ein Modell-Runner auf deinem eigenen Rechner funktionieren genauso gut, und du kannst mehrere gleichzeitig haben."
+          },
+          "finish": {
+            "title": "Danach pro Agent wählen",
+            "body": "Die Modellkonfiguration im selben Bereich der Seitenleiste legt fest, welches Modell jede Agentenart nutzt. Günstige Schritte können auf günstigen Modellen laufen und die schweren auf deinem besten, ohne eine einzige Pipeline zu ändern."
+          }
+        }
+      },
+      "designPipeline": {
+        "title": "Eine Pipeline entwerfen",
+        "description": "Stelle die Agenten zusammen, die eine Aufgabe liefern, und speichere sie für jede Aufgabe.",
+        "steps": {
+          "intro": {
+            "title": "Die Abfolge liegt bei dir",
+            "body": "Eine Pipeline ist die geordnete Reihe von Agenten, die aus einer Aufgabe einen gemergten Pull Request macht. Die eingebauten decken die meiste Arbeit ab, und diese Tour öffnet den Builder, in dem du deine eigene formen kannst."
+          },
+          "open": {
+            "title": "Eine Pipeline erstellen",
+            "body": "Der Builder öffnet sich neben dem Board, damit die Arbeit im Blick bleibt, während du den Ablauf formst."
+          },
+          "palette": {
+            "title": "Die Agentenpalette",
+            "body": "Hier stehen alle Agentenarten, die dieses Deployment mitbringt, von denen, die die Arbeit planen, bis zu denen, die sie prüfen, testen und mergen. Klicke eine an, um sie als Schritt anzuhängen."
+          },
+          "chain": {
+            "title": "Die Kette, die du baust",
+            "body": "Schritte laufen von oben nach unten, und jede Zeile hat ihre eigenen Schalter: den Reviewer anhängen, der einen Schritt bei zu niedriger Bewertung zurückschickt, deine Freigabe verlangen, bevor der nächste startet, oder einen Schritt als Panel aus mehreren Modellen laufen lassen."
+          },
+          "save": {
+            "title": "Die Pipeline speichern",
+            "body": "Speichern wird verfügbar, sobald der Entwurf mindestens einen Schritt enthält. Eine gespeicherte Pipeline landet in der Bibliothek in diesem Fenster und wird überall angeboten, wo eine Aufgabe eine auswählt; benenne sie nach der Arbeit, die sie erledigt, nicht nach den Agenten darin, denn dieser Name ist alles, was du später siehst."
+          },
+          "finish": {
+            "title": "Bereit zum Ausführen",
+            "body": "Eine eingebaute zu klonen ist der schnellste Start: kopiere die passendste, ändere einen Schritt, speichere sie unter eigenem Namen. Nichts, was du speicherst, wird wirksam, bevor eine Aufgabe damit gestartet wird."
+          }
+        }
+      },
+      "agentStandards": {
+        "title": "Die Standards festlegen, denen Agenten folgen",
+        "description": "Pflege die Richtlinien, die jeder Agent liest, bevor er deinen Code anfasst.",
+        "steps": {
+          "intro": {
+            "title": "Standards, keine Anweisungen",
+            "body": "Kontextfragmente sind die Hausregeln: Konventionen, Review-Kriterien und Best Practices, die bei jedem Lauf in den Prompt eines Agenten eingefügt werden. Sie hier zu pflegen ist der Weg, das Ergebnis zu steuern, statt dieselben Regeln in jeder Aufgabe zu wiederholen."
+          },
+          "open": {
+            "title": "Kontextfragmente",
+            "body": "Das öffnet die Bibliothek für dieses Board."
+          },
+          "library": {
+            "title": "Ein zusammengeführter Katalog",
+            "body": "Der eingebaute Katalog, die Fragmente deines Accounts und die dieses Boards werden zu einer Liste zusammengeführt, wobei die nähere Ebene gewinnt. Du kannst hier eines schreiben, ein Dokument importieren oder einen Repository-Ordner verknüpfen, damit Dateien, die du schon pflegst, die Quelle der Wahrheit bleiben."
+          },
+          "finish": {
+            "title": "Wo sie landen",
+            "body": "Ein Service oder eine Aufgabe kann einschränken, welche Fragmente ihre Agenten bekommen, und die boardweiten Vorgaben stehen in den Workspace-Einstellungen. Agenten, die Code schreiben, erhalten eine verdichtete Kurzfassung jedes Fragments, damit ein langer Standard die Aufgabe selbst nicht verdrängt."
+          }
+        }
+      },
+      "connectSystems": {
+        "title": "Die Systeme verbinden, die du schon nutzt",
+        "description": "Tracker, Dokumente, Chat und Monitoring, und was jedes davon einem Lauf hinzufügt.",
+        "steps": {
+          "intro": {
+            "title": "Läufe können weiter reichen",
+            "body": "Tickets können aus deinem Tracker kommen, Anforderungen aus deinen Dokumenten, Benachrichtigungen in den Chat deines Teams und Release-Gesundheit aus deinem Monitoring. Jede Verbindung ist optional, und jede verändert, was ein Lauf sehen oder sagen kann."
+          },
+          "open": {
+            "title": "Der Integrations-Hub",
+            "body": "Eine Liste aller externen Systeme, die dieser Workspace anbinden kann, wobei alles Verbundene markiert ist."
+          },
+          "hub": {
+            "title": "Verbinde, was du brauchst",
+            "body": "Die Quellcodeverwaltung kommt zuerst, denn Pipelines brauchen Code, an dem sie arbeiten. Der Rest kann warten, bis die Frage aufkommt: ein Tracker, aus dem Tickets geholt werden, eine Dokumentquelle für Anforderungskontext, Chat für Benachrichtigungen, Monitoring, um ein Release nach dem Ausliefern zu beobachten."
+          },
+          "finish": {
+            "title": "Deins oder das des Workspace",
+            "body": "Manche Einträge gehören dir und nicht dem Board, etwa ein persönliches Zugriffstoken oder ein persönlicher Plan, und werden nur für Läufe genutzt, die du startest. Der Hub markiert, was was ist, und Meine Einrichtung sammelt das, was dir gehört."
+          }
+        }
       }
     }
   },

package/i18n/locales/en.json

@@ -6419,7 +6419,7 @@
       "intro": "Guided tours walk you through the app right on this screen: they highlight the actual controls and tell you what to click.",
       "decline": "No thanks",
       "later": "Maybe later",
-      "empty": "No tours are available for your role on this board yet.",
+      "empty": "No first-run walkthroughs are available for your role on this board yet, but the full catalogue may still hold one you can take.",
       "browse": "See all tutorials"
     },
     "catalogue": {
@@ -6460,7 +6460,10 @@
       "service": "A service on the board",
       "task": "A task on the board",
       "waitingAnswer": "A run waiting for your answer",
-      "finishedRun": "A run that finished successfully"
+      "finishedRun": "A run that finished successfully",
+      "integrationsManage": "Permission to manage integrations",
+      "settingsManage": "Permission to manage workspace settings",
+      "library": "The context fragment library enabled on this deployment"
     },
     "overlay": {
       "next": "Next",
@@ -6663,6 +6666,102 @@
             "body": "Merged work marks the task done on the board. That is the whole loop: plan, run, answer, review, merge."
           }
         }
+      },
+      "wireModels": {
+        "title": "Connect a model provider",
+        "description": "Point the workspace at the engines your agents run on.",
+        "steps": {
+          "intro": {
+            "title": "Agents need an engine",
+            "body": "Every step of every pipeline is a model call, so nothing runs until this workspace can reach a provider. This tour shows where that connection lives."
+          },
+          "open": {
+            "title": "Model providers",
+            "body": "This opens the providers hub: every engine this deployment can connect, with the ones already wired marked as connected."
+          },
+          "hub": {
+            "title": "Pick how you connect",
+            "body": "One gateway key unlocks a wide catalogue at once. A vendor key, a personal plan or a model runner on your own machine work just as well, and you can hold several at the same time."
+          },
+          "finish": {
+            "title": "Then choose per agent",
+            "body": "Model configuration, in the same sidebar section, sets which model each agent kind uses. Cheap steps can run on cheap models and the hard ones on your best, without editing a single pipeline."
+          }
+        }
+      },
+      "designPipeline": {
+        "title": "Design a pipeline",
+        "description": "Assemble the agents that deliver a task, and save it for any task to run.",
+        "steps": {
+          "intro": {
+            "title": "The sequence is yours",
+            "body": "A pipeline is the ordered set of agents that turns a task into a merged pull request. The built-in ones cover most work, and this tour opens the builder where you can shape your own."
+          },
+          "open": {
+            "title": "Build a pipeline",
+            "body": "The builder opens beside the board, so the work stays in view while you shape the flow."
+          },
+          "palette": {
+            "title": "The agent palette",
+            "body": "Every agent kind this deployment ships is listed here, from the ones that plan the work to the ones that review, test and merge it. Click one to append it as a step."
+          },
+          "chain": {
+            "title": "The chain you are building",
+            "body": "Steps run top to bottom, and each row carries its own switches: attach the reviewer that sends a step back when it scores too low, require your approval before the next one starts, or run a step as a panel of several models."
+          },
+          "save": {
+            "title": "Saving your pipeline",
+            "body": "Save becomes available once the draft holds at least one step. A saved pipeline joins the library in this window and is offered wherever a task picks one; name it for the job it does rather than the agents in it, because that name is all you see when choosing later."
+          },
+          "finish": {
+            "title": "Ready to run",
+            "body": "Cloning a built-in is the quickest start: copy the closest one, change a step, save it under your own name. Nothing you save takes effect until a task is actually started with it."
+          }
+        }
+      },
+      "agentStandards": {
+        "title": "Set the standards agents follow",
+        "description": "Curate the guidelines every agent reads before it touches your code.",
+        "steps": {
+          "intro": {
+            "title": "Standards, not instructions",
+            "body": "Context fragments are the house rules: conventions, review criteria and best practices folded into an agent's prompt on every run. Curating them is how you steer the output instead of restating the same rules in every task."
+          },
+          "open": {
+            "title": "Context fragments",
+            "body": "This opens the library for this board."
+          },
+          "library": {
+            "title": "One merged catalog",
+            "body": "The built-in catalog, your account's fragments and this board's own are merged into a single list, with the closer tier winning. You can write one here, import a document, or link a repository folder so files you already maintain stay the source of truth."
+          },
+          "finish": {
+            "title": "Where they land",
+            "body": "A service or a task can narrow which fragments its agents get, and the board-wide defaults live in Workspace settings. Agents that write code are given a condensed brief of each fragment, so a long standard never crowds out the task itself."
+          }
+        }
+      },
+      "connectSystems": {
+        "title": "Connect the systems you already use",
+        "description": "Trackers, documents, chat and monitors, and what each one adds to a run.",
+        "steps": {
+          "intro": {
+            "title": "Runs can reach further",
+            "body": "Issues can arrive from your tracker, requirements from your documents, notifications in your team chat, and release health from your monitors. Every connection is optional, and each one changes what a run can see or say."
+          },
+          "open": {
+            "title": "The integrations hub",
+            "body": "One list of every external system this workspace can link, with whatever is connected already marked."
+          },
+          "hub": {
+            "title": "Connect what you need",
+            "body": "Source control comes first, because pipelines need code to work on. The rest can wait until the question comes up: a tracker to pull issues from, a document source for requirements context, chat for notifications, monitors to watch a release after it ships."
+          },
+          "finish": {
+            "title": "Yours or the workspace's",
+            "body": "Some entries belong to you rather than to the board, such as a personal access token or plan, and are used only for runs you start. The hub marks which is which, and My setup collects the ones that are yours."
+          }
+        }
       }
     }
   },

package/i18n/locales/es.json

@@ -6202,7 +6202,7 @@
       "intro": "Los recorridos guiados te muestran la aplicación directamente en esta pantalla: resaltan los controles reales y te dicen dónde hacer clic.",
       "decline": "No, gracias",
       "later": "Quizás más tarde",
-      "empty": "Todavía no hay recorridos disponibles para tu rol en este tablero.",
+      "empty": "Todavía no hay recorridos de primer contacto disponibles para tu rol en este tablero, pero el catálogo completo puede tener alguno que sí puedas hacer.",
       "browse": "Ver todos los tutoriales"
     },
     "catalogue": {
@@ -6234,7 +6234,10 @@
       "service": "Un servicio en el tablero",
       "task": "Una tarea en el tablero",
       "waitingAnswer": "Una ejecución esperando tu respuesta",
-      "finishedRun": "Una ejecución terminada correctamente"
+      "finishedRun": "Una ejecución terminada correctamente",
+      "integrationsManage": "Permiso para gestionar integraciones",
+      "settingsManage": "Permiso para gestionar los ajustes del espacio de trabajo",
+      "library": "La biblioteca de fragmentos de contexto habilitada en este despliegue"
     },
     "overlay": {
       "next": "Siguiente",
@@ -6428,6 +6431,102 @@
             "body": "El trabajo fusionado marca la tarea como hecha en el tablero. Ese es el ciclo completo: planificar, ejecutar, responder, revisar y fusionar."
           }
         }
+      },
+      "wireModels": {
+        "title": "Conectar un proveedor de modelos",
+        "description": "Apunta el espacio de trabajo a los motores con los que funcionan tus agentes.",
+        "steps": {
+          "intro": {
+            "title": "Los agentes necesitan un motor",
+            "body": "Cada paso de cada pipeline es una llamada a un modelo, así que nada funciona hasta que este espacio de trabajo alcance un proveedor. Este recorrido te muestra dónde vive esa conexión."
+          },
+          "open": {
+            "title": "Proveedores de modelos",
+            "body": "Esto abre el hub de proveedores: todos los motores que este despliegue puede conectar, con los ya configurados marcados como conectados."
+          },
+          "hub": {
+            "title": "Elige cómo conectarte",
+            "body": "Una clave de pasarela desbloquea un catálogo amplio de una sola vez. Una clave de proveedor, un plan personal o un ejecutor de modelos en tu propia máquina sirven igual de bien, y puedes tener varios a la vez."
+          },
+          "finish": {
+            "title": "Luego elige por agente",
+            "body": "La configuración del modelo, en la misma sección de la barra lateral, decide qué modelo usa cada tipo de agente. Los pasos baratos pueden ir en modelos baratos y los difíciles en tu mejor modelo, sin editar ningún pipeline."
+          }
+        }
+      },
+      "designPipeline": {
+        "title": "Diseñar un pipeline",
+        "description": "Ensambla los agentes que entregan una tarea y guárdalo para cualquier tarea.",
+        "steps": {
+          "intro": {
+            "title": "La secuencia es tuya",
+            "body": "Un pipeline es el conjunto ordenado de agentes que convierte una tarea en una pull request fusionada. Los que vienen incluidos cubren la mayor parte del trabajo, y este recorrido abre el constructor donde puedes dar forma al tuyo."
+          },
+          "open": {
+            "title": "Crear un pipeline",
+            "body": "El constructor se abre junto al tablero, así el trabajo sigue a la vista mientras das forma al flujo."
+          },
+          "palette": {
+            "title": "La paleta de agentes",
+            "body": "Aquí están todos los tipos de agente que trae este despliegue, desde los que planifican el trabajo hasta los que lo revisan, lo prueban y lo fusionan. Haz clic en uno para añadirlo como paso."
+          },
+          "chain": {
+            "title": "La cadena que estás montando",
+            "body": "Los pasos se ejecutan de arriba abajo, y cada fila tiene sus propios interruptores: añadir el revisor que devuelve un paso cuando puntúa demasiado bajo, exigir tu aprobación antes de que arranque el siguiente, o ejecutar un paso como un panel de varios modelos."
+          },
+          "save": {
+            "title": "Guardar tu pipeline",
+            "body": "Guardar se habilita en cuanto el borrador tiene al menos un paso. Un pipeline guardado se suma a la biblioteca de esta ventana y se ofrece allí donde una tarea elige uno; nómbralo por el trabajo que hace y no por los agentes que contiene, porque ese nombre es todo lo que verás al elegir después."
+          },
+          "finish": {
+            "title": "Listo para ejecutar",
+            "body": "Clonar uno incluido es la vía más rápida: copia el más parecido, cambia un paso y guárdalo con tu propio nombre. Nada de lo que guardes surte efecto hasta que una tarea se arranque con él."
+          }
+        }
+      },
+      "agentStandards": {
+        "title": "Fijar los estándares que siguen los agentes",
+        "description": "Cuida las pautas que todo agente lee antes de tocar tu código.",
+        "steps": {
+          "intro": {
+            "title": "Estándares, no instrucciones",
+            "body": "Los fragmentos de contexto son las reglas de la casa: convenciones, criterios de revisión y buenas prácticas que se insertan en el prompt de un agente en cada ejecución. Cuidarlos es la forma de dirigir el resultado en lugar de repetir las mismas reglas en cada tarea."
+          },
+          "open": {
+            "title": "Fragmentos de contexto",
+            "body": "Esto abre la biblioteca de este tablero."
+          },
+          "library": {
+            "title": "Un catálogo unificado",
+            "body": "El catálogo incluido, los fragmentos de tu cuenta y los de este tablero se unen en una sola lista, y gana el nivel más cercano. Puedes escribir uno aquí, importar un documento o enlazar una carpeta de un repositorio para que los archivos que ya mantienes sigan siendo la fuente de verdad."
+          },
+          "finish": {
+            "title": "Dónde acaban",
+            "body": "Un servicio o una tarea puede restringir qué fragmentos reciben sus agentes, y los valores por defecto de todo el tablero están en los ajustes del espacio de trabajo. Los agentes que escriben código reciben un resumen condensado de cada fragmento, para que un estándar largo no desplace a la propia tarea."
+          }
+        }
+      },
+      "connectSystems": {
+        "title": "Conectar los sistemas que ya usas",
+        "description": "Gestores de incidencias, documentos, chat y monitores, y qué aporta cada uno a una ejecución.",
+        "steps": {
+          "intro": {
+            "title": "Las ejecuciones pueden llegar más lejos",
+            "body": "Las incidencias pueden venir de tu gestor de tareas, los requisitos de tus documentos, las notificaciones al chat de tu equipo y la salud de una release de tus monitores. Cada conexión es opcional, y cada una cambia lo que una ejecución puede ver o decir."
+          },
+          "open": {
+            "title": "El hub de integraciones",
+            "body": "Una lista de todos los sistemas externos que este espacio de trabajo puede enlazar, con lo que ya está conectado marcado."
+          },
+          "hub": {
+            "title": "Conecta lo que necesites",
+            "body": "El control de código va primero, porque los pipelines necesitan código sobre el que trabajar. El resto puede esperar a que surja la necesidad: un gestor de incidencias del que importar tareas, una fuente de documentos para el contexto de requisitos, chat para las notificaciones, monitores para vigilar una release después de publicarla."
+          },
+          "finish": {
+            "title": "Tuyo o del espacio de trabajo",
+            "body": "Algunas entradas son tuyas y no del tablero, como un token de acceso personal o un plan, y solo se usan en las ejecuciones que arrancas tú. El hub marca cuál es cuál, y Mi configuración reúne las que son tuyas."
+          }
+        }
       }
     }
   },

package/i18n/locales/fr.json

@@ -6202,7 +6202,7 @@
       "intro": "Les visites guidées vous montrent l'application directement à l'écran : elles mettent en évidence les vrais contrôles et vous indiquent où cliquer.",
       "decline": "Non merci",
       "later": "Peut-être plus tard",
-      "empty": "Aucune visite n'est encore disponible pour votre rôle sur ce tableau.",
+      "empty": "Aucune visite de premiers pas n'est encore disponible pour votre rôle sur ce tableau, mais le catalogue complet peut tout de même en contenir une accessible.",
       "browse": "Voir tous les tutoriels"
     },
     "catalogue": {
@@ -6234,7 +6234,10 @@
       "service": "Un service sur le tableau",
       "task": "Une tâche sur le tableau",
       "waitingAnswer": "Une exécution en attente de votre réponse",
-      "finishedRun": "Une exécution terminée avec succès"
+      "finishedRun": "Une exécution terminée avec succès",
+      "integrationsManage": "L'autorisation de gérer les intégrations",
+      "settingsManage": "L'autorisation de gérer les paramètres de l'espace de travail",
+      "library": "La bibliothèque de fragments de contexte activée sur ce déploiement"
     },
     "overlay": {
       "next": "Suivant",
@@ -6428,6 +6431,102 @@
             "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."
           }
         }
+      },
+      "wireModels": {
+        "title": "Connecter un fournisseur de modèles",
+        "description": "Indiquez à l'espace de travail les moteurs qui font tourner vos agents.",
+        "steps": {
+          "intro": {
+            "title": "Les agents ont besoin d'un moteur",
+            "body": "Chaque étape de chaque pipeline est un appel de modèle : rien ne tourne tant que cet espace de travail n'atteint pas un fournisseur. Cette visite montre où se trouve cette connexion."
+          },
+          "open": {
+            "title": "Fournisseurs de modèles",
+            "body": "Ceci ouvre le hub des fournisseurs : tous les moteurs que ce déploiement peut connecter, ceux déjà en place étant marqués comme connectés."
+          },
+          "hub": {
+            "title": "Choisissez votre mode de connexion",
+            "body": "Une clé de passerelle débloque d'un coup un large catalogue. Une clé d'éditeur, un abonnement personnel ou un exécuteur de modèles sur votre propre machine font tout aussi bien l'affaire, et vous pouvez en avoir plusieurs à la fois."
+          },
+          "finish": {
+            "title": "Puis choisissez par agent",
+            "body": "La configuration du modèle, dans la même section de la barre latérale, définit quel modèle utilise chaque type d'agent. Les étapes simples peuvent tourner sur des modèles économiques et les difficiles sur votre meilleur, sans modifier un seul pipeline."
+          }
+        }
+      },
+      "designPipeline": {
+        "title": "Concevoir un pipeline",
+        "description": "Assemblez les agents qui livrent une tâche, et enregistrez-le pour n'importe quelle tâche.",
+        "steps": {
+          "intro": {
+            "title": "La séquence vous appartient",
+            "body": "Un pipeline est la suite ordonnée d'agents qui transforme une tâche en pull request fusionnée. Ceux fournis couvrent l'essentiel du travail, et cette visite ouvre le constructeur où vous pouvez façonner le vôtre."
+          },
+          "open": {
+            "title": "Créer un pipeline",
+            "body": "Le constructeur s'ouvre à côté du tableau, pour garder le travail sous les yeux pendant que vous façonnez le flux."
+          },
+          "palette": {
+            "title": "La palette d'agents",
+            "body": "Tous les types d'agent fournis par ce déploiement sont listés ici, de ceux qui planifient le travail à ceux qui le relisent, le testent et le fusionnent. Cliquez sur l'un d'eux pour l'ajouter comme étape."
+          },
+          "chain": {
+            "title": "La chaîne que vous construisez",
+            "body": "Les étapes s'exécutent de haut en bas, et chaque ligne a ses propres interrupteurs : attacher le relecteur qui renvoie une étape lorsqu'elle est trop mal notée, exiger votre approbation avant le démarrage de la suivante, ou faire tourner une étape comme un panel de plusieurs modèles."
+          },
+          "save": {
+            "title": "Enregistrer votre pipeline",
+            "body": "Enregistrer devient actif dès que le brouillon contient au moins une étape. Un pipeline enregistré rejoint la bibliothèque de cette fenêtre et est proposé partout où une tâche en choisit un ; nommez-le d'après le travail qu'il fait plutôt que d'après les agents qu'il contient, car ce nom est tout ce que vous verrez au moment de choisir."
+          },
+          "finish": {
+            "title": "Prêt à tourner",
+            "body": "Cloner un pipeline fourni est le départ le plus rapide : copiez le plus proche, changez une étape, enregistrez-le sous votre propre nom. Rien de ce que vous enregistrez ne prend effet avant qu'une tâche soit réellement lancée avec."
+          }
+        }
+      },
+      "agentStandards": {
+        "title": "Définir les standards que suivent les agents",
+        "description": "Entretenez les règles que chaque agent lit avant de toucher à votre code.",
+        "steps": {
+          "intro": {
+            "title": "Des standards, pas des consignes",
+            "body": "Les fragments de contexte sont les règles de la maison : conventions, critères de relecture et bonnes pratiques insérés dans le prompt d'un agent à chaque exécution. Les entretenir ici, c'est piloter le résultat au lieu de répéter les mêmes règles dans chaque tâche."
+          },
+          "open": {
+            "title": "Fragments de contexte",
+            "body": "Ceci ouvre la bibliothèque de ce tableau."
+          },
+          "library": {
+            "title": "Un catalogue fusionné",
+            "body": "Le catalogue fourni, les fragments de votre compte et ceux de ce tableau sont fusionnés en une seule liste, le niveau le plus proche l'emportant. Vous pouvez en écrire un ici, importer un document, ou relier un dossier de dépôt pour que les fichiers que vous maintenez déjà restent la source de vérité."
+          },
+          "finish": {
+            "title": "Où ils s'appliquent",
+            "body": "Un service ou une tâche peut restreindre les fragments que reçoivent ses agents, et les valeurs par défaut du tableau sont dans les paramètres de l'espace de travail. Les agents qui écrivent du code reçoivent un résumé condensé de chaque fragment, pour qu'un long standard n'éclipse pas la tâche elle-même."
+          }
+        }
+      },
+      "connectSystems": {
+        "title": "Connecter les systèmes que vous utilisez déjà",
+        "description": "Outils de suivi, documents, messagerie et supervision, et ce que chacun apporte à une exécution.",
+        "steps": {
+          "intro": {
+            "title": "Les exécutions peuvent aller plus loin",
+            "body": "Les tickets peuvent venir de votre outil de suivi, les exigences de vos documents, les notifications dans la messagerie de votre équipe, et la santé d'une mise en production de votre supervision. Chaque connexion est optionnelle, et chacune change ce qu'une exécution peut voir ou dire."
+          },
+          "open": {
+            "title": "Le hub d'intégrations",
+            "body": "Une liste de tous les systèmes externes que cet espace de travail peut relier, avec ce qui est déjà connecté signalé."
+          },
+          "hub": {
+            "title": "Connectez ce dont vous avez besoin",
+            "body": "Le gestionnaire de code d'abord, car les pipelines ont besoin de code sur lequel travailler. Le reste peut attendre que la question se pose : un outil de suivi d'où importer des tickets, une source de documents pour le contexte des exigences, la messagerie pour les notifications, la supervision pour surveiller une mise en production."
+          },
+          "finish": {
+            "title": "À vous ou à l'espace de travail",
+            "body": "Certaines entrées vous appartiennent plutôt qu'au tableau, comme un jeton d'accès personnel ou un abonnement, et ne servent qu'aux exécutions que vous lancez. Le hub indique lesquelles, et Ma configuration rassemble les vôtres."
+          }
+        }
       }
     }
   },

package/i18n/locales/he.json

@@ -6213,7 +6213,7 @@
       "intro": "סיורים מודרכים מציגים את האפליקציה ישירות על המסך: הם מדגישים את הפקדים האמיתיים ואומרים לך על מה ללחוץ.",
       "decline": "לא תודה",
       "later": "אולי מאוחר יותר",
-      "empty": "אין עדיין סיורים זמינים לתפקיד שלך בלוח הזה.",
+      "empty": "אין עדיין סיורי התחלה זמינים לתפקיד שלך בלוח הזה, אבל בקטלוג המלא ייתכן שיש סיור שכן תוכל לעשות.",
       "browse": "הצג את כל המדריכים"
     },
     "catalogue": {
@@ -6245,7 +6245,10 @@
       "service": "שירות בלוח",
       "task": "משימה בלוח",
       "waitingAnswer": "ריצה שממתינה לתשובה שלך",
-      "finishedRun": "ריצה שהסתיימה בהצלחה"
+      "finishedRun": "ריצה שהסתיימה בהצלחה",
+      "integrationsManage": "הרשאה לנהל אינטגרציות",
+      "settingsManage": "הרשאה לנהל את הגדרות סביבת העבודה",
+      "library": "ספריית מקטעי ההקשר מופעלת בפריסה הזו"
     },
     "overlay": {
       "next": "הבא",
@@ -6439,6 +6442,102 @@
             "body": "עבודה שמוזגה מסמנת את המשימה כגמורה על הלוח. זהו המחזור השלם: לתכנן, להריץ, לענות, לסקור ולמזג."
           }
         }
+      },
+      "wireModels": {
+        "title": "חיבור ספק מודלים",
+        "description": "הפנה את סביבת העבודה למנועים שהסוכנים שלך רצים עליהם.",
+        "steps": {
+          "intro": {
+            "title": "לסוכנים דרוש מנוע",
+            "body": "כל שלב בכל צינור הוא קריאה למודל, ולכן שום דבר לא רץ עד שסביבת העבודה הזו מגיעה לספק. הסיור הזה מראה איפה נמצא החיבור."
+          },
+          "open": {
+            "title": "ספקי מודלים",
+            "body": "זה פותח את מרכז הספקים: כל מנוע שהפריסה הזו יכולה לחבר, כשאלה שכבר מוגדרים מסומנים כמחוברים."
+          },
+          "hub": {
+            "title": "בחר איך להתחבר",
+            "body": "מפתח אחד לשער פותח קטלוג רחב בבת אחת. מפתח של ספק, מנוי אישי או מריץ מודלים על המכונה שלך עושים את העבודה לא פחות טוב, ואפשר להחזיק כמה במקביל."
+          },
+          "finish": {
+            "title": "אחר כך בחר לכל סוכן",
+            "body": "תצורת המודל, באותו חלק בסרגל הצד, קובעת איזה מודל כל סוג סוכן מפעיל. שלבים זולים יכולים לרוץ על מודלים זולים והקשים על הטוב שבהם, בלי לשנות אף צינור."
+          }
+        }
+      },
+      "designPipeline": {
+        "title": "תכנון צינור",
+        "description": "הרכב את הסוכנים שמבצעים משימה, ושמור את הצינור לכל משימה.",
+        "steps": {
+          "intro": {
+            "title": "הסדר הוא שלך",
+            "body": "צינור הוא רצף הסוכנים המסודר שהופך משימה לבקשת מיזוג ממוזגת. אלה שמגיעים מוכנים מכסים את רוב העבודה, והסיור הזה פותח את הבונה שבו תרכיב את שלך."
+          },
+          "open": {
+            "title": "בניית צינור",
+            "body": "הבונה נפתח לצד הלוח, כך שהעבודה נשארת מול העיניים בזמן שאתה מרכיב את הזרימה."
+          },
+          "palette": {
+            "title": "פלטת הסוכנים",
+            "body": "כאן מופיעים כל סוגי הסוכנים שהפריסה מציעה, מאלה שמתכננים את העבודה ועד אלה שסוקרים, בודקים וממזגים אותה. לחיצה על אחד מוסיפה אותו כשלב."
+          },
+          "chain": {
+            "title": "השרשרת שאתה בונה",
+            "body": "השלבים רצים מלמעלה למטה, ולכל שורה יש מפסקים משלה: לצרף את הסוקר שמחזיר שלב כשהניקוד נמוך מדי, לדרוש את האישור שלך לפני שהשלב הבא מתחיל, או להריץ שלב כפאנל של כמה מודלים."
+          },
+          "save": {
+            "title": "שמירת הצינור שלך",
+            "body": "אפשרות השמירה נפתחת ברגע שבטיוטה יש שלב אחד לפחות. צינור שנשמר מצטרף לספרייה בחלון הזה ומוצע בכל מקום שבו משימה בוחרת צינור; תן לו שם לפי העבודה שהוא עושה ולא לפי הסוכנים שבתוכו, כי זה כל מה שתראה כשתבחר אחר כך."
+          },
+          "finish": {
+            "title": "מוכן להרצה",
+            "body": "שכפול של צינור מוכן הוא ההתחלה המהירה ביותר: העתק את הקרוב ביותר, שנה שלב, ושמור בשם שלך. שום דבר ששמרת לא נכנס לתוקף עד שמשימה מופעלת איתו."
+          }
+        }
+      },
+      "agentStandards": {
+        "title": "קביעת התקנים שהסוכנים מקפידים עליהם",
+        "description": "תחזק את ההנחיות שכל סוכן קורא לפני שהוא נוגע בקוד שלך.",
+        "steps": {
+          "intro": {
+            "title": "תקנים, לא הוראות",
+            "body": "מקטעי הקשר הם כללי הבית: מוסכמות, קריטריונים לסקירה ושיטות עבודה מומלצות שנשתלים בהנחיה של הסוכן בכל הרצה. תחזוקה שלהם היא הדרך לכוון את התוצאה במקום לחזור על אותם כללים בכל משימה."
+          },
+          "open": {
+            "title": "מקטעי הקשר",
+            "body": "זה פותח את הספרייה של הלוח הזה."
+          },
+          "library": {
+            "title": "קטלוג אחד מאוחד",
+            "body": "הקטלוג המוכן, המקטעים של החשבון שלך ואלה של הלוח הזה מתמזגים לרשימה אחת, והרובד הקרוב יותר מנצח. אפשר לכתוב מקטע כאן, לייבא מסמך, או לקשר תיקייה במאגר כדי שקבצים שאתה כבר מתחזק יישארו מקור האמת."
+          },
+          "finish": {
+            "title": "לאן הם מגיעים",
+            "body": "שירות או משימה יכולים לצמצם אילו מקטעים הסוכנים שלהם מקבלים, וברירות המחדל של כל הלוח נמצאות בהגדרות סביבת העבודה. סוכנים שכותבים קוד מקבלים תקציר מרוכז של כל מקטע, כך שתקן ארוך לא דוחק את המשימה עצמה."
+          }
+        }
+      },
+      "connectSystems": {
+        "title": "חיבור המערכות שאתה כבר עובד איתן",
+        "description": "מערכות מעקב, מסמכים, צ'אט ומוניטורים, ומה כל אחת מוסיפה להרצה.",
+        "steps": {
+          "intro": {
+            "title": "הרצות יכולות להגיע רחוק יותר",
+            "body": "תקלות יכולות להגיע ממערכת המעקב שלך, דרישות מהמסמכים שלך, התראות לצ'אט של הצוות, ובריאות גרסה מהמוניטורים שלך. כל חיבור הוא רשות, וכל אחד מהם משנה מה הרצה יכולה לראות או להגיד."
+          },
+          "open": {
+            "title": "מרכז האינטגרציות",
+            "body": "רשימה אחת של כל המערכות החיצוניות שסביבת העבודה הזו יכולה לקשר, כשמה שכבר מחובר מסומן."
+          },
+          "hub": {
+            "title": "חבר את מה שדרוש לך",
+            "body": "ניהול הקוד ראשון, כי צינורות צריכים קוד לעבוד עליו. השאר יכול לחכות עד שהשאלה תעלה: מערכת מעקב לייבוא תקלות, מקור מסמכים להקשר של דרישות, צ'אט להתראות, ומוניטורים כדי לעקוב אחרי גרסה שיצאה."
+          },
+          "finish": {
+            "title": "שלך או של סביבת העבודה",
+            "body": "חלק מהפריטים שייכים לך ולא ללוח, כמו אסימון גישה אישי או מנוי, והם משמשים רק בהרצות שאתה מתחיל. המרכז מסמן מה שייך למי, וההגדרות שלי מרכזות את מה ששלך."
+          }
+        }
       }
     }
   },