@cat-factory/app 0.211.0 → 0.213.0

package/app/components/settings/ModelConfigurationPanel.vue

@@ -12,6 +12,7 @@
 // base-model picker plus a filterable per-agent override list.
 import { computed, ref, watch } from 'vue'
 import { onKeyStroke } from '@vueuse/core'
+import type { ModelFlavor } from '@cat-factory/contracts'
 import type { AgentKind } from '~/types/domain'
 import type { ModelPreset } from '~/types/model-presets'
 import AgentTierSelect from '~/components/palettes/AgentTierSelect.vue'
@@ -19,9 +20,12 @@ import { filterByAgentTierKeeping } from '~/utils/agentTier'
 import { MODEL_CONFIGURABLE_SYSTEM_KINDS } from '~/utils/catalog'
 import { cachingLabel, contextLabel, costLabel, displayFlavor, isSelectable } from '~/stores/models'
 import ConsensusGroupsSection from '~/components/settings/ConsensusGroupsSection.vue'
+import ProviderPreferenceEditor from '~/components/settings/ProviderPreferenceEditor.vue'
+import { showOverrideField } from '~/utils/uiMode'
 
 const { t } = useI18n()
 const ui = useUiStore()
+const uiMode = useUiModeStore()
 const models = useModelsStore()
 const presets = useModelPresetsStore()
 const agents = useAgentsStore()
@@ -43,6 +47,8 @@ interface EditorState {
   baseModelId: string
   overrides: Record<string, string>
   isDefault: boolean
+  /** The preset's route order; undefined ⇒ it inherits the deployment's default order. */
+  providerPreference: ModelFlavor[] | undefined
 }
 const editor = ref<EditorState | null>(null)
 const busy = ref(false)
@@ -144,6 +150,7 @@ function startCreate() {
     baseModelId: selectableModels.value[0]?.id ?? 'kimi-k2.7',
     overrides: {},
     isDefault: false,
+    providerPreference: undefined,
   }
   filter.value = ''
 }
@@ -154,10 +161,19 @@ function startEdit(p: ModelPreset) {
     baseModelId: p.baseModelId,
     overrides: { ...p.overrides },
     isDefault: p.isDefault,
+    providerPreference: p.providerPreference ? [...p.providerPreference] : undefined,
   }
   filter.value = ''
 }
 
+// The route order is an OVERRIDE of the deployment's default, so basic mode hides it — but only
+// while this preset states none. A preset that already carries one (written by a teammate, by the
+// API, or here at the advanced tier) keeps the control, or a basic-mode user would be looking at a
+// preset whose routes they can neither read nor reset.
+const showRouteOrder = computed(() =>
+  showOverrideField(uiMode.isAdvanced, editor.value?.providerPreference),
+)
+
 async function setDefault(p: ModelPreset) {
   if (p.isDefault) return
   busy.value = true
@@ -249,6 +265,9 @@ async function save() {
         baseModelId: e.baseModelId,
         overrides: e.overrides,
         isDefault: e.isDefault,
+        // Always sent on a patch, `[]` included: an absent field means "leave the stored order
+        // alone", so a reset has to arrive as the empty list that clears it.
+        providerPreference: e.providerPreference ?? [],
       })
     } else {
       await presets.create({
@@ -256,6 +275,7 @@ async function save() {
         baseModelId: e.baseModelId,
         overrides: e.overrides,
         isDefault: e.isDefault,
+        ...(e.providerPreference ? { providerPreference: e.providerPreference } : {}),
       })
     }
     editor.value = null
@@ -422,6 +442,12 @@ function fail(title: string, e: unknown) {
                         )
                       }}
                     </span>
+                    <!-- A custom route order changes which provider the same model runs on, so the
+                         list says so rather than leaving it visible only inside the editor (which
+                         basic mode hides). -->
+                    <span v-if="p.providerPreference?.length" class="text-slate-300">
+                      · {{ t('settings.modelConfiguration.list.customRouteOrder') }}
+                    </span>
                   </div>
                 </div>
                 <p
