@cat-factory/app 0.217.2 → 0.219.0

package/app/utils/riskPolicy.spec.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import type { RiskPolicy } from '~/types/merge'
-import { RISK_POLICY_AXES, RISK_POLICY_CEILING_FIELD, riskPolicyCeilings } from '~/utils/riskPolicy'
+import {
+  RISK_POLICY_AXES,
+  RISK_POLICY_CEILING_FIELD,
+  riskPolicyCeilings,
+  rolePolicySummary,
+} from '~/utils/riskPolicy'
 
 const policy = (over: Partial<RiskPolicy> = {}): RiskPolicy =>
   ({
@@ -20,6 +25,8 @@ const policy = (over: Partial<RiskPolicy> = {}): RiskPolicy =>
     judgeMaxBounces: 2,
     autoMergeEnabled: true,
     classRules: {},
+    classRulesByRole: {},
+    dryRunRoles: [],
     isDefault: true,
     version: 1,
     createdAt: 0,
@@ -51,3 +58,27 @@ describe('riskPolicyCeilings', () => {
     expect(Object.keys(RISK_POLICY_CEILING_FIELD).sort()).toEqual([...RISK_POLICY_AXES].sort())
   })
 })
+
+describe('rolePolicySummary', () => {
+  it('is empty on a policy that treats every initiator alike', () => {
+    expect(rolePolicySummary(policy())).toEqual({ sandboxed: [], narrowed: [] })
+  })
+
+  it('lists both layers in the shared role order', () => {
+    const p = policy({
+      dryRunRoles: ['viewer', 'member'],
+      classRulesByRole: { admin: { schema: 'never' } },
+    })
+    expect(rolePolicySummary(p)).toEqual({
+      sandboxed: ['member', 'viewer'],
+      narrowed: ['admin'],
+    })
+  })
+
+  // The sandbox outranks the class rules, so naming both for one role would report a second
+  // limit that changes nothing about what that role's runs can do.
+  it('does not also report class rules for a role the policy sandboxes', () => {
+    const p = policy({ dryRunRoles: ['member'], classRulesByRole: { member: { docs: 'never' } } })
+    expect(rolePolicySummary(p)).toEqual({ sandboxed: ['member'], narrowed: [] })
+  })
+})

package/app/utils/riskPolicy.ts

@@ -1,4 +1,5 @@
-import type { RiskPolicy } from '~/types/merge'
+import { WORKSPACE_ROLES } from '@cat-factory/contracts'
+import type { RiskPolicy, WorkspaceRole } from '~/types/merge'
 
 /**
  * The three axes a `merger` agent scores a pull request on. Presentation order is
@@ -40,3 +41,30 @@ export interface RiskPolicyCeiling {
 export function riskPolicyCeilings(p: RiskPolicy): RiskPolicyCeiling[] {
   return RISK_POLICY_AXES.map((axis) => ({ axis, max: p[RISK_POLICY_CEILING_FIELD[axis]] }))
 }
+
+/** What a policy's ROLE layer does, for the surfaces that explain a policy rather than edit it. */
+export interface RolePolicySummary {
+  /** Roles whose runs are sandboxed: they open a pull request and merge nothing. */
+  sandboxed: WorkspaceRole[]
+  /**
+   * Roles held to stricter per-class rules than the base map. A sandboxed role is NOT listed
+   * here even when it also carries class rules: the sandbox already outranks them, so naming
+   * both would read as two limits where the second changes nothing.
+   */
+  narrowed: WorkspaceRole[]
+}
+
+/**
+ * A policy's role layer, in the shared role order so every surface names the tiers the same way.
+ * Both lists are empty on a policy that treats every initiator alike, which is every built-in, so
+ * a surface can render the whole section conditionally on that.
+ */
+export function rolePolicySummary(p: RiskPolicy): RolePolicySummary {
+  const sandboxed = WORKSPACE_ROLES.filter((role) => p.dryRunRoles.includes(role))
+  return {
+    sandboxed: [...sandboxed],
+    narrowed: WORKSPACE_ROLES.filter(
+      (role) => !sandboxed.includes(role) && Object.keys(p.classRulesByRole[role] ?? {}).length > 0,
+    ),
+  }
+}

package/i18n/locales/de.json

@@ -522,6 +522,19 @@
           "always": "Immer automatisch zusammenführen",
           "never": "Immer Review verlangen"
         }
