@gaia-ai/addon-gaia-ui 0.9.2 → 0.10.0

package/dist/src/Entity/run/Data/runs.d.ts

@@ -219,6 +219,8 @@ export type RunPage = Page<RunRow>;
  * `links.next`.
  */
 export declare function loadProjectRuns(client: DropshClient, projectId: string, criteria: RunCriteria, page?: number): Promise<RunPage>;
+/** One page of runs attributed to a user via ticket assignee (GAIA-377 D2). */
+export declare function loadUserRuns(client: DropshClient, userId: string, criteria: RunCriteria, page?: number): Promise<RunPage>;
 /**
  * Newest-STARTED first, and TOTAL (GAIA-255 D5).
  *

package/dist/src/Entity/run/Data/runs.js

@@ -7,7 +7,7 @@
 // no-request read of the ticket document (spec D7).
 import { loadPage, } from '../../collection.js';
 import { LIST_PAGE_SIZE } from '../../cycle.js';
-import { buildRunQueryParams } from './query.js';
+import { buildRunQueryParams, buildUserRunQueryParams, } from './query.js';
 import { deriveRunStatus, runStartedAge } from './status.js';
 /** Read a value as a string, or `undefined` when it is not one. */
 function str(value) {
@@ -217,6 +217,24 @@ export async function loadProjectRuns(client, projectId, criteria, page = 0) {
         return data.map((item) => mapRunData(item, ticketsById));
     }, page, window);
 }