@@ -483,6 +509,17 @@ function fail(title: string, e: unknown) {
                 </label>
               </div>
 
+              <!-- Which of a model's ROUTES this preset's runs prefer: a compliance preset can put
+                   AWS Bedrock ahead of a model's own provider API, an everyday preset a flat-rate
+                   subscription first. An override of the deployment default, so basic mode hides it
+                   until the preset actually carries one. -->
+              <ProviderPreferenceEditor
+                v-if="showRouteOrder"
+                v-model="editor.providerPreference"
+                :has-subscription="creds.configuredVendors.size > 0"
+                :is-default-preset="editor.isDefault"
+              />
+
               <div>
                 <div class="mb-1 flex items-start justify-between gap-3">
                   <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">

package/app/components/settings/ProviderPreferenceEditor.logic.spec.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_MODEL_FLAVOR_ORDER, type ModelFlavor } from '@cat-factory/contracts'
+import {
+  commitFlavorOrder,
+  isDefaultFlavorOrder,
+  moveFlavor,
+  subscriptionOverridesOrder,
+} from '~/components/settings/ProviderPreferenceEditor.logic'
+
+const DEFAULT = [...DEFAULT_MODEL_FLAVOR_ORDER]
+
+describe('isDefaultFlavorOrder', () => {
+  it('is true only for the full shipped order, position for position', () => {
+    expect(isDefaultFlavorOrder(DEFAULT)).toBe(true)
+    expect(isDefaultFlavorOrder([...DEFAULT].reverse())).toBe(false)
+  })
+
+  it('rejects a PREFIX of the default rather than reading it as "no preference"', () => {
+    // `every` is vacuously true for a prefix, so without the length check a partial order that
+    // happens to start like the default would be silently cleared — the preset would lose an
+    // order the caller meant to store.
+    expect(isDefaultFlavorOrder(DEFAULT.slice(0, 2))).toBe(false)
+    expect(isDefaultFlavorOrder([])).toBe(false)
+  })
+})
+
+describe('commitFlavorOrder', () => {
+  it('stores an order that equals the default as ABSENT, not as a copy of it', () => {
+    // The whole "a preset keeps tracking the shipped order as the product changes it" property
+    // rests on this, and the SPA is the only place it happens.
+    expect(commitFlavorOrder(DEFAULT)).toBeUndefined()
+  })
+
+  it('stores a genuinely reordered list', () => {
+    const reordered: ModelFlavor[] = [
+      'bedrock',
+      'direct',
+      'openrouter',
+      'cloudflare',
+      'subscription',
+    ]
+    expect(commitFlavorOrder(reordered)).toEqual(reordered)
+  })
+
+  it('copies rather than aliasing the array it was given', () => {
+    const next: ModelFlavor[] = ['bedrock', 'direct', 'openrouter', 'cloudflare', 'subscription']
+    const stored = commitFlavorOrder(next)
+    next[0] = 'cloudflare'
+    expect(stored?.[0]).toBe('bedrock')
+  })
+})
+
+describe('moveFlavor', () => {
+  it('swaps with the neighbour in the given direction', () => {
+    expect(moveFlavor(DEFAULT, 1, -1)).toEqual([DEFAULT[1], DEFAULT[0], ...DEFAULT.slice(2)])
+  })
+
+  it('is a no-op past either end', () => {
+    expect(moveFlavor(DEFAULT, 0, -1)).toBeUndefined()
+    expect(moveFlavor(DEFAULT, DEFAULT.length - 1, 1)).toBeUndefined()
+  })
+
+  it('never drops or duplicates a route (a preference reorders, it never filters)', () => {
+    const moved = moveFlavor(DEFAULT, 2, 1)!
+    expect([...moved].sort()).toEqual([...DEFAULT].sort())
+  })
+})
+
+describe('subscriptionOverridesOrder', () => {
+  const compliance: ModelFlavor[] = ['bedrock', 'direct']
+  const subscriptionFirst: ModelFlavor[] = ['subscription', 'direct']
+
+  it('warns whenever a connected plan can overrule the order (the compliance-preset case)', () => {
+    // "Subscriptions always win" is applied by the engine ON TOP of the route this order resolves,
+    // so a preset promoting AWS Bedrock is silently overruled for a dual-mode model on a workspace
+    // holding a token. The control has to say so rather than promise the route.
+    expect(subscriptionOverridesOrder({ preference: compliance, hasSubscription: true })).toBe(true)
+  })
+
+  it('stays quiet when the order already puts the subscription first (override agrees with it)', () => {
+    expect(
+      subscriptionOverridesOrder({ preference: subscriptionFirst, hasSubscription: true }),
+    ).toBe(false)
+  })
+
+  it('stays quiet with no connected subscription — no token, no override', () => {
+    expect(subscriptionOverridesOrder({ preference: compliance, hasSubscription: false })).toBe(
+      false,
+    )
+  })
+
+  it('stays quiet when the preset states no order at all (nothing was promised)', () => {
+    expect(subscriptionOverridesOrder({ preference: undefined, hasSubscription: true })).toBe(false)
+    expect(subscriptionOverridesOrder({ preference: [], hasSubscription: true })).toBe(false)
+  })
+
+  it('judges the RESOLVED total order, not the caller’s partial list', () => {
+    // A one-entry list still resolves to a full order, so "is subscription first" is answerable
+    // for it — and `['subscription']` promotes the route even though it names nothing else.
+    expect(
+      subscriptionOverridesOrder({ preference: ['subscription'], hasSubscription: true }),
+    ).toBe(false)
+  })
+})

