@gaia-ai/addon-gaia-ui 0.11.1 → 0.11.2

package/dist/src/Agent/Component/agent-list/index.d.ts

@@ -0,0 +1,6 @@
+import type { HostedAgent } from '../../../types.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export declare function agentListRows(agents: HostedAgent[]): string[];

package/dist/src/Agent/Component/agent-list/index.js

@@ -0,0 +1,14 @@
+import { pad } from '../../../lib/format.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export function agentListRows(agents) {
+    const header = `${pad('AGENT', 32)} PROJECT`;
+    if (agents.length === 0)
+        return [header, 'No ticket agents.'];
+    return [
+        header,
+        ...agents.map((a) => `${pad(a.label || a.id, 32)} ${a.group}`),
+    ];
+}

package/dist/src/Component/agent-list/index.d.ts

@@ -0,0 +1,6 @@
+import type { HostedAgent } from '../../types.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export declare function agentListRows(agents: HostedAgent[]): string[];

package/dist/src/Component/agent-list/index.js

@@ -0,0 +1,14 @@
+import { pad } from '../../lib/format.js';
+/** A fixed-column flat table for the Ticket-Agents screen: header + one line per
+ *  live agent (its label · the project/group it runs for). One physical row per
+ *  entry, so the Kernel's `1 + index` selection math holds. The agents are the
+ *  host's live set (from `list(group)`); a finished agent drops out on refresh. */
+export function agentListRows(agents) {
+    const header = `${pad('AGENT', 32)} PROJECT`;
+    if (agents.length === 0)
+        return [header, 'No ticket agents.'];
+    return [
+        header,
+        ...agents.map((a) => `${pad(a.label || a.id, 32)} ${a.group}`),
+    ];
+}

package/dist/src/Component/comment-item/index.d.ts

@@ -0,0 +1,21 @@
+/** One collapsible comment entry for the Comments tab. */
+export interface CommentItem {
+    type: string;
+    author: string;
+    created: string | null;
+    bodyLines: string[];
+    preview: string;
+}
+/** The rendered Comments-tab view. */
+export interface CommentsTabView {
+    lines: string[];
+    boldRows: Set<number>;
+    headerRows: number[];
+    selectable: number;
+}
+/** The relative age of a comment's ISO `created`, or '—' when unknown. */
+export declare function relativeCreated(created: string | null | undefined, nowSeconds: number): string;
+export declare function commentsTabView(items: CommentItem[], { expanded, nowSeconds, }?: {
+    expanded?: Set<number>;
+    nowSeconds?: number;
+}): CommentsTabView;

package/dist/src/Component/comment-item/index.js

@@ -0,0 +1,39 @@
+import { humanizeAge } from '../../Deriver/liveness.js';
+/** The relative age of a comment's ISO `created`, or '—' when unknown. */
+export function relativeCreated(created, nowSeconds) {
+    const ms = created ? Date.parse(created) : Number.NaN;
+    return Number.isNaN(ms)
+        ? '—'
+        : humanizeAge(Math.floor(ms / 1000), nowSeconds);
+}
+// The Comments tab: one collapsible entry per comment. Collapsed = a single
+// caret header row (`▸ type · author · age · preview`); expanded (`▾`) appends
+// the full body, one physical row per body line. `headerRows[i]` is the row
+// index of comment i's header (for selection highlight + scroll).
+export function commentsTabView(items, { expanded = new Set(), nowSeconds = 0, } = {}) {
+    if (!items.length) {
+        return {
+            lines: ['No comments.'],
+            boldRows: new Set(),
+            headerRows: [],
+            selectable: 0,
+        };
+    }
+    const lines = [];
+    const boldRows = new Set();
+    const headerRows = [];
+    items.forEach((item, i) => {
+        headerRows.push(lines.length);
+        boldRows.add(lines.length);
+        const caret = expanded.has(i) ? '▾' : '▸';
+        const age = relativeCreated(item.created, nowSeconds);
+        const author = item.author || '—';
+        lines.push(`${caret} ${item.type} · ${author} · ${age} · ${item.preview}`);
+        if (expanded.has(i)) {
+            for (const bodyLine of item.bodyLines)
+                lines.push(`    ${bodyLine}`);
+            lines.push('');
+        }
+    });
+    return { lines, boldRows, headerRows, selectable: items.length };
+}