+      },
+      "roleRules": {
+        "heading": "Grenzen je startender Rolle",
+        "help": "Was ein Lauf darf, hängt auch davon ab, wer ihn gestartet hat. Eine Rolle kann strengeren Regeln als den obigen unterliegen oder nur Probeläufe machen: Die Pipeline arbeitet und öffnet einen Pull Request, zusammengeführt wird nichts. Eine Rolle kann diese Richtlinie nur verschärfen, nie lockern.",
+        "autoMergeOffWarning": "Für diese Vorlage ist das automatische Zusammenführen aus, jeder Pull Request geht also ohnehin an einen Menschen und die Kategoriegrenzen unten ändern nichts mehr. Probeläufe gelten weiterhin: Sie verweigern auch das manuelle Zusammenführen.",
+        "sandboxLabel": "Nur Probeläufe",
+        "sandboxNote": "Läufe dieser Rolle öffnen einen Pull Request und führen nichts zusammen, die Kategorieregeln unten können sie also nicht weiter einschränken.",
+        "noRules": "Keine Kategoriegrenzen",
+        "ruleCount": "{count} Kategorie eingeschränkt | {count} Kategorien eingeschränkt",
+        "inherit": "Wie in dieser Richtlinie",
+        "redundant": "Ohne Wirkung: Diese Richtlinie ist bereits mindestens so streng.",
+        "alreadyStrictest": "Wird ohnehin immer geprüft",
+        "baseHint": "Diese Richtlinie vergleicht in jeder Kategorie die Bewertungen, eine Rolle kann eine Kategorie daher nur auf \"immer Review\" verschärfen."
       }
     },
     "observabilityConnection": {
@@ -1161,7 +1174,28 @@
         "maxSweepFailures": "Aufeinanderfolgende fehlgeschlagene Durchläufe einer Hintergrundprüfung."
       },
       "notLoaded": "Die aktuellen Einstellungen dieses Kontos konnten nicht geladen werden; ein Speichern würde die übrigen überschreiben. Bitte vor dem Bearbeiten neu laden.",
-      "invalidNumbers": "Diese Obergrenzen sind keine Zahlen"
+      "invalidNumbers": "Diese Obergrenzen sind keine Zahlen",
+      "failureKinds": {
+        "label": "Regeln pro Fehlerart",
+        "description": "Alarm auslösen, wenn eine Fehlerart den Anteil an Fehlschlägen erreicht, den Sie ihr zugestehen. Die Obergrenze für die dominante Ursache oben fragt, ob eine Art alle anderen überlagert; diese Regeln fragen, ob eine benannte Art das erreicht, was diese Installation von ihr toleriert.",
+        "overrideLabel": "Eigene Regeln pro Fehlerart für dieses Konto festlegen",
+        "overrideHint": "Aus: Das Konto verwendet die Regeln der Installation. Ein: Die Liste unten ersetzt sie vollständig, und eine leere Liste bedeutet gar keine Regeln pro Fehlerart.",
+        "empty": "Keine Regeln. Dieses Konto löst den Alarm pro Fehlerart nicht aus.",
+        "kindLabel": "Fehlerart",
+        "shareLabel": "Anteil an Fehlschlägen (%)",
+        "shareHint": "Die Regel löst ab diesem Anteil aus.",
+        "minCountLabel": "Mindestanzahl Fehlschläge",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Wie viele Fehlschläge dieser Art im Zeitfenster nötig sind, bevor die Regel auslösen kann. Ohne diesen Wert ist ein niedriger Anteil überempfindlich: Fünf Läufe mit einer Verdrängung sind bereits 20 %.",
+        "addRule": "Regel hinzufügen",
+        "allKindsCovered": "Jede Fehlerart hat bereits eine Regel.",
+        "removeRule": "Regel entfernen",
+        "duplicateKind": "Jede Fehlerart darf höchstens eine Regel haben.",
+        "tooManyRules": "Höchstens {max} Regeln pro Fehlerart. Entfernen Sie einige vor dem Speichern.",
+        "unknownKind": "{kind} (unbekannt)",
+        "invalidTitle": "Diese Regeln pro Fehlerart können nicht gespeichert werden",
+        "invalidRows": "Prüfen Sie die Regeln {rows}: Der Anteil muss über 0 und höchstens 100 liegen, eine Mindestanzahl muss eine ganze Zahl ab 1 sein, und jede Art darf nur einmal vorkommen."
+      }
     }
   },
   "inspector": {
@@ -1539,7 +1573,9 @@
       "chooseApproach": "Ansatz wählen",
       "triageFollowUps": "Folgeaufgaben entscheiden",
       "elapsedTooltip": "Verstrichene Zeit für diesen Schritt",
-      "reviewFindings": "Befunde prüfen"
+      "reviewFindings": "Befunde prüfen",
+      "dryRun": "Probelauf",
+      "dryRunHint": "Dieser Lauf öffnet einen Pull Request und führt nichts zusammen."
     },
     "structure": {
       "title": "Struktur",
@@ -1960,7 +1996,10 @@
         "title": "Diesen Dienst archivieren?",
         "body": "„{name}“ und seine Aufgaben werden vom Board ausgeblendet. Du kannst den Dienst jederzeit wiederherstellen."
       },