package/app/components/settings/ProviderPreferenceEditor.logic.ts

@@ -0,0 +1,81 @@
+// The pure half of `ProviderPreferenceEditor.vue`: what a reordering COMMITS, and what the
+// control has to say about a route order the run path may still override. Extracted so both can
+// be pinned without mounting Vue — the "equals the default is stored as absent" normalisation in
+// particular, which the backend's whole "a preset keeps tracking the shipped order" property rests
+// on and which no backend test can see (the SPA is the only thing that performs it).
+
+import {
+  DEFAULT_MODEL_FLAVOR_ORDER,
+  type ModelFlavor,
+  orderedModelFlavorPreference,
+} from '@cat-factory/contracts'
+
+/**
+ * Whether an order is today's shipped default, position for position.
+ *
+ * The length check is not redundant: `every` is vacuously true for a PREFIX, so without it a
+ * partial order that happens to start like the default would be read as "no preference" and
+ * silently cleared. The editor only ever produces full permutations, which is exactly why the
+ * guard belongs here rather than in the caller — it is what keeps that a property of this
+ * function instead of a property of its one current caller.
+ */
+export function isDefaultFlavorOrder(next: readonly ModelFlavor[]): boolean {
+  return (
+    next.length === DEFAULT_MODEL_FLAVOR_ORDER.length &&
+    next.every((flavor, i) => DEFAULT_MODEL_FLAVOR_ORDER[i] === flavor)
+  )
+}
+
+/**
+ * What a reordering stores: the new order, or UNSET when it lands back on the shipped default.
+ *
+ * "No preference" and "an order that happens to match today's default" are different states, and
+ * only the first keeps following the shipped order as the product changes it. Storing a copy would
+ * silently pin today's wording of a list that is itself scheduled to be reordered.
+ */
+export function commitFlavorOrder(next: readonly ModelFlavor[]): ModelFlavor[] | undefined {
+  return isDefaultFlavorOrder(next) ? undefined : [...next]
+}
+
+/** Swap the entry at `index` with its neighbour `delta` away; undefined when the move is a no-op. */
+export function moveFlavor(
+  order: readonly ModelFlavor[],
+  index: number,
+  delta: number,
+): ModelFlavor[] | undefined {
+  const next = [...order]
+  const target = index + delta
+  const moved = next[index]
+  const displaced = next[target]
+  if (!moved || !displaced) return undefined
+  next[index] = displaced
+  next[target] = moved
+  return next
+}
+
+/**
+ * Whether to warn that a connected subscription will still win over this order.
+ *
+ * "Subscriptions always win" is applied by the ENGINE on top of the route this order resolves: a
+ * dual-mode model (Kimi/DeepSeek/GLM) switches to its subscription flavour whenever the workspace
+ * or the run initiator holds a token, whatever the preset asked for. So the override does not
+ * merely re-rank the subscription route within this list — it sits OUTSIDE the list — and the only
+ * order it cannot contradict is one that already puts `subscription` first.
+ *
+ * That is why the test is "is subscription first", not "was subscription demoted": `subscription`
+ * is last in today's shipped order, so a demotion test could never fire, and the case that actually
+ * bites is the opposite one — a compliance preset promoting `bedrock` and being silently overruled.
+ * Until the override moves into this order, the control has to say so, because copy promising a
+ * residency-guaranteed route that a connected plan quietly overrules is the one thing a compliance
+ * preset must never do.
+ *
+ * Only when the preset actually states an order (nothing is promised otherwise) AND the workspace
+ * has a connected subscription (no token, no override).
+ */
+export function subscriptionOverridesOrder(input: {
+  preference: readonly ModelFlavor[] | undefined
+  hasSubscription: boolean
+}): boolean {
+  if (!input.preference?.length || !input.hasSubscription) return false
+  return orderedModelFlavorPreference(input.preference)[0] !== 'subscription'
+}

