@gaia-ai/addon-gaia-ui 0.18.0 → 0.20.0

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

@@ -26,6 +26,16 @@ export interface Conductor {
  * contract, because it already answers a failure by falling back.
  */
 export declare const listConductors: (client: DropshClient) => Promise<ListOutcome<Conductor>>;
+/**
+ * The conductor collection scoped to one project (GAIA-664 review F4).
+ *
+ * The create popup's narrow option loader, not `ConductorQuery`'s row-page
+ * read above (GAIA-664 plan correction): this keeps `listOutcome`'s own
+ * outcome/error contract rather than inventing a second one for the same
+ * entity. An unscoped caller keeps calling {@link listConductors}; this is
+ * additive.
+ */
+export declare const listConductorsForProject: (client: DropshClient, projectId: string) => Promise<ListOutcome<Conductor>>;
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

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

@@ -8,7 +8,7 @@ import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
 import { humanizeAge } from '../../../lib/format.js';
 import { loadPage, } from '../../collection.js';
 import { LIST_PAGE_SIZE } from '../../cycle.js';
-import { listOutcome, listPreferringWrite, } from '../../transport.js';
+import { listOutcome, listPreferringWrite, messageOf, } from '../../transport.js';
 import { deriveConductorStatus } from './liveness.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const toConductor = (r) => ({
@@ -32,6 +32,28 @@ const toConductor = (r) => ({
  * contract, because it already answers a failure by falling back.
  */
 export const listConductors = (client) => listOutcome(client, 'gaia_conductor', toConductor);
+/**
+ * The conductor collection scoped to one project (GAIA-664 review F4).
+ *
+ * The create popup's narrow option loader, not `ConductorQuery`'s row-page
+ * read above (GAIA-664 plan correction): this keeps `listOutcome`'s own
+ * outcome/error contract rather than inventing a second one for the same
+ * entity. An unscoped caller keeps calling {@link listConductors}; this is
+ * additive.
+ */
+export const listConductorsForProject = async (client, projectId) => {
+    try {
+        return {
+            rows: (await client
+                .collection('gaia_conductor')
+                .where('project_id.id', '=', projectId)
+                .list()).map(toConductor),
+        };
+    }
+    catch (caught) {
+        return { rows: [], error: messageOf(caught) };
+    }
+};
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

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

@@ -1,5 +1,5 @@
 import type { VNode } from '@opentui/core';
-import { type CreateFormOptions, type CreateFormState } from '../../Form/create.js';
+import type { CreateFieldId, CreateFormOptions, CreateFormState, FieldDef } from '../../Form/create.js';
 /** The chrome the kernel wraps this tree in. */
 export interface CreateFormChrome {
     /**
@@ -25,4 +25,4 @@ export interface CreateFormChrome {
 /** The id the popup's body column is rooted at. */
 export declare const CREATE_FORM_REGION = "create-form";
 /** Render the "New ticket" popup as the tree the kernel frames. */
-export declare function createFormTree(s: CreateFormState, opts: CreateFormOptions, chrome?: CreateFormChrome): VNode;
+export declare function createFormTree(fields: FieldDef<CreateFieldId>[], s: CreateFormState, opts: CreateFormOptions, chrome?: CreateFormChrome): VNode;

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

@@ -17,7 +17,6 @@
 // to rebase again onto its own.
 import { columnNode, textNode } from '../../../../lib/vnode.js';
 import { note, renderDeclaredFieldsTree, widgetFor, } from '../../../../Widget/index.js';
-import { FIELDS, } from '../../Form/create.js';
 const DEFAULT_WIDTH = 58;
 /** The id the popup's body column is rooted at. */
 export const CREATE_FORM_REGION = 'create-form';
@@ -34,7 +33,7 @@ const WHOLE_FORM = 'The form options';
  */
 const bagName = (field) => field.kind === 'multiselect' ? field.label : `${field.label} options`;
 /** Render the "New ticket" popup as the tree the kernel frames. */
-export function createFormTree(s, opts, chrome = {}) {
+export function createFormTree(fields, s, opts, chrome = {}) {
     const width = chrome.width ?? DEFAULT_WIDTH;
     // Keyed by BAG, which is what `from` names; the typed shape is the adapter's
     // business, and reading it by key is what keeps this loop declaration-driven.
@@ -49,7 +48,8 @@ export function createFormTree(s, opts, chrome = {}) {
     // one, plus a whole-form failure, collapses into ONE row at the top. It is a
     // note, not a refusal: a failed OPTION read must not cost the writer the
     // description they opened the popup to type (D4).
-    const formLevel = FIELDS.filter((f) => !widgetFor(f).ownsError)
+    const formLevel = fields
+        .filter((f) => !widgetFor(f).ownsError)
         .map(reason)
         .filter((sentence) => sentence !== undefined);
     if (errors.form !== undefined) {
@@ -63,7 +63,7 @@ export function createFormTree(s, opts, chrome = {}) {
     // `note` supplies the `⚠` sigil itself, so the message is passed plain —
     // and it WRAPS, which is what keeps a long server message off the frame's
     // ellipsis (the same reason the option-load note above it wraps).
-    ...(chrome.message ? noteNodes(chrome.message, 'create-form-message') : []), renderDeclaredFieldsTree(FIELDS, s, opts, {
+    ...(chrome.message ? noteNodes(chrome.message, 'create-form-message') : []), renderDeclaredFieldsTree(fields, s, opts, {
         width,
         errorFor: reason,
         // A form-level failure means no read succeeded, so an empty bag may not

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 };
@@ -69,10 +69,6 @@ const colonValue = (text) => {
     const index = text.indexOf(':');
     return index < 0 ? text : text.slice(index + 1);
 };
-const entityLabel = (document, id, type) => {
-    const row = (document.included ?? []).find((resource) => resource.id === id && resource.type === type);
-    return (asString(row?.attributes?.label) ?? asString(row?.attributes?.name) ?? id);
-};
 const PRIORITY_LABEL = {
     '1': 'high',
     '2': 'medium',
@@ -86,12 +82,6 @@ const lifecycleProperties = (document) => {
     const priorityKey = String(attributes.priority ?? '').toLowerCase();
     const extras = [
         property('priority', PRIORITY_LABEL[priorityKey] ?? ''),
-        property('team', (() => {
-            const teamId = relationshipIds(document, 'team')[0];
-            return teamId === undefined
-                ? ''
-                : entityLabel(document, teamId, 'gaia_team--gaia_team');
-        })()),
         property('closed', attributes.closed === true ? 'yes' : 'no'),
     ];
     const frozenAtRaw = attributes.frozen_at;
@@ -122,6 +112,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();
@@ -129,6 +120,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:'))
@@ -170,6 +165,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,
@@ -404,13 +400,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);
@@ -456,9 +457,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

@@ -44,8 +44,8 @@ function headerLineNodes(id, content, fg) {
 }
 export function ticketHeaderTree(document, identifier, title, lastRow, labels) {
     // One compact meta line — state · assignee · labels — under the title. The
-    // full set (created by, team, branch, …) lives in the Overview sidebar, so
-    // the header stays two lines rather than five. Empty fields drop out.
+    // full set (created by, branch, …) lives in the Overview sidebar, so the
+    // header stays two lines rather than five. Empty fields drop out.
     const meta = [
         headerState(document),
         headerAssignee(document, labels),
@@ -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

@@ -53,8 +53,9 @@ export function loadTicketDetail(client, ticketId, includes = [
     'parent_id',
     'labels',
     '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

@@ -29,8 +29,9 @@ const allIncludes = [
     'sub_tickets',
     'referenced_tickets',
     '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/write.js

@@ -69,6 +69,14 @@ export function buildTicketCreateBody(payload, projectId) {
             })),
         };
     }
+    if (payload.reviewers.length > 0) {
+        relationships.reviewers = {
+            data: payload.reviewers.map((r) => ({
+                type: 'user--user',
+                id: r.id,
+            })),
+        };
+    }
     const parent = one('gaia_ticket--gaia_ticket', payload.parent?.id);
     if (parent)
         relationships.parent_id = parent;