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

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

@@ -16,6 +16,15 @@ export function updateTicketAssignment(client, ticketId, body) {
     }
     return client.update(TICKET_TYPE, ticketId, body);
 }
+/**
+ * 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 function updateTicketFrozen(client, ticketId, frozen) {
+    return updateTicketAssignment(client, ticketId, { attributes: { frozen } });
+}
 /** The text format every ticket description is stored in (`gaia_rich`). */
 export const TICKET_DESCRIPTION_FORMAT = 'gaia_rich';
 /** A JSON:API to-one linkage, or nothing at all. */
@@ -60,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

package/dist/src/Entity/ticket/Form/create-data.js

@@ -21,6 +21,7 @@ import { listTerms } from '../../term/Data/terms.js';
 import { listUsers } from '../../user/Data/users.js';
 import { WORKFLOW_OPTIONS, } from './create.js';
 import { parentOptionSource } from './parent-source.js';
+import { loadReviewerOptions } from './reviewer-options.js';
 // One back-compat re-export, no implementation: `loadEditFormOptions` lives in
 // `./edit-form-data.js`, because a module named for the create form owning the EDIT
 // form's loader is the category error AC-6 is about.
@@ -71,7 +72,7 @@ const LABEL_VOCABULARY = 'gaia_labels';
  *      can lag, but it can never show a row contradicting the text on screen.
  */
 export function createFormSources(client, hints = {}) {
-    const { currentUser, ownConductorMachineId, ownerUserId, projectId } = hints;
+    const { currentUser, ownConductorMachineId, ownerUserId, projectId, workspaceId, } = hints;
     const sources = {
         assignee: {
             bag: 'users',
@@ -84,6 +85,12 @@ export function createFormSources(client, hints = {}) {
                 return { options: rows.map(toOption), error: outcome.error };
             },
         },
+        reviewers: {
+            bag: 'reviewers',
+            async load() {
+                return loadReviewerOptions(client, workspaceId);
+            },
+        },
         conductor: {
             bag: 'conductors',
             async load() {
@@ -131,6 +138,7 @@ export async function composeCreateFormOptions(sources) {
     const { bags, errors } = await primeSources(sources);
     return {
         users: [],
+        reviewers: [],
         conductors: [],
         labels: [],
         workflows: WORKFLOW_OPTIONS,

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

@@ -12,6 +12,7 @@ export { cycleValue };
  */
 export interface CreateOptionErrors {
     users?: string | undefined;
+    reviewers?: string | undefined;
     conductors?: string | undefined;
     labels?: string | undefined;
     parents?: string | undefined;
@@ -38,6 +39,7 @@ export interface ParentOption extends Option {
 }
 export interface CreateFormOptions {
     users: Option[];
+    reviewers: Option[];
     conductors: Option[];
     labels: Option[];
     workflows: Option[];
@@ -67,7 +69,7 @@ export type FieldDef<Id extends string = string> = Omit<FieldDecl, 'id'> & {
  */
 export declare const AGENT_ACTION_ID = "submit";
 export declare const DIRECT_ACTION_ID = "direct";
-export type CreateFieldId = 'title' | 'description' | 'parent' | 'assignee' | 'conductor' | 'labels' | 'workflow' | 'submit' | 'direct';
+export type CreateFieldId = 'title' | 'description' | 'parent' | 'assignee' | 'reviewers' | 'conductor' | 'labels' | 'workflow' | 'submit' | 'direct';
 /** What the form HOLDS. `active`/`cursor` are the kernel's and must not appear. */
 export interface CreateValues {
     /**
@@ -84,6 +86,7 @@ export interface CreateValues {
     parent: string | null;
     parentQuery: string;
     assignee: string | null;
+    reviewers: ReadonlySet<string>;
     conductor: string | null;
     labels: ReadonlySet<string>;
     workflow: string | null;
@@ -101,6 +104,7 @@ export interface CreateFormPayload {
     description: string;
     workflow: Option | null;
     assignee: Option | null;
+    reviewers: Option[];
     conductor: Option | null;
     labels: Option[];
     /**

package/dist/src/Entity/ticket/Form/create.js

@@ -76,6 +76,7 @@ export const CREATE_FORM = declareForm({
             pageSize: PARENT_PAGE_SIZE,
         }),
         f.select('assignee', 'Assignee', { from: 'users' }),
+        f.multi('reviewers', 'Reviewers', { from: 'reviewers' }),
         // Clearable (D2): a SET conductor means the ticket is claimed at the next
         // poll and a qualification run starts; a cleared one means it waits for a
         // human. The field is clearable precisely so that choice is the operator's
@@ -95,6 +96,7 @@ export const CREATE_FORM = declareForm({
         description: v.description,
         workflow: optionFor(o.workflows, v.workflow),
         assignee: optionFor(o.users, v.assignee),
+        reviewers: (o.reviewers ?? []).filter((x) => v.reviewers.has(x.id)),
         conductor: optionFor(o.conductors, v.conductor),
         labels: o.labels.filter((x) => v.labels.has(x.id)),
         parent: parentFor(o.parents ?? [], v.parent),
@@ -135,6 +137,7 @@ export const serialize = (s, opts) => CREATE_FORM.toObject(s, opts);
 // signatures predate the kernel and take no options — pass an empty bag.
 const NO_OPTIONS = {
     users: [],
+    reviewers: [],
     conductors: [],
     labels: [],
     workflows: [],

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

@@ -7,5 +7,7 @@ export interface EditFormHints {
     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;
 }
 export declare function loadEditFormOptions(clients: EditFormClients, hints?: EditFormHints): Promise<EditFormOptions>;

package/dist/src/Entity/ticket/Form/edit-data.js

@@ -15,6 +15,7 @@ import { listConductorsPreferringWrite, } from '../../conductor/Data/conductors.
 import { listTerms } from '../../term/Data/terms.js';
 import { listUsersPreferringWrite } from '../../user/Data/users.js';
 import { ownFirst } from './create-data.js';
+import { loadReviewerOptions } from './reviewer-options.js';
 /** The vocabulary this popup offers as its labels (GAIA-360 D9 / D11). */
 const LABEL_VOCABULARY = 'gaia_labels';
 /**
@@ -42,14 +43,26 @@ export async function loadEditFormOptions(clients, hints = {}) {
     const labelsPromise = clients.read
         ? listTerms(clients.read, LABEL_VOCABULARY).then((outcome) => outcome.rows.map((t) => ({ id: t.id, label: t.label })), () => [])
         : Promise.resolve([]);
-    const [users, conductors, labels] = await Promise.all([
+    const reviewerClient = clients.write ?? clients.read;
+    const reviewersPromise = reviewerClient
+        ? loadReviewerOptions(reviewerClient, hints.workspaceId)
+        : Promise.resolve({
+            options: [],
+            error: 'no client — reviewers cannot be loaded',
+        });
+    const [users, conductors, labels, reviewers] = await Promise.all([
         listUsersPreferringWrite(clients),
         listConductorsPreferringWrite(clients),
         labelsPromise,
+        reviewersPromise,
     ]);
     return {
         users: excludeAnonymous(users).map((u) => ({ id: u.id, label: u.label })),
+        reviewers: reviewers.options,
         conductors: ownFirst(inProject(conductors, hints.projectId).filter((c) => c.active), (c) => hints.ownerUserId !== undefined && c.ownerUserId === hints.ownerUserId).map(withStatusSuffix),
         labels,
+        ...(reviewers.error === undefined
+            ? {}
+            : { errors: { reviewers: reviewers.error } }),
     };
 }

package/dist/src/Entity/ticket/Form/edit.d.ts

@@ -1,7 +1,7 @@
 import { type FormState } from '../../../Form/index.js';
 import type { TicketDetailDocument } from '../../../types.js';
 import type { FieldDef, Option } from './create.js';
-export type EditFieldId = 'assignee' | 'conductor' | 'estimate' | 'spent' | 'parent' | 'labels' | 'submit' | 'cancelTicket';
+export type EditFieldId = 'assignee' | 'reviewers' | 'conductor' | 'estimate' | 'spent' | 'parent' | 'labels' | 'submit' | 'cancelTicket';
 /**
  * GAIA-313 / GAIA-360 — the ONE lifecycle move this popup offers, as a named
  * constant.
@@ -35,8 +35,12 @@ export declare const TERMINAL_TICKET_STATES: ReadonlySet<string>;
 /** The option lists the popup offers (loaded by `loadEditFormOptions`). */
 export interface EditFormOptions {
     users: Option[];
+    reviewers: Option[];
     conductors: Option[];
     labels: Option[];
+    errors?: {
+        reviewers?: string | undefined;
+    } | undefined;
     /**
      * Parent candidates from the option loader (project-scoped typeahead). Absent
      * until the screen primes a source; an empty array means "searched, nothing
@@ -48,7 +52,10 @@ export interface EditFormOptions {
  *  verbatim so submit needs no ambient state, and never transitions it. */
 interface EditValues {
     ticketId: string;
+    /** Whether `relationships.reviewers` was present on the loaded document. */
+    reviewersLoaded: boolean;
     assignee: string | null;
+    reviewers: ReadonlySet<string>;
     conductor: string | null;
     /** The human duration as TYPED — seconds only exist at `toObject` (D5). */
     estimate: string;
@@ -86,6 +93,12 @@ export interface EditFormPayload {
                 id: string;
             } | null;
         };
+        reviewers?: {
+            data: {
+                type: string;
+                id: string;
+            }[];
+        };
     };
 }
 /** Cancel ticket writes ONLY the lifecycle attribute (GAIA-360 D1). */

package/dist/src/Entity/ticket/Form/edit.js

@@ -105,6 +105,7 @@ const timeAttributes = (v) => {
 const declareEditForm = (savable, cancellable) => declareForm({
     fields: (f) => [
         f.select('assignee', 'Assignee', { from: 'users', clearable: true }),
+        f.multi('reviewers', 'Reviewers', { from: 'reviewers' }),
         f.select('conductor', 'Conductor', {
             from: 'conductors',
             clearable: true,
@@ -132,6 +133,16 @@ const declareEditForm = (savable, cancellable) => declareForm({
             conductor_id: linkage('gaia_conductor--gaia_conductor', v.conductor),
             labels: labelsLinkage(v.labels),
             parent_id: linkage('gaia_ticket--gaia_ticket', v.parent),
+            ...(v.reviewersLoaded || v.reviewers.size > 0
+                ? {
+                    reviewers: {
+                        data: [...v.reviewers].map((id) => ({
+                            type: 'user--user',
+                            id,
+                        })),
+                    },
+                }
+                : {}),
         },
     }),
 });
@@ -178,6 +189,7 @@ export const EDIT_FIELDS_CLOSED = EDIT_FORM_CLOSED.fields;
  */
 export const EMPTY_EDIT_FORM_OPTIONS = {
     users: [],
+    reviewers: [],
     conductors: [],
     labels: [],
 };
@@ -196,6 +208,22 @@ const labelIds = (document) => {
     }
     return data.id ? new Set([data.id]) : new Set();
 };
+const reviewersFromDocument = (document) => {
+    const rel = document.data?.relationships?.reviewers;
+    if (rel === undefined)
+        return { ids: new Set(), loaded: false };
+    const data = rel.data;
+    // A to-many relationship without `data` was not read; never treat it as empty.
+    if (!data)
+        return { ids: new Set(), loaded: false };
+    if (Array.isArray(data)) {
+        return {
+            ids: new Set(data.map((row) => row.id).filter(Boolean)),
+            loaded: true,
+        };
+    }
+    return { ids: data.id ? new Set([data.id]) : new Set(), loaded: true };
+};
 const timeValue = (document, name) => {
     const value = document.data?.attributes?.[name];
     // An unset field prefills EMPTY, never `0m`: the popup must not turn "nobody
@@ -227,9 +255,12 @@ const parentQueryFromDocument = (document, parentId) => {
  *  explicit `null` STICKS instead of falling back to the first option. */
 export function initialEditForm(document) {
     const parent = relId(document, 'parent_id');
+    const reviewers = reviewersFromDocument(document);
     return EDIT_FORM.initial(EMPTY_EDIT_FORM_OPTIONS, {
         ticketId: document.data?.id ?? '',
+        reviewersLoaded: reviewers.loaded,
         assignee: relId(document, 'assignee_user_id'),
+        reviewers: reviewers.ids,
         conductor: relId(document, 'conductor_id'),
         estimate: timeValue(document, 'time_estimate'),
         spent: timeValue(document, 'time_spent'),

package/dist/src/Entity/ticket/Form/reviewer-options.d.ts

@@ -0,0 +1,10 @@
+import type { Option } from '../../../Form/index.js';
+import type { DropshClient } from '../../../types.js';
+export declare const NO_WORKSPACE_REVIEWERS_ERROR = "no workspace in scope \u2014 reviewers cannot be loaded";
+export interface ReviewerOptionOutcome {
+    options: Option[];
+    error?: string | undefined;
+}
+/** Selected ids that are not in the bag stay visible/removable. */
+export declare function withSelectedReviewers(bag: Option[], selected: Iterable<string>, labels?: ReadonlyMap<string, string>): Option[];
+export declare function loadReviewerOptions(client: DropshClient, workspaceId: string | undefined): Promise<ReviewerOptionOutcome>;

package/dist/src/Entity/ticket/Form/reviewer-options.js

@@ -0,0 +1,48 @@
+// Form-layer adapter: the Reviewers option bag is membership ∩ users.
+// Data services stay form-ignorant; this module owns the intersection, the
+// Anonymous drop, and the reviewer-specific error. Never falls back to the
+// instance-wide user list.
+import { listAllUsers } from '../../user/Data/users.js';
+import { loadWorkspaceMemberships } from '../../workspace/Data/members.js';
+export const NO_WORKSPACE_REVIEWERS_ERROR = 'no workspace in scope — reviewers cannot be loaded';
+const toOption = (row) => ({
+    id: row.id,
+    label: row.label,
+});
+/** Selected ids that are not in the bag stay visible/removable. */
+export function withSelectedReviewers(bag, selected, labels = new Map()) {
+    const known = new Set(bag.map((option) => option.id));
+    const extra = [];
+    for (const id of selected) {
+        if (known.has(id))
+            continue;
+        extra.push({ id, label: labels.get(id) ?? id });
+    }
+    return extra.length === 0 ? bag : [...bag, ...extra];
+}
+export async function loadReviewerOptions(client, workspaceId) {
+    if (!workspaceId) {
+        return { options: [], error: NO_WORKSPACE_REVIEWERS_ERROR };
+    }
+    try {
+        const [memberships, users] = await Promise.all([
+            loadWorkspaceMemberships(client, workspaceId),
+            listAllUsers(client),
+        ]);
+        if (users.error) {
+            return { options: [], error: users.error };
+        }
+        const memberIds = new Set(memberships.memberIds);
+        return {
+            options: users.rows
+                .filter((user) => memberIds.has(user.id) && user.uid !== 0)
+                .map(toOption),
+        };
+    }
+    catch (caught) {
+        return {
+            options: [],
+            error: caught instanceof Error ? caught.message : String(caught),
+        };
+    }
+}

package/dist/src/Entity/ticket/Screen/conductor-tickets.d.ts

@@ -57,8 +57,8 @@ export declare class ConductorTicketsScreen extends ListScreen<TicketRow, void>
         }, {
             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";

package/dist/src/Entity/ticket/Screen/create-ticket-form.js

@@ -90,10 +90,14 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
             ...(context.project === undefined
                 ? {}
                 : { projectId: context.project.id }),
+            ...(context.services.workspaceId === undefined
+                ? {}
+                : { workspaceId: context.services.workspaceId }),
         });
         this.sources = sources;
         return composeCreateFormOptions(sources).catch((caught) => ({
             users: [],
+            reviewers: [],
             conductors: [],
             labels: [],
             workflows: [],

package/dist/src/Entity/ticket/Screen/edit-assignment-form.js

@@ -13,6 +13,7 @@ import { CANCEL_TICKET_ACTION_ID, cancelEditPayload, EDIT_FORM_CLOSED, EMPTY_EDI
 import { loadEditFormOptions } from '../Form/edit-data.js';
 import { editParentOptionSource } from '../Form/edit-parent-source.js';
 import { keyToIntent } from '../Form/keys.js';
+import { withSelectedReviewers } from '../Form/reviewer-options.js';
 export const editAssignmentInputContext = defineContext('edit-assignment-input', 'input');
 const relationshipId = (document, name) => {
     const data = document.data?.relationships?.[name]?.data;
@@ -20,6 +21,27 @@ const relationshipId = (document, name) => {
         return undefined;
     return Array.isArray(data) ? data[0]?.id : data.id;
 };
+const reviewerIds = (document) => {
+    const data = document.data?.relationships?.reviewers?.data;
+    if (!data)
+        return [];
+    return (Array.isArray(data) ? data : [data])
+        .map((row) => row.id)
+        .filter((id) => Boolean(id));
+};
+const includedUserLabels = (document) => {
+    const labels = new Map();
+    for (const row of document.included ?? []) {
+        if (row.type !== 'user--user' || !row.id)
+            continue;
+        const attrs = row.attributes ?? {};
+        const label = (typeof attrs.display_name === 'string' && attrs.display_name) ||
+            (typeof attrs.name === 'string' && attrs.name) ||
+            row.id;
+        labels.set(row.id, label);
+    }
+    return labels;
+};
 export class EditAssignmentFormScreen extends AsyncModalScreen {
     static result(ticketId, assigneeId) {
         return { type: 'ticket-assignment-updated', ticketId, assigneeId };
@@ -82,7 +104,7 @@ export class EditAssignmentFormScreen extends AsyncModalScreen {
         // once per screen lifetime through `OwnerIdentity` rather than threaded
         // straight through. Fails open: `unavailable` omits the hint entirely.
         const ownerOutcome = await this.ownerIdentity.resolve(context.services.client, context.services.currentUser);
-        const options = await loadEditFormOptions({
+        const loaded = await loadEditFormOptions({
             read: context.services.client,
             ...(context.services.writeClient === undefined
                 ? {}
@@ -92,7 +114,14 @@ export class EditAssignmentFormScreen extends AsyncModalScreen {
             ...(ownerOutcome.kind === 'resolved'
                 ? { ownerUserId: ownerOutcome.id }
                 : {}),
+            ...(context.services.workspaceId === undefined
+                ? {}
+                : { workspaceId: context.services.workspaceId }),
         }).catch(() => EMPTY_EDIT_FORM_OPTIONS);
+        const options = {
+            ...loaded,
+            reviewers: withSelectedReviewers(loaded.reviewers, reviewerIds(document), includedUserLabels(document)),
+        };
         // Parent typeahead: project-scoped source with self-exclusion (D5/D11).
         // No project ⇒ no source, so the bag stays absent and the field shows
         // its absentNote. Built as one object: OptionSources is Readonly and

package/dist/src/Entity/ticket/Screen/ticket-addons.d.ts

@@ -0,0 +1,94 @@
+import type { VNode } from '@opentui/core';
+import { type ActionItem } from '../../../Component/footer-actions/index.js';
+import { AsyncModalScreen } from '../../../Screen/async-modal-screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ModalChrome } from '../../../Screen/modal-screen.js';
+import type { ScreenAction, ScreenContext } from '../../../Screen/screen.js';
+import type { TicketDetailDocument } from '../../../types.js';
+import { type TicketAddon, type TicketAddons } from '../Data/addons.js';
+interface AddonsData {
+    ticket: TicketDetailDocument;
+    model: TicketAddons;
+}
+/** What the message form needs; passed as navigation state. */
+export interface AddonFormState {
+    ticketUuid: string;
+    addon: string;
+    key: string;
+    label: string;
+    input: NonNullable<TicketAddon['messages'][number]['input']>;
+}
+export declare class TicketAddonsScreen extends AsyncScreen<AddonsData> {
+    static readonly route: {
+        id: string;
+        path: string;
+        parent: string;
+        fallback: {
+            routeId: string;
+        };
+        context: (params: Readonly<Record<string, string>>, state: unknown, base: import("../../../Routing/context.js").ContextBag) => import("../../../Routing/context.js").ContextBag;
+    };
+    readonly id: string;
+    readonly frameId = "ticket";
+    private readonly cursor;
+    private selected;
+    private sending;
+    private timer;
+    protected load(context: ScreenContext): Promise<AddonsData>;
+    protected didLoad(data: AddonsData, context: ScreenContext): void;
+    reload(context: ScreenContext): void;
+    leave(): void;
+    reset(): void;
+    /** Re-read every 3 s while the shown addon has an open message. */
+    private schedulePoll;
+    private stopPoll;
+    private addon;
+    private entries;
+    private clampCursor;
+    protected renderLoading(): string[];
+    private lines;
+    protected renderReady(data: AddonsData, context: ScreenContext): VNode;
+    renderNonInteractive(context: ScreenContext): string[];
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): readonly ActionItem[];
+    protected notice(): string | undefined;
+    select(index: number, context: ScreenContext): boolean;
+    activate(index: number, context: ScreenContext): boolean;
+    /** Runs an entry's message: sends it, or opens its form. */
+    private run;
+    handleInput(input: string, context: ScreenContext): boolean;
+    commandForInput(input: string): string | undefined;
+    actionForInput(input: string, context: ScreenContext): ScreenAction | undefined;
+    receiveResult(result: unknown, context: ScreenContext): void;
+}
+type FormOptions = Record<string, {
+    id: string;
+    label: string;
+}[]>;
+/** The form of an action with input, built from its input subset. */
+export declare class AddonActionFormScreen extends AsyncModalScreen<FormOptions> {
+    static readonly route: {
+        id: string;
+        path: string;
+        parent: string;
+        presentation: "modal";
+    };
+    readonly id: string;
+    private target;
+    private form;
+    private values;
+    private errors;
+    private sending;
+    protected load(context: ScreenContext): Promise<FormOptions>;
+    protected didLoad(options: FormOptions): void;
+    protected renderLoading(): string[];
+    protected renderReady(options: FormOptions): VNode;
+    protected modalChrome(): ModalChrome;
+    protected actions(): readonly ActionItem[];
+    handleInput(input: string, context: ScreenContext): boolean;
+    private submit;
+    protected notice(): string | undefined;
+    reset(): void;
+}
+export {};