@gaia-ai/addon-gaia-ui 0.6.1

package/dist/src/Screen/dashboard.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Screen/dashboard.js

@@ -0,0 +1 @@
+export {};

package/dist/src/Screen/project.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Screen/project.js

@@ -0,0 +1 @@
+export {};

package/dist/src/Screen/ticket.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Screen/ticket.js

@@ -0,0 +1 @@
+export {};

package/dist/src/Service/agent.d.ts

@@ -0,0 +1,17 @@
+import type { TuiAgentService } from '../types.js';
+/** The launch intent passed to {@link TuiAgentService.launch}. */
+export type CreateLaunch = Parameters<TuiAgentService['launch']>[0];
+/**
+ * Build the `ticket:create` launch intent for a project. The prompt is a pure
+ * pointer to WORKFLOW.md (the pre-filled form is passed via
+ * `$GAIA_NEW_TICKET_INPUT`); `GAIA_ID` is never inherited (a create must not be
+ * bound to a claimed ticket).
+ */
+export declare function buildCreateLaunch(opts: {
+    project: string;
+    cwd: string;
+    specPath?: string | undefined;
+    workflow?: string | undefined;
+    createPrompt?: string | undefined;
+    label?: string | undefined;
+}): CreateLaunch;

package/dist/src/Service/agent.js

@@ -0,0 +1,28 @@
+const CREATE_PROMPT = 'Read the repository\'s WORKFLOW.md and follow its "Create ticket" section to ' +
+    'create a new GAIA ticket. Do not start work on the new ticket.';
+/**
+ * Build the `ticket:create` launch intent for a project. The prompt is a pure
+ * pointer to WORKFLOW.md (the pre-filled form is passed via
+ * `$GAIA_NEW_TICKET_INPUT`); `GAIA_ID` is never inherited (a create must not be
+ * bound to a claimed ticket).
+ */
+export function buildCreateLaunch(opts) {
+    const env = {
+        ...process.env,
+        TERM: 'xterm-256color',
+        GAIA_PROJECT: opts.project,
+    };
+    delete env.GAIA_ID;
+    if (opts.specPath)
+        env.GAIA_NEW_TICKET_INPUT = opts.specPath;
+    if (opts.workflow)
+        env.GAIA_WORKFLOW = opts.workflow;
+    return {
+        group: opts.project,
+        cwd: opts.cwd,
+        prompt: opts.createPrompt?.trim() || CREATE_PROMPT,
+        env,
+        isNew: true,
+        ...(opts.label !== undefined ? { label: opts.label } : {}),
+    };
+}

package/dist/src/Service/create-form-data.d.ts

@@ -0,0 +1,10 @@
+import type { DropshClient } from '../types.js';
+import type { CreateFormOptions, Option } from './create-form.js';
+/** The fixed GAIA workflow classification (triage → workflow + destination). */
+export declare const WORKFLOW_OPTIONS: Option[];
+/** Hints from the launcher used to preselect the machine's own user + conductor. */
+export interface CreateFormHints {
+    currentUser?: string | undefined;
+    ownConductorMachineId?: string | undefined;
+}
+export declare function loadCreateFormOptions(client: DropshClient, hints?: CreateFormHints): Promise<CreateFormOptions>;

package/dist/src/Service/create-form-data.js

