fix(activity): runs keep their true outcome and spend, the page reaches every kept row, a closing dialog leaves the server log alone

Backend
- A run's outcome write sits outside the job's own try: a database blip after a run that
  succeeded no longer records it as failed (the row waits for the next start's sweep).
- An interrupted run keeps what it spent (the sweep sums its quota rows, as finish does).
- The Scheduler's ad-hoc row says running while any backfill runs, not only the newest.
- recent_runs reads each job's last runs off its index instead of ranking the whole table.
- An interval change is stored with its audit row in one transaction, then rescheduled.
- One API instance per database is the stated contract (.env.example, jobruns).
- Turning full history on for a channel already complete records no run.
- Migration 0109 round-trips interrupted and ad-hoc runs; the run words' DB CHECKs are
  test-held to the enums; the account filter is one helper for the four activity reads.
- An audit row says how many of its request's log lines are still kept.

Frontend
- An "All" period reaches every row still kept (runs and admin actions outlive 90 days).
- Back/Forward is followed in place by the server log: a closing dialog no longer turns
  Live off; a pivot still opens a fresh log.
- Runs moved over from the audit log read their one-liner in the reader's language.
- Filter choices or accounts that failed to load say so beside the filters, with a retry.
- An old server-log link keeps its account, text and range; a remembered retired page
  opens its tab.
- A request whose lines are gone says so instead of linking to an empty list.
- The log lines and the history rows share one row frame, and the server log one list
  frame with the other tabs; an empty list is announced; each day's quota is readable.

frontend/src/lib/activityUrlState.test.ts

@@ -9,6 +9,7 @@ import {
   activityParamUpdates,
   DEFAULT_ACTIVITY_STATE,
   sinceOf,
+  ACTIVITY_WINDOWS,
   type ActivityUrlState,
 } from "./activityUrlState";
 
@@ -54,4 +55,11 @@ describe("activityUrlState", () => {
     expect(sinceOf("24h", now)).toBe("2026-10-17T12:00:00.000Z");
     expect(sinceOf("90d", now)).toBe("2026-07-20T12:00:00.000Z");
   });
+
+  it("offers everything kept, past the longest range", () => {
+    // Runs and admin actions are kept 180 days by default, or for ever: a 90-day cap hid the rest.
+    expect(ACTIVITY_WINDOWS[ACTIVITY_WINDOWS.length - 1]).toBe("all");
+    expect(activityParamsToState(new URLSearchParams("aw=all")).window).toBe("all");
+    expect(sinceOf("all")).toBe("1970-01-01T00:00:00.000Z");
+  });
 });

frontend/src/lib/activityUrlState.ts

@@ -3,12 +3,13 @@
 // each tab's own (the run list's job and status, the audit list's action). The server log's own
 // filters keep their `l…` keys (./logsUrlState). setPage clears all of them (ACTIVITY_KEYS); the page
 // re-mirrors them while it is open.
+import type { RunStatus } from "./api";
 import { LOGS_KEYS } from "./logsUrlState";
 
 export type ActivityTab = "runs" | "admin" | "logs" | "quota";
