@cat-factory/app 0.218.0 → 0.219.0

package/app/components/layout/AccountFailureKindRules.vue

@@ -0,0 +1,285 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { AgentFailureKind, PlatformFailureKindRule } from '~/types/execution'
+import {
+  AGENT_FAILURE_KINDS,
+  FAILURE_KIND_KEYS,
+  failureKindRuleFaults,
+  isAgentFailureKind,
+  MAX_FAILURE_KIND_RULES,
+} from '~/utils/failureKinds'
+
+// The per-failure-kind alert rules of the platform-health sheet: "page when `evicted` reaches
+// 5% of the window's failures". Its own component because it edits a LIST where
+// its parent edits scalars, and the two have different notions of what an override is.
+//
+// That difference is the whole of this file. A scalar override is per field: leave the box
+// empty and that one ceiling inherits. A list cannot work that way — merging rule by rule would
+// let an account retune a deployment rule but never DROP one, and silently reinstating a rule an
+// operator deleted is the worse failure for something wired to a pager. So the account's list
+// REPLACES the deployment's, which makes "no rules at all" a setting somebody can choose, and
+// makes it indistinguishable from "inherit" unless the two are asked separately. Hence the
+// explicit override switch: off omits the field, on sends the list, empty included.
+
+const props = defineProps<{
+  /** The account's rules, or undefined when it inherits the deployment's. */
+  modelValue: PlatformFailureKindRule[] | undefined
+}>()
+const emit = defineEmits<{ 'update:modelValue': [PlatformFailureKindRule[] | undefined] }>()
+
+const { t } = useI18n()
+
+const overriding = computed(() => props.modelValue !== undefined)
+const rules = computed(() => props.modelValue ?? [])
+
+/**
+ * The kinds offered for a row: the known vocabulary, plus whatever this row already names.
+ *
+ * The second half matters on exactly the row that would otherwise lose data. A rule stored
+ * against a kind a later release RETIRED still parses (the contract keeps the field a string so
+ * one stale rule cannot take the account's whole settings row down with it), so it reaches this
+ * editor, and a select that only offered current members would silently re-point it at the first
+ * one the moment anything else on the sheet was saved. It is offered back, marked unrecognised,
+ * so the human decides whether to re-pick it or drop it.
+ */
+function kindItems(current: string) {
+  const known = AGENT_FAILURE_KINDS.map((kind) => ({
+    label: t(FAILURE_KIND_KEYS[kind]),
+    value: kind as string,
+  }))
+  if (current === '' || isAgentFailureKind(current)) return known
+  return [
+    ...known,
+    {
+      label: t('settings.platformAlerts.failureKinds.unknownKind', { kind: current }),
+      value: current,
+    },
+  ]
+}
+
+/** The kinds already spoken for, so the UI can say which row is the duplicate. */
+const duplicateKinds = computed(() => {
+  const seen = new Set<string>()
+  const dupes = new Set<string>()
+  for (const rule of rules.value) {
+    if (seen.has(rule.kind)) dupes.add(rule.kind)
+    seen.add(rule.kind)
+  }
+  return dupes
+})
+
+/** A share is edited in PERCENT, which is how the rule is spoken ("5% or more"), stored 0..1. */
+function sharePercent(rule: PlatformFailureKindRule): number {
+  return Math.round(rule.maxShare * 1000) / 10
+}
+
+function setOverriding(on: boolean) {
+  // Turning the override ON starts from the empty list rather than a seeded row: an editor that
+  // invented a rule would have the human deleting a page they never asked for.
+  emit('update:modelValue', on ? [] : undefined)
+}
+
+function patch(index: number, next: Partial<PlatformFailureKindRule>) {
+  emit(
+    'update:modelValue',
+    rules.value.map((rule, i) => (i === index ? { ...rule, ...next } : rule)),
+  )
+}
+
+function setShare(index: number, raw: string) {
+  const percent = Number(raw.trim())
+  // A blank or unreadable box is left at zero rather than dropped: `maxShare` has no "unset"
+  // (a rule without a ceiling is not a rule), and 0 is refused by the contract, so an incomplete
+  // row is REPORTED by `faults` below instead of being quietly discarded on save.
+  patch(index, { maxShare: Number.isFinite(percent) ? percent / 100 : 0 })
+}
+
+function setMinCount(index: number, raw: string) {
+  const trimmed = raw.trim()
+  if (trimmed === '') {
+    const { minCount: _dropped, ...rest } = rules.value[index]!
+    emit(
+      'update:modelValue',
+      rules.value.map((rule, i) => (i === index ? rest : rule)),
+    )
+    return
+  }
+  const parsed = Number(trimmed)
+  patch(index, { minCount: Number.isFinite(parsed) ? Math.round(parsed) : 1 })
+}
+
+/**
+ * The first kind nothing has claimed, or undefined once every one is spoken for.
+ *
+ * Undefined is what DISABLES the add button, rather than seeding a duplicate of the first kind
+ * and letting the duplicate warning explain it afterwards: at most one rule per kind is the
+ * contract, so a row the editor can only add in a state the contract refuses is a row it should
+ * not offer. It also puts the list's cap out of reach by construction — the vocabulary is far
+ * shorter than `MAX_FAILURE_KIND_RULES`, so unique-by-kind is the binding limit.
+ */
+const nextFreeKind = computed<AgentFailureKind | undefined>(() => {
+  const taken = new Set(rules.value.map((rule) => rule.kind))
+  return AGENT_FAILURE_KINDS.find((kind) => !taken.has(kind))
+})
+
+function addRule() {
+  const kind = nextFreeKind.value
+  if (kind === undefined) return
+  emit('update:modelValue', [...rules.value, { kind, maxShare: 0.05 }])
+}
+
+function removeRule(index: number) {
+  emit(
+    'update:modelValue',
+    rules.value.filter((_, i) => i !== index),
+  )
+}
+
+/**
+ * What the backend would refuse about this list. The same helper the parent's save path calls,
+ * so what the sheet flags and what the save stops on cannot disagree.
+ */
+const faults = computed(() => failureKindRuleFaults(rules.value))
+</script>
+
+<template>
+  <div class="space-y-2" data-testid="platform-alert-failure-kinds">
+    <label class="text-[11px] font-medium text-slate-300">
+      {{ t('settings.platformAlerts.failureKinds.label') }}
+    </label>
+    <p class="text-[11px] text-slate-400">
+      {{ t('settings.platformAlerts.failureKinds.description') }}
+    </p>
+
+    <div class="space-y-1">
+      <UCheckbox
+        :model-value="overriding"
+        size="sm"
+        :label="t('settings.platformAlerts.failureKinds.overrideLabel')"
+        data-testid="platform-alert-failure-kinds-override"
+        @update:model-value="setOverriding(!!$event)"
+      />
+      <p class="ps-6 text-[11px] text-slate-400">
+        {{ t('settings.platformAlerts.failureKinds.overrideHint') }}
+      </p>
+    </div>
+
+    <template v-if="overriding">
+      <p
+        v-if="rules.length === 0"
+        class="text-[11px] text-slate-500"
+        data-testid="platform-alert-failure-kinds-empty"
+      >
+        {{ t('settings.platformAlerts.failureKinds.empty') }}
+      </p>
+
+      <div
+        v-for="(rule, index) in rules"
+        :key="index"
+        class="grid grid-cols-1 items-end gap-2 sm:grid-cols-[2fr_1fr_1fr_auto]"
+        :data-testid="`platform-alert-failure-kind-row-${index}`"
+      >
+        <div class="space-y-1">
+          <label class="block text-[11px] text-slate-300">
+            {{ t('settings.platformAlerts.failureKinds.kindLabel') }}
+          </label>
+          <USelect
+            :model-value="rule.kind"
+            :items="kindItems(rule.kind)"
+            value-key="value"
+            size="sm"
+            :data-testid="`platform-alert-failure-kind-${index}`"
+            @update:model-value="patch(index, { kind: String($event) })"
+          />
+        </div>
+        <div class="space-y-1">
+          <label class="block text-[11px] text-slate-300">
+            {{ t('settings.platformAlerts.failureKinds.shareLabel') }}
+          </label>
+          <UInput
+            :model-value="String(sharePercent(rule))"
+            type="number"
+            step="1"
+            size="sm"
+            :data-testid="`platform-alert-failure-share-${index}`"
+            @update:model-value="setShare(index, String($event))"
+          />
+          <p v-if="index === 0" class="text-[11px] text-slate-500">
+            {{ t('settings.platformAlerts.failureKinds.shareHint') }}
+          </p>
+        </div>
+        <div class="space-y-1">
+          <label class="block text-[11px] text-slate-300">
+            {{ t('settings.platformAlerts.failureKinds.minCountLabel') }}
+          </label>
+          <UInput
+            :model-value="rule.minCount === undefined ? '' : String(rule.minCount)"
+            type="number"
+            step="1"
+            size="sm"
+            :placeholder="t('settings.platformAlerts.failureKinds.minCountPlaceholder')"
+            :data-testid="`platform-alert-failure-min-count-${index}`"
+            @update:model-value="setMinCount(index, String($event))"
+          />
+        </div>
+        <UButton
+          color="neutral"
+          variant="subtle"
+          size="xs"
+          icon="i-lucide-trash-2"
+          :aria-label="t('settings.platformAlerts.failureKinds.removeRule')"
+          :data-testid="`platform-alert-failure-remove-${index}`"
+          @click="removeRule(index)"
+        />
+      </div>
+
+      <p
+        v-if="faults.tooMany"
+        class="text-[11px] text-amber-300"
+        data-testid="platform-alert-failure-kinds-too-many"
+      >
+        {{
+          t('settings.platformAlerts.failureKinds.tooManyRules', { max: MAX_FAILURE_KIND_RULES })
+        }}
+      </p>
+      <p
+        v-else-if="duplicateKinds.size > 0"
+        class="text-[11px] text-amber-300"
+        data-testid="platform-alert-failure-kinds-duplicate"
+      >
+        {{ t('settings.platformAlerts.failureKinds.duplicateKind') }}
+      </p>
+      <p
+        v-else-if="faults.rows.length > 0"
+        class="text-[11px] text-amber-300"
+        data-testid="platform-alert-failure-kinds-invalid"
+      >
+        {{
+          t('settings.platformAlerts.failureKinds.invalidRows', { rows: faults.rows.join(', ') })
+        }}
+      </p>
+
+      <UButton
+        color="neutral"
+        variant="subtle"
+        size="xs"
+        icon="i-lucide-plus"
+        :disabled="nextFreeKind === undefined"
+        data-testid="platform-alert-failure-kinds-add"
+        @click="addRule"
+      >
+        {{ t('settings.platformAlerts.failureKinds.addRule') }}
+      </UButton>
+      <p
+        v-if="nextFreeKind === undefined"
+        class="text-[11px] text-slate-500"
+        data-testid="platform-alert-failure-kinds-all-covered"
+      >
+        {{ t('settings.platformAlerts.failureKinds.allKindsCovered') }}
+      </p>
+      <p class="text-[11px] text-slate-500">
+        {{ t('settings.platformAlerts.failureKinds.minCountHint') }}
+      </p>
+    </template>
+  </div>
+</template>

