@gaia-ai/addon-gaia-ui 0.7.0 → 0.8.0

package/dist/src/Agent/launch.d.ts

@@ -17,9 +17,9 @@ export declare function buildCreateLaunch(opts: {
     label?: string | undefined;
 }): CreateLaunch;
 /**
- * A short human label for the agent list: the description's first line (capped to 40
- * incl. the ellipsis), else "New <workflow>". GAIA-236 AC-8: it builds the `label`
- * `buildCreateLaunch` takes, so it belongs to the module that builds the launch
- * intent — moved from `Service/create-form.ts` unchanged.
+ * A short human label for the agent list: the ticket's title, else the
+ * description's first line (both capped to 40 incl. the ellipsis), else
+ * "New <workflow>". GAIA-236 AC-8: it builds the `label` `buildCreateLaunch`
+ * takes, so it belongs to the module that builds the launch intent.
  */
 export declare function shortName(payload: CreateFormPayload): string;

package/dist/src/Agent/launch.js

@@ -32,18 +32,25 @@ export function buildCreateLaunch(opts) {
     };
 }
 /**
- * A short human label for the agent list: the description's first line (capped to 40
- * incl. the ellipsis), else "New <workflow>". GAIA-236 AC-8: it builds the `label`
- * `buildCreateLaunch` takes, so it belongs to the module that builds the launch
- * intent — moved from `Service/create-form.ts` unchanged.
+ * A short human label for the agent list: the ticket's title, else the
+ * description's first line (both capped to 40 incl. the ellipsis), else
+ * "New <workflow>". GAIA-236 AC-8: it builds the `label` `buildCreateLaunch`
+ * takes, so it belongs to the module that builds the launch intent.
  */
 export function shortName(payload) {
+    // GAIA-309 D9: the title is what the operator NAMED the ticket, so it is the
+    // better tab label; the description's first line stays the fallback for a
+    // payload that has no title yet. This touches the launch intent's `label`
+    // ONLY — never `prompt`, never `env`, which is what AC-6 pins.
+    const cap = (line) => line.length > 40 ? `${line.slice(0, 39)}…` : line;
+    const title = payload.title.trim();
+    if (title)
+        return cap(title);
     const firstLine = payload.description
         .split('\n')
         .map((l) => l.trim())
         .find((l) => l.length > 0);
-    if (firstLine) {
-        return firstLine.length > 40 ? `${firstLine.slice(0, 39)}…` : firstLine;
-    }
+    if (firstLine)
+        return cap(firstLine);
     return `New ${payload.workflow?.label ?? 'ticket'}`;
 }

package/dist/src/Component/stats-panel/index.d.ts

@@ -36,14 +36,25 @@ export interface StatsPanelOptions {
      * components keep their boundary.
      */
     columns?: readonly string[] | undefined;
+    /**
+     * The group's name, printed in the header row's already-empty label field
+     * (GAIA-324 D4). A caller that renders several groups under one heading uses
+     * it to say which group each block of bars is.
+     *
+     * The component stays ENTITY-NEUTRAL: this is a string, and nothing here knows
+     * a ticket from a run. It is padded exactly like a data label, so the title,
+     * the labels beneath it and the column titles keep one geometry.
+     */
+    title?: string | undefined;
     /** What to render instead of rows when there are none (spec R7). */
     emptyMessage?: string | undefined;
 }
 /**
- * One block's body rows: an optional column header, then one row per entry.
+ * One block's body rows: an optional header row (the group's title, the column
+ * titles, or both), then one row per entry.
  *
  * Every column is measured with `displayWidth` (through `pad`/`padNumber`), so a
  * wide-character label cannot shift the numbers out of alignment — the failure
  * that makes a table of counts unreadable exactly when the data is interesting.
  */
-export declare function statsPanelRows(rows: readonly StatsPanelRow[], { columns, emptyMessage }?: StatsPanelOptions): string[];
+export declare function statsPanelRows(rows: readonly StatsPanelRow[], { columns, title, emptyMessage }?: StatsPanelOptions): string[];