-      "runBlocked": "Blockiert durch eine unerledigte Abhängigkeit: {names} | Blockiert durch {count} unerledigte Abhängigkeiten: {names}"
+      "runBlocked": "Blockiert durch eine unerledigte Abhängigkeit: {names} | Blockiert durch {count} unerledigte Abhängigkeiten: {names}",
+      "dryRun": "Probelauf: nichts zusammenführen",
+      "dryRunForced": "Probelauf: Läufe deiner Rolle werden hier nie zusammengeführt",
+      "dryRunHint": "Dieser Lauf öffnet einen Pull Request und führt nichts zusammen."
     }
   },
   "layout": {
@@ -2819,6 +2858,7 @@
       "start": "Starten",
       "blocked": "Blockiert",
       "startPipeline": "{name} starten",
+      "startPipelineDryRun": "{name} als Probelauf starten: öffnet einen Pull Request, führt nichts zusammen",
       "pipelineFallback": "Pipeline",
       "waitingOn": "Wartet auf: {deps}",
       "blockedByDependenciesTitle": "Durch Abhängigkeiten blockiert",
@@ -2844,6 +2884,10 @@
       "reviewAndApprove": "Überprüfen & freigeben",
       "clickToViewStep": "Klicken, um Schrittdetails & Ausgabe anzuzeigen"
     },
+    "dryRunToast": {
+      "title": "Probelauf gestartet",
+      "body": "\"{name}\" läuft. Läufe deiner Rolle führen bei dieser Aufgabe nichts zusammen."
+    },
     "epic": {
       "label": "Epic",
       "activeCount": "{count} aktiv",
@@ -5779,7 +5823,10 @@
     "description": "Beschreibung",
     "overallProgress": "Gesamtfortschritt",
     "dependencies": "Abhängigkeiten",
-    "noDependencies": "Keine"
+    "noDependencies": "Keine",
+    "dryRun": "Probelauf",
+    "dryRunHint": "Die Pipeline ausführen und einen Pull Request öffnen, aber nichts zusammenführen.",
+    "dryRunForcedHint": "Die Risikorichtlinie dieser Aufgabe lässt deine Rolle nur Probeläufe machen."
   },
   "environments": {
     "title": "Ephemere Umgebung",
@@ -6046,7 +6093,10 @@
       "manualHeading": "Nur manuelle Prüfung",
       "manualExplainer": "Diese Richtlinie mergt nie von selbst, jeder Pull Request wartet also unabhängig von den Bewertungen auf eine menschliche Prüfung.",
       "ciHeading": "CI-Fixes",
-      "ciAttempts": "Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt. | Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt."
+      "ciAttempts": "Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt. | Der Lauf darf {count} Mal versuchen, eine rote CI grün zu bekommen, bevor er aufgibt.",
+      "roleHeading": "Wer den Lauf gestartet hat",
+      "roleSandboxed": "Läufe von {roles} öffnen einen Pull Request und werden nie zusammengeführt.",
+      "roleNarrowed": "Für Läufe von {roles} gelten in einigen Änderungskategorien strengere Regeln."
     }
   },
   "modelPreset": {

package/i18n/locales/en.json

@@ -492,6 +492,7 @@
       "start": "Start",
       "blocked": "Blocked",
       "startPipeline": "Start {name}",
+      "startPipelineDryRun": "Start {name} as a dry run: opens a pull request, merges nothing",
       "pipelineFallback": "pipeline",
       "waitingOn": "Waiting on: {deps}",
       "blockedByDependenciesTitle": "Blocked by dependencies",
@@ -517,6 +518,13 @@
       "reviewAndApprove": "Review & approve",
       "clickToViewStep": "Click to view step details & output"
     },
