@cat-factory/app 0.161.0 → 0.162.0

package/app/components/panels/ReportsSpendBreakdown.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import type { ReportSpendRow } from '~/types/execution'
+import { maxOf, segmentPct, spendMagnitude } from './ReportsPanel.logic'
+
+// One ranked spend breakdown: a horizontal bar per slice, split into the metered
+// (`violet-500`, real money) and subscription (`amber-600`, illustrative equivalent-API
+// cost) segments with a surface gap between them. Extracted from `ReportsPanel.vue` because
+// the panel renders four of these against different dimensions — the shape is identical,
+// only the row list and the heading differ.
+//
+// Every bar is scaled against the HEAVIEST slice in this list, so a full bar means "the
+// biggest consumer here", never an absolute budget. The panel owns the legend (the two
+// series mean the same thing in every breakdown, so repeating it per card would be noise).
+const props = defineProps<{
+  rows: ReportSpendRow[]
+  currency: string
+  testId: string
+  /** Resolves a slice's display name (the panel owns the unattributed/i18n vocabulary). */
+  labelOf: (row: ReportSpendRow) => string
+}>()
+
+const { t, n } = useI18n()
+const money = (value: number) => n(value, { key: 'currency', currency: props.currency })
+const max = computed(() => maxOf(props.rows, spendMagnitude))
+</script>
+
+<template>
+  <div class="rounded-lg border border-slate-800 bg-slate-900/40 p-4">
+    <div v-if="!rows.length" class="py-4 text-center text-xs text-slate-500">
+      {{ t('reports.spend.empty') }}
+    </div>
+    <ul v-else class="flex flex-col gap-2.5" :data-testid="testId">
+      <li v-for="row in rows" :key="row.key" class="text-xs" data-testid="reports-spend-row">
+        <div class="mb-1 flex items-baseline justify-between gap-2">
+          <span class="min-w-0 truncate text-slate-300">{{ labelOf(row) }}</span>
+          <!-- The metered figure alone is the slice's SPEND. The subscription cost rides
+               beside it, in its own series colour and explicitly named, because it is the
+               illustrative cost of flat-rate quota usage — adding the two into one currency
+               figure would report money that was never billed. -->
+          <span class="shrink-0 tabular-nums text-slate-400">
+            {{ money(row.meteredCost) }}
+            <span v-if="row.subscriptionCost > 0" class="text-amber-400">
+              {{ t('reports.spend.subscriptionAside', { value: money(row.subscriptionCost) }) }}
+            </span>
+          </span>
+        </div>
+        <div class="flex h-1.5 gap-[2px]">
+          <div
+            class="h-1.5 rounded-full bg-violet-500"
+            :style="{ width: `${segmentPct(row.meteredCost, max)}%` }"
+          />
+          <div
+            class="h-1.5 rounded-full bg-amber-600"
+            :style="{ width: `${segmentPct(row.subscriptionCost, max)}%` }"
+          />
+        </div>
+        <p class="mt-1 text-[10px] text-slate-500">
+          {{ t('reports.spend.calls', { count: row.calls }, row.calls) }} ·
+          {{
+            t('reports.spend.tokens', {
+              input: formatTokens(row.inputTokens),
+              output: formatTokens(row.outputTokens),
+            })
+          }}
+        </p>
+      </li>
+    </ul>
+  </div>
+</template>

package/app/composables/api/reports.ts