package/app/components/layout/AccountPlatformAlertSettings.vue

@@ -4,7 +4,14 @@ import type {
   PlatformAlertSettings,
   PlatformAlertThresholdOverrides,
   PlatformAlertWindow,
+  PlatformFailureKindRule,
 } from '~/types/execution'
+import AccountFailureKindRules from '~/components/layout/AccountFailureKindRules.vue'
+import {
+  failureKindRuleFaults,
+  hasFailureKindRuleFaults,
+  MAX_FAILURE_KIND_RULES,
+} from '~/utils/failureKinds'
 
 // Per-account tuning for the platform-health alert sweep (admin only): the ceilings the
 // deployment's aggregate run health is checked against, and the window they are evaluated over.
@@ -38,9 +45,12 @@ const windowItems = computed(() =>
 )
 
 /**
- * The numeric ceilings, each rendered as one row: the contract key plus the input's step.
+ * The NUMERIC ceilings, each rendered as one row: the contract key plus the input's step.
  * ONE table drives the form, the hydrate and the save, so adding a threshold to the contract
  * is a single entry rather than a form field plus a save branch free to disagree with it.
+ *
+ * `failureKindRules` is deliberately absent from it: it is a LIST, so it has neither a step nor
+ * a blank-means-inherit box, and it is edited by its own component below.
  */
 const THRESHOLDS = [
   { field: 'minRuns', step: 1 },
@@ -83,6 +93,10 @@ const thresholdHints = computed<Record<ThresholdField, string>>(() => ({
 const muted = ref(false)
 const alertWindow = ref<PlatformAlertWindow | ''>('')
 const values = ref<Record<ThresholdField, string>>(blankValues())
+// Undefined is "inherit the deployment's rules"; an EMPTY array is "this account has none".
+// Kept apart for the same reason blank and 0 are above, and here the two are further apart
+// still: one follows the deployment's pager wiring, the other switches it off.
+const failureKindRules = ref<PlatformFailureKindRule[] | undefined>(undefined)
 const saving = ref(false)
 
 function blankValues(): Record<ThresholdField, string> {
@@ -112,6 +126,9 @@ function hydrate() {
   const next = blankValues()
   for (const th of THRESHOLDS) next[th.field] = toDisplay(th.field, stored?.thresholds?.[th.field])
   values.value = next
+  // Copied, not aliased: the editor mutates by replacement, and hydrating from the store's own
+  // objects would let an unsaved edit read back as the account's stored state.
+  failureKindRules.value = stored?.thresholds?.failureKindRules?.map((rule) => ({ ...rule }))
 }
 
 onMounted(async () => {
@@ -159,9 +176,14 @@ function collectThresholds(): PlatformAlertThresholdOverrides {
     const parsed = fromDisplay(th.field, values.value[th.field])
     if (parsed !== undefined) out[th.field] = parsed
   }
+  // Sent whole or omitted whole. An empty list is a real setting and travels as one.
+  if (failureKindRules.value !== undefined) out.failureKindRules = failureKindRules.value
   return out
 }
 
+/** What the backend would refuse about the per-kind rules, from the helper the editor shows. */
+const ruleFaults = computed(() => failureKindRuleFaults(failureKindRules.value ?? []))
+
 async function save() {
   if (!loaded.value) {
     toast.add({ title: t('settings.platformAlerts.notLoaded'), color: 'error' })
@@ -175,6 +197,22 @@ async function save() {
     })
     return
   }
+  // Refused here rather than left to the write boundary: the API rejects the WHOLE config blob,
+  // so a bad rule would read to the admin as the model policy beside it failing to save. The
+  // two faults describe themselves differently because they are fixed differently — a row
+  // number is useless advice for a list that is simply too long.
+  if (hasFailureKindRuleFaults(ruleFaults.value)) {
+    toast.add({
+      title: t('settings.platformAlerts.failureKinds.invalidTitle'),
+      description: ruleFaults.value.tooMany
+        ? t('settings.platformAlerts.failureKinds.tooManyRules', { max: MAX_FAILURE_KIND_RULES })
+        : t('settings.platformAlerts.failureKinds.invalidRows', {
+            rows: ruleFaults.value.rows.join(', '),
+          }),
+      color: 'error',
+    })
+    return
+  }
   const thresholds = collectThresholds()
   // Each key is omitted rather than nulled when it carries no override: an absent key is what
   // the backend reads as "inherit the deployment default", and a stored null would be a value.
@@ -210,12 +248,14 @@ function resetAll() {
   muted.value = false
   alertWindow.value = ''
   values.value = blankValues()
+  failureKindRules.value = undefined
 }
 
 const hasOverrides = computed(
   () =>
     muted.value ||
     alertWindow.value !== '' ||
+    failureKindRules.value !== undefined ||
     THRESHOLDS.some((th) => values.value[th.field].trim() !== ''),
 )
 </script>
@@ -288,6 +328,8 @@ const hasOverrides = computed(
       </div>
     </div>
 
+    <AccountFailureKindRules v-model="failureKindRules" />
+
     <!--
       A save REPLACES the whole account config and this sheet edits one key of it, so with the
       current config not in hand there is nothing to carry forward. Say so and disable the

package/app/components/panels/OperatorDashboardPanel.vue

@@ -1,8 +1,9 @@
 <script setup lang="ts">
 import { computed, watch } from 'vue'
 import { onKeyStroke } from '@vueuse/core'
-import type { AgentFailureKind, PlatformObservabilityWindow } from '~/types/execution'
+import type { PlatformObservabilityWindow } from '~/types/execution'
 import { formatMs } from '~/utils/observability'
+import { FAILURE_KIND_KEYS, isAgentFailureKind } from '~/utils/failureKinds'
 
 // Deployment-level (platform-operator) observability dashboard: the aggregate health of the
 // active account's runs — outcome totals + success rate, a time-bucketed outcome trend, the
@@ -29,25 +30,12 @@ const WINDOWS: { value: PlatformObservabilityWindow; label: string }[] = [
   { value: '90d', label: t('platformObservability.window.ninetyDays') },
 ]
 
-// Exhaustive enum→label map (tier-2 dynamic-key guard): a new AgentFailureKind fails the
-// typecheck here, and an out-of-enum kind falls back to its raw code below.
-const FAILURE_KIND_KEYS: Record<AgentFailureKind, string> = {
-  preflight: 'platformObservability.failureKind.preflight',
-  dispatch: 'platformObservability.failureKind.dispatch',
-  environment: 'platformObservability.failureKind.environment',
-  evicted: 'platformObservability.failureKind.evicted',
-  timeout: 'platformObservability.failureKind.timeout',
-  agent: 'platformObservability.failureKind.agent',
-  job_failed: 'platformObservability.failureKind.job_failed',
-  rejected: 'platformObservability.failureKind.rejected',
-  companion_rejected: 'platformObservability.failureKind.companion_rejected',
-  stalled: 'platformObservability.failureKind.stalled',
-  cancelled: 'platformObservability.failureKind.cancelled',
-  unknown: 'platformObservability.failureKind.unknown',
-}
+// The enum→label map is SHARED with the alert-settings panel (`~/utils/failureKinds`), which
+// offers the same vocabulary as the subject of a per-kind alert rule: one map, so the kind an
+// operator points a page at and the kind this breakdown shows can never be labelled differently.
+// An out-of-enum kind (a retired one on an old row) falls back to its raw code.
 function failureLabel(kind: string): string {
-  const key = FAILURE_KIND_KEYS[kind as AgentFailureKind]
-  return key ? t(key) : kind
+  return isAgentFailureKind(kind) ? t(FAILURE_KIND_KEYS[kind]) : kind
 }
 
 const DAY_MS = 24 * 60 * 60 * 1000

package/app/types/execution.ts

@@ -36,6 +36,7 @@ export type {
   PlatformAlertSettings,
   PlatformAlertThresholdOverrides,
   PlatformAlertWindow,
+  PlatformFailureKindRule,
   PlatformFailingRun,
   ReportWindow,
   ReportSpendDimension,

package/app/utils/failureKinds.spec.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest'
+import type { PlatformFailureKindRule } from '~/types/execution'
+import {
+  AGENT_FAILURE_KINDS,
+  FAILURE_KIND_KEYS,
+  failureKindRuleFaults,
+  hasFailureKindRuleFaults,
+  isAgentFailureKind,
+  MAX_FAILURE_KIND_RULES,
+} from '~/utils/failureKinds'
+
+describe('the failure-kind vocabulary', () => {
+  it('offers exactly the kinds the contract declares, and labels every one', () => {
+    // The map is what both the dashboard breakdown and the alert-rule picker read, so a kind
+    // added to the contract without a label here would render a raw code in both.
+    expect(AGENT_FAILURE_KINDS.length).toBeGreaterThan(0)
+    for (const kind of AGENT_FAILURE_KINDS) expect(FAILURE_KIND_KEYS[kind]).toBeTruthy()
+    expect(Object.keys(FAILURE_KIND_KEYS).sort()).toEqual([...AGENT_FAILURE_KINDS].sort())
+  })
+
+  it('recognises a current kind and refuses a retired or mistyped one', () => {
+    // Re-exported from `@cat-factory/contracts` rather than reimplemented, because the backend
+    // asks the identical question of an operator-typed kind in the env var. Pinned through the
+    // SPA's own import path so the re-export cannot quietly disappear.
+    expect(isAgentFailureKind('evicted')).toBe(true)
+    // The case the predicate exists for: a kind that a release retired still arrives on stored
+    // rules and old run rows, and must render as itself rather than as `undefined` or as
+    // whichever current member a guess landed on.
+    expect(isAgentFailureKind('evicetd')).toBe(false)
+  })
+
+  it('never offers more kinds than a rule list may hold, so the cap cannot bind first', () => {
+    // What makes "one rule per kind" the binding limit in the editor, and therefore what lets
+    // the add button simply stop rather than seeding a row the contract would refuse.
+    expect(AGENT_FAILURE_KINDS.length).toBeLessThanOrEqual(MAX_FAILURE_KIND_RULES)
+  })
+})
+
+describe('failureKindRuleFaults', () => {
+  const rule = (over: Partial<PlatformFailureKindRule> = {}): PlatformFailureKindRule => ({
+    kind: 'evicted',
+    maxShare: 0.05,
+    ...over,
+  })
+
+  it('accepts a well-formed set of rules', () => {
+    expect(
+      failureKindRuleFaults([rule(), rule({ kind: 'timeout', maxShare: 1, minCount: 3 })]),
+    ).toEqual({ rows: [], tooMany: false })
+    expect(failureKindRuleFaults([])).toEqual({ rows: [], tooMany: false })
+    expect(hasFailureKindRuleFaults(failureKindRuleFaults([rule()]))).toBe(false)
+  })
+
+  it('names the 1-based rows the backend would refuse', () => {
+    // The share bounds mirror the contract: 0 is satisfied by any distribution (including a kind
+    // that never occurred), and there is nothing above "all of them".
+    expect(failureKindRuleFaults([rule({ maxShare: 0 })]).rows).toEqual([1])
+    expect(failureKindRuleFaults([rule({ maxShare: 1.5 })]).rows).toEqual([1])
+    expect(failureKindRuleFaults([rule(), rule({ kind: 'timeout', minCount: 0 })]).rows).toEqual([
+      2,
+    ])
+    expect(failureKindRuleFaults([rule({ kind: 'timeout', minCount: 2.5 })]).rows).toEqual([1])
+  })
+
+  it('names BOTH rows of a duplicated kind, since either could be the one to fix', () => {
+    expect(failureKindRuleFaults([rule(), rule({ maxShare: 0.5 })]).rows).toEqual([1, 2])
+  })
+
+  it('reports an over-long list as its own fault, not as a bad row', () => {
+    // "There are too many rules" is fixed by deleting any of them, so pointing at a row number
+    // would name a row that is perfectly well-formed. The two faults travel separately for that
+    // reason, and either one alone must still stop the save.
+    const many = Array.from({ length: MAX_FAILURE_KIND_RULES + 1 }, (_, i) =>
+      rule({ kind: `kind${i}` }),
+    )
+    const faults = failureKindRuleFaults(many)
+    expect(faults).toEqual({ rows: [], tooMany: true })
+    expect(hasFailureKindRuleFaults(faults)).toBe(true)
+    // Exactly at the cap is fine — the bound is inclusive, as `v.maxLength` is.
+    expect(failureKindRuleFaults(many.slice(0, MAX_FAILURE_KIND_RULES)).tooMany).toBe(false)
+  })
+})

package/app/utils/failureKinds.ts

@@ -0,0 +1,91 @@
+// ---------------------------------------------------------------------------
+// Shared presentation for the run FAILURE TAXONOMY — the vocabulary the operator dashboard
+// renders as a breakdown and the alert settings panel offers as the subject of a per-kind
+// rule. Two surfaces answering about the same set, so the enum→key map lives here once: a
+// second copy is a map that drifts, and the surface that drifts is the one where an operator
+// picks the kind a page is wired to.
+//
+// The map is an exhaustive `Record<AgentFailureKind, …>`, so adding a kind to the contract
+// fails the typecheck here rather than rendering a raw code in either place.
+//
+// What is PRESENTATION lives here; what is a RULE comes from `@cat-factory/contracts` and is
+// re-exported so a component has one import. `isAgentFailureKind` in particular is not the
+// SPA's to own: the backend asks the identical question of an operator-typed kind in
+// `PLATFORM_ALERTS_FAILURE_KIND_RATES`, and two copies of "which kinds exist" is the pair that
+// drifts the moment one is retired.
+// ---------------------------------------------------------------------------
+
+import { agentFailureKindSchema, MAX_FAILURE_KIND_RULES } from '@cat-factory/contracts'
+import type { AgentFailureKind, PlatformFailureKindRule } from '~/types/execution'
+
+export { isAgentFailureKind, MAX_FAILURE_KIND_RULES } from '@cat-factory/contracts'
+
+/** i18n key per failure kind. */
+export const FAILURE_KIND_KEYS: Record<AgentFailureKind, string> = {
+  preflight: 'platformObservability.failureKind.preflight',
+  dispatch: 'platformObservability.failureKind.dispatch',
+  environment: 'platformObservability.failureKind.environment',
+  evicted: 'platformObservability.failureKind.evicted',
+  timeout: 'platformObservability.failureKind.timeout',
+  agent: 'platformObservability.failureKind.agent',
+  job_failed: 'platformObservability.failureKind.job_failed',
+  rejected: 'platformObservability.failureKind.rejected',
+  companion_rejected: 'platformObservability.failureKind.companion_rejected',
+  stalled: 'platformObservability.failureKind.stalled',
+  cancelled: 'platformObservability.failureKind.cancelled',
+  unknown: 'platformObservability.failureKind.unknown',
+}
+
+/**
+ * The kinds a human may be OFFERED, in the contract's own declared order.
+ *
+ * Read off the picklist rather than restated, so the choices a rule can be written against are
+ * the choices the backend recognises. The DISPLAYED set is deliberately not the same thing as
+ * the set of values that may ARRIVE: a stored rule or a persisted run row can still name a kind
+ * a later release retired, which `isAgentFailureKind` is for.
+ */
+export const AGENT_FAILURE_KINDS = agentFailureKindSchema.options as readonly AgentFailureKind[]
+
+/**
+ * Whether a stored per-kind rule list would be REFUSED by the contract, and why.
+ *
+ * One implementation shared by the editor and the save path, because they are the same question
+ * asked twice: a fault the editor flags but the save path does not is a save that fails on the
+ * WHOLE settings blob, for a reason the sheet never showed and about a sibling setting the admin
+ * never touched.
+ *
+ * The two faults are kept APART rather than folded into one list of bad rows, because they need
+ * different fixes and one of them belongs to no row in particular: "row 3 is malformed" is fixed
+ * in row 3, while "there are more rules than the contract allows" is fixed by deleting any of
+ * them. Reporting the second as a row number would point at a row that is perfectly fine.
+ *
+ * Deliberately mirrors the contract rather than re-deciding anything: a share in (0, 1], a whole
+ * minimum count of 1 or more when one is set, at most one rule per kind, and at most
+ * {@link MAX_FAILURE_KIND_RULES} rules.
+ */
+export interface FailureKindRuleFaults {
+  /** 1-based positions of individual rules the contract would refuse. */
+  rows: number[]
+  /** Whether the LIST is over the contract's cap, which is no single row's fault. */
+  tooMany: boolean
+}
+
+export function failureKindRuleFaults(
+  rules: readonly PlatformFailureKindRule[],
+): FailureKindRuleFaults {
+  const counts = new Map<string, number>()
+  for (const rule of rules) counts.set(rule.kind, (counts.get(rule.kind) ?? 0) + 1)
+  const rows = rules.flatMap((rule, index) => {
+    const shareOk = rule.maxShare > 0 && rule.maxShare <= 1
+    const countOk =
+      rule.minCount === undefined || (Number.isInteger(rule.minCount) && rule.minCount >= 1)
+    const unique = (counts.get(rule.kind) ?? 0) === 1
+    return shareOk && countOk && unique ? [] : [index + 1]
+  })
+  return { rows, tooMany: rules.length > MAX_FAILURE_KIND_RULES }
+}
+
+/** Whether a list is savable at all — the one question both call sites actually branch on. */
+export function hasFailureKindRuleFaults(faults: FailureKindRuleFaults): boolean {
+  return faults.rows.length > 0 || faults.tooMany
+}

package/i18n/locales/de.json

@@ -1174,7 +1174,28 @@
         "maxSweepFailures": "Aufeinanderfolgende fehlgeschlagene Durchläufe einer Hintergrundprüfung."
       },
       "notLoaded": "Die aktuellen Einstellungen dieses Kontos konnten nicht geladen werden; ein Speichern würde die übrigen überschreiben. Bitte vor dem Bearbeiten neu laden.",
-      "invalidNumbers": "Diese Obergrenzen sind keine Zahlen"
+      "invalidNumbers": "Diese Obergrenzen sind keine Zahlen",
+      "failureKinds": {
+        "label": "Regeln pro Fehlerart",
+        "description": "Alarm auslösen, wenn eine Fehlerart den Anteil an Fehlschlägen erreicht, den Sie ihr zugestehen. Die Obergrenze für die dominante Ursache oben fragt, ob eine Art alle anderen überlagert; diese Regeln fragen, ob eine benannte Art das erreicht, was diese Installation von ihr toleriert.",
+        "overrideLabel": "Eigene Regeln pro Fehlerart für dieses Konto festlegen",
+        "overrideHint": "Aus: Das Konto verwendet die Regeln der Installation. Ein: Die Liste unten ersetzt sie vollständig, und eine leere Liste bedeutet gar keine Regeln pro Fehlerart.",
+        "empty": "Keine Regeln. Dieses Konto löst den Alarm pro Fehlerart nicht aus.",
+        "kindLabel": "Fehlerart",
+        "shareLabel": "Anteil an Fehlschlägen (%)",
+        "shareHint": "Die Regel löst ab diesem Anteil aus.",
+        "minCountLabel": "Mindestanzahl Fehlschläge",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Wie viele Fehlschläge dieser Art im Zeitfenster nötig sind, bevor die Regel auslösen kann. Ohne diesen Wert ist ein niedriger Anteil überempfindlich: Fünf Läufe mit einer Verdrängung sind bereits 20 %.",
+        "addRule": "Regel hinzufügen",
+        "allKindsCovered": "Jede Fehlerart hat bereits eine Regel.",
+        "removeRule": "Regel entfernen",
+        "duplicateKind": "Jede Fehlerart darf höchstens eine Regel haben.",
+        "tooManyRules": "Höchstens {max} Regeln pro Fehlerart. Entfernen Sie einige vor dem Speichern.",
+        "unknownKind": "{kind} (unbekannt)",
+        "invalidTitle": "Diese Regeln pro Fehlerart können nicht gespeichert werden",
+        "invalidRows": "Prüfen Sie die Regeln {rows}: Der Anteil muss über 0 und höchstens 100 liegen, eine Mindestanzahl muss eine ganze Zahl ab 1 sein, und jede Art darf nur einmal vorkommen."
+      }
     }
   },
   "inspector": {

package/i18n/locales/en.json

@@ -3648,7 +3648,28 @@
         "maxSweepFailures": "Consecutive failed passes of one background sweep."
       },
       "notLoaded": "This account's current settings could not be loaded, so saving would overwrite the rest of them. Reload before editing.",
-      "invalidNumbers": "These ceilings are not numbers"
+      "invalidNumbers": "These ceilings are not numbers",
+      "failureKinds": {
+        "label": "Per-failure-kind rules",
+        "description": "Page when one failure kind reaches the share of failures you allow it. The dominant-cause ceiling above asks whether one kind is swamping the rest; these ask whether a named kind has reached what this deployment tolerates from it.",
+        "overrideLabel": "Set this account's own per-kind rules",
+        "overrideHint": "Off, the account uses the rules the deployment configured. On, the list below replaces them entirely, and an empty list means no per-kind rules at all.",
+        "empty": "No rules. This account will not raise the per-kind alert.",
+        "kindLabel": "Failure kind",
+        "shareLabel": "Share of failures (%)",
+        "shareHint": "The rule fires at this share or above.",
+        "minCountLabel": "Minimum failures",
+        "minCountPlaceholder": "1",
+        "minCountHint": "How many failures of that kind the window needs before the rule can fire. A low share is a hair trigger without it: five runs with one eviction is already 20%.",
+        "addRule": "Add rule",
+        "allKindsCovered": "Every failure kind already has a rule.",
+        "removeRule": "Remove rule",
+        "duplicateKind": "Each failure kind may carry at most one rule.",
+        "tooManyRules": "At most {max} per-kind rules. Remove some before saving.",
+        "unknownKind": "{kind} (unrecognised)",
+        "invalidTitle": "These per-kind rules cannot be saved",
+        "invalidRows": "Check rules {rows}: the share must be above 0 and at most 100, a minimum count must be a whole number of 1 or more, and each kind may appear once."
+      }
     }
   },
   "providers": {

package/i18n/locales/es.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "Pasadas fallidas consecutivas de un barrido en segundo plano."
       },
       "notLoaded": "No se pudieron cargar los ajustes actuales de esta cuenta, así que guardar sobrescribiría el resto. Vuelve a cargar antes de editar.",
-      "invalidNumbers": "Estos límites no son números"
+      "invalidNumbers": "Estos límites no son números",
+      "failureKinds": {
+        "label": "Reglas por tipo de fallo",
+        "description": "Avisa cuando un tipo de fallo alcanza la proporción de fallos que le permites. El límite de causa dominante de arriba pregunta si un tipo está desbordando al resto; estas reglas preguntan si un tipo concreto ha alcanzado lo que este despliegue tolera de él.",
+        "overrideLabel": "Definir reglas por tipo propias de esta cuenta",
+        "overrideHint": "Desactivado, la cuenta usa las reglas configuradas en el despliegue. Activado, la lista de abajo las sustituye por completo, y una lista vacía significa ninguna regla por tipo.",
+        "empty": "Sin reglas. Esta cuenta no generará la alerta por tipo de fallo.",
+        "kindLabel": "Tipo de fallo",
+        "shareLabel": "Proporción de fallos (%)",
+        "shareHint": "La regla se activa a partir de esta proporción.",
+        "minCountLabel": "Fallos mínimos",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Cuántos fallos de ese tipo necesita la ventana antes de que la regla pueda dispararse. Sin esto, una proporción baja salta a la mínima: cinco ejecuciones con un desalojo ya son el 20 %.",
+        "addRule": "Añadir regla",
+        "allKindsCovered": "Cada tipo de fallo ya tiene una regla.",
+        "removeRule": "Eliminar regla",
+        "duplicateKind": "Cada tipo de fallo admite como máximo una regla.",
+        "tooManyRules": "Como máximo {max} reglas por tipo. Elimina algunas antes de guardar.",
+        "unknownKind": "{kind} (no reconocido)",
+        "invalidTitle": "Estas reglas por tipo no se pueden guardar",
+        "invalidRows": "Revisa las reglas {rows}: la proporción debe ser mayor que 0 y como máximo 100, el mínimo debe ser un número entero de 1 o más, y cada tipo puede aparecer una sola vez."
+      }
     }
   },
   "providers": {

package/i18n/locales/fr.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "Passages consécutifs en échec d'un balayage en arrière-plan."
       },
       "notLoaded": "Les paramètres actuels de ce compte n'ont pas pu être chargés ; enregistrer écraserait les autres. Rechargez avant de modifier.",
-      "invalidNumbers": "Ces plafonds ne sont pas des nombres"
+      "invalidNumbers": "Ces plafonds ne sont pas des nombres",
+      "failureKinds": {
+        "label": "Règles par type d'échec",
+        "description": "Alerter quand un type d'échec atteint la part d'échecs que vous lui accordez. Le plafond de cause dominante ci-dessus demande si un type submerge les autres ; ces règles demandent si un type nommé a atteint ce que ce déploiement tolère de lui.",
+        "overrideLabel": "Définir les règles par type propres à ce compte",
+        "overrideHint": "Désactivé, le compte utilise les règles configurées par le déploiement. Activé, la liste ci-dessous les remplace entièrement, et une liste vide signifie aucune règle par type.",
+        "empty": "Aucune règle. Ce compte ne déclenchera pas l'alerte par type d'échec.",
+        "kindLabel": "Type d'échec",
+        "shareLabel": "Part des échecs (%)",
+        "shareHint": "La règle se déclenche à partir de cette part.",
+        "minCountLabel": "Échecs minimum",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Combien d'échecs de ce type la fenêtre doit compter avant que la règle puisse se déclencher. Sans cela, une part faible se déclenche pour un rien : cinq exécutions avec une éviction, c'est déjà 20 %.",
+        "addRule": "Ajouter une règle",
+        "allKindsCovered": "Chaque type d'échec a déjà une règle.",
+        "removeRule": "Supprimer la règle",
+        "duplicateKind": "Chaque type d'échec ne peut porter qu'une seule règle.",
+        "tooManyRules": "Au plus {max} règles par type. Supprimez-en avant d’enregistrer.",
+        "unknownKind": "{kind} (non reconnu)",
+        "invalidTitle": "Ces règles par type ne peuvent pas être enregistrées",
+        "invalidRows": "Vérifiez les règles {rows} : la part doit être supérieure à 0 et au plus 100, un minimum doit être un entier supérieur ou égal à 1, et chaque type ne peut apparaître qu'une fois."
+      }
     }
   },
   "providers": {

package/i18n/locales/he.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "מעברים כושלים רצופים של סריקת רקע אחת."
       },
       "notLoaded": "לא ניתן היה לטעון את ההגדרות הנוכחיות של חשבון זה, ולכן שמירה תדרוס את שאר ההגדרות. יש לטעון מחדש לפני עריכה.",
