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

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;

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

@@ -0,0 +1,133 @@
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+/**
+ * How much of the log's tail is read per refresh.
+ *
+ * The live log on a working machine is megabytes; this view re-reads on every
+ * 5 s tick, so it reads a bounded window from the END rather than the file.
+ */
+const WINDOW_BYTES = 64 * 1024;
+/** Default number of formatted lines handed to the renderer. */
+const DEFAULT_MAX_LINES = 500;
+/** pino's numeric levels, as labels. */
+const LEVELS = {
+    10: 'TRACE',
+    20: 'DEBUG',
+    30: 'INFO',
+    40: 'WARN',
+    50: 'ERROR',
+    60: 'FATAL',
+};
+/** Fields consumed by the formatted prefix, not repeated in the k=v tail. */
+const CONSUMED = new Set(['level', 'time', 'msg', 'pid', 'hostname']);
+/**
+ * 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 function tailConductorLog(path, options = {}) {
+    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+    let size;
+    try {
+        size = statSync(path).size;
+    }
+    catch {
+        return {
+            present: false,
+            lines: [`no log at ${path}`],
+            truncated: false,
+        };
+    }
+    const start = Math.max(0, size - WINDOW_BYTES);
+    const truncated = start > 0;
+    let raw = '';
+    try {
+        const fd = openSync(path, 'r');
+        try {
+            const length = size - start;
+            const buf = Buffer.alloc(length);
+            readSync(fd, buf, 0, length, start);
+            raw = buf.toString('utf8');
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (err) {
+        return {
+            present: true,
+            lines: [`could not read ${path}: ${String(err)}`],
+            truncated: false,
+        };
+    }
+    const all = raw.split('\n');
+    // The window almost certainly cut through a record; that fragment is not a
+    // line the conductor ever wrote, so it is dropped rather than shown broken.
+    if (truncated)
+        all.shift();
+    const lines = all
+        .filter((l) => l.trim() !== '')
+        .map(formatLine)
+        .slice(-maxLines);
+    return { present: true, lines, truncated };
+}
+function formatLine(line) {
+    const record = parseRecord(line);
+    if (!record)
+        return line;
+    const level = LEVELS[Number(record.level)] ?? String(record.level ?? '');
+    const time = formatTime(record.time);
+    const msg = typeof record.msg === 'string' ? record.msg : '';
+    const context = Object.entries(record)
+        .filter(([k, v]) => !CONSUMED.has(k) && v !== undefined)
+        .map(([k, v]) => `${k}=${renderValue(v)}`)
+        .join(' ');
+    const head = [time, level.padEnd(5), msg].filter(Boolean).join(' ');
+    return context === '' ? head : `${head}  (${context})`;
+}
+function parseRecord(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{'))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        // A pino record is an object with a numeric level; anything else that
+        // happens to be JSON is not ours to reformat.
+        if (typeof parsed === 'object' &&
+            parsed !== null &&
+            typeof parsed.level === 'number') {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatTime(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return '';
+    const d = new Date(value);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function renderValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value) ?? '';
+    }
+    catch {
+        return '';
+    }
+}

package/dist/src/Entity/conductor/Data/own-conductor.d.ts

@@ -0,0 +1,30 @@
+import type { DropshClient } from '../../../types.js';
+import type { JsonApiCollectionDoc } from '../../collection.js';
+/** What this checkout's conductor record supplies to the cockpit's defaults. */
+export interface OwnConductor {
+    /** This machine's conductor id — preselected in the new-ticket form. */
+    machineId: string | undefined;
+    /** The project name it serves — the new-ticket form's default project. */
+    project: string | undefined;
+}
+/**
+ * Pick this checkout's conductor out of a `gaia_conductor` collection.
+ *
+ * A repo may host several conductor configs, and they share one
+ * `workspace_root` — the dir alone cannot say which of them the cockpit belongs
+ * to. The first in server order is taken, and that is a documented guess rather
+ * than a resolution: both values only PRESELECT fields in the new-ticket form,
+ * which the writer sees and can change.
+ */
+export declare function selectOwnConductor(doc: JsonApiCollectionDoc, gaiaDir: string): OwnConductor;
+/**
+ * Read the conductor collection and resolve this checkout's own record.
+ *
+ * One request with the project sideloaded, so the project NAME costs no second
+ * round trip. The read is owner-gated, so it is already this user's conductors.
+ *
+ * A failure yields nothing rather than rejecting: this runs on the boot path,
+ * and an unreachable control plane must leave the cockpit openable — the two
+ * values it produces are form defaults, not preconditions.
+ */
+export declare function readOwnConductor(client: DropshClient, gaiaDir: string): Promise<OwnConductor>;