@@ -0,0 +1,52 @@
+/** The fixed GAIA workflow classification (triage → workflow + destination). */
+export const WORKFLOW_OPTIONS = [
+    { id: 'gaia_feature', label: 'feature' },
+    { id: 'gaia_bug', label: 'bug' },
+    { id: 'gaia_chore', label: 'chore' },
+];
+const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
+async function list(client, type, map) {
+    try {
+        return (await client.collection(type).list()).map(map);
+    }
+    catch {
+        return [];
+    }
+}
+/** Stable-sort the items matching `isOwn` to the front (so index 0 = default). */
+function ownFirst(items, isOwn) {
+    const own = items.filter(isOwn);
+    const rest = items.filter((i) => !isOwn(i));
+    return [...own, ...rest];
+}
+export async function loadCreateFormOptions(client, hints = {}) {
+    const [users, conductorRows, labels] = await Promise.all([
+        list(client, 'user', (r) => ({
+            id: r.id,
+            label: str(r.attr('display_name')) ?? str(r.attr('name')) ?? r.id,
+            name: str(r.attr('name')),
+        })),
+        list(client, 'gaia_conductor', (r) => ({
+            id: r.id,
+            label: str(r.attr('label')) ?? str(r.attr('machine_id')) ?? r.id,
+            machineId: str(r.attr('machine_id')),
+        })),
+        list(client, 'gaia_term', (r) => ({
+            id: r.id,
+            label: str(r.attr('name')) ?? str(r.attr('label')) ?? r.id,
+        })),
+    ]);
+    // Preselect the machine's own user (by username) + conductor (by machine_id).
+    const orderedUsers = hints.currentUser
+        ? ownFirst(users, (u) => u.name === hints.currentUser || u.id === hints.currentUser)
+        : users;
+    const orderedConductors = hints.ownConductorMachineId
+        ? ownFirst(conductorRows, (c) => c.machineId === hints.ownConductorMachineId)
+        : conductorRows;
+    return {
+        users: orderedUsers.map((u) => ({ id: u.id, label: u.label })),
+        conductors: orderedConductors.map((c) => ({ id: c.id, label: c.label })),
+        labels,
+        workflows: WORKFLOW_OPTIONS,
+    };
+}

package/dist/src/Service/create-form.d.ts

@@ -0,0 +1,52 @@
+export interface Option {
+    id: string;
+    label: string;
+}
+export interface CreateFormOptions {
+    users: Option[];
+    conductors: Option[];
+    labels: Option[];
+    workflows: Option[];
+}
+export type FieldKind = 'text' | 'select' | 'multiselect' | 'action';
+export interface FieldDef {
+    id: 'description' | 'assignee' | 'conductor' | 'labels' | 'workflow' | 'submit';
+    label: string;
+    kind: FieldKind;
+}
+/** Field order in the popup (top to bottom). */
+export declare const FIELDS: FieldDef[];
+export interface CreateFormState {
+    description: string;
+    assignee: string | null;
+    conductor: string | null;
+    workflow: string | null;
+    labels: Set<string>;
+    /** Active field index into {@link FIELDS}. */
+    active: number;
+    /** Highlighted label index (when the labels field is active). */
+    labelCursor: number;
+}
+export declare function initialForm(opts: CreateFormOptions): CreateFormState;
+export declare const activeField: (s: CreateFormState) => FieldDef;
+export declare function moveField(s: CreateFormState, delta: number): CreateFormState;
+/** Append typed text to the description (only meaningful on the text field). */
+export declare function typeChar(s: CreateFormState, text: string): CreateFormState;
+export declare function backspace(s: CreateFormState): CreateFormState;
+export declare function newline(s: CreateFormState): CreateFormState;
+/** Cycle the active single-select field's value by `dir` (+1 / -1). */
+export declare function cycle(s: CreateFormState, opts: CreateFormOptions, dir: 1 | -1): CreateFormState;
+export declare function moveLabelCursor(s: CreateFormState, opts: CreateFormOptions, dir: 1 | -1): CreateFormState;
+export declare function toggleLabel(s: CreateFormState, opts: CreateFormOptions): CreateFormState;
+/** The submitted payload (resolved options), handed to the create agent. */
+export interface CreateFormPayload {
+    description: string;
+    workflow: Option | null;
+    assignee: Option | null;
+    conductor: Option | null;
+    labels: Option[];
+}
+/** A short human label for the agent list: the description's first line (capped),
+ *  else "New <workflow>". */
+export declare function shortName(payload: CreateFormPayload): string;
+export declare function serialize(s: CreateFormState, opts: CreateFormOptions): CreateFormPayload;

package/dist/src/Service/create-form.js