-      "invalidNumbers": "תקרות אלה אינן מספרים"
+      "invalidNumbers": "תקרות אלה אינן מספרים",
+      "failureKinds": {
+        "label": "כללים לפי סוג כשל",
+        "description": "התרעה כאשר סוג כשל מגיע לחלק בכשלים שהוגדר לו. תקרת הסיבה הדומיננטית שלמעלה שואלת אם סוג אחד מציף את כל השאר; הכללים כאן שואלים אם סוג מסוים הגיע למה שהפריסה הזאת מוכנה לספוג ממנו.",
+        "overrideLabel": "הגדרת כללים משלו לחשבון הזה",
+        "overrideHint": "כבוי, החשבון משתמש בכללים שהוגדרו בפריסה. דלוק, הרשימה שלמטה מחליפה אותם לחלוטין, ורשימה ריקה משמעה שאין כללים לפי סוג כלל.",
+        "empty": "אין כללים. החשבון הזה לא יפיק התרעה לפי סוג כשל.",
+        "kindLabel": "סוג כשל",
+        "shareLabel": "חלק מהכשלים (%)",
+        "shareHint": "הכלל פועל מהחלק הזה ומעלה.",
+        "minCountLabel": "מינימום כשלים",
+        "minCountPlaceholder": "1",
+        "minCountHint": "כמה כשלים מהסוג הזה נדרשים בחלון לפני שהכלל יכול לפעול. בלי זה, אחוז נמוך רגיש מדי: חמש ריצות עם פינוי אחד הן כבר 20%.",
+        "addRule": "הוספת כלל",
+        "allKindsCovered": "לכל סוג כשל כבר יש כלל.",
+        "removeRule": "הסרת כלל",
+        "duplicateKind": "לכל סוג כשל אפשר להגדיר כלל אחד לכל היותר.",
+        "tooManyRules": "לכל היותר {max} כללים לפי סוג. הסירו חלק לפני השמירה.",
+        "unknownKind": "{kind} (לא מזוהה)",
+        "invalidTitle": "לא ניתן לשמור את הכללים האלה",
+        "invalidRows": "בדקו את הכללים {rows}: החלק חייב להיות גדול מ-0 ולכל היותר 100, מינימום חייב להיות מספר שלם מ-1 ומעלה, וכל סוג יכול להופיע פעם אחת בלבד."
+      }
     }
   },
   "providers": {

package/i18n/locales/it.json

@@ -1174,7 +1174,28 @@
         "maxSweepFailures": "Passaggi falliti consecutivi di una scansione in background."
       },
       "notLoaded": "Non è stato possibile caricare le impostazioni correnti di questo account, quindi il salvataggio sovrascriverebbe le altre. Ricarica prima di modificare.",