package/dist/src/Entity/conductor/Data/own-conductor.js

@@ -0,0 +1,73 @@
+// GAIA-232 (spec Decision D9) — "which conductor is THIS checkout's?", answered
+// from the control plane instead of the deleted `~/.gaia/conductors.json`.
+//
+// The `gaia ui` entry used to read two values straight out of the registry file:
+// the project this checkout belongs to, and this machine's conductor
+// `machine_id`. Both preselect fields in the new-ticket form. The entry cannot
+// resolve them itself — it holds no JSON:API client (GAIA-223 spec Finding 1) —
+// so it hands over the `.gaia` dir it is standing in and the renderer matches it
+// against each conductor's `workspace_root`, which is the same directory the
+// registry's `path` held.
+//
+// The matching rule is deliberately unchanged from the registry lookup it
+// replaces (`resolve(entry.path) === resolve(gaiaDir)`): an exact, normalised
+// path comparison, never a longest-prefix walk. So a worktree — which has its
+// own `.gaia` — resolves to no conductor rather than quietly inheriting its
+// parent checkout's project, exactly as before.
+import { resolve } from 'node:path';
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+const NOTHING = { machineId: undefined, project: undefined };
+/** Id of a single-valued relationship linkage (`data` object), or null. */
+function singleRelId(rel) {
+    const data = rel?.data;
+    if (!data || Array.isArray(data))
+        return null;
+    return data.id ?? null;
+}
+const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
+/**
+ * Pick this checkout's conductor out of a `gaia_conductor` collection.
+ *
+ * A repo may host several conductor configs, and they share one
+ * `workspace_root` — the dir alone cannot say which of them the cockpit belongs
+ * to. The first in server order is taken, and that is a documented guess rather
+ * than a resolution: both values only PRESELECT fields in the new-ticket form,
+ * which the writer sees and can change.
+ */
+export function selectOwnConductor(doc, gaiaDir) {
+    const target = resolve(gaiaDir);
+    const own = (doc.data ?? []).find((c) => {
+        const root = str(c.attributes?.workspace_root);
+        // A conductor that never reported a workspace matches no directory,
+        // whatever `resolve('')` would make of an empty path.
+        return root !== undefined && resolve(root) === target;
+    });
+    if (own === undefined)
+        return NOTHING;
+    const projectId = singleRelId(own.relationships?.project_id);
+    const project = projectId
+        ? str((doc.included ?? []).find((inc) => inc.id === projectId)?.attributes
+            ?.name)
+        : undefined;
+    return { machineId: str(own.attributes?.machine_id), project };
+}
+/**
+ * Read the conductor collection and resolve this checkout's own record.
+ *
+ * One request with the project sideloaded, so the project NAME costs no second
+ * round trip. The read is owner-gated, so it is already this user's conductors.
+ *
+ * A failure yields nothing rather than rejecting: this runs on the boot path,
+ * and an unreachable control plane must leave the cockpit openable — the two
+ * values it produces are form defaults, not preconditions.
+ */
+export async function readOwnConductor(client, gaiaDir) {
+    const params = new DrupalJsonApiParams().addInclude(['project_id']);
+    try {
+        const doc = (await client.get('gaia_conductor/gaia_conductor', params));
+        return selectOwnConductor(doc, gaiaDir);
+    }
+    catch {
+        return NOTHING;
+    }
+}

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