package/app/components/settings/ProviderPreferenceEditor.vue

@@ -0,0 +1,180 @@
+<script setup lang="ts">
+// The ROUTE-ORDER editor for one model preset: which of a model's routes (its own provider API,
+// AWS Bedrock, the OpenRouter gateway, Cloudflare Workers AI, a subscription harness) the preset's
+// runs prefer, most preferred first.
+//
+// Two properties of the backend model decide the whole shape of this control:
+//
+//  - A preference REORDERS, never filters. So the list always shows EVERY route and the only
+//    affordance is moving one. There is deliberately no way to remove a route: a preset that
+//    could drop one would make a model whose only route is that one unstartable, which is not
+//    what anybody choosing an order means.
+//  - "No preference" is a real, distinct state from "an order that happens to match today's
+//    default". Only the first keeps tracking the shipped order as the product changes it, so
+//    reordering back to the default clears the preference rather than storing a copy of it, and
+//    the header says which of the two the preset is in.
+//
+// A third property is the engine's rather than this order's, and it is why the control can warn:
+// "subscriptions always win" is applied on TOP of the resolved route, so on a workspace with a
+// connected plan a dual-mode model ignores an order that ranks `subscription` lower than the
+// shipped default does. The logic module says when; the copy says so plainly.
+import { computed } from 'vue'
+import type { ModelFlavor } from '@cat-factory/contracts'
+import { orderedModelFlavorPreference } from '@cat-factory/contracts'
+import {
+  commitFlavorOrder,
+  moveFlavor,
+  subscriptionOverridesOrder,
+} from '~/components/settings/ProviderPreferenceEditor.logic'
+
+const props = defineProps<{
+  /** The preset's stored order; empty/absent ⇒ the deployment's default order. */
+  modelValue: ModelFlavor[] | undefined
+  /**
+   * Whether this workspace has ANY subscription vendor connected. Drives the caveat only: the
+   * override it warns about is the engine's, so the control cannot prevent it, only name it.
+   */
+  hasSubscription?: boolean
+  /**
+   * Whether the preset being edited is the workspace DEFAULT. `GET /models` resolves its flavour
+   * badges under the default preset's order, so on any OTHER preset the model list beside this
+   * control is showing routes this order does not govern, and the control says so.
+   */
+  isDefaultPreset?: boolean
+}>()
+const emit = defineEmits<{ 'update:modelValue': [ModelFlavor[] | undefined] }>()
+
+const { t } = useI18n()
+
+/** Static literal keys, one per route, so the typed-message-key check sees them all. */
+const ROUTE_LABELS: Record<ModelFlavor, string> = {
+  direct: 'settings.modelConfiguration.routes.direct',
+  bedrock: 'settings.modelConfiguration.routes.bedrock',
+  openrouter: 'settings.modelConfiguration.routes.openrouter',
+  cloudflare: 'settings.modelConfiguration.routes.cloudflare',
+  subscription: 'settings.modelConfiguration.routes.subscription',
+}
+const ROUTE_HINTS: Record<ModelFlavor, string> = {
+  direct: 'settings.modelConfiguration.routeHints.direct',
+  bedrock: 'settings.modelConfiguration.routeHints.bedrock',
+  openrouter: 'settings.modelConfiguration.routeHints.openrouter',
+  cloudflare: 'settings.modelConfiguration.routeHints.cloudflare',
+  subscription: 'settings.modelConfiguration.routeHints.subscription',
+}
+
+/** The order actually in force: the preset's own, else the default. Always all five routes. */
+const order = computed(() => orderedModelFlavorPreference(props.modelValue))
+const isCustom = computed(() => (props.modelValue?.length ?? 0) > 0)
+
+/** A connected plan overrules a deprioritised subscription route — see the logic module. */
+const subscriptionWins = computed(() =>
+  subscriptionOverridesOrder({
+    preference: props.modelValue,
+    hasSubscription: props.hasSubscription ?? false,
+  }),
+)
+
+/** The badges beside this control render under the DEFAULT preset's order, not this one's. */
+const badgesShowAnotherOrder = computed(() => isCustom.value && props.isDefaultPreset === false)
+
+function move(index: number, delta: number) {
+  const next = moveFlavor(order.value, index, delta)
+  if (next) emit('update:modelValue', commitFlavorOrder(next))
+}
+
+function reset() {
+  emit('update:modelValue', undefined)
+}
+</script>
+
+<template>
+  <div>
+    <div class="mb-1 flex items-start justify-between gap-3">
+      <span class="text-[11px] font-semibold uppercase tracking-wide text-slate-400">
+        {{ t('settings.modelConfiguration.routeOrder.label') }}
+      </span>
+      <UButton
+        v-if="isCustom"
+        size="xs"
+        variant="ghost"
+        color="neutral"
+        icon="i-lucide-rotate-ccw"
+        data-testid="preset-route-order-reset"
+        @click="reset"
+      >
+        {{ t('settings.modelConfiguration.routeOrder.reset') }}
+      </UButton>
+    </div>
+    <p class="mb-2 text-[11px] leading-relaxed text-slate-500">
+      {{
+        isCustom
+          ? t('settings.modelConfiguration.routeOrder.customHint')
+          : t('settings.modelConfiguration.routeOrder.defaultHint')
+      }}
+    </p>
+    <!-- The engine applies "subscriptions always win" ON TOP of this order, so on a workspace with
+         a connected plan a dual-mode model ignores a deprioritised subscription route. Said here
+         rather than left to be discovered in a run: copy that promises a residency-guaranteed
+         route a connected plan quietly overrules is the one thing this control must not do. -->
+    <p
+      v-if="subscriptionWins"
+      class="mb-2 text-[11px] leading-relaxed text-amber-400/90"
+      data-testid="preset-route-order-subscription-warning"
+    >
+      {{ t('settings.modelConfiguration.routeOrder.subscriptionOverrideHint') }}
+    </p>
+    <!-- The model list beside this control shows each model's route under the WORKSPACE DEFAULT
+         preset (that is what `GET /models` resolves), so on any other preset those badges are
+         answering a different question than this order asks. -->
+    <p
+      v-if="badgesShowAnotherOrder"
+      class="mb-2 text-[11px] leading-relaxed text-slate-500"
+      data-testid="preset-route-order-badge-hint"
+    >
+      {{ t('settings.modelConfiguration.routeOrder.badgesUseDefaultPresetHint') }}
+    </p>
+    <ol
+      class="divide-y divide-slate-800 rounded-xl border border-slate-800 bg-slate-900/50"
+      data-testid="preset-route-order"
+    >
+      <li
+        v-for="(flavor, index) in order"
+        :key="flavor"
+        class="flex items-center gap-3 px-4 py-2.5"
+        :data-testid="`preset-route-${flavor}`"
+      >
+        <span
+          class="flex h-5 w-5 shrink-0 items-center justify-center rounded bg-slate-800 text-[10px] font-semibold text-slate-400"
+        >
+          {{ index + 1 }}
+        </span>
+        <div class="min-w-0 flex-1">
+          <p class="truncate text-sm text-slate-200">{{ t(ROUTE_LABELS[flavor]) }}</p>
+          <p class="truncate text-[11px] text-slate-500">{{ t(ROUTE_HINTS[flavor]) }}</p>
+        </div>
+        <div class="flex shrink-0 items-center gap-1">
+          <UButton
+            size="xs"
+            variant="ghost"
+            color="neutral"
+            icon="i-lucide-chevron-up"
+            :disabled="index === 0"
+            :title="t('settings.modelConfiguration.routeOrder.moveUp')"
+            :aria-label="t('settings.modelConfiguration.routeOrder.moveUp')"
+            @click="move(index, -1)"
+          />
+          <UButton
+            size="xs"
+            variant="ghost"
+            color="neutral"
+            icon="i-lucide-chevron-down"
+            :disabled="index === order.length - 1"
+            :title="t('settings.modelConfiguration.routeOrder.moveDown')"
+            :aria-label="t('settings.modelConfiguration.routeOrder.moveDown')"
+            @click="move(index, 1)"
+          />
+        </div>
+      </li>
+    </ol>
+  </div>
+</template>