-      "invalidNumbers": "Questi limiti non sono numeri"
+      "invalidNumbers": "Questi limiti non sono numeri",
+      "failureKinds": {
+        "label": "Regole per tipo di errore",
+        "description": "Avvisa quando un tipo di errore raggiunge la quota di errori che gli concedi. Il tetto sulla causa dominante qui sopra chiede se un tipo sta sommergendo gli altri; queste regole chiedono se un tipo specifico ha raggiunto ciò che questo deployment tollera da esso.",
+        "overrideLabel": "Imposta regole per tipo proprie di questo account",
+        "overrideHint": "Disattivato, l'account usa le regole configurate dal deployment. Attivato, l'elenco qui sotto le sostituisce del tutto, e un elenco vuoto significa nessuna regola per tipo.",
+        "empty": "Nessuna regola. Questo account non genererà l'avviso per tipo di errore.",
+        "kindLabel": "Tipo di errore",
+        "shareLabel": "Quota di errori (%)",
+        "shareHint": "La regola scatta da questa quota in su.",
+        "minCountLabel": "Errori minimi",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Quanti errori di quel tipo servono nella finestra prima che la regola possa scattare. Senza, una quota bassa scatta per un nulla: cinque esecuzioni con uno sfratto sono già il 20%.",
+        "addRule": "Aggiungi regola",
+        "allKindsCovered": "Ogni tipo di errore ha già una regola.",
+        "removeRule": "Rimuovi regola",
+        "duplicateKind": "Ogni tipo di errore può avere al massimo una regola.",
+        "tooManyRules": "Al massimo {max} regole per tipo. Rimuovine alcune prima di salvare.",
+        "unknownKind": "{kind} (non riconosciuto)",
+        "invalidTitle": "Queste regole per tipo non possono essere salvate",
+        "invalidRows": "Controlla le regole {rows}: la quota deve essere maggiore di 0 e al massimo 100, il minimo deve essere un numero intero da 1 in su, e ogni tipo può comparire una volta sola."
+      }
     }
   },
   "inspector": {

package/i18n/locales/ja.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "ひとつのバックグラウンド監視が連続して失敗した回数。"
       },
       "notLoaded": "このアカウントの現在の設定を読み込めなかったため、保存すると他の設定が上書きされます。編集する前に再読み込みしてください。",
