@gaia-ai/addon-gaia-ui 0.17.2 → 0.19.0

package/dist/src/Entity/ticket/Component/edit-form/index.js

@@ -56,7 +56,7 @@ const WARNING_INDENT = 2;
  *  Parent/Labels are structural (GAIA-360). The duration grammar is named
  *  because the popup has no validation channel: an unparseable entry is
  *  silently left unwritten, so the accepted spelling has to be on screen. */
-const LEGEND = 'Assignee = human ownership · Conductor = who works it next · ' +
+const LEGEND = 'Assignee = human ownership · Reviewers = named reviewers · Conductor = who works it next · ' +
     'Estimate/Spent = accounted time, not the run footprint (1d 2h 30m, 90m, or a bare number as minutes) · ' +
     'Parent = optional parent ticket · Labels = multi-select from gaia_labels · ' +
     'Cancel ticket abandons a non-terminal ticket (Esc closes and writes nothing)';
@@ -100,7 +100,14 @@ export function editFormTree(fields, s, opts, chrome = {}) {
             'a conductor';
         rows.push(...proseNodes(`⚠ ${run.identifier} is being worked on by ${who} (run: ${run.runState}).`, width, 'edit-form-run'), underNode('Reassigning does not stop that run;', width, 'edit-form-run-keeps'), underNode('clearing the conductor stops the NEXT dispatch.', width, 'edit-form-run-next'), textNode({ id: 'edit-form-run-gap', content: '' }));
     }
-    rows.push(renderDeclaredFieldsTree(fields, s, opts, { width }));
+    const errors = (opts.errors ?? {});
+    const reason = (field) => {
+        const message = field.from === undefined ? undefined : errors[field.from];
+        return message === undefined
+            ? undefined
+            : `${field.kind === 'multiselect' ? field.label : `${field.label} options`} could not be loaded: ${message}`;
+    };
+    rows.push(renderDeclaredFieldsTree(fields, s, opts, { width, errorFor: reason }));
     rows.push(textNode({ id: 'edit-form-gap', content: '' }));
     rows.push(...proseNodes(LEGEND, width, 'edit-form-legend'));
     // GAIA-391: the server's message is the whole of this line now. It used to

package/dist/src/Entity/ticket/Component/sections/index.js