@@ -0,0 +1,98 @@
+// Pure state model for the "New ticket" popup form (GAIA-190). The kernel drives
+// it from raw key input; `Component/create-form` renders it. On submit the
+// serialized payload is handed to the create agent (via a temp spec file), which
+// creates the ticket through the canonical path. No I/O here.
+/** Field order in the popup (top to bottom). */
+export const FIELDS = [
+    { id: 'description', label: 'Description', kind: 'text' },
+    { id: 'assignee', label: 'Assignee', kind: 'select' },
+    { id: 'conductor', label: 'Conductor', kind: 'select' },
+    { id: 'labels', label: 'Labels', kind: 'multiselect' },
+    { id: 'workflow', label: 'Workflow', kind: 'select' },
+    { id: 'submit', label: 'Create ticket', kind: 'action' },
+];
+const clamp = (v, min, max) => Math.max(min, Math.min(v, max));
+export function initialForm(opts) {
+    return {
+        description: '',
+        assignee: opts.users[0]?.id ?? null,
+        conductor: opts.conductors[0]?.id ?? null,
+        workflow: opts.workflows[0]?.id ?? null,
+        labels: new Set(),
+        active: 0,
+        labelCursor: 0,
+    };
+}
+export const activeField = (s) => (FIELDS[s.active] ?? FIELDS[0]);
+export function moveField(s, delta) {
+    return { ...s, active: clamp(s.active + delta, 0, FIELDS.length - 1) };
+}
+/** Append typed text to the description (only meaningful on the text field). */
+export function typeChar(s, text) {
+    return { ...s, description: s.description + text };
+}
+export function backspace(s) {
+    return { ...s, description: s.description.slice(0, -1) };
+}
+export function newline(s) {
+    return { ...s, description: `${s.description}\n` };
+}
+const cycleValue = (list, current, dir) => {
+    if (list.length === 0)
+        return current;
+    const idx = list.findIndex((o) => o.id === current);
+    const next = (idx < 0 ? 0 : idx + dir + list.length) % list.length;
+    return list[next]?.id ?? current;
+};
+/** Cycle the active single-select field's value by `dir` (+1 / -1). */
+export function cycle(s, opts, dir) {
+    switch (activeField(s).id) {
+        case 'assignee':
+            return { ...s, assignee: cycleValue(opts.users, s.assignee, dir) };
+        case 'conductor':
+            return { ...s, conductor: cycleValue(opts.conductors, s.conductor, dir) };
+        case 'workflow':
+            return { ...s, workflow: cycleValue(opts.workflows, s.workflow, dir) };
+        default:
+            return s;
+    }
+}
+export function moveLabelCursor(s, opts, dir) {
+    return {
+        ...s,
+        labelCursor: clamp(s.labelCursor + dir, 0, Math.max(0, opts.labels.length - 1)),
+    };
+}
+export function toggleLabel(s, opts) {
+    const option = opts.labels[s.labelCursor];
+    if (!option)
+        return s;
+    const labels = new Set(s.labels);
+    if (labels.has(option.id))
+        labels.delete(option.id);
+    else
+        labels.add(option.id);
+    return { ...s, labels };
+}
+const optionFor = (list, id) => list.find((o) => o.id === id) ?? null;
+/** A short human label for the agent list: the description's first line (capped),
+ *  else "New <workflow>". */
+export function shortName(payload) {
+    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;
+    }
+    return `New ${payload.workflow?.label ?? 'ticket'}`;
+}
+export function serialize(s, opts) {
+    return {
+        description: s.description,
+        workflow: optionFor(opts.workflows, s.workflow),
+        assignee: optionFor(opts.users, s.assignee),
+        conductor: optionFor(opts.conductors, s.conductor),
+        labels: opts.labels.filter((o) => s.labels.has(o.id)),
+    };
+}

package/dist/src/Service/project-data.d.ts

