@runwisp/ui 0.14.0 → 0.15.0

package/src/lib/components/dashboard/RunsList.svelte

@@ -175,7 +175,7 @@
         if (run.status === "running") return "live";
         if (run.status === "pending") return "queued";
         if (displayed === "failed" || displayed === "crashed") {
-            return "exit " + String(run.exit_code);
+            return "exit " + String(run.exitCode);
         }
         return runDuration(run) ?? "—";
     }
@@ -277,30 +277,30 @@
     // (page-injected or popover-set) always applies.
     function buildSelectorFilter(): NonNullable<RunSelector["filter"]> {
         const filter: NonNullable<RunSelector["filter"]> = {};
-        if (taskNameFilter) filter.task_name = taskNameFilter;
-        else if (filters.task_name) filter.task_name = filters.task_name;
+        if (taskNameFilter) filter.taskName = taskNameFilter;
+        else if (filters.taskName) filter.taskName = filters.taskName;
         if (!showFilters) return filter;
         if (filters.statuses.length > 0) filter.status = filters.statuses.join(",");
         const query = filters.search.trim();
         if (query) filter.search = query;
-        if (filters.created_after) filter.created_after = filters.created_after;
-        if (filters.created_before) filter.created_before = filters.created_before;
-        if (filters.triggered_by) filter.triggered_by = filters.triggered_by;
-        const exit = exitCodeRange(filters.exit_code);
-        if (exit.min !== undefined) filter.exit_code_min = exit.min;
-        if (exit.max !== undefined) filter.exit_code_max = exit.max;
-        if (filters.retries_only) filter.retries_only = true;
+        if (filters.createdAfter) filter.createdAfter = filters.createdAfter;
+        if (filters.createdBefore) filter.createdBefore = filters.createdBefore;
+        if (filters.triggeredBy) filter.triggeredBy = filters.triggeredBy;
+        const exit = exitCodeRange(filters.exitCode);
+        if (exit.min !== undefined) filter.exitCodeMin = exit.min;
+        if (exit.max !== undefined) filter.exitCodeMax = exit.max;
+        if (filters.retriesOnly) filter.retriesOnly = true;
         return filter;
     }
 
     function buildSelector(): RunSelector {
         if (!selectAllMode) {
-            return { match_all: false, ids: [...explicitIds] };
+            return { matchAll: false, ids: [...explicitIds] };
         }
         return {
-            match_all: true,
+            matchAll: true,
             filter: buildSelectorFilter(),
-            except_ids: [...exceptIds],
+            exceptIds: [...exceptIds],
         };
     }
 
@@ -319,19 +319,19 @@
             case "time":
                 return timeChipLabel();
             case "task":
-                return filters.task_name ?? "";
-            case "triggered_by":
-                return "Trigger: " + triggerDescription(filters.triggered_by ?? "");
-            case "exit_code":
-                return exitCodeChipLabel(filters.exit_code);
+                return filters.taskName ?? "";
+            case "triggeredBy":
+                return "Trigger: " + triggerDescription(filters.triggeredBy ?? "");
+            case "exitCode":
+                return exitCodeChipLabel(filters.exitCode);
             case "retries":
                 return "Retries only";
         }
     }
 
     function timeChipLabel(): string {
-        const after = filters.created_after;
-        const before = filters.created_before;
+        const after = filters.createdAfter;
+        const before = filters.createdBefore;
         if (isWholeDay(after, before) && after) return `On ${formatCalendarDate(after)}`;
         if (after && before) return `${formatDateTime(after)} – ${formatDateTime(before)}`;
         if (after) return `Since ${formatDateTime(after)}`;
@@ -350,9 +350,9 @@
         const sel = buildSelector();
         // Narrow the selector to the affected predicate when in explicit mode
         // so we don't ask the server to operate on rows the UI excluded.
-        const narrowed: RunSelector = sel.match_all
+        const narrowed: RunSelector = sel.matchAll
             ? sel
-            : { match_all: false, ids: affected.map((r) => r.id) };
+            : { matchAll: false, ids: affected.map((r) => r.id) };
         handler(narrowed, affected);
         clearSelection();
     }