+    "dryRunToast": {
+      "title": "Dry run started",
+      "body": "Running \"{name}\". Your role's runs merge nothing on this task."
+    },
+    "@dryRunToast": {
+      "description": "Toast shown when a run starts that the task's merge policy has sandboxed because of the initiator's workspace role: the pipeline runs and opens a pull request, and nothing merges. {name} is the pipeline name, kept verbatim. Not a choice the reader made, so word it as a statement of what the run will do rather than as a confirmation of a setting."
+    },
     "epic": {
       "label": "Epic",
       "activeCount": "{count} active",
@@ -1155,7 +1163,9 @@
       "chooseApproach": "Choose approach",
       "triageFollowUps": "Decide follow-ups",
       "elapsedTooltip": "Elapsed time on this step",
-      "reviewFindings": "Review findings"
+      "reviewFindings": "Review findings",
+      "dryRun": "Dry run",
+      "dryRunHint": "This run opens a pull request and merges nothing."
     },
     "structure": {
       "title": "Structure",
@@ -1584,7 +1594,10 @@
       "runBlocked": "Blocked by an unfinished dependency: {names} | Blocked by {count} unfinished dependencies: {names}",
       "@runBlocked": {
         "description": "Count-driven plural: {count} unfinished dependencies, {names} their comma-joined titles. Languages with more than two plural forms (e.g. Polish, Ukrainian: one/few/many) need the extra pipe-separated forms."
-      }
+      },
+      "dryRun": "Dry run: merge nothing",
+      "dryRunForced": "Dry run: your role's runs never merge here",
+      "dryRunHint": "This run opens a pull request and merges nothing."
     }
   },
   "observability": {
@@ -2977,6 +2990,22 @@
           "always": "Always auto-merge",
           "never": "Always require review"
         }
+      },
+      "roleRules": {
+        "heading": "Limits per initiator role",
+        "help": "What a run may do also depends on who started it. A role can be held to stricter rules than the ones above, or to dry runs only: the pipeline works and opens a pull request, and nothing merges. A role can only narrow this policy, never widen it.",
+        "autoMergeOffWarning": "Auto-merge is off for this preset, so every pull request already goes to a human and the class limits below add nothing. Dry runs still apply: they refuse a manual merge too.",
+        "sandboxLabel": "Dry runs only",
+        "sandboxNote": "Runs started by this role open a pull request and merge nothing, so the class rules below cannot hold them to anything stricter.",
+        "noRules": "No class limits",
+        "ruleCount": "{count} class limited | {count} classes limited",
+        "@ruleCount": {
+          "description": "Count-based tally of how many change classes this role narrows (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
+        },
+        "inherit": "Same as this policy",
+        "redundant": "No effect: this policy is already at least as strict.",
+        "alreadyStrictest": "Already always reviewed",
+        "baseHint": "This policy compares the scores for every class, so a role can only narrow a class to review-only."
       }
     },
     "observabilityConnection": {
@@ -3619,7 +3648,28 @@
         "maxSweepFailures": "Consecutive failed passes of one background sweep."
       },
       "notLoaded": "This account's current settings could not be loaded, so saving would overwrite the rest of them. Reload before editing.",