-      "invalidNumbers": "これらの上限値が数値ではありません"
+      "invalidNumbers": "これらの上限値が数値ではありません",
+      "failureKinds": {
+        "label": "失敗種別ごとのルール",
+        "description": "ある失敗種別が、許容する失敗の割合に達したときに通知します。上のドミナント原因のしきい値は「1 つの種別が他をのみ込んでいるか」を問うものですが、これらのルールは「名指しした種別がこのデプロイで許容する範囲に達したか」を問います。",
+        "overrideLabel": "このアカウント独自の種別ルールを設定する",
+        "overrideHint": "オフの場合、アカウントはデプロイ側で設定されたルールを使います。オンの場合、下の一覧がそれを完全に置き換え、空の一覧は「種別ルールなし」を意味します。",
+        "empty": "ルールがありません。このアカウントでは種別ごとのアラートは発報しません。",
+        "kindLabel": "失敗種別",
+        "shareLabel": "失敗に占める割合 (%)",
+        "shareHint": "この割合以上でルールが発報します。",
+        "minCountLabel": "最小失敗件数",
+        "minCountPlaceholder": "1",
+        "minCountHint": "ルールが発報できるようになるまでに、その種別の失敗が対象期間に何件必要かを指定します。これがないと低い割合は過敏になります。5 件の実行のうち 1 件が退避なら、それだけで 20% です。",
+        "addRule": "ルールを追加",
+        "allKindsCovered": "すべての失敗種別にルールが設定済みです。",
+        "removeRule": "ルールを削除",
+        "duplicateKind": "1 つの失敗種別に設定できるルールは 1 つまでです。",
+        "tooManyRules": "種別ごとのルールは最大 {max} 件です。保存する前にいくつか削除してください。",
+        "unknownKind": "{kind}（未知の種別）",
+        "invalidTitle": "これらの種別ルールは保存できません",
+        "invalidRows": "ルール {rows} を確認してください。割合は 0 より大きく 100 以下、最小件数は 1 以上の整数、各種別は 1 回だけ指定できます。"
+      }
     }
   },
   "providers": {

package/i18n/locales/pl.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "Kolejne nieudane przebiegi jednego zadania w tle."
       },
       "notLoaded": "Nie udało się wczytać bieżących ustawień tego konta, więc zapis nadpisałby pozostałe. Odśwież przed edycją.",