@@ -0,0 +1,19 @@
+import { getReportsContract } from '@cat-factory/contracts'
+import type { ReportWindow } from '~/types/execution'
+import type { ApiContext } from './context'
+
+/**
+ * Reports: cross-cutting usage analytics for an account over a time window
+ * (admin-gated). The sibling of `platformObservabilityApi` — same account scope,
+ * a different question ("where did the spend and the work go" vs "is it healthy").
+ * `workspaceId` narrows every breakdown to one board.
+ */
+export function reportsApi({ send }: ApiContext) {
+  return {
+    getReports: (accountId: string, window: ReportWindow, workspaceId?: string | null) =>
+      send(getReportsContract, {
+        pathParams: { accountId },
+        queryParams: { window, ...(workspaceId ? { workspaceId } : {}) },
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -3,6 +3,7 @@ import { createApiClient, createSend, createSendWith } from './api/client'
 import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
 import { platformObservabilityApi } from './api/platformObservability'
+import { reportsApi } from './api/reports'
 import { authApi } from './api/auth'
 import { bootstrapApi } from './api/bootstrap'
 import { boardApi } from './api/board'
@@ -112,6 +113,7 @@ export function useApi() {
     ...modelsApi(ctx),
     ...accountsApi(ctx),
     ...platformObservabilityApi(ctx),
+    ...reportsApi(ctx),
     ...workspacesApi(ctx),
     ...boardApi(ctx),
     ...executionApi(ctx),

package/app/composables/useNavContributions.ts

@@ -45,6 +45,7 @@ export function useNavContributions() {
     localModels: () => ui.openLocalModels(),
     accountSettings: () => ui.openAccountSettings(),
     operatorDashboard: () => ui.openOperatorDashboard(),
+    reports: () => ui.openReports(),
     shortcuts: () => ui.openShortcutsHelp(),
   }
 

package/app/modular/nav-contributions.spec.ts

@@ -166,6 +166,7 @@ describe('nav grouping helpers', () => {
       'model-config',
       'account-settings',
       'operator-dashboard',
+      'reports',
     ])
   })
 

package/app/modular/nav-contributions.ts

@@ -96,6 +96,7 @@ export const NAV_ACTIONS = [
   'localModels',
   'accountSettings',
   'operatorDashboard',
+  'reports',
   'shortcuts',
 ] as const
 
@@ -354,6 +355,16 @@ export const NAV_CONTRIBUTIONS: readonly NavContribution[] = [
     testId: 'nav-operator-dashboard',
     sidebar: { group: 'configuration', order: 40 },
   },
+  {
+    id: 'reports',
+    labelKey: 'nav.reports',
+    icon: 'i-lucide-chart-column',
+    surfaces: S('sidebar'),
+    gate: (g) => g.accountsEnabled && g.isAccountAdmin,
+    action: 'reports',
+    testId: 'nav-reports',
+    sidebar: { group: 'configuration', order: 45 },
+  },
   {
     id: 'keyboard-shortcuts',
     labelKey: 'layout.commandBar.cmd.shortcuts',

package/app/pages/index.vue

@@ -35,6 +35,7 @@ const ObservabilityPanel = defineAsyncComponent(
 const OperatorDashboardPanel = defineAsyncComponent(
   () => import('~/components/panels/OperatorDashboardPanel.vue'),
 )
+const ReportsPanel = defineAsyncComponent(() => import('~/components/panels/ReportsPanel.vue'))
 const KaizenPanel = defineAsyncComponent(() => import('~/components/kaizen/KaizenPanel.vue'))
 // Occasional, externally store-gated surfaces — deferred to their own chunks like the
 // sibling document modals above. Each mounts only while its ui open-flag is set, so it
@@ -400,6 +401,7 @@ watch(
       <RecurringPipelineModal v-if="ui.addRecurringFrameId" />
       <ObservabilityPanel v-if="ui.observabilityInstanceId" />
       <OperatorDashboardPanel v-if="ui.operatorDashboardOpen" />
+      <ReportsPanel v-if="ui.reportsOpen" />
       <KaizenPanel v-if="ui.kaizenScreenOpen" />
       <DocumentSourceConnectModal v-if="ui.documentConnect" />
       <DocumentImportModal v-if="ui.documentImport" />

package/app/stores/reports.spec.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useAccountsStore } from '~/stores/accounts'
+import { useReportsStore } from '~/stores/reports'
+import type { ReportsView } from '~/types/execution'
+
+// The reports view is loaded three ways that can each be triggered while another is still in
+// flight — the window buttons, the board filter and the refresh button — so the store's
+// monotonicity guard is the thing that keeps the panel from showing numbers for a window the
+// user already left. These drive that race directly.
+
+/** Minimal projection — only what the store stores and these assertions read. */
+function view(over: Partial<ReportsView> = {}): ReportsView {
+  return {
+    window: '7d',
+    generatedAt: 1_000,
+    since: 0,
+    workspaceId: null,
+    currency: 'EUR',
+    totals: { inputTokens: 0, outputTokens: 0, calls: 0, meteredCost: 0, subscriptionCost: 0 },
+    spend: { byModel: [], byAgentKind: [], byWorkspace: [], byService: [], byTaskType: [] },
+    activity: { byWorkspace: [], byService: [], byTaskType: [] },
+    trend: { bucketMs: 1_000, points: [] },
+    ...over,
+  } as ReportsView
+}
+
+/** Seed an active account, since every load is scoped to one. */
+function seedAccount() {
+  const accounts = useAccountsStore()
+  accounts.accounts = [
+    {
+      id: 'acc1',
+      type: 'org',
+      name: 'Acme',
+      githubAccountLogin: null,
+      createdAt: 0,
+      roles: null,
+    },
+  ] as never
+  accounts.activeAccountId = 'acc1'
+}
+
+describe('reports store — concurrent loads', () => {
+  beforeEach(() => {
+    seedAccount()
+  })
+
+  it('a stale load never overwrites a fresher one that already resolved', async () => {
+    // The user picks 24h, then immediately 90d. The 24h request is slower and lands LAST;
+    // committing it would leave the panel labelled 90d while showing 24h numbers.
+    let resolveSlow!: (v: ReportsView) => void
+    const slow = new Promise<ReportsView>((res) => {
+      resolveSlow = res
+    })
+    const responses: Record<string, Promise<ReportsView>> = {
+      '24h': slow,
+      '90d': Promise.resolve(view({ window: '90d', totals: { ...view().totals, calls: 42 } })),
+    }
+    vi.stubGlobal('useApi', () => ({
+      getReports: (_id: string, window: string) => responses[window]!,
+    }))
+    const store = useReportsStore()
+
+    const first = store.setWindow('24h')
+    const second = store.setWindow('90d')
+    await second
+    resolveSlow(view({ window: '24h', totals: { ...view().totals, calls: 7 } }))
+    await first
+
+    expect(store.view?.window).toBe('90d')
+    expect(store.view?.totals.calls).toBe(42)
+    // The superseded load must not resurrect the spinner it started either.
+    expect(store.loading).toBe(false)
+  })
+
+  it('a superseded FAILURE never replaces the newer view with an error', async () => {
+    // The same race the other way round: an in-flight load rejects after a later
+    // one succeeded. Committing it would blank a perfectly good panel.
+    let rejectSlow!: (e: Error) => void
+    const slow = new Promise<ReportsView>((_res, rej) => {
+      rejectSlow = rej
+    })
+    const responses: Record<string, Promise<ReportsView>> = {
+      '24h': slow,
+      '90d': Promise.resolve(view({ window: '90d' })),
+    }
+    vi.stubGlobal('useApi', () => ({
+      getReports: (_id: string, window: string) => responses[window]!,
+    }))
+    const store = useReportsStore()
+
+    const first = store.setWindow('24h')
+    await store.setWindow('90d')
+    rejectSlow(new Error('gateway timeout'))
+    await first
+
+    expect(store.failed).toBe(false)
+    expect(store.error).toBeNull()
+    expect(store.view?.window).toBe('90d')
+  })
+
+  it('records a failure from the newest load, with the raw message as detail', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getReports: () => Promise.reject(new Error('reports are not available')),
+    }))
+    const store = useReportsStore()
+    await store.load()
+    expect(store.failed).toBe(true)
+    // Raw backend prose only — the localized heading is the panel's job.
+    expect(store.error).toBe('reports are not available')
+    expect(store.loading).toBe(false)
+  })
+})

package/app/stores/reports.ts

@@ -0,0 +1,91 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { ReportWindow, ReportsView } from '~/types/execution'
+import { useAccountsStore } from '~/stores/accounts'
+
+/**
+ * Reports: cross-cutting usage analytics for the active account — spend per model and
+ * agent kind, spend + run activity per workspace / service / task type, and a spend trend,
+ * over a selectable window and optionally narrowed to one board.
+ *
+ * The sibling of the `platformObservability` store: same account scope, same admin gate,
+ * same on-demand load. Nothing is pushed live (these are periodic rollups); changing the
+ * window or the board filter re-fetches, and a manual refresh re-fetches unconditionally.
+ */
+export const useReportsStore = defineStore('reports', () => {
+  const api = useApi()
+  const accounts = useAccountsStore()
+
+  const window = ref<ReportWindow>('7d')
+  /** The single board every breakdown is narrowed to, or null for the whole account. */
+  const workspaceFilter = ref<string | null>(null)
+  const view = ref<ReportsView | null>(null)
+  const loading = ref(false)
+  /** Whether the last load failed. The panel owns the localized wording. */
+  const failed = ref(false)
+  /**
+   * The backend's raw (untranslated) message for a failed load, shown beneath the localized
+   * heading as a last-resort detail — null when the failure carried no message at all.
+   */
+  const error = ref<string | null>(null)
+
+  const accountId = computed(() => accounts.activeAccount?.id ?? null)
+
+  /**
+   * Monotonicity guard. The window buttons, the board filter and the refresh button can each
+   * start a load, so two are easily in flight at once — and without this a staler response
+   * resolving later would overwrite the newer view (and its `loading`/error state) with
+   * numbers for a window the user already moved off. Only the newest load may commit.
+   */
+  let latest = 0
+
+  async function load() {
+    const id = accountId.value
+    if (!id) {
+      view.value = null
+      return
+    }
+    const seq = ++latest
+    loading.value = true
+    failed.value = false
+    error.value = null
+    try {
+      const next = await api.getReports(id, window.value, workspaceFilter.value)
+      if (seq !== latest) return
+      view.value = next
+    } catch (err) {
+      if (seq !== latest) return
+      failed.value = true
+      error.value = err instanceof Error ? err.message : null
+    } finally {
+      if (seq === latest) loading.value = false
+    }
+  }
+
+  /** Switch the window and reload (a no-op when it is already the loaded one). */
+  async function setWindow(next: ReportWindow) {
+    if (next === window.value && view.value) return
+    window.value = next
+    await load()
+  }
+
+  /** Narrow to one board (null = the whole account) and reload. */
+  async function setWorkspaceFilter(next: string | null) {
+    if (next === workspaceFilter.value && view.value) return
+    workspaceFilter.value = next
+    await load()
+  }
+
+  return {
+    window,
+    workspaceFilter,
+    view,
+    loading,
+    failed,
+    error,
+    accountId,
+    load,
+    setWindow,
+    setWorkspaceFilter,
+  }
+})

package/app/stores/ui/modals.ts

@@ -440,6 +440,10 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   // from `observabilityConnectionOpen` (the Datadog connection) AND `observabilityInstanceId`
   // (the per-run LLM call panel).
   const operatorDashboardOpen = ref(false)
+  // Reports: the cross-cutting usage-analytics panel over the same account scope (spend per
+  // model / agent kind, spend + activity per workspace / service / task type). Admin-gated.
+  // Distinct from `operatorDashboardOpen`, which answers the deployment-HEALTH question.
+  const reportsOpen = ref(false)
   // Private package registries: the workspace's npm/GitHub-Packages entries agent
   // containers install with. Opened from the Integrations hub.
   const packageRegistriesOpen = ref(false)
@@ -486,6 +490,13 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   function closeOperatorDashboard() {
     operatorDashboardOpen.value = false
   }
+  function openReports() {
+    resetHubReturn()
+    reportsOpen.value = true
+  }
+  function closeReports() {
+    reportsOpen.value = false
+  }
   function openPackageRegistries() {
     resetHubReturn()
     packageRegistriesOpen.value = true
@@ -544,6 +555,7 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     slackOpen,
     observabilityConnectionOpen,
     operatorDashboardOpen,
+    reportsOpen,
     packageRegistriesOpen,
     apiTokensOpen,
     modelConfigOpen,
@@ -559,6 +571,8 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     openObservabilityConnection,
     closeObservabilityConnection,
     openOperatorDashboard,
+    openReports,
+    closeReports,
     closeOperatorDashboard,
     openPackageRegistries,
     closePackageRegistries,

package/app/types/execution.ts

@@ -30,6 +30,14 @@ export type {
   PlatformOutcomeTotals,
   PlatformTrendPoint,
   PlatformFailureSlice,
+  ReportWindow,
+  ReportSpendDimension,
+  ReportActivityDimension,
+  ReportSpendRow,
+  ReportActivityRow,
+  ReportTrendPoint,
+  ReportTotals,
+  ReportsView,
   AgentSearchQuery,
   WebSearchAvailability,
   WebSearchProvider,

package/i18n/locales/de.json

@@ -3000,6 +3000,70 @@
       "title": "Jetzt aktiv"
     }
   },
+  "reports": {
+    "title": "Berichte",
+    "refresh": "Aktualisieren",
+    "loading": "Berichte werden geladen…",
+    "retry": "Erneut versuchen",
+    "error": "Berichte konnten nicht geladen werden.",
+    "period": "{from} bis {to}",
+    "unattributed": "Nicht zugeordnet",
+    "window": {
+      "oneDay": "Letzte 24 Stunden",
+      "sevenDays": "Letzte 7 Tage",
+      "thirtyDays": "Letzte 30 Tage",
+      "ninetyDays": "Letzte 90 Tage"
+    },
+    "filter": {
+      "board": "Board",
+      "allBoards": "Alle Boards"
+    },
+    "dimension": {
+      "workspace": "Board",
+      "service": "Service",
+      "taskType": "Aufgabentyp"
+    },
+    "breakdown": {
+      "title": "Aufschlüsselung nach"
+    },
+    "totals": {
+      "title": "In diesem Zeitraum",
+      "metered": "Abgerechnete Kosten",
+      "subscription": "Abo",
+      "calls": "LLM-Aufrufe",
+      "tokens": "Tokens",
+      "illustrative": "Abokosten sind nur kalkulatorisch – diese Tarife sind pauschal, werden nicht pro Token abgerechnet und zählen nie als Ausgaben."
+    },
+    "trend": {
+      "title": "Kosten im Zeitverlauf",
+      "empty": "In diesem Zeitraum wurde keine Nutzung erfasst."
+    },
+    "legend": {
+      "metered": "Abgerechnet",
+      "subscription": "Abo"
+    },
+    "spend": {
+      "byModel": "Kosten nach Modell",
+      "byAgentKind": "Kosten nach Agententyp",
+      "heading": "Kosten",
+      "empty": "In diesem Zeitraum wurde keine Nutzung erfasst.",
+      "calls": "{count} Aufruf | {count} Aufrufe",
+      "tokens": "{input} rein / {output} raus",
+      "subscriptionAside": "+{value} Abo"
+    },
+    "activity": {
+      "heading": "Läufe",
+      "empty": "In diesem Zeitraum gab es keine Läufe.",
+      "runs": "{count} Lauf | {count} Läufe",
+      "avg": "Ø {value}"
+    },
+    "status": {
+      "done": "Abgeschlossen",
+      "failed": "Fehlgeschlagen",
+      "running": "Läuft",
+      "other": "Sonstige"
+    }
+  },
   "auth": {
     "gate": {
       "loading": "Wird geladen…"
@@ -4159,6 +4223,7 @@
     "modelConfiguration": "Modellkonfiguration",
     "accountSettings": "Kontoeinstellungen",
     "operatorDashboard": "Plattform-Observability",
+    "reports": "Berichte",
     "environmentSetup": "Umgebungseinrichtung"
   },
   "errors": {

package/i18n/locales/en.json

@@ -130,6 +130,7 @@
     "modelConfiguration": "Model configuration",
     "accountSettings": "Account settings",
     "operatorDashboard": "Platform observability",
+    "reports": "Reports",
     "environmentSetup": "Environment setup"
   },
   "board": {
@@ -1524,6 +1525,70 @@
       "title": "Live now"
     }
   },
+  "reports": {
+    "title": "Reports",
+    "refresh": "Refresh",
+    "loading": "Loading reports…",
+    "retry": "Retry",
+    "error": "Reports could not be loaded.",
+    "period": "{from} to {to}",
+    "unattributed": "Unattributed",
+    "window": {
+      "oneDay": "Last 24 hours",
+      "sevenDays": "Last 7 days",
+      "thirtyDays": "Last 30 days",
+      "ninetyDays": "Last 90 days"
+    },
+    "filter": {
+      "board": "Board",
+      "allBoards": "All boards"
+    },
+    "dimension": {
+      "workspace": "Board",
+      "service": "Service",
+      "taskType": "Task type"
+    },
+    "breakdown": {
+      "title": "Breakdown by"
+    },
+    "totals": {
+      "title": "This window",
+      "metered": "Metered spend",
+      "subscription": "Subscription",
+      "calls": "LLM calls",
+      "tokens": "Tokens",
+      "illustrative": "Subscription costs are illustrative — those plans are flat-rate, not billed per token, and are never counted as spend."
+    },
+    "trend": {
+      "title": "Spend over time",
+      "empty": "No recorded usage in this window."
+    },
+    "legend": {
+      "metered": "Metered",
+      "subscription": "Subscription"
+    },
+    "spend": {
+      "byModel": "Spend by model",
+      "byAgentKind": "Spend by agent kind",
+      "heading": "Spend",
+      "empty": "No recorded usage in this window.",
+      "calls": "{count} call | {count} calls",
+      "tokens": "{input} in / {output} out",
+      "subscriptionAside": "+{value} subscription"
+    },
+    "activity": {
+      "heading": "Runs",
+      "empty": "No runs in this window.",
+      "runs": "{count} run | {count} runs",
+      "avg": "avg {value}"
+    },
+    "status": {
+      "done": "Completed",
+      "failed": "Failed",
+      "running": "Running",
+      "other": "Other"
+    }
+  },
   "auth": {
     "gate": {
       "loading": "Loading…"

package/i18n/locales/es.json

@@ -111,6 +111,7 @@
     "modelConfiguration": "Configuración del modelo",
     "accountSettings": "Ajustes de la cuenta",
     "operatorDashboard": "Observabilidad de la plataforma",
+    "reports": "Informes",
     "infrastructure": "Infraestructura",
     "environmentSetup": "Configuración de entorno"
   },
@@ -1461,6 +1462,70 @@
       "title": "Activas ahora"
     }
   },