package/dist/src/Component/create-form/index.d.ts

@@ -0,0 +1,3 @@
+import type { CreateFormOptions, CreateFormState } from '../../Service/create-form.js';
+/** Render the "New ticket" popup form as plain rows (the kernel frames it). */
+export declare function createFormLines(s: CreateFormState, opts: CreateFormOptions): string[];

package/dist/src/Component/create-form/index.js

@@ -0,0 +1,26 @@
+const labelOf = (list, id) => list.find((o) => o.id === id)?.label ?? '—';
+/** Render the "New ticket" popup form as plain rows (the kernel frames it). */
+export function createFormLines(s, opts) {
+    const mark = (i) => (s.active === i ? '▸ ' : '  ');
+    const lines = [];
+    lines.push(`${mark(0)}Description:`);
+    const body = s.description.length ? s.description.split('\n') : ['<empty>'];
+    for (const line of body)
+        lines.push(`    ${line}`);
+    lines.push(`${mark(1)}Assignee:  < ${labelOf(opts.users, s.assignee)} >`);
+    lines.push(`${mark(2)}Conductor: < ${labelOf(opts.conductors, s.conductor)} >`);
+    lines.push(`${mark(3)}Labels:`);
+    if (opts.labels.length === 0) {
+        lines.push('    (none available)');
+    }
+    else {
+        opts.labels.forEach((o, i) => {
+            const box = s.labels.has(o.id) ? '[x]' : '[ ]';
+            const cursor = s.active === 3 && s.labelCursor === i ? '›' : ' ';
+            lines.push(`   ${cursor}${box} ${o.label}`);
+        });
+    }
+    lines.push(`${mark(4)}Workflow:  < ${labelOf(opts.workflows, s.workflow)} >`);
+    lines.push(`${mark(5)}[ Create ticket ]`);
+    return lines;
+}

package/dist/src/Component/dashboard-list/index.d.ts

@@ -0,0 +1,8 @@
+/** The minimum shape a dashboard row needs to render. */
+export interface DashboardRowInput {
+    project: string;
+    derivedStatus: string;
+    ageLabel: string;
+}
+/** One line per project: name, derived status, relative age. */
+export declare function dashboardRows(projects: DashboardRowInput[]): string[];

package/dist/src/Component/dashboard-list/index.js

@@ -0,0 +1,7 @@
+import { pad } from '../../lib/format.js';
+/** One line per project: name, derived status, relative age. */
+export function dashboardRows(projects) {
+    if (projects.length === 0)
+        return ['No projects.'];
+    return projects.map((p) => `${pad(p.project, 24)} ${pad(p.derivedStatus, 14)} ${p.ageLabel}`);
+}

package/dist/src/Component/project-picker/index.d.ts

@@ -0,0 +1,15 @@
+/** A project that claims the repo. */
+export interface PickerCandidate {
+    id: string;
+    name: string;
+}
+/**
+ * The picker screen's rows: a heading naming the repo, then one row per
+ * candidate with `▸` on the selected one.
+ */
+export declare function projectPickerRows(candidates: PickerCandidate[], repo: string, selected: number): string[];
+/**
+ * The non-TTY form (spec Decision 11): the candidate list plus the direct
+ * command, printed once so `gaia ui --here | cat` stays scriptable — no prompt.
+ */
+export declare function projectPickerHint(candidates: PickerCandidate[], repo: string): string;

package/dist/src/Component/project-picker/index.js

