@gaia-ai/addon-gaia-ui 0.14.0 → 0.14.2

package/dist/src/Entity/collection.d.ts

@@ -162,6 +162,21 @@ export interface ListColumn<Row, Ctx = void> {
     readonly min?: number;
     readonly max?: number;
     readonly grow?: number;
+    /**
+     * Size this column to the longest value in the rows being rendered, never
+     * below `width` and never below the header's own label.
+     *
+     * The other columns of this tree are DECLARED widths and deliberately so — a
+     * domain constant like STATE's 13 is the length of `qualification`. An
+     * identifier has no such constant: its length is the project's prefix plus a
+     * number, so a fixed column cuts exactly the number that distinguishes one
+     * ticket from the next (GAIA-549). One width per render, shared by the header
+     * and every row, is what keeps the column aligned.
+     *
+     * Deliberately uncapped: a cap puts the ellipsis back on the number. The
+     * surplus demand is paid by the row's grower, which is the title.
+     */
+    readonly fit?: boolean;
     get(row: Row, ctx: Ctx): unknown;
 }
 /**

package/dist/src/Entity/collection.js

@@ -96,9 +96,11 @@ const BLANKS = ' '.repeat(GROWN_CELL_FILL);
  * argument for it: the target is a number the COLUMN DECLARES, never a width
  * measured off the page (spec D4), and the cell resolves to exactly the columns
  * it resolved to before — Yoga is handed the same budget either way. `cellText`
- * and `elideLeft` are the two sanctioned `displayWidth` callers because they
- * mark a cut against a declared width; this is the third and it is the same
- * shape, one step further: it FILLS to a declared width.
+ * and `elideLeft` are sanctioned `displayWidth` callers because they mark a cut
+ * against a declared width; this is the same shape, one step further: it FILLS
+ * to a declared width. {@link fitColumns} is the one caller that measures a
+ * value instead, and it does so to PRODUCE the declared width before any cell
+ * exists, so the rule this paragraph states still holds below it.
  *
  * The two branches are not a style choice, they are what the renderer allows:
  *
@@ -261,6 +263,24 @@ const tableRow = (ids, columns, value, { selected, bold }) => seamlessRowNode(id
  *  `rowNodeId`. Beside {@link listTableTree}, which keys the rows under it, and
  *  reading the SAME `noun` off the same configuration (GAIA-345 D2). */
 export const listRowIds = (table, rows) => rows.map((row) => rowNodeId(table.noun, row.id));
