@cat-factory/app 0.210.1 → 0.212.0

package/app/components/layout/NotificationsInbox.vue

@@ -8,7 +8,7 @@ import type { ReviewEffort } from '~/types/merge'
 // (merge / confirm / retry) or dismissed. Hydrated from the snapshot and patched
 // live via the `notification` WorkspaceEvent.
 
-const { t, te } = useI18n()
+const { t, te, d } = useI18n()
 
 const notifications = useNotificationsStore()
 const ui = useUiStore()
@@ -326,6 +326,44 @@ function revealVisualConfirm(n: Notification) {
   else if (n.blockId) ui.select(n.blockId)
 }
 
+/**
+ * The failing runs a `platform_health` card is aggregating, captured when the alert fired.
+ * Empty for a card raised on a condition with no failing run behind it (a backlog or a stall),
+ * where the payload carries no list at all, which is the point: an empty list would read as
+ * "we looked and found no failures".
+ */
+function failingRuns(n: Notification) {
+  return n.payload?.platformFailingRuns ?? []
+}
+
+/**
+ * How many of the workspace's failures the card is showing. Rendered only when the sample is
+ * SHORT of the total, so the card states what it left out instead of presenting the cap as the
+ * whole story.
+ */
+function failingRunsOmitted(n: Notification): number {
+  return Math.max(0, (n.payload?.platformFailedTotal ?? 0) - failingRuns(n).length)
+}
+
+/**
+ * Whether a linked failing run can actually be opened. A run that has since aged out of the
+ * board's loaded set and carries no block is a link to nowhere, and rendering it as clickable
+ * would be worse than rendering it plainly: the operator would read "nothing happened" from a
+ * click that silently did nothing.
+ */
+function canOpenFailingRun(run: { executionId: string; blockId: string | null }): boolean {
+  return !!execution.getInstance(run.executionId) || !!run.blockId
+}
+
+/**
+ * Open one failing run behind a platform-health alert: its observability drill-down when the
+ * run is loaded (the "why did this fail" surface), otherwise focus its task on the board.
+ */
+function revealFailingRun(run: { executionId: string; blockId: string | null }) {
+  if (execution.getInstance(run.executionId)) ui.openObservability(run.executionId)
+  else if (run.blockId) ui.select(run.blockId)
+}
+
 /**
  * Open the decision surface for a parked iteration-cap run: find the run's step that is
  * waiting on a human and open it through the universal step dispatch — which routes a
@@ -401,6 +439,43 @@ function revealDecision(n: Notification) {
                 <UIcon name="i-lucide-external-link" class="h-3 w-3" />
                 {{ t('layout.notifications.openPr') }}
               </a>
+              <!--
+                A platform-health card deep-links to the runs it aggregated, so the operator
+                lands on the evidence rather than only on the dashboard.
+              -->
+              <div
+                v-if="failingRuns(n).length"
+                class="mt-1.5 flex flex-col gap-0.5"
+                data-testid="notification-failing-runs"
+              >
+                <component
+                  :is="canOpenFailingRun(run) ? 'button' : 'span'"
+                  v-for="run in failingRuns(n)"
+                  :key="run.executionId"
+                  :type="canOpenFailingRun(run) ? 'button' : undefined"
+                  class="flex items-center gap-1 text-start text-[11px]"
+                  :class="
+                    canOpenFailingRun(run)
+                      ? 'text-sky-400 hover:underline'
+                      : 'cursor-default text-slate-500'
+                  "
+                  :title="
+                    canOpenFailingRun(run) ? undefined : t('layout.notifications.failingRunGone')
+                  "
+                  @click="canOpenFailingRun(run) && revealFailingRun(run)"
+                >
+                  <UIcon name="i-lucide-circle-alert" class="h-3 w-3 shrink-0" />
+                  <span class="truncate">{{
+                    t('layout.notifications.failingRun', {
+                      kind: run.failureKind,
+                      at: d(new Date(run.createdAt), 'short'),
+                    })
+                  }}</span>
+                </component>
+                <span v-if="failingRunsOmitted(n) > 0" class="text-[11px] text-slate-500">
+                  {{ t('layout.notifications.failingRunsMore', { count: failingRunsOmitted(n) }) }}
+                </span>
+              </div>
               <MergeEffortChips
                 v-if="collectsEffort(n)"
                 :model-value="effortFor(n)"

package/app/components/panels/OperatorDashboardPanel.vue

@@ -25,6 +25,8 @@ const WINDOWS: { value: PlatformObservabilityWindow; label: string }[] = [
   { value: '1h', label: t('platformObservability.window.oneHour') },
   { value: '24h', label: t('platformObservability.window.oneDay') },
   { value: '7d', label: t('platformObservability.window.sevenDays') },
+  { value: '30d', label: t('platformObservability.window.thirtyDays') },
+  { value: '90d', label: t('platformObservability.window.ninetyDays') },
 ]
 
 // Exhaustive enum→label map (tier-2 dynamic-key guard): a new AgentFailureKind fails the
@@ -48,6 +50,21 @@ function failureLabel(kind: string): string {
   return key ? t(key) : kind
 }
 
+const DAY_MS = 24 * 60 * 60 * 1000
+
+// How the window was answered. A rollup-backed window that has materialised NOTHING must not
+// render as a quiet quarter, and one whose watermark is well behind `now` must not render its
+// empty tail as idleness, so the banner distinguishes "no rollup yet", "the rollup is behind"
+// and "up to date" rather than leaving all three to look like data.
+const rollupState = computed<'none' | 'stale' | 'current' | null>(() => {
+  const v = view.value
+  if (!v || v.source !== 'daily-rollup') return null
+  if (v.rolledUpThrough == null) return 'none'
+  // A day of slack: the sweep materialises the CURRENT day, so being one bucket behind is the
+  // normal state between passes rather than a gap worth flagging.
+  return v.generatedAt - v.rolledUpThrough > 2 * DAY_MS ? 'stale' : 'current'
+})
+
 // The largest failure count, so each taxonomy bar is drawn relative to the leader.
 const maxFailure = computed(() => Math.max(1, ...(view.value?.failures ?? []).map((f) => f.count)))
 // The largest total in any trend bucket, so each stacked column scales to the tallest.
@@ -58,6 +75,13 @@ const maxTrend = computed(() =>
 function barPct(count: number, max: number): number {
   return Math.round((count / max) * 100)
 }
+
+// Share of a gate kind's runs the precheck satisfied outright, 0..1: the number the
+// precheck-before-escalate design exists to move. Null (not 0) when nothing settled, because
+// "no gates ran" is not "every gate needed a fixer".
+function cleanRate(stat: { gates: number; cleanPasses: number }): number | null {
+  return stat.gates > 0 ? stat.cleanPasses / stat.gates : null
+}
 function heightPct(count: number, max: number): number {
   // Floor a non-zero column to 4% so a single run is still visible in the sparkline.
   return count === 0 ? 0 : Math.max(4, Math.round((count / max) * 100))
@@ -170,6 +194,41 @@ watch(
           </div>
 
           <div v-else-if="view" class="mx-auto flex max-w-5xl flex-col gap-6">
+            <!--
+              Rollup provenance. An un-materialised rollup and an idle quarter produce the same
+              empty series, so the long windows say which one this is instead of showing
+              confident zeros.
+            -->
+            <p
+              v-if="rollupState === 'none'"
+              class="rounded-lg border border-amber-800/60 bg-amber-950/30 px-3 py-2 text-xs text-amber-200"
+              data-testid="operator-rollup-missing"
+            >
+              {{ t('platformObservability.rollup.none') }}
+            </p>
+            <p
+              v-else-if="rollupState === 'stale'"
+              class="rounded-lg border border-amber-800/60 bg-amber-950/30 px-3 py-2 text-xs text-amber-200"
+              data-testid="operator-rollup-stale"
+            >
+              {{
+                t('platformObservability.rollup.stale', {
+                  date: d(new Date(view.rolledUpThrough ?? 0), 'short'),
+                })
+              }}
+            </p>
+            <p
+              v-else-if="rollupState === 'current'"
+              class="text-xs text-slate-500"
+              data-testid="operator-rollup-current"
+            >
+              {{
+                t('platformObservability.rollup.current', {
+                  date: d(new Date(view.rolledUpThrough ?? 0), 'short'),
+                })
+              }}
+            </p>
+
             <!-- Outcome summary tiles -->
             <section>
               <h2 class="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-500">
@@ -271,6 +330,77 @@ watch(
               </div>
             </section>
 
+            <!-- Gate / CI-fixer attempt statistics -->
+            <section>
+              <h2 class="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-500">
+                {{ t('platformObservability.gates.title') }}
+              </h2>
+              <div class="overflow-x-auto rounded-lg border border-slate-800 bg-slate-900/40 p-4">
+                <p v-if="!view.gates.length" class="py-4 text-center text-xs text-slate-500">
+                  {{ t('platformObservability.gates.empty') }}
+                </p>
+                <table v-else class="w-full text-left text-xs" data-testid="operator-gates">
+                  <thead class="text-[11px] uppercase tracking-wide text-slate-500">
+                    <tr>
+                      <th class="pb-2 pe-3 font-medium">
+                        {{ t('platformObservability.gates.gate') }}
+                      </th>
+                      <th class="pb-2 pe-3 text-end font-medium">
+                        {{ t('platformObservability.gates.settled') }}
+                      </th>
+                      <th class="pb-2 pe-3 text-end font-medium">
+                        {{ t('platformObservability.gates.cleanPasses') }}
+                      </th>
+                      <th class="pb-2 pe-3 text-end font-medium">
+                        {{ t('platformObservability.gates.attempts') }}
+                      </th>
+                      <th class="pb-2 pe-3 text-end font-medium">
+                        {{ t('platformObservability.gates.helperFailures') }}
+                      </th>
+                      <th class="pb-2 text-end font-medium">
+                        {{ t('platformObservability.gates.exhausted') }}
+                      </th>
+                    </tr>
+                  </thead>
+                  <tbody class="text-slate-300">
+                    <tr
+                      v-for="g in view.gates"
+                      :key="g.gateKind"
+                      class="border-t border-slate-800/70"
+                    >
+                      <td class="py-2 pe-3">
+                        <span class="font-medium text-slate-200">{{ g.gateKind }}</span>
+                        <span v-if="g.helperKind" class="ms-1.5 text-slate-500"
+                          >&rarr; {{ g.helperKind }}</span
+                        >
+                      </td>
+                      <td class="py-2 pe-3 text-end tabular-nums">{{ g.gates }}</td>
+                      <td class="py-2 pe-3 text-end tabular-nums">
+                        <span class="text-emerald-400">{{ g.cleanPasses }}</span>
+                        <span v-if="cleanRate(g) !== null" class="ms-1 text-slate-500"
+                          >({{ n(cleanRate(g) ?? 0, 'percent') }})</span
+                        >
+                      </td>
+                      <td class="py-2 pe-3 text-end tabular-nums">{{ g.attempts }}</td>
+                      <td class="py-2 pe-3 text-end tabular-nums">
+                        <span :class="g.helperFailures > 0 ? 'text-amber-400' : ''">{{
+                          g.helperFailures
+                        }}</span>
+                      </td>
+                      <td class="py-2 text-end tabular-nums">
+                        <span :class="g.exhausted > 0 ? 'text-rose-400' : ''">{{
+                          g.exhausted
+                        }}</span>
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+                <p class="mt-3 text-[11px] leading-relaxed text-slate-500">
+                  {{ t('platformObservability.gates.hint') }}
+                </p>
+              </div>
+            </section>
+
             <div class="grid gap-6 md:grid-cols-2">
               <!-- Failure taxonomy -->
               <section>

package/app/components/settings/LocalModelEndpointsPanel.vue

@@ -6,7 +6,12 @@
 // serves and tick which to enable. Save persists the endpoint; the enabled models then surface
 // automatically in the per-workspace model picker. One endpoint per runner type.
 import { computed, ref, watch } from 'vue'
-import { LOCAL_RUNNER_DEFAULTS, LOCAL_RUNNER_LABELS, type LocalRunner } from '~/types/localModels'
+import {
+  LOCAL_RUNNER_DEFAULTS,
+  LOCAL_RUNNER_LABELS,
+  type LocalRunner,
+  type LocalRunnerUrlReason,
+} from '~/types/localModels'
 import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 import SecretInput from '~/components/common/SecretInput.vue'
 
@@ -36,6 +41,23 @@ const RUNNERS: { value: LocalRunner; label: string }[] = (
   Object.keys(LOCAL_RUNNER_LABELS) as LocalRunner[]
 ).map((value) => ({ value, label: LOCAL_RUNNER_LABELS[value] }))
 
+// Why the deployment refuses a runner URL, in translated copy. An exhaustive Record keyed
+// off the contracts union, so adding a reason backend-side fails this typecheck instead of
+// rendering the backend's English (which stays available as the "details" line).
+const URL_REASON_KEYS = {
+  invalid_url: 'settings.localModelEndpoints.urlReason.invalid_url',
+  scheme_not_allowed: 'settings.localModelEndpoints.urlReason.scheme_not_allowed',
+  credentials_not_allowed: 'settings.localModelEndpoints.urlReason.credentials_not_allowed',
+  query_or_fragment_not_allowed:
+    'settings.localModelEndpoints.urlReason.query_or_fragment_not_allowed',
+  host_not_loopback: 'settings.localModelEndpoints.urlReason.host_not_loopback',
+  host_not_local: 'settings.localModelEndpoints.urlReason.host_not_local',
+} as const satisfies Record<LocalRunnerUrlReason, string>
+
+function urlReasonText(reason: LocalRunnerUrlReason): string {
+  return t(URL_REASON_KEYS[reason])
+}
+
 // ---- add / edit draft ------------------------------------------------------
 const provider = ref<LocalRunner>('ollama')
 const label = ref('')
@@ -45,6 +67,9 @@ const apiKey = ref('')
 const discovered = ref<string[]>([])
 const selected = ref<string[]>([])
 const testError = ref<string | null>(null)
+// The backend's own wording, kept as DETAIL beside a translated refusal rather than being
+// shown as the description (it names env vars an operator, not this user, acts on).
+const testErrorDetail = ref<string | null>(null)
 const tested = ref(false)
 const testing = ref(false)
 const busy = ref(false)
@@ -84,6 +109,7 @@ async function test() {
   if (!baseUrl.value.trim()) return
   testing.value = true
   testError.value = null
+  testErrorDetail.value = null
   try {
     const result = await store.test({
       provider: provider.value,
@@ -98,7 +124,12 @@ async function test() {
       selected.value = keep.length ? keep : [...result.models]
       testError.value = null
     } else {
-      testError.value = result.error ?? t('settings.localModelEndpoints.unreachable')
+      // A policy refusal describes itself in the user's language; the backend's English
+      // stays as the detail line. A genuine reachability failure has no reason vocabulary.
+      testError.value = result.errorReason
+        ? urlReasonText(result.errorReason)
+        : (result.error ?? t('settings.localModelEndpoints.unreachable'))
+      testErrorDetail.value = result.errorReason ? (result.error ?? null) : null
     }
   } catch (e) {
     testError.value = e instanceof Error ? e.message : String(e)
@@ -217,6 +248,12 @@ async function remove(p: LocalRunner) {
                 · {{ t('settings.localModelEndpoints.keySet') }}</template
               >
             </div>
+            <!-- A row whose URL the deployment no longer permits: its models are withheld
+                 from the picker, so this is the only place that can say why. -->
+            <div v-if="e.urlBlockedReason" class="mt-1 text-[11px] text-amber-400">
+              {{ t('settings.localModelEndpoints.blocked') }}
+              <span class="block text-amber-300/70">{{ urlReasonText(e.urlBlockedReason) }}</span>
+            </div>
           </div>
           <div class="flex items-center gap-1">
             <UButton
@@ -300,7 +337,12 @@ async function remove(p: LocalRunner) {
             >
               {{ t('settings.localModelEndpoints.testConnection') }}
             </UButton>
-            <span v-if="testError" class="text-xs text-rose-400">{{ testError }}</span>
+            <span v-if="testError" class="text-xs text-rose-400">
+              {{ testError }}
+              <span v-if="testErrorDetail" class="block text-[11px] text-rose-300/70">{{
+                testErrorDetail
+              }}</span>
+            </span>
             <span v-else-if="tested && discovered.length" class="text-xs text-emerald-400">
               {{
                 t(

package/app/types/execution.ts

@@ -31,6 +31,12 @@ export type {
   PlatformOutcomeTotals,
   PlatformTrendPoint,
   PlatformFailureSlice,
+  PlatformGateStat,
+  PlatformTrendSource,
+  PlatformAlertSettings,
+  PlatformAlertThresholdOverrides,
+  PlatformAlertWindow,
+  PlatformFailingRun,
   ReportWindow,
   ReportSpendDimension,
   ReportActivityDimension,

package/app/types/localModels.ts

@@ -14,6 +14,7 @@
 export type {
   LocalRunner,
   LocalModelEndpoint,
+  LocalRunnerUrlReason,
   UpsertLocalModelEndpointInput,
   TestLocalModelEndpointInput,
   LocalModelEndpointTestResult,

package/i18n/locales/de.json

@@ -957,6 +957,15 @@
       "confirmRemove": {
         "title": "Diesen Runner entfernen?",
         "body": "\"{name}\" wird entfernt. Dies kann nicht rückgängig gemacht werden."
+      },
+      "blocked": "Die URL dieses Runners ist auf dieser Installation nicht erlaubt, daher sind seine Modelle in der Auswahl ausgeblendet.",
+      "urlReason": {
+        "invalid_url": "Das ist keine gültige URL.",
+        "scheme_not_allowed": "Eine Runner-URL muss mit http:// oder https:// beginnen.",
+        "credentials_not_allowed": "Eine Runner-URL darf keinen Benutzernamen und kein Passwort enthalten.",
+        "query_or_fragment_not_allowed": "Gib nur die Basis-URL ein, ohne \"?\"-Abfrage und ohne \"#\"-Fragment.",
+        "host_not_loopback": "Diese Installation erreicht nur Runner auf ihrem eigenen Rechner (localhost). Bitte einen Betreiber, Runner im lokalen Netzwerk zu erlauben.",
+        "host_not_local": "Ein Runner muss auf deinem eigenen Rechner oder in deinem lokalen Netzwerk laufen. Öffentliche Hosts sind nicht erlaubt."
       }
     },
     "modelPolicy": {
@@ -1076,6 +1085,48 @@
       "offHint": "Nicht gesetzt: Jedes Board entscheidet selbst. Bestehende Boards behalten ihre Auswahl.",
       "saved": "Richtlinie für Ausführungs-Anmeldedaten gespeichert",
       "saveFailed": "Richtlinie für Ausführungs-Anmeldedaten konnte nicht gespeichert werden"
+    },
+    "platformAlerts": {
+      "title": "Plattform-Zustandswarnungen",
+      "description": "Obergrenzen, gegen die der Laufzustand dieses Kontos geprüft wird. Leere Felder übernehmen die Vorgaben der Installation.",
+      "muteLabel": "Warnungen für dieses Konto stummschalten",
+      "muteHint": "Warnungen lassen sich hier nur abschalten. Ob die Prüfung überhaupt läuft, ist eine Einstellung der Installation.",
+      "windowLabel": "Auswertungsfenster",
+      "windowHint": "Wie weit jede Bedingung zurückblickt. Ein längeres Fenster reagiert langsamer und bleibt ruhiger.",
+      "thresholdsLabel": "Schwellenwerte",
+      "inheritHint": "Ein leeres Feld übernimmt die Vorgabe der Installation. Eine Null ist ein echter Wert, kein leeres Feld.",
+      "inheritPlaceholder": "Übernommen",
+      "reset": "Überschreibungen löschen",
+      "saved": "Warneinstellungen gespeichert",
+      "saveFailed": "Warneinstellungen konnten nicht gespeichert werden",
+      "window": {
+        "inherit": "Vorgabe der Installation",
+        "oneHour": "Letzte Stunde",
+        "oneDay": "Letzte 24 Stunden",
+        "sevenDays": "Letzte 7 Tage"
+      },
+      "thresholds": {
+        "minRuns": "Mindestanzahl Läufe",
+        "maxFailureRate": "Obergrenze Fehlerquote",
+        "maxP99DurationMs": "Obergrenze p99-Dauer (Minuten)",
+        "maxBacklog": "Obergrenze Rückstau",
+        "stalledBuckets": "Leere Intervalle bis zum Stillstand",
+        "minStalledPriorRuns": "Läufe, bevor Stillstand zählt",
+        "maxFailureKindShare": "Anteil der dominanten Ursache",
+        "maxSweepFailures": "Fehlschläge der Prüfung in Folge"
+      },
+      "hints": {
+        "minRuns": "Abgeschlossene Läufe, die das Fenster braucht, bevor die Fehlerwarnungen auslösen können.",
+        "maxFailureRate": "Anteil der Läufe, die fehlschlagen dürfen, von 0 bis 1.",
+        "maxP99DurationMs": "Wie lange die langsamsten Läufe dauern dürfen.",
+        "maxBacklog": "Unfertige Läufe, die gleichzeitig unterwegs sein dürfen.",
+        "stalledBuckets": "Abschließende leere Intervalle im Verlauf, die als Stillstand gelten.",
+        "minStalledPriorRuns": "Läufe, die der frühere Teil des Fensters getragen haben muss. Null warnt bei jeder Stille.",
+        "maxFailureKindShare": "Anteil der Fehler, den eine einzelne Ursache ausmachen darf, über 0 und bis 1.",
+        "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"
     }
   },
   "inspector": {
@@ -2064,7 +2115,10 @@
         "budget_paused": "Als gelesen markieren",
         "key_drift": "Veraltete Zugangsdaten entfernen",
         "merge_tag_request": "Aufwand erfassen"
-      }
+      },
+      "failingRun": "{kind} · {at}",
+      "failingRunsMore": "{count} weitere nicht angezeigt",
+      "failingRunGone": "Dieser Lauf ist nicht mehr geladen und hat keine Aufgabe zum Öffnen."
     },
     "aiProvidersBanner": {
       "setup": {
@@ -2587,16 +2641,25 @@
       "addFailedTitle": "Wiederkehrende Pipeline konnte nicht hinzugefügt werden",
       "onDemand": "On-Demand (nur manuell)",
       "onDemandHint": "Läuft nur, wenn Sie ihn auslösen, ohne Zeitplan. Da Sie jedes Mal anwesend sind, kann seine Aufgabe ein Modell mit individueller Nutzung verwenden.",
+      "onDemandLockedHint": "Fest aktiviert: Ein per Tracker ausgelöster Zeitplan wird von Webhooks gesteuert und hat daher keinen eigenen Rhythmus.",
       "intake": "Issue-Aufnahme",
       "intakeHint": "Jeder Lauf wählt ein passendes offenes Issue aus dem Tracker und bearbeitet es von Anfang bis Ende.",
       "intakeNoSources": "Verbinden Sie zuerst eine Task-Quelle, um Issues daraus zu ziehen.",
       "intakeGithubRepo": "Repository",
+      "intakeBoardId": "Board-ID",
+      "intakeBoardIdHelp": "Das Board, Projekt oder die Warteschlange, auf die dieser Tracker die Aufnahme eingrenzt. Das Format gibt der Tracker vor.",
+      "trackerTrigger": "Läufe durch Tracker-Webhooks starten",
+      "trackerTriggerHint": "Ein Ticket, das den Filtern unten entspricht, wird als eigene Aufgabe importiert und auf dieser Pipeline ausgeführt. Erfordert einen bedarfsgesteuerten Zeitplan.",
+      "intakeDispatchQueueHint": "Ein passendes Ereignis startet diesen Zeitplan, der das älteste passende Ticket des Boards übernimmt. Geeignet für einen Rückstand, bei dem die Plattform entscheidet, was als Nächstes bearbeitet wird.",
+      "intakeDispatchPerTicketHint": "Ein passendes Ereignis importiert genau dieses Ticket als eigene Aufgabe und führt die Pipeline darauf aus. Geeignet für bereits gesichtete Tickets.",
       "intakeTitleFragment": "Titel enthält",
       "intakeTitleFragmentPlaceholder": "z. B. crash",
       "intakeLabels": "Labels",
       "intakeLabelsPlaceholder": "durch Komma getrennt",
       "intakeIssueType": "Issue-Typ",
-      "intakeInProgressLabel": "In-Bearbeitung-Label"
+      "intakeInProgressLabel": "In-Bearbeitung-Label",
+      "refusalPerTicketRequiresOnDemand": "Ein per Tracker ausgelöster Zeitplan muss bedarfsgesteuert sein. Ein Rhythmus-Tick enthält kein Ticket, das übergeben werden könnte.",
+      "refusalPerTicketConflictsWithBugIntake": "Diese Pipeline wählt ihr Issue selbst vom Board und kann daher nicht zusätzlich von einem eingehenden Ticket gesteuert werden. Wählen Sie eine Pipeline ohne Bug-Intake-Schritt."
     },
     "failure": {
       "containerFailedToStart": "Container konnte nicht gestartet werden",
@@ -3235,7 +3298,9 @@
     "window": {
       "oneHour": "Letzte Stunde",
       "oneDay": "Letzte 24 Stunden",
-      "sevenDays": "Letzte 7 Tage"
+      "sevenDays": "Letzte 7 Tage",
+      "thirtyDays": "Letzte 30 Tage",
+      "ninetyDays": "Letzte 90 Tage"
     },
     "outcomes": {
       "title": "Lauf-Ergebnisse",
@@ -3285,6 +3350,22 @@
     },
     "live": {
       "title": "Jetzt aktiv"
+    },
+    "rollup": {
+      "none": "Die tägliche Aggregation hat noch nichts erzeugt. Dieses Zeitfenster ist also mangels Daten leer, nicht mangels Läufen.",
+      "stale": "Die tägliche Aggregation reicht nur bis {date}. Alles danach sind fehlende Daten, keine ruhige Zeit.",
+      "current": "Aus der täglichen Aggregation, vollständig bis {date}."
+    },
+    "gates": {
+      "title": "Gate-Versuche",
+      "empty": "In diesem Zeitfenster wurde kein Gate abgeschlossen.",
+      "gate": "Gate",
+      "settled": "Abgeschlossen",
+      "cleanPasses": "Ohne Fixer bestanden",
+      "attempts": "Fixer-Versuche",
+      "helperFailures": "Fixer-Fehlschläge",
+      "exhausted": "An Menschen übergeben",
+      "hint": "Ohne Fixer bestanden heißt: die Vorprüfung war zufrieden und es wurde gar kein Fixer gestartet. Fixer-Fehlschläge sind Versuche, deren eigener Job abgestürzt ist, im Unterschied zu Versuchen, die liefen und die Prüfung rot ließen."
     }
   },
   "reports": {

package/i18n/locales/en.json

@@ -362,16 +362,25 @@
       "addFailedTitle": "Could not add recurring pipeline",
       "onDemand": "On-demand (manual only)",
       "onDemandHint": "Runs only when you trigger it, with no schedule. Because you are present each time, its task may use an individual-usage subscription model.",
+      "onDemandLockedHint": "Locked on: a tracker-triggered schedule is driven by webhooks, so it has no cadence of its own.",
       "intake": "Issue intake",
       "intakeHint": "Each run picks one matching open issue from the tracker and works it end to end.",
       "intakeNoSources": "Connect a task source first to pull issues from it.",
       "intakeGithubRepo": "Repository",
+      "intakeBoardId": "Board id",
+      "intakeBoardIdHelp": "The board, project or queue this tracker scopes intake to. Its format is defined by the tracker.",
+      "trackerTrigger": "Start runs from tracker webhooks",
+      "trackerTriggerHint": "A ticket matching the filters below is imported as its own task and run on this pipeline. Needs an on-demand schedule.",
+      "intakeDispatchQueueHint": "A matching event starts this schedule, which picks up the oldest matching issue on the board. Use this for a backlog, where the platform decides what is worked next.",
+      "intakeDispatchPerTicketHint": "A matching event imports that ticket as its own task and runs the pipeline on it. Use this for tickets someone has already triaged.",
       "intakeTitleFragment": "Title contains",
       "intakeTitleFragmentPlaceholder": "e.g. crash",
       "intakeLabels": "Labels",
       "intakeLabelsPlaceholder": "comma-separated",
       "intakeIssueType": "Issue type",
-      "intakeInProgressLabel": "In-progress label"
+      "intakeInProgressLabel": "In-progress label",
+      "refusalPerTicketRequiresOnDemand": "A tracker-triggered schedule must be on-demand. A cadence tick carries no ticket to dispatch.",
+      "refusalPerTicketConflictsWithBugIntake": "This pipeline picks its own issue from the board, so it cannot also be driven by a pushed ticket. Choose a pipeline without a bug-intake step."
     },
     "failure": {
       "containerFailedToStart": "Container failed to start",
@@ -1637,7 +1646,9 @@
     "window": {
       "oneHour": "Last hour",
       "oneDay": "Last 24 hours",
-      "sevenDays": "Last 7 days"
+      "sevenDays": "Last 7 days",
+      "thirtyDays": "Last 30 days",
+      "ninetyDays": "Last 90 days"
     },
     "outcomes": {
       "title": "Run outcomes",
@@ -1687,6 +1698,22 @@
     },
     "live": {
       "title": "Live now"
+    },
+    "rollup": {
+      "none": "The daily rollup has produced nothing yet, so this window is empty for lack of data, not for lack of runs.",
+      "stale": "The daily rollup only reaches {date}. Anything after that is missing data, not idle time.",
+      "current": "From the daily rollup, complete through {date}."
+    },
+    "gates": {
+      "title": "Gate attempts",
+      "empty": "No gate settled in this window.",
+      "gate": "Gate",
+      "settled": "Settled",
+      "cleanPasses": "Clean passes",
+      "attempts": "Fixer attempts",
+      "helperFailures": "Fixer failures",
+      "exhausted": "Handed to a human",
+      "hint": "A clean pass is a gate the precheck satisfied without starting a fixer at all. Fixer failures are attempts whose own job crashed, as opposed to attempts that ran and left the check red."
     }
   },
   "reports": {
@@ -2041,7 +2068,10 @@
         "budget_paused": "Mark read",
         "key_drift": "Drop stale credentials",
         "merge_tag_request": "Record effort"
-      }
+      },
+      "failingRun": "{kind} · {at}",
+      "failingRunsMore": "{count} more not shown",
+      "failingRunGone": "This run is no longer loaded and has no task to open."
     },
     "aiProvidersBanner": {
       "setup": {
@@ -3333,6 +3363,15 @@
       "confirmRemove": {
         "title": "Remove this runner?",
         "body": "\"{name}\" will be removed. This can't be undone."
+      },
+      "blocked": "This runner's URL is not allowed on this deployment, so its models are hidden from the picker.",
+      "urlReason": {
+        "invalid_url": "That is not a valid URL.",
+        "scheme_not_allowed": "A runner URL must start with http:// or https://.",
+        "credentials_not_allowed": "A runner URL must not contain a username or password.",
+        "query_or_fragment_not_allowed": "Enter the base URL only, with no \"?\" query and no \"#\" fragment.",
+        "host_not_loopback": "This deployment only reaches runners on its own machine (localhost). Ask an operator to allow local-network runners.",
+        "host_not_local": "A runner must be on your own machine or your local network. Public hosts are not allowed."
       }
     },
     "modelPolicy": {
@@ -3452,6 +3491,48 @@
       "offHint": "Not set: each board decides for itself. Existing boards keep whatever they have chosen.",
       "saved": "Run credential policy saved",
       "saveFailed": "Could not save the run credential policy"
+    },
+    "platformAlerts": {
+      "title": "Platform health alerts",
+      "description": "Ceilings this account's own run health is checked against. Blank fields inherit the deployment defaults.",
+      "muteLabel": "Mute alerts for this account",
+      "muteHint": "Alerts can only be switched off here. Whether the sweep runs at all is a deployment setting.",
+      "windowLabel": "Evaluation window",
+      "windowHint": "How far back each condition looks. A longer window reacts more slowly and stays quieter.",
+      "thresholdsLabel": "Thresholds",
+      "inheritHint": "Leave a field empty to inherit the deployment default. A zero is a real setting, not an empty one.",
+      "inheritPlaceholder": "Inherited",
+      "reset": "Clear overrides",
+      "saved": "Alert settings saved",
+      "saveFailed": "Could not save the alert settings",
+      "window": {
+        "inherit": "Deployment default",
+        "oneHour": "Last hour",
+        "oneDay": "Last 24 hours",
+        "sevenDays": "Last 7 days"
+      },
+      "thresholds": {
+        "minRuns": "Minimum runs",
+        "maxFailureRate": "Failure rate ceiling",
+        "maxP99DurationMs": "p99 duration ceiling (minutes)",
+        "maxBacklog": "Backlog ceiling",
+        "stalledBuckets": "Empty buckets before a stall",
+        "minStalledPriorRuns": "Runs before a stall counts",
+        "maxFailureKindShare": "Dominant failure share",
+        "maxSweepFailures": "Sweep failures in a row"
+      },
+      "hints": {
+        "minRuns": "Finished runs the window needs before the failure alerts can fire.",
+        "maxFailureRate": "Share of runs that may fail, from 0 to 1.",
+        "maxP99DurationMs": "How long the slowest runs may take.",
+        "maxBacklog": "Unfinished runs that may be in flight at once.",
+        "stalledBuckets": "Trailing empty trend buckets that count as a stall.",
+        "minStalledPriorRuns": "Runs the earlier part of the window must have carried. Zero alerts on any silence.",
+        "maxFailureKindShare": "Share of failures one cause may account for, above 0 and up to 1.",
+        "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"
     }
   },
   "providers": {