@@ -0,0 +1,42 @@
+// GAIA-223 AC-8 (spec Decision 14) — the picker `gaia ui --here` shows when the
+// cwd's repo is claimed by MORE THAN ONE gaia project.
+//
+// One repo mapping to several projects is designed for, not an edge case:
+// GAIA-126/137 let `.gaia/` hold one conductor config per project, which is how
+// a Drupal multisite repo maps each site to its own GAIA project. Erroring on
+// N>1 would fail permanently, by design, in exactly the repos the feature is
+// most useful in — so the ambiguity is shown rather than resolved behind the
+// user's back.
+//
+// Pure, like every other Component: candidates in, rows out. The kernel owns
+// selection state, Enter and Esc.
+/** Clamp a selection index into the candidate range (0 when there are none). */
+function clamp(selected, length) {
+    if (length <= 0)
+        return 0;
+    return Math.max(0, Math.min(Math.trunc(selected), length - 1));
+}
+/**
+ * The picker screen's rows: a heading naming the repo, then one row per
+ * candidate with `▸` on the selected one.
+ */
+export function projectPickerRows(candidates, repo, selected) {
+    const heading = [`Several gaia projects claim ${repo} — which one?`, ''];
+    if (candidates.length === 0) {
+        return [...heading, 'No projects.'];
+    }
+    const index = clamp(selected, candidates.length);
+    return [
+        ...heading,
+        ...candidates.map((c, i) => `${i === index ? '▸' : ' '} ${c.name}`),
+    ];
+}
+/**
+ * The non-TTY form (spec Decision 11): the candidate list plus the direct
+ * command, printed once so `gaia ui --here | cat` stays scriptable — no prompt.
+ */
+export function projectPickerHint(candidates, repo) {
+    const names = candidates.map((c) => `  ${c.name}`).join('\n');
+    return (`Several gaia projects claim ${repo}:\n${names}\n` +
+        "Open one directly with 'gaia ui project:<name>'.");
+}

package/dist/src/Component/run-table/index.d.ts

@@ -0,0 +1,10 @@
+import type { RunRow } from '../../Service/run-data.js';
+/**
+ * A fixed-column flat table of a project's runs: header + one line per run.
+ * Columns RUN · TICKET · STATE · PHASE · AGENT · STARTED, mirroring
+ * `ticketTableRows` (1 logical entry = 1 physical row). STATE is the derived
+ * liveness status and STARTED is the relative start age.
+ */
+export declare function runTableRows(runs: RunRow[], nowSeconds: number, { emptyMessage }?: {
+    emptyMessage?: string | undefined;
+}): string[];

package/dist/src/Component/run-table/index.js

@@ -0,0 +1,20 @@
+import { deriveRunStatus, runStartedAge } from '../../Deriver/run-status.js';
+import { pad } from '../../lib/format.js';
+/**
+ * A fixed-column flat table of a project's runs: header + one line per run.
+ * Columns RUN · TICKET · STATE · PHASE · AGENT · STARTED, mirroring
+ * `ticketTableRows` (1 logical entry = 1 physical row). STATE is the derived
+ * liveness status and STARTED is the relative start age.
+ */
+export function runTableRows(runs, nowSeconds, { emptyMessage } = {}) {
+    const header = `${pad('RUN', 8)} ${pad('TICKET', 10)} ${pad('STATE', 8)} ${pad('PHASE', 10)} ${pad('AGENT', 8)} STARTED`;
+    if (runs.length === 0)
+        return [header, emptyMessage ?? 'No runs for this project.'];
+    return [
+        header,
+        ...runs.map((r) => {
+            const run = `#${r.drupalId ?? r.id.slice(0, 6)}`;
+            return `${pad(run, 8)} ${pad(r.ticketIdentifier, 10)} ${pad(deriveRunStatus(r, nowSeconds), 8)} ${pad(r.phase, 10)} ${pad(r.agent, 8)} ${runStartedAge(r, nowSeconds)}`;
+        }),
+    ];
+}