+/**
+ * The column set as RENDERED: a `fit` column resolved against the rows this
+ * frame carries, every other column untouched.
+ *
+ * Measured with `displayWidth`, like every other measurement in this tree, so a
+ * wide glyph costs the columns it paints rather than the characters it has.
+ * That makes this the one caller that measures a VALUE rather than marking a cut
+ * against a width already declared (see {@link tableRow}) — which is the point:
+ * it turns the longest value of this frame INTO the declared width, once, before
+ * a cell is built, so every cell below still resolves against a number the
+ * column declares.
+ */
+const fitColumns = (columns, rows, ctx) => columns.map((column) => column.fit !== true
+    ? column
+    : {
+        ...column,
+        width: rows.reduce((widest, row) => Math.max(widest, displayWidth(String(column.get(row, ctx) ?? ''))), Math.max(column.width, displayWidth(column.label))),
+    });
 /**
  * GAIA-340 D1 — a column-driven list as the renderable tree a screen hands over.
  *
@@ -301,6 +321,7 @@ export const listRowIds = (table, rows) => rows.map((row) => rowNodeId(table.nou
  */
 export function listTableTree(table, rows, ctx, { selectedIndex }) {
     const { noun, columns, emptyMessage, header = true } = table;
+    const rendered = fitColumns(columns, rows, ctx);
     return columnNode(`${noun}-table`, 
     // GAIA-345 D5/D6 — the header is BOLD, which is what distinguishes it from a
     // data row, and it is optional because one list is not a record set: the
@@ -310,14 +331,14 @@ export function listTableTree(table, rows, ctx, { selectedIndex }) {
             tableRow({
                 row: `${noun}-header`,
                 cell: (key) => `${noun}-header-${key}`,
-            }, columns, (column) => column.label, { selected: false, bold: true }),
+            }, rendered, (column) => column.label, { selected: false, bold: true }),
         ]
         : []), ...(rows.length === 0
         ? [textNode({ id: `${noun}-empty`, content: emptyMessage })]
         : rows.map((row, index) => tableRow({
             row: rowNodeId(noun, row.id),
             cell: (key) => `${noun}-cell-${row.id}-${key}`,
-        }, columns, (column) => column.get(row, ctx), { selected: index === selectedIndex, bold: false }))));
+        }, rendered, (column) => column.get(row, ctx), { selected: index === selectedIndex, bold: false }))));
 }
 /**
  * GAIA-345 D7 — the SAME list for the surface that has no layout:

package/dist/src/Entity/conductor/Data/detail.d.ts

@@ -0,0 +1,39 @@
+import { type SessionStore } from '../../../Data/session-store.js';
+import type { DropshClient } from '../../../types.js';
+import { type ConductorStatus } from './liveness.js';
+/** The conductor detail scope's shared header data. */
+export interface ConductorDetail {
+    id: string;
+    /** Never empty — the uuid is the last fallback. */
+    label: string;
+    /** The `--conductor <name>` stem it was started from, if reported. */
+    conductorName: string | undefined;
+    /** The sideloaded machine's own label, or its host_key, or ''. */
+    machineLabel: string;
+    /** The linked project's uuid, or '' when unlinked — no project read here. */
+    projectLabel: string;
+    /** The `.gaia` dir it last registered from; '' when it never reported one. */
+    workspaceRoot: string;
+    lastPid: number | undefined;
+    status: ConductorStatus;
+    lastSeen: number;
+    currentLoad: number;
+    maxParallel: number;
+    /** THIS record's machine host_key, for the `mine` derivation. */
+    hostKey: string | undefined;
+}
+/** Read one conductor with its sideloaded machine, mapped to {@link ConductorDetail}. */
+export declare function loadConductorDetail(client: DropshClient, conductorId: string, nowSeconds: number): Promise<ConductorDetail>;
+/** What the store-cached read needs from the outside world. */
+interface ConductorDetailContext {
+    readonly store?: SessionStore;
+    readonly services?: {
+        client: DropshClient;
+    };
+}
+/**
+ * The store-cached single-entity read every tab of the conductor scope
+ * shares — one request per conductor per session, not one per tab.
+ */
+export declare function readConductorDetail(context: ConductorDetailContext, conductorId: string, nowSeconds?: number): Promise<ConductorDetail>;
+export {};

package/dist/src/Entity/conductor/Data/detail.js

@@ -0,0 +1,69 @@
+// The shared conductor read for the conductor detail scope. ONE cached
+// single-entity read (`include=machine`), so all four tabs share exactly one
+// header instead of each re-deriving it.
+import { toUnixSeconds } from '@gaia-ai/core';
+import { dataKey } from '../../../Data/session-store.js';
+import { deriveConductorStatus } from './liveness.js';
+const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
+const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+function singleRelId(raw, key) {
+    const data = raw.relationships?.[key]?.data;
+    if (!data || Array.isArray(data))
+        return null;
+    return data.id ?? null;
+}
+/** Read one conductor with its sideloaded machine, mapped to {@link ConductorDetail}. */
+export async function loadConductorDetail(client, conductorId, nowSeconds) {
+    const doc = (await client.get(`gaia_conductor/gaia_conductor/${conductorId}?include=machine`));
+    const raw = doc?.data ?? { id: conductorId };
+    const attrs = raw.attributes ?? {};
+    const machineId = singleRelId(raw, 'machine');
+    const machine = machineId
+        ? (doc.included ?? []).find((r) => r.id === machineId)
+        : undefined;
+    const machineAttrs = machine?.attributes ?? {};
+    const lastSeen = toUnixSeconds(attrs.last_seen) ?? 0;
+    const leaseExpiresAt = toUnixSeconds(attrs.lease_expires_at) ?? 0;
+    const hostKey = str(machineAttrs.host_key);
+    return {
+        id: raw.id ?? conductorId,
+        label: str(attrs.label) ??
+            str(attrs.conductor_id) ??
+            str(attrs.machine_id) ??
+            raw.id ??
+            conductorId,
+        conductorName: str(attrs.conductor_name),
+        machineLabel: str(machineAttrs.label) ?? hostKey ?? '',
+        projectLabel: singleRelId(raw, 'project_id') ?? '',
+        workspaceRoot: str(attrs.workspace_root) ?? '',
+        lastPid: num(attrs.last_pid),
+        status: deriveConductorStatus({
+            present: true,
+            status: str(attrs.status) ?? null,
+            lastSeen: lastSeen === 0 ? null : lastSeen,
+            leaseExpiresAt: leaseExpiresAt === 0 ? null : leaseExpiresAt,
+        }, nowSeconds),
+        lastSeen,
+        currentLoad: num(machineAttrs.current_load) ?? num(attrs.current_load) ?? 0,
+        maxParallel: num(machineAttrs.max_parallel) ?? num(attrs.max_parallel) ?? 0,
+        hostKey,
+    };
+}
+const conductorDetailKey = (id) => dataKey(`conductor/${id}`);
+/**
+ * The store-cached single-entity read every tab of the conductor scope
+ * shares — one request per conductor per session, not one per tab.
+ */
+export async function readConductorDetail(context, conductorId, nowSeconds = Math.floor(Date.now() / 1000)) {
+    if (!context.services)
+        throw new Error('Conductor detail requires services');
+    const key = conductorDetailKey(conductorId);
+    if (!context.store)
+        return loadConductorDetail(context.services.client, conductorId, nowSeconds);
+    const cached = context.store.get(key);
+    if (cached)
+        return cached;
+    const detail = await loadConductorDetail(context.services.client, conductorId, nowSeconds);
+    context.store.set(key, detail, ['detail']);
+    return detail;
+}