@@ -8,9 +8,10 @@ const HEADINGS = {
     // where the ticket SITS in the work hierarchy (context) while links are
     // outbound artifacts of it. `Description` renders as one collapsible entry (see
     // `ticket-detail`'s `EXPANDABLE_HEADINGS`), and `Assignment` keeps its GAIA-233
-    // position immediately after it. GAIA-308: `Time` follows `Assignment` — a
-    // section no entry lists is invisible in the TTY rendering even though the flat
-    // `gaia ui GAIA-308 | cat` render still shows it.
+    // position immediately after it. Pending reviews sits between Assignment and
+    // Time when the current document carries submitted reviews. GAIA-308: `Time`
+    // follows that pair — a section no entry lists is invisible in the TTY
+    // rendering even though the flat `gaia ui GAIA-308 | cat` render still shows it.
     // GAIA-369 D3/D4: `Latest summary` sits directly ABOVE `Description` and is
     // collapsible through the same `EXPANDABLE_HEADINGS` path. Above, because the
     // newest phase handoff says where the work STANDS while the description says
@@ -28,6 +29,7 @@ const HEADINGS = {
         'Latest plan',
         'Description',
         'Assignment',
+        'Pending reviews',
         'Time',
         'Branch',
         'Environments',

package/dist/src/Entity/ticket/Component/ticket-content/index.d.ts

@@ -1,4 +1,5 @@
 import { type VNode } from '@opentui/core';
+import type { TicketAddons } from '../../Data/addons.js';
 import { type TicketContentEntry, type TicketContentModel, type TicketContentTab, type TicketProperty, type TicketSidebar } from './model.js';
 export declare const SIDEBAR_TABS: readonly [{
     readonly id: "details";
@@ -31,7 +32,23 @@ export interface TicketContentProps {
     /** The Planning document tab last chosen in this visit. */
     readonly documentKey?: string;
     readonly onDocumentTab: (key: string) => void;
+    /**
+     * The ticket's conductor-run addons (GAIA-661), rendered as a second,
+     * unlabeled card below the sidebar — never visible as "addon" wording.
+     * Absent (or empty) omits the card entirely.
+     */
+    readonly addonsPreview?: TicketAddons;
+    readonly onOpenAddons?: () => void;
 }
 /** The Planning pane's active document: the selection, the visit's tab, or Description. */
 export declare const activeDocumentKey: (documents: readonly TicketContentEntry[], selectedKey: string | undefined, documentKey: string | undefined) => string | undefined;
+/**
+ * The row id a Tab/arrow-key visit lands on for the inline messages card —
+ * exported so the screen can add it to `selectableKeys` and open the full
+ * send/poll screen on Enter, the same way Details/Stats/Related are reached
+ * by keyboard even though their own pane switching stays mouse-only.
+ */
+export declare const ADDONS_KEY = "addons-card";
+/** Whether the preview has at least one message worth a keyboard stop. */
+export declare const hasAddonsMessages: (preview: TicketAddons) => boolean;
 export declare function TicketContent(props: TicketContentProps): VNode;

package/dist/src/Entity/ticket/Component/ticket-content/index.js

@@ -357,6 +357,60 @@ const sidebarCard = (id, sidebar, props) => {
         ],
     });
 };
+/**
+ * The row id a Tab/arrow-key visit lands on for the inline messages card —
+ * exported so the screen can add it to `selectableKeys` and open the full
+ * send/poll screen on Enter, the same way Details/Stats/Related are reached
+ * by keyboard even though their own pane switching stays mouse-only.
+ */
+export const ADDONS_KEY = 'addons-card';
+/** Whether the preview has at least one message worth a keyboard stop. */
+export const hasAddonsMessages = (preview) => preview.addons.some((addon) => addon.messages.length > 0);
+/**
+ * The ticket's conductor-run messages (GAIA-661): one pressable line per
+ * message, opening the full send/poll screen, and the requester's own latest
+ * answer as a one-line preview. Nothing here ever reads "addon".
+ */
+const addonsCard = (id, preview, onOpen, selected) => {
+    if (preview.addons.length === 0)
+        return null;
+    const lines = [];
+    for (const addon of preview.addons) {
+        for (const message of addon.messages) {
+            lines.push(paragraphNode({
+                id: `${id}-${addon.name}-${message.key}`,
+                runs: [plainRun(message.label)],
+                fg: FOREGROUND_HIGHLIGHT,
+                onMouseDown: onOpen,
+            }));
+        }
+        const result = addon.latest?.result;
+        const answer = addon.contract === 2 && result && 'markdown' in result
+            ? result.markdown.split('\n')[0]
+            : undefined;
+        // The same wording as the Web card: never another requester's answer.
+        const markdown = addon.messages.length > 0 && !addon.latest
+            ? 'You have not sent a message to this addon.'
+            : answer === ''
+                ? 'Completed without a response.'
+                : answer;
+        if (markdown)
+            lines.push(paragraphNode({
+                id: `${id}-${addon.name}-latest`,
+                runs: [plainRun(markdown, DIM)],
+                fg: FOREGROUND,
+            }));
+    }
+    if (lines.length === 0)
+        return null;
+    return Card({
+        id: ticketContentRowId(ADDONS_KEY),
+        width: '100%',
+        paddingY: 1,
+        borderColor: selected ? FOREGROUND_HIGHLIGHT : BORDER,
+        children: lines,
+    });
+};
 const linksSection = (id, links, activateProperty) => {
     // Drop the `none` placeholder linkProperties emits for a linkless ticket, so
     // the section is omitted entirely rather than painting "links : none".
@@ -380,9 +434,13 @@ const overview = (id, props) => {
     const wide = props.terminalColumns >= WIDE_OVERVIEW_COLUMNS;
     const main = model.entries.filter((entry) => entry.key !== TECHNICAL_KEY);
     const links = linksSection(`${id}-links`, model.sidebar?.links ?? [], props.activateProperty);
-    const side = model.sidebar === undefined
+    const sidebar = model.sidebar === undefined
         ? null
         : sidebarCard(`${id}-sidebar`, model.sidebar, props);
+    const addons = props.addonsPreview
+        ? addonsCard(`${id}-addons`, props.addonsPreview, props.onOpenAddons, props.selectedKey === ADDONS_KEY)
+        : null;
+    const side = sidebar === null && addons === null ? null : [sidebar, addons];
     const sideBySide = wide && side !== null;
     return h(BoxRenderable, {
         id,
@@ -401,7 +459,7 @@ const overview = (id, props) => {
     }, overviewDocuments(`${id}-documents`, main, props), ...(links === null ? [] : [links])), ...(side === null
         ? []
         : [
-            column(`${id}-side`, { width: sideBySide ? '30%' : '100%', flexShrink: 0 }, side),
+            column(`${id}-side`, { width: sideBySide ? '30%' : '100%', flexShrink: 0, gap: 1 }, ...side.filter((node) => node !== null)),
         ]));
 };
 export function TicketContent(props) {

package/dist/src/Entity/ticket/Component/ticket-content/model.d.ts

@@ -52,7 +52,7 @@ export interface TicketContentModel {
 export type TicketContentTab = 'overview' | 'planning' | 'comments';
 export declare const documentTabLabel: (title: string) => string;
 export declare const FOOTPRINT_COLUMNS: readonly TicketMatrixColumn[];
-export declare function ticketContentModel(document: TicketDetailDocument, tab: TicketContentTab, labels: AssignmentLabels | undefined, nowSeconds: number): TicketContentModel;
+export declare function ticketContentModel(document: TicketDetailDocument, tab: TicketContentTab, labels: AssignmentLabels | undefined, nowSeconds: number, baseUrl?: string): TicketContentModel;
 export declare function ticketContentRowId(key: string): string;
 export declare function resolveSelectedKey(selectableKeys: readonly string[], previous: string | undefined): string | undefined;
 export declare function retainExpandedKeys(keys: readonly string[], previous: ReadonlySet<string>): Set<string>;

package/dist/src/Entity/ticket/Component/ticket-content/model.js

@@ -23,7 +23,7 @@ const PLANNING_DOCUMENTS = [
 ];
 const isBlankLine = (line) => lineText(line).trim() === '';
 const isBlankBody = (lines) => lines.length === 0 || lines.every(isBlankLine);
-const sectionByHeading = (document, labels, nowSeconds) => new Map(sectionsForTab(document, OVERVIEW_TAB, labels, nowSeconds).map((section) => [section.heading, section]));
+const sectionByHeading = (document, labels, nowSeconds, baseUrl) => new Map(sectionsForTab(document, OVERVIEW_TAB, labels, nowSeconds, baseUrl).map((section) => [section.heading, section]));
 const contentEntry = (key, title, expandable, collapsed, expanded, metadata) => metadata === undefined
     ? { key, title, expandable, collapsed, expanded }
     : { key, title, metadata, expandable, collapsed, expanded };
@@ -94,6 +94,23 @@ const lifecycleProperties = (document) => {
         })()),
         property('closed', attributes.closed === true ? 'yes' : 'no'),
     ];
+    const frozenAtRaw = attributes.frozen_at;
+    const frozenAt = asString(frozenAtRaw) ??
+        (typeof frozenAtRaw === 'number' && frozenAtRaw > 0
+            ? new Date(frozenAtRaw * 1000).toISOString()
+            : undefined);
+    if (attributes.frozen === true) {
+        extras.push(property('frozen', 'yes'));
+        if (frozenAt !== undefined)
+            extras.push(property('frozen at', frozenAt));
+    }
+    const stall = asString(attributes.stall_reason);
+    if (stall !== undefined) {
+        // `property()` treats values that start with "no " as empty states
+        // (`No conductor.` → none). `no conductor` is a real stall reason, so
+        // the value is kept verbatim.
+        extras.push({ key: 'stall', value: stall });
+    }
     const createdAt = asString(attributes.created);
     if (createdAt !== undefined)
         extras.push(property('created at', createdAt));
@@ -105,6 +122,7 @@ const lifecycleProperties = (document) => {
 const technicalProperties = (byHeading, document, labels) => {
     const assignment = byHeading.get('Assignment')?.lines ?? [];
     const assigned = [];
+    const reviewers = [];
     const conductor = [];
     for (const line of assignment) {
         const text = lineText(line).trim();
@@ -112,6 +130,10 @@ const technicalProperties = (byHeading, document, labels) => {
             assigned.push(property('assigned', ''));
         else if (text.startsWith('Assignee:'))
             assigned.push(property('assigned', colonValue(text)));
+        else if (text.startsWith('Reviewers:')) {
+            const value = colonValue(text);
+            reviewers.push(property('reviewers', value === '—' ? '' : value));
+        }
         else if (text === 'No conductor.')
             conductor.push(property('conductor', ''));
         else if (text.startsWith('Conductor:'))
@@ -153,6 +175,7 @@ const technicalProperties = (byHeading, document, labels) => {
     return [
         property('parent', parentText, parentId === undefined ? {} : { ticketId: parentId }),
         ...(assigned.length > 0 ? assigned : [property('assigned', '')]),
+        ...(reviewers.length > 0 ? reviewers : [property('reviewers', '')]),
         property('created', headerCreatedBy(document, labels)),
         ...lifecycleProperties(document),
         ...branch,
@@ -387,13 +410,18 @@ const hasSummary = (lines) => {
         .filter((line) => line !== '');
     return text.length > 0 && text.some((line) => line !== EMPTY_SUMMARY);
 };
-const overviewModel = (document, labels, nowSeconds) => {
-    const byHeading = sectionByHeading(document, labels, nowSeconds);
+const overviewModel = (document, labels, nowSeconds, baseUrl) => {
+    const byHeading = sectionByHeading(document, labels, nowSeconds, baseUrl);
     const summaryLines = byHeading.get('Latest summary')?.lines ?? [];
     const documents = [];
     if (hasSummary(summaryLines)) {
         documents.push(contentEntry(sectionKey('Latest summary'), 'Latest summary', true, firstLineSummary(summaryLines.map(styledOf)), summaryLines));
     }
+    // Shown only to the current assignee, whose detail read carries the queue.
+    const pendingLines = byHeading.get('Pending reviews')?.lines ?? [];
+    if (pendingLines.length > 0) {
+        documents.push(contentEntry(sectionKey('Pending reviews'), 'Pending reviews', true, pendingLines.slice(0, 1), pendingLines));
+    }
     documents.push(described('Description', byHeading.get('Description')?.lines ?? ['No description.'], 'No description.'));
     const details = technicalProperties(byHeading, document, labels);
     const technical = asLines(details);
@@ -439,9 +467,9 @@ const commentsModel = (document, nowSeconds) => commentItems(document).map((item
         : item.bodyLines;
     return contentEntry(`comment:${item.id}`, item.type, true, blank ? ['No comment content.'] : [], expanded, `${item.author || '—'} · ${relativeCreated(item.created, nowSeconds)}`);
 });
-export function ticketContentModel(document, tab, labels, nowSeconds) {
+export function ticketContentModel(document, tab, labels, nowSeconds, baseUrl) {
     if (tab === 'overview') {
-        const { entries, sidebar } = overviewModel(document, labels, nowSeconds);
+        const { entries, sidebar } = overviewModel(document, labels, nowSeconds, baseUrl);
         return {
             entries,
             selectableKeys: entries.map((entry) => entry.key),

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

@@ -55,6 +55,10 @@ export interface AssignmentLabels {
         id: string;
         label: string;
     }[];
+    reviewers?: {
+        id: string;
+        label: string;
+    }[];
 }
 /**
  * The ticket's assignee as ONE row of text — the header box's Assigned row.
@@ -157,9 +161,9 @@ export declare function headerState(document: TicketDetailDocument): string;
  * it is optional so every pre-existing caller and fixture is unchanged, and the
  * kernel passes the real clock.
  */
-export declare function detailSections(document: TicketDetailDocument, labels?: AssignmentLabels, nowSeconds?: number): Section[];
+export declare function detailSections(document: TicketDetailDocument, labels?: AssignmentLabels, nowSeconds?: number, baseUrl?: string): Section[];
 /** The detailSections that belong to a given (non-comments) tab, in tab order. */
-export declare function sectionsForTab(document: TicketDetailDocument, tabIndex: number, labels?: AssignmentLabels, nowSeconds?: number): Section[];
+export declare function sectionsForTab(document: TicketDetailDocument, tabIndex: number, labels?: AssignmentLabels, nowSeconds?: number, baseUrl?: string): Section[];
 /**
  * One item per comment for the collapsible Comments tab: type, author, created
  * (raw ISO — the plugin formats the relative age), the body RENDERED into

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

@@ -156,11 +156,46 @@ function compareCommentsNewestFirst(a, b) {
  * tickets) and shared with those consumers, so an in-place sort would be an
  * invisible side effect on someone else's input.
  */
+const COMMENT_TYPES = new Set([
+    'gaia_comment--gaia_comment',
+    'gaia_comment--review',
+]);
+function isCommentResource(resource) {
+    return typeof resource.type === 'string' && COMMENT_TYPES.has(resource.type);
+}
 function commentResources(document) {
+    const included = (document.included ?? []).filter(isCommentResource);
+    const linkage = document.data?.relationships?.comments?.data;
+    const comments = linkage === undefined
+        ? included
+        : included.filter((r) => new Set(toManyIds(document, 'comments')).has(r.id ?? ''));
+    return comments.sort(compareCommentsNewestFirst);
+}
+function pendingReviewResources(document) {
+    const linked = new Set(toManyIds(document, 'pending_reviews'));
     return (document.included ?? [])
-        .filter((r) => r.type === 'gaia_comment--gaia_comment')
+        .filter((r) => r.type === 'gaia_comment--review' && linked.has(r.id ?? ''))
         .sort(compareCommentsNewestFirst);
 }
+function pendingReviewLines(document, baseUrl) {
+    const pending = pendingReviewResources(document);
+    if (!pending.length)
+        return [];
+    const web = ticketUrl(baseUrl, document.data?.id);
+    return [
+        `${pending.length} review${pending.length === 1 ? '' : 's'} awaiting acceptance`,
+        ...pending.map((r) => {
+            const author = asString(r.attributes?.author_name) ??
+                asString(r.attributes?.author) ??
+                'unknown';
+            const state = asString(r.attributes?.review_state) ?? 'submitted';
+            return `— ${author} · ${state}`;
+        }),
+        web
+            ? `Open in Web to accept or reject: ${web}`
+            : 'Open this ticket in Web to accept or reject.',
+    ];
+}
 /**
  * The `expandedComments` set a freshly opened ticket detail starts with: the
  * newest comment expanded, every older one collapsed.
@@ -272,8 +307,20 @@ export function headerCreatedBy(document, labels) {
         knownLabel(labels?.users, userId) ??
         userId);
 }
+function reviewerName(document, id, labels) {
+    const user = included(document, 'user--user', id);
+    return (asString(user?.attributes?.display_name) ??
+        asString(user?.attributes?.name) ??
+        knownLabel(labels?.reviewers, id) ??
+        knownLabel(labels?.users, id) ??
+        id);
+}
 function assignmentLines(document, labels) {
     const assignee = assigneeName(document, labels);
+    const reviewerIds = toManyIds(document, 'reviewers');
+    const reviewerLabel = reviewerIds.length
+        ? reviewerIds.map((id) => reviewerName(document, id, labels)).join(', ')
+        : '—';
     const conductorId = relId(document, 'conductor_id');
     const conductor = included(document, 'gaia_conductor--gaia_conductor', conductorId);
     const conductorLabel = asString(conductor?.attributes?.label) ??
@@ -282,6 +329,7 @@ function assignmentLines(document, labels) {
         conductorId;
     return [
         assignee ? `Assignee:  ${assignee}` : 'Unassigned.',
+        `Reviewers: ${reviewerLabel}`,
         conductorLabel ? `Conductor: ${conductorLabel}` : 'No conductor.',
     ];
 }
@@ -596,7 +644,7 @@ function timeLines(a) {
  * it is optional so every pre-existing caller and fixture is unchanged, and the
  * kernel passes the real clock.
  */
-export function detailSections(document, labels, nowSeconds = 0) {
+export function detailSections(document, labels, nowSeconds = 0, baseUrl) {
     const a = document.data?.attributes ?? {};
     const sections = [];
     // GAIA-369 D1/D7: `State` LEADS, and no tab lists it — the same arrangement
@@ -648,6 +696,10 @@ export function detailSections(document, labels, nowSeconds = 0) {
         heading: 'Assignment',
         lines: assignmentLines(document, labels),
     });
+    const pendingLines = pendingReviewLines(document, baseUrl);
+    if (pendingLines.length) {
+        sections.push({ heading: 'Pending reviews', lines: pendingLines });
+    }
     // GAIA-308 AC-9: an overrun has to be visible where the pair is read. Right
     // after Assignment, and deliberately ABOVE Runs — the accounted number is
     // read first, the machine footprint that informed it second.
@@ -716,12 +768,15 @@ export function detailSections(document, labels, nowSeconds = 0) {
     return sections;
 }
 /** The detailSections that belong to a given (non-comments) tab, in tab order. */
-export function sectionsForTab(document, tabIndex, labels, nowSeconds = 0) {
+export function sectionsForTab(document, tabIndex, labels, nowSeconds = 0, baseUrl) {
     const tab = TICKET_SECTIONS[tabIndex];
     const headings = tab?.headings ?? [];
     if (!headings.length)
         return [];
-    const byHeading = new Map(detailSections(document, labels, nowSeconds).map((s) => [s.heading, s]));
+    const byHeading = new Map(detailSections(document, labels, nowSeconds, baseUrl).map((s) => [
+        s.heading,
+        s,
+    ]));
     return headings
         .map((h) => byHeading.get(h))
         .filter((s) => s !== undefined);

package/dist/src/Entity/ticket/Data/addons.d.ts

@@ -0,0 +1,53 @@
+import type { MessageInput, MessageResult } from '@gaia-ai/message';
+import type { DropshClient } from '../../../types.js';
+export interface AddonLatest {
+    status: string;
+    result: MessageResult | null;
+    changed: number;
+}
+/** A contract-2 message entry (GAIA-661). */
+export interface AddonMessageEntry {
+    key: string;
+    label: string;
+    input: MessageInput | null;
+    access: string;
+    /** Whether the viewer holds the ticket operation the message requires. */
+    access_ok: boolean;
+}
+export interface TicketAddon {
+    id: string;
+    name: string;
+    version: string;
+    contract: number;
+    label: string;
+    messages: AddonMessageEntry[];
+    /**
+     * This requester's own newest message for the ticket (GAIA-661), never
+     * another requester's — the server already selects it.
+     */
+    latest: (AddonLatest & {
+        action: string;
+        label: string;
+    }) | null;
+}
+export interface TicketAddons {
+    conductor: {
+        status: string;
+    } | null;
+    addons: TicketAddon[];
+}
+/** One selectable line of an addon panel. */
+export type AddonEntry = {
+    kind: 'message';
+    id: string;
+    message: AddonMessageEntry;
+};
+export declare function readTicketAddons(client: Pick<DropshClient, 'get'>, ticketUuid: string): Promise<TicketAddons>;
+export declare function sendAddonAction(client: Pick<DropshClient, 'post'>, ticketUuid: string, messageId: string, payload: Record<string, unknown>): Promise<void>;
+/**
+ * Whether the addon's newest message is still pending or running. Messages
+ * are answered in order, so no older one can still be open.
+ */
+export declare function isOpen(addon: TicketAddon): boolean;
+/** The panel's lines: one entry per permitted message, always. */
+export declare function addonEntries(addon: TicketAddon): AddonEntry[];

package/dist/src/Entity/ticket/Data/addons.js

@@ -0,0 +1,35 @@
+// The ticket's addons as the server reads them for a viewer
+// (`GET gaia/addons/ticket/{uuid}`), and the one write: sending a message
+// through the conductor inbox (`POST gaia/inbox/send`). The TUI renders the
+// same definitions and states as the web card, so a reviewer's `gaia ui`
+// needs no addon installed. Contract 1 (views/actions/rows, GAIA-661) is
+// retired; only contract-2 messages are live.
+export async function readTicketAddons(client, ticketUuid) {
+    const doc = (await client.get(`gaia/addons/ticket/${ticketUuid}`));
+    const attrs = doc?.data?.attributes;
+    return { conductor: attrs?.conductor ?? null, addons: attrs?.addons ?? [] };
+}
+export async function sendAddonAction(client, ticketUuid, messageId, payload) {
+    await client.post('gaia/inbox/send', {
+        data: {
+            attributes: { ticket: ticketUuid, message_id: messageId, payload },
+        },
+    });
+}
+/**
+ * Whether the addon's newest message is still pending or running. Messages
+ * are answered in order, so no older one can still be open.
+ */
+export function isOpen(addon) {
+    return (addon.latest?.status === 'pending' || addon.latest?.status === 'running');
+}
+/** The panel's lines: one entry per permitted message, always. */
+export function addonEntries(addon) {
+    return addon.messages
+        .filter((message) => message.access_ok)
+        .map((message) => ({
+        kind: 'message',
+        id: `message:${message.key}`,
+        message,
+    }));
+}

package/dist/src/Entity/ticket/Data/detail.js

@@ -55,6 +55,8 @@ export function loadTicketDetail(client, ticketId, includes = [
     'blocked_by',
     'team',
     'owner_user_id',
+    'reviewers',
+    'pending_reviews',
 ]) {
     return client.get(`gaia_ticket/gaia_ticket/${ticketId}?include=${includes.join(',')}`);
 }

package/dist/src/Entity/ticket/Data/store.js

@@ -31,6 +31,8 @@ const allIncludes = [
     'runs',
     'team',
     'owner_user_id',
+    'reviewers',
+    'pending_reviews',
 ];
 const ids = (data) => (Array.isArray(data) ? data : data ? [data] : []).map((item) => item.id);
 /** Preserve omitted fields; explicit relationship replacement removes old rows. */

package/dist/src/Entity/ticket/Data/tickets.d.ts

@@ -23,6 +23,10 @@ export interface TicketRow {
     projectId: string | null;
     /** Boolean closed flag; an absent attribute reads as open (spec D5). */
     closed: boolean;
+    /** Operator hold; an absent attribute reads as not frozen (GAIA-302). */
+    frozen: boolean;
+    /** Why the ticket is standing still: frozen|blocked|no conductor|failing, else ''. */
+    stallReason: string;
 }
 /** A `(id) → resource` lookup over a document's sideloaded `included` entries.
  *  JSON:API ids are UUIDs (unique across bundles), so id alone keys uniquely. */
@@ -83,8 +87,8 @@ export declare const TICKET_COLUMNS: readonly [{
 }, {
     readonly key: "run";
     readonly label: "RUN";
-    readonly width: 8;
-    readonly fields: readonly ["derived_status"];
+    readonly width: 12;
+    readonly fields: readonly ["derived_status", "stall_reason"];
     readonly get: (r: TicketRow) => string;
 }, {
     readonly key: "parent";
@@ -153,8 +157,8 @@ export declare const TICKET_TABLE: {
     }, {
         readonly key: "run";
         readonly label: "RUN";
-        readonly width: 8;
-        readonly fields: readonly ["derived_status"];
+        readonly width: 12;
+        readonly fields: readonly ["derived_status", "stall_reason"];
         readonly get: (r: TicketRow) => string;
     }, {
         readonly key: "parent";
@@ -217,8 +221,8 @@ export declare const CONDUCTOR_TICKET_COLUMNS: readonly [{
 }, {
     readonly key: "run";
     readonly label: "RUN";
-    readonly width: 8;
-    readonly fields: readonly ["derived_status"];
+    readonly width: 12;
+    readonly fields: readonly ["derived_status", "stall_reason"];
     readonly get: (r: TicketRow) => string;
 }, {
     readonly key: "conductor";
@@ -264,8 +268,8 @@ export declare const CONDUCTOR_TICKET_TABLE: {
     }, {
         readonly key: "run";
         readonly label: "RUN";
-        readonly width: 8;
-        readonly fields: readonly ["derived_status"];
+        readonly width: 12;
+        readonly fields: readonly ["derived_status", "stall_reason"];
         readonly get: (r: TicketRow) => string;
     }, {
         readonly key: "conductor";
@@ -292,7 +296,7 @@ export declare const CONDUCTOR_TICKET_TABLE: {
  * down to the bytes on the wire. Column order would emit `title` last (it rides
  * the trailing TITLE column) instead of second.
  */
-export declare const TICKET_LIST_ATTRIBUTES: readonly ["identifier", "title", "state", "priority", "assignee_initials", "owner_initials", "derived_status", "workflow", "closed"];
+export declare const TICKET_LIST_ATTRIBUTES: readonly ["identifier", "title", "state", "priority", "assignee_initials", "owner_initials", "derived_status", "stall_reason", "workflow", "closed", "frozen"];
 /** What `addFields('gaia_ticket--gaia_ticket', …)` takes. */
 export declare const TICKET_LIST_FIELDS: string[];
 /** The sideloaded conductor renders one column: its label. */

package/dist/src/Entity/ticket/Data/tickets.js

@@ -57,7 +57,7 @@ export const TICKET_LIST_RELATIONSHIPS = [
  * columns' union PLUS this list, and this list is an explicit declaration rather
  * than an unstated remainder.
  */
-const TICKET_PREDICATE_ATTRIBUTES = ['workflow', 'closed'];
+const TICKET_PREDICATE_ATTRIBUTES = ['workflow', 'closed', 'frozen'];
 /**
  * The ticket list's columns — the header, the width, the cell value AND the
  * fieldset entry of each, in ONE declaration (GAIA-294 AC 4).
@@ -125,9 +125,13 @@ export const TICKET_COLUMNS = [
     {
         key: 'run',
         label: 'RUN',
-        width: 8,
-        fields: ['derived_status'],
-        get: (r) => r.derivedStatus,
+        width: 12,
+        // `stall_reason` rides this column: GAIA-302 shows WHY a ticket is standing
+        // still exactly where it would otherwise show what it is doing, so the two
+        // share one cell and therefore one fieldset entry. Width 12 fits
+        // `no conductor`, the longest operator-facing reason.
+        fields: ['derived_status', 'stall_reason'],
+        get: (r) => r.stallReason || r.derivedStatus,
     },
     {
         key: 'parent',
@@ -220,8 +224,10 @@ export const TICKET_LIST_ATTRIBUTES = [
     'assignee_initials',
     'owner_initials',
     'derived_status',
+    'stall_reason',
     'workflow',
     'closed',
+    'frozen',
 ];
 /** What `addFields('gaia_ticket--gaia_ticket', …)` takes. */
 export const TICKET_LIST_FIELDS = [
@@ -265,6 +271,7 @@ export function mapTicketData(item, included) {
         assigneeInitials: str('assignee_initials') ?? '',
         ownerInitials: str('owner_initials') ?? '',
         derivedStatus: str('derived_status') ?? 'idle',
+        stallReason: str('stall_reason') ?? '',
         labels,
         type: str('workflow') ?? null,
         parent,
@@ -272,6 +279,7 @@ export function mapTicketData(item, included) {
         assigneeId: singleRelId(rel('assignee_user_id')),
         projectId: singleRelId(rel('project_id')),
         closed: typeof raw('closed') === 'boolean' ? raw('closed') : false,
+        frozen: typeof raw('frozen') === 'boolean' ? raw('frozen') : false,
     };
 }
 /**

package/dist/src/Entity/ticket/Data/write.d.ts

@@ -11,6 +11,13 @@ export declare const TICKET_TYPE = "gaia_ticket--gaia_ticket";
  * silent failure that criterion forbids.
  */
 export declare function updateTicketAssignment(client: DropshClient | undefined, ticketId: string, body: ResourceWriteBody): Promise<unknown>;
+/**
+ * PATCH a ticket's `frozen` flag (GAIA-302).
+ *
+ * Same write path as assignment: a refusal is not caught here so the caller
+ * can put the server's words on the status line.
+ */
+export declare function updateTicketFrozen(client: DropshClient | undefined, ticketId: string, frozen: boolean): Promise<unknown>;
 /** The text format every ticket description is stored in (`gaia_rich`). */
 export declare const TICKET_DESCRIPTION_FORMAT = "gaia_rich";
 /**