@@ -0,0 +1,78 @@
+import { type SignalOutcome } from '@gaia-ai/core';
+/** What a cockpit action reports back to its row. */
+export interface ConductorActionResult {
+    ok: boolean;
+    message: string;
+}
+/** A detached child launch, injected so tests spawn nothing. */
+export interface SpawnRequest {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string | undefined>;
+}
+/**
+ * The platform seams the cockpit's conductor actions stand on.
+ *
+ * `spawn` settles when the child has really been forked, or rejects when it
+ * could not be. It is not `void`, because the failure that actually happens —
+ * `ENOENT`, `EACCES` — arrives on an `'error'` EVENT a tick after the call
+ * returns, and a caller with nothing to await can neither report it nor even
+ * survive it (GAIA-232 review finding F2).
+ */
+export interface ConductorProcessDeps {
+    spawn?: (request: SpawnRequest) => void | Promise<void>;
+    signal?: (input: {
+        pid: number | undefined;
+        workspaceRoot: string;
+        signal: NodeJS.Signals;
+    }) => SignalOutcome;
+}
+export interface ConductorProcessHost {
+    start(input: {
+        workspaceRoot: string;
+        conductorName: string | undefined;
+    }): Promise<ConductorActionResult>;
+    stop(input: {
+        pid: number | undefined;
+        workspaceRoot: string;
+    }): Promise<ConductorActionResult>;
+}
+/**
+ * Start and stop a conductor from the cockpit.
+ *
+ * Start runs the same `gaia conductor start` a human runs, in the conductor's
+ * own workspace — rather than reimplementing the lifecycle in the TUI process.
+ * How that command backgrounds itself (herdr, or a bare foreground child) is
+ * not this screen's business, and keeping one implementation means the cockpit
+ * cannot drift from the command line.
+ *
+ * Stop is a verified signal, never a spawn: the process already exists, and
+ * asking a child to find it would only add a way to get it wrong.
+ */
+export declare function createConductorProcessHost(deps?: ConductorProcessDeps): ConductorProcessHost;
+/**
+ * The real launch: detached and fully disowned.
+ *
+ * `gaia ui` must not become the conductor's parent — the operator quits the
+ * cockpit far more often than they stop a conductor, and a child tied to this
+ * process would die with it. The streams are ignored for the same reason a
+ * separate logger exists: anything the child printed would land on the TUI's
+ * frame.
+ *
+ * The `'error'` listener is not defensive tidiness, it is the whole point
+ * (GAIA-232 review finding F2). `child_process.spawn` does not throw on a
+ * missing or unexecutable binary: it returns a child object and emits `'error'`
+ * asynchronously. An EventEmitter with no `'error'` listener THROWS that event,
+ * out of a tick nobody is in — so `gaia` missing from the TUI's `PATH`, or a
+ * `workspaceRoot` deleted since the last 5 s read, took the whole cockpit down.
+ *
+ * Node guarantees exactly one of `'spawn'` / `'error'`, so the promise always
+ * settles. The listener deliberately stays attached afterwards: a post-spawn
+ * `'error'` on a settled promise is a harmless no-op, and removing it would
+ * restore the crash for the rarer case.
+ *
+ * Exported so the real child is covered by a test — with a binary that cannot
+ * exist, so the suite never starts a conductor.
+ */
+export declare function defaultSpawn(request: SpawnRequest): Promise<void>;

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