-      "invalidNumbers": "Te limity nie są liczbami"
+      "invalidNumbers": "Te limity nie są liczbami",
+      "failureKinds": {
+        "label": "Reguły dla poszczególnych rodzajów awarii",
+        "description": "Alarm, gdy jeden rodzaj awarii osiągnie dopuszczony dla niego udział w awariach. Powyższy limit dominującej przyczyny pyta, czy jeden rodzaj przytłacza pozostałe; te reguły pytają, czy wskazany rodzaj osiągnął to, co to wdrożenie z jego strony toleruje.",
+        "overrideLabel": "Ustaw własne reguły tego konta",
+        "overrideHint": "Wyłączone: konto korzysta z reguł skonfigurowanych we wdrożeniu. Włączone: poniższa lista zastępuje je w całości, a pusta lista oznacza brak reguł dla rodzajów awarii.",
+        "empty": "Brak reguł. To konto nie zgłosi alertu dla rodzaju awarii.",
+        "kindLabel": "Rodzaj awarii",
+        "shareLabel": "Udział w awariach (%)",
+        "shareHint": "Reguła uruchamia się od tego udziału wzwyż.",
+        "minCountLabel": "Minimalna liczba awarii",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Ile awarii tego rodzaju musi wystąpić w oknie, zanim reguła zadziała. Bez tego niski udział jest nadwrażliwy: pięć uruchomień z jednym wywłaszczeniem to już 20%.",
+        "addRule": "Dodaj regułę",
+        "allKindsCovered": "Każdy rodzaj awarii ma już regułę.",
+        "removeRule": "Usuń regułę",
+        "duplicateKind": "Każdy rodzaj awarii może mieć najwyżej jedną regułę.",
+        "tooManyRules": "Najwyżej {max} reguł na rodzaj. Usuń część przed zapisaniem.",
+        "unknownKind": "{kind} (nierozpoznany)",
+        "invalidTitle": "Tych reguł nie można zapisać",
+        "invalidRows": "Sprawdź reguły {rows}: udział musi być większy niż 0 i najwyżej 100, minimum musi być liczbą całkowitą od 1 w górę, a każdy rodzaj może wystąpić tylko raz."
+      }
     }
   },
   "providers": {

package/i18n/locales/tr.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "Bir arka plan taramasının üst üste başarısız geçişi."
       },
       "notLoaded": "Bu hesabın mevcut ayarları yüklenemedi; kaydetmek diğerlerinin üzerine yazar. Düzenlemeden önce yeniden yükleyin.",