+  "reports": {
+    "title": "Informes",
+    "refresh": "Actualizar",
+    "loading": "Cargando informes…",
+    "retry": "Reintentar",
+    "error": "No se pudieron cargar los informes.",
+    "period": "Del {from} al {to}",
+    "unattributed": "Sin atribuir",
+    "window": {
+      "oneDay": "Últimas 24 horas",
+      "sevenDays": "Últimos 7 días",
+      "thirtyDays": "Últimos 30 días",
+      "ninetyDays": "Últimos 90 días"
+    },
+    "filter": {
+      "board": "Tablero",
+      "allBoards": "Todos los tableros"
+    },
+    "dimension": {
+      "workspace": "Tablero",
+      "service": "Servicio",
+      "taskType": "Tipo de tarea"
+    },
+    "breakdown": {
+      "title": "Desglose por"
+    },
+    "totals": {
+      "title": "En este periodo",
+      "metered": "Gasto medido",
+      "subscription": "Suscripción",
+      "calls": "Llamadas al LLM",
+      "tokens": "Tokens",
+      "illustrative": "Los costes de suscripción son orientativos: esos planes son de tarifa plana, no se facturan por token y nunca cuentan como gasto."
+    },
+    "trend": {
+      "title": "Gasto a lo largo del tiempo",
+      "empty": "No se registró uso en este periodo."
+    },
+    "legend": {
+      "metered": "Medido",
+      "subscription": "Suscripción"
+    },
+    "spend": {
+      "byModel": "Gasto por modelo",
+      "byAgentKind": "Gasto por tipo de agente",
+      "heading": "Gasto",
+      "empty": "No se registró uso en este periodo.",
+      "calls": "{count} llamada | {count} llamadas",
+      "tokens": "{input} de entrada / {output} de salida",
+      "subscriptionAside": "+{value} suscripción"
+    },
+    "activity": {
+      "heading": "Ejecuciones",
+      "empty": "No hubo ejecuciones en este periodo.",
+      "runs": "{count} ejecución | {count} ejecuciones",
+      "avg": "media {value}"
+    },
+    "status": {
+      "done": "Completadas",
+      "failed": "Fallidas",
+      "running": "En curso",
+      "other": "Otras"
+    }
+  },
   "auth": {
     "gate": {
       "loading": "Cargando…"