@@ -0,0 +1,101 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { signalVerifiedProcess } from '@gaia-ai/core';
+/**
+ * Start and stop a conductor from the cockpit.
+ *
+ * Start runs the same `gaia conductor start` a human runs, in the conductor's
+ * own workspace — rather than reimplementing the lifecycle in the TUI process.
+ * How that command backgrounds itself (herdr, or a bare foreground child) is
+ * not this screen's business, and keeping one implementation means the cockpit
+ * cannot drift from the command line.
+ *
+ * Stop is a verified signal, never a spawn: the process already exists, and
+ * asking a child to find it would only add a way to get it wrong.
+ */
+export function createConductorProcessHost(deps = {}) {
+    const spawn = deps.spawn ?? defaultSpawn;
+    const signal = deps.signal ?? signalVerifiedProcess;
+    return {
+        async start({ workspaceRoot, conductorName }) {
+            try {
+                // Awaited, so "starting …" is claimed only once the fork has really
+                // happened — and so an `'error'` event becomes a reported failure
+                // instead of an unhandled one.
+                await spawn({
+                    command: 'gaia',
+                    args: ['conductor', 'start'],
+                    cwd: workspaceRoot,
+                    env: {
+                        ...process.env,
+                        // Target by NAME and let core resolve it — the stem→file mapping
+                        // has exactly one owner, and it is not this screen.
+                        ...(conductorName ? { GAIA_CONDUCTOR: conductorName } : {}),
+                        // Cleared, not merely unset: an inherited value beats
+                        // $GAIA_CONDUCTOR in core's resolution, so a shell that exported it
+                        // would make this button start a DIFFERENT conductor — silently,
+                        // since both are valid configs and neither errors.
+                        GAIA_CONDUCTOR_CONFIG: '',
+                    },
+                });
+                return {
+                    ok: true,
+                    message: `starting ${conductorName ?? 'conductor'} in ${workspaceRoot}`,
+                };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    message: `could not start: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+        async stop({ pid, workspaceRoot }) {
+            const outcome = signal({ pid, workspaceRoot, signal: 'SIGTERM' });
+            return outcome.ok
+                ? {
+                    ok: true,
+                    message: `stopped pid ${outcome.pid}; it writes its own offline as it exits`,
+                }
+                : { ok: false, message: outcome.message };
+        },
+    };
+}
+/**
+ * The real launch: detached and fully disowned.
+ *
+ * `gaia ui` must not become the conductor's parent — the operator quits the
+ * cockpit far more often than they stop a conductor, and a child tied to this
+ * process would die with it. The streams are ignored for the same reason a
+ * separate logger exists: anything the child printed would land on the TUI's
+ * frame.
+ *
+ * The `'error'` listener is not defensive tidiness, it is the whole point
+ * (GAIA-232 review finding F2). `child_process.spawn` does not throw on a
+ * missing or unexecutable binary: it returns a child object and emits `'error'`
+ * asynchronously. An EventEmitter with no `'error'` listener THROWS that event,
+ * out of a tick nobody is in — so `gaia` missing from the TUI's `PATH`, or a
+ * `workspaceRoot` deleted since the last 5 s read, took the whole cockpit down.
+ *
+ * Node guarantees exactly one of `'spawn'` / `'error'`, so the promise always
+ * settles. The listener deliberately stays attached afterwards: a post-spawn
+ * `'error'` on a settled promise is a harmless no-op, and removing it would
+ * restore the crash for the rarer case.
+ *
+ * Exported so the real child is covered by a test — with a binary that cannot
+ * exist, so the suite never starts a conductor.
+ */
+export function defaultSpawn(request) {
+    return new Promise((resolve, reject) => {
+        const child = nodeSpawn(request.command, request.args, {
+            cwd: request.cwd,
+            env: request.env,
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.on('error', reject);
+        child.once('spawn', () => {
+            child.unref();
+            resolve();
+        });
+    });
+}

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

@@ -0,0 +1,42 @@
+import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
+export declare class ConductorsScreen extends BaseScreen {
+    static readonly route: {
+        id: string;
+        path: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+    };
+    readonly id: string;
+    readonly frameId = "conductors";
+    private rows;
+    private projectNames;
+    private selectedIndex;
+    private logFor;
+    private status;
+    private reading;
+    private timer;
+    private readonly busyIds;
+    private activation;
+    topTab(): {
+        readonly level: "root";
+        readonly tab: "conductors";
+    };
+    private quietRead;
+    get busy(): boolean;
+    reload(context: ScreenContext): void;
+    enter(context: ScreenContext): void;
+    leave(): void;
+    render(context: ScreenContext): string[];
+    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    select(index: number, context: ScreenContext): boolean;
+    activate(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+    reset(): void;
+    private refresh;
+    private act;
+    private stopTimer;
+}

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

@@ -0,0 +1,200 @@
+import { existsSync } from 'node:fs';
+import { humanizeAge } from '../../../lib/format.js';
+import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { conductorRows } from '../Component/conductor-list/index.js';
+import { listConductorRows, listProjectNames, } from '../Data/conductors.js';
+import { tailConductorLog } from '../Data/log-tail.js';
+import { createConductorProcessHost } from '../Data/process.js';
+const REFRESH_MS = 5_000;
+export class ConductorsScreen extends BaseScreen {
+    static route = {
+        id: 'conductors',
+        path: '/conductors',
+        tab: { id: 'conductors', label: 'Conductors', scope: 'root', order: 30 },
+    };
+    id = ConductorsScreen.route.id;
+    frameId = 'conductors';
+    rows = [];
+    projectNames = new Map();
+    selectedIndex = 0;
+    logFor = null;
+    status = '';
+    reading = false;
+    timer = null;
+    busyIds = new Set();
+    activation = 0;
+    topTab() {
+        return { level: 'root', tab: 'conductors' };
+    }
+    // GAIA-285 spec D5/D6 — the shared `R` lands here; the 5 s tick passes
+    // `quiet` so only an EXPLICIT reload states its loading in the footer.
+    quietRead = false;
+    get busy() {
+        return this.reading && !this.quietRead;
+    }
+    reload(context) {
+        void this.refresh(context);
+    }
+    enter(context) {
+        const activation = ++this.activation;
+        void this.refresh(context, true, activation);
+        this.stopTimer();
+        this.timer = setInterval(() => void this.refresh(context, false, undefined, true), REFRESH_MS);
+        this.timer.unref?.();
+    }
+    leave() {
+        this.activation++;
+        this.stopTimer();
+    }
+    render(context) {
+        const lines = conductorRows(this.rows.map((row) => ({
+            label: row.label,
+            machineId: row.machineId,
+            project: row.projectId
+                ? (this.projectNames.get(row.projectId) ?? '')
+                : '',
+            derivedStatus: row.derivedStatus,
+            ageLabel: humanizeAge(row.lastSeen || null, context.nowSeconds?.() ?? Math.floor(Date.now() / 1000)),
+            workspaceRoot: row.workspaceRoot,
+            lastPid: row.lastPid,
+            isLocal: row.isLocal,
+            busy: this.busyIds.has(row.id),
+        })));
+        const open = this.rows.find((row) => row.id === this.logFor);
+        if (!open)
+            return lines;
+        return [
+            ...lines,
+            '',
+            open.isLocal
+                ? `log — ${open.workspaceRoot}/log.txt`
+                : `log — ${open.label} runs on another machine; no log here`,
+            ...(open.isLocal
+                ? tailConductorLog(`${open.workspaceRoot}/log.txt`, { maxLines: 40 })
+                    .lines
+                : []),
+        ];
+    }
+    present(context) {
+        return presentation(this.render(context), {
+            selectable: this.rows.length,
+            selectedIndex: this.selectedIndex,
+            selectedRow: this.rows.length ? this.selectedIndex : -1,
+            title: 'GAIA conductors',
+            meta: `${this.rows.length} conductor(s)  ·  s start · x stop${this.status ? `  ·  ${this.status}` : ''}`,
+            status: ' ↑↓ select · Enter log · s start · x stop · Tab tabs · q quit ',
+        });
+    }
+    select(index, context) {
+        if (index < 0 || index >= this.rows.length)
+            return false;
+        this.selectedIndex = index;
+        context.requestDraw();
+        return true;
+    }
+    activate(index, context) {
+        const row = this.rows[index];
+        if (!row)
+            return false;
+        this.logFor = this.logFor === row.id ? null : row.id;
+        context.requestDraw();
+        return true;
+    }
+    handleInput(input, context) {
+        if (input === 's' || input === 'x') {
+            void this.act(input === 's' ? 'start' : 'stop', context);
+            return true;
+        }
+        if (input === '\r' || input === '\n')
+            return this.activate(this.selectedIndex, context);
+        if (input === 'j' || input === '\x1b[B')
+            return this.select(Math.min(this.selectedIndex + 1, this.rows.length - 1), context);
+        if (input === 'k' || input === '\x1b[A')
+            return this.select(Math.max(this.selectedIndex - 1, 0), context);
+        return false;
+    }
+    reset() {
+        this.leave();
+        this.rows = [];
+        this.projectNames.clear();
+        this.selectedIndex = 0;
+        this.logFor = null;
+        this.status = '';
+        this.busyIds.clear();
+    }
+    async refresh(context, includeProjects = false, activation = this.activation, quiet = false) {
+        if (this.reading || !context.services)
+            return;
+        this.reading = true;
+        this.quietRead = quiet;
+        try {
+            if (includeProjects && this.projectNames.size === 0) {
+                const names = await listProjectNames(context.services.client);
+                if (activation !== this.activation)
+                    return;
+                this.projectNames = names;
+            }
+            const rows = await listConductorRows(context.services.client, {
+                now: context.nowSeconds?.() ?? Math.floor(Date.now() / 1000),
+                exists: existsSync,
+            });
+            if (activation !== this.activation)
+                return;
+            this.rows = rows;
+            this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.rows.length - 1));
+        }
+        finally {
+            this.reading = false;
+            this.quietRead = false;
+        }
+        // After the finally, so the frame this triggers already reads busy=false —
+        // drawn from inside the try it would restate `Loading…` one last time.
+        if (context.isActive())
+            context.requestDraw();
+    }
+    async act(action, context) {
+        const row = this.rows[this.selectedIndex];
+        if (!row || this.busyIds.has(row.id))
+            return;
+        if (!row.isLocal) {
+            this.status = `${row.label} runs on another machine — no action from here`;
+            context.requestDraw();
+            return;
+        }
+        if (action === 'start' && row.derivedStatus === 'running') {
+            this.status = `${row.label} is already running`;
+            context.requestDraw();
+            return;
+        }
+        this.busyIds.add(row.id);
+        this.status = `${action}…`;
+        context.requestDraw();
+        const host = context.services?.conductorProcess ?? createConductorProcessHost();
+        try {
+            const result = action === 'start'
+                ? await host.start({
+                    workspaceRoot: row.workspaceRoot,
+                    conductorName: row.conductorName,
+                })
+                : await host.stop({
+                    pid: row.lastPid,
+                    workspaceRoot: row.workspaceRoot,
+                });
+            this.status = result.message;
+        }
+        catch (caught) {
+            this.status = caught instanceof Error ? caught.message : String(caught);
+        }
+        finally {
+            this.busyIds.delete(row.id);
+            await this.refresh(context);
+            if (context.isActive())
+                context.requestDraw();
+        }
+    }
+    stopTimer() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+}