package/dist/src/Entity/conductor/Data/log-block.d.ts

@@ -0,0 +1,18 @@
+import type { ConductorDetail } from './detail.js';
+export interface ConductorLog {
+    readonly heading: string;
+    readonly lines: readonly string[];
+}
+/**
+ * Whether the log block should tail a real file — true only when the
+ * detail's own machine host_key matches THIS process's. An absent key on
+ * either side is never waved through as a match: an unproven identity is
+ * refused, the same rule the Conductors list's `mine` uses.
+ */
+export declare function isMine(detail: ConductorDetail, thisHostKey: string | undefined): boolean;
+/**
+ * The open row's log block: where it is, and its tail. A conductor on
+ * another machine has a workspace this machine cannot read, so the block
+ * states that instead of showing an empty tail.
+ */
+export declare function logBlockFor(detail: ConductorDetail, mine: boolean): ConductorLog;

package/dist/src/Entity/conductor/Data/log-block.js

@@ -0,0 +1,32 @@
+// The conductor log block: where it is, and its tail — the single home for
+// what was duplicated character for character in both Conductors screens.
+import { configHomeOf } from '@gaia-ai/core';
+import { tailConductorLog } from './log-tail.js';
+/**
+ * Whether the log block should tail a real file — true only when the
+ * detail's own machine host_key matches THIS process's. An absent key on
+ * either side is never waved through as a match: an unproven identity is
+ * refused, the same rule the Conductors list's `mine` uses.
+ */
+export function isMine(detail, thisHostKey) {
+    return (detail.hostKey !== undefined &&
+        thisHostKey !== undefined &&
+        detail.hostKey === thisHostKey);
+}
+/**
+ * The open row's log block: where it is, and its tail. A conductor on
+ * another machine has a workspace this machine cannot read, so the block
+ * states that instead of showing an empty tail.
+ */
+export function logBlockFor(detail, mine) {
+    const logPath = `${configHomeOf(detail.workspaceRoot)}/log.txt`;
+    return mine
+        ? {
+            heading: `log — ${logPath}`,
+            lines: tailConductorLog(logPath, { maxLines: 40 }).lines,
+        }
+        : {
+            heading: `log — ${detail.label} runs on another machine; no log here`,
+            lines: [],
+        };
+}

package/dist/src/Entity/conductor/Screen/conductor-log.d.ts