@@ -368,7 +368,7 @@
         // reliably re-triggers its fetch effect.
         filters = {
             ...filters,
-            sort_direction: filters.sort_direction === "asc" ? "desc" : "asc",
+            sortDirection: filters.sortDirection === "asc" ? "desc" : "asc",
         };
     }
 
@@ -480,7 +480,7 @@
                     {#snippet icon()}
                         <ArrowUpDown
                             size={14}
-                            class="text-on-surface-muted {filters.sort_direction === 'asc'
+                            class="text-on-surface-muted {filters.sortDirection === 'asc'
                                 ? 'rotate-180'
                                 : ''}"
                         />
@@ -626,7 +626,7 @@
             checked={isRowSelected(run.id)}
             onchange={() => toggleRow(run.id)}
             onclick={(e) => e.stopPropagation()}
-            aria-label={`Select run from ${formatDateTime(run.start_at ?? run.created_at)}`}
+            aria-label={`Select run from ${formatDateTime(run.startAt ?? run.createdAt)}`}
             class="size-3.5 cursor-pointer rounded border-outline accent-primary opacity-0 {selectionActive
                 ? 'opacity-100'
                 : 'group-hover/row:opacity-100'}"
@@ -639,9 +639,9 @@
     {@const config = getRunStatusConfig(dstatus)}
     {@const running = run.status === "running"}
     {@const spine = config.dot.replace(" animate-pulse", "")}
-    {@const startedAt = run.start_at ?? run.created_at}
+    {@const startedAt = run.startAt ?? run.createdAt}
     {@const retry = runRetryLabel(run)}
-    {@const suffix = instanceSuffix(run.instance_index, getInstanceCount(run.task_name))}
+    {@const suffix = instanceSuffix(run.instanceIndex, getInstanceCount(run.taskName))}
     <button
         class="btn-scale group relative w-full rounded-[3px] border text-left select-none {showTaskName
             ? 'p-3'
@@ -660,7 +660,7 @@
                 <span class="flex min-w-0 flex-1 flex-col gap-0.5">
                     <span class="flex items-center gap-1.5">
                         <span class="truncate font-mono text-[13px] font-semibold text-on-surface">