-      "invalidNumbers": "Bu üst sınırlar sayı değil"
+      "invalidNumbers": "Bu üst sınırlar sayı değil",
+      "failureKinds": {
+        "label": "Hata türü başına kurallar",
+        "description": "Bir hata türü, ona tanıdığınız hata payına ulaştığında uyarır. Yukarıdaki baskın neden tavanı bir türün diğerlerini bastırıp bastırmadığını sorar; buradaki kurallar ise adı geçen bir türün bu kurulumun ondan kabul ettiği sınıra ulaşıp ulaşmadığını sorar.",
+        "overrideLabel": "Bu hesaba özel tür kuralları tanımla",
+        "overrideHint": "Kapalıyken hesap, kurulumda yapılandırılan kuralları kullanır. Açıkken aşağıdaki liste onların yerini tamamen alır ve boş liste hiç tür kuralı olmaması demektir.",
+        "empty": "Kural yok. Bu hesap tür bazlı uyarı üretmeyecek.",
+        "kindLabel": "Hata türü",
+        "shareLabel": "Hatalar içindeki pay (%)",
+        "shareHint": "Kural bu paydan itibaren tetiklenir.",
+        "minCountLabel": "En az hata sayısı",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Kuralın tetiklenebilmesi için pencerede o türden kaç hata gerektiğini belirler. Bu olmadan düşük bir pay çok hassas kalır: beş çalıştırmada bir tahliye zaten %20 eder.",
+        "addRule": "Kural ekle",
+        "allKindsCovered": "Her hata türünün zaten bir kuralı var.",
+        "removeRule": "Kuralı kaldır",
+        "duplicateKind": "Her hata türü en fazla bir kural taşıyabilir.",
+        "tooManyRules": "En fazla {max} tür kuralı. Kaydetmeden önce bir kısmını kaldırın.",
+        "unknownKind": "{kind} (tanınmıyor)",
+        "invalidTitle": "Bu tür kuralları kaydedilemiyor",
+        "invalidRows": "{rows} numaralı kuralları gözden geçirin: pay 0'dan büyük ve en fazla 100 olmalı, en az sayı 1 veya üzeri bir tam sayı olmalı ve her tür yalnızca bir kez yer alabilir."
+      }
     }
   },
   "providers": {

package/i18n/locales/uk.json

@@ -3541,7 +3541,28 @@
         "maxSweepFailures": "Послідовні невдалі проходи одного фонового прибирання."
       },
       "notLoaded": "Не вдалося завантажити поточні налаштування цього облікового запису, тож збереження перезапише решту. Перезавантажте перед редагуванням.",