@@ -0,0 +1,36 @@
+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';
+interface LogView {
+    readonly label: string;
+    readonly heading: string;
+    readonly lines: readonly string[];
+}
+/** The tail of the selected conductor's log, or why there is none here. */
+export declare class ConductorLogScreen extends AsyncScreen<LogView> {
+    static readonly route: {
+        id: string;
+        path: string;
+        parent: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            weight: number;
+        };
+        fallback: {
+            routeId: string;
+        };
+    };
+    readonly id: string;
+    readonly frameId = "conductor";
+    protected load(context: ScreenContext): Promise<LogView>;
+    protected renderLoading(): string[];
+    protected renderReady(view: LogView): VNode;
+    protected chrome(): FullScreenChrome;
+    /** Nothing on this tab to act on. */
+    protected actions(): never[];
+    renderNonInteractive(): string[];
+}
+export {};

package/dist/src/Entity/conductor/Screen/conductor-log.js

@@ -0,0 +1,46 @@
+import { columnNode, textNode } from '../../../lib/vnode.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { readConductorDetail } from '../Data/detail.js';
+import { isMine, logBlockFor } from '../Data/log-block.js';
+import { createConductorProcessHost } from '../Data/process.js';
+import { conductorTitle } from './conductor-overview.js';
+/** The tail of the selected conductor's log, or why there is none here. */
+export class ConductorLogScreen extends AsyncScreen {
+    static route = {
+        id: 'conductor.log',
+        path: '/conductors/:conductorId/log',
+        parent: 'conductors',
+        tab: { id: 'log', label: 'Log', scope: 'conductor', weight: 40 },
+        fallback: { routeId: 'conductors' },
+    };
+    id = ConductorLogScreen.route.id;
+    frameId = 'conductor';
+    async load(context) {
+        const conductorId = context.params?.conductorId ?? '';
+        const detail = await readConductorDetail(context, conductorId);
+        const host = context.services?.conductorProcess ?? createConductorProcessHost();
+        const thisHostKey = await host.thisHostKey();
+        const block = logBlockFor(detail, isMine(detail, thisHostKey));
+        return { label: detail.label, ...block };
+    }
+    renderLoading() {
+        return ['Loading log…'];
+    }
+    renderReady(view) {
+        return columnNode('conductor-log', textNode({ id: 'conductor-log-heading', content: view.heading }), ...view.lines.map((line, index) => textNode({ id: `conductor-log-${index}`, content: line })));
+    }
+    chrome() {
+        return {
+            title: conductorTitle(this.readyValue ? { label: this.readyValue.label } : undefined),
+        };
+    }
+    /** Nothing on this tab to act on. */
+    actions() {
+        return [];
+    }
+    renderNonInteractive() {
+        return this.readyValue
+            ? [this.readyValue.heading, ...this.readyValue.lines]
+            : [];
+    }
+}

package/dist/src/Entity/conductor/Screen/conductor-overview.d.ts

@@ -0,0 +1,40 @@
+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 ConductorDetail } from '../Data/detail.js';
+/** `GAIA conductor — <label>` — the tab bar title every tab of the scope shares. */
+export declare function conductorTitle(detail: Pick<ConductorDetail, 'label'> | undefined): string;
+/**
+ * The label/value rows of the Overview tab — the single source both
+ * `renderReady` and `renderNonInteractive` draw from, so the piped output
+ * cannot drift from the drawn tree.
+ */
+export declare function conductorOverviewRows(detail: ConductorDetail, nowSeconds?: number): string[];
+/** Overview — the conductor detail scope's landing tab. */
+export declare class ConductorOverviewScreen extends AsyncScreen<ConductorDetail> {
+    static readonly route: {
+        id: string;
+        path: string;
+        pipe: "scope";
+        parent: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            weight: number;
+        };
+        fallback: {
+            routeId: string;
+        };
+    };
+    readonly id: string;
+    readonly frameId = "conductor";
+    protected load(context: ScreenContext): Promise<ConductorDetail>;
+    protected renderLoading(): string[];
+    protected renderReady(detail: ConductorDetail, context: ScreenContext): VNode;
+    protected chrome(): FullScreenChrome;
+    /** Read-only — nothing on this tab to act on. */
+    protected actions(): never[];
+    renderNonInteractive(context: ScreenContext): string[];
+}

package/dist/src/Entity/conductor/Screen/conductor-overview.js