package/dist/src/Component/tab-bar/index.d.ts

@@ -0,0 +1,20 @@
+/** One ticket-detail tab: its id, label, and the section headings it groups. */
+export interface DetailTab {
+    id: string;
+    label: string;
+    headings: string[];
+}
+export declare const DETAIL_TABS: DetailTab[];
+/** The tab bar as a single row; the active tab is bracketed. */
+export declare function tabBar(activeIndex: number): string;
+/** Where one detail tab sits inside the bar: `[start, end)` in display columns
+ *  from the bar's own first column. */
+export interface DetailTabSpan {
+    index: number;
+    start: number;
+    end: number;
+}
+/** The bar's own hit map, built from the SAME `segment`/`SEPARATOR` the rendered
+ *  bar is joined from — see `Component/top-tabs/index.ts`'s `topTabSpans` for the
+ *  full argument. */
+export declare function detailTabSpans(activeIndex: number): DetailTabSpan[];

package/dist/src/Component/tab-bar/index.js

@@ -0,0 +1,42 @@
+import { displayWidth } from '../../lib/width.js';
+// The ticket-detail screen is split into tabs so only one tab's content draws at
+// a time (keeps the fixed-height window small) — Sub-tickets + Referenced share a
+// Related tab, Comments is its own tab with collapsible entries (owned by the
+// plugin's draw loop, which needs the interactive expand state).
+export const DETAIL_TABS = [
+    {
+        id: 'overview',
+        label: 'Overview',
+        headings: ['Description', 'Branch', 'Links', 'Environments'],
+    },
+    { id: 'comments', label: 'Comments', headings: [] },
+    {
+        id: 'related',
+        label: 'Related',
+        headings: ['Sub-tickets', 'Referenced tickets'],
+    },
+    { id: 'runs', label: 'Runs', headings: ['Runs'] },
+];
+/** What joins two tabs in the rendered bar — part of neither tab's span. */
+const SEPARATOR = ' ';
+/** One tab's rendered segment: bracketed when active, space-padded otherwise. */
+const segment = (tab, index, activeIndex) => index === activeIndex ? `[${tab.label}]` : ` ${tab.label} `;
+/** The tab bar as a single row; the active tab is bracketed. */
+export function tabBar(activeIndex) {
+    return DETAIL_TABS.map((t, i) => segment(t, i, activeIndex)).join(SEPARATOR);
+}
+/** The bar's own hit map, built from the SAME `segment`/`SEPARATOR` the rendered
+ *  bar is joined from — see `Component/top-tabs/index.ts`'s `topTabSpans` for the
+ *  full argument. */
+export function detailTabSpans(activeIndex) {
+    const spans = [];
+    let start = 0;
+    DETAIL_TABS.forEach((tab, index) => {
+        if (index > 0)
+            start += displayWidth(SEPARATOR);
+        const width = displayWidth(segment(tab, index, activeIndex));
+        spans.push({ index, start, end: start + width });
+        start += width;
+    });
+    return spans;
+}

package/dist/src/Component/ticket-detail/index.d.ts