@@ -0,0 +1,48 @@
+import { type TicketCriteria } from '../lib/ticket-query.js';
+import type { DropshClient, JsonApiResource } from '../types.js';
+/** One flat-table row derived from a `gaia_ticket` dropsh resource. */
+export interface TicketRow {
+    id: string;
+    identifier: string;
+    title: string;
+    state: string;
+    priority: unknown;
+    assigneeInitials: string;
+    derivedStatus: string;
+    labels?: string[];
+    type: string | null;
+    /** Parent ticket identifier (`GAIA-nnn`) from `parent_id`, else null (AC-1/2). */
+    parent: string | null;
+    /** Assigned conductor label from `conductor_id`, else null (AC-3/4). */
+    conductor: string | null;
+}
+/** A `(id) → resource` lookup over a document's sideloaded `included` entries.
+ *  JSON:API ids are UUIDs (unique across bundles), so id alone keys uniquely. */
+type IncludedIndex = Map<string, JsonApiResource>;
+/** Map a RAW JSON:API `data[]` entry (from client.get) to a table row.
+ *  `included` resolves the parent identifier + conductor label from the
+ *  sideloaded relationships (AC-5); absent/unresolved → null (AC-2/4). */
+export declare function mapTicketData(item: JsonApiResource, included?: IncludedIndex): TicketRow;
+/** Server-side filtered/searched ticket list for a project. The query sideloads
+ *  `parent_id` + `conductor_id`; each row's parent/conductor is resolved from
+ *  the document's `included` (AC-5). */
+export declare function loadFilteredTickets(client: DropshClient, projectId: string, criteria: TicketCriteria): Promise<TicketRow[]>;
+/** The resolved project header + its ticket rows. */
+export interface ProjectWithTickets {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    tickets: TicketRow[];
+}
+/**
+ * Resolve a `gaia_project` by its slug (the registry `project`, which matches
+ * the project's `name`) and list its tickets, most-recently-changed first.
+ *
+ * The ticket listing delegates to {@link loadFilteredTickets} with empty
+ * criteria — one include-aware `client.get` path shared with the search/filter
+ * load, so both resolve parent/conductor identically (no dual-mapper drift).
+ */
+export declare function loadProjectWithTickets(client: DropshClient, projectSlug: string): Promise<ProjectWithTickets>;
+export {};

package/dist/src/Service/project-data.js

@@ -0,0 +1,92 @@
+// Project / ticket list reads — through the dropsh JSON:API client
+// (`services.client`). Every rendered object is a Drupal entity (AC-5).
+import { asString } from '../lib/format.js';
+import { buildTicketQueryParams, } from '../lib/ticket-query.js';
+/** Build the {@link IncludedIndex} from a document's `included` array. */
+function indexIncluded(included) {
+    const index = new Map();
+    for (const r of included ?? [])
+        if (r.id)
+            index.set(r.id, r);
+    return index;
+}
+/** Read the id of a single-valued relationship linkage (`data` object), or
+ *  null when the linkage is absent, null, or an (unexpected) array. */
+function singleRelId(rel) {
+    const data = rel?.data;
+    if (!data || Array.isArray(data))
+        return null;
+    return data.id ?? null;
+}
+/** Map a RAW JSON:API `data[]` entry (from client.get) to a table row.
+ *  `included` resolves the parent identifier + conductor label from the
+ *  sideloaded relationships (AC-5); absent/unresolved → null (AC-2/4). */
+export function mapTicketData(item, included) {
+    const a = item.attributes ?? {};
+    const str = (key) => typeof a[key] === 'string' ? a[key] : undefined;
+    const labelData = item.relationships?.labels?.data;
+    const labels = Array.isArray(labelData)
+        ? labelData.map((l) => l.id).filter(Boolean)
+        : labelData
+            ? [labelData.id]
+            : [];
+    const index = included ?? new Map();
+    const parentId = singleRelId(item.relationships?.parent_id);
+    const parent = parentId
+        ? (asString(index.get(parentId)?.attributes?.identifier) ?? null)
+        : null;
+    const conductorId = singleRelId(item.relationships?.conductor_id);
+    const conductor = conductorId
+        ? (asString(index.get(conductorId)?.attributes?.label) ?? null)
+        : null;
+    return {
+        id: item.id ?? '',
+        identifier: str('identifier') ?? item.id ?? '',
+        title: str('title') ?? 'Untitled',
+        state: str('state') ?? 'unknown',
+        priority: a.priority ?? null,
+        assigneeInitials: str('assignee_initials') ?? '',
+        derivedStatus: str('derived_status') ?? 'idle',
+        labels,
+        type: str('workflow') ?? null,
+        parent,
+        conductor,
+    };
+}
+/** Server-side filtered/searched ticket list for a project. The query sideloads
+ *  `parent_id` + `conductor_id`; each row's parent/conductor is resolved from
+ *  the document's `included` (AC-5). */
+export async function loadFilteredTickets(client, projectId, criteria) {
+    const params = buildTicketQueryParams(projectId, criteria);
+    const doc = (await client.get('gaia_ticket/gaia_ticket', params));
+    const index = indexIncluded(doc?.included);
+    return (doc?.data ?? []).map((item) => mapTicketData(item, index));
+}
+/**
+ * Resolve a `gaia_project` by its slug (the registry `project`, which matches
+ * the project's `name`) and list its tickets, most-recently-changed first.
+ *
+ * The ticket listing delegates to {@link loadFilteredTickets} with empty
+ * criteria — one include-aware `client.get` path shared with the search/filter
+ * load, so both resolve parent/conductor identically (no dual-mapper drift).
+ */
+export async function loadProjectWithTickets(client, projectSlug) {
+    const projectRes = await client
+        .collection('gaia_project')
+        .where('name', '=', projectSlug)
+        .first();
+    const projectId = projectRes?.id ?? projectSlug;
+    const tickets = await loadFilteredTickets(client, projectId, {
+        query: '',
+        state: null,
+        type: null,
+    });
+    return {
+        project: {
+            id: projectId,
+            name: projectRes?.attr('name') ?? projectSlug,
+            slug: projectSlug,
+        },
+        tickets,
+    };
+}