@@ -0,0 +1,61 @@
+import { humanizeAge } from '../../../lib/format.js';
+import { columnNode, textNode } from '../../../lib/vnode.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { readConductorDetail } from '../Data/detail.js';
+/** `GAIA conductor — <label>` — the tab bar title every tab of the scope shares. */
+export function conductorTitle(detail) {
+    return `GAIA conductor — ${detail?.label ?? ''}`;
+}
+/**
+ * The label/value rows of the Overview tab — the single source both
+ * `renderReady` and `renderNonInteractive` draw from, so the piped output
+ * cannot drift from the drawn tree.
+ */
+export function conductorOverviewRows(detail, nowSeconds = Math.floor(Date.now() / 1000)) {
+    return [
+        `Status: ${detail.status} (${humanizeAge(detail.lastSeen || null, nowSeconds)})`,
+        `Machine: ${detail.machineLabel || '—'}`,
+        `Project: ${detail.projectLabel || '—'}`,
+        `Workspace: ${detail.workspaceRoot || '—'}`,
+        `PID: ${detail.lastPid ?? '-'}`,
+        // Stated explicitly as the machine's own budget, not the conductor's:
+        // several conductors can share one host's capacity.
+        `Load: ${detail.currentLoad}/${detail.maxParallel} (machine budget)`,
+    ];
+}
+/** Overview — the conductor detail scope's landing tab. */
+export class ConductorOverviewScreen extends AsyncScreen {
+    static route = {
+        id: 'conductor.overview',
+        path: '/conductors/:conductorId',
+        pipe: 'scope',
+        parent: 'conductors',
+        tab: { id: 'overview', label: 'Overview', scope: 'conductor', weight: 10 },
+        fallback: { routeId: 'conductors' },
+    };
+    id = ConductorOverviewScreen.route.id;
+    frameId = 'conductor';
+    load(context) {
+        return readConductorDetail(context, context.params?.conductorId ?? '', context.nowSeconds?.() ?? Math.floor(Date.now() / 1000));
+    }
+    renderLoading() {
+        return ['Loading conductor…'];
+    }
+    renderReady(detail, context) {
+        const nowSeconds = context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+        return columnNode('conductor-overview', ...conductorOverviewRows(detail, nowSeconds).map((line, index) => textNode({ id: `conductor-overview-${index}`, content: line })));
+    }
+    chrome() {
+        return { title: conductorTitle(this.readyValue) };
+    }
+    /** Read-only — nothing on this tab to act on. */
+    actions() {
+        return [];
+    }
+    renderNonInteractive(context) {
+        if (!this.readyValue)
+            return [];
+        const nowSeconds = context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+        return conductorOverviewRows(this.readyValue, nowSeconds);
+    }
+}

package/dist/src/Entity/conductor/Screen/conductor-runs.d.ts

@@ -0,0 +1,90 @@
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
+import { type Page } from '../../collection.js';
+import { type RunRow } from '../../run/Data/runs.js';
+/** Held work — the runs one conductor currently holds (claimed/running). */
+export declare class ConductorRunsScreen extends ListScreen<RunRow, number> {
+    static readonly route: {
+        id: string;
+        path: string;
+        parent: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            weight: number;
+        };
+        fallback: {
+            routeId: string;
+        };
+    };
+    readonly id: string;
+    readonly frameId = "conductor";
+    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: "title";
+            readonly label: "TITLE";
+            readonly width: 0;
+            readonly grow: 2;
+            readonly min: 24;
+            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: "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: "This conductor holds no run.";
+    };
+    protected tableContext(context: ScreenContext): number;
+    protected loadRows(context: ScreenContext, page: number): Promise<Page<RunRow>>;
+    protected renderLoading(): string[];
+    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;
+    /**
+     * The header title needs the shared conductor label. Loaded once here (the
+     * store-cached read is cheap on a repeat) rather than threading it through
+     * `loadRows`'s row type.
+     */
+    private headerDetail;
+    protected didLoad(_data: Page<RunRow>, context: ScreenContext): void;
+    reset(): void;
+    /**
+     * The pipe's own text — the SAME table + rows the drawn tree uses, through
+     * `listTableRows` rather than a second description (Task 8's anti-drift
+     * pattern).
+     */
+    renderNonInteractive(context: ScreenContext): string[];
+}

package/dist/src/Entity/conductor/Screen/conductor-runs.js

