@gaia-ai/addon-gaia-ui 0.18.0 → 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 };
@@ -122,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();
@@ -129,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:'))
@@ -170,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,
@@ -404,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);
@@ -456,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/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;

package/dist/src/Entity/ticket/Form/addon-action.d.ts

@@ -0,0 +1,37 @@
+import type { MessageInput as AddonInput } from '@gaia-ai/message';
+import type { FieldDecl, Option } from '../../../Form/field.js';
+/** A form field as the TUI renders it: a text line or a select. */
+export interface FieldSpec {
+    id: string;
+    label: string;
+    kind: 'text' | 'select';
+    options?: Option[];
+}
+/**
+ * The rendering table on a terminal: text lines for strings and numbers, a
+ * select for an enum, and yes/no for a boolean (there is no toggle widget).
+ * A required field without a default is marked `*`.
+ */
+export declare function formFields(input: AddonInput): FieldSpec[];
+/**
+ * Typed payload from the form's strings, or the per-field errors. The server
+ * validates again; this only spares a round trip for the obvious mistakes.
+ */
+export declare function payloadFrom(input: AddonInput, values: Record<string, string | null | undefined>): {
+    payload: Record<string, unknown>;
+} | {
+    errors: Record<string, string>;
+};
+export type AddonFormValues = Record<string, string | null>;
+type AddonFormOptions = Record<string, Option[]>;
+/** The kernel form for an input: its fields, then the Send row. */
+export declare function addonForm(input: AddonInput): {
+    fields: FieldDecl[];
+    activeField: (s: import("../../../Form/form.js").FormState<AddonFormValues>) => FieldDecl;
+    move: (s: import("../../../Form/form.js").FormState<AddonFormValues>, d: number) => import("../../../Form/form.js").FormState<AddonFormValues>;
+    initial(options: AddonFormOptions, prefill?: Partial<AddonFormValues>): import("../../../Form/form.js").FormState<AddonFormValues>;
+    apply(s: import("../../../Form/form.js").FormState<AddonFormValues>, options: AddonFormOptions, intent: import("../../../Form/form.js").Intent): import("../../../Form/form.js").FormState<AddonFormValues>;
+    toObject: (s: import("../../../Form/form.js").FormState<AddonFormValues>, options: AddonFormOptions) => AddonFormValues;
+};
+export type AddonForm = ReturnType<typeof addonForm>;
+export {};

package/dist/src/Entity/ticket/Form/addon-action.js

@@ -0,0 +1,80 @@
+// The form of an addon action with input, over the form kernel: the input
+// subset of the addon schema mapped onto text lines and selects, and the
+// typed payload read back from the strings the form holds.
+import { declareForm } from '../../../Form/form.js';
+/**
+ * The rendering table on a terminal: text lines for strings and numbers, a
+ * select for an enum, and yes/no for a boolean (there is no toggle widget).
+ * A required field without a default is marked `*`.
+ */
+export function formFields(input) {
+    const required = new Set(input.required ?? []);
+    return Object.entries(input.properties).map(([id, field]) => {
+        const label = `${field.title ?? id}${required.has(id) && field.default === undefined ? ' *' : ''}`;
+        if (field.enum)
+            return {
+                id,
+                label,
+                kind: 'select',
+                options: field.enum.map((v) => ({ id: String(v), label: String(v) })),
+            };
+        if (field.type === 'boolean')
+            return {
+                id,
+                label,
+                kind: 'select',
+                options: [
+                    { id: 'yes', label: 'yes' },
+                    { id: 'no', label: 'no' },
+                ],
+            };
+        return { id, label, kind: 'text' };
+    });
+}
+/**
+ * Typed payload from the form's strings, or the per-field errors. The server
+ * validates again; this only spares a round trip for the obvious mistakes.
+ */
+export function payloadFrom(input, values) {
+    const required = new Set(input.required ?? []);
+    const payload = {};
+    const errors = {};
+    for (const [id, field] of Object.entries(input.properties)) {
+        const raw = (values[id] ?? '').trim();
+        if (raw === '') {
+            if (required.has(id) && field.default === undefined)
+                errors[id] = 'is required';
+            continue;
+        }
+        if (field.type === 'boolean')
+            payload[id] = raw === 'yes';
+        else if (field.type === 'integer') {
+            if (!/^-?\d+$/.test(raw))
+                errors[id] = 'must be a whole number';
+            else
+                payload[id] = Number(raw);
+        }
+        else if (field.type === 'number') {
+            const n = Number(raw);
+            if (!Number.isFinite(n))
+                errors[id] = 'must be a number';
+            else
+                payload[id] = n;
+        }
+        else if (field.format === 'uri' && !URL.canParse(raw))
+            errors[id] = 'must be a URL';
+        else
+            payload[id] = raw;
+    }
+    return Object.keys(errors).length > 0 ? { errors } : { payload };
+}
+/** The kernel form for an input: its fields, then the Send row. */
+export function addonForm(input) {
+    const fields = formFields(input).map((f) => f.kind === 'select'
+        ? { id: f.id, label: f.label, kind: 'select', from: f.id }
+        : { id: f.id, label: f.label, kind: 'text' });
+    return declareForm({
+        fields: (f) => [...fields, f.action('Send')],
+        toObject: (values) => values,
+    });
+}

package/dist/src/Entity/ticket/Form/create-data.d.ts

@@ -20,6 +20,8 @@ export interface CreateFormHints {
     projectId?: string | undefined;
     /** The launcher's user uuid; hoists everything the machine's user owns (GAIA-460). */
     ownerUserId?: string | undefined;
+    /** Workspace UUID for the Reviewers bag (membership ∩ users). */
+    workspaceId?: string | undefined;
 }
 /**
  * Stable-partition the machine's own row to the front: index 0 is what a ring