+/** One page of runs attributed to a user via ticket assignee (GAIA-377 D2). */
+export async function loadUserRuns(client, userId, criteria, page = 0) {
+    const window = {
+        offset: page * LIST_PAGE_SIZE,
+        limit: LIST_PAGE_SIZE,
+    };
+    const params = buildUserRunQueryParams(userId, criteria, {
+        size: window.limit,
+        index: page,
+    });
+    return loadPage(client, 'gaia_run/gaia_run', params, (data, included) => {
+        const ticketsById = new Map();
+        for (const inc of included)
+            if (inc.id)
+                ticketsById.set(inc.id, inc);
+        return data.map((item) => mapRunData(item, ticketsById));
+    }, page, window);
+}
 /**
  * Newest-STARTED first, and TOTAL (GAIA-255 D5).
  *

package/dist/src/Entity/run/Screen/run-detail.d.ts

@@ -1,10 +1,17 @@
-import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 import type { TicketDetailDocument } from '../../../types.js';
 export interface RunDetailInput {
     readonly document: TicketDetailDocument;
 }
 export declare const runDetailInputContext: import("../../../Routing/context.js").ContextKey<RunDetailInput>;
-export declare class RunDetailScreen extends BaseScreen {
+/**
+ * Run detail — normal {@link AsyncScreen}. The document arrives via navigation
+ * context (or empty); refresh is the shared R / ui-refresh path.
+ */
+export declare class RunDetailScreen extends AsyncScreen<TicketDetailDocument> {
     readonly frameId = "run";
     topTab(): null;
     static readonly route: {
@@ -17,20 +24,13 @@ export declare class RunDetailScreen extends BaseScreen {
         context: (_params: Readonly<Record<string, string>>, state: unknown, base: import("../../../Routing/context.js").ContextBag) => import("../../../Routing/context.js").ContextBag;
     };
     readonly id: string;
-    private document;
-    enter(context: ScreenContext): void;
-    /**
-     * GAIA-340 D1 — the first screen on the renderable side of the boundary.
-     *
-     * It hands over NODES: the component returns the block as a tree and this
-     * returns it with the three chrome labels beside it. There is no
-     * `render(context): string[]` any more, because there is no second
-     * description of the screen to keep in step with this one — the bold section
-     * headings that were `boldRows` indices into a row surface are props on the
-     * rows' own nodes now (D3), and the surface those indices pointed into is
-     * gone.
-     */
-    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    reload(context: ScreenContext): void;
+    protected load(context: ScreenContext): Promise<TicketDetailDocument>;
+    protected renderLoading(): string[];
+    protected renderReady(document: TicketDetailDocument, context: ScreenContext): VNode;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    /** Read-only — kernel basics cover ↑↓ / Esc / q; no extra chips. */
+    protected actions(): never[];
     /**
      * F5 — the pipe's own output, and it is `string[]`.
      *
@@ -41,13 +41,6 @@ export declare class RunDetailScreen extends BaseScreen {
      * path lays the body out on a cell grid of a fixed width, and a pipe has no
      * width — on run #4928 it clipped 420 transcript rows at 80 columns, losing
      * 97.7 % of a 1.34 MB captured agent transcript.
-     *
-     * This is NOT a `ScreenPresentation.lines` coming back (R3): `present()` still
-     * hands over a tree and nothing else. Both shapes are projections of the block's
-     * ONE keyed traversal (`flatRows`), so there is no second description of the
-     * screen to keep in step — see `tests/Screen/run-detail-non-tty.test.ts`, which
-     * asserts the two row for row.
      */
     renderNonInteractive(context: ScreenContext): string[];
-    reset(): void;
 }

package/dist/src/Entity/run/Screen/run-detail.js

@@ -1,8 +1,12 @@
 import { defineContext } from '../../../Routing/context.js';
-import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { runDetailRows, runDetailTitle, runDetailTree, } from '../Component/run-detail/index.js';
 export const runDetailInputContext = defineContext('run-detail-input', 'input');
-export class RunDetailScreen extends BaseScreen {
+/**
+ * Run detail — normal {@link AsyncScreen}. The document arrives via navigation
+ * context (or empty); refresh is the shared R / ui-refresh path.
+ */
+export class RunDetailScreen extends AsyncScreen {
     frameId = 'run';
     topTab() {
         return null;
@@ -19,30 +23,28 @@ export class RunDetailScreen extends BaseScreen {
             : base,
     };
     id = RunDetailScreen.route.id;
-    document = {};
-    enter(context) {
+    reload(context) {
+        this.retry(context);
+    }
+    load(context) {
         if (context.contexts?.has(runDetailInputContext))
-            this.document = context.contexts.get(runDetailInputContext).document;
-        context.requestDraw();
+            return Promise.resolve(context.contexts.get(runDetailInputContext).document);
+        return Promise.resolve({});
     }
-    /**
-     * GAIA-340 D1 — the first screen on the renderable side of the boundary.
-     *
-     * It hands over NODES: the component returns the block as a tree and this
-     * returns it with the three chrome labels beside it. There is no
-     * `render(context): string[]` any more, because there is no second
-     * description of the screen to keep in step with this one — the bold section
-     * headings that were `boldRows` indices into a row surface are props on the
-     * rows' own nodes now (D3), and the surface those indices pointed into is
-     * gone.
-     */
-    present(context) {
-        const runId = context.params?.runId ?? '';
-        return presentation(runDetailTree(this.document, runId), {
-            title: runDetailTitle(this.document, runId),
-            meta: '↑↓ scroll · Esc back · q quit',
-            status: ' ↑↓ scroll · Esc back · q quit ',
-        });
+    renderLoading() {
+        return ['Loading run…'];
+    }
+    renderReady(document, context) {
+        return runDetailTree(document, context.params?.runId ?? '');
+    }
+    chrome(context) {
+        return {
+            title: runDetailTitle(this.readyValue ?? {}, context.params?.runId ?? ''),
+        };
+    }
+    /** Read-only — kernel basics cover ↑↓ / Esc / q; no extra chips. */
+    actions() {
+        return [];
     }
     /**
      * F5 — the pipe's own output, and it is `string[]`.
@@ -54,17 +56,8 @@ export class RunDetailScreen extends BaseScreen {
      * path lays the body out on a cell grid of a fixed width, and a pipe has no
      * width — on run #4928 it clipped 420 transcript rows at 80 columns, losing
      * 97.7 % of a 1.34 MB captured agent transcript.
-     *
-     * This is NOT a `ScreenPresentation.lines` coming back (R3): `present()` still
-     * hands over a tree and nothing else. Both shapes are projections of the block's
-     * ONE keyed traversal (`flatRows`), so there is no second description of the
-     * screen to keep in step — see `tests/Screen/run-detail-non-tty.test.ts`, which
-     * asserts the two row for row.
      */
     renderNonInteractive(context) {
-        return runDetailRows(this.document, context.params?.runId ?? '');
-    }
-    reset() {
-        this.document = {};
+        return runDetailRows(this.readyValue ?? {}, context.params?.runId ?? '');
     }
 }

package/dist/src/Entity/run/Screen/runs.d.ts

@@ -1,9 +1,10 @@
+import type { FullScreenChrome, ListFilterBadge } from '../../../Screen/full-screen.js';
 import { ListScreen } from '../../../Screen/list-screen.js';
-import { type ScreenContext, type ScreenPresentation } from '../../../Screen/screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 import { type RunCriteria } from '../Data/query.js';
 import { type RunPage, type RunRow } from '../Data/runs.js';
 export declare class RunsScreen extends ListScreen<RunRow, number> {
-    readonly frameId = "project-runs";
+    readonly frameId = "runs";
     readonly topTabOverlay = true;
     protected readonly table: {
         readonly noun: "run";
@@ -78,7 +79,10 @@ export declare class RunsScreen extends ListScreen<RunRow, number> {
      *  clients/test doubles, as on the ticket list. */
     protected filterRow(row: RunRow): boolean;
     protected renderLoading(): string[];
-    present(context: ScreenContext): ScreenPresentation;
+    /** Runs expose only the closed cycle — one badge, always shown (GAIA-375 A′). */
+    protected badges(): readonly ListFilterBadge[];
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
     activate(index: number, context: ScreenContext): boolean;
     select(index: number, context: ScreenContext): boolean;
     handleInput(input: string, context: ScreenContext): boolean;

package/dist/src/Entity/run/Screen/runs.js

@@ -1,10 +1,10 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { ListScreen } from '../../../Screen/list-screen.js';
-import { presentation, } from '../../../Screen/screen.js';
 import { CLOSED_FILTER_VALUES, cycleValue } from '../../cycle.js';
 import { DEFAULT_RUN_CRITERIA } from '../Data/query.js';
 import { loadProjectRuns, RUN_TABLE, selectedRunTicketId, } from '../Data/runs.js';
 export class RunsScreen extends ListScreen {
-    frameId = 'project-runs';
+    frameId = 'runs';
     topTabOverlay = true;
     table = RUN_TABLE;
     topTab() {
@@ -63,55 +63,38 @@ export class RunsScreen extends ListScreen {
     renderLoading() {
         return ['Loading runs…'];
     }
-    present(context) {
-        const rows = this.rows;
-        // Standing segment: stated whenever rows are hidden, including the very
-        // first render (AC-4) — unconditional, as on the ticket list.
-        const closedSegment = this.criteria.closed === null
-            ? ''
-            : this.criteria.closed
-                ? 'closed: only'
-                : 'closed: hidden';
-        // The PAGE number, and only that; the collection's size is a different
-        // quantity, stated in its own segment by `countLabel` off the `meta.count`
-        // the page response carries (D6e). A page that offers a next page while
-        // showing few rows is correct rather than a bug: `links.next` is the
-        // end-of-collection signal, and a page can be full without being the last.
-        // The whole segment describes the LOADED page, not the requested index —
-        // that is what the `page` the value carries is for (D4); same reasoning,
-        // same shape and the same bottom-line home as the ticket list, which must
-        // not drift from this one. It is the same `loadedPage` the ARROW keys act
-        // on, so the number the operator reads and the number the keys move from
-        // are one value (R1).
-        //
-        // Built by `ListScreen` since GAIA-294, which is what makes "must not drift
-        // from the ticket list" a mechanism rather than a promise.
-        const paging = this.pagingSegments();
-        // The rows ON SCREEN and the size of the FILTERED COLLECTION, side by side:
-        // `7 of 1340 run(s)` when the server reported the total, `7 of ? run(s)`
-        // when it reported none (GAIA-292 D6c/D6d). Neither quantity replaces the
-        // other, so the row count never jumps; the total is read off the value the
-        // rows came with (D4/D4a) and from no second screen member — which is now
-        // structural rather than careful, because the server answered both from one
-        // query. Empty while the page loads (D6c), which is why the segments are
-        // joined rather than concatenated — an omitted count must not leave the line
-        // opening with a separator.
-        const count = this.countLabel();
-        return presentation(this.surface(context), {
-            selectable: rows.length,
+    /** Runs expose only the closed cycle — one badge, always shown (GAIA-375 A′). */
+    badges() {
+        if (this.criteria.closed === null) {
+            return [{ id: 'closed', label: 'x closed' }];
+        }
+        return [
+            {
+                id: 'closed',
+                label: 'x closed',
+                value: this.criteria.closed ? 'closed: only' : 'closed: hidden',
+            },
+        ];
+    }
+    chrome(context) {
+        // Count + page in header meta; ←/→ in footer actions (GAIA-375 / GAIA-292).
+        const pagingLine = [this.countLabel(), ...this.pagingSegments()]
+            .filter(Boolean)
+            .join(' · ');
+        return {
+            selectable: this.rows.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each row lands on (GAIA-340 Task 11).
             rowIds: this.rowNodeIds,
             title: `${context.project?.name ?? context.project?.slug ?? ''} · runs`,
-            meta: [
-                count,
-                closedSegment,
-                'Enter ticket · Tab tabs · x closed · Esc back',
-            ]
-                .filter(Boolean)
-                .join('  ·  '),
-            status: ` ${paging.join(' · ')} · ↑↓ select · Enter ticket · Tab tabs · x closed · Esc back · q quit `,
-        });
+            meta: pagingLine,
+        };
+    }
+    actions() {
+        return [
+            actionItem('runs-enter', 'Enter', 'ticket'),
+            actionItem('runs-tab', 'Tab', 'tabs'),
+            ...this.pagingActionItems(),
+        ];
     }
     activate(index, context) {
         const id = this.readyValue

package/dist/src/Entity/run/Screen/user-runs.d.ts

@@ -0,0 +1,79 @@
+import type { FullScreenChrome, ListFilterBadge } from '../../../Screen/full-screen.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
+import { type RunPage, type RunRow } from '../Data/runs.js';
+/** Runs attributed to one user via ticket assignee (GAIA-377 D2). */
+export declare class UserRunsScreen extends ListScreen<RunRow, number> {
+    readonly frameId = "user-runs";
+    readonly topTabOverlay = true;
+    protected readonly table: {
+        readonly noun: "run";
+        readonly columns: readonly [{
+            readonly key: "run";
+            readonly label: "RUN";
+            readonly width: 8;
+            readonly fields: readonly ["drupal_internal__id"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "ticket";
+            readonly label: "TICKET";
+            readonly width: 10;
+            readonly fields: readonly ["ticket_id"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "state";
+            readonly label: "STATE";
+            readonly width: 8;
+            readonly fields: readonly ["state", "heartbeat", "claim_expires_at"];
+            readonly get: (r: RunRow, nowSeconds: number) => string;
+        }, {
+            readonly key: "phase";
+            readonly label: "PHASE";
+            readonly width: 13;
+            readonly fields: readonly ["state_at_start"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "agent";
+            readonly label: "AGENT";
+            readonly width: 8;
+            readonly fields: readonly ["agent"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "started";
+            readonly label: "STARTED";
+            readonly width: 0;
+            readonly grow: 1;
+            readonly fields: readonly ["started_at", "created"];
+            readonly get: (r: RunRow, nowSeconds: number) => string;
+        }];
+        readonly emptyMessage: "No runs for this project.";
+    };
+    topTab(): {
+        readonly level: "user";
+        readonly tab: "runs";
+    };
+    static readonly route: {
+        id: string;
+        path: string;
+        fallback: {
+            routeId: string;
+        };
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+    };
+    readonly id: string;
+    private criteria;
+    protected tableContext(context: ScreenContext): number;
+    protected loadRows(context: ScreenContext, page: number): Promise<RunPage>;
+    protected filterRow(row: RunRow): boolean;
+    protected renderLoading(): string[];
+    protected badges(): readonly ListFilterBadge[];
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
+    activate(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+}

package/dist/src/Entity/run/Screen/user-runs.js

@@ -0,0 +1,98 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import { CLOSED_FILTER_VALUES, cycleValue } from '../../cycle.js';
+import { DEFAULT_RUN_CRITERIA } from '../Data/query.js';
+import { loadUserRuns, RUN_TABLE, selectedRunTicketId, } from '../Data/runs.js';
+/** Runs attributed to one user via ticket assignee (GAIA-377 D2). */
+export class UserRunsScreen extends ListScreen {
+    frameId = 'user-runs';
+    topTabOverlay = true;
+    table = RUN_TABLE;
+    topTab() {
+        return { level: 'user', tab: 'runs' };
+    }
+    static route = {
+        id: 'user.runs',
+        path: '/users/:userId/runs',
+        fallback: { routeId: 'users' },
+        tab: { id: 'runs', label: 'Runs', scope: 'user', order: 30 },
+    };
+    id = UserRunsScreen.route.id;
+    criteria = { ...DEFAULT_RUN_CRITERIA };
+    tableContext(context) {
+        return context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+    }
+    loadRows(context, page) {
+        if (!context.services)
+            throw new Error('User runs requires services');
+        const userId = context.user?.id ?? context.params?.userId;
+        if (!userId)
+            throw new Error('User runs requires userId');
+        return loadUserRuns(context.services.client, userId, this.criteria, page);
+    }
+    filterRow(row) {
+        return this.criteria.closed === null || row.closed === this.criteria.closed;
+    }
+    renderLoading() {
+        return ['Loading runs…'];
+    }
+    badges() {
+        if (this.criteria.closed === null) {
+            return [{ id: 'closed', label: 'x closed' }];
+        }
+        return [
+            {
+                id: 'closed',
+                label: 'x closed',
+                value: this.criteria.closed ? 'closed: only' : 'closed: hidden',
+            },
+        ];
+    }
+    chrome(context) {
+        const name = context.user?.name ?? context.params?.userName ?? 'user';
+        const pagingLine = [this.countLabel(), ...this.pagingSegments()]
+            .filter(Boolean)
+            .join(' · ');
+        return {
+            selectable: this.rows.length,
+            selectedIndex: this.selectedIndex,
+            rowIds: this.rowNodeIds,
+            title: `${name} · runs`,
+            meta: pagingLine,
+        };
+    }
+    actions() {
+        return [
+            actionItem('user-runs-enter', 'Enter', 'ticket'),
+            actionItem('user-runs-tab', 'Tab', 'tabs'),
+            ...this.pagingActionItems(),
+        ];
+    }
+    activate(index, context) {
+        const id = this.readyValue
+            ? selectedRunTicketId(this.readyValue.rows, index)
+            : null;
+        if (!id || !context.navigate)
+            return false;
+        context.navigate('ticket.detail', { ticketId: id, tab: 'runs' });
+        return true;
+    }
+    handleInput(input, context) {
+        if (input === 'x') {
+            this.criteria = {
+                ...this.criteria,
+                closed: cycleValue(CLOSED_FILTER_VALUES, this.criteria.closed),
+            };
+            this.page = 0;
+            this.retry(context);
+            return true;
+        }
+        if (this.handlePagingInput(input, context))
+            return true;
+        if (this.handleCursorInput(input, context))
+            return true;
+        if (input === 'enter')
+            return this.activate(this.selectedIndex, context);
+        return super.handleInput(input, context);
+    }
+}

package/dist/src/Entity/statistics/Data/statistics.d.ts

@@ -36,10 +36,22 @@ export interface StatisticsRow {
  * the blocks the document carries — an empty array would render as an empty
  * `PER PROJECT` heading.
  */
+/**
+ * One UTC calendar day in a user-scoped `by_day` series (GAIA-377).
+ *
+ * Present only under `?user_id=`; the user overview draws the last seven days
+ * as weekday rows. `label` is the English short weekday the server computed.
+ */
+export interface StatisticsDayRow {
+    date: string;
+    label: string;
+    count: number;
+}
 export interface StatisticsBlock {
     total: StatisticsWindows;
     byProject?: StatisticsRow[];
     byUser?: StatisticsRow[];
+    byDay?: StatisticsDayRow[];
 }
 /** The whole document, as the Dashboard consumes it. */
 export interface Statistics {
@@ -68,20 +80,33 @@ export type StatisticsResult = {
 };
 /** How an `id: null` breakdown row is named on screen (spec D8/D11). */
 export declare const UNATTRIBUTED_LABEL = "\u2014 unattributed";
+/**
+ * Closed tickets per run for each trailing window (GAIA-377 D4).
+ *
+ * Derived on the client from totals that already travel together — a
+ * server-computed copy would be a second source of truth that can disagree.
+ * `null` when the window has zero runs: never `0`, never `Infinity`.
+ */
+export declare function closedPerRun(tickets: StatisticsWindows, runs: StatisticsWindows): {
+    day: number | null;
+    week: number | null;
+    month: number | null;
+};
+/** Format a closed-per-run value for the screen: two decimals, or `—`. */
+export declare const formatClosedPerRun: (value: number | null) => string;
 /**
  * Read the control plane's ticket and run statistics — the ONE source of every
  * figure the Dashboard renders (AC-8).
  *
  * With `projectId` the read is scoped and the server drops `by_project` from
- * both blocks (spec D5). The parameter name is `project_id` and NOT `project`:
- * JSON:API requires an implementation-specific query parameter to contain at
- * least one non-`a-z` character, and Drupal enforces it — `?project=` is
- * rejected with a 400 by `JsonApiRequestValidator` before the resource is ever
- * reached, so it cannot even be accepted as an alias.
+ * both blocks (spec D5). With `userId` (GAIA-377 D3) it drops `by_user` and
+ * keeps `by_project`. The parameter names are `project_id` / `user_id` and NOT
+ * bare letters: JSON:API requires an implementation-specific query parameter to
+ * contain at least one non-`a-z` character, and Drupal enforces it.
  *
  * The client is the caller's, singular and used once: the TUI reads everything
  * through `services.client` (the `session` profile), and `pm` cannot read
  * `gaia_run` — a loader that reached for another client would render zero runs
  * as a real measurement (spec R3).
  */
-export declare function loadStatistics(client: DropshClient, projectId?: string): Promise<StatisticsResult>;
+export declare function loadStatistics(client: DropshClient, projectId?: string, userId?: string): Promise<StatisticsResult>;

package/dist/src/Entity/statistics/Data/statistics.js

@@ -25,14 +25,28 @@ function rowsOf(value) {
         };
     });
 }
+function dayRowsOf(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map((entry) => {
+        const r = (entry ?? {});
+        return {
+            date: typeof r.date === 'string' ? r.date : '',
+            label: typeof r.label === 'string' ? r.label : '',
+            count: num(r.count),
+        };
+    });
+}
 function blockOf(value) {
     const b = (value ?? {});
     const byProject = rowsOf(b.by_project);
     const byUser = rowsOf(b.by_user);
+    const byDay = dayRowsOf(b.by_day);
     return {
         total: windowsOf(b.total),
         ...(byProject ? { byProject } : {}),
         ...(byUser ? { byUser } : {}),
+        ...(byDay ? { byDay } : {}),
     };
 }
 /** The HTTP status of an unknown throw — dropsh's `HttpError` carries one. */
@@ -86,27 +100,46 @@ function jsonApiErrorDetail(caught) {
     // fall back to a non-empty marker rather than to `undefined`.
     return typeof detail === 'string' && detail !== '' ? detail : 'HTTP 404';
 }
+/**
+ * Closed tickets per run for each trailing window (GAIA-377 D4).
+ *
+ * Derived on the client from totals that already travel together — a
+ * server-computed copy would be a second source of truth that can disagree.
+ * `null` when the window has zero runs: never `0`, never `Infinity`.
+ */
+export function closedPerRun(tickets, runs) {
+    const ratio = (t, r) => (r > 0 ? t / r : null);
+    return {
+        day: ratio(tickets.day, runs.day),
+        week: ratio(tickets.week, runs.week),
+        month: ratio(tickets.month, runs.month),
+    };
+}
+/** Format a closed-per-run value for the screen: two decimals, or `—`. */
+export const formatClosedPerRun = (value) => value === null ? '—' : value.toFixed(2);
 /**
  * Read the control plane's ticket and run statistics — the ONE source of every
  * figure the Dashboard renders (AC-8).
  *
  * With `projectId` the read is scoped and the server drops `by_project` from
- * both blocks (spec D5). The parameter name is `project_id` and NOT `project`:
- * JSON:API requires an implementation-specific query parameter to contain at
- * least one non-`a-z` character, and Drupal enforces it — `?project=` is
- * rejected with a 400 by `JsonApiRequestValidator` before the resource is ever
- * reached, so it cannot even be accepted as an alias.
+ * both blocks (spec D5). With `userId` (GAIA-377 D3) it drops `by_user` and
+ * keeps `by_project`. The parameter names are `project_id` / `user_id` and NOT
+ * bare letters: JSON:API requires an implementation-specific query parameter to
+ * contain at least one non-`a-z` character, and Drupal enforces it.
  *
  * The client is the caller's, singular and used once: the TUI reads everything
  * through `services.client` (the `session` profile), and `pm` cannot read
  * `gaia_run` — a loader that reached for another client would render zero runs
  * as a real measurement (spec R3).
  */
-export async function loadStatistics(client, projectId) {
+export async function loadStatistics(client, projectId, userId) {
     const params = new DrupalJsonApiParams();
     if (projectId !== undefined) {
         params.addCustomParam({ project_id: projectId });
     }
+    if (userId !== undefined) {
+        params.addCustomParam({ user_id: userId });
+    }
     let doc;
     try {
         doc = (await client.get('gaia/statistics', params));