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

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,218 @@ 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 a conductor ROW cannot know on its own, handed to the columns per frame. */
+export interface ConductorListContext {
+    /** The clock the AGE column reads — one `now` for the whole frame. */
+    readonly nowSeconds: number;
+    /** The conductors with an action in flight, so a second keypress reads as
+     *  visibly redundant. */
+    readonly busyIds: ReadonlySet<string>;
+    /** Project uuid → name, from the screen's own small read. */
+    readonly projectNames: ReadonlyMap<string, string>;
+}
+/**
+ * The conductors list, declared once (GAIA-345 D2/D10) — its eight columns, the
+ * noun every one of its node ids is prefixed with, and what it says when it is
+ * empty.
+ *
+ * It GAINED A HEADER with this ticket (D6). This is the list a header earns its
+ * keep in most: eight columns of ids, paths and numbers are not self-describing
+ * the way three named ones were. The consequence is stated because it is a
+ * behaviour change — the list grows one row at the top and its selection
+ * highlight moves down one physical row. Nothing computes that offset:
+ * selection is a node attribute and the cursor is found through `rowIds`, both
+ * of which GAIA-340 made position-free.
+ *
+ * `fields` names what each column is built from, as everywhere. This loader
+ * reads the whole `gaia_conductor` collection with no sparse fieldset, so there
+ * is no `AssertExhaustive` proof binding these — declaring them anyway keeps
+ * that a fact about this loader rather than a hole in the column model.
+ *
+ * WHICH COLUMNS GROW, AND WHY THOSE TWO. The rule is the operator's and it is
+ * about the CONTENT: a free-text column grows. `NAME` and `PROJECT` are the two
+ * here — a conductor's label and a project's name are operator-written prose
+ * with no vocabulary and no shared head, so both benefit from a surplus and
+ * neither loses anything to Yoga's right-hand cut. They SHARE it through
+ * `grow`, which is what the mechanism exists for, and the shares are 2 : 1 in
+ * `NAME`'s favour: the label is the row's identity and the column an operator
+ * reads first, while the project name is a secondary attribute that repeats
+ * across every row of one project. `PROJECT` keeps its 14 as its BASIS rather
+ * than as a bound, so a narrow terminal leaves it exactly the columns it had
+ * before this ticket and a wide one hands it a share.
+ *
+ * The other six do not grow, and each for its own reason. `MACHINE` and
+ * `WORKSPACE` are free text too, and are the ONE exception to the rule: they
+ * are elided from the LEFT (see {@link elideLeft}), which needs a declared
+ * width to cut against and keeps the distinguishing tail — a grower would hand
+ * the cut back to the renderer's right-hand clip and lose exactly what that
+ * elision preserves. `STATUS`, `AGE` and `PID` are closed vocabularies that
+ * cannot use a surplus at all. `MARKS` is a closed vocabulary too and keeps a
+ * real budget for a measured reason: `width: 0, grow: 0` collapses it to zero
+ * columns and the mark vanishes.
+ */
+export declare const CONDUCTOR_TABLE: {
+    readonly noun: "conductor";
+    readonly emptyMessage: "No conductors on this control plane.";
+    readonly columns: readonly [{
+        /**
+         * A GROWER — free text, right-truncated, and the column an operator reads
+         * first. Declared FIRST and growing all the same: `flexGrow` is a
+         * property of the cell, not of its position in the row (measured, spec
+         * R2). Its `grow: 2` against `PROJECT`'s 1 is the identity column's larger
+         * claim on the surplus, argued above.
+         *
+         * `min: 20` is the ONE floor on this list, and it is preservation rather
+         * than invention: 20 is the budget this column has carried since
+         * GAIA-232, and without it a narrow terminal squeezes the grower to
+         * nothing while seven fixed budgets keep theirs — measured at 80 columns,
+         * NAME came out ONE column wide and the label read `c…`. The other seven
+         * columns need 106 columns between them, so below ~126 the row runs past
+         * the right edge and the renderer clips it there. That is exactly what
+         * this list did before this ticket, at every width; the floor keeps the
+         * narrow case as it was and lets the wide case improve.
+         */
+        readonly key: "name";
+        readonly label: "NAME";
+        readonly width: 0;
+        readonly min: 20;
+        readonly grow: 2;
+        readonly fields: readonly ["label", "machine_id"];
+        readonly get: (row: ConductorRow) => string;
+    }, {
+        readonly key: "machine";
+        readonly label: "MACHINE";
+        readonly width: 20;
+        readonly fields: readonly ["machine_id"];
+        readonly get: (row: ConductorRow) => string;
+    }, {
+        /**
+         * A project NAME, so free text, so a GROWER — the operator's correction to
+         * Task 6, which shipped this column fixed at 14 and named the cut an
+         * accepted residual. Measured at 160 columns with that configuration: 15
+         * columns unused at the right edge while an ordinary project name was cut
+         * to `keytec-gaia-p…`, which is finding 3 of this very ticket reproduced
+         * one column further left.
+         *
+         * The 14 stays as the flex BASIS, not as a bound: it is what the column
+         * starts from and what a terminal too narrow to give anything leaves it,
+         * so the narrow case is unchanged and only the wide one improves. No
+         * `min`, deliberately — without one the cell keeps `flexShrink: 0` and an
+         * overflowing row takes its columns from `NAME`, whose `min: 20` is the
+         * floor this list has always had.
+         */
+        readonly key: "project";
+        readonly label: "PROJECT";
+        readonly width: 14;
+        readonly grow: 1;
+        readonly fields: readonly ["project_id"];
+        readonly get: (row: ConductorRow, ctx: ConductorListContext) => string;
+    }, {
+        /** A CLOSED VOCABULARY. `ConductorStatus`'s reachable members here are
+         *  `running | stale | offline` — this screen can never produce
+         *  `registry-only`, because every row IS a control-plane record — whose
+         *  longest is 7, so 9 shows each of them whole. */
+        readonly key: "status";
+        readonly label: "STATUS";
+        readonly width: 9;
+        readonly fields: readonly ["status", "lease_expires_at", "last_seen"];
+        readonly get: (row: ConductorRow) => ConductorStatus;
+    }, {
+        /** `humanizeAge`'s own vocabulary, exactly as on the projects list: `—`,
+         *  `just now`, `<n>m|h|d ago`. 8 is the longest of them. */
+        readonly key: "age";
+        readonly label: "AGE";
+        readonly width: 8;
+        readonly fields: readonly ["last_seen"];
+        readonly get: (row: ConductorRow, ctx: ConductorListContext) => string;
+    }, {
+        readonly key: "workspace";
+        readonly label: "WORKSPACE";
+        readonly width: 24;
+        readonly fields: readonly ["workspace_root"];
+        readonly get: (row: ConductorRow) => string;
+    }, {
+        /** A pid is at most 7 digits — Linux's `pid_max` ceiling is 4 194 304 —
+         *  and a conductor that never reported one shows `-` rather than a
+         *  fabricated number. */
+        readonly key: "pid";
+        readonly label: "PID";
+        readonly width: 7;
+        readonly fields: readonly ["last_pid"];
+        readonly get: (row: ConductorRow) => string;
+    }, {
+        /**
+         * A closed vocabulary too, which is why it takes a budget instead of the
+         * trailing slot it used to hold: everything it can say is `…`,
+         * `elsewhere` or both, and 11 is `… elsewhere`.
+         *
+         * A non-local conductor 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. The mark says why their actions are inert here: a pid from
+         * another machine means nothing on this one.
+         */
+        readonly key: "marks";
+        readonly label: "MARKS";
+        readonly width: 11;
+        readonly fields: readonly ["workspace_root"];
+        readonly get: (row: ConductorRow, ctx: ConductorListContext) => string;
+    }];
+};
+/** 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,12 @@
+// 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 { humanizeAge } from '../../../lib/format.js';
 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 +29,275 @@ 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);
+/**
+ * Shorten a value from the LEFT, keeping its end — and the ONE exception to
+ * this ticket's "free text grows" rule (GAIA-345 D10).
+ *
+ * A CONTENT decision, which is why it is a cell accessor and not a layout
+ * member: a cell's `truncate` can only drop the RIGHT, and both values it is
+ * applied to carry their distinguishing part in the TAIL. A composed
+ * `machine_id` is `${user_id}-${machine_id}-${project}`, so every row of a
+ * user-scoped control plane repeats the same user uuid at the head; conductor
+ * workspaces all share `/home/<user>/projects/…`. Eliding the right would leave
+ * every row looking identical.
+ *
+ * THAT IS WHY `MACHINE` AND `WORKSPACE` KEEP FIXED BUDGETS while `NAME` grows.
+ * Making either a grower would hand its cut back to the renderer's
+ * right-truncation — head kept, tail dropped — which is strictly worse than
+ * today and loses the exact information this function exists to preserve. A
+ * grower also declares no width for this to cut against: `elideLeft` marks its
+ * cut with a leading `…` precisely because it is told, in advance, how many
+ * columns it has.
+ */
+const elideLeft = (value, width) => value.length <= width ? value : `…${value.slice(value.length - (width - 1))}`;
+/** How much width the machine_id column gets before {@link elideLeft} cuts it. */
+const MACHINE_ID_WIDTH = 20;
+/**
+ * The same, for the workspace path column — and the column that PAYS for this
+ * list fitting the cockpit's own default terminal.
+ *
+ * 30 made the row want 126 columns (NAME's floor 20, MACHINE 20, PROJECT 14,
+ * STATUS 9, AGE 8, WORKSPACE 30, PID 7, MARKS 11, plus seven separators) while
+ * `gaia ui` opens at 120, so the terminal cut the LAST column: measured on a
+ * real pty, the header ended `PID     MAR` and a non-local conductor's
+ * `elsewhere` came out `elsew`. 24 brings the row to exactly 120.
+ *
+ * WHY THIS COLUMN GIVES THE SIX. `WORKSPACE` is the only column in the row whose
+ * cut is free: it is elided from the LEFT, so it loses six columns of the HEAD —
+ * the `/home/<user>/projects/…` prefix every conductor workspace on a machine
+ * shares — and keeps the distinguishing tail either way. Every other column
+ * would pay in information: `MACHINE` elides left too but is already the
+ * narrower of the pair, the three closed vocabularies are sized to their own
+ * longest member, and `NAME`/`PROJECT` are the growers this ticket widened.
+ *
+ * A DECLARED BUDGET, never a measurement (spec D4). 24 is not the width of
+ * anyone's path — no page's data is consulted to arrive at it, so the columns do
+ * not move when the list does. It is shared by the column's `width` and by the
+ * {@link elideLeft} its accessor applies for exactly that reason: two numbers
+ * could drift, and a marker cut at one width inside a cell laid out at another
+ * is the defect the single constant makes unspellable.
+ */
+const PATH_WIDTH = 24;
+/**
+ * The conductors list, declared once (GAIA-345 D2/D10) — its eight columns, the
+ * noun every one of its node ids is prefixed with, and what it says when it is
+ * empty.
+ *
+ * It GAINED A HEADER with this ticket (D6). This is the list a header earns its
+ * keep in most: eight columns of ids, paths and numbers are not self-describing
+ * the way three named ones were. The consequence is stated because it is a
+ * behaviour change — the list grows one row at the top and its selection
+ * highlight moves down one physical row. Nothing computes that offset:
+ * selection is a node attribute and the cursor is found through `rowIds`, both
+ * of which GAIA-340 made position-free.
+ *
+ * `fields` names what each column is built from, as everywhere. This loader
+ * reads the whole `gaia_conductor` collection with no sparse fieldset, so there
+ * is no `AssertExhaustive` proof binding these — declaring them anyway keeps
+ * that a fact about this loader rather than a hole in the column model.
+ *
+ * WHICH COLUMNS GROW, AND WHY THOSE TWO. The rule is the operator's and it is
+ * about the CONTENT: a free-text column grows. `NAME` and `PROJECT` are the two
+ * here — a conductor's label and a project's name are operator-written prose
+ * with no vocabulary and no shared head, so both benefit from a surplus and
+ * neither loses anything to Yoga's right-hand cut. They SHARE it through
+ * `grow`, which is what the mechanism exists for, and the shares are 2 : 1 in
+ * `NAME`'s favour: the label is the row's identity and the column an operator
+ * reads first, while the project name is a secondary attribute that repeats
+ * across every row of one project. `PROJECT` keeps its 14 as its BASIS rather
+ * than as a bound, so a narrow terminal leaves it exactly the columns it had
+ * before this ticket and a wide one hands it a share.
+ *
+ * The other six do not grow, and each for its own reason. `MACHINE` and
+ * `WORKSPACE` are free text too, and are the ONE exception to the rule: they
+ * are elided from the LEFT (see {@link elideLeft}), which needs a declared
+ * width to cut against and keeps the distinguishing tail — a grower would hand
+ * the cut back to the renderer's right-hand clip and lose exactly what that
+ * elision preserves. `STATUS`, `AGE` and `PID` are closed vocabularies that
+ * cannot use a surplus at all. `MARKS` is a closed vocabulary too and keeps a
+ * real budget for a measured reason: `width: 0, grow: 0` collapses it to zero
+ * columns and the mark vanishes.
+ */
+export const CONDUCTOR_TABLE = {
+    noun: 'conductor',
+    emptyMessage: 'No conductors on this control plane.',
+    columns: [
+        {
+            /**
+             * A GROWER — free text, right-truncated, and the column an operator reads
+             * first. Declared FIRST and growing all the same: `flexGrow` is a
+             * property of the cell, not of its position in the row (measured, spec
+             * R2). Its `grow: 2` against `PROJECT`'s 1 is the identity column's larger
+             * claim on the surplus, argued above.
+             *
+             * `min: 20` is the ONE floor on this list, and it is preservation rather
+             * than invention: 20 is the budget this column has carried since
+             * GAIA-232, and without it a narrow terminal squeezes the grower to
+             * nothing while seven fixed budgets keep theirs — measured at 80 columns,
+             * NAME came out ONE column wide and the label read `c…`. The other seven
+             * columns need 106 columns between them, so below ~126 the row runs past
+             * the right edge and the renderer clips it there. That is exactly what
+             * this list did before this ticket, at every width; the floor keeps the
+             * narrow case as it was and lets the wide case improve.
+             */
+            key: 'name',
+            label: 'NAME',
+            width: 0,
+            min: 20,
+            grow: 2,
+            fields: ['label', 'machine_id'],
+            get: (row) => row.label !== '' ? row.label : (row.machineId ?? ''),
+        },
+        {
+            // Its OWN column, not merely the label's fallback (GAIA-232 AC-1): two
+            // conductors of one repo share a project and a workspace_root, and the
+            // machine_id is the only thing that separates them.
+            key: 'machine',
+            label: 'MACHINE',
+            width: MACHINE_ID_WIDTH,
+            fields: ['machine_id'],
+            get: (row) => elideLeft(row.machineId ?? '', MACHINE_ID_WIDTH),
+        },
+        {
+            /**
+             * A project NAME, so free text, so a GROWER — the operator's correction to
+             * Task 6, which shipped this column fixed at 14 and named the cut an
+             * accepted residual. Measured at 160 columns with that configuration: 15
+             * columns unused at the right edge while an ordinary project name was cut
+             * to `keytec-gaia-p…`, which is finding 3 of this very ticket reproduced
+             * one column further left.
+             *
+             * The 14 stays as the flex BASIS, not as a bound: it is what the column
+             * starts from and what a terminal too narrow to give anything leaves it,
+             * so the narrow case is unchanged and only the wide one improves. No
+             * `min`, deliberately — without one the cell keeps `flexShrink: 0` and an
+             * overflowing row takes its columns from `NAME`, whose `min: 20` is the
+             * floor this list has always had.
+             */
+            key: 'project',
+            label: 'PROJECT',
+            width: 14,
+            grow: 1,
+            fields: ['project_id'],
+            get: (row, ctx) => row.projectId ? (ctx.projectNames.get(row.projectId) ?? '') : '',
+        },
+        {
+            /** A CLOSED VOCABULARY. `ConductorStatus`'s reachable members here are
+             *  `running | stale | offline` — this screen can never produce
+             *  `registry-only`, because every row IS a control-plane record — whose
+             *  longest is 7, so 9 shows each of them whole. */
+            key: 'status',
+            label: 'STATUS',
+            width: 9,
+            fields: ['status', 'lease_expires_at', 'last_seen'],
+            get: (row) => row.derivedStatus,
+        },
+        {
+            /** `humanizeAge`'s own vocabulary, exactly as on the projects list: `—`,
+             *  `just now`, `<n>m|h|d ago`. 8 is the longest of them. */
+            key: 'age',
+            label: 'AGE',
+            width: 8,
+            fields: ['last_seen'],
+            get: (row, ctx) => humanizeAge(row.lastSeen || null, ctx.nowSeconds),
+        },
+        {
+            key: 'workspace',
+            label: 'WORKSPACE',
+            width: PATH_WIDTH,
+            fields: ['workspace_root'],
+            get: (row) => elideLeft(row.workspaceRoot, PATH_WIDTH),
+        },
+        {
+            /** A pid is at most 7 digits — Linux's `pid_max` ceiling is 4 194 304 —
+             *  and a conductor that never reported one shows `-` rather than a
+             *  fabricated number. */
+            key: 'pid',
+            label: 'PID',
+            width: 7,
+            fields: ['last_pid'],
+            get: (row) => row.lastPid === undefined ? '-' : String(row.lastPid),
+        },
+        {
+            /**
+             * A closed vocabulary too, which is why it takes a budget instead of the
+             * trailing slot it used to hold: everything it can say is `…`,
+             * `elsewhere` or both, and 11 is `… elsewhere`.
+             *
+             * A non-local conductor 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. The mark says why their actions are inert here: a pid from
+             * another machine means nothing on this one.
+             */
+            key: 'marks',
+            label: 'MARKS',
+            width: 11,
+            fields: ['workspace_root'],
+            get: (row, ctx) => [ctx.busyIds.has(row.id) ? '…' : '', row.isLocal ? '' : 'elsewhere']
+                .filter((mark) => mark !== '')
+                .join(' '),
+        },
+    ],
+};
+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

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

@@ -0,0 +1,25 @@
+export interface LogTail {
+    /** Whether the log file exists at all. */
+    present: boolean;
+    /** Formatted lines, oldest first. */
+    lines: string[];
+    /** Whether earlier content was cut off by the byte window. */
+    truncated: boolean;
+}
+export interface LogTailOptions {
+    maxLines?: number;
+}
+/**
+ * The tail of a conductor's `log.txt`, formatted for reading.
+ *
+ * The file sink writes raw pino NDJSON (`pino-pretty` serves only the stdout
+ * sink), so a dump would be a wall of JSON. Each record becomes
+ * `HH:MM:SS LEVEL msg (k=v …)`; anything that is not a pino record — a stack
+ * trace, a stray `console.log`, a line the window cut — is passed through
+ * verbatim rather than hidden, because a log view that silently drops what it
+ * cannot parse is worse than one that shows it.
+ *
+ * Never throws: this runs inside a TUI refresh, where an unreadable log must
+ * leave the screen navigable.
+ */
+export declare function tailConductorLog(path: string, options?: LogTailOptions): LogTail;