-      "invalidNumbers": "These ceilings are not numbers"
+      "invalidNumbers": "These ceilings are not numbers",
+      "failureKinds": {
+        "label": "Per-failure-kind rules",
+        "description": "Page when one failure kind reaches the share of failures you allow it. The dominant-cause ceiling above asks whether one kind is swamping the rest; these ask whether a named kind has reached what this deployment tolerates from it.",
+        "overrideLabel": "Set this account's own per-kind rules",
+        "overrideHint": "Off, the account uses the rules the deployment configured. On, the list below replaces them entirely, and an empty list means no per-kind rules at all.",
+        "empty": "No rules. This account will not raise the per-kind alert.",
+        "kindLabel": "Failure kind",
+        "shareLabel": "Share of failures (%)",
+        "shareHint": "The rule fires at this share or above.",
+        "minCountLabel": "Minimum failures",
+        "minCountPlaceholder": "1",
+        "minCountHint": "How many failures of that kind the window needs before the rule can fire. A low share is a hair trigger without it: five runs with one eviction is already 20%.",
+        "addRule": "Add rule",
+        "allKindsCovered": "Every failure kind already has a rule.",
+        "removeRule": "Remove rule",
+        "duplicateKind": "Each failure kind may carry at most one rule.",
+        "tooManyRules": "At most {max} per-kind rules. Remove some before saving.",
+        "unknownKind": "{kind} (unrecognised)",
+        "invalidTitle": "These per-kind rules cannot be saved",
+        "invalidRows": "Check rules {rows}: the share must be above 0 and at most 100, a minimum count must be a whole number of 1 or more, and each kind may appear once."
+      }
     }
   },
   "providers": {
@@ -4634,7 +4684,10 @@
       "manualHeading": "Manual review only",
       "manualExplainer": "This policy never merges on its own, so every pull request waits for a human review whatever it scores.",
       "ciHeading": "CI fixes",
-      "ciAttempts": "The run may try {count} time to turn a red CI green before it gives up. | The run may try {count} times to turn a red CI green before it gives up."
+      "ciAttempts": "The run may try {count} time to turn a red CI green before it gives up. | The run may try {count} times to turn a red CI green before it gives up.",
+      "roleHeading": "Who started the run",
+      "roleSandboxed": "Runs started by {roles} open a pull request and never merge.",
+      "roleNarrowed": "Runs started by {roles} follow stricter rules for some change classes."
     }
   },
   "modelPreset": {
@@ -5463,7 +5516,10 @@
     "description": "Description",
     "overallProgress": "Overall progress",
     "dependencies": "Dependencies",
-    "noDependencies": "None"
+    "noDependencies": "None",
+    "dryRun": "Dry run",
+    "dryRunHint": "Run the pipeline and open a pull request, but merge nothing.",
+    "dryRunForcedHint": "This task's risk policy holds your role to dry runs."
   },
   "environments": {
     "title": "Ephemeral environment",

package/i18n/locales/es.json

@@ -447,6 +447,7 @@
       "start": "Iniciar",
       "blocked": "Bloqueada",
       "startPipeline": "Iniciar {name}",
+      "startPipelineDryRun": "Iniciar {name} como ejecución de prueba: abre una pull request y no fusiona nada",
       "pipelineFallback": "pipeline",
       "waitingOn": "Esperando a: {deps}",
       "blockedByDependenciesTitle": "Bloqueada por dependencias",
@@ -472,6 +473,10 @@
         "body": "Ejecutando \"{name}\"."
       }
     },
+    "dryRunToast": {
+      "title": "Ejecución de prueba iniciada",
+      "body": "Ejecutando \"{name}\". Las ejecuciones de tu rol no fusionan nada en esta tarea."
+    },
     "epic": {
       "label": "Épica",
       "activeCount": "{count} activas",
@@ -1077,7 +1082,9 @@
       "chooseApproach": "Elegir enfoque",
       "triageFollowUps": "Decidir seguimientos",
       "elapsedTooltip": "Tiempo transcurrido en este paso",
-      "reviewFindings": "Revisar hallazgos"
+      "reviewFindings": "Revisar hallazgos",
+      "dryRun": "Ejecución de prueba",
+      "dryRunHint": "Esta ejecución abre una pull request y no fusiona nada."
     },
     "structure": {
       "title": "Estructura",
@@ -1498,7 +1505,10 @@
         "title": "¿Archivar este servicio?",
         "body": "«{name}» y sus tareas se ocultarán del tablero. Puedes restaurarlo en cualquier momento."
       },
-      "runBlocked": "Bloqueado por una dependencia sin terminar: {names} | Bloqueado por {count} dependencias sin terminar: {names}"
+      "runBlocked": "Bloqueado por una dependencia sin terminar: {names} | Bloqueado por {count} dependencias sin terminar: {names}",
+      "dryRun": "Ejecución de prueba: no fusionar nada",
+      "dryRunForced": "Ejecución de prueba: las ejecuciones de tu rol nunca se fusionan aquí",
+      "dryRunHint": "Esta ejecución abre una pull request y no fusiona nada."
     }
   },
   "observability": {
@@ -2738,6 +2748,19 @@
           "always": "Fusionar siempre automáticamente",
           "never": "Exigir siempre revisión"
         }