-                            {run.task_name}{#if suffix}<span class="text-on-surface-muted"
+                            {run.taskName}{#if suffix}<span class="text-on-surface-muted"
                                     >{suffix}</span
                                 >{/if}
                         </span>
@@ -675,7 +675,7 @@
                         title={formatFullDateTime(startedAt)}
                     >
                         <span class="truncate">{formatDateTime(startedAt)}</span>
-                        <span class="shrink-0">· {formatTriggeredByLabel(run.triggered_by)}</span>
+                        <span class="shrink-0">· {formatTriggeredByLabel(run.triggeredBy)}</span>
                         {#if retry}
                             <span class="shrink-0 rounded bg-surface-sunken px-1 font-mono"
                                 >{retry}</span

package/src/lib/components/dashboard/run-filters.test.ts

@@ -47,7 +47,7 @@ describe("emptyRunFilters", () => {
     it("is a fully-open filter — no dimension active, newest-first", () => {
         const f = emptyRunFilters();
         expect(f.statuses).toEqual([]);
-        expect(f.sort_direction).toBe("desc");
+        expect(f.sortDirection).toBe("desc");
         expect(activeFilterCount(f)).toBe(0);
     });
 });
@@ -75,56 +75,54 @@ describe("isNeedsAttention", () => {
 describe("dimensionActive / activeDimensions", () => {
     it("detects each dimension independently", () => {
         expect(dimensionActive(base({ statuses: ["failed"] }), "status")).toBe(true);
-        expect(dimensionActive(base({ created_after: "2026-01-01T00:00:00Z" }), "time")).toBe(true);
-        expect(dimensionActive(base({ created_before: "2026-01-01T00:00:00Z" }), "time")).toBe(
-            true,
-        );
-        expect(dimensionActive(base({ task_name: "backup" }), "task")).toBe(true);
-        expect(dimensionActive(base({ triggered_by: "cron" }), "triggered_by")).toBe(true);
-        expect(dimensionActive(base({ exit_code: "137" }), "exit_code")).toBe(true);
-        expect(dimensionActive(base({ exit_code: ">100" }), "exit_code")).toBe(true);
-        expect(dimensionActive(base({ retries_only: true }), "retries")).toBe(true);
+        expect(dimensionActive(base({ createdAfter: "2026-01-01T00:00:00Z" }), "time")).toBe(true);
+        expect(dimensionActive(base({ createdBefore: "2026-01-01T00:00:00Z" }), "time")).toBe(true);
+        expect(dimensionActive(base({ taskName: "backup" }), "task")).toBe(true);
+        expect(dimensionActive(base({ triggeredBy: "cron" }), "triggeredBy")).toBe(true);
+        expect(dimensionActive(base({ exitCode: "137" }), "exitCode")).toBe(true);
+        expect(dimensionActive(base({ exitCode: ">100" }), "exitCode")).toBe(true);
+        expect(dimensionActive(base({ retriesOnly: true }), "retries")).toBe(true);
     });
 
     it("treats an exact exit code of 0 as active (distinct from absent)", () => {
-        expect(dimensionActive(base({ exit_code: "0" }), "exit_code")).toBe(true);
+        expect(dimensionActive(base({ exitCode: "0" }), "exitCode")).toBe(true);
     });
 
     it("treats an empty or unparseable exit-code expression as inactive", () => {
-        expect(dimensionActive(base({ exit_code: "" }), "exit_code")).toBe(false);
-        expect(dimensionActive(base({ exit_code: "nonsense" }), "exit_code")).toBe(false);
+        expect(dimensionActive(base({ exitCode: "" }), "exitCode")).toBe(false);
+        expect(dimensionActive(base({ exitCode: "nonsense" }), "exitCode")).toBe(false);
     });
 
     it("lists active dimensions in display (most→least useful) order", () => {
         const f = base({
-            retries_only: true,
+            retriesOnly: true,
             statuses: ["failed"],
-            triggered_by: "cron",
-            created_after: "2026-01-01T00:00:00Z",
+            triggeredBy: "cron",
+            createdAfter: "2026-01-01T00:00:00Z",
         });
-        expect(activeDimensions(f)).toEqual(["status", "time", "triggered_by", "retries"]);
+        expect(activeDimensions(f)).toEqual(["status", "time", "triggeredBy", "retries"]);
     });
 });
 
 describe("clearDimension", () => {
     it("resets one dimension and leaves the rest untouched", () => {
-        const f = base({ statuses: ["failed"], triggered_by: "cron", retries_only: true });
-        const cleared = clearDimension(f, "triggered_by");
-        expect(cleared.triggered_by).toBeUndefined();
+        const f = base({ statuses: ["failed"], triggeredBy: "cron", retriesOnly: true });
+        const cleared = clearDimension(f, "triggeredBy");
+        expect(cleared.triggeredBy).toBeUndefined();
         expect(cleared.statuses).toEqual(["failed"]);
-        expect(cleared.retries_only).toBe(true);
+        expect(cleared.retriesOnly).toBe(true);
     });
 
     it("clears the exit-code expression", () => {
-        const f = base({ exit_code: ">100 <150" });
-        expect(clearDimension(f, "exit_code").exit_code).toBeUndefined();
+        const f = base({ exitCode: ">100 <150" });
+        expect(clearDimension(f, "exitCode").exitCode).toBeUndefined();
     });
 
     it("clears both time bounds together", () => {
-        const f = base({ created_after: "2026-01-01T00:00:00Z", created_before: "2026-02-01" });
+        const f = base({ createdAfter: "2026-01-01T00:00:00Z", createdBefore: "2026-02-01" });
         const cleared = clearDimension(f, "time");
-        expect(cleared.created_after).toBeUndefined();
-        expect(cleared.created_before).toBeUndefined();
+        expect(cleared.createdAfter).toBeUndefined();
+        expect(cleared.createdBefore).toBeUndefined();
     });
 });
 
@@ -132,18 +130,18 @@ describe("clearPopoverFilters", () => {
     it("clears every popover dimension but keeps search and sort", () => {
         const f = base({
             search: "nightly",
-            sort_direction: "asc",
+            sortDirection: "asc",
             statuses: ["failed"],
-            task_name: "backup",
-            triggered_by: "cron",
-            exit_code: "1",
-            retries_only: true,
-            created_after: "2026-01-01T00:00:00Z",
+            taskName: "backup",
+            triggeredBy: "cron",
+            exitCode: "1",
+            retriesOnly: true,
+            createdAfter: "2026-01-01T00:00:00Z",
         });
         const cleared = clearPopoverFilters(f);
         expect(activeFilterCount(cleared)).toBe(0);
         expect(cleared.search).toBe("nightly");
-        expect(cleared.sort_direction).toBe("asc");
+        expect(cleared.sortDirection).toBe("asc");
     });
 });
 

package/src/lib/components/dashboard/run-filters.ts

@@ -8,7 +8,7 @@ export type RunsListSortDirection = "asc" | "desc" | "";
 /**
  * The single filter shape shared by the runs list, the filter popover, the
  * SSE-merge source, and the bulk selector. Every field beyond `search` and
- * `sort_direction` is an optional dimension applied server-side; the zero
+ * `sortDirection` is an optional dimension applied server-side; the zero
  * value (`emptyRunFilters`) matches every run.
  *
  * `statuses` is a multi-select set joined to a comma-separated string only at
@@ -19,26 +19,26 @@ export type RunsListSortDirection = "asc" | "desc" | "";
 export interface RunsListFilters {
     search: string;
     statuses: string[];
-    sort_direction: RunsListSortDirection;
+    sortDirection: RunsListSortDirection;
     // Optional dimensions explicitly admit `undefined` so a dimension can be
     // cleared by reassignment (`{ ...f, x: undefined }`) under the project's
     // exactOptionalPropertyTypes — a fresh object reference is what re-triggers
     // the parent's fetch effect through several levels of `bind:`.
-    task_name?: string | undefined;
-    created_after?: string | undefined;
-    created_before?: string | undefined;
-    triggered_by?: string | undefined;
+    taskName?: string | undefined;
+    createdAfter?: string | undefined;
+    createdBefore?: string | undefined;
+    triggeredBy?: string | undefined;
     // A human exit-code expression — a bare code (`137`), a comparison (`>100`,
     // `<=150`), or a space-separated combination (`>100 <150`). Normalized to an
     // inclusive [min, max] range (`exitCodeRange`) at the wire boundary; the
-    // server only ever sees `exit_code_min` / `exit_code_max`.
-    exit_code?: string | undefined;
-    retries_only?: boolean | undefined;
+    // server only ever sees `exitCodeMin` / `exitCodeMax`.
+    exitCode?: string | undefined;
+    retriesOnly?: boolean | undefined;
 }
 
 /** A fresh default filter — no dimensions active, newest-first. */
 export function emptyRunFilters(): RunsListFilters {
-    return { search: "", statuses: [], sort_direction: "desc" };
+    return { search: "", statuses: [], sortDirection: "desc" };
 }
 
 /**
@@ -131,14 +131,14 @@ function exactBucket(statuses: string[]): StatusBucket | undefined {
  * page the task name is the page scope (injected at fetch time), never a
  * popover-set filter, so it stays absent from those filters and is not counted.
  */
-export type FilterDimension = "status" | "time" | "task" | "triggered_by" | "exit_code" | "retries";
+export type FilterDimension = "status" | "time" | "task" | "triggeredBy" | "exitCode" | "retries";
 
 const DIMENSION_ORDER: FilterDimension[] = [
     "status",
     "time",
     "task",
-    "triggered_by",
-    "exit_code",
+    "triggeredBy",
+    "exitCode",
     "retries",
 ];
 
@@ -148,15 +148,15 @@ export function dimensionActive(f: RunsListFilters, dim: FilterDimension): boole
         case "status":
             return f.statuses.length > 0;
         case "time":
-            return Boolean(f.created_after) || Boolean(f.created_before);
+            return Boolean(f.createdAfter) || Boolean(f.createdBefore);
         case "task":
-            return Boolean(f.task_name);
-        case "triggered_by":
-            return Boolean(f.triggered_by);
-        case "exit_code":
-            return exitCodeRangeActive(f.exit_code);
+            return Boolean(f.taskName);
+        case "triggeredBy":
+            return Boolean(f.triggeredBy);
+        case "exitCode":
+            return exitCodeRangeActive(f.exitCode);
         case "retries":
-            return Boolean(f.retries_only);
+            return Boolean(f.retriesOnly);
     }
 }
 
@@ -176,15 +176,15 @@ export function clearDimension(f: RunsListFilters, dim: FilterDimension): RunsLi
         case "status":
             return { ...f, statuses: [] };
         case "time":
-            return { ...f, created_after: undefined, created_before: undefined };
+            return { ...f, createdAfter: undefined, createdBefore: undefined };
         case "task":
-            return { ...f, task_name: undefined };
-        case "triggered_by":
-            return { ...f, triggered_by: undefined };
-        case "exit_code":
-            return { ...f, exit_code: undefined };
+            return { ...f, taskName: undefined };
+        case "triggeredBy":
+            return { ...f, triggeredBy: undefined };
+        case "exitCode":
+            return { ...f, exitCode: undefined };
         case "retries":
-            return { ...f, retries_only: undefined };
+            return { ...f, retriesOnly: undefined };
     }
 }
 
@@ -196,12 +196,12 @@ export function clearPopoverFilters(f: RunsListFilters): RunsListFilters {
     return {
         ...f,
         statuses: [],
-        created_after: undefined,
-        created_before: undefined,
-        task_name: undefined,
-        triggered_by: undefined,
-        exit_code: undefined,
-        retries_only: undefined,
+        createdAfter: undefined,
+        createdBefore: undefined,
+        taskName: undefined,
+        triggeredBy: undefined,
+        exitCode: undefined,
+        retriesOnly: undefined,
     };
 }
 

package/src/lib/components/dashboard/run-helpers.test.ts

@@ -2,29 +2,54 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RUN_STATUSES } from "@runwisp/common";
 import {
     runDuration,
     runStartDelay,
+    runVerdict,
     formatTriggeredByLabel,
     runRetryLabel,
     instanceSuffix,
 } from "./run-helpers.js";
 