package/dist/src/Service/projects.d.ts

@@ -0,0 +1,21 @@
+import { type ConductorStatus } from '../Deriver/liveness.js';
+import type { DropshClient } from '../types.js';
+/** A derived dashboard row: one distinct project + its liveliest conductor. */
+export interface DashboardProject {
+    project: string;
+    derivedStatus: ConductorStatus;
+    lastSeen: number | null;
+    ageLabel: string;
+}
+/**
+ * Resolve the dashboard's project rows straight from the control plane: list the
+ * `gaia_conductor` entities (read is owner-gated, so this is already scoped to
+ * the current user's conductors — no local registry needed), sideload their
+ * `project_id`, group by project name, and report each project's liveliest
+ * conductor (running > stale > offline). Everything is a Drupal entity read
+ * through `services.client` (AC-5); the dashboard itself stays a screen/route.
+ */
+export declare function loadDashboardProjects({ client, nowSeconds, }: {
+    client: DropshClient;
+    nowSeconds: () => number;
+}): Promise<DashboardProject[]>;

package/dist/src/Service/projects.js

@@ -0,0 +1,80 @@
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+import { deriveConductorStatus, humanizeAge, } from '../Deriver/liveness.js';
+/** JSON:API timestamps arrive as ISO-8601 strings; liveness works in seconds. */
+function toEpochSeconds(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return null;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : Math.floor(ms / 1000);
+}
+/** 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;
+}
+// Most-alive-first ranking so a project with several conductors reports its
+// liveliest one, not whichever the collection happened to return first.
+const STATUS_RANK = {
+    running: 0,
+    stale: 1,
+    offline: 2,
+    'registry-only': 3,
+};
+/**
+ * Resolve the dashboard's project rows straight from the control plane: list the
+ * `gaia_conductor` entities (read is owner-gated, so this is already scoped to
+ * the current user's conductors — no local registry needed), sideload their
+ * `project_id`, group by project name, and report each project's liveliest
+ * conductor (running > stale > offline). Everything is a Drupal entity read
+ * through `services.client` (AC-5); the dashboard itself stays a screen/route.
+ */
+export async function loadDashboardProjects({ client, nowSeconds, }) {
+    const params = new DrupalJsonApiParams().addInclude(['project_id']);
+    let doc;
+    try {
+        doc = (await client.get('gaia_conductor/gaia_conductor', params));
+    }
+    catch {
+        return [];
+    }
+    // Resolve each conductor's project name from the sideloaded gaia_project.
+    const projectNameById = new Map();
+    for (const inc of doc.included ?? []) {
+        if (inc.id && typeof inc.attributes?.name === 'string') {
+            projectNameById.set(inc.id, inc.attributes.name);
+        }
+    }
+    const now = nowSeconds();
+    const best = new Map();
+    for (const c of doc.data ?? []) {
+        const a = c.attributes ?? {};
+        const projectId = singleRelId(c.relationships?.project_id);
+        const project = projectId ? projectNameById.get(projectId) : undefined;
+        // A conductor whose project cannot be resolved is not a dashboard row.
+        if (!project)
+            continue;
+        const lastSeen = toEpochSeconds(a.last_seen ?? null);
+        const derivedStatus = deriveConductorStatus({
+            present: true,
+            status: typeof a.status === 'string' ? a.status : null,
+            lastSeen,
+            leaseExpiresAt: toEpochSeconds(a.lease_expires_at ?? null),
+        }, now);
+        const prev = best.get(project);
+        if (!prev || STATUS_RANK[derivedStatus] < STATUS_RANK[prev.derivedStatus]) {
+            best.set(project, { derivedStatus, lastSeen });
+        }
+    }
+    return [...best.entries()].map(([project, b]) => ({
+        project,
+        derivedStatus: b.derivedStatus,
+        lastSeen: b.lastSeen,
+        ageLabel: humanizeAge(b.lastSeen, now),
+    }));
+}

