feat(activity): one Activity page — runs, admin actions, server log and quota under one filter bar

The audit log, the server log and the admin quota view were three pages (the quota one a Stats tab),
each with its own filters, and the background runs had no list at all. Now one page ("Napló" /
"Activity") reads all four, each still its own table on the server: a shared bar (text, a period of
1 h to 90 days defaulting to 7, an account) and each tab's own filters, the whole view in the URL.
The old page ids open their tab.

Server side: the audit log and the new run list (`/api/admin/runs`) filter and page like the server
log, through one keyset helper (`routes/_keyset`) the log now shares; an audit row keeps the request
it was made in (migration 0111), so its log lines are a pivot away, as a run's are (`lrun`). The
quota breakdown takes since/until and one account. The Scheduler rows get a history button to their
job's runs.

Also fixed on the way: re-saving the value in force on the Configuration page staged its override
without committing it (the commit sat inside the audit branch), so the save was lost.

frontend/src/lib/auditText.ts

@@ -0,0 +1,99 @@
+import type { TFunction } from "i18next";
+import type { AuditRow, JobResult } from "./api";
+import { formatNumber } from "./format";
+import { jobResultText } from "./jobResult";
+
+function fmt(v: unknown): string {
+  return v == null || v === "" ? "—" : String(v);
+}
+
+/** A logged config value in the reader's language: a switch reads on/off, a count is grouped, a
+ *  choice is named as the Configuration page names it. */
+function configValue(t: TFunction, key: string, v: unknown, lang: string): string {
+  if (typeof v === "boolean") return t(v ? "audit.on" : "audit.off");
+  if (typeof v === "number") return formatNumber(v, lang);
+  if (typeof v === "string" && v) return t(`config.choices.${key}.${v}`, { defaultValue: v });
+  return fmt(v);
+}
+
+/** A row's `after` as a job-style result (counts), or null when it holds none. */
+function counts(after: Record<string, unknown>): JobResult | null {
+  const out: JobResult = {};
+  for (const [k, v] of Object.entries(after)) if (typeof v === "number") out[k] = v;
+  return Object.keys(out).length ? out : null;
+}
+
+/** The details of the rows whose server `summary` is a fixed English line, rebuilt from the row's
+ *  data in the reader's language: a config change names the field and its values, an interval or batch change its new value, a count-bearing
+ *  action its counts; a pause/resume says nothing the action has not. `undefined` = not one of these (or
+ *  an older row without the data); the generic summary + change rendering applies. */
+function localDetails(
+  t: TFunction,
+  row: AuditRow,
+  lang: string,
+): { head: string | null; sub: string | null } | undefined {
+  const after = row.after ?? {};
+  const before = row.before ?? {};
+  if ((row.action === "config_set" || row.action === "config_reset") && row.target_id) {
+    const key = row.target_id;
+    const head = t(`config.fields.${key}.label`, key);
+    const reset = row.action === "config_reset";
+    // A secret's value is never logged: there is no before/after to show.
+    if (!row.before && !row.after)
+      return { head, sub: t(reset ? "audit.secretReset" : "audit.secretUpdated") };
+    const to = reset ? t("audit.default") : configValue(t, key, after.value, lang);
+    return { head, sub: `${configValue(t, key, before.value, lang)} → ${to}` };
+  }
+  if (
+    row.action === "scheduler_interval" &&
+    row.target_id &&
+    typeof after.interval_minutes === "number"
+  )
+    return {
+      head: t(`scheduler.jobs.${row.target_id}`, row.target_id),
+      sub: t("scheduler.everyMin", { count: after.interval_minutes }),
+    };
+  if (row.action === "maintenance_tune" && typeof after.revalidate_batch === "number")
+    return {
+      head: t("scheduler.maintenance.batchLabel"),
+      sub: formatNumber(after.revalidate_batch, lang),
+    };
+  if (row.action === "audit_clear" || row.action === "discovery_purge") {
+    const result = counts(after);
+    return result ? { head: null, sub: jobResultText(t, result, lang) } : undefined;
+  }
+  if (row.action === "sync_pause" || row.action === "sync_resume") return { head: null, sub: null };
+  return undefined;
+}
+
+/** A compact before→after (or after-only) rendering of the JSON snapshots, e.g. "role: user → admin". */
+function changeText(row: AuditRow): string | null {
+  const { before, after } = row;
+  if (before && after) {
+    return Object.keys(after)
+      .map((k) => `${k}: ${fmt(before[k])} → ${fmt(after[k])}`)
+      .join(", ");
+  }
+  if (after) {
+    return Object.entries(after)
+      .map(([k, v]) => `${k}: ${fmt(v)}`)
+      .join(", ");
+  }
+  return null;
+}
+
+/** An audit row in the reader's language: `head` names what changed (a config field, a job; else
+ *  the server's summary), `sub` the change itself (before → after, a count). Either may be null. */
+export function auditText(
+  t: TFunction,
+  row: AuditRow,
+  lang: string,
+): { head: string | null; sub: string | null } {
+  const local = localDetails(t, row, lang);
+  return local ?? { head: row.summary, sub: changeText(row) };
+}
+
+export function auditActionLabel(t: TFunction, action: string): string {
+  // Canonical key → localized label; falls back to the raw key for any unmapped action.
+  return t(`auditActions.${action}`, action);
+}