-      "invalidNumbers": "Ці обмеження не є числами"
+      "invalidNumbers": "Ці обмеження не є числами",
+      "failureKinds": {
+        "label": "Правила за видом збою",
+        "description": "Сповіщати, коли один вид збою досягає дозволеної для нього частки збоїв. Стеля домінантної причини вище запитує, чи один вид перекриває решту; ці правила запитують, чи названий вид досяг межі, яку це розгортання від нього терпить.",
+        "overrideLabel": "Задати власні правила для цього облікового запису",
+        "overrideHint": "Вимкнено: обліковий запис використовує правила, налаштовані в розгортанні. Увімкнено: список нижче замінює їх повністю, а порожній список означає відсутність правил за видом збою.",
+        "empty": "Правил немає. Цей обліковий запис не подаватиме сповіщення за видом збою.",
+        "kindLabel": "Вид збою",
+        "shareLabel": "Частка збоїв (%)",
+        "shareHint": "Правило спрацьовує від цієї частки й вище.",
+        "minCountLabel": "Мінімум збоїв",
+        "minCountPlaceholder": "1",
+        "minCountHint": "Скільки збоїв цього виду потрібно у вікні, перш ніж правило зможе спрацювати. Без цього низька частка надто чутлива: п'ять запусків з одним витісненням це вже 20%.",
+        "addRule": "Додати правило",
+        "allKindsCovered": "Кожен вид збою вже має правило.",
+        "removeRule": "Вилучити правило",
+        "duplicateKind": "Кожен вид збою може мати щонайбільше одне правило.",
+        "tooManyRules": "Щонайбільше {max} правил за видом. Вилучіть частину перед збереженням.",
+        "unknownKind": "{kind} (нерозпізнаний)",
+        "invalidTitle": "Ці правила не можна зберегти",
+        "invalidRows": "Перевірте правила {rows}: частка має бути більшою за 0 і не більшою за 100, мінімум має бути цілим числом від 1, і кожен вид може траплятися лише раз."
+      }
     }
   },
   "providers": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.218.0",
+  "version": "0.219.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.231.0"
+    "@cat-factory/contracts": "0.232.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",