@gaia-ai/addon-gaia-ui 0.9.1 → 0.9.2

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

@@ -1,7 +1,7 @@
 import type { VNode } from '@opentui/core';
 import type { ActiveRunInfo } from '../../../run/Data/active-run.js';
 import type { FieldDef } from '../../Form/create.js';
-import { type EditFieldId, type EditFormOptions, type EditFormState } from '../../Form/edit.js';
+import type { EditFieldId, EditFormOptions, EditFormState } from '../../Form/edit.js';
 /** The chrome around the fields: who we write as, what went wrong, who is live. */
 export interface EditFormChrome {
     /** The auth profile the write will actually use (AC-5 — never implied). */

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

@@ -1,6 +1,6 @@
-// The "Edit ticket" popup's body (GAIA-233, widened by GAIA-308), as CHROME
-// around its declaration — a genuine sibling of `Component/create-form` now, not
-// a second implementation of it.
+// The "Edit ticket" popup's body (GAIA-233, widened by GAIA-308 / GAIA-360), as
+// CHROME around its declaration — a genuine sibling of `Component/create-form`
+// now, not a second implementation of it.
 //
 // GAIA-257 (re-entry) AC-13/AC-14. What this file used to carry, and why each
 // piece had to go:
@@ -22,10 +22,13 @@
 // things that really are this popup's own — around one call.
 //
 // GAIA-313 (D4) finally makes the claim above literally true: the field list is
-// HANDED IN rather than imported. There are two declarations now — one with the
-// State row, one without — so importing either here would make this file a
+// HANDED IN rather than imported. There are two declarations now — with and
+// without Cancel ticket — so importing either here would make this file a
 // second decider that can drift from the screen's. It names no field; it renders
-// the list it is given, and keys its one conditional legend on that list.
+// the list it is given.
+//
+// GAIA-360 removes the State select legend. Parent and Labels are ordinary
+// declared fields drawn by the shared widget layer.
 //
 // GAIA-340 Task 9 — and it returns a RENDERABLE TREE. The rows are gone with the
 // caret they carried: this popup's two `text` fields hold their insertion point
@@ -35,7 +38,6 @@
 import { columnNode, indentedColumn, textNode } from '../../../../lib/vnode.js';
 import { wrapToWidth } from '../../../../lib/width.js';
 import { findOption, renderDeclaredFieldsTree, } from '../../../../Widget/index.js';
-import { STATE_FIELD_ID, } from '../../Form/edit.js';
 const DEFAULT_WIDTH = 58;
 /** The id the popup's body column is rooted at. */
 export const EDIT_FORM_REGION = 'edit-form';
@@ -48,24 +50,16 @@ export const EDIT_FORM_REGION = 'edit-form';
  * again. One number, spent once, in the layout.
  */
 const WARNING_INDENT = 2;
-/** Four semantically different things in one form, so the form says which is
- *  which: `assignee_user_id` is human ownership, `conductor_id` is what
- *  dispatches, and the two durations are the ACCOUNTED time (GAIA-308) — not
- *  the run footprint the Runs tab shows, which the machine measured and which
- *  is allowed to differ (R6). 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. */
+/** Four assignment/time fields plus structure: `assignee_user_id` is human
+ *  ownership, `conductor_id` is what dispatches, the two durations are the
+ *  ACCOUNTED time (GAIA-308) — not the run footprint the Runs tab shows — and
+ *  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 · ' +
-    'Estimate/Spent = accounted time, not the run footprint (1d 2h 30m, 90m, or a bare number as minutes)';
-/**
- * GAIA-313 D6 — the popup now has two "cancels" and they mean opposite things:
- * `Esc` closes the popup, the State row abandons the ticket. The status line
- * says `Esc cancel`, so the disambiguation has to be on screen, next to the row
- * that caused it. Rendered only when that row is present — a terminal ticket's
- * popup would otherwise explain an affordance it does not offer.
- */
-const STATE_LEGEND = 'State = the only lifecycle move this popup offers is cancelling the ticket · ' +
-    'Esc closes the popup and writes nothing';
+    '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)';
 /**
  * A block of chrome prose, wrapped so the frame never has to clip it.
  *
@@ -109,8 +103,6 @@ export function editFormTree(fields, s, opts, chrome = {}) {
     rows.push(renderDeclaredFieldsTree(fields, s, opts, { width }));
     rows.push(textNode({ id: 'edit-form-gap', content: '' }));
     rows.push(...proseNodes(LEGEND, width, 'edit-form-legend'));
-    if (fields.some((f) => f.id === STATE_FIELD_ID))
-        rows.push(...proseNodes(STATE_LEGEND, width, 'edit-form-state-legend'));
     if (chrome.message !== undefined && chrome.message !== '') {
         rows.push(...proseNodes(chrome.message, width, 'edit-form-message'));
     }

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

@@ -1,5 +1,5 @@
 import type { OptionClients } from '../../transport.js';
-import { type EditFormOptions } from './edit.js';
+import type { EditFormOptions } from './edit.js';
 /** The two clients an edit-options load may use, by role. */
 export type EditFormClients = OptionClients;
 export interface EditFormHints {

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

@@ -1,14 +1,20 @@
 // GAIA-236 — the ADAPTER between the data services and the EDIT popup, and a sibling
 // of `loadCreateFormOptions` rather than a parameterisation of it. A data service
-// (`users.ts`, `conductors.ts`) returns data and knows nothing about forms; this
-// module knows both sides and therefore owns the mapping to `Option` and this popup's
-// policy: read write-client-first, drop Anonymous, filter conductors to the ticket's
-// project, put liveness in the label, and do NOT reorder — the popup preselects the
-// ticket's current assignee. Each rule has exactly one user, so each is written
-// once, here, beside the create adapter it differs from.
+// (`users.ts`, `conductors.ts`, `terms.ts`) returns data and knows nothing about forms;
+// this module knows both sides and therefore owns the mapping to `Option` and this
+// popup's policy: read write-client-first for users/conductors, drop Anonymous, filter
+// conductors to the ticket's project, put liveness in the label, load the
+// `gaia_labels` vocabulary for the Labels multi-select, and do NOT reorder — the
+// popup preselects the ticket's current assignee. Each rule has exactly one user,
+// so each is written once, here, beside the create adapter it differs from.
+//
+// GAIA-360: labels bag replaces the constant State select targets. Parent typeahead
+// is an OptionSource on the screen, not a batch bag here.
 import { listConductorsPreferringWrite, } from '../../conductor/Data/conductors.js';
+import { listTerms } from '../../term/Data/terms.js';
 import { listUsersPreferringWrite } from '../../user/Data/users.js';
-import { STATE_TARGET_OPTIONS } from './edit.js';
+/** The vocabulary this popup offers as its labels (GAIA-360 D9 / D11). */
+const LABEL_VOCABULARY = 'gaia_labels';
 /**
  * uid 0 is Drupal's Anonymous and never a valid human assignee. A row whose uid never
  * loaded is `undefined` — NOT Anonymous — and stays.
@@ -28,15 +34,20 @@ const withStatusSuffix = (c) => ({
     label: c.status ? `${c.label} (${c.status})` : c.label,
 });
 export async function loadEditFormOptions(clients, hints = {}) {
-    const [users, conductors] = await Promise.all([
+    // Labels have no write-preferring helper: terms are not write-gated the way
+    // assignees/conductors are. Fail-open to [] when the read client is absent or
+    // the vocabulary throws (D11).
+    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([
         listUsersPreferringWrite(clients),
         listConductorsPreferringWrite(clients),
+        labelsPromise,
     ]);
     return {
         users: excludeAnonymous(users).map((u) => ({ id: u.id, label: u.label })),
         conductors: inProject(conductors, hints.projectId).map(withStatusSuffix),
-        // A constant, not a read — the popup's State row needs its positions
-        // whether or not the two collection reads succeeded (D8).
-        stateTargets: STATE_TARGET_OPTIONS,
+        labels,
     };
 }

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

@@ -0,0 +1,8 @@
+import type { DropshClient } from '../../../types.js';
+import type { OptionSource } from '../../../Widget/index.js';
+import type { ParentOption } from './create.js';
+/**
+ * Parent candidates for the edit popup: project-scoped, identifier+title match,
+ * excluding `ticketId` so an operator cannot parent a ticket to itself.
+ */
+export declare function editParentOptionSource(client: DropshClient, projectId: string, ticketId: string): OptionSource<ParentOption>;

package/dist/src/Entity/ticket/Form/edit-parent-source.js

@@ -0,0 +1,23 @@
+// GAIA-360 D5/D9 — edit's Parent autocomplete source: the shared
+// `parentOptionSource` (identifier+title match, project scope) with the open
+// ticket filtered out of every load. Self-parent is a client-side footgun;
+// deeper cycle detection stays server-side.
+import { parentOptionSource } from './parent-source.js';
+/**
+ * Parent candidates for the edit popup: project-scoped, identifier+title match,
+ * excluding `ticketId` so an operator cannot parent a ticket to itself.
+ */
+export function editParentOptionSource(client, projectId, ticketId) {
+    const base = parentOptionSource(client, projectId, 'identifier+title');
+    return {
+        bag: base.bag,
+        ...(base.debounceMs === undefined ? {} : { debounceMs: base.debounceMs }),
+        async load(query) {
+            const outcome = await base.load(query);
+            return {
+                options: outcome.options.filter((row) => row.id !== ticketId),
+                ...(outcome.error === undefined ? {} : { error: outcome.error }),
+            };
+        },
+    };
+}

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

@@ -1,9 +1,10 @@
 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' | 'stateTarget' | 'submit';
+export type EditFieldId = 'assignee' | 'conductor' | 'estimate' | 'spent' | 'parent' | 'labels' | 'submit' | 'cancelTicket';
 /**
- * GAIA-313 — the ONE lifecycle move this popup offers, as a named constant.
+ * GAIA-313 / GAIA-360 — the ONE lifecycle move this popup offers, as a named
+ * constant.
  *
  * Not derived, and deliberately so: `state_flow` is a `gaia_dashboard` computed
  * field rendering the happy path (`qualification … done`) and never contains
@@ -17,14 +18,13 @@ export type EditFieldId = 'assignee' | 'conductor' | 'estimate' | 'spent' | 'sta
  * predicate, and no workflow id is needed to tell them apart.
  */
 export declare const CANCELLED_STATE = "cancelled";
-/** The position that writes nothing. Not `null`: the shared `select` widget
- *  renders a clearable null as `— none —`, which is not what "keep" means. */
-export declare const KEEP_STATE = "keep";
-/** The declared field's id. Never `cancel` — `intent.kind === 'cancel'` already
- *  means "close the popup", and two meanings for one word is a defect waiting. */
-export declare const STATE_FIELD_ID = "stateTarget";
-/** The two positions of the State row, in ring order. */
-export declare const STATE_TARGET_OPTIONS: Option[];
+/**
+ * The Cancel ticket action's field id (GAIA-360 D4).
+ *
+ * Never `'cancel'` — `intent.kind === 'cancel'` already means "close the
+ * popup", and two meanings for one word is a defect waiting.
+ */
+export declare const CANCEL_TICKET_ACTION_ID = "cancelTicket";
 /**
  * The states no transition leaves, in every ticket workflow.
  *
@@ -36,9 +36,13 @@ export declare const TERMINAL_TICKET_STATES: ReadonlySet<string>;
 export interface EditFormOptions {
     users: Option[];
     conductors: Option[];
-    /** A CONSTANT list, not a read — it rides in the bag because `from` names a
-     *  bag key and that is the only channel a declared select has (D8). */
-    stateTargets: Option[];
+    labels: Option[];
+    /**
+     * Parent candidates from the option loader (project-scoped typeahead). Absent
+     * until the screen primes a source; an empty array means "searched, nothing
+     * matched" once a source is live.
+     */
+    parents?: Option[] | undefined;
 }
 /** What the form HOLDS. `ticketId` is a NON-field value: the kernel carries it
  *  verbatim so submit needs no ambient state, and never transitions it. */
@@ -49,12 +53,12 @@ interface EditValues {
     /** The human duration as TYPED — seconds only exist at `toObject` (D5). */
     estimate: string;
     spent: string;
-    /** `KEEP_STATE` or `CANCELLED_STATE`. Nullable because `SelectKey` requires
-     *  it; the control cannot produce a null (non-clearable ring, inert Del). */
-    stateTarget: string | null;
+    /** The PICKED parent's uuid, or null. `parentQuery` holds what was typed. */
+    parent: string | null;
+    parentQuery: string;
+    labels: ReadonlySet<string>;
 }
-/** The payload of the PATCH (GAIA-233 Decision 2's `ResourceWriteBody`, which
- *  already declares `attributes?`, so the writer needs no change). */
+/** The payload of the ordinary Save PATCH (GAIA-233 Decision 2). */
 export interface EditFormPayload {
     attributes: Record<string, number | string | null>;
     relationships: {
@@ -70,6 +74,24 @@ export interface EditFormPayload {
                 id: string;
             } | null;
         };
+        labels: {
+            data: {
+                type: string;
+                id: string;
+            }[];
+        };
+        parent_id: {
+            data: {
+                type: string;
+                id: string;
+            } | null;
+        };
+    };
+}
+/** Cancel ticket writes ONLY the lifecycle attribute (GAIA-360 D1). */
+export interface CancelEditPayload {
+    attributes: {
+        state: typeof CANCELLED_STATE;
     };
 }
 /** The ordinary popup: a non-terminal ticket can be cancelled from it. */