+      },
+      "roleRules": {
+        "heading": "Límites según el rol que inicia",
+        "help": "Lo que puede hacer una ejecución también depende de quién la inició. Un rol puede quedar sujeto a reglas más estrictas que las de arriba, o solo a ejecuciones de prueba: la canalización trabaja y abre una pull request, pero no se fusiona nada. Un rol solo puede endurecer esta política, nunca relajarla.",
+        "autoMergeOffWarning": "El auto-merge está desactivado en este preajuste, así que cada pull request ya pasa por una persona y los límites de categoría de abajo no añaden nada. Las ejecuciones de prueba siguen aplicándose: también rechazan una fusión manual.",
+        "sandboxLabel": "Solo ejecuciones de prueba",
+        "sandboxNote": "Las ejecuciones iniciadas por este rol abren una pull request y no fusionan nada, así que las reglas por categoría de abajo no pueden restringirlas más.",
+        "noRules": "Sin límites por categoría",
+        "ruleCount": "{count} categoría limitada | {count} categorías limitadas",
+        "inherit": "Igual que esta política",
+        "redundant": "Sin efecto: esta política ya es igual de estricta o más.",
+        "alreadyStrictest": "Ya se revisa siempre",
+        "baseHint": "Esta política compara las puntuaciones en todas las categorías, así que un rol solo puede endurecer una categoría hasta exigir revisión."
       }
     },
     "observabilityConnection": {
@@ -3518,7 +3541,28 @@
         "maxSweepFailures": "Pasadas fallidas consecutivas de un barrido en segundo plano."
       },
       "notLoaded": "No se pudieron cargar los ajustes actuales de esta cuenta, así que guardar sobrescribiría el resto. Vuelve a cargar antes de editar.",
-      "invalidNumbers": "Estos límites no son números"
+      "invalidNumbers": "Estos límites no son números",
+      "failureKinds": {
+        "label": "Reglas por tipo de fallo",
+        "description": "Avisa cuando un tipo de fallo alcanza la proporción de fallos que le permites. El límite de causa dominante de arriba pregunta si un tipo está desbordando al resto; estas reglas preguntan si un tipo concreto ha alcanzado lo que este despliegue tolera de él.",
+        "overrideLabel": "Definir reglas por tipo propias de esta cuenta",
+        "overrideHint": "Desactivado, la cuenta usa las reglas configuradas en el despliegue. Activado, la lista de abajo las sustituye por completo, y una lista vacía significa ninguna regla por tipo.",
+        "empty": "Sin reglas. Esta cuenta no generará la alerta por tipo de fallo.",
+        "kindLabel": "Tipo de fallo",
+        "shareLabel": "Proporción de fallos (%)",
+        "shareHint": "La regla se activa a partir de esta proporción.",
+        "minCountLabel": "Fallos mínimos",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Cuántos fallos de ese tipo necesita la ventana antes de que la regla pueda dispararse. Sin esto, una proporción baja salta a la mínima: cinco ejecuciones con un desalojo ya son el 20 %.",
+        "addRule": "Añadir regla",
+        "allKindsCovered": "Cada tipo de fallo ya tiene una regla.",
+        "removeRule": "Eliminar regla",
+        "duplicateKind": "Cada tipo de fallo admite como máximo una regla.",
+        "tooManyRules": "Como máximo {max} reglas por tipo. Elimina algunas antes de guardar.",
+        "unknownKind": "{kind} (no reconocido)",
+        "invalidTitle": "Estas reglas por tipo no se pueden guardar",
+        "invalidRows": "Revisa las reglas {rows}: la proporción debe ser mayor que 0 y como máximo 100, el mínimo debe ser un número entero de 1 o más, y cada tipo puede aparecer una sola vez."
+      }
     }
   },
   "providers": {
@@ -5224,7 +5268,10 @@
     "description": "Descripción",
     "overallProgress": "Progreso general",
     "dependencies": "Dependencias",
-    "noDependencies": "Ninguna"
+    "noDependencies": "Ninguna",
+    "dryRun": "Ejecución de prueba",
+    "dryRunHint": "Ejecutar la canalización y abrir una pull request, pero no fusionar nada.",
+    "dryRunForcedHint": "La política de riesgo de esta tarea limita tu rol a ejecuciones de prueba."
   },
   "environments": {
     "title": "Entorno efímero",
@@ -5913,7 +5960,10 @@
       "manualHeading": "Solo revisión manual",
       "manualExplainer": "Esta política nunca fusiona por su cuenta, así que cada pull request espera una revisión humana sea cual sea su puntuación.",
       "ciHeading": "Correcciones de CI",
-      "ciAttempts": "La ejecución puede intentar {count} vez poner CI en verde antes de rendirse. | La ejecución puede intentar {count} veces poner CI en verde antes de rendirse."
+      "ciAttempts": "La ejecución puede intentar {count} vez poner CI en verde antes de rendirse. | La ejecución puede intentar {count} veces poner CI en verde antes de rendirse.",
+      "roleHeading": "Quién inició la ejecución",
+      "roleSandboxed": "Las ejecuciones iniciadas por {roles} abren una pull request y nunca se fusionan.",
+      "roleNarrowed": "Las ejecuciones iniciadas por {roles} siguen reglas más estrictas en algunas categorías de cambio."
     }
   },
   "modelPreset": {

package/i18n/locales/fr.json

@@ -447,6 +447,7 @@
       "start": "Démarrer",
       "blocked": "Bloquée",
       "startPipeline": "Démarrer {name}",
+      "startPipelineDryRun": "Démarrer {name} en exécution à blanc : ouvre une pull request, ne fusionne rien",
       "pipelineFallback": "pipeline",
       "waitingOn": "En attente de : {deps}",
       "blockedByDependenciesTitle": "Bloquée par des dépendances",
@@ -472,6 +473,10 @@
         "body": "Exécution de \"{name}\"."
       }
     },
