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

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

@@ -1,5 +1,5 @@
 import type { DropshClient } from '../../../types.js';
-import { type OptionSources } from '../../../Widget/index.js';
+import { type OptionSource, type OptionSources } from '../../../Widget/index.js';
 import { type CreateFormOptions } from './create.js';
 export { type EditFormClients, type EditFormHints, loadEditFormOptions, } from './edit-data.js';
 export { parentLabel } from './parent-source.js';
@@ -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
@@ -27,6 +29,15 @@ export interface CreateFormHints {
  * conductors — only what counts as "own" differs, which the caller passes in.
  */
 export declare const ownFirst: <T>(rows: T[], isOwn: (row: T) => boolean) => T[];
+/**
+ * The `conductors` option source for one (possibly absent) project.
+ *
+ * Extracted from `createFormSources` (GAIA-664 AC-8) so the screen can call it
+ * a SECOND time, scoped to whatever project the operator just picked in the
+ * new Project field — the only way the Conductor bag can re-scope without a
+ * second, hand-written read living beside this one.
+ */
+export declare function conductorOptionSource(client: DropshClient, hints: Pick<CreateFormHints, 'projectId' | 'ownerUserId' | 'ownConductorMachineId'>): OptionSource;
 /**
  * The option sources this popup's fields load through, keyed by FIELD id.
  *

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

@@ -16,11 +16,13 @@
 // primes them, re-queries them and merges them for every field alike. The popup's
 // policy is unchanged and still lives here; only the plumbing left.
 import { primeSources, } from '../../../Widget/index.js';
-import { listConductors } from '../../conductor/Data/conductors.js';
+import { listConductorsForProject } from '../../conductor/Data/conductors.js';
 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 { projectOptionSource } from './project-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.
@@ -47,6 +49,43 @@ const toOption = (row) => ({ id: row.id, label: row.label });
  * type's vocabularies a given widget wants is the widget's business.
  */
 const LABEL_VOCABULARY = 'gaia_labels';
+/**
+ * The `conductors` option source for one (possibly absent) project.
+ *
+ * Extracted from `createFormSources` (GAIA-664 AC-8) so the screen can call it
+ * a SECOND time, scoped to whatever project the operator just picked in the
+ * new Project field — the only way the Conductor bag can re-scope without a
+ * second, hand-written read living beside this one.
+ */
+export function conductorOptionSource(client, hints) {
+    const { projectId, ownerUserId, ownConductorMachineId } = hints;
+    return {
+        bag: 'conductors',
+        async load() {
+            // GAIA-664 review F4: a new ticket's project scopes the conductor
+            // candidates the same way the Web dialog's selection handler does —
+            // including offering NONE without a resolved project, since the
+            // server now rejects a conductor assignment on a projectless ticket
+            // the same way it rejects a cross-project one.
+            if (projectId === undefined) {
+                return { options: [] };
+            }
+            const outcome = await listConductorsForProject(client, projectId);
+            const assignable = outcome.rows.filter((c) => c.active);
+            // Two stable partitions, strongest LAST (GAIA-460 D8): everything I own
+            // rises above everyone else's, then this checkout's record rises above
+            // the rest of mine. Applied in the other order the weaker rule would
+            // scatter what the stronger one just gathered.
+            const byOwner = ownerUserId
+                ? ownFirst(assignable, (c) => c.ownerUserId === ownerUserId)
+                : assignable;
+            const rows = ownConductorMachineId
+                ? ownFirst(byOwner, (c) => c.machineId === ownConductorMachineId)
+                : byOwner;
+            return { options: rows.map(toOption), error: outcome.error };
+        },
+    };
+}
 /**
  * The option sources this popup's fields load through, keyed by FIELD id.
  *
@@ -71,7 +110,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,24 +123,17 @@ export function createFormSources(client, hints = {}) {
                 return { options: rows.map(toOption), error: outcome.error };
             },
         },
-        conductor: {
-            bag: 'conductors',
+        reviewers: {
+            bag: 'reviewers',
             async load() {
-                const outcome = await listConductors(client);
-                const assignable = outcome.rows.filter((c) => c.active);
-                // Two stable partitions, strongest LAST (GAIA-460 D8): everything I own
-                // rises above everyone else's, then this checkout's record rises above
-                // the rest of mine. Applied in the other order the weaker rule would
-                // scatter what the stronger one just gathered.
-                const byOwner = ownerUserId
-                    ? ownFirst(assignable, (c) => c.ownerUserId === ownerUserId)
-                    : assignable;
-                const rows = ownConductorMachineId
-                    ? ownFirst(byOwner, (c) => c.machineId === ownConductorMachineId)
-                    : byOwner;
-                return { options: rows.map(toOption), error: outcome.error };
+                return loadReviewerOptions(client, workspaceId);
             },
         },
+        conductor: conductorOptionSource(client, {
+            projectId,
+            ownerUserId,
+            ownConductorMachineId,
+        }),
         labels: {
             bag: 'labels',
             async load() {
@@ -118,6 +150,12 @@ export function createFormSources(client, hints = {}) {
         // error channel the parent-filter picker composes.
         sources.parent = parentOptionSource(client, projectId);
     }
+    else {
+        // GAIA-664 AC-8: no project in scope ⇒ the popup offers a Project field
+        // instead of refusing outright, over the SAME source the project-filter
+        // picker searches with (`projectOptionSource`) — never a second read.
+        sources.project = projectOptionSource(client);
+    }
     return sources;
 }
 /**
@@ -131,6 +169,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,10 +12,14 @@ export { cycleValue };
  */
 export interface CreateOptionErrors {
     users?: string | undefined;
+    reviewers?: string | undefined;
     conductors?: string | undefined;
     labels?: string | undefined;
     parents?: string | undefined;
     workflows?: string | undefined;
+    /** GAIA-664 AC-8: the project picker's own search, shown only while the
+     *  popup has no project in scope — see {@link CreateFormOptions.projects}. */
+    projects?: string | undefined;
     /**
      * The whole load threw, rather than one bag failing. Until GAIA-257 the kernel
      * answered that by silently substituting four empty bags (F2a) — a whole-form
@@ -38,6 +42,7 @@ export interface ParentOption extends Option {
 }
 export interface CreateFormOptions {
     users: Option[];
+    reviewers: Option[];
     conductors: Option[];
     labels: Option[];
     workflows: Option[];
@@ -49,6 +54,13 @@ export interface CreateFormOptions {
      * the first thing, which is why the key is optional rather than defaulted.
      */
     parents?: ParentOption[] | undefined;
+    /**
+     * Candidate projects, searched by name — the SAME source the project-filter
+     * picker composes (`projectOptionSource`). Only declared as a source while
+     * the popup has no project in scope (GAIA-664 AC-8): with one, the operator
+     * is already working inside it and the field does not exist.
+     */
+    projects?: Option[] | undefined;
     /** Present only when at least one read failed; see `CreateOptionErrors`. */
     errors?: CreateOptionErrors | undefined;
 }
@@ -67,9 +79,19 @@ 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 = 'project' | '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 {
+    /**
+     * The PICKED project's uuid, or null — GAIA-664 AC-8. Only a field on the
+     * form built WITHOUT a project in scope ({@link CREATE_FORM_WITH_PROJECT});
+     * on the ordinary form (a project already in scope) nothing ever sets it, so
+     * it reads as `undefined` at runtime despite the type — the same shape the
+     * other two-key autocomplete, `parent`, already has when its source is
+     * absent. `projectQuery` holds what was typed.
+     */
+    project: string | null;
+    projectQuery: string;
     /**
      * The ticket's title. `gaia_ticket.title` is `setRequired(TRUE)` server-side,
      * so a direct create without one is rejected — this was never optional
@@ -84,6 +106,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 +124,7 @@ export interface CreateFormPayload {
     description: string;
     workflow: Option | null;
     assignee: Option | null;
+    reviewers: Option[];
     conductor: Option | null;
     labels: Option[];
     /**
@@ -113,7 +137,8 @@ export interface CreateFormPayload {
 /** The option with `id`, or null — used by both forms' `toObject`. */
 export declare const optionFor: (list: Option[], id: string | null) => Option | null;
 /**
- * The declaration. No field carries a function. Exactly ONE select is
+ * The declaration used whenever a project is already in scope (unchanged,
+ * GAIA-664 AC-8). No field carries a function. Exactly ONE select is
  * `clearable` — the conductor (GAIA-309 D2); every other one cycles over real
  * options only, exactly as before GAIA-233.
  */
@@ -125,8 +150,29 @@ export declare const CREATE_FORM: {
     apply(s: FormState<CreateValues>, options: CreateFormOptions, intent: import("../../../Form/form.js").Intent): FormState<CreateValues>;
     toObject: (s: FormState<CreateValues>, options: CreateFormOptions) => CreateFormPayload;
 };
-/** Field order in the popup (top to bottom). */
+/**
+ * The declaration used when the popup opens with NO project in scope
+ * (GAIA-664 AC-8, the human decision replacing the old refusal-only form):
+ * one extra `autocomplete` field, ahead of everything else, over the SAME
+ * `projectOptionSource` the project-filter picker searches with — never a
+ * second project read. Picking a row here is what the screen reads to scope
+ * the Conductor bag and to carry a project into both submit paths; `toObject`
+ * needs none of it; the id travels through `CreateValues.project` instead,
+ * the same way the screen already reads `context.project` for the other form.
+ */
+export declare const CREATE_FORM_WITH_PROJECT: {
+    fields: FieldDecl[];
+    activeField: (s: FormState<CreateValues>) => FieldDecl;
+    move: (s: FormState<CreateValues>, d: number) => FormState<CreateValues>;
+    initial(options: CreateFormOptions, prefill?: Partial<CreateValues>): FormState<CreateValues>;
+    apply(s: FormState<CreateValues>, options: CreateFormOptions, intent: import("../../../Form/form.js").Intent): FormState<CreateValues>;
+    toObject: (s: FormState<CreateValues>, options: CreateFormOptions) => CreateFormPayload;
+};
+/** Field order in the popup (top to bottom), a project already in scope. */
 export declare const FIELDS: FieldDef<CreateFieldId>[];
+/** Field order with NO project in scope (GAIA-664 AC-8) — `FIELDS` plus the
+ *  Project picker, ahead of everything else. */
+export declare const FIELDS_WITH_PROJECT: FieldDef<CreateFieldId>[];
 export type CreateFormState = FormState<CreateValues>;
 /**
  * The values the popup carries from one open to the next (GAIA-314 D2).

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

@@ -5,6 +5,7 @@
 // is repeated here.
 import { cycleValue, declareForm, } from '../../../Form/index.js';
 import { PARENT_PAGE_SIZE } from '../Data/parents.js';
+import { PROJECT_PAGE_SIZE } from '../Data/projects-search.js';
 // `cycleValue` is re-exported because GAIA-233's contract cases pin it against
 // an arbitrary option list, which no declared form can supply.
 //
@@ -48,60 +49,95 @@ const parentFor = (list, id) => {
         : null;
 };
 /**
- * The declaration. No field carries a function. Exactly ONE select is
+ * The shared field list (GAIA-664 AC-8): every field BUT the project picker,
+ * which only one of the two declarations below carries. Factored out so the
+ * two forms cannot drift apart on the fields neither decision touches — only
+ * `declareForm`'s one `fields` callback may differ between them.
+ */
+const sharedFields = (f) => [
+    // First, because it is the one field the server REQUIRES (D1). Both submit
+    // paths read it: the direct write sends it, the agent adopts it from the
+    // temp JSON spec.
+    f.text('title', 'Title'),
+    f.text('description', 'Description'),
+    // Between the description and the assignee on purpose: a parent is chosen
+    // WITH what the ticket is about, before who works on it (GAIA-257 D5).
+    f.autocomplete('parent', 'Parent', {
+        from: 'parents',
+        query: 'parentQuery',
+        // The two things an ENTITY-AGNOSTIC widget cannot know, as plain data on
+        // the declaration (GAIA-257 re-entry AC-15 keeps a field printable, so
+        // neither may be a function). `absentNote` is what an ABSENT bag means
+        // HERE — the popup opened from the dashboard, where `n` is global and no
+        // project is in scope (D8) — as against an empty array, which would mean
+        // "this project was searched and nothing matched". `pageSize` is what the
+        // bag is filled from, so the suggestion list can say a full page may be a
+        // truncated answer even when the local filter narrows it (R3 / AC-17).
+        absentNote: '(no project context — open a project to pick a parent)',
+        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
+    // and not implicit. The preselection survives — `initial()` fills a select
+    // from `listOf(options)[0]` regardless of `clearable`, and `ownFirst` in
+    // `create-data.ts` puts the machine's own conductor there.
+    f.select('conductor', 'Conductor', { from: 'conductors', clearable: true }),
+    f.multi('labels', 'Labels', { from: 'labels' }),
+    f.select('workflow', 'Workflow', { from: 'workflows' }),
+    // Agent row FIRST and keeping the id `'submit'` (D7): nothing that exists
+    // today changes its meaning or its position.
+    f.action('Create with agent', AGENT_ACTION_ID),
+    f.action('Create directly', DIRECT_ACTION_ID),
+];
+const toCreatePayload = (v, o) => ({
+    title: v.title,
+    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),
+});
+/**
+ * The declaration used whenever a project is already in scope (unchanged,
+ * GAIA-664 AC-8). No field carries a function. Exactly ONE select is
  * `clearable` — the conductor (GAIA-309 D2); every other one cycles over real
  * options only, exactly as before GAIA-233.
  */
 export const CREATE_FORM = declareForm({
+    fields: sharedFields,
+    toObject: toCreatePayload,
+});
+/**
+ * The declaration used when the popup opens with NO project in scope
+ * (GAIA-664 AC-8, the human decision replacing the old refusal-only form):
+ * one extra `autocomplete` field, ahead of everything else, over the SAME
+ * `projectOptionSource` the project-filter picker searches with — never a
+ * second project read. Picking a row here is what the screen reads to scope
+ * the Conductor bag and to carry a project into both submit paths; `toObject`
+ * needs none of it; the id travels through `CreateValues.project` instead,
+ * the same way the screen already reads `context.project` for the other form.
+ */
+export const CREATE_FORM_WITH_PROJECT = declareForm({
     fields: (f) => [
-        // First, because it is the one field the server REQUIRES (D1). Both submit
-        // paths read it: the direct write sends it, the agent adopts it from the
-        // temp JSON spec.
-        f.text('title', 'Title'),
-        f.text('description', 'Description'),
-        // Between the description and the assignee on purpose: a parent is chosen
-        // WITH what the ticket is about, before who works on it (GAIA-257 D5).
-        f.autocomplete('parent', 'Parent', {
-            from: 'parents',
-            query: 'parentQuery',
-            // The two things an ENTITY-AGNOSTIC widget cannot know, as plain data on
-            // the declaration (GAIA-257 re-entry AC-15 keeps a field printable, so
-            // neither may be a function). `absentNote` is what an ABSENT bag means
-            // HERE — the popup opened from the dashboard, where `n` is global and no
-            // project is in scope (D8) — as against an empty array, which would mean
-            // "this project was searched and nothing matched". `pageSize` is what the
-            // bag is filled from, so the suggestion list can say a full page may be a
-            // truncated answer even when the local filter narrows it (R3 / AC-17).
-            absentNote: '(no project context — open a project to pick a parent)',
-            pageSize: PARENT_PAGE_SIZE,
+        f.autocomplete('project', 'Project', {
+            from: 'projects',
+            query: 'projectQuery',
+            pageSize: PROJECT_PAGE_SIZE,
         }),
-        f.select('assignee', 'Assignee', { from: 'users' }),
-        // 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
-        // and not implicit. The preselection survives — `initial()` fills a select
-        // from `listOf(options)[0]` regardless of `clearable`, and `ownFirst` in
-        // `create-data.ts` puts the machine's own conductor there.
-        f.select('conductor', 'Conductor', { from: 'conductors', clearable: true }),
-        f.multi('labels', 'Labels', { from: 'labels' }),
-        f.select('workflow', 'Workflow', { from: 'workflows' }),
-        // Agent row FIRST and keeping the id `'submit'` (D7): nothing that exists
-        // today changes its meaning or its position.
-        f.action('Create with agent', AGENT_ACTION_ID),
-        f.action('Create directly', DIRECT_ACTION_ID),
+        ...sharedFields(f),
     ],
-    toObject: (v, o) => ({
-        title: v.title,
-        description: v.description,
-        workflow: optionFor(o.workflows, v.workflow),
-        assignee: optionFor(o.users, v.assignee),
-        conductor: optionFor(o.conductors, v.conductor),
-        labels: o.labels.filter((x) => v.labels.has(x.id)),
-        parent: parentFor(o.parents ?? [], v.parent),
-    }),
+    toObject: toCreatePayload,
 });
-/** Field order in the popup (top to bottom). */
+/** Field order in the popup (top to bottom), a project already in scope. */
 export const FIELDS = CREATE_FORM.fields;
+/** Field order with NO project in scope (GAIA-664 AC-8) — `FIELDS` plus the
+ *  Project picker, ahead of everything else. */
+export const FIELDS_WITH_PROJECT = CREATE_FORM_WITH_PROJECT.fields;
 /** Snapshot the routing values of a form that is about to be replaced. */
 export const rememberedValues = (s) => ({
     parent: s.parent,
@@ -135,6 +171,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). */