package/dist/src/Component/stats-panel/index.js

@@ -31,12 +31,16 @@ export const BAR_WIDTH = 20;
 /**
  * The label column, in display columns: 26 for the text plus {@link LABEL_GAP}.
  *
- * The text budget is wide enough for the longest label the Dashboard actually
- * builds: a breakdown row suffixes its entity type (`gaia · tickets`), the
- * unattributed bucket's `— unattributed · tickets` is 24 columns and a real
- * project name reaches 26 (`gaia-e2e-project · tickets`). At 18 that suffix was
- * cut to `— unattributed · t…`, which silently made the two entity types
- * indistinguishable in exactly the row where attribution is already unclear.
+ * The text budget is what the field has to hold, and after GAIA-324 that is two
+ * different kinds of text sharing one column: a breakdown row's bare entity name
+ * (a real project name reaches 26 columns on its own — `gaia-e2e-project` plus a
+ * suffix used to; a long one still does), and the group TITLE printed in the
+ * header row's label field above it. Both are padded to the same field, which is
+ * what keeps a title, the labels it captions and the column titles on one
+ * geometry. Kept at 26 rather than narrowed with the `· tickets` suffix GAIA-324
+ * deleted: the budget was never sized for the suffix alone, and a project name
+ * cut to `a-very-long-project-…` is the same unreadable row the width exists to
+ * prevent.
  */
 const LABEL_WIDTH = 27;
 /**
@@ -44,16 +48,16 @@ const LABEL_WIDTH = 27;
  *
  * Load-bearing, not decoration. `pad` fills a label to exactly `LABEL_WIDTH`, so
  * a label of precisely that width left NO separator and the row rendered
- * `gaia-e2e-project · tickets████████` — a real project name, at exactly 26
- * columns. A truncated label collided the same way, ending in `…` against the
- * bar. Every fixture in the tests was shorter, which is why the suite was green
- * while the screen was wrong; the gap is part of the geometry now so the label
- * length cannot decide whether it exists.
+ * `gaia-e2e-project-name██████` — a real project name, at exactly 26 columns. A
+ * truncated label collided the same way, ending in `…` against the bar. Every
+ * fixture in the tests was shorter, which is why the suite was green while the
+ * screen was wrong; the gap is part of the geometry now so the label length
+ * cannot decide whether it exists.
  *
  * It is ADDED to the field rather than taken out of it: the 26 columns above are
  * a content budget with a stated reason, and spending one of them on the gap
- * would cut `gaia-e2e-project · tickets` to `gaia-e2e-project · ticke…` — losing
- * exactly the entity-type suffix that tells the two rows of a project apart.
+ * would truncate one more column off the longest names — the labels that are
+ * already hardest to tell apart.
  */
 const LABEL_GAP = 1;
 /** One number column, in display columns. */
@@ -81,24 +85,30 @@ function bar(value, max) {
     return BAR_FULL.repeat(filled) + BAR_EMPTY.repeat(BAR_WIDTH - filled);
 }
 /**
- * One block's body rows: an optional column header, then one row per entry.
+ * One block's body rows: an optional header row (the group's title, the column
+ * titles, or both), then one row per entry.
  *
  * Every column is measured with `displayWidth` (through `pad`/`padNumber`), so a
  * wide-character label cannot shift the numbers out of alignment — the failure
  * that makes a table of counts unreadable exactly when the data is interesting.
  */