+    "dryRunToast": {
+      "title": "Exécution à blanc démarrée",
+      "body": "Exécution de \"{name}\". Les exécutions de ton rôle ne fusionnent rien sur cette tâche."
+    },
     "epic": {
       "label": "Épopée",
       "activeCount": "{count} actives",
@@ -1077,7 +1082,9 @@
       "chooseApproach": "Choisir l'approche",
       "triageFollowUps": "Trancher les suivis",
       "elapsedTooltip": "Temps écoulé sur cette étape",
-      "reviewFindings": "Examiner les remarques"
+      "reviewFindings": "Examiner les remarques",
+      "dryRun": "Exécution à blanc",
+      "dryRunHint": "Cette exécution ouvre une pull request et ne fusionne rien."
     },
     "structure": {
       "title": "Structure",
@@ -1498,7 +1505,10 @@
         "title": "Archiver ce service ?",
         "body": "« {name} » et ses tâches seront masqués du tableau. Vous pouvez le restaurer à tout moment."
       },
-      "runBlocked": "Bloqué par une dépendance non terminée : {names} | Bloqué par {count} dépendances non terminées : {names}"
+      "runBlocked": "Bloqué par une dépendance non terminée : {names} | Bloqué par {count} dépendances non terminées : {names}",
+      "dryRun": "Exécution à blanc : ne rien fusionner",
+      "dryRunForced": "Exécution à blanc : les exécutions de votre rôle ne sont jamais fusionnées ici",
+      "dryRunHint": "Cette exécution ouvre une pull request et ne fusionne rien."
     }
   },
   "observability": {
@@ -2738,6 +2748,19 @@
           "always": "Toujours fusionner automatiquement",
           "never": "Toujours exiger une revue"
         }
+      },
+      "roleRules": {
+        "heading": "Limites selon le rôle qui lance l'exécution",
+        "help": "Ce qu'une exécution peut faire dépend aussi de qui l'a lancée. Un rôle peut être soumis à des règles plus strictes que celles ci-dessus, ou aux seules exécutions à blanc : le pipeline travaille et ouvre une pull request, mais rien n'est fusionné. Un rôle peut seulement durcir cette politique, jamais l'assouplir.",
+        "autoMergeOffWarning": "La fusion automatique est désactivée pour ce préréglage : chaque pull request passe déjà par un humain et les limites de catégorie ci-dessous n'ajoutent rien. Les exécutions à blanc restent en vigueur : elles refusent aussi une fusion manuelle.",
+        "sandboxLabel": "Exécutions à blanc uniquement",
+        "sandboxNote": "Les exécutions lancées par ce rôle ouvrent une pull request et ne fusionnent rien : les règles par catégorie ci-dessous ne peuvent donc rien durcir de plus.",
+        "noRules": "Aucune limite par catégorie",
+        "ruleCount": "{count} catégorie limitée | {count} catégories limitées",
+        "inherit": "Comme cette politique",
+        "redundant": "Sans effet : cette politique est déjà au moins aussi stricte.",
+        "alreadyStrictest": "Déjà toujours relu",
+        "baseHint": "Cette politique compare les scores pour chaque catégorie : un rôle ne peut donc durcir une catégorie que jusqu'à la revue obligatoire."
       }
     },
     "observabilityConnection": {
@@ -3518,7 +3541,28 @@
         "maxSweepFailures": "Passages consécutifs en échec d'un balayage en arrière-plan."
       },
       "notLoaded": "Les paramètres actuels de ce compte n'ont pas pu être chargés ; enregistrer écraserait les autres. Rechargez avant de modifier.",
