@gaia-ai/addon-gaia-ui 0.7.0 → 0.8.0

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

@@ -19,20 +19,15 @@ import { primeSources, } from '../../../Widget/index.js';
 import { listConductors } from '../../conductor/Data/conductors.js';
 import { listTerms } from '../../term/Data/terms.js';
 import { listUsers } from '../../user/Data/users.js';
-import { loadParentCandidates } from '../Data/parents.js';
 import { WORKFLOW_OPTIONS, } from './create.js';
+import { parentOptionSource } from './parent-source.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.
 export { loadEditFormOptions, } from './edit-data.js';
-/**
- * How long the parent picker waits before re-querying (GAIA-257 D7).
- *
- * A property of THIS field's source, not of the kernel: the kernel now drives
- * whatever sources a form declares and has no interest in how long any of them
- * waits.
- */
-const PARENT_QUERY_DEBOUNCE_MS = 150;
+// The parent label policy moved to `parent-source.ts` with the source (GAIA-284
+// D5); re-exported so the existing import site keeps working unchanged.
+export { parentLabel } from './parent-source.js';
 /**
  * Stable-partition the machine's own row to the front: index 0 is what a ring
  * defaults to. This popup's only ordering rule, and it reads the same for users and
@@ -52,22 +47,6 @@ 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';
-/**
- * `GAIA-nnn · <title>` — the picker label, composed HERE (GAIA-257 D5).
- *
- * The kernel filters candidates by a case-insensitive substring of
- * `Option.label` and knows nothing of identifiers or titles. AC-5's "matching
- * on identifier AND on title" is therefore met by what the label is MADE OF,
- * not by a second rule in the kernel: a substring of this string is a match on
- * either half. Exported so the popup's own tests can state the rule once.
- */
-export const parentLabel = (row) => `${row.identifier} · ${row.title}`;
-const toParentOption = (row) => ({
-    id: row.id,
-    label: parentLabel(row),
-    identifier: row.identifier,
-    title: row.title,
-});
 /**
  * The option sources this popup's fields load through, keyed by FIELD id.
  *
@@ -127,17 +106,9 @@ export function createFormSources(client, hints = {}) {
     // "nothing can be offered" and "searched, nothing matched" are different
     // things and the field says different things about them (D8).
     if (projectId !== undefined) {
-        sources.parent = {
-            bag: 'parents',
-            debounceMs: PARENT_QUERY_DEBOUNCE_MS,
-            async load(query) {
-                const outcome = await loadParentCandidates(client, projectId, query);
-                return {
-                    options: outcome.rows.map(toParentOption),
-                    error: outcome.error,
-                };
-            },
-        };
+        // The shared parent source (GAIA-284 D5): the same read, label policy and
+        // error channel the parent-filter picker composes.
+        sources.parent = parentOptionSource(client, projectId);
     }
     return sources;
 }

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

@@ -57,9 +57,27 @@ export { WORKFLOW_OPTIONS } from '../Data/workflow.js';
 export type FieldDef<Id extends string = string> = Omit<FieldDecl, 'id'> & {
     id: Id;
 };
-export type CreateFieldId = 'description' | 'parent' | 'assignee' | 'conductor' | 'labels' | 'workflow' | 'submit';
+/**
+ * The two action rows' field ids (GAIA-309 D3/D7).
+ *
+ * Exported because the SCREEN branches on them: the kernel's one `submit`
+ * intent cannot say which of two actions was fired, so the screen resolves the
+ * active field and compares. `'submit'` keeps its name for the agent row so
+ * every pre-GAIA-309 assertion about it stays literally true.
+ */
+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';
 /** What the form HOLDS. `active`/`cursor` are the kernel's and must not appear. */