-export type ActivityWindow = "1h" | "24h" | "7d" | "30d" | "90d";
-/** The run statuses the list can narrow to (the API's `RunStatus`). */
-export type RunStatusFilter = "running" | "ok" | "error" | "skipped" | "interrupted";
+export type ActivityWindow = "1h" | "24h" | "7d" | "30d" | "90d" | "all";
+/** The run statuses the list can narrow to: the API's `RunStatus` (held by backendIds.contract.test). */
+export type RunStatusFilter = RunStatus;
 
 export interface ActivityUrlState {
   tab: ActivityTab;
@@ -24,7 +25,9 @@ export interface ActivityUrlState {
 }
 
 export const ACTIVITY_TABS: readonly ActivityTab[] = ["runs", "admin", "logs", "quota"];
-export const ACTIVITY_WINDOWS: readonly ActivityWindow[] = ["1h", "24h", "7d", "30d", "90d"];
+// `all` = everything still kept: runs and admin actions are kept 180 days by default (0 = for ever),
+// longer than any fixed range.
+export const ACTIVITY_WINDOWS: readonly ActivityWindow[] = ["1h", "24h", "7d", "30d", "90d", "all"];
 export const RUN_STATUSES: readonly RunStatusFilter[] = [
   "error",
   "interrupted",
@@ -33,12 +36,13 @@ export const RUN_STATUSES: readonly RunStatusFilter[] = [
   "ok",
 ];
 
-const WINDOW_HOURS: Record<ActivityWindow, number> = {
+const WINDOW_HOURS: Record<ActivityWindow, number | null> = {
   "1h": 1,
   "24h": 24,
   "7d": 24 * 7,
   "30d": 24 * 30,
   "90d": 24 * 90,
+  all: null,
 };
 
 export const DEFAULT_ACTIVITY_STATE: ActivityUrlState = {
@@ -92,7 +96,9 @@ export function activityParamUpdates(state: ActivityUrlState): Record<string, st
   };
 }
 
-/** Where the window starts, as the API takes it. */
+/** Where the window starts, as the API takes it: `all` from the epoch (the quota read would default
+ *  to its last 30 days without one). */
 export function sinceOf(window: ActivityWindow, now = Date.now()): string {
-  return new Date(now - WINDOW_HOURS[window] * 3_600_000).toISOString();
+  const hours = WINDOW_HOURS[window];
+  return new Date(hours === null ? 0 : now - hours * 3_600_000).toISOString();
 }

frontend/src/lib/api/admin.ts

@@ -105,6 +105,8 @@ export interface AuditRow {
   after: Record<string, unknown> | null;
   /** The request the change was made in — its log lines are one pivot away. Null on older rows. */
   request_id: string | null;
+  /** How many of that request's log lines are still kept (they go after days, the row after months). */
+  log_lines: number;
 }
 
 /** A page of a history list (audit log, runs), newest first; `next_cursor` continues it. */
@@ -142,7 +144,8 @@ export interface RunRow {
   summary: string | null;
   result: JobResult | null;
   error: string | null;
-  failure: { code: string; [key: string]: unknown } | null;
+  /** A failure the job named (`progress.JobFailed`): its reason, and the values it is said with. */
+  failure: { failure: string; [key: string]: unknown } | null;
   quota_units: number;
   /** How many stored log lines the run left (WARNING and up only). */
   log_lines: number;
@@ -249,8 +252,10 @@ function queryString(values: object): string {
 export type JobResult = { [key: string]: number | string | JobResult };
 
 /** How a run ended — the server's `RunStatus` (app/runstatus.py) minus `running`. `interrupted`:
- *  the process stopped mid-run (a deploy, a crash), and its next start closed the row. */
+ *  the process stopped mid-run (a deploy, a crash), and its next start closed the row. The values are
+ *  held to the server's by backendIds.contract.test (through RUN_STATUSES, typed as `RunStatus`). */
 export type RunOutcome = "ok" | "error" | "skipped" | "interrupted";
+export type RunStatus = RunOutcome | "running";
 
 /** One past run, as the row's history dots show it. */
 export interface RunBrief {

frontend/src/lib/auditText.dom.test.ts

@@ -25,6 +25,7 @@ const row = (over: Partial<AuditRow>): AuditRow => ({
   before: null,
   after: null,
   request_id: null,
+  log_lines: 0,
   ...over,
 });
 

frontend/src/lib/navRing.contract.test.ts

@@ -37,9 +37,10 @@ it("index.css draws an inset item's ring inside, after the outside rule", () =>
 
 // The items that sit flush, by their source: a new one of the kind should be added here.
 const src = (p: string) => readFileSync(new URL(p, import.meta.url), "utf8");
-it.each([["../components/LogLine.tsx", /navItemAttrs\(navIndex, [^)]*\{ inset: true \}\)/]])(
-  "%s asks for the inside ring",
-  (file, re) => {
-    expect(src(file)).toMatch(re);
-  },
-);
+// The history rows (runs, admin actions) and the log lines share one frame, HistoryRow.
+it.each([
+  ["../components/HistoryRow.tsx", /navItemAttrs\(navIndex, [^)]*\{ inset: true \}\)/],
+  ["../components/LogLine.tsx", /<HistoryRow\s/],
+])("%s asks for the inside ring", (file, re) => {
+  expect(src(file)).toMatch(re);
+});

frontend/src/lib/queryKeys.ts

@@ -87,8 +87,12 @@ export const qk = {
   adminInvites: () => ["admin-invites"] as const,
   adminPendingAccess: () => ["admin-pending-access"] as const,
   adminConfig: () => ["admin-config"] as const,
-  adminAudit: (filters: object) => ["admin-audit", filters] as const,
-  adminAuditFacets: (filters: object) => ["admin-audit-facets", filters] as const,
+  adminAudit: (filters?: object) =>
+    filters !== undefined ? (["admin-audit", filters] as const) : (["admin-audit"] as const),
+  adminAuditFacets: (filters?: object) =>
+    filters !== undefined
+      ? (["admin-audit-facets", filters] as const)
+      : (["admin-audit-facets"] as const),
   adminRuns: (filters: object) => ["admin-runs", filters] as const,
   adminRunFacets: (filters: object) => ["admin-run-facets", filters] as const,
   // The console's filters are part of the key; `since` is not (it moves with the clock) — the

frontend/src/lib/urlState.ts

@@ -142,15 +142,32 @@ function isPage(p: string | null | undefined): p is Page {
 }
 
 // A page this build no longer has, the page that took its place, and the params that open its part
-// of that page. A bookmark, the remembered last page and an old history entry can still name one; all
-// three resolve through `resolvePage`, so a retired page lands where its content went instead of on
-// the feed, and the navigation provider writes `params` into the address bar as it rewrites the page.
-const RETIRED: Readonly<Record<string, { page: Page; params?: Record<string, string> }>> = {
+// of that page — from the old link's own params. A bookmark, the remembered last page and an old
+// history entry can still name one; all three resolve through `resolvePage`, so a retired page lands
+// where its content went instead of on the feed, and the navigation provider writes `params` into the
+// address bar as it rewrites the page (a null clears a key the old page owned).
+type Updates = Record<string, string | null>;
+const RETIRED: Readonly<
+  Record<string, { page: Page; params?: (old: URLSearchParams) => Updates }>
+> = {
   // The download queue became the tray; what it downloaded lives in Files.
   downloads: { page: "files" },
   // The audit log and the server log became tabs of the activity page (its `at` key).
-  audit: { page: "activity", params: { at: "admin" } },
-  logs: { page: "activity", params: { at: "logs" } },
+  audit: { page: "activity", params: () => ({ at: "admin" }) },
+  // The server log's own account, text and range became the page's shared filters; a link without
+  // a range meant the log's default then, 24 hours.
+  logs: {
+    page: "activity",
+    params: (old) => ({
+      at: "logs",
+      au: old.get("lu"),
+      aq: old.get("lq"),
+      aw: old.get("lwin") ?? "24h",
+      lu: null,
+      lq: null,
+      lwin: null,
+    }),
+  },
 };
 
 const retired = (p: string | null | undefined) =>
@@ -162,9 +179,13 @@ export function resolvePage(p: string | null | undefined): Page | null {
   return retired(p)?.page ?? null;
 }
 
-/** The params that open a retired page's part of its successor (none for a live page). */
-export function retiredParams(p: string | null | undefined): Record<string, string> {
-  return isPage(p) ? {} : (retired(p)?.params ?? {});
+/** The params that open a retired page's part of its successor, read from the old link's `params`
+ *  (none for a live page). */
+export function retiredParams(
+  p: string | null | undefined,
+  params = new URLSearchParams(window.location.search),
+): Updates {
+  return isPage(p) ? {} : (retired(p)?.params?.(params) ?? {});
 }
 
 export function readPage(): Page {