package/dist/src/Service/run-data.d.ts

@@ -0,0 +1,35 @@
+import type { DropshClient, JsonApiResource } from '../types.js';
+/** One flat-table row derived from a `gaia_run` dropsh resource. */
+export interface RunRow {
+    id: string;
+    /** The `#844`-style internal id (human handle in the RUN column). */
+    drupalId: number | string | null;
+    /** The run's ticket relationship id, or null when absent. */
+    ticketId: string | null;
+    /** The ticket's `identifier` from the sideloaded include, or '—'. */
+    ticketIdentifier: string;
+    /** Authoritative run state (`claimed|running|done|expired|failed`). */
+    state: string;
+    /** The ticket state the run was dispatched for (`state_at_start`). */
+    phase: string;
+    /** The executing agent (`claude`, `codex`, …). */
+    agent: string;
+    /** ISO start time; falls back to `created` when the run never started. */
+    startedAt: string | null;
+    heartbeat: string | null;
+    claimExpiresAt: string | null;
+}
+/**
+ * Map a RAW JSON:API `data[]` entry (from `client.get`) to a run row, resolving
+ * the ticket identifier from the sideloaded includes indexed by id. Mirrors
+ * `mapTicketData` — the only I/O is upstream in {@link loadProjectRuns}.
+ */
+export declare function mapRunData(item: JsonApiResource, ticketsById: Map<string, JsonApiResource>): RunRow;
+/**
+ * List the `gaia_run` entities of a project, most-recently-started first.
+ * Filtered by `ticket_id.project_id.id`, includes `ticket_id`, sorts
+ * `started_at` DESC, pages 50 (deeper history via offset is a later follow-up).
+ */
+export declare function loadProjectRuns(client: DropshClient, projectId: string): Promise<RunRow[]>;
+/** The selected run's ticket id, or null when out of range / ticket-less. */
+export declare function selectedRunTicketId(rows: Pick<RunRow, 'ticketId'>[], index: number): string | null;

package/dist/src/Service/run-data.js