-interface CreateValues {
+export interface CreateValues {
+    /**
+     * The ticket's title. `gaia_ticket.title` is `setRequired(TRUE)` server-side,
+     * so a direct create without one is rejected — this was never optional
+     * (GAIA-309 D1). Deriving it from the description's first line was considered
+     * and rejected: the operator could not correct a bad title without rewriting
+     * their own opening sentence.
+     */
+    title: string;
     description: string;
     /** The PICKED parent's uuid, or null. `parentQuery` holds what was typed —
      *  an autocomplete field owns two keys (GAIA-257 D5). */
@@ -78,6 +96,8 @@ export interface ParentRef {
 }
 /** The submitted payload (resolved options), handed to the create agent. */
 export interface CreateFormPayload {
+    /** What the operator NAMED the ticket. Required server-side (GAIA-309 D1). */
+    title: string;
     description: string;
     workflow: Option | null;
     assignee: Option | null;
@@ -93,8 +113,9 @@ 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 and no field is `clearable`: the
- * create form's selects cycle over real options only, exactly as before GAIA-233.
+ * The declaration. 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 declare const CREATE_FORM: {
     fields: FieldDecl[];
@@ -107,7 +128,26 @@ export declare const CREATE_FORM: {
 /** Field order in the popup (top to bottom). */
 export declare const FIELDS: FieldDef<CreateFieldId>[];
 export type CreateFormState = FormState<CreateValues>;
-export declare const initialForm: (opts: CreateFormOptions) => CreateFormState;
+/**
+ * The values the popup carries from one open to the next (GAIA-314 D2).
+ *
+ * The popup is ONE screen instance, entered again and again (spec F1/F2), so
+ * something has to say which of its values are the ticket being written and
+ * which are the operator's standing routing choice. That answer belongs beside
+ * the field declaration, not in the screen: the `Pick` ties the list to the
+ * value shape, so renaming a field breaks the build instead of silently
+ * dropping it out of the memory.
+ *
+ * `workflow` is NOT here, deliberately. A ticket type is a per-ticket decision,
+ * and a silently retained `gaia_bug` on the next feature ticket is a wrong
+ * value nobody looks at (D5). The parent contributes BOTH of its keys, because
+ * an autocomplete owns two and `apply` never produces one without the other
+ * (D4).
+ */
+export type CreateRemembered = Pick<CreateValues, 'parent' | 'parentQuery' | 'assignee' | 'conductor' | 'labels'>;
+/** Snapshot the routing values of a form that is about to be replaced. */
+export declare const rememberedValues: (s: CreateFormState) => CreateRemembered;
+export declare const initialForm: (opts: CreateFormOptions, prefill?: Partial<CreateValues>) => CreateFormState;
 export declare const activeField: (s: CreateFormState) => FieldDef<CreateFieldId>;
 export declare const moveField: (s: CreateFormState, delta: number) => CreateFormState;
 /** Append typed text to the description (only meaningful on the text field). */

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

@@ -1,7 +1,8 @@
 // The "New ticket" popup form (GAIA-190) as a DECLARATION over the form kernel
-// (GAIA-236): five fields plus an action, and one `toObject` that yields the payload
-// the create agent gets. The mechanics — navigation, text editing, cycling, the
-// multiselect cursor — all live in `Form/`; nothing of them is repeated here.
+// (GAIA-236): seven fields plus two actions, and one `toObject` that yields the
+// payload BOTH submit paths consume (GAIA-309). The mechanics — navigation, text
+// editing, cycling, the multiselect cursor — all live in `Form/`; nothing of them
+// is repeated here.
 import { cycleValue, declareForm, } from '../../../Form/index.js';
 import { PARENT_PAGE_SIZE } from '../Data/parents.js';
 // `cycleValue` is re-exported because GAIA-233's contract cases pin it against
@@ -20,6 +21,16 @@ export { cycleValue };
 // previously kept its own second copy (GAIA-236 phase 4). Re-exported so this form's
 // existing import sites are unchanged.
 export { WORKFLOW_OPTIONS } from '../Data/workflow.js';
+/**
+ * The two action rows' field ids (GAIA-309 D3/D7).
+ *
+ * Exported because the SCREEN branches on them: the kernel's one `submit`
+ * intent cannot say which of two actions was fired, so the screen resolves the
+ * active field and compares. `'submit'` keeps its name for the agent row so
+ * every pre-GAIA-309 assertion about it stays literally true.
+ */
+export const AGENT_ACTION_ID = 'submit';
+export const DIRECT_ACTION_ID = 'direct';
 /** The option with `id`, or null — used by both forms' `toObject`. */
 export const optionFor = (list, id) => list.find((o) => o.id === id) ?? null;
 /**
@@ -37,11 +48,16 @@ const parentFor = (list, id) => {
         : null;
 };
 /**
- * The declaration. No field carries a function and no field is `clearable`: the
- * create form's selects cycle over real options only, exactly as before GAIA-233.
+ * The declaration. 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: (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).
@@ -60,12 +76,22 @@ export const CREATE_FORM = declareForm({
             pageSize: PARENT_PAGE_SIZE,
         }),
         f.select('assignee', 'Assignee', { from: 'users' }),
-        f.select('conductor', 'Conductor', { from: 'conductors' }),
+        // 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' }),
-        f.action('Create ticket'),
+        // 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),
     ],
     toObject: (v, o) => ({
+        title: v.title,
         description: v.description,
         workflow: optionFor(o.workflows, v.workflow),
         assignee: optionFor(o.users, v.assignee),
@@ -76,13 +102,24 @@ export const CREATE_FORM = declareForm({
 });
 /** Field order in the popup (top to bottom). */
 export const FIELDS = CREATE_FORM.fields;
+/** Snapshot the routing values of a form that is about to be replaced. */
+export const rememberedValues = (s) => ({
+    parent: s.parent,
+    parentQuery: s.parentQuery,
+    assignee: s.assignee,
+    conductor: s.conductor,
+    // Copied, not referenced: the snapshot outlives the state object it came
+    // from, and the reducer builds a NEW Set on every toggle — an alias would
+    // make the memory depend on which of the two was mutated last.
+    labels: new Set(s.labels),
+});
 // ---- thin adapters (GAIA-236 AC-3) -----------------------------------------
 //
 // The popup itself is driven by `keyToIntent` + `CREATE_FORM.apply` in the kernel.
 // These per-transition functions stay because they ARE this module's tested
 // contract: keeping them is what lets `tests/Service/create-form.test.ts` prove the
 // re-cut changed no behaviour instead of being rewritten to match it.
-export const initialForm = (opts) => CREATE_FORM.initial(opts);
+export const initialForm = (opts, prefill = {}) => CREATE_FORM.initial(opts, prefill);
 export const activeField = (s) => CREATE_FORM.activeField(s);
 export const moveField = (s, delta) => CREATE_FORM.move(s, delta);
 /** Append typed text to the description (only meaningful on the text field). */

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

@@ -8,6 +8,7 @@
 // once, here, beside the create adapter it differs from.
 import { listConductorsPreferringWrite, } from '../../conductor/Data/conductors.js';
 import { listUsersPreferringWrite } from '../../user/Data/users.js';
+import { STATE_TARGET_OPTIONS } from './edit.js';
 /**
  * uid 0 is Drupal's Anonymous and never a valid human assignee. A row whose uid never
  * loaded is `undefined` — NOT Anonymous — and stays.
@@ -34,5 +35,8 @@ export async function loadEditFormOptions(clients, hints = {}) {
     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,
     };
 }

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

@@ -1,11 +1,44 @@
 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' | 'submit';
-/** The two option lists the popup offers (loaded by `loadEditFormOptions`). */
+export type EditFieldId = 'assignee' | 'conductor' | 'estimate' | 'spent' | 'stateTarget' | 'submit';
+/**
+ * GAIA-313 — 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
+ * `cancelled`, so no served fact carries the cancel edge. The precedent is
+ * `STATE_FILTER_VALUES` in `Data/query.ts`, hardcoded for the same reason.
+ *
+ * One constant serves every ticket workflow because in ALL of them
+ * (`gaia_feature`, `gaia_bug`, `gaia_chore`, `gaia_deployment`,
+ * `gaia_verification`) `cancel.from` is exactly the set of non-terminal states —
+ * so "non-terminal" and "the workflow permits cancelling" are the same
+ * 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 states no transition leaves, in every ticket workflow.
+ *
+ * The server's own definition (`TypeWorkflows::isTerminal` — "a state no
+ * transition leaves") evaluates to exactly this pair for all five workflows.
+ */
+export declare const TERMINAL_TICKET_STATES: ReadonlySet<string>;
+/** The option lists the popup offers (loaded by `loadEditFormOptions`). */
 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[];
 }
 /** 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. */
@@ -13,9 +46,17 @@ interface EditValues {
     ticketId: string;
     assignee: string | null;
     conductor: string | null;
+    /** 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 relationship payload of the PATCH (GAIA-233 Decision 2's `ResourceWriteBody`). */
+/** The payload of the PATCH (GAIA-233 Decision 2's `ResourceWriteBody`, which
+ *  already declares `attributes?`, so the writer needs no change). */
 export interface EditFormPayload {
+    attributes: Record<string, number | string | null>;
     relationships: {
         assignee_user_id: {
             data: {
@@ -31,14 +72,7 @@ export interface EditFormPayload {
         };
     };
 }
-/**
- * The declaration. BOTH selects are `clearable`: AC-4 requires REMOVING an
- * assignment, not only changing it, so `null` is a real position in each cycle.
- *
- * `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 ordinary popup: a non-terminal ticket can be cancelled from it. */
 export declare const EDIT_FORM: {
     fields: import("../../../Form/field.js").FieldDecl[];
     activeField: (s: FormState<EditValues>) => import("../../../Form/field.js").FieldDecl;
@@ -47,9 +81,42 @@ 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;
 };
-/** Field order in the popup. */
+/** A terminal ticket's popup: assignment and time only. */
+export declare const EDIT_FORM_TERMINAL: {
+    fields: import("../../../Form/field.js").FieldDecl[];
+    activeField: (s: FormState<EditValues>) => import("../../../Form/field.js").FieldDecl;
+    move: (s: FormState<EditValues>, d: number) => FormState<EditValues>;
+    initial(options: EditFormOptions, prefill?: Partial<EditValues>): FormState<EditValues>;
+    apply(s: FormState<EditValues>, options: EditFormOptions, intent: import("../../../Form/form.js").Intent): FormState<EditValues>;
+    toObject: (s: FormState<EditValues>, options: EditFormOptions) => EditFormPayload;
+};
+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).
+ *
+ * An unknown state fails OPEN (D7): `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.
+ */
+export declare const editFormFor: (document: TicketDetailDocument) => EditFormDeclaration;
+/** Field order in the popup, per declaration. */
 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).
+ */
+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. */

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

@@ -1,53 +1,200 @@
-// The "Edit assignment" popup (GAIA-233) as a DECLARATION over the form kernel
-// (GAIA-236): two `clearable` selects plus an action, and one `toObject` that yields
-// the JSON:API relationship payload of the PATCH. Its own field list, its own prefill
-// source (the ticket's relationships, 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 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.
+//
+// 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.
 import { declareForm } from '../../../Form/index.js';
+import { formatDuration, parseDuration } from '../../../lib/format.js';
+/**
+ * GAIA-313 — 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
+ * `cancelled`, so no served fact carries the cancel edge. The precedent is
+ * `STATE_FILTER_VALUES` in `Data/query.ts`, hardcoded for the same reason.
+ *
+ * One constant serves every ticket workflow because in ALL of them
+ * (`gaia_feature`, `gaia_bug`, `gaia_chore`, `gaia_deployment`,
+ * `gaia_verification`) `cancel.from` is exactly the set of non-terminal states —
+ * so "non-terminal" and "the workflow permits cancelling" are the same
+ * 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 states no transition leaves, in every ticket workflow.
+ *
+ * The server's own definition (`TypeWorkflows::isTerminal` — "a state no
+ * transition leaves") evaluates to exactly this pair for all five workflows.
+ */
+export const TERMINAL_TICKET_STATES = new Set([
+    'done',
+    CANCELLED_STATE,
+]);
 /** A JSON:API to-one linkage, or an explicit `null` for "remove it". */
 const linkage = (type, id) => ({
     data: id === null ? null : { type, id },
 });
 /**
- * The declaration. BOTH selects are `clearable`: AC-4 requires REMOVING an
- * assignment, not only changing it, so `null` is a real position in each cycle.
+ * The two time attributes of the PATCH, in seconds.
+ *
+ * Three outcomes per field, and the third is the reason this is not a one-liner:
+ *   parsed value → the number;
+ *   empty input  → `null`, an explicit REMOVE (the selects are clearable for the
+ *                  same reason — AC-4 requires removing a value, not only
+ *                  changing it);
+ *   unparseable  → the key is OMITTED. Writing 0 for "soon" would silently
+ *                  destroy a real estimate, and the popup has no validation
+ *                  channel of its own; leaving the key out means the server
+ *                  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
+ * relationships do.
+ */
+const timeAttributes = (v) => {
+    const out = {};
+    for (const [key, field] of [
+        ['time_estimate', 'estimate'],
+        ['time_spent', 'spent'],
+    ]) {
+        const raw = v[field];
+        const seconds = parseDuration(raw);
+        if (seconds === null)
+            continue;
+        out[key] = raw.trim() === '' ? null : seconds;
+    }
+    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).
+ *
+ * BOTH assignment selects are `clearable`: AC-4 requires REMOVING an assignment,
+ * not only changing it, so `null` is a real position in each cycle.
  *
  * `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.
+ * no-op PATCH is what the popup visibly promises. The two time attributes are the
+ * documented exception — see `timeAttributes`.
+ *
+ * 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.
  */
-export const EDIT_FORM = declareForm({
+const declareEditForm = (cancellable) => declareForm({
     fields: (f) => [
         f.select('assignee', 'Assignee', { from: 'users', clearable: true }),
-        f.select('conductor', 'Conductor', { from: 'conductors', clearable: true }),
-        f.action('Save assignment'),
+        f.select('conductor', 'Conductor', {
+            from: 'conductors',
+            clearable: true,
+        }),
+        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.
+        ...(cancellable
+            ? [f.select('stateTarget', 'State', { from: 'stateTargets' })]
+            : []),
+        f.action('Save'),
     ],
     toObject: (v) => ({
+        attributes: { ...timeAttributes(v), ...stateAttribute(v) },
         relationships: {
             assignee_user_id: linkage('user--user', v.assignee),
             conductor_id: linkage('gaia_conductor--gaia_conductor', v.conductor),
         },
     }),
 });
-/** Field order in the popup. */
+/** 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. */
+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) => {
+    const value = document.data?.attributes?.state;
+    return typeof value === 'string' ? value : '';
+};
+/**
+ * Which declaration a ticket gets (AC-4).
+ *
+ * An unknown state fails OPEN (D7): `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.
+ */
+export const editFormFor = (document) => TERMINAL_TICKET_STATES.has(ticketState(document))
+    ? EDIT_FORM_TERMINAL
+    : EDIT_FORM;
+/** Field order in the popup, per declaration. */
 export const EDIT_FIELDS = EDIT_FORM.fields;
-// The prefill below names every value, and `clear`/`toObject` read no option list,
-// so the adapters that have no options to pass hand over an empty bag.
-const NO_OPTIONS = { users: [], conductors: [] };
+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).
+ */
+export const EMPTY_EDIT_FORM_OPTIONS = {
+    users: [],
+    conductors: [],
+    stateTargets: STATE_TARGET_OPTIONS,
+};
 const relId = (document, name) => {
     const data = document.data?.relationships?.[name]?.data;
     if (!data)
         return null;
     return Array.isArray(data) ? (data[0]?.id ?? null) : data.id;
 };
+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) : '';
+};
 /** 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) {
-    return EDIT_FORM.initial(NO_OPTIONS, {
+    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,
     });
 }
 // ---- thin adapters over the kernel (the popup itself runs on keyToIntent) ----
@@ -57,5 +204,5 @@ export const moveEditField = (s, delta) => EDIT_FORM.move(s, delta);
 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. */
-export const clearEditValue = (s) => EDIT_FORM.apply(s, NO_OPTIONS, { kind: 'clear' });
-export const serializeEdit = (s) => EDIT_FORM.toObject(s, NO_OPTIONS);
+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/Form/keys.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ticket-form adapter for translating terminal input into form intents.
+ *
+ * The generic form kernel deliberately has no knowledge of terminal screens;
+ * consumers outside the kernel reach it through their entity form adapter.
+ */
+export { keyToIntent } from '../../../Form/index.js';

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

@@ -0,0 +1,7 @@
+/**
+ * Ticket-form adapter for translating terminal input into form intents.
+ *
+ * The generic form kernel deliberately has no knowledge of terminal screens;
+ * consumers outside the kernel reach it through their entity form adapter.
+ */
+export { keyToIntent } from '../../../Form/index.js';