@cat-factory/app 0.217.2 → 0.218.0

package/app/types/merge.ts

@@ -11,6 +11,12 @@ export type {
   MergeClassRollup,
   MergeClassRule,
   MergeClassRules,
+  RuleableChangeClass,
+  // The ROLE layer of a preset: per-role narrowing of the rules above, and the roles whose
+  // runs are sandboxed (they open a pull request and merge nothing).
+  ClassRulesByRole,
+  DryRunRoles,
+  WorkspaceRole,
   MergeTrackRecord,
   ReviewEffort,
   RequirementConcernLevel,

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": {
@@ -1539,7 +1552,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 +1975,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 +2837,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 +2863,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 +5802,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 +6072,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": {
@@ -4634,7 +4663,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 +5495,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": {
@@ -5224,7 +5247,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 +5939,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": {
@@ -5224,7 +5247,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 +5939,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": {

package/i18n/locales/he.json

@@ -447,6 +447,7 @@
       "start": "התחל",
       "blocked": "חסום",
       "startPipeline": "התחל {name}",
+      "startPipelineDryRun": "להתחיל את {name} כהרצת יבש: נפתחת בקשת משיכה ולא ממוזג דבר",
       "pipelineFallback": "צינור",
       "waitingOn": "ממתין ל: {deps}",
       "blockedByDependenciesTitle": "חסום על ידי תלויות",
@@ -472,6 +473,10 @@
         "body": "מריץ את \"{name}\"."
       }
     },
+    "dryRunToast": {
+      "title": "הרצת יבש החלה",
+      "body": "מריץ את \"{name}\". הרצות של התפקיד שלך לא ממזגות דבר במשימה הזו."
+    },
     "epic": {
       "label": "אפיק",
       "activeCount": "{count} פעילים",
@@ -1077,7 +1082,9 @@
       "chooseApproach": "בחר גישה",
       "triageFollowUps": "הכרע בהמשכים",
       "elapsedTooltip": "הזמן שחלף בשלב זה",
-      "reviewFindings": "עיין בממצאים"
+      "reviewFindings": "עיין בממצאים",
+      "dryRun": "הרצת יבש",
+      "dryRunHint": "ההרצה הזו פותחת בקשת משיכה ואינה ממזגת דבר."
     },
     "structure": {
       "title": "מבנה",
@@ -1498,7 +1505,10 @@
         "title": "להעביר שירות זה לארכיון?",
         "body": "\"{name}\" והמשימות שלו יוסתרו מהלוח. אפשר לשחזר אותו בכל עת."
       },
-      "runBlocked": "חסום על ידי תלות אחת שלא הושלמה: {names} | חסום על ידי שתי תלויות שלא הושלמו: {names} | חסום על ידי {count} תלויות שלא הושלמו: {names}"
+      "runBlocked": "חסום על ידי תלות אחת שלא הושלמה: {names} | חסום על ידי שתי תלויות שלא הושלמו: {names} | חסום על ידי {count} תלויות שלא הושלמו: {names}",
+      "dryRun": "הרצת יבש: לא למזג דבר",
+      "dryRunForced": "הרצת יבש: הרצות של התפקיד שלך לעולם אינן ממוזגות כאן",
+      "dryRunHint": "ההרצה הזו פותחת בקשת משיכה ואינה ממזגת דבר."
     }
   },
   "observability": {
@@ -2879,6 +2889,19 @@
           "always": "למזג תמיד אוטומטית",
           "never": "לדרוש תמיד סקירה"
         }