package/app/types/execution.ts

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

package/i18n/locales/de.json

@@ -22,7 +22,8 @@
         "deleteTitle": "Preset löschen",
         "basePrefix": "Basis:",
         "overrideCount": "{count} Override | {count} Overrides",
-        "empty": "Noch keine Presets. Erstelle eines, um Modelle deinen Agenten zuzuordnen."
+        "empty": "Noch keine Presets. Erstelle eines, um Modelle deinen Agenten zuzuordnen.",
+        "customRouteOrder": "eigene Routen-Reihenfolge"
       },
       "editor": {
         "useBaseModel": "Basismodell verwenden",
@@ -43,6 +44,30 @@
         "nameRequiredTitle": "Name erforderlich",
         "nameRequiredBody": "Gib dem Preset einen Namen.",
         "saveFailed": "Preset konnte nicht gespeichert werden"
+      },
+      "routes": {
+        "direct": "Die eigene Provider-API des Modells",
+        "bedrock": "AWS Bedrock",
+        "openrouter": "OpenRouter-Gateway",
+        "cloudflare": "Cloudflare Workers AI",
+        "subscription": "Abo (Claude Code / Codex)"
+      },
+      "routeHints": {
+        "direct": "Benötigt einen API-Schlüssel für diesen Provider.",
+        "bedrock": "Läuft in deiner AWS-Region, mit den für dein Konto freigegebenen Modellen.",
+        "openrouter": "Ein Schlüssel, viele Anbieter, mit Aufschlag weiterverkauft.",
+        "cloudflare": "Immer verfügbar, ohne Prompt-Caching.",
+        "subscription": "Pauschales Kontingent eines verbundenen Tarifs."
+      },
+      "routeOrder": {
+        "label": "Routen-Reihenfolge",
+        "defaultHint": "Dieses Preset folgt dem Standard des Deployments. Verschiebe eine Route nach oben, um sie zu bevorzugen.",
+        "customHint": "Dieses Preset bevorzugt Routen in dieser Reihenfolge. Ein Modell, das nur über eine niedrigere Route erreichbar ist, läuft weiterhin und wird nur später versucht.",
+        "reset": "Standardreihenfolge verwenden",
+        "moveUp": "Diese Route stärker bevorzugen",
+        "moveDown": "Diese Route weniger bevorzugen",
+        "subscriptionOverrideHint": "Ein verbundenes Abo gewinnt weiterhin bei Modellen, die eines anbieten: Die Engine leitet diese unabhängig von dieser Reihenfolge auf den Tarif. Routen unterhalb des Abo-Eintrags gelten für alle anderen Modelle.",
+        "badgesUseDefaultPresetHint": "Die Route neben jedem Modell oben ist die des Standard-Presets des Workspace, nicht die dieses Presets."
       }
     },
     "account": {
@@ -1085,6 +1110,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": {
@@ -2073,7 +2140,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": {
@@ -3253,7 +3323,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",
@@ -3303,6 +3375,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": {
@@ -5885,7 +5973,7 @@
       "newDescription": "Neue integrierte Modell-Presets sind verfügbar. Füge sie zur Bibliothek dieses Boards hinzu.",
       "add": "Hinzufügen",
       "updatesHeading": "Updates verfügbar",
-      "updatesDescription": "Eine neuere Version dieser integrierten Modell-Presets ist verfügbar. Führe ein erneutes Seeding durch, um sie zu übernehmen (Standard und Reihenfolge bleiben erhalten).",
+      "updatesDescription": "Eine neuere Version dieser integrierten Modell-Presets ist verfügbar. Führe ein erneutes Seeding durch, um sie zu übernehmen: Standard und Reihenfolge bleiben erhalten, eine eigene Routen-Reihenfolge auf dem Preset wird jedoch zurückgesetzt.",
       "versionAvailable": "Version {from} → {to} verfügbar.",
       "reseed": "Erneut seeden",
       "reseedAll": "Alle aktualisieren ({count})",