@@ -81,7 +103,7 @@ export declare const EDIT_FORM: {
     apply(s: FormState<EditValues>, options: EditFormOptions, intent: import("../../../Form/form.js").Intent): FormState<EditValues>;
     toObject: (s: FormState<EditValues>, options: EditFormOptions) => EditFormPayload;
 };
-/** A terminal ticket's popup: assignment and time only. */
+/** A terminal ticket's popup: assignment, times, structure — no Cancel ticket. */
 export declare const EDIT_FORM_TERMINAL: {
     fields: import("../../../Form/field.js").FieldDecl[];
     activeField: (s: FormState<EditValues>) => import("../../../Form/field.js").FieldDecl;
@@ -94,12 +116,12 @@ export type EditFormDeclaration = typeof EDIT_FORM;
 /** The ticket's state as the popup sees it; `''` when the read carried none. */
 export declare const ticketState: (document: TicketDetailDocument) => string;
 /**
- * Which declaration a ticket gets (AC-4).
+ * Which declaration a ticket gets (AC-4 / D13).
  *
- * An unknown state fails OPEN (D7): `loadTicketDetail` requests no fieldset, so
+ * An unknown state fails OPEN (D13): `loadTicketDetail` requests no fieldset, so
  * a missing `state` means genuinely unknown rather than not-requested. Hiding
- * the row on a thin read would cost a legitimate affordance; offering it costs
- * at worst the server's 422, which the popup already renders in full.
+ * Cancel ticket on a thin read would cost a legitimate affordance; offering it
+ * costs at worst the server's 422, which the popup already renders in full.
  */
 export declare const editFormFor: (document: TicketDetailDocument) => EditFormDeclaration;
 /** Field order in the popup, per declaration. */
@@ -107,26 +129,30 @@ export declare const EDIT_FIELDS: FieldDef<EditFieldId>[];
 export declare const EDIT_FIELDS_TERMINAL: FieldDef<EditFieldId>[];
 export type EditFormState = FormState<EditValues>;
 /**
- * No lists to OFFER — the two server-read bags are empty; the constant one is
- * not, because it is not read from anywhere.
- *
- * The prefill below names every value, and `clear`/`toObject` read no option
- * list, so the adapters that have no options to pass hand over this bag.
- * Exported so the screen's options-failure path can reuse it: a failed
- * user/conductor read must not silently take the State row's positions away
- * (D8).
+ * No lists to OFFER — bags start empty until the adapter / option loader fills
+ * them. Prefill names every value, and `clear`/`toObject` read no option list
+ * for the required fields, so adapters that have no options hand over this bag.
+ * Exported so the screen's options-failure path can reuse it (D11): a failed
+ * user/conductor/label read must not silently remove Cancel ticket (D8 keeps
+ * the action on the declaration, not in the bag).
  */
 export declare const EMPTY_EDIT_FORM_OPTIONS: EditFormOptions;
 /** Prefill from the ticket's CURRENT values (AC-1) — never from `opts[0]`. The
  *  kernel applies a prefill with `Object.hasOwn`, so an unassigned ticket's
  *  explicit `null` STICKS instead of falling back to the first option. */
 export declare function initialEditForm(document: TicketDetailDocument): EditFormState;
+/**
+ * The Cancel ticket PATCH body (GAIA-360 D1): lifecycle only.
+ *
+ * Local field edits are discarded; after a successful write the detail reloads
+ * from the server (same as Save's reload path). No relationships.
+ */
+export declare const cancelEditPayload: () => CancelEditPayload;
 export declare const activeEditField: (s: EditFormState) => FieldDef<EditFieldId>;
 export declare const moveEditField: (s: EditFormState, delta: number) => EditFormState;
 /** Cycle the active select by `dir`, `null` included (AC-4). */
 export declare const cycleEdit: (s: EditFormState, opts: EditFormOptions, dir: 1 | -1) => EditFormState;
-/** Clear the active select outright (the Del/Backspace shortcut). Cycling to `null`
- *  already works; a long conductor list just makes it tedious. */
+/** Clear the active select/autocomplete outright (the Del/Backspace shortcut). */
 export declare const clearEditValue: (s: EditFormState) => EditFormState;
 export declare const serializeEdit: (s: EditFormState) => EditFormPayload;
 export {};

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

@@ -1,17 +1,20 @@
-// The "Edit ticket" popup (GAIA-233, widened by GAIA-308 and GAIA-313) as a
-// DECLARATION over the form kernel (GAIA-236): two `clearable` selects, two text
-// fields carrying the accounted durations, one non-clearable State select, plus
-// an action; and one `toObject` that yields the JSON:API payload of the PATCH.
-// Its own field list, its own prefill source (the ticket's own relationships and
-// attributes, never `opts[0]`) and its own output — the mechanics are the
-// kernel's. No I/O here.
+// The "Edit ticket" popup (GAIA-233, widened by GAIA-308 / GAIA-313 / GAIA-360)
+// as a DECLARATION over the form kernel (GAIA-236): two `clearable` selects, two
+// text fields for accounted durations, a clearable Parent autocomplete, a Labels
+// multi-select, and dual actions (Save + Cancel ticket on non-terminal). One
+// `toObject` yields the ordinary Save PATCH; Cancel ticket uses a separate pure
+// payload helper. No I/O here.
 //
-// GAIA-313 makes it TWO declarations from one body: a terminal ticket's popup
-// simply does not carry the State row (D3), and `editFormFor` picks between them.
+// GAIA-360 removes the State select entirely (D8). Cancelling is a second
+// `f.action` whose id is never `cancel` — that intent closes the popup (Esc).
+// Two declarations from one body: a terminal ticket's popup simply omits the
+// Cancel ticket action (D3), and `editFormFor` picks between them.
 import { declareForm } from '../../../Form/index.js';
 import { formatDuration, parseDuration } from '../../../lib/format.js';
+import { PARENT_PAGE_SIZE } from '../Data/parents.js';
 /**
- * GAIA-313 — the ONE lifecycle move this popup offers, as a named constant.
+ * GAIA-313 / GAIA-360 — the ONE lifecycle move this popup offers, as a named
+ * constant.
  *
  * Not derived, and deliberately so: `state_flow` is a `gaia_dashboard` computed
  * field rendering the happy path (`qualification … done`) and never contains
@@ -25,17 +28,13 @@ import { formatDuration, parseDuration } from '../../../lib/format.js';
  * predicate, and no workflow id is needed to tell them apart.
  */
 export const CANCELLED_STATE = 'cancelled';
-/** The position that writes nothing. Not `null`: the shared `select` widget
- *  renders a clearable null as `— none —`, which is not what "keep" means. */
-export const KEEP_STATE = 'keep';
-/** The declared field's id. Never `cancel` — `intent.kind === 'cancel'` already
- *  means "close the popup", and two meanings for one word is a defect waiting. */
-export const STATE_FIELD_ID = 'stateTarget';
-/** The two positions of the State row, in ring order. */
-export const STATE_TARGET_OPTIONS = [
-    { id: KEEP_STATE, label: 'keep current state' },
-    { id: CANCELLED_STATE, label: 'cancelled — abandon this ticket' },
-];
+/**
+ * The Cancel ticket action's field id (GAIA-360 D4).
+ *
+ * Never `'cancel'` — `intent.kind === 'cancel'` already means "close the
+ * popup", and two meanings for one word is a defect waiting.
+ */
+export const CANCEL_TICKET_ACTION_ID = 'cancelTicket';
 /**
  * The states no transition leaves, in every ticket workflow.
  *
@@ -50,6 +49,10 @@ export const TERMINAL_TICKET_STATES = new Set([
 const linkage = (type, id) => ({
     data: id === null ? null : { type, id },
 });
+/** Multi-value term linkage for labels (always present on ordinary Save). */
+const labelsLinkage = (ids) => ({
+    data: [...ids].map((id) => ({ type: 'gaia_term--gaia_labels', id })),
+});
 /**
  * The two time attributes of the PATCH, in seconds.
  *
@@ -64,7 +67,7 @@ const linkage = (type, id) => ({
  *                  keeps what it had and the operator sees their typo survive
  *                  the save.
  *
- * This is why `toObject` cannot emit both keys unconditionally the way the two
+ * This is why `toObject` cannot emit both keys unconditionally the way the
  * relationships do.
  */
 const timeAttributes = (v) => {
@@ -82,31 +85,22 @@ const timeAttributes = (v) => {
     return out;
 };
 /**
- * The ONE lifecycle attribute this popup may write, and only on the position
- * that means it (AC-2/AC-3).
- *
- * On every other position the key is ABSENT rather than sent as the ticket's
- * current value: a self-transition (`coding → coding`) is not a declared
- * transition in any workflow, so echoing the current state would turn every
- * ordinary assignee edit into a 422.
- */
-const stateAttribute = (v) => v.stateTarget === CANCELLED_STATE ? { state: CANCELLED_STATE } : {};
-/**
- * One body, two declarations (D3).
+ * One body, two declarations (D3 / D8).
  *
  * BOTH assignment selects are `clearable`: AC-4 requires REMOVING an assignment,
- * not only changing it, so `null` is a real position in each cycle.
+ * not only changing it, so `null` is a real position in each cycle. Parent is
+ * clearable for the same reason (D7). Labels always PATCH the full selected set,
+ * including empty.
  *
- * `toObject` always emits BOTH relationships, even when neither changed: "only send
- * what changed" is a rule the operator cannot read off the screen, and an explicit
- * no-op PATCH is what the popup visibly promises. The two time attributes are the
- * documented exception — see `timeAttributes`.
+ * Ordinary Save NEVER includes `attributes.state` — a self-transition is not a
+ * declared edge, so echoing the current state would turn every ordinary edit
+ * into a 422. Cancel ticket is a separate action that uses `cancelEditPayload`.
  *
  * The kernel builds its field list once, at module load, and every consumer —
  * the renderer's `▸` marker, `keyToIntent`, `apply` — indexes that array by
  * `state.active`. So a row cannot be hidden at render time without shifting
  * every index below it; absence has to be a property of WHICH DECLARATION is in
- * force. The State row sits last, above the action, so indices 0–3 never move.
+ * force.
  */
 const declareEditForm = (cancellable) => declareForm({
     fields: (f) => [
@@ -117,25 +111,33 @@ const declareEditForm = (cancellable) => declareForm({
         }),
         f.text('estimate', 'Estimate'),
         f.text('spent', 'Spent'),
-        // NOT clearable: that is what makes "exactly two positions" provable
-        // rather than observed — `keyToIntent` returns null for Del/Backspace on
-        // a non-clearable select, and `cycleValue` never puts a null in the ring.
+        f.autocomplete('parent', 'Parent', {
+            from: 'parents',
+            query: 'parentQuery',
+            clearable: true,
+            absentNote: '(no project context — open a project to pick a parent)',
+            pageSize: PARENT_PAGE_SIZE,
+        }),
+        f.multi('labels', 'Labels', { from: 'labels' }),
+        f.action('Save', 'submit'),
         ...(cancellable
-            ? [f.select('stateTarget', 'State', { from: 'stateTargets' })]
+            ? [f.action('Cancel ticket', CANCEL_TICKET_ACTION_ID)]
             : []),
-        f.action('Save'),
     ],
     toObject: (v) => ({
-        attributes: { ...timeAttributes(v), ...stateAttribute(v) },
+        // Ordinary Save never writes lifecycle state (D6/D7).
+        attributes: { ...timeAttributes(v) },
         relationships: {
             assignee_user_id: linkage('user--user', v.assignee),
             conductor_id: linkage('gaia_conductor--gaia_conductor', v.conductor),
+            labels: labelsLinkage(v.labels),
+            parent_id: linkage('gaia_ticket--gaia_ticket', v.parent),
         },
     }),
 });
 /** The ordinary popup: a non-terminal ticket can be cancelled from it. */
 export const EDIT_FORM = declareEditForm(true);
-/** A terminal ticket's popup: assignment and time only. */
+/** A terminal ticket's popup: assignment, times, structure — no Cancel ticket. */
 export const EDIT_FORM_TERMINAL = declareEditForm(false);
 /** The ticket's state as the popup sees it; `''` when the read carried none. */
 export const ticketState = (document) => {
@@ -143,12 +145,12 @@ export const ticketState = (document) => {
     return typeof value === 'string' ? value : '';
 };
 /**
- * Which declaration a ticket gets (AC-4).
+ * Which declaration a ticket gets (AC-4 / D13).
  *
- * An unknown state fails OPEN (D7): `loadTicketDetail` requests no fieldset, so
+ * An unknown state fails OPEN (D13): `loadTicketDetail` requests no fieldset, so
  * a missing `state` means genuinely unknown rather than not-requested. Hiding
- * the row on a thin read would cost a legitimate affordance; offering it costs
- * at worst the server's 422, which the popup already renders in full.
+ * Cancel ticket on a thin read would cost a legitimate affordance; offering it
+ * costs at worst the server's 422, which the popup already renders in full.
  */
 export const editFormFor = (document) => TERMINAL_TICKET_STATES.has(ticketState(document))
     ? EDIT_FORM_TERMINAL
@@ -157,19 +159,17 @@ export const editFormFor = (document) => TERMINAL_TICKET_STATES.has(ticketState(
 export const EDIT_FIELDS = EDIT_FORM.fields;
 export const EDIT_FIELDS_TERMINAL = EDIT_FORM_TERMINAL.fields;
 /**
- * No lists to OFFER — the two server-read bags are empty; the constant one is
- * not, because it is not read from anywhere.
- *
- * The prefill below names every value, and `clear`/`toObject` read no option
- * list, so the adapters that have no options to pass hand over this bag.
- * Exported so the screen's options-failure path can reuse it: a failed
- * user/conductor read must not silently take the State row's positions away
- * (D8).
+ * No lists to OFFER — bags start empty until the adapter / option loader fills
+ * them. Prefill names every value, and `clear`/`toObject` read no option list
+ * for the required fields, so adapters that have no options hand over this bag.
+ * Exported so the screen's options-failure path can reuse it (D11): a failed
+ * user/conductor/label read must not silently remove Cancel ticket (D8 keeps
+ * the action on the declaration, not in the bag).
  */
 export const EMPTY_EDIT_FORM_OPTIONS = {
     users: [],
     conductors: [],
-    stateTargets: STATE_TARGET_OPTIONS,
+    labels: [],
 };
 const relId = (document, name) => {
     const data = document.data?.relationships?.[name]?.data;
@@ -177,32 +177,71 @@ const relId = (document, name) => {
         return null;
     return Array.isArray(data) ? (data[0]?.id ?? null) : data.id;
 };
+const labelIds = (document) => {
+    const data = document.data?.relationships?.labels?.data;
+    if (!data)
+        return new Set();
+    if (Array.isArray(data)) {
+        return new Set(data.map((row) => row.id).filter(Boolean));
+    }
+    return data.id ? new Set([data.id]) : new Set();
+};
 const timeValue = (document, name) => {
     const value = document.data?.attributes?.[name];
     // An unset field prefills EMPTY, never `0m`: the popup must not turn "nobody
     // estimated this" into a typed zero the operator then saves by accident.
     return typeof value === 'number' ? formatDuration(value) : '';
 };
+/**
+ * Parent query text from the detail include when present (D9).
+ *
+ * A known parent must not blank when absent from the first candidate page — the
+ * id is always set from the relationship; the query is best-effort display
+ * material from the sideload. Missing include ⇒ empty query, id still set.
+ */
+const parentQueryFromDocument = (document, parentId) => {
+    if (!parentId)
+        return '';
+    const hit = document.included?.find((row) => row.id === parentId && row.type === 'gaia_ticket--gaia_ticket');
+    if (!hit)
+        return '';
+    const attrs = hit.attributes ?? {};
+    const identifier = typeof attrs.identifier === 'string' ? attrs.identifier : '';
+    const title = typeof attrs.title === 'string' ? attrs.title : '';
+    if (!identifier && !title)
+        return '';
+    return [identifier, title].filter(Boolean).join(' · ');
+};
 /** Prefill from the ticket's CURRENT values (AC-1) — never from `opts[0]`. The
  *  kernel applies a prefill with `Object.hasOwn`, so an unassigned ticket's
  *  explicit `null` STICKS instead of falling back to the first option. */
 export function initialEditForm(document) {
+    const parent = relId(document, 'parent_id');
     return EDIT_FORM.initial(EMPTY_EDIT_FORM_OPTIONS, {
         ticketId: document.data?.id ?? '',
         assignee: relId(document, 'assignee_user_id'),
         conductor: relId(document, 'conductor_id'),
         estimate: timeValue(document, 'time_estimate'),
         spent: timeValue(document, 'time_spent'),
-        // Always KEEP, on both declarations: the popup never opens armed to cancel.
-        stateTarget: KEEP_STATE,
+        parent,
+        parentQuery: parentQueryFromDocument(document, parent),
+        labels: labelIds(document),
     });
 }
+/**
+ * The Cancel ticket PATCH body (GAIA-360 D1): lifecycle only.
+ *
+ * Local field edits are discarded; after a successful write the detail reloads
+ * from the server (same as Save's reload path). No relationships.
+ */
+export const cancelEditPayload = () => ({
+    attributes: { state: CANCELLED_STATE },
+});
 // ---- thin adapters over the kernel (the popup itself runs on keyToIntent) ----
 export const activeEditField = (s) => EDIT_FORM.activeField(s);
 export const moveEditField = (s, delta) => EDIT_FORM.move(s, delta);
 /** Cycle the active select by `dir`, `null` included (AC-4). */
 export const cycleEdit = (s, opts, dir) => EDIT_FORM.apply(s, opts, { kind: 'cycle', dir });
-/** Clear the active select outright (the Del/Backspace shortcut). Cycling to `null`
- *  already works; a long conductor list just makes it tedious. */
+/** Clear the active select/autocomplete outright (the Del/Backspace shortcut). */
 export const clearEditValue = (s) => EDIT_FORM.apply(s, EMPTY_EDIT_FORM_OPTIONS, { kind: 'clear' });
 export const serializeEdit = (s) => EDIT_FORM.toObject(s, EMPTY_EDIT_FORM_OPTIONS);

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

@@ -27,7 +27,7 @@ export declare class EditAssignmentFormScreen extends AsyncScreen<EditAssignment
     };
     readonly id: string;
     /**
-     * The declaration THIS ticket's popup runs on (GAIA-313 D3).
+     * The declaration THIS ticket's popup runs on (GAIA-313 D3 / GAIA-360 D8).
      *
      * Chosen once, in `didLoad`, and used for BOTH the rendered rows and the key
      * routing — the kernel indexes its field array by `state.active`, so two
@@ -41,6 +41,9 @@ export declare class EditAssignmentFormScreen extends AsyncScreen<EditAssignment
     private action;
     private message;
     private submitting;
+    private context;
+    private sources;
+    private optionLoader;
     get options(): EditFormOptions | undefined;
     protected load(context: ScreenContext): Promise<EditAssignmentData>;
     protected didLoad(data: EditAssignmentData): void;
@@ -68,22 +71,9 @@ export declare class EditAssignmentFormScreen extends AsyncScreen<EditAssignment
      * own input context is declared `role: 'input'`, which `scopeKey()` filters
      * out. So without this the second open reuses the first open's `form` and
      * `declaration` — and GAIA-313 put the first LIFECYCLE-MUTATING value into that
-     * reused state: an armed `cancelled` survived `Esc` and rode the next Save, and
-     * a popup reopened on a just-cancelled ticket still offered the transition the
-     * server would now reject.
-     *
-     * Overridden HERE and not on `AsyncScreen`, deliberately: the sibling modals
-     * (create-ticket, parent-filter, who-filter) share the caching shape but carry
-     * no value that changes the ticket's lifecycle, and dropping every screen's
-     * document on `leave` would re-read on every back-navigation in the cockpit.
-     * The cost here is one detail read and one options read per open — what a modal
-     * editing form should pay.
-     *
-     * Safe at every call site: `Router.navigate` calls `leave()` and then re-points
-     * `location` before anything draws, so the reset screen (whose `renderLoading`
-     * is `Loading assignment…`) is never rendered; and `submit()`'s trailing
-     * `.finally` only re-writes `submitting = false`, which `reset()` has already
-     * set, on a context whose `isActive()` is false by then.
+     * reused state. Overridden HERE and not on `AsyncScreen`, deliberately: the
+     * sibling modals share the caching shape but carry no lifecycle-mutating
+     * residual that must die with the popup.
      */
     leave(): void;
     reset(): void;

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

@@ -3,11 +3,13 @@ import { columnNode } from '../../../lib/vnode.js';
 import { defineContext } from '../../../Routing/context.js';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { presentation, } from '../../../Screen/screen.js';
+import { createOptionLoader, } from '../../../Widget/option-source.js';
 import { activeRunInfo } from '../../run/Data/active-run.js';
 import { EDIT_FORM_REGION, editFormTree, } from '../Component/edit-form/index.js';
 import { loadTicketDetail } from '../Data/detail.js';
-import { EDIT_FORM_TERMINAL, EMPTY_EDIT_FORM_OPTIONS, editFormFor, initialEditForm, serializeEdit, } from '../Form/edit.js';
+import { CANCEL_TICKET_ACTION_ID, cancelEditPayload, EDIT_FORM_TERMINAL, EMPTY_EDIT_FORM_OPTIONS, editFormFor, initialEditForm, serializeEdit, } from '../Form/edit.js';
 import { loadEditFormOptions } from '../Form/edit-data.js';
+import { editParentOptionSource } from '../Form/edit-parent-source.js';
 import { keyToIntent } from '../Form/keys.js';
 export const editAssignmentInputContext = defineContext('edit-assignment-input', 'input');
 const relationshipId = (document, name) => {
@@ -35,7 +37,7 @@ export class EditAssignmentFormScreen extends AsyncScreen {
     };
     id = EditAssignmentFormScreen.route.id;
     /**
-     * The declaration THIS ticket's popup runs on (GAIA-313 D3).
+     * The declaration THIS ticket's popup runs on (GAIA-313 D3 / GAIA-360 D8).
      *
      * Chosen once, in `didLoad`, and used for BOTH the rendered rows and the key
      * routing — the kernel indexes its field array by `state.active`, so two
@@ -49,10 +51,14 @@ export class EditAssignmentFormScreen extends AsyncScreen {
     action;
     message = '';
     submitting = false;
+    context;
+    sources = {};
+    optionLoader;
     get options() {
         return this.readyValue?.options;
     }
     async load(context) {
+        this.context = context;
         const ticketId = context.params?.ticketId;
         if (!context.services || !ticketId)
             throw new Error('Assignment form requires ticketId and services');
@@ -68,11 +74,38 @@ export class EditAssignmentFormScreen extends AsyncScreen {
                 ? {}
                 : { write: context.services.writeClient }),
         }, ...(projectId === undefined ? [] : [{ projectId }])).catch(() => EMPTY_EDIT_FORM_OPTIONS);
+        // 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
+        // does not permit property assignment after construction.
+        this.sources =
+            projectId === undefined
+                ? {}
+                : {
+                    parent: editParentOptionSource(context.services.client, projectId, ticketId),
+                };
         return { document, options };
     }
     didLoad(data) {
         this.declaration = editFormFor(data.document);
         this.form = initialEditForm(data.document);
+        this.optionLoader = createOptionLoader({
+            sources: this.sources,
+            ...(this.context?.options?.debounce
+                ? { debounce: this.context.options.debounce }
+                : {}),
+            current: () => this.readyValue?.options ?? null,
+            onLoaded: (next) => {
+                const ready = this.readyValue;
+                if (!ready)
+                    return;
+                this.replaceReady({ ...ready, options: next });
+                this.context?.requestDraw();
+            },
+        });
+        // Prime parent candidates with the empty query so ←/→ browses before typing.
+        if (this.sources.parent)
+            this.optionLoader.reload('parent', '');
     }
     renderLoading() {
         return ['Loading assignment…'];
@@ -107,14 +140,22 @@ export class EditAssignmentFormScreen extends AsyncScreen {
         this.action = undefined;
         return action;
     }
-    submit(context, data) {
+    submit(context, data, 
+    /** When true, Cancel ticket path (lifecycle-only). */
+    cancelTicket) {
         if (this.submitting || !this.form || !context.services)
             return;
         this.submitting = true;
         this.message = '';
         const ticketId = data.document.data?.id ?? context.params?.ticketId ?? '';
-        const payload = serializeEdit(this.form);
-        const assigneeId = payload.relationships.assignee_user_id.data?.id ?? '';
+        const payload = cancelTicket
+            ? cancelEditPayload()
+            : serializeEdit(this.form);
+        const assigneeId = cancelTicket
+            ? (relationshipId(data.document, 'assignee_user_id') ?? '')
+            : 'relationships' in payload
+                ? (payload.relationships.assignee_user_id.data?.id ?? '')
+                : '';
         void (context.services.writeClient ?? context.services.client)
             .update('gaia_ticket--gaia_ticket', ticketId, payload)
             .then(async () => {
@@ -147,20 +188,37 @@ export class EditAssignmentFormScreen extends AsyncScreen {
         const data = this.readyValue;
         if (!data || !this.form)
             return false;
+        const field = this.declaration.activeField(this.form);
         // GAIA-300 D3 — the field count is passed so the kernel can scope ↑/↓
         // suggestion-browsing to single-field forms; this form has several, so
         // its ↑/↓ behaviour is unchanged.
-        const intent = keyToIntent(input, this.declaration.activeField(this.form), {
+        const intent = keyToIntent(input, field, {
             fieldCount: this.declaration.fields.length,
+            ...(field.query !== undefined
+                ? {
+                    query: String(this.form[field.query] ??
+                        ''),
+                }
+                : {}),
         });
         if (!intent)
             return true;
         if (intent.kind === 'cancel')
             this.action = { type: 'back' };
-        else if (intent.kind === 'submit')
-            this.submit(context, data);
-        else
+        else if (intent.kind === 'submit') {
+            // D10: Ctrl+S ALWAYS Save, even when the cursor is on Cancel ticket.
+            // Only Enter/submit while standing on the cancelTicket action cancels.
+            const cancelTicket = input !== 'ctrl+s' && field.id === CANCEL_TICKET_ACTION_ID;
+            this.submit(context, data, cancelTicket);
+        }
+        else {
             this.form = this.declaration.apply(this.form, data.options, intent);
+            if (field.query !== undefined &&
+                (intent.kind === 'insert' || intent.kind === 'backspace')) {
+                const query = this.form[field.query];
+                this.optionLoader?.reload(field.id, typeof query === 'string' ? query : '');
+            }
+        }
         context.requestDraw();
         return true;
     }
@@ -173,22 +231,9 @@ export class EditAssignmentFormScreen extends AsyncScreen {
      * own input context is declared `role: 'input'`, which `scopeKey()` filters
      * out. So without this the second open reuses the first open's `form` and
      * `declaration` — and GAIA-313 put the first LIFECYCLE-MUTATING value into that
-     * reused state: an armed `cancelled` survived `Esc` and rode the next Save, and
-     * a popup reopened on a just-cancelled ticket still offered the transition the
-     * server would now reject.
-     *
-     * Overridden HERE and not on `AsyncScreen`, deliberately: the sibling modals
-     * (create-ticket, parent-filter, who-filter) share the caching shape but carry
-     * no value that changes the ticket's lifecycle, and dropping every screen's
-     * document on `leave` would re-read on every back-navigation in the cockpit.
-     * The cost here is one detail read and one options read per open — what a modal
-     * editing form should pay.
-     *
-     * Safe at every call site: `Router.navigate` calls `leave()` and then re-points
-     * `location` before anything draws, so the reset screen (whose `renderLoading`
-     * is `Loading assignment…`) is never rendered; and `submit()`'s trailing
-     * `.finally` only re-writes `submitting = false`, which `reset()` has already
-     * set, on a context whose `isActive()` is false by then.
+     * reused state. Overridden HERE and not on `AsyncScreen`, deliberately: the
+     * sibling modals share the caching shape but carry no lifecycle-mutating
+     * residual that must die with the popup.
      */
     leave() {
         this.reset();
@@ -200,6 +245,10 @@ export class EditAssignmentFormScreen extends AsyncScreen {
         this.action = undefined;
         this.message = '';
         this.submitting = false;
+        this.optionLoader?.cancel();
+        this.optionLoader = undefined;
+        this.sources = {};
+        this.context = undefined;
         super.reset();
     }
     present(context) {
@@ -210,7 +259,9 @@ export class EditAssignmentFormScreen extends AsyncScreen {
             meta: String(this.readyValue?.document.data?.attributes?.identifier ??
                 context.params?.ticketId ??
                 ''),
-            status: ' ↑↓ field · ←→ change · Ctrl+S save · Esc cancel ',
+            // GAIA-360 D12 — Esc closes the popup; Cancel ticket is the lifecycle
+            // action. Status must not say "Esc cancel".
+            status: ' ↑↓ field · ←→ change · Ctrl+S save · Esc close ',
             // The popup's box supplies its own border and padding, so the body it
             // holds must not also carry the body window's inset — see
             // `presentation()`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-gaia-ui",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "GAIA TUI: interactive terminal UI (dashboard, projects, tickets) as a dropsh `tui` renderer plugin.",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,6 @@
     "drupal-jsonapi-params": "^3.0.1"
   },
   "peerDependencies": {
-    "@gaia-ai/core": "^0.9.1"
+    "@gaia-ai/core": "^0.9.2"
   }
 }