+      },
+      "roleRules": {
+        "heading": "מגבלות לפי תפקיד המפעיל",
+        "help": "מה שהרצה רשאית לעשות תלוי גם במי שהפעיל אותה. אפשר להחיל על תפקיד כללים מחמירים יותר מאלה שלמעלה, או להגביל אותו להרצות יבשות בלבד: הפייפליין עובד ופותח בקשת משיכה, ושום דבר לא ממוזג. תפקיד יכול רק להחמיר את המדיניות הזו, לעולם לא להקל אותה.",
+        "autoMergeOffWarning": "המיזוג האוטומטי כבוי בהגדרה הזאת, ולכן כל בקשת מיזוג ממילא עוברת לאדם והמגבלות לפי סוג שלמטה כבר לא מוסיפות דבר. הרצות יבשות עדיין חלות: הן מסרבות גם למיזוג ידני.",
+        "sandboxLabel": "הרצות יבשות בלבד",
+        "sandboxNote": "הרצות שמפעיל התפקיד הזה פותחות בקשת משיכה ואינן ממזגות דבר, ולכן הכללים לפי סוג השינוי שלמטה אינם יכולים להחמיר אותן עוד.",
+        "noRules": "אין מגבלות לפי סוג",
+        "ruleCount": "סוג אחד מוגבל | שני סוגים מוגבלים | {count} סוגים מוגבלים",
+        "inherit": "כמו במדיניות הזו",
+        "redundant": "ללא השפעה: המדיניות הזו כבר מחמירה לפחות באותה מידה.",
+        "alreadyStrictest": "כבר תמיד נדרשת סקירה",
+        "baseHint": "המדיניות הזו משווה את הציונים בכל סוג שינוי, ולכן תפקיד יכול להחמיר סוג רק עד דרישת סקירה."
       }
     },
     "observabilityConnection": {
@@ -5224,7 +5247,10 @@
     "description": "תיאור",
     "overallProgress": "התקדמות כוללת",
     "dependencies": "תלויות",
-    "noDependencies": "אין"
+    "noDependencies": "אין",
+    "dryRun": "הרצת יבש",
+    "dryRunHint": "להריץ את הפייפליין ולפתוח בקשת משיכה, בלי למזג דבר.",
+    "dryRunForcedHint": "מדיניות הסיכון של המשימה הזו מגבילה את התפקיד שלך להרצות יבשות."
   },
   "environments": {
     "title": "סביבה זמנית",
@@ -5913,7 +5939,10 @@
       "manualHeading": "סקירה ידנית בלבד",
       "manualExplainer": "מדיניות זו לעולם אינה ממזגת מעצמה, ולכן כל בקשת משיכה ממתינה לסקירה אנושית ללא קשר לניקוד.",
       "ciHeading": "תיקוני CI",
-      "ciAttempts": "ההרצה רשאית לנסות פעם אחת להחזיר CI אדום למצב ירוק לפני שהיא מוותרת. | ההרצה רשאית לנסות פעמיים להחזיר CI אדום למצב ירוק לפני שהיא מוותרת. | ההרצה רשאית לנסות {count} פעמים להחזיר CI אדום למצב ירוק לפני שהיא מוותרת."
+      "ciAttempts": "ההרצה רשאית לנסות פעם אחת להחזיר CI אדום למצב ירוק לפני שהיא מוותרת. | ההרצה רשאית לנסות פעמיים להחזיר CI אדום למצב ירוק לפני שהיא מוותרת. | ההרצה רשאית לנסות {count} פעמים להחזיר CI אדום למצב ירוק לפני שהיא מוותרת.",
+      "roleHeading": "מי הפעיל את ההרצה",
+      "roleSandboxed": "הרצות שמפעילים {roles} פותחות בקשת משיכה ולעולם אינן ממוזגות.",
+      "roleNarrowed": "על הרצות שמפעילים {roles} חלים כללים מחמירים יותר בחלק מסוגי השינוי."
     }
   },
   "modelPreset": {

package/i18n/locales/it.json

@@ -522,6 +522,19 @@
           "always": "Unisci sempre automaticamente",
           "never": "Richiedi sempre una revisione"
         }