@@ -0,0 +1,128 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
+import { flattenSections } from '../../../Component/section-list/index.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import { listTableRows, loadPage } from '../../collection.js';
+import { LIST_PAGE_SIZE } from '../../cycle.js';
+import { buildConductorRunQueryParams } from '../../run/Data/query.js';
+import { CONDUCTOR_RUN_TABLE, mapRunData, } from '../../run/Data/runs.js';
+import { deriveRunStatus } from '../../run/Data/status.js';
+import { readConductorDetail } from '../Data/detail.js';
+import { conductorTitle } from './conductor-overview.js';
+/** Held work — the runs one conductor currently holds (claimed/running). */
+export class ConductorRunsScreen extends ListScreen {
+    static route = {
+        id: 'conductor.runs',
+        path: '/conductors/:conductorId/runs',
+        parent: 'conductors',
+        tab: { id: 'runs', label: 'Held work', scope: 'conductor', weight: 20 },
+        fallback: { routeId: 'conductors' },
+    };
+    id = ConductorRunsScreen.route.id;
+    frameId = 'conductor';
+    table = CONDUCTOR_RUN_TABLE;
+    tableContext(context) {
+        return context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+    }
+    loadRows(context, page) {
+        if (!context.services)
+            throw new Error('Held work requires services');
+        const conductorId = context.params?.conductorId ?? '';
+        const window = { offset: page * LIST_PAGE_SIZE, limit: LIST_PAGE_SIZE };
+        const params = buildConductorRunQueryParams(conductorId, {
+            size: window.limit,
+            index: page,
+        });
+        return loadPage(context.services.client, 'gaia_run/gaia_run', params, (data, included) => {
+            const ticketsById = new Map(included.filter((r) => r.id).map((r) => [r.id, r]));
+            return data.map((item) => mapRunData(item, ticketsById));
+        }, page, window);
+    }
+    renderLoading() {
+        return ['Loading held work…'];
+    }
+    chrome(context) {
+        const nowSeconds = this.tableContext(context);
+        const stale = this.rows.filter((row) => deriveRunStatus(row, nowSeconds) === 'stale').length;
+        return {
+            selectable: this.rows.length,
+            selectedIndex: this.selectedIndex,
+            rowIds: this.rowNodeIds,
+            title: conductorTitle(this.headerDetail),
+            meta: [
+                this.countLabel(),
+                ...(stale > 0 ? [`${stale} stale`] : []),
+                ...this.pagingSegments(),
+            ]
+                .filter(Boolean)
+                .join(' · '),
+        };
+    }
+    actions() {
+        return [
+            ...(this.rows.length > 0
+                ? [actionItem('conductor-runs-enter', 'Enter', 'ticket')]
+                : []),
+            actionItem('conductor-runs-tab', 'Tab', 'tabs'),
+            ...this.pagingActionItems(),
+        ];
+    }
+    activate(index, context) {
+        const ticketId = this.rows[index]?.ticketId;
+        if (!ticketId || !context.navigate)
+            return false;
+        context.navigate('ticket.runs', { ticketId });
+        return true;
+    }
+    select(index, context) {
+        if (index < 0 || index >= this.rows.length)
+            return false;
+        this.selectedIndex = index;
+        context.requestDraw();
+        return true;
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, 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 false;
+    }
+    /**
+     * The header title needs the shared conductor label. Loaded once here (the
+     * store-cached read is cheap on a repeat) rather than threading it through
+     * `loadRows`'s row type.
+     */
+    headerDetail;
+    didLoad(_data, context) {
+        const conductorId = context.params?.conductorId ?? '';
+        if (!conductorId || !context.services || this.headerDetail)
+            return;
+        void readConductorDetail(context, conductorId).then((detail) => {
+            this.headerDetail = detail;
+            context.requestDraw();
+        });
+    }
+    reset() {
+        this.resetList();
+        this.headerDetail = undefined;
+        super.reset();
+    }
+    /**
+     * The pipe's own text — the SAME table + rows the drawn tree uses, through
+     * `listTableRows` rather than a second description (Task 8's anti-drift
+     * pattern).
+     */
+    renderNonInteractive(context) {
+        const nowSeconds = this.tableContext(context);
+        return flattenSections([
+            {
+                heading: 'Held work',
+                lines: listTableRows(CONDUCTOR_RUN_TABLE, this.rows, nowSeconds),
+            },
+        ]).lines;
+    }
+}