-      "invalidNumbers": "Ces plafonds ne sont pas des nombres"
+      "invalidNumbers": "Ces plafonds ne sont pas des nombres",
+      "failureKinds": {
+        "label": "Règles par type d'échec",
+        "description": "Alerter quand un type d'échec atteint la part d'échecs que vous lui accordez. Le plafond de cause dominante ci-dessus demande si un type submerge les autres ; ces règles demandent si un type nommé a atteint ce que ce déploiement tolère de lui.",
+        "overrideLabel": "Définir les règles par type propres à ce compte",
+        "overrideHint": "Désactivé, le compte utilise les règles configurées par le déploiement. Activé, la liste ci-dessous les remplace entièrement, et une liste vide signifie aucune règle par type.",
+        "empty": "Aucune règle. Ce compte ne déclenchera pas l'alerte par type d'échec.",
+        "kindLabel": "Type d'échec",
+        "shareLabel": "Part des échecs (%)",
+        "shareHint": "La règle se déclenche à partir de cette part.",
+        "minCountLabel": "Échecs minimum",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Combien d'échecs de ce type la fenêtre doit compter avant que la règle puisse se déclencher. Sans cela, une part faible se déclenche pour un rien : cinq exécutions avec une éviction, c'est déjà 20 %.",
+        "addRule": "Ajouter une règle",
+        "allKindsCovered": "Chaque type d'échec a déjà une règle.",
+        "removeRule": "Supprimer la règle",
+        "duplicateKind": "Chaque type d'échec ne peut porter qu'une seule règle.",
+        "tooManyRules": "Au plus {max} règles par type. Supprimez-en avant d’enregistrer.",
+        "unknownKind": "{kind} (non reconnu)",
+        "invalidTitle": "Ces règles par type ne peuvent pas être enregistrées",
+        "invalidRows": "Vérifiez les règles {rows} : la part doit être supérieure à 0 et au plus 100, un minimum doit être un entier supérieur ou égal à 1, et chaque type ne peut apparaître qu'une fois."
+      }
     }
   },
   "providers": {
@@ -5224,7 +5268,10 @@
     "description": "Description",
     "overallProgress": "Progression globale",
     "dependencies": "Dépendances",
-    "noDependencies": "Aucune"
+    "noDependencies": "Aucune",
+    "dryRun": "Exécution à blanc",
+    "dryRunHint": "Lancer le pipeline et ouvrir une pull request, sans rien fusionner.",
+    "dryRunForcedHint": "La politique de risque de cette tâche limite votre rôle aux exécutions à blanc."
   },
   "environments": {
     "title": "Environnement éphémère",
@@ -5913,7 +5960,10 @@
       "manualHeading": "Revue manuelle uniquement",
       "manualExplainer": "Cette politique ne fusionne jamais d'elle-même : chaque pull request attend une revue humaine, quelles que soient les notes.",
       "ciHeading": "Corrections CI",
-      "ciAttempts": "L'exécution peut tenter {count} fois de remettre la CI au vert avant d'abandonner. | L'exécution peut tenter {count} fois de remettre la CI au vert avant d'abandonner."
+      "ciAttempts": "L'exécution peut tenter {count} fois de remettre la CI au vert avant d'abandonner. | L'exécution peut tenter {count} fois de remettre la CI au vert avant d'abandonner.",
+      "roleHeading": "Qui a lancé l'exécution",
+      "roleSandboxed": "Les exécutions lancées par {roles} ouvrent une pull request et ne sont jamais fusionnées.",
+      "roleNarrowed": "Les exécutions lancées par {roles} suivent des règles plus strictes pour certaines catégories de changement."
     }
   },
   "modelPreset": {