+      },
+      "roleRules": {
+        "heading": "Limiti per ruolo di chi avvia",
+        "help": "Ciò che un'esecuzione può fare dipende anche da chi l'ha avviata. Un ruolo può essere soggetto a regole più severe di quelle sopra, oppure alle sole prove: la pipeline lavora e apre una pull request, ma non viene unito nulla. Un ruolo può solo restringere questo criterio, mai allargarlo.",
+        "autoMergeOffWarning": "L'unione automatica è disattivata per questo preset, quindi ogni pull request passa già da una persona e i limiti per categoria qui sotto non aggiungono nulla. Le prove restano valide: rifiutano anche un'unione manuale.",
+        "sandboxLabel": "Solo prove",
+        "sandboxNote": "Le esecuzioni avviate da questo ruolo aprono una pull request e non uniscono nulla, quindi le regole per categoria qui sotto non possono restringerle ulteriormente.",
+        "noRules": "Nessun limite per categoria",
+        "ruleCount": "{count} categoria limitata | {count} categorie limitate",
+        "inherit": "Come questo criterio",
+        "redundant": "Nessun effetto: questo criterio è già almeno altrettanto severo.",
+        "alreadyStrictest": "Già sempre in revisione",
+        "baseHint": "Questo criterio confronta i punteggi per ogni categoria, quindi un ruolo può restringere una categoria solo fino alla revisione obbligatoria."
       }
     },
     "observabilityConnection": {
@@ -1539,7 +1552,9 @@
       "chooseApproach": "Scegli approccio",
       "triageFollowUps": "Decidi i follow-up",
       "elapsedTooltip": "Tempo trascorso su questo passaggio",
-      "reviewFindings": "Esamina i rilievi"
+      "reviewFindings": "Esamina i rilievi",
+      "dryRun": "Prova",
+      "dryRunHint": "Questa esecuzione apre una pull request e non unisce nulla."
     },
     "structure": {
       "title": "Struttura",
@@ -1960,7 +1975,10 @@
         "title": "Archiviare questo servizio?",
         "body": "\"{name}\" e le sue attività verranno nascosti dalla board. Puoi ripristinarlo in qualsiasi momento."
       },
-      "runBlocked": "Bloccato da una dipendenza non completata: {names} | Bloccato da {count} dipendenze non completate: {names}"
+      "runBlocked": "Bloccato da una dipendenza non completata: {names} | Bloccato da {count} dipendenze non completate: {names}",
+      "dryRun": "Prova: non unire nulla",
+      "dryRunForced": "Prova: le esecuzioni del tuo ruolo qui non vengono mai unite",
+      "dryRunHint": "Questa esecuzione apre una pull request e non unisce nulla."
     }
   },
   "layout": {
@@ -2819,6 +2837,7 @@
       "start": "Avvia",
       "blocked": "Bloccato",
       "startPipeline": "Avvia {name}",
+      "startPipelineDryRun": "Avvia {name} come prova: apre una pull request e non unisce nulla",
       "pipelineFallback": "pipeline",
       "waitingOn": "In attesa di: {deps}",
       "blockedByDependenciesTitle": "Bloccato dalle dipendenze",
@@ -2844,6 +2863,10 @@
       "reviewAndApprove": "Rivedi e approva",
       "clickToViewStep": "Clicca per vedere i dettagli e l'output della fase"
     },
+    "dryRunToast": {
+      "title": "Prova avviata",
+      "body": "Esecuzione di \"{name}\". Le esecuzioni del tuo ruolo non uniscono nulla su questa attività."
+    },
     "epic": {
       "label": "Epic",
       "activeCount": "{count} attive",
@@ -5779,7 +5802,10 @@
     "description": "Descrizione",
     "overallProgress": "Avanzamento complessivo",
     "dependencies": "Dipendenze",
-    "noDependencies": "Nessuna"
+    "noDependencies": "Nessuna",
+    "dryRun": "Prova",
+    "dryRunHint": "Esegui la pipeline e apri una pull request, senza unire nulla.",
+    "dryRunForcedHint": "Il criterio di rischio di questa attività limita il tuo ruolo alle sole prove."
   },
   "environments": {
     "title": "Ambiente effimero",
@@ -6046,7 +6072,10 @@
       "manualHeading": "Solo revisione manuale",
       "manualExplainer": "Questo criterio non unisce mai da solo, quindi ogni pull request attende una revisione umana qualunque sia il punteggio.",
       "ciHeading": "Correzioni CI",
-      "ciAttempts": "L'esecuzione può fare {count} tentativo per rimettere in verde la CI prima di arrendersi. | L'esecuzione può fare {count} tentativi per rimettere in verde la CI prima di arrendersi."
+      "ciAttempts": "L'esecuzione può fare {count} tentativo per rimettere in verde la CI prima di arrendersi. | L'esecuzione può fare {count} tentativi per rimettere in verde la CI prima di arrendersi.",
+      "roleHeading": "Chi ha avviato l'esecuzione",
+      "roleSandboxed": "Le esecuzioni avviate da {roles} aprono una pull request e non vengono mai unite.",
+      "roleNarrowed": "Le esecuzioni avviate da {roles} seguono regole più severe per alcune categorie di modifica."
     }
   },
   "modelPreset": {