@@ -0,0 +1,38 @@
+import type { TicketDetailDocument } from '../../types.js';
+import type { CommentItem } from '../comment-item/index.js';
+import type { Section } from '../section-list/index.js';
+/**
+ * The `expandedComments` set a freshly opened ticket detail starts with: the
+ * newest comment expanded, every older one collapsed.
+ *
+ * It lives beside the sort on purpose — "index 0 is the newest" is one module's
+ * invariant, so the kernel never needs to know which index that is.
+ */
+export declare function initialExpandedComments(document: TicketDetailDocument): Set<number>;
+/**
+ * The ticket detail sections, each with an explicit empty state:
+ * Description, Comments, Sub-tickets, Runs, Referenced tickets, Links,
+ * Branch, Environments.
+ */
+export declare function detailSections(document: TicketDetailDocument): Section[];
+/** The detailSections that belong to a given (non-comments) tab, in tab order. */
+export declare function sectionsForTab(document: TicketDetailDocument, tabIndex: number): Section[];
+/**
+ * One item per comment for the collapsible Comments tab: type, author, created
+ * (raw ISO — the plugin formats the relative age), the body split into physical
+ * lines, and a first-line preview for the collapsed header.
+ */
+export declare function commentItems(document: TicketDetailDocument): CommentItem[];
+export declare function detailLines(detail?: TicketDetailDocument | null): {
+    lines: string[];
+    boldRows: Set<number>;
+};
+export declare function tabViewLines(detail: TicketDetailDocument | null | undefined, tabIndex: number, { expanded, nowSeconds, }?: {
+    expanded?: Set<number>;
+    nowSeconds?: number;
+}): {
+    lines: string[];
+    boldRows: Set<number>;
+    headerRows: number[];
+    selectable: number;
+};

package/dist/src/Component/ticket-detail/index.js

