@cosmicdrift/kumiko-bundled-features 0.239.0 → 0.241.0

package/src/audit/i18n.ts

@@ -1,5 +1,5 @@
 // @runtime client
-// Server + client i18n for audit (nav labels + AuditLogScreen).
+// Server + client i18n for audit (nav labels + audit-log/-detail screens).
 
 type LocalizedString = { readonly en: string };
 
@@ -7,27 +7,12 @@ export const AUDIT_I18N: Readonly<Record<string, LocalizedString>> = {
   "screen:audit-log.title": { en: "Audit log" },
   "screen:audit-log-detail.title": { en: "Event" },
   "audit:nav.auditLog": { en: "Audit" },
-  "audit.log.title": { en: "Audit log" },
-  "audit.log.loading": { en: "Loading events…" },
-  "audit.log.empty": { en: "No events." },
-  "audit.log.newest": { en: "Newest" },
-  "audit.log.older": { en: "Load older" },
   "audit.log.col.when": { en: "When" },
   "audit.log.col.type": { en: "Event" },
-  "audit.log.col.aggregate": { en: "Aggregate" },
+  "audit.log.col.aggregateType": { en: "Aggregate type" },
+  "audit.log.col.aggregateId": { en: "Aggregate ID" },
   "audit.log.col.actor": { en: "Actor" },
-  "audit.log.actor.system": { en: "System" },
-  "audit.log.actor.anonymous": { en: "Anonymous" },
-  "audit.log.actor.unknown": { en: "Unknown actor" },
-  "audit.log.filter.eventType": { en: "Event type" },
-  "audit.log.filter.aggregateType": { en: "Aggregate type" },
-  "audit.log.filter.from": { en: "From" },
-  "audit.log.filter.to": { en: "To" },
-  "audit.log.filter.apply": { en: "Filter" },
-  "audit.log.filter.reset": { en: "Reset" },
   "audit.log.details": { en: "Details" },
-  "audit.log.detail.loading": { en: "Loading event…" },
-  "audit.log.detail.missing": { en: "Event not found." },
   "audit.log.detail.payload": { en: "Event payload" },
   "audit.log.detail.metadata": { en: "Metadata" },
   "audit.log.detail.field.id": { en: "Event ID" },

package/src/audit/web/client-plugin.tsx

@@ -1,9 +1,7 @@
 // @runtime client
 import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
 import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
-import { AUDIT_FEATURE, AUDIT_LOG_DETAIL_SCREEN_ID, AUDIT_LOG_SCREEN_ID } from "../constants";
-import { AuditLogDetailScreen } from "./audit-log-detail-screen";
-import { AuditLogScreen } from "./audit-log-screen";
+import { AUDIT_FEATURE } from "../constants";
 import { defaultTranslations } from "./i18n";
 
 export type AuditClientOptions = {
@@ -14,9 +12,5 @@ export function auditClient(options?: AuditClientOptions): ClientFeatureDefiniti
   return {
     name: AUDIT_FEATURE,
     translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
-    components: {
-      [AUDIT_LOG_SCREEN_ID]: AuditLogScreen,
-      [AUDIT_LOG_DETAIL_SCREEN_ID]: AuditLogDetailScreen,
-    },
   };
 }

package/src/audit/web/index.ts

@@ -1,5 +1,3 @@
 // @runtime client
 
-export { AuditLogDetailScreen } from "./audit-log-detail-screen";
-export { AuditLogScreen } from "./audit-log-screen";
 export { type AuditClientOptions, auditClient } from "./client-plugin";

package/src/auth-mfa/web/mfa-enable-screen.tsx

@@ -220,9 +220,5 @@ export function MfaEnableScreen({
   );
 
   if (embedded) return content;
-  return (
-    <FormScreenShell testId="mfa-enable-screen" maxWidth="3xl">
-      {content}
-    </FormScreenShell>
-  );
+  return <FormScreenShell testId="mfa-enable-screen">{content}</FormScreenShell>;
 }

package/src/config/__tests__/config.integration.test.ts

@@ -939,6 +939,37 @@ describe("config.readiness query handler", () => {
     expect(keys).not.toContain("orders:config:max-order-count");
   });
 
+  type MissingWithSummary = Missing & { missingCount: number; missingTone: "default" | "warn" };
+
+  test("missingCount matches missing.length and missingTone is warn while something is missing (fw#2312)", async () => {
+    const result = await stack.http.queryOk<MissingWithSummary>(
+      ConfigQueries.readiness,
+      {},
+      readinessAdminFor(6),
+    );
+
+    expect(result.missingCount).toBe(result.missing.length);
+    expect(result.missingCount).toBeGreaterThan(0);
+    expect(result.missingTone).toBe("warn");
+  });
+
+  test("missingCount is 0 and missingTone is default once every required key is set (fw#2312)", async () => {
+    const admin = readinessAdminFor(7);
+    for (const [key, value] of [
+      ["transport:config:smtp-host", "smtp.example.com"],
+      ["transport:config:api-url", "https://api.example.com"],
+      ["transport:config:webhook-url", "https://webhook.example.com"],
+      ["transport:config:timeout", 30],
+    ] as const) {
+      await stack.http.writeOk(ConfigHandlers.set, { key, value }, admin);
+    }
+
+    const result = await stack.http.queryOk<MissingWithSummary>(ConfigQueries.readiness, {}, admin);
+    expect(result.missing).toEqual([]);
+    expect(result.missingCount).toBe(0);
+    expect(result.missingTone).toBe("default");
+  });
+
   test("whitespace-only text value still counts as missing (requireNonEmpty-Parität)", async () => {
     const admin = readinessAdminFor(2);
     await stack.http.writeOk(

package/src/config/handlers/readiness.query.ts

@@ -140,6 +140,13 @@ export const readinessQuery = defineQueryHandler({
       query.user,
       db,
     );
-    return { missing };
+    // Additive, display-ready fields for the admin-shell dashboard stat
+    // panel (fw#2312) — `missing` itself stays untouched for existing
+    // consumers that read the array directly.
+    return {
+      missing,
+      missingCount: missing.length,
+      missingTone: missing.length > 0 ? "warn" : "default",
+    };
   },
 });

package/src/jobs/__tests__/jobs-screens.boot.test.ts

@@ -16,9 +16,14 @@ describe("jobs screens + handler access alignment", () => {
 
   test("job-runs screens are SystemAdmin-gated", () => {
     const jobs = createJobsFeature();
-    for (const id of [JOB_RUNS_SCREEN_ID, JOB_RUN_DETAIL_SCREEN_ID] as const) {
+    const expectedTypeById = {
+      [JOB_RUNS_SCREEN_ID]: "projectionList",
+      [JOB_RUN_DETAIL_SCREEN_ID]: "projectionDetail",
+      "job-trigger": "actionForm",
+    } as const;
+    for (const id of Object.keys(expectedTypeById) as (keyof typeof expectedTypeById)[]) {
       const screen = jobs.screens[id];
-      expect(screen?.type).toBe("custom");
+      expect(screen?.type).toBe(expectedTypeById[id]);
       if (screen && "access" in screen && screen.access && "roles" in screen.access) {
         expect(screen.access.roles).toEqual(SYSTEM_ADMIN_ROLES);
       }

package/src/jobs/__tests__/jobs-security.integration.test.ts

@@ -2,7 +2,12 @@
 // Real HTTP via setupTestStack — no mocks.
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { defineFeature, type SessionUser } from "@cosmicdrift/kumiko-framework/engine";
+import { sql } from "@cosmicdrift/kumiko-framework/db";
+import {
+  defineFeature,
+  type SessionUser,
+  SYSTEM_TENANT_ID,
+} from "@cosmicdrift/kumiko-framework/engine";
 import {
   createTestUser,
   setupTestStack,
@@ -10,7 +15,7 @@ import {
   TestUsers,
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
-import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { rolesOf, seedRow } from "@cosmicdrift/kumiko-framework/testing";
 import { createConfigFeature } from "../../config/feature";
 import {
   JOB_RUN_DETAIL_SCREEN_ID,
@@ -108,3 +113,37 @@ describe("SystemAdmin can use jobs queries", () => {
     expect(Array.isArray(res.rows)).toBe(true);
   });
 });
+
+describe("jobs:query:list totalCount (fw#2312)", () => {
+  test("without totalCount the shape carries no total field", async () => {
+    const res = await stack.http.queryOk<{ rows: readonly unknown[]; total?: number }>(
+      JobQueries.list,
+      { jobName: "jobs-sec-app:job:total-count-shape" },
+      systemAdmin,
+    );
+    expect(res.total).toBeUndefined();
+  });
+
+  test("total reflects the full match count, not capped by limit", async () => {
+    const jobName = "jobs-sec-app:job:total-count-probe";
+    for (let i = 0; i < 6; i++) {
+      await seedRow(stack.db, jobRunsTable, {
+        id: crypto.randomUUID(),
+        tenantId: SYSTEM_TENANT_ID,
+        jobName,
+        bullJobId: `total-count-${i}`,
+        status: "completed",
+        attempt: 1,
+        startedAt: sql`now()`,
+      });
+    }
+
+    const res = await stack.http.queryOk<{ rows: readonly unknown[]; total?: number }>(
+      JobQueries.list,
+      { jobName, limit: 2, totalCount: true },
+      systemAdmin,
+    );
+    expect(res.rows.length).toBe(2);
+    expect(res.total).toBe(6);
+  });
+});

package/src/jobs/changes.json

@@ -1,4 +1,11 @@
 [
+  {
+    "version": "0.241.0",
+    "type": "breaking",
+    "title": "JobRunsScreen and JobRunDetailScreen removed; job-runs/job-run-detail are now declarative screens (fw#2312).",
+    "detail": "`job-runs`/`job-run-detail` render through the generic renderer (`projectionList`/`projectionDetail`) instead of custom React components — the renderer selects a screen by its `screen.type`, not a client component registry, so `JobRunsScreen`/`JobRunDetailScreen` were dead exports the moment the screen definitions switched. Job triggering moved from an inline control on the old custom screen to a new `job-trigger` `actionForm`, opened via a `kind: \"drawer\"` `toolbarAction` on `job-runs`. `job-run-detail`'s `logs` field now uses the `format: \"json\"` field-renderer (see framework changelog) instead of a raw escaped-string dump.",
+    "migration": "Breaking only if you imported these components directly (no shipped consumer app did). Remove `import { JobRunsScreen, JobRunDetailScreen } from \"@cosmicdrift/kumiko-bundled-features/jobs/web\"` and any `components: { JobRunsScreen: ..., JobRunDetailScreen: ... }` entry in your `jobsClient()`/renderer setup — the bundled feature registers its own `job-runs`/`job-run-detail`/`job-trigger` screens now, nothing left for an app to wire."
+  },
   {
     "version": "0.120.0",
     "type": "improvement",

package/src/jobs/feature.ts

@@ -1,5 +1,5 @@
 import { defineFeature, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
-import { JOB_RUN_DETAIL_SCREEN_ID, JOB_RUNS_SCREEN_ID } from "./constants";
+import { JOB_RUN_DETAIL_SCREEN_ID, JOB_RUNS_SCREEN_ID, JobHandlers, JobQueries } from "./constants";
 import { catalogQuery } from "./handlers/catalog.query";
 import { detailQuery } from "./handlers/detail.query";
 import { listQuery } from "./handlers/list.query";
@@ -109,20 +109,112 @@ export function createJobsFeature(options: JobsFeatureOptions = {}): FeatureDefi
 
     r.translations({ keys: JOBS_I18N });
 
-    // kumiko-lint-ignore app-feature-structure Phase-3 conversion tracked in #2312
     r.screen({
       id: JOB_RUNS_SCREEN_ID,
-      type: "custom",
-      renderer: { react: { __component: "JobRunsScreen" } },
-      description:
-        "Operator table of recent job runs with status filters, plus a panel to trigger a manual job with a payload; open it to monitor background jobs and start one.",
+      type: "projectionList",
+      query: JobQueries.list,
+      columns: [
+        { field: "jobName", label: "jobs.runs.col.job" },
+        { field: "status", label: "jobs.runs.col.status" },
+        { field: "startedAt", label: "jobs.runs.col.started", renderer: { format: "timestamp" } },
+        { field: "duration", label: "jobs.runs.col.duration" },
+      ],
+      defaultSort: { field: "startedAt", dir: "desc" },
+      facets: [
+        {
+          field: "status",
+          type: "select",
+          label: "jobs.runs.filter.status",
+          options: [
+            { value: "queued", label: "jobs.runs.filter.queued" },
+            { value: "running", label: "jobs.runs.filter.running" },
+            { value: "completed", label: "jobs.runs.filter.completed" },
+            { value: "failed", label: "jobs.runs.filter.failed" },
+          ],
+        },
+      ],
+      rowActions: [
+        {
+          kind: "navigate",
+          id: "open",
+          label: "jobs.runs.open",
+          screen: JOB_RUN_DETAIL_SCREEN_ID,
+          entityId: "id",
+          rowClick: true,
+        },
+      ],
+      toolbarActions: [
+        {
+          kind: "drawer",
+          id: "trigger",
+          label: "jobs.trigger.title",
+          screen: "job-trigger",
+          style: "primary",
+        },
+      ],
+      pagination: "infinite",
       access: systemAdminAccess,
     });
-    // kumiko-lint-ignore app-feature-structure Phase-3 conversion tracked in #2312
+    r.screen({
+      id: "job-trigger",
+      type: "actionForm",
+      handler: JobHandlers.trigger,
+      fields: {
+        jobName: { type: "text", required: true },
+        payload: { type: "longText", multiline: true, default: "{}" },
+      },
+      layout: { sections: [{ fields: ["jobName", "payload"] }] },
+      submitLabel: "jobs.trigger.submit",
+      access: systemAdminAccess,
+      description: "Manually trigger a job by name with an optional JSON object payload.",
+    });
     r.screen({
       id: JOB_RUN_DETAIL_SCREEN_ID,
-      type: "custom",
-      renderer: { react: { __component: "JobRunDetailScreen" } },
+      type: "projectionDetail",
+      query: JobQueries.details,
+      idParam: "runId",
+      fieldLabels: {
+        jobName: "jobs.detail.field.job",
+        status: "jobs.detail.field.status",
+        id: "jobs.detail.field.id",
+        startedAt: "jobs.detail.field.started",
+        finishedAt: "jobs.detail.field.finished",
+        duration: "jobs.detail.field.duration",
+        error: "jobs.detail.field.error",
+        logs: "jobs.detail.logs",
+      },
+      layout: {
+        sections: [
+          {
+            fields: [
+              "jobName",
+              "status",
+              "id",
+              { field: "startedAt", renderer: { format: "timestamp" } },
+              { field: "finishedAt", renderer: { format: "timestamp" } },
+              "duration",
+              "error",
+            ],
+          },
+          // No section `title` here (fw#2312 label-dedup fix): the section
+          // holds exactly one field, so a title would repeat the field's own
+          // label (rendered by RenderField as the Field's heading) verbatim.
+          {
+            fields: [{ field: "logs", renderer: { format: "json" } }],
+          },
+        ],
+      },
+      actions: [
+        {
+          kind: "writeHandler",
+          id: "retry",
+          label: "jobs.detail.retry",
+          handler: JobHandlers.retry,
+          payload: { map: { runId: "id" } },
+          visible: { field: "status", eq: "failed" },
+          style: "primary",
+        },
+      ],
       description:
         "Detail view of one job run with status, timings, error and log lines, and a retry action for failed runs; reached from a row of the job-runs list.",
       listScreenId: JOB_RUNS_SCREEN_ID,

package/src/jobs/handlers/list.query.ts

@@ -1,4 +1,4 @@
-import { selectMany, type WhereObject } from "@cosmicdrift/kumiko-framework/bun-db";
+import { countWhere, selectMany, type WhereObject } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
 import { z } from "zod";
@@ -28,7 +28,13 @@ export const listQuery = defineQueryHandler({
   schema: z.object({
     jobName: z.string().optional(),
     status: z.enum(["queued", "running", "completed", "failed"]).optional(),
+    filters: z
+      .array(z.object({ field: z.string(), op: z.literal("in"), value: z.array(z.string()) }))
+      .optional(),
+    sort: z.enum(["jobName", "status", "startedAt", "duration"]).optional(),
+    sortDirection: z.enum(["asc", "desc"]).optional(),
     limit: z.number().optional(),
+    totalCount: z.boolean().optional(),
   }),
   access: { roles: ["SystemAdmin"] },
   handler: async (query, ctx) => {
@@ -40,12 +46,23 @@ export const listQuery = defineQueryHandler({
     const db = ctx.systemDb.acknowledgeCrossTenant("cross-tenant job monitoring");
     const where: WhereObject = {};
     if (query.payload.jobName) where["jobName"] = query.payload.jobName;
-    if (query.payload.status) where["status"] = query.payload.status;
+    const statusFilter = query.payload.filters?.find((filter) => filter.field === "status");
+    const statuses = statusFilter?.value ?? (query.payload.status ? [query.payload.status] : []);
+    if (statuses.length === 1) where["status"] = statuses[0];
+    const sortColumn = query.payload.sort ?? "startedAt";
     const rows = await selectMany(db, jobRunsTable, where, {
-      orderBy: { col: "id", direction: "desc" },
+      orderBy: { col: sortColumn, direction: query.payload.sortDirection ?? "desc" },
       limit: query.payload.limit ?? 50,
     });
+    // countWhere reruns the SAME `where` without the limit — `rows.length` is
+    // capped at the page size and would silently undercount the total.
+    const total =
+      query.payload.totalCount === true ? await countWhere(db, jobRunsTable, where) : undefined;
     // payload/error are stored encrypted under the triggering user's DEK (#799, #2307).
-    return { rows: await mapWithConcurrency(rows, KMS_POOL_CONCURRENCY, decryptRunRow) };
+    return {
+      rows: await mapWithConcurrency(rows, KMS_POOL_CONCURRENCY, decryptRunRow),
+      nextCursor: null,
+      ...(total !== undefined && { total }),
+    };
   },
 });

package/src/jobs/handlers/trigger.write.ts

@@ -17,7 +17,7 @@ export const triggerWrite = defineWriteHandler({
     "Starts one manually-triggerable job with the given payload after validating it against the job's schema; use it to run a maintenance or import job on demand.",
   schema: z.object({
     jobName: z.string(),
-    payload: z.record(z.string(), z.unknown()).optional(),
+    payload: z.union([z.record(z.string(), z.unknown()), z.string()]).optional(),
   }),
   access: { roles: ["SystemAdmin"] },
   handler: async (event, ctx) => {
@@ -43,8 +43,21 @@ export const triggerWrite = defineWriteHandler({
       );
     }
 
-    const rawPayload = event.payload.payload ?? {};
-    let payload: DbRow = rawPayload as DbRow;
+    let rawPayload: DbRow = {};
+    if (typeof event.payload.payload === "string" && event.payload.payload.trim() !== "") {
+      try {
+        const parsed: unknown = JSON.parse(event.payload.payload);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return writeFailure(new UnprocessableError(JobErrors.notManual));
+        }
+        rawPayload = parsed as DbRow;
+      } catch {
+        return writeFailure(new UnprocessableError(JobErrors.notManual));
+      }
+    } else if (event.payload.payload !== undefined) {
+      rawPayload = event.payload.payload as DbRow;
+    }
+    let payload: DbRow = rawPayload;
     if (jobDef.schema !== undefined) {
       const parsed = jobDef.schema.safeParse(rawPayload);
       if (!parsed.success) {

package/src/jobs/i18n.ts

@@ -6,13 +6,12 @@ type LocalizedString = { readonly en: string };
 export const JOBS_I18N: Readonly<Record<string, LocalizedString>> = {
   "screen:job-runs.title": { en: "Job runs" },
   "screen:job-run-detail.title": { en: "Job run" },
+  "screen:job-trigger.title": { en: "Trigger job" },
+  "jobs:entity:__action-form__:field:jobName": { en: "Job name" },
+  "jobs:entity:__action-form__:field:payload": { en: "JSON payload" },
   "jobs:nav.jobRuns": { en: "Jobs" },
-  "jobs.runs.title": { en: "Job runs" },
-  "jobs.runs.loading": { en: "Loading runs…" },
-  "jobs.runs.empty": { en: "No job runs." },
   "jobs.runs.open": { en: "Details" },
   "jobs.runs.filter.status": { en: "Status" },
-  "jobs.runs.filter.all": { en: "All" },
   "jobs.runs.filter.completed": { en: "Completed" },
   "jobs.runs.filter.failed": { en: "Failed" },
   "jobs.runs.filter.running": { en: "Running" },
@@ -21,8 +20,6 @@ export const JOBS_I18N: Readonly<Record<string, LocalizedString>> = {
   "jobs.runs.col.status": { en: "Status" },
   "jobs.runs.col.started": { en: "Started" },
   "jobs.runs.col.duration": { en: "Duration (ms)" },
-  "jobs.detail.loading": { en: "Loading details…" },
-  "jobs.detail.missing": { en: "Run not found." },
   "jobs.detail.field.job": { en: "Job" },
   "jobs.detail.field.status": { en: "Status" },
   "jobs.detail.field.id": { en: "Run ID" },
@@ -31,28 +28,9 @@ export const JOBS_I18N: Readonly<Record<string, LocalizedString>> = {
   "jobs.detail.field.duration": { en: "Duration (ms)" },
   "jobs.detail.field.error": { en: "Error" },
   "jobs.detail.logs": { en: "Logs" },
-  "jobs.detail.logs.empty": { en: "No log lines." },
   "jobs.detail.retry": { en: "Retry" },
-  "jobs.detail.retrying": { en: "Retrying…" },
   "jobs.trigger.title": { en: "Run a job" },
-  "jobs.trigger.explainer": {
-    en: "Only manually triggerable jobs. After starting, the run appears in the history below.",
-  },
-  "jobs.trigger.job": { en: "Job" },
-  "jobs.trigger.payload": { en: "Payload (JSON)" },
-  "jobs.trigger.payload.hint": { en: "Schema hint" },
-  "jobs.trigger.payload.invalidJson": {
-    en: "Payload is not a valid JSON object.",
-  },
   "jobs.trigger.submit": { en: "Run" },
-  "jobs.trigger.submitting": { en: "Starting…" },
-  "jobs.trigger.success": { en: "Job started." },
-  "jobs.trigger.empty": {
-    en: "No manually triggerable jobs are registered.",
-  },
-  "jobs.trigger.perTenant": {
-    en: "Runs once per active tenant.",
-  },
   "jobs.errors.unknownJob": { en: "Unknown job." },
   "jobs.errors.notManual": {
     en: "This job cannot be triggered manually.",

package/src/jobs/index.ts

@@ -1,3 +1,4 @@
+export { JOBS_FEATURE, JobErrors, JobHandlers, JobQueries } from "./constants";
 export { createJobsFeature, type JobsFeatureOptions } from "./feature";
 export type { JobRunLoggerCallbacks } from "./job-run-logger";
 export { createJobRunLogger } from "./job-run-logger";

package/src/jobs/web/client-plugin.tsx

@@ -1,10 +1,8 @@
 // @runtime client
 import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
 import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
-import { JOB_RUN_DETAIL_SCREEN_ID, JOB_RUNS_SCREEN_ID, JOBS_FEATURE } from "../constants";
+import { JOBS_FEATURE } from "../constants";
 import { defaultTranslations } from "./i18n";
-import { JobRunDetailScreen } from "./job-run-detail-screen";
-import { JobRunsScreen } from "./job-runs-screen";
 
 export type JobsClientOptions = {
   readonly translations?: TranslationsByLocale;
@@ -14,9 +12,5 @@ export function jobsClient(options?: JobsClientOptions): ClientFeatureDefinition
   return {
     name: JOBS_FEATURE,
     translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
-    components: {
-      [JOB_RUNS_SCREEN_ID]: JobRunsScreen,
-      [JOB_RUN_DETAIL_SCREEN_ID]: JobRunDetailScreen,
-    },
   };
 }

package/src/jobs/web/index.ts

@@ -1,4 +1,2 @@
 // @runtime client
 export { type JobsClientOptions, jobsClient } from "./client-plugin";
-export { JobRunDetailScreen } from "./job-run-detail-screen";
-export { JobRunsScreen } from "./job-runs-screen";

package/src/personal-access-tokens/web/pat-tokens-screen.tsx

@@ -289,7 +289,7 @@ export function PatTokensScreen({
     return <div className="flex flex-col gap-6">{content}</div>;
   }
   return (
-    <FormScreenShell testId="pat-tokens-screen" maxWidth="3xl" className="flex flex-col gap-6">
+    <FormScreenShell testId="pat-tokens-screen" className="flex flex-col gap-6">
       {content}
     </FormScreenShell>
   );

package/src/tenant/__tests__/tenant.integration.test.ts

@@ -190,6 +190,38 @@ describe("scenario 5: tenant.list", () => {
       "SystemAdmin",
     ]);
   });
+
+  test("without totalCount the shape carries no total field (fw#2312)", async () => {
+    const result = await stack.http.queryOk<{
+      rows: Record<string, unknown>[];
+      nextCursor: string | null;
+      total?: number;
+    }>(TenantQueries.list, {}, systemAdmin);
+    expect(result.total).toBeUndefined();
+  });
+
+  test("total reflects the full match count, not capped by limit (fw#2312)", async () => {
+    await stack.http.writeOk(
+      TenantHandlers.create,
+      { key: "gamma", name: "Gamma LLC" },
+      systemAdmin,
+    );
+
+    const unpaged = await stack.http.queryOk<{ rows: Record<string, unknown>[] }>(
+      TenantQueries.list,
+      {},
+      systemAdmin,
+    );
+    const expectedTotal = unpaged.rows.length;
+    expect(expectedTotal).toBeGreaterThanOrEqual(3);
+
+    const paged = await stack.http.queryOk<{
+      rows: Record<string, unknown>[];
+      total?: number;
+    }>(TenantQueries.list, { limit: 1, totalCount: true }, systemAdmin);
+    expect(paged.rows.length).toBe(1);
+    expect(paged.total).toBe(expectedTotal);
+  });
 });
 
 // --- Scenario 6: Config integration ---

package/src/tenant/handlers/list.query.ts

@@ -12,6 +12,7 @@ export const listQuery = defineQueryHandler({
     cursor: z.string().optional(),
     limit: z.number().optional(),
     search: z.string().optional(),
+    totalCount: z.boolean().optional(),
   }),
   access: { roles: ["SystemAdmin"] },
   description:

package/src/tier-engine/__tests__/drift.test.ts

@@ -18,7 +18,7 @@ describe("tier-engine drift pins", () => {
     expect(TierEngineHandlers.update).toBe("tier-engine:write:tier-assignment:update");
     expect(TierEngineQueries.list).toBe("tier-engine:query:tier-assignment:list");
     expect(TierEngineQueries.getActiveTier).toBe("tier-engine:query:get-active-tier");
-    // Screen↔Handler-Contract: der TierAdminScreen dispatcht exakt diese QNs.
+    // Screen↔Handler-Contract: the tier-admin actionForm dispatches exactly these QNs.
     expect(TierEngineHandlers.setTenantTier).toBe("tier-engine:write:set-tenant-tier");
     expect(TierEngineQueries.getTenantTier).toBe("tier-engine:query:get-tenant-tier");
     expect(TierEngineQueries.tierOptions).toBe("tier-engine:query:tier-options");