+describe("runVerdict", () => {
+    it("covers every run status", () => {
+        for (const status of RUN_STATUSES) {
+            expect(runVerdict(status).verb, status).toBeTruthy();
+        }
+    });
+
+    it("phrases a timed outcome so a duration reads after it", () => {
+        expect(runVerdict("success")).toEqual({ verb: "succeeded in", timed: true });
+        expect(runVerdict("failed")).toEqual({ verb: "failed after", timed: true });
+    });
+
+    it("marks statuses that never produced a duration as untimed", () => {
+        // These end without ever running, so the caller renders the verb alone
+        // rather than "skipped after —".
+        expect(runVerdict("missed").timed).toBe(false);
+        expect(runVerdict("skipped").timed).toBe(false);
+        expect(runVerdict("dst_skipped").timed).toBe(false);
+        expect(runVerdict("queue_full").timed).toBe(false);
+        expect(runVerdict("pending").timed).toBe(false);
+    });
+});
+
 describe("runDuration", () => {
-    it("returns undefined when start_at is not set", () => {
+    it("returns undefined when startAt is not set", () => {
         expect(runDuration({})).toBeUndefined();
     });
 
-    it("returns formatted duration when both start_at and end_at are set", () => {
+    it("returns formatted duration when both startAt and endAt are set", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:05.000Z";
-        expect(runDuration({ start_at: start, end_at: end })).toBe("5s");
+        expect(runDuration({ startAt: start, endAt: end })).toBe("5s");
     });
 
     it("returns ms duration for sub-second runs", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:00.500Z";
-        expect(runDuration({ start_at: start, end_at: end })).toBe("500ms");
+        expect(runDuration({ startAt: start, endAt: end })).toBe("500ms");
     });
 
     describe("with fake clock", () => {
@@ -36,35 +61,35 @@ describe("runDuration", () => {
             vi.useRealTimers();
         });
 
-        it("uses current time when end_at is not set (run still in progress)", () => {
-            expect(runDuration({ start_at: "2024-06-15T12:00:00.000Z" })).toBe("2s");
+        it("uses current time when endAt is not set (run still in progress)", () => {
+            expect(runDuration({ startAt: "2024-06-15T12:00:00.000Z" })).toBe("2s");
         });
     });
 
     it("counts against an injected now for an in-progress run", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const now = new Date("2024-06-15T12:00:07.000Z").getTime();
-        expect(runDuration({ start_at: start }, now)).toBe("7s");
+        expect(runDuration({ startAt: start }, now)).toBe("7s");
     });
 
     it("ignores the injected now once the run has ended", () => {
         const start = "2024-06-15T12:00:00.000Z";
         const end = "2024-06-15T12:00:05.000Z";
         const now = new Date("2024-06-15T12:01:00.000Z").getTime();
-        expect(runDuration({ start_at: start, end_at: end }, now)).toBe("5s");
+        expect(runDuration({ startAt: start, endAt: end }, now)).toBe("5s");
     });
 });
 
 describe("runStartDelay", () => {
-    it("returns undefined when start_at is not set", () => {
-        expect(runStartDelay({ created_at: "2024-06-15T12:00:00.000Z" })).toBeUndefined();
+    it("returns undefined when startAt is not set", () => {
+        expect(runStartDelay({ createdAt: "2024-06-15T12:00:00.000Z" })).toBeUndefined();
     });
 
     it("returns undefined when the run started within a second of its tick", () => {
         expect(
             runStartDelay({
-                created_at: "2024-06-15T12:00:00.000Z",
-                start_at: "2024-06-15T12:00:00.300Z",
+                createdAt: "2024-06-15T12:00:00.000Z",
+                startAt: "2024-06-15T12:00:00.300Z",
             }),
         ).toBeUndefined();
     });
@@ -72,8 +97,8 @@ describe("runStartDelay", () => {
     it("formats the jitter/queue gap when the run started meaningfully later", () => {
         expect(
             runStartDelay({
-                created_at: "2024-06-15T03:00:00.000Z",
-                start_at: "2024-06-15T03:07:12.000Z",
+                createdAt: "2024-06-15T03:00:00.000Z",
+                startAt: "2024-06-15T03:07:12.000Z",
             }),
         ).toBe("7m 12s");
     });
@@ -91,15 +116,15 @@ describe("formatTriggeredByLabel", () => {
 
 describe("runRetryLabel", () => {
     it("returns undefined for a first attempt that is not a retry", () => {
-        expect(runRetryLabel({ retry_attempt: 0 })).toBeUndefined();
+        expect(runRetryLabel({ retryAttempt: 0 })).toBeUndefined();
     });
 
     it("labels a run with a positive attempt number", () => {
-        expect(runRetryLabel({ retry_attempt: 2 })).toBe("retry #2");
+        expect(runRetryLabel({ retryAttempt: 2 })).toBe("retry #2");
     });
 
     it("labels a run that points back at the run it re-attempts", () => {
-        expect(runRetryLabel({ retry_attempt: 1, retry_of_run_id: "01JABC" })).toBe("retry #1");
+        expect(runRetryLabel({ retryAttempt: 1, retryOfRunId: "01JABC" })).toBe("retry #1");
     });
 });
 

package/src/lib/components/dashboard/run-helpers.ts

@@ -1,30 +1,68 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Run } from "@runwisp/common";
+import type { Run, RunStatus } from "@runwisp/common";
 import { formatDuration } from "../../utils/format.js";
 
+export interface RunVerdict {
+    /** Verb phrase for the outcome, ending in its preposition when `timed`. */
+    verb: string;
+    /**
+     * Whether the phrase expects a duration after it. False for statuses that
+     * never produced one (nothing ran, or nothing has yet), so the caller
+     * renders the verb alone rather than "skipped after —".
+     */
+    timed: boolean;
+}
+
+/**
+ * The run's outcome as a verb phrase, so a detail view can state it as one
+ * sentence ("succeeded in 933ms") instead of a status badge competing with a
+ * separate duration readout for the same glance.
+ */
+const RUN_VERDICTS: Record<RunStatus, RunVerdict> = {
+    success: { verb: "succeeded in", timed: true },
+    failed: { verb: "failed after", timed: true },
+    crashed: { verb: "crashed after", timed: true },
+    timeout: { verb: "timed out after", timed: true },
+    stopped: { verb: "stopped after", timed: true },
+    daemon_stopped: { verb: "cut short after", timed: true },
+    log_overflow: { verb: "killed after", timed: true },
+    start_failed: { verb: "gave up after", timed: true },
+    ended: { verb: "ended after", timed: true },
+    running: { verb: "running for", timed: true },
+    pending: { verb: "queued", timed: false },
+    missed: { verb: "never ran", timed: false },
+    skipped: { verb: "skipped", timed: false },
+    dst_skipped: { verb: "skipped", timed: false },
+    queue_full: { verb: "skipped", timed: false },
+};
+
+export function runVerdict(status: RunStatus): RunVerdict {
+    return RUN_VERDICTS[status];
+}
+
 export function runDuration(
-    run: Pick<Run, "start_at" | "end_at">,
+    run: Pick<Run, "startAt" | "endAt">,
     now: number = Date.now(),
 ): string | undefined {
-    if (!run.start_at) return undefined;
-    const start = new Date(run.start_at).getTime();
-    const end = run.end_at ? new Date(run.end_at).getTime() : now;
+    if (!run.startAt) return undefined;
+    const start = new Date(run.startAt).getTime();
+    const end = run.endAt ? new Date(run.endAt).getTime() : now;
     return formatDuration(end - start);
 }
 
 /**
- * Gap between when a run was scheduled (`created_at`, the cron tick) and when
- * it actually started (`start_at`), formatted — or undefined when the two are
+ * Gap between when a run was scheduled (`createdAt`, the cron tick) and when
+ * it actually started (`startAt`), formatted — or undefined when the two are
  * within a second of each other. This is the visible face of `jitter`: a
  * jittered run is created at its tick but starts later inside the window, and
  * this is by how much. It also surfaces queue-wait, since a queued run is
  * created when it joins the line and started when the line clears.
  */
-export function runStartDelay(run: Pick<Run, "created_at" | "start_at">): string | undefined {
-    if (!run.start_at) return undefined;
-    const delay = new Date(run.start_at).getTime() - new Date(run.created_at).getTime();
+export function runStartDelay(run: Pick<Run, "createdAt" | "startAt">): string | undefined {
+    if (!run.startAt) return undefined;
+    const delay = new Date(run.startAt).getTime() - new Date(run.createdAt).getTime();
     if (delay < 1000) return undefined;
     return formatDuration(delay);
 }
@@ -44,8 +82,8 @@ export function instanceSuffix(instanceIndex: number, instanceCount: number): st
     return "";
 }
 
-/** Human label for why a run fired (the `triggered_by` source). */
-export function formatTriggeredByLabel(triggeredBy: Run["triggered_by"]): string {
+/** Human label for why a run fired (the `triggeredBy` source). */
+export function formatTriggeredByLabel(triggeredBy: Run["triggeredBy"]): string {
     if (triggeredBy === "api") return "API";
     if (triggeredBy === "cron") return "Cron";
     if (triggeredBy === "service") return "Service";
@@ -58,11 +96,9 @@ export function formatTriggeredByLabel(triggeredBy: Run["triggered_by"]): string
  * A run is a retry if it carries a positive attempt number or points back at
  * the run it re-attempts.
  */
-export function runRetryLabel(
-    run: Pick<Run, "retry_attempt" | "retry_of_run_id">,
-): string | undefined {
-    if (run.retry_attempt > 0 || run.retry_of_run_id) {
-        return `retry #${String(run.retry_attempt)}`;
+export function runRetryLabel(run: Pick<Run, "retryAttempt" | "retryOfRunId">): string | undefined {
+    if (run.retryAttempt > 0 || run.retryOfRunId) {
+        return `retry #${String(run.retryAttempt)}`;
     }
     return undefined;
 }