@@ -0,0 +1,193 @@
+// The ticket-detail screen: composes section-list (flatten + markdown bold),
+// tab-bar (DETAIL_TABS) and comment-item (the collapsible Comments tab) into
+// the two shapes the plugin's draw loop consumes — the whole document
+// flattened (`detailLines`, non-TTY/back-compat) and one tab at a time
+// (`tabViewLines`, the interactive screen).
+import { asString } from '../../lib/format.js';
+import { commentsTabView } from '../comment-item/index.js';
+import { flattenSections } from '../section-list/index.js';
+import { DETAIL_TABS } from '../tab-bar/index.js';
+function fieldValue(value) {
+    if (value && typeof value === 'object' && 'value' in value) {
+        const inner = value.value;
+        if (typeof inner === 'string')
+            return inner;
+    }
+    return typeof value === 'string' ? value : '';
+}
+function refCount(document, name) {
+    const data = document.data?.relationships?.[name]?.data;
+    return Array.isArray(data) ? data.length : data ? 1 : 0;
+}
+/**
+ * Newest-first — the exact reversal of the server's total order
+ * (`CommentsItemList`: `created ASC, id ASC`), three keys applied in turn:
+ * `created` DESC, then `drupal_internal__id` DESC (the server's own monotonic
+ * key, so two comments written in the same second keep the server's relative
+ * order, reversed), then the resource `id` DESC.
+ *
+ * The third key exists to make the comparator TOTAL rather than leaning on
+ * `Array.prototype.sort` being stable in modern V8: the order must be
+ * *deterministic* — identical for the same comments in any input order, and
+ * defined even for a fixture or partial include that carries no
+ * `drupal_internal__id`. Stability would only preserve whatever order the
+ * include happened to arrive in.
+ *
+ * A missing or unparseable `created` sorts LAST (treated as the oldest), so a
+ * malformed row can never take the top slot and steal the default expansion.
+ */
+function compareCommentsNewestFirst(a, b) {
+    const at = Date.parse(asString(a.attributes?.created) ?? '');
+    const bt = Date.parse(asString(b.attributes?.created) ?? '');
+    const aUnknown = Number.isNaN(at);
+    const bUnknown = Number.isNaN(bt);
+    if (aUnknown !== bUnknown)
+        return aUnknown ? 1 : -1;
+    if (!aUnknown && at !== bt)
+        return bt - at;
+    const ai = Number(a.attributes?.drupal_internal__id);
+    const bi = Number(b.attributes?.drupal_internal__id);
+    if (!Number.isNaN(ai) && !Number.isNaN(bi) && ai !== bi)
+        return bi - ai;
+    // Code-unit comparison, not localeCompare: a locale-sensitive collation would
+    // put the "deterministic" back in the hands of the runtime's locale data.
+    const aid = a.id ?? '';
+    const bid = b.id ?? '';
+    return aid === bid ? 0 : aid < bid ? 1 : -1;
+}
+/**
+ * The document's `gaia_comment` includes, NEWEST FIRST.
+ *
+ * This is the single function both renderings read — `detailSections`' Comments
+ * section (→ `detailLines`, the non-TTY render) and `commentItems` (→ the
+ * interactive Comments tab) — so newest-first is one line of code and the two
+ * orders structurally cannot drift.
+ *
+ * It sorts the copy `filter` already allocated and NEVER `document.included`
+ * itself: that array is mixed (comments *plus* sub-tickets, runs and referenced
+ * tickets) and shared with those consumers, so an in-place sort would be an
+ * invisible side effect on someone else's input.
+ */
+function commentResources(document) {
+    return (document.included ?? [])
+        .filter((r) => r.type === 'gaia_comment--gaia_comment')
+        .sort(compareCommentsNewestFirst);
+}
+/**
+ * The `expandedComments` set a freshly opened ticket detail starts with: the
+ * newest comment expanded, every older one collapsed.
+ *
+ * It lives beside the sort on purpose — "index 0 is the newest" is one module's
+ * invariant, so the kernel never needs to know which index that is.
+ */
+export function initialExpandedComments(document) {
+    return commentResources(document).length
+        ? new Set([0])
+        : new Set();
+}
+/**
+ * The ticket detail sections, each with an explicit empty state:
+ * Description, Comments, Sub-tickets, Runs, Referenced tickets, Links,
+ * Branch, Environments.
+ */
+export function detailSections(document) {
+    const a = document.data?.attributes ?? {};
+    const sections = [];
+    const description = fieldValue(a.description);
+    sections.push({
+        heading: 'Description',
+        lines: description ? description.split('\n') : ['No description.'],
+    });
+    const comments = commentResources(document);
+    sections.push({
+        heading: 'Comments',
+        // One physical line per body line: a `— type ·` marker followed by the body
+        // split on '\n' (mirrors the Description section). Keeping a multi-line body
+        // in a single entry breaks draw()'s one-entry-one-row invariant (AC-4).
+        lines: comments.length
+            ? comments.flatMap((c) => {
+                const type = asString(c.attributes?.gaia_comment_type) ?? 'comment';
+                const body = fieldValue(c.attributes?.body);
+                return [`— ${type} ·`, ...(body ? body.split('\n') : [''])];
+            })
+            : ['No comments.'],
+    });
+    const relSection = (heading, rel) => {
+        const n = refCount(document, rel);
+        sections.push({
+            heading,
+            lines: n
+                ? [`${n} ${heading.toLowerCase()}`]
+                : [`No ${heading.toLowerCase()}.`],
+        });
+    };
+    relSection('Sub-tickets', 'sub_tickets');
+    relSection('Runs', 'runs');
+    relSection('Referenced tickets', 'referenced_tickets');
+    const links = Array.isArray(a.links) ? a.links : [];
+    sections.push({
+        heading: 'Links',
+        lines: links.length
+            ? links.map((l) => {
+                const link = l;
+                return `${link.title ?? ''} ${link.uri ?? link.url ?? ''}`.trim();
+            })
+            : ['No links.'],
+    });
+    sections.push({
+        heading: 'Branch',
+        lines: [
+            `branch: ${asString(a.branch_name) ?? '—'}`,
+            `base:   ${asString(a.base_branch) ?? '—'}`,
+        ],
+    });
+    relSection('Environments', 'environments');
+    return sections;
+}
+/** The detailSections that belong to a given (non-comments) tab, in tab order. */
+export function sectionsForTab(document, tabIndex) {
+    const tab = DETAIL_TABS[tabIndex];
+    const headings = tab?.headings ?? [];
+    if (!headings.length)
+        return [];
+    const byHeading = new Map(detailSections(document).map((s) => [s.heading, s]));
+    return headings
+        .map((h) => byHeading.get(h))
+        .filter((s) => s !== undefined);
+}
+/**
+ * One item per comment for the collapsible Comments tab: type, author, created
+ * (raw ISO — the plugin formats the relative age), the body split into physical
+ * lines, and a first-line preview for the collapsed header.
+ */
+export function commentItems(document) {
+    const comments = commentResources(document);
+    return comments.map((c) => {
+        const type = asString(c.attributes?.gaia_comment_type) ?? 'comment';
+        const author = asString(c.attributes?.author_name) ?? '';
+        const created = asString(c.attributes?.created) ?? null;
+        const body = fieldValue(c.attributes?.body);
+        const bodyLines = body ? body.split('\n') : [''];
+        return { type, author, created, bodyLines, preview: bodyLines[0] ?? '' };
+    });
+}
+// The whole ticket-detail document flattened (all sections) — the NON-TTY ticket
+// render, printed verbatim by the kernel when stdout is not a terminal
+// (`Kernel/tui-kernel.ts:147`), i.e. what `gaia ui GAIA-nnn | cat` shows. The
+// interactive screen renders one tab at a time via tabViewLines instead.
+export function detailLines(detail) {
+    return flattenSections(detailSections(detail ?? {}));
+}
+// The rows for one detail tab. The Comments tab is the collapsible list; every
+// other tab flattens just its own sections. Returns `selectable`/`headerRows`
+// so the draw loop can highlight + scroll the selected comment (0 elsewhere).
+export function tabViewLines(detail, tabIndex, { expanded = new Set(), nowSeconds = 0, } = {}) {
+    if (DETAIL_TABS[tabIndex]?.id === 'comments') {
+        return commentsTabView(commentItems(detail ?? {}), {
+            expanded,
+            nowSeconds,
+        });
+    }
+    const { lines, boldRows } = flattenSections(sectionsForTab(detail ?? {}, tabIndex));
+    return { lines, boldRows, headerRows: [], selectable: 0 };
+}