-export function statsPanelRows(rows, { columns, emptyMessage } = {}) {
+export function statsPanelRows(rows, { columns, title, emptyMessage } = {}) {
     if (rows.length === 0) {
         return emptyMessage === undefined ? [] : [`${INDENT}${emptyMessage}`];
     }
     const barValue = (row) => row.numbers.at(-1) ?? 0;
     const max = Math.max(...rows.map(barValue));
     const out = [];
-    if (columns && columns.length > 0) {
+    if ((columns && columns.length > 0) || title !== undefined) {
         out.push(INDENT +
-            pad('', LABEL_WIDTH) +
+            // The SAME label geometry as a data row below (padded to the field width
+            // minus the gap, then the gap), so a group title sits exactly over the
+            // labels it captions. With no title this is the blank label field the
+            // header row always had, byte for byte.
+            pad(title ?? '', LABEL_WIDTH - LABEL_GAP) +
+            ' '.repeat(LABEL_GAP) +
             ' '.repeat(BAR_WIDTH) +
-            columns.map((c) => padNumber(c, NUMBER_WIDTH)).join(''));
+            (columns ?? []).map((c) => padNumber(c, NUMBER_WIDTH)).join(''));
     }
     for (const row of rows) {
         out.push(INDENT +

package/dist/src/Component/top-tabs/index.d.ts

@@ -10,6 +10,9 @@ export declare const ROOT_TABS: readonly [{
 }, {
     readonly id: "projects";
     readonly label: "Projects";
+}, {
+    readonly id: "conductors";
+    readonly label: "Conductors";
 }];
 /** The project level: the tabs of an opened project. */
 export declare const PROJECT_TABS: readonly [{
@@ -33,6 +36,9 @@ export declare const TAB_LEVELS: {
     }, {
         readonly id: "projects";
         readonly label: "Projects";
+    }, {
+        readonly id: "conductors";
+        readonly label: "Conductors";
     }];
     readonly project: readonly [{
         readonly id: "dashboard";

package/dist/src/Component/top-tabs/index.js

@@ -26,15 +26,23 @@ import { displayWidth } from '../../lib/width.js';
 // `topTabSpans(level, id)`, `tabBarFor(location)`, `TabIdOf<L>`). It was a
 // property of ONE function, the level-blind `locateTab`, which walked the levels
 // in key order and would now resolve the project level's `dashboard` to the ROOT
-// location. `gotoTopTab` was its only caller, and it only ever moves within one
+// location. Top-tab navigation was its only caller, and it only moves within one
 // level — the bar you Tab through or click IS the current level's bar — so it
 // pairs the target with `here.level` directly and `locateTab` is deleted.
 //
-// Only tabs that are actually navigable are listed. A planned screen (`Users` on
-// the root level, `Conductors` on the project level) arrives with its own ticket
-// and adds its entry here then — a tab drawn before its screen exists would
-// advertise navigation the operator cannot take, which is the very defect
-// GAIA-239 removes.
+// Only tabs that are actually navigable are listed. A planned screen (`Users`)
+// arrives with its own ticket and adds its entry here then — a tab drawn before
+// its screen exists would advertise navigation the operator cannot take, which
+// is the very defect GAIA-239 removes.
+//
+// GAIA-232 added `conductors`, and put it on the ROOT level although the note
+// above once reserved it for the project level. A conductor is an operator
+// concern: "is my conductor alive?" has to be answerable without first choosing
+// a project, and one conductor commonly serves work across a checkout rather
+// than sitting inside one project's screen. Which project it serves is a COLUMN
+// of that screen, not a navigation level above it. Being an ordinary entry here
+// is also what keeps it inside the derived id union and gives it GAIA-241's
+// click spans for free.
 //
 // `as const satisfies` is load-bearing on both halves: `satisfies` still
 // shape-checks every entry against `TopTab`, while `as const` keeps the literal
@@ -45,6 +53,7 @@ import { displayWidth } from '../../lib/width.js';
 export const ROOT_TABS = [
     { id: 'dashboard', label: 'Dashboard' },
     { id: 'projects', label: 'Projects' },
+    { id: 'conductors', label: 'Conductors' },
 ];
 /** The project level: the tabs of an opened project. */
 export const PROJECT_TABS = [

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

@@ -0,0 +1,98 @@
+import type { DropshClient, JsonApiResource } from '../types.js';
+/** A JSON:API collection document (the raw shape `client.get` returns). */
+export interface JsonApiCollectionDoc {
+    data?: JsonApiResource[];
+    included?: JsonApiResource[];
+    /**
+     * The document-level `meta`. GAIA-305 makes every `gaia_*` collection report its
+     * total here (`GaiaResourceType::includeCount()` -> TRUE, applied by
+     * `GaiaResourceTypeRepository::countsCollections()`); see {@link Page.total}.
+     *
+     * Optional and loosely typed on purpose: a control plane that predates GAIA-305
+     * answers either with no `meta` at all or with a `meta` carrying only `omitted`
+     * — both measured this session — and neither is an error.
+     */
+    meta?: {
+        count?: unknown;
+    };
+    /**
+     * JSON:API's own paging links. `next` is the ONLY valid end-of-list signal, and
+     * it stays so after GAIA-305: a page can simply BE the last one, and `next` is
+     * what says whether it is. `rows.length === limit` cannot answer that — a full
+     * page is exactly as consistent with "more follows" as with "that was all", and
+     * the run collection's last page is short for the ordinary reason that
+     * collections do not divide evenly.
+     *
+     * (GAIA-305 does retire the older reason given here — that access filtering
+     * emptied pages after `page[limit]` had bounded the query, so a SHORT page said
+     * nothing at all. Its query-level access filtering makes pages full again. The
+     * conclusion is unchanged; only the argument for it is.)
+     *
+     * Optional, because the three non-paged readers (the parent picker, the projects
+     * screen, the own-conductor lookup) read one bounded bag and never page.
+     */
+    links?: {
+        next?: unknown;
+    };
+}
+/**
+ * The window a paged read ASKED the server for: the request's own `page[offset]`
+ * and `page[limit]` (GAIA-312 D3).
+ *
+ * A fact about the REQUEST, never an inference about the pages before it. Both
+ * list queries send `page[limit]=size` and `page[offset]=index * size`
+ * (`Entity/*​/Data/query.ts`), and since GAIA-305 the server skips and counts the
+ * same access-filtered collection — which is what lets a screen turn an offset
+ * into a position at all.
+ */
+export interface PageWindow {
+    /** Rows of the collection the request told the server to skip. */
+    offset: number;
+    /** Rows the request told the server to return at most. */
+    limit: number;
+}
+/**
+ * One page of rows plus everything the screen states about it.
+ *
+ * Carried together so a `hasNext`, a page number or a total cannot go stale beside
+ * fresh rows (GAIA-292 D4/D4a).
+ */
+export interface Page<Row> {
+    rows: Row[];
+    hasNext: boolean;
+    /** The page these rows CAME FROM, not the one most recently requested. */
+    page: number;
+    /**
+     * The size of the filtered collection as the SERVER reported it, or null when it
+     * reported none (GAIA-292 D6e).
+     *
+     * It rides the page response's `meta.count`, so it costs no read of its own and
+     * cannot describe a different collection than the rows beside it: the server
+     * applied one query and answered both from it. That is why the earlier background
+     * walk — 28 sequential reads for the open-run collection — is gone rather than
+     * kept as a fallback.
+     *
+     * A number renders as `20 of 107 ticket(s)`; `null` renders as `20 of ?
+     * ticket(s)` (D6d), which is a visible statement that this control plane reports
+     * no total — never a number nobody established.
+     */
+    total: number | null;
+    /**
+     * The window these rows were read with, or `null` when they no longer fill a
+     * window that positions them (GAIA-312 D3/D4).
+     *
+     * Required and explicitly nullable, exactly like {@link Page.total}: "not
+     * established" occupies the field's own place instead of being spelled by an
+     * absent key. `null` means the screen states a row COUNT; a window means it may
+     * state a RANGE, under the test in `ListScreen.countLabel`.
+     */
+    window: PageWindow | null;
+}
+/**
+ * Read one page of a collection and map it to rows.
+ *
+ * `mapRows` receives `data` AND `included` so each slice keeps its own sideload
+ * indexing — the ticket list indexes every include by id, the run list builds a
+ * ticket-only map — without this function knowing either.
+ */
+export declare function loadPage<Row>(client: DropshClient, path: string, params: unknown, mapRows: (data: JsonApiResource[], included: JsonApiResource[]) => Row[], page: number, window: PageWindow): Promise<Page<Row>>;

package/dist/src/Entity/collection.js

@@ -0,0 +1,46 @@
+// The ONE JSON:API collection-document shape and the ONE page read (GAIA-294).
+//
+// Slice-less on purpose, directly under `Entity/` beside `transport.ts`,
+// `count.ts` and `cycle.ts`. That is the only placement every slice's `Data/` may
+// import: `tests/boundary.test.ts` G2 forbids a data module from reaching another
+// slice, and its `sliceOf` returns undefined for a file sitting here, so these
+// edges are not cross-slice ones.
+//
+// Before this file the document was declared FIVE times — in ticket/Data/tickets,
+// run/Data/runs, ticket/Data/parents, project/Data/projects and
+// conductor/Data/own-conductor — and only the first two carried `links.next`. Same
+// name, different shapes: the drift GAIA-292's "mirroring Task 3 exactly so the
+// two lists cannot drift" was meant to prevent had already happened.
+/**
+ * The collection total a document reports, or null when it reports none.
+ *
+ * Defensive by contract rather than by suspicion: this value is rendered to the
+ * operator as a total, so anything that is not a usable count must become the
+ * explicit unknown instead of a guess (AC 8.5). A count that is absent, not a
+ * number, not finite, or negative is no count.
+ */
+function readTotal(doc) {
+    const count = doc?.meta?.count;
+    if (typeof count !== 'number')
+        return null;
+    if (!Number.isFinite(count) || count < 0)
+        return null;
+    return count;
+}
+/**
+ * Read one page of a collection and map it to rows.
+ *
+ * `mapRows` receives `data` AND `included` so each slice keeps its own sideload
+ * indexing — the ticket list indexes every include by id, the run list builds a
+ * ticket-only map — without this function knowing either.
+ */
+export async function loadPage(client, path, params, mapRows, page, window) {
+    const doc = (await client.get(path, params));
+    return {
+        rows: mapRows(doc?.data ?? [], doc?.included ?? []),
+        hasNext: Boolean(doc?.links?.next),
+        page,
+        total: readTotal(doc),
+        window,
+    };
+}

package/dist/src/Entity/conductor/Component/conductor-list/index.d.ts

@@ -0,0 +1,25 @@
+/** The minimum shape a conductor row needs to render. */
+export interface ConductorRowInput {
+    label: string;
+    machineId: string | undefined;
+    project: string;
+    derivedStatus: string;
+    ageLabel: string;
+    workspaceRoot: string;
+    lastPid: number | undefined;
+    /** Whether this conductor's workspace exists on THIS machine. */
+    isLocal: boolean;
+    /** Whether an action on this row is in flight. */
+    busy: boolean;
+}
+/**
+ * One line per conductor: who, where, alive, since when, and its process.
+ *
+ * A non-local row is marked rather than hidden. The control plane is
+ * user-scoped, not machine-scoped, so a user's other machines' conductors are
+ * legitimately in this list — and silently dropping them would make the cockpit
+ * disagree with `gaia conductor ls` for no visible reason. Marking them says
+ * why their actions are inert here: a pid from another machine means nothing on
+ * this one.
+ */
+export declare function conductorRows(conductors: ConductorRowInput[]): string[];

package/dist/src/Entity/conductor/Component/conductor-list/index.js

@@ -0,0 +1,60 @@
+import { pad } from '../../../../lib/format.js';
+/** How much width the workspace column gets before it is elided. */
+const PATH_WIDTH = 30;
+/**
+ * How much width the machine_id column gets before it is elided.
+ *
+ * A `machine_id` is COMPOSED (`${user_id}-${machine_id}-${project}`), so on a
+ * user-scoped control plane every row repeats the same uuid at the head. It is
+ * therefore elided from the left like the path: the tail is the only part that
+ * tells one conductor from another.
+ */
+const MACHINE_ID_WIDTH = 20;
+/**
+ * One line per conductor: who, where, alive, since when, and its process.
+ *
+ * A non-local row is marked rather than hidden. The control plane is
+ * user-scoped, not machine-scoped, so a user's other machines' conductors are
+ * legitimately in this list — and silently dropping them would make the cockpit
+ * disagree with `gaia conductor ls` for no visible reason. Marking them says
+ * why their actions are inert here: a pid from another machine means nothing on
+ * this one.
+ */
+export function conductorRows(conductors) {
+    if (conductors.length === 0)
+        return ['No conductors on this control plane.'];
+    return conductors.map((c) => {
+        const name = c.label !== '' ? c.label : (c.machineId ?? '');
+        const pid = c.lastPid === undefined ? '-' : String(c.lastPid);
+        const marks = [c.busy ? '…' : '', c.isLocal ? '' : 'elsewhere']
+            .filter((m) => m !== '')
+            .join(' ');
+        return [
+            pad(name, 20),
+            // Its OWN column, not merely the label's fallback (AC-1, spec D2): two
+            // conductors of one repo share a project and a workspace_root, and the
+            // machine_id is the only thing that separates them.
+            pad(elideLeft(c.machineId ?? '', MACHINE_ID_WIDTH), MACHINE_ID_WIDTH),
+            pad(c.project, 14),
+            pad(c.derivedStatus, 9),
+            pad(c.ageLabel, 8),
+            pad(elideLeft(c.workspaceRoot, PATH_WIDTH), PATH_WIDTH),
+            pad(pid, 7),
+            marks,
+        ]
+            .join(' ')
+            .trimEnd();
+    });
+}
+/**
+ * Shorten a path from the LEFT, keeping its end.
+ *
+ * Conductor workspaces share a long common head (`/home/<user>/projects/…`) and
+ * differ at the tail, which is also the part that identifies the checkout.
+ * Eliding the right would leave every row looking identical.
+ */
+function elideLeft(path, width) {
+    if (path.length <= width)
+        return path;
+    return `…${path.slice(path.length - (width - 1))}`;
+}

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

@@ -1,5 +1,6 @@
 import type { DropshClient } from '../../../types.js';
 import { type ListOutcome, type OptionClients } from '../../transport.js';
+import { type ConductorStatus } from './liveness.js';
 /** One conductor of the control plane, as this renderer needs it. */
 export interface Conductor {
     id: string;
@@ -26,3 +27,59 @@ export declare const listConductors: (client: DropshClient) => Promise<ListOutco
  * and `pm` sees the FULL conductor set where `session` sees a subset.
  */
 export declare const listConductorsPreferringWrite: (clients: OptionClients) => Promise<Conductor[]>;
+/** A conductor as the Conductors screen renders it. */
+export interface ConductorRow extends Conductor {
+    /** The `.gaia` dir it last registered from; '' when it never reported one. */
+    workspaceRoot: string;
+    /** Unix seconds of the last heartbeat; 0 when it never reported one. */
+    lastSeen: number;
+    /** Unix seconds the lease runs out; 0 when unset. */
+    leaseExpiresAt: number;
+    currentLoad: number;
+    maxParallel: number;
+    /** The pid its serve loop last reported, if any. */
+    lastPid: number | undefined;
+    /** The config stem it was started from, as `--conductor <name>` takes it. */
+    conductorName: string | undefined;
+    /** Liveness, derived — never the raw `status`. */
+    derivedStatus: ConductorStatus;
+    /**
+     * Whether this conductor's workspace exists on THIS machine.
+     *
+     * The control plane is user-scoped, not machine-scoped, so a user's other
+     * machines' conductors appear in this list. They are shown rather than hidden
+     * — filtering by machine_id would mean substring-matching a composed string —
+     * but only a local row can be started or stopped from here, because a pid
+     * from another machine means nothing on this one.
+     */
+    isLocal: boolean;
+}
+/** What the row projection needs from the outside world, injected for tests. */
+export interface ConductorRowContext {
+    /** Unix seconds; the liveness derivation's clock. */
+    now: number;
+    /** Whether a path exists on this machine. */
+    exists: (path: string) => boolean;
+}
+/**
+ * The conductor collection as cockpit rows, in server order.
+ *
+ * Swallows a read failure into an empty list on purpose: the Conductors screen
+ * re-reads every 5 s, so one failed poll must leave the screen navigable rather
+ * than replace it with an error.
+ */
+export declare const listConductorRows: (client: DropshClient, ctx: ConductorRowContext) => Promise<ConductorRow[]>;
+/**
+ * Project uuid → name, for the Conductors screen's project column.
+ *
+ * A conductor references its project by uuid; the screen shows the name. This
+ * is a separate small read rather than a widened `ProjectRow`, because
+ * `loadProjectRows` builds the PROJECTS screen (one row per project, derived
+ * from conductors) and adding an id to it would change a shape four screens
+ * depend on to serve one column.
+ *
+ * A failed read yields an empty map: an unnamed project renders blank, which is
+ * better than a screen that refuses to list conductors because their projects
+ * could not be resolved.
+ */
+export declare const listProjectNames: (client: DropshClient) => Promise<Map<string, string>>;

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

@@ -1,4 +1,11 @@
+// GAIA-236 — the CONDUCTOR data service. It returns CONDUCTORS and knows nothing
+// about forms: no `Option`, no project filter, no `(status)` in a label. Those are
+// one popup's rules and live with that popup's adapter (`edit-form-data.ts`); a
+// service that applied them would be unusable for any other purpose. The two read
+// strategies are both just reading, so both live here.
+import { toUnixSeconds } from '@gaia-ai/core';
 import { listOutcome, listPreferringWrite, } from '../../transport.js';
+import { deriveConductorStatus } from './liveness.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const toConductor = (r) => ({
     id: r.id,
@@ -21,3 +28,63 @@ export const listConductors = (client) => listOutcome(client, 'gaia_conductor',
  * and `pm` sees the FULL conductor set where `session` sees a subset.
  */
 export const listConductorsPreferringWrite = (clients) => listPreferringWrite(clients, 'gaia_conductor', toConductor);
+const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+const toConductorRow = (r, ctx) => {
+    const workspaceRoot = str(r.attr('workspace_root')) ?? '';
+    // ISO-8601 over the wire, not the unix integer the field name implies — a
+    // `typeof === 'number'` guard here is what made a live conductor read `stale`.
+    const lastSeen = toUnixSeconds(r.attr('last_seen')) ?? 0;
+    const leaseExpiresAt = toUnixSeconds(r.attr('lease_expires_at')) ?? 0;
+    return {
+        ...toConductor(r),
+        workspaceRoot,
+        lastSeen,
+        leaseExpiresAt,
+        currentLoad: num(r.attr('current_load')) ?? 0,
+        maxParallel: num(r.attr('max_parallel')) ?? 0,
+        lastPid: num(r.attr('last_pid')),
+        conductorName: str(r.attr('conductor_name')),
+        // `present: true` because the row IS a control-plane record — which is why
+        // `registry-only` can never come out of this screen.
+        derivedStatus: deriveConductorStatus({
+            present: true,
+            status: str(r.attr('status')) ?? null,
+            lastSeen: lastSeen === 0 ? null : lastSeen,
+            leaseExpiresAt: leaseExpiresAt === 0 ? null : leaseExpiresAt,
+        }, ctx.now),
+        // A conductor that never reported a workspace cannot be local, whatever the
+        // filesystem would say about an empty path.
+        isLocal: workspaceRoot !== '' && ctx.exists(workspaceRoot),
+    };
+};
+/**
+ * The conductor collection as cockpit rows, in server order.
+ *
+ * Swallows a read failure into an empty list on purpose: the Conductors screen
+ * re-reads every 5 s, so one failed poll must leave the screen navigable rather
+ * than replace it with an error.
+ */
+export const listConductorRows = async (client, ctx) => {
+    const outcome = await listOutcome(client, 'gaia_conductor', (r) => toConductorRow(r, ctx));
+    return outcome.rows;
+};
+/**
+ * Project uuid → name, for the Conductors screen's project column.
+ *
+ * A conductor references its project by uuid; the screen shows the name. This
+ * is a separate small read rather than a widened `ProjectRow`, because
+ * `loadProjectRows` builds the PROJECTS screen (one row per project, derived
+ * from conductors) and adding an id to it would change a shape four screens
+ * depend on to serve one column.
+ *
+ * A failed read yields an empty map: an unnamed project renders blank, which is
+ * better than a screen that refuses to list conductors because their projects
+ * could not be resolved.
+ */
+export const listProjectNames = async (client) => {
+    const outcome = await listOutcome(client, 'gaia_project', (r) => ({
+        id: r.id,
+        name: str(r.attr('name')) ?? str(r.attr('label')) ?? '',
+    }));
+    return new Map(outcome.rows.map((p) => [p.id, p.name]));
+};

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

@@ -1,5 +1,6 @@
+import { type ConductorLiveness } from '@gaia-ai/core';
 /** The derived liveness state of a conductor. */
-export type ConductorStatus = 'running' | 'stale' | 'offline' | 'registry-only';
+export type ConductorStatus = ConductorLiveness | 'registry-only';
 /** The raw liveness inputs derived from a `gaia_conductor` record. */
 export interface ConductorInput {
     present?: boolean;

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

@@ -1,23 +1,19 @@
-// Conductor liveness derivation. Mirrors the server-side ConductorDeriver
+// Conductor liveness derivation.
+//
+// The rule itself lives in `@gaia-ai/core` (`deriveConductorLiveness`) so the
+// CLI listing, this cockpit and the server-side ConductorDeriver
 // (web/modules/custom/gaia_core/modules/gaia_dashboard/src/Dashboard/ConductorDeriver.php)
-// and the CLI `classify()` in gaia-cli/conductor/src/commands/conductor.ts:
-// no gaia_conductor record → registry-only; status 'offline' → offline; else
-// stale when last_seen older than 600s OR the lease has expired; else running.
-const STALE_WINDOW_SECONDS = 600;
+// cannot drift into describing one conductor three ways. What stays here is the
+// one thing core cannot answer: whether a gaia_conductor record exists at all.
+import { deriveConductorLiveness } from '@gaia-ai/core';
 export function deriveConductorStatus(conductor, nowSeconds) {
+    // `registry-only` means "something names this conductor but the control plane
+    // has no record of it". The Conductors screen reads the control plane itself,
+    // so every row it builds is present by construction and this branch cannot
+    // fire there; it remains for callers that join a record against another list.
     if (!conductor?.present)
         return 'registry-only';
-    if (conductor.status === 'offline')
-        return 'offline';
-    if (conductor.lastSeen == null)
-        return 'stale';
-    if (nowSeconds - conductor.lastSeen > STALE_WINDOW_SECONDS)
-        return 'stale';
-    if (conductor.leaseExpiresAt != null &&
-        conductor.leaseExpiresAt < nowSeconds) {
-        return 'stale';
-    }
-    return 'running';
+    return deriveConductorLiveness(conductor, nowSeconds);
 }
 // `humanizeAge` moved to `lib/format.ts` (GAIA-236, entity-slice Phase 0): it is a
 // generic relative-time formatter with no conductor vocabulary, and keeping it here