@@ -0,0 +1,62 @@
+// Project-scoped run list reads — through the dropsh JSON:API client
+// (`services.client`). Every rendered object is a `gaia_run` Drupal entity
+// (AC-5). Runs are scoped to the selected project via the nested filter
+// `ticket_id.project_id.id` (a project may span several conductors, so the
+// ticket→project relationship is the canonical scope, not `conductor_id`).
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+/** Read a value as a string, or `undefined` when it is not one. */
+function str(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Map a RAW JSON:API `data[]` entry (from `client.get`) to a run row, resolving
+ * the ticket identifier from the sideloaded includes indexed by id. Mirrors
+ * `mapTicketData` — the only I/O is upstream in {@link loadProjectRuns}.
+ */
+export function mapRunData(item, ticketsById) {
+    const a = item.attributes ?? {};
+    const ticketRel = item.relationships?.ticket_id?.data;
+    const ticketId = Array.isArray(ticketRel)
+        ? (ticketRel[0]?.id ?? null)
+        : (ticketRel?.id ?? null);
+    const ticket = ticketId ? ticketsById.get(ticketId) : undefined;
+    const drupalId = typeof a.drupal_internal__id === 'number' ||
+        typeof a.drupal_internal__id === 'string'
+        ? a.drupal_internal__id
+        : null;
+    return {
+        id: item.id ?? '',
+        drupalId,
+        ticketId,
+        ticketIdentifier: str(ticket?.attributes?.identifier) ?? (ticketId ? ticketId : '—'),
+        state: str(a.state) ?? 'unknown',
+        phase: str(a.state_at_start) ?? '—',
+        agent: str(a.agent) ?? '—',
+        startedAt: str(a.started_at) ?? str(a.created) ?? null,
+        heartbeat: str(a.heartbeat) ?? null,
+        claimExpiresAt: str(a.claim_expires_at) ?? null,
+    };
+}
+/**
+ * List the `gaia_run` entities of a project, most-recently-started first.
+ * Filtered by `ticket_id.project_id.id`, includes `ticket_id`, sorts
+ * `started_at` DESC, pages 50 (deeper history via offset is a later follow-up).
+ */
+export async function loadProjectRuns(client, projectId) {
+    const params = new DrupalJsonApiParams();
+    params.addFilter('ticket_id.project_id.id', projectId);
+    params.addInclude(['ticket_id']);
+    params.addSort('started_at', 'DESC');
+    params.addPageLimit(50);
+    const doc = (await client.get('gaia_run/gaia_run', params));
+    const ticketsById = new Map();
+    for (const inc of doc?.included ?? []) {
+        if (inc.id)
+            ticketsById.set(inc.id, inc);
+    }
+    return (doc?.data ?? []).map((item) => mapRunData(item, ticketsById));
+}
+/** The selected run's ticket id, or null when out of range / ticket-less. */
+export function selectedRunTicketId(rows, index) {
+    return rows[index]?.ticketId ?? null;
+}

package/dist/src/Service/ticket-data.d.ts

@@ -0,0 +1,6 @@
+import type { DropshClient, TicketDetailDocument } from '../types.js';
+/**
+ * Load one ticket's full detail document (the entity + its sideloaded
+ * comments, sub-tickets, runs and referenced tickets).
+ */
+export declare function loadTicketDetail(client: DropshClient, ticketId: string): Promise<TicketDetailDocument>;

package/dist/src/Service/ticket-data.js

@@ -0,0 +1,7 @@
+/**
+ * Load one ticket's full detail document (the entity + its sideloaded
+ * comments, sub-tickets, runs and referenced tickets).
+ */
+export function loadTicketDetail(client, ticketId) {
+    return client.get(`gaia_ticket/gaia_ticket/${ticketId}?include=comments,sub_tickets,runs,referenced_tickets`);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+import gaiaUiPlugin from './plugin.js';
+export default gaiaUiPlugin;
+export type { GaiaUiOptions } from './plugin.js';
+export declare const ticketRendererPlugin: typeof gaiaUiPlugin;
+export { type DropshBuildProgram, type DropshProgram, type GaiaUiLauncherOptions, type HomeConnection, runGaiaUi, } from './launcher.js';
+export type { HostedAgent, TuiAgentService } from './types.js';

package/dist/src/index.js

@@ -0,0 +1,10 @@
+import gaiaUiPlugin from './plugin.js';
+// The dropsh `tui` renderer plugin factory (default export) — the conductor's
+// plugin resolver auto-picks the default.
+export default gaiaUiPlugin;
+// Back-compat alias for the former package's named export.
+export const ticketRendererPlugin = gaiaUiPlugin;
+// GAIA-194 AC-4/AC-5: the home-rooted launcher (dropsh-tui invocation moved out
+// of the conductor `gaia ui` command). herdr-agnostic (agent impl injected) and
+// dropsh-decoupled (buildProgram injected).
+export { runGaiaUi, } from './launcher.js';