package/dist/src/Component/ticket-table/index.d.ts

@@ -0,0 +1,5 @@
+import type { TicketRow } from '../../Service/project-data.js';
+/** A fixed-column flat table: header + one line per ticket. */
+export declare function ticketTableRows(tickets: TicketRow[], { emptyMessage }?: {
+    emptyMessage?: string | undefined;
+}): string[];

package/dist/src/Component/ticket-table/index.js

@@ -0,0 +1,14 @@
+import { pad } from '../../lib/format.js';
+/** A fixed-column flat table: header + one line per ticket. */
+export function ticketTableRows(tickets, { emptyMessage } = {}) {
+    const header = `${pad('IDENTIFIER', 10)} ${pad('STATE', 8)} ${pad('PRIO', 5)} ${pad('WHO', 4)} ${pad('RUN', 8)} ${pad('PARENT', 10)} ${pad('COND', 14)} TITLE`;
+    if (tickets.length === 0)
+        return [header, emptyMessage ?? 'No tickets.'];
+    return [
+        header,
+        ...tickets.map((t) => {
+            const labels = t.labels?.length ? `  [${t.labels.join(',')}]` : '';
+            return `${pad(t.identifier, 10)} ${pad(t.state, 8)} ${pad(t.priority ?? '—', 5)} ${pad(t.assigneeInitials || '—', 4)} ${pad(t.derivedStatus, 8)} ${pad(t.parent ?? '—', 10)} ${pad(t.conductor ?? '—', 14)} ${t.title}${labels}`;
+        }),
+    ];
+}

package/dist/src/Component/ticket-teaser/index.d.ts

@@ -0,0 +1,7 @@
+import type { TicketDetailDocument, UiViewMode } from '../../types.js';
+/**
+ * A ticket rendered compactly, with the field set of its Drupal view-mode
+ * display. `full` never reaches here — the kernel renders the tabbed detail for
+ * it — but it is accepted and treated as `teaser` so the function is total.
+ */
+export declare function ticketTeaserLines(document: TicketDetailDocument, mode: UiViewMode): string[];

package/dist/src/Component/ticket-teaser/index.js

@@ -0,0 +1,76 @@
+// GAIA-223 AC-7 — the compact ticket block behind `gaia ui <ticket> --view
+// teaser|board_card` (spec Decision 13, variant A).
+//
+// THE FIELD SETS BELOW ARE A DELIBERATE DUPLICATE of two Drupal displays:
+//   config/sync/core.entity_view_display.gaia_ticket.gaia_ticket.teaser.yml
+//     → gaia_theme:ticket-row — identifier, title, state, derived_status,
+//       since_label, claim_machine, assignee_{name,initials,color}
+//   config/sync/core.entity_view_display.gaia_ticket.gaia_ticket.board_card.yml
+//     → gaia_theme:board-card — identifier, title, state, workflow(type),
+//       derived_status, priority, url; footer slot: claim_machine
+//
+// Why duplicated: those displays are display_builder→SDC bindings producing
+// HTML, JSON:API never serves rendered output, and NEITHER the `session` nor the
+// `pm` scope may read `entity_view_display` (both come back empty with
+// "insufficient authorization"). Reading the mapping at runtime — variant B — is
+// the named follow-up in the spec's *Out of scope*; it needs a `gaia_session`
+// read permission in `config/sync` AND the recipe copy, plus proof that
+// `third_party_settings` survives JSON:API serialization. When that lands, this
+// module is the ONE place that changes; the `--view` CLI surface is identical
+// either way. Until then, this file drifting from those YAMLs is the accepted
+// cost, named in Decision 13.
+import { asString } from '../../lib/format.js';
+/** The same em-dash placeholder ticket-table/run-table use for a missing value. */
+const MISSING = '—';
+/** Left column width, so the labels line up like the other components' columns. */
+const LABEL_WIDTH = 10;
+function row(label, value) {
+    return `${label.padEnd(LABEL_WIDTH)} ${value}`;
+}
+/** An attribute as a display string, or the shared placeholder. */
+function attr(attributes, key) {
+    const raw = attributes[key];
+    if (typeof raw === 'string' && raw !== '')
+        return raw;
+    if (typeof raw === 'number')
+        return String(raw);
+    return MISSING;
+}
+/**
+ * A ticket rendered compactly, with the field set of its Drupal view-mode
+ * display. `full` never reaches here — the kernel renders the tabbed detail for
+ * it — but it is accepted and treated as `teaser` so the function is total.
+ */
+export function ticketTeaserLines(document, mode) {
+    const a = document.data?.attributes ?? {};
+    const heading = `${attr(a, 'identifier')} · ${attr(a, 'title')}`;
+    if (mode === 'board_card') {
+        return [
+            heading,
+            '',
+            row('state', attr(a, 'state')),
+            row('type', attr(a, 'workflow')),
+            row('status', attr(a, 'derived_status')),
+            row('priority', attr(a, 'priority')),
+            row('claim', attr(a, 'claim_machine')),
+        ];
+    }
+    // `teaser`. The display binds assignee_name + assignee_initials + a colour;
+    // the terminal block shows the name with the initials as its short handle.
+    const name = attr(a, 'assignee_name');
+    const initials = asString(a.assignee_initials);
+    const assignee = name === MISSING
+        ? (initials ?? MISSING)
+        : initials
+            ? `${name} (${initials})`
+            : name;
+    return [
+        heading,
+        '',
+        row('state', attr(a, 'state')),
+        row('status', attr(a, 'derived_status')),
+        row('since', attr(a, 'since_label')),
+        row('assignee', assignee),
+        row('claim', attr(a, 'claim_machine')),
+    ];
+}