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

package/dist/src/Entity/conductor/Data/conductors.d.ts

@@ -26,6 +26,16 @@ export interface Conductor {
  * contract, because it already answers a failure by falling back.
  */
 export declare const listConductors: (client: DropshClient) => Promise<ListOutcome<Conductor>>;
+/**
+ * The conductor collection scoped to one project (GAIA-664 review F4).
+ *
+ * The create popup's narrow option loader, not `ConductorQuery`'s row-page
+ * read above (GAIA-664 plan correction): this keeps `listOutcome`'s own
+ * outcome/error contract rather than inventing a second one for the same
+ * entity. An unscoped caller keeps calling {@link listConductors}; this is
+ * additive.
+ */
+export declare const listConductorsForProject: (client: DropshClient, projectId: string) => Promise<ListOutcome<Conductor>>;
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

package/dist/src/Entity/conductor/Data/conductors.js

@@ -8,7 +8,7 @@ import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
 import { humanizeAge } from '../../../lib/format.js';
 import { loadPage, } from '../../collection.js';
 import { LIST_PAGE_SIZE } from '../../cycle.js';
-import { listOutcome, listPreferringWrite, } from '../../transport.js';
+import { listOutcome, listPreferringWrite, messageOf, } from '../../transport.js';
 import { deriveConductorStatus } from './liveness.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const toConductor = (r) => ({
@@ -32,6 +32,28 @@ const toConductor = (r) => ({
  * contract, because it already answers a failure by falling back.
  */
 export const listConductors = (client) => listOutcome(client, 'gaia_conductor', toConductor);
+/**
+ * The conductor collection scoped to one project (GAIA-664 review F4).
+ *
+ * The create popup's narrow option loader, not `ConductorQuery`'s row-page
+ * read above (GAIA-664 plan correction): this keeps `listOutcome`'s own
+ * outcome/error contract rather than inventing a second one for the same
+ * entity. An unscoped caller keeps calling {@link listConductors}; this is
+ * additive.
+ */
+export const listConductorsForProject = async (client, projectId) => {
+    try {
+        return {
+            rows: (await client
+                .collection('gaia_conductor')
+                .where('project_id.id', '=', projectId)
+                .list()).map(toConductor),
+        };
+    }
+    catch (caught) {
+        return { rows: [], error: messageOf(caught) };
+    }
+};
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

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

@@ -1,5 +1,5 @@
 import type { VNode } from '@opentui/core';
-import { type CreateFormOptions, type CreateFormState } from '../../Form/create.js';
+import type { CreateFieldId, CreateFormOptions, CreateFormState, FieldDef } from '../../Form/create.js';
 /** The chrome the kernel wraps this tree in. */
 export interface CreateFormChrome {
     /**
@@ -25,4 +25,4 @@ export interface CreateFormChrome {
 /** The id the popup's body column is rooted at. */
 export declare const CREATE_FORM_REGION = "create-form";
 /** Render the "New ticket" popup as the tree the kernel frames. */
-export declare function createFormTree(s: CreateFormState, opts: CreateFormOptions, chrome?: CreateFormChrome): VNode;
+export declare function createFormTree(fields: FieldDef<CreateFieldId>[], s: CreateFormState, opts: CreateFormOptions, chrome?: CreateFormChrome): VNode;

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

@@ -17,7 +17,6 @@
 // to rebase again onto its own.
 import { columnNode, textNode } from '../../../../lib/vnode.js';
 import { note, renderDeclaredFieldsTree, widgetFor, } from '../../../../Widget/index.js';
-import { FIELDS, } from '../../Form/create.js';
 const DEFAULT_WIDTH = 58;
 /** The id the popup's body column is rooted at. */
 export const CREATE_FORM_REGION = 'create-form';
@@ -34,7 +33,7 @@ const WHOLE_FORM = 'The form options';
  */
 const bagName = (field) => field.kind === 'multiselect' ? field.label : `${field.label} options`;
 /** Render the "New ticket" popup as the tree the kernel frames. */
-export function createFormTree(s, opts, chrome = {}) {
+export function createFormTree(fields, s, opts, chrome = {}) {
     const width = chrome.width ?? DEFAULT_WIDTH;
     // Keyed by BAG, which is what `from` names; the typed shape is the adapter's
     // business, and reading it by key is what keeps this loop declaration-driven.
@@ -49,7 +48,8 @@ export function createFormTree(s, opts, chrome = {}) {
     // one, plus a whole-form failure, collapses into ONE row at the top. It is a
     // note, not a refusal: a failed OPTION read must not cost the writer the
     // description they opened the popup to type (D4).
-    const formLevel = FIELDS.filter((f) => !widgetFor(f).ownsError)
+    const formLevel = fields
+        .filter((f) => !widgetFor(f).ownsError)
         .map(reason)
         .filter((sentence) => sentence !== undefined);
     if (errors.form !== undefined) {
@@ -63,7 +63,7 @@ export function createFormTree(s, opts, chrome = {}) {
     // `note` supplies the `⚠` sigil itself, so the message is passed plain —
     // and it WRAPS, which is what keeps a long server message off the frame's
     // ellipsis (the same reason the option-load note above it wraps).
-    ...(chrome.message ? noteNodes(chrome.message, 'create-form-message') : []), renderDeclaredFieldsTree(FIELDS, s, opts, {
+    ...(chrome.message ? noteNodes(chrome.message, 'create-form-message') : []), renderDeclaredFieldsTree(fields, s, opts, {
         width,
         errorFor: reason,
         // A form-level failure means no read succeeded, so an empty bag may not

package/dist/src/Entity/ticket/Component/ticket-content/model.js

@@ -69,10 +69,6 @@ const colonValue = (text) => {
     const index = text.indexOf(':');
     return index < 0 ? text : text.slice(index + 1);
 };
-const entityLabel = (document, id, type) => {
-    const row = (document.included ?? []).find((resource) => resource.id === id && resource.type === type);
-    return (asString(row?.attributes?.label) ?? asString(row?.attributes?.name) ?? id);
-};
 const PRIORITY_LABEL = {
     '1': 'high',
     '2': 'medium',
@@ -86,12 +82,6 @@ const lifecycleProperties = (document) => {
     const priorityKey = String(attributes.priority ?? '').toLowerCase();
     const extras = [
         property('priority', PRIORITY_LABEL[priorityKey] ?? ''),
-        property('team', (() => {
-            const teamId = relationshipIds(document, 'team')[0];
-            return teamId === undefined
-                ? ''
-                : entityLabel(document, teamId, 'gaia_team--gaia_team');
-        })()),
         property('closed', attributes.closed === true ? 'yes' : 'no'),
     ];
     const frozenAtRaw = attributes.frozen_at;

package/dist/src/Entity/ticket/Component/ticket-detail/index.js

@@ -44,8 +44,8 @@ function headerLineNodes(id, content, fg) {
 }
 export function ticketHeaderTree(document, identifier, title, lastRow, labels) {
     // One compact meta line — state · assignee · labels — under the title. The
-    // full set (created by, team, branch, …) lives in the Overview sidebar, so
-    // the header stays two lines rather than five. Empty fields drop out.
+    // full set (created by, branch, …) lives in the Overview sidebar, so the
+    // header stays two lines rather than five. Empty fields drop out.
     const meta = [
         headerState(document),
         headerAssignee(document, labels),

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

@@ -53,7 +53,6 @@ export function loadTicketDetail(client, ticketId, includes = [
     'parent_id',
     'labels',
     'blocked_by',
-    'team',
     'owner_user_id',
     'reviewers',
     'pending_reviews',

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

@@ -29,7 +29,6 @@ const allIncludes = [
     'sub_tickets',
     'referenced_tickets',
     'runs',
-    'team',
     'owner_user_id',
     'reviewers',
     'pending_reviews',

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';
@@ -29,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,12 @@
 // 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
@@ -48,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.
  *
@@ -91,24 +129,11 @@ export function createFormSources(client, hints = {}) {
                 return loadReviewerOptions(client, workspaceId);
             },
         },
-        conductor: {
-            bag: 'conductors',
-            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 };
-            },
-        },
+        conductor: conductorOptionSource(client, {
+            projectId,
+            ownerUserId,
+            ownConductorMachineId,
+        }),
         labels: {
             bag: 'labels',
             async load() {
@@ -125,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;
 }
 /**

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

@@ -17,6 +17,9 @@ export interface CreateOptionErrors {
     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
@@ -51,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;
 }
@@ -69,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' | 'reviewers' | '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
@@ -117,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.
  */
@@ -129,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,62 +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' }),
-        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),
+        ...sharedFields(f),
     ],
-    toObject: (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),
-    }),
+    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,

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

@@ -27,6 +27,17 @@ export declare class CreateTicketFormScreen extends AsyncModalScreen<CreateFormO
     private context;
     private sources;
     private optionLoader;
+    /**
+     * Which declared form is standing (GAIA-664 AC-8): the ordinary one when a
+     * project is already in scope (unchanged), or the one with the extra
+     * Project field when it is not. Set once per `load()` — a scope change goes
+     * through `reset()`, which drops the whole screen, not just this flag.
+     */
+    private hasProjectContext;
+    /** The hints `load()` resolved, MINUS `projectId` — kept so a project picked
+     *  in the new field can rebuild the Conductor source with the rest intact
+     *  (GAIA-664 AC-8). */
+    private hints;
     /** The last refusal, drawn inside the popup (GAIA-309 D6). */
     private message;
     /** In-flight guard against a second POST from a second keypress. */
@@ -39,6 +50,10 @@ export declare class CreateTicketFormScreen extends AsyncModalScreen<CreateFormO
      */
     private readonly ownerIdentity;
     get options(): CreateFormOptions | undefined;
+    /** The declared form standing right now (GAIA-664 AC-8). */
+    private declaration;
+    /** `declaration()`'s own field list — what the component walks to render. */
+    private fieldList;
     protected load(context: ScreenContext): Promise<CreateFormOptions>;
     /**
      * Reopening the popup starts a NEW ticket (GAIA-314 D1/D3).
@@ -57,6 +72,7 @@ export declare class CreateTicketFormScreen extends AsyncModalScreen<CreateFormO
      */
     enter(context: ScreenContext): void;
     protected didLoad(options: CreateFormOptions): void;
+    private startOptionLoader;
     protected renderLoading(): string[];
     /**
      * GAIA-340 D1/D3 — the popup's body as the tree the widget layer builds.
@@ -73,6 +89,14 @@ export declare class CreateTicketFormScreen extends AsyncModalScreen<CreateFormO
     protected renderReady(options: CreateFormOptions): VNode;
     takeAction(): ScreenAction | undefined;
     handleInput(input: string, context: ScreenContext): boolean;
+    /**
+     * Re-scope the project-dependent bags to the project just picked in the
+     * Project field (GAIA-664 AC-8): Conductor through the same source
+     * `createFormSources` declares, Parent by swapping in that project's parent
+     * source (the option loader reads `this.sources` at query time, so later
+     * typing searches the new project). No project: no conductor, no parent.
+     */
+    private rescopeToProject;
     reset(): void;
     protected modalChrome(context: ScreenContext): ModalChrome;
     protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];

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

@@ -11,9 +11,10 @@ import { OwnerIdentity } from '../../conductor/Data/own-rows.js';
 import { resolveWhoCandidate } from '../../user/Data/users.js';
 import { CREATE_FORM_REGION, createFormTree, } from '../Component/create-form/index.js';
 import { buildTicketCreateBody, createTicket } from '../Data/write.js';
-import { AGENT_ACTION_ID, CREATE_FORM, DIRECT_ACTION_ID, initialForm, rememberedValues, } from '../Form/create.js';
-import { composeCreateFormOptions, createFormSources, } from '../Form/create-data.js';
+import { AGENT_ACTION_ID, CREATE_FORM, CREATE_FORM_WITH_PROJECT, DIRECT_ACTION_ID, FIELDS, FIELDS_WITH_PROJECT, optionFor, rememberedValues, } from '../Form/create.js';
+import { composeCreateFormOptions, conductorOptionSource, createFormSources, } from '../Form/create-data.js';
 import { keyToIntent } from '../Form/keys.js';
+import { parentOptionSource } from '../Form/parent-source.js';
 // The key hints, on TWO rows (GAIA-309 D7 / AC-1).
 //
 // Not a style choice. The popup is a fixed overlay — the kernel draws it at
@@ -54,6 +55,17 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
     context;
     sources = {};
     optionLoader;
+    /**
+     * Which declared form is standing (GAIA-664 AC-8): the ordinary one when a
+     * project is already in scope (unchanged), or the one with the extra
+     * Project field when it is not. Set once per `load()` — a scope change goes
+     * through `reset()`, which drops the whole screen, not just this flag.
+     */
+    hasProjectContext = false;
+    /** The hints `load()` resolved, MINUS `projectId` — kept so a project picked
+     *  in the new field can rebuild the Conductor source with the rest intact
+     *  (GAIA-664 AC-8). */
+    hints = {};
     /** The last refusal, drawn inside the popup (GAIA-309 D6). */
     message = '';
     /** In-flight guard against a second POST from a second keypress. */
@@ -68,6 +80,14 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
     get options() {
         return this.readyValue;
     }
+    /** The declared form standing right now (GAIA-664 AC-8). */
+    declaration() {
+        return this.hasProjectContext ? CREATE_FORM : CREATE_FORM_WITH_PROJECT;
+    }
+    /** `declaration()`'s own field list — what the component walks to render. */
+    fieldList() {
+        return this.hasProjectContext ? FIELDS : FIELDS_WITH_PROJECT;
+    }
     async load(context) {
         this.context = context;
         if (!context.services)
@@ -77,7 +97,8 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         // once per screen lifetime through `OwnerIdentity` rather than threaded
         // straight through. Fails open: `unavailable` omits the hint entirely.
         const ownerOutcome = await this.ownerIdentity.resolve(context.services.client, context.services.currentUser);
-        const sources = createFormSources(context.services.client, {
+        this.hasProjectContext = context.project !== undefined;
+        this.hints = {
             ...(context.services.currentUser === undefined
                 ? {}
                 : { currentUser: context.services.currentUser }),
@@ -87,12 +108,15 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
             ...(context.services.ownConductorMachineId === undefined
                 ? {}
                 : { ownConductorMachineId: context.services.ownConductorMachineId }),
-            ...(context.project === undefined
-                ? {}
-                : { projectId: context.project.id }),
             ...(context.services.workspaceId === undefined
                 ? {}
                 : { workspaceId: context.services.workspaceId }),
+        };
+        const sources = createFormSources(context.services.client, {
+            ...this.hints,
+            ...(context.project === undefined
+                ? {}
+                : { projectId: context.project.id }),
         });
         this.sources = sources;
         return composeCreateFormOptions(sources).catch((caught) => ({
@@ -130,7 +154,7 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         // it through the very same rule.
         const options = this.readyValue;
         if (options) {
-            this.form = initialForm(options, this.remembered ?? {});
+            this.form = this.declaration().initial(options, this.remembered ?? {});
             // `super.enter`'s `ready` branch already painted — from the form we just
             // replaced. The kernel draws SYNCHRONOUSLY inside `requestDraw`, so that
             // paint is the only one this navigation issues, and without a second one
@@ -142,7 +166,11 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         }
     }
     didLoad(options) {
-        this.form = initialForm(options, this.remembered ?? {});
+        this.form = this.declaration().initial(options, this.remembered ?? {});
+        this.startOptionLoader();
+    }
+    startOptionLoader() {
+        this.optionLoader?.cancel();
         this.optionLoader = createOptionLoader({
             sources: this.sources,
             // Absent unless the caller injected one: `createOptionLoader` owns the
@@ -179,7 +207,9 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         // the standing tree rather than build a second one beside it.
         if (!this.form)
             return columnNode(CREATE_FORM_REGION);
-        return createFormTree(this.form, options, { message: this.message });
+        return createFormTree(this.fieldList(), this.form, options, {
+            message: this.message,
+        });
     }
     takeAction() {
         const action = this.action;
@@ -192,14 +222,15 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         const options = this.readyValue;
         if (!options || !this.form)
             return false;
-        const field = CREATE_FORM.activeField(this.form);
+        const declaration = this.declaration();
+        const field = declaration.activeField(this.form);
         // GAIA-309 D7 — Ctrl+D is handled HERE rather than in `Form/keys.ts`. The
         // kernel's one `submit` intent cannot say WHICH of two actions was meant,
         // and a generic key module has no business knowing that a form has an
         // "agent" action and a "direct" one. So the second binding belongs to the
         // form that has two, and the kernel's Intent union is untouched.
         if (input === 'ctrl+d') {
-            const payload = CREATE_FORM.toObject(this.form, options);
+            const payload = declaration.toObject(this.form, options);
             void this.submitDirect(payload, context);
             context.requestDraw();
             return true;
@@ -208,7 +239,7 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         // suggestion-browsing to single-field forms; this form has several, so
         // ↑/↓ keep moving between fields here (AC-5).
         const intent = keyToIntent(input, field, {
-            fieldCount: CREATE_FORM.fields.length,
+            fieldCount: declaration.fields.length,
         });
         if (!intent)
             return true;
@@ -216,7 +247,7 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
             this.action = { type: 'back' };
         }
         else if (intent.kind === 'submit') {
-            const payload = CREATE_FORM.toObject(this.form, options);
+            const payload = declaration.toObject(this.form, options);
             // Ctrl+S PRESSES THE ROW YOU ARE STANDING ON; from any other field it
             // means the agent, exactly as it did before this ticket (AC-6). Enter on
             // an action row arrives here as the same `submit` intent, so both keys
@@ -234,7 +265,29 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
             // operator types the missing title and is still told the title is
             // missing. Any field change retires it.
             this.message = '';
-            this.form = CREATE_FORM.apply(this.form, options, intent);
+            // GAIA-664 AC-8: a NEW pick (or a clear) on the Project field re-scopes
+            // the Conductor bag and drops any conductor picked under the PREVIOUS
+            // project — the same staleness `parent`'s project already forbids,
+            // applied to the field that now decides it instead of receiving it.
+            const previousProject = field.id === 'project'
+                ? this.form.project
+                : null;
+            this.form = declaration.apply(this.form, options, intent);
+            // Any change counts, typing included: editing the query drops the
+            // pick, and a conductor of the dropped project must go with it.
+            if (field.id === 'project') {
+                const nextProject = this.form
+                    .project;
+                if (nextProject !== previousProject) {
+                    this.form = {
+                        ...this.form,
+                        conductor: null,
+                        parent: null,
+                        parentQuery: '',
+                    };
+                    void this.rescopeToProject(nextProject, context);
+                }
+            }
             if (field.query !== undefined &&
                 (intent.kind === 'insert' || intent.kind === 'backspace')) {
                 const query = this.form[field.query];
@@ -244,6 +297,57 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         context.requestDraw();
         return true;
     }
+    /**
+     * Re-scope the project-dependent bags to the project just picked in the
+     * Project field (GAIA-664 AC-8): Conductor through the same source
+     * `createFormSources` declares, Parent by swapping in that project's parent
+     * source (the option loader reads `this.sources` at query time, so later
+     * typing searches the new project). No project: no conductor, no parent.
+     */
+    async rescopeToProject(projectId, context) {
+        const client = context.services?.client;
+        if (!client)
+            return;
+        const { parent: _previous, ...rest } = this.sources;
+        this.sources =
+            projectId === null
+                ? rest
+                : { ...rest, parent: parentOptionSource(client, projectId) };
+        this.startOptionLoader();
+        const conductorSource = conductorOptionSource(client, {
+            ...this.hints,
+            ...(projectId === null ? {} : { projectId }),
+        });
+        const [conductors, parents] = await Promise.all([
+            conductorSource.load(''),
+            this.sources.parent?.load(''),
+        ]);
+        const current = this.readyValue;
+        if (!current || !context.isActive())
+            return;
+        // A later pick supersedes this load: a slow answer for the previous
+        // project must not replace the current project's candidates.
+        const picked = this.form
+            ?.project ?? null;
+        if (picked !== projectId)
+            return;
+        // Errors merged like the option loader's own merge: a failed read shows
+        // its error instead of reading as "this project has none".
+        const errors = { ...current.errors };
+        delete errors.conductors;
+        delete errors.parents;
+        if (conductors.error !== undefined)
+            errors.conductors = conductors.error;
+        if (parents?.error !== undefined)
+            errors.parents = parents.error;
+        this.replaceReady({
+            ...current,
+            conductors: conductors.options,
+            parents: parents?.options,
+            errors: Object.keys(errors).length > 0 ? errors : undefined,
+        });
+        context.requestDraw();
+    }
     reset() {
         this.form = undefined;
         this.remembered = undefined;
@@ -254,6 +358,8 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         this.optionLoader?.cancel();
         this.optionLoader = undefined;
         this.sources = {};
+        this.hasProjectContext = false;
+        this.hints = {};
         this.ownerIdentity.reset();
         super.reset();
     }
@@ -278,7 +384,7 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
     }
     fieldActions() {
         return this.form &&
-            CREATE_FORM.activeField(this.form).kind === 'autocomplete'
+            this.declaration().activeField(this.form).kind === 'autocomplete'
             ? [
                 actionItem('create-field', '↑↓', 'field'),
                 actionItem('create-suggest', '←→', 'suggestion'),
@@ -312,12 +418,17 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
         // D8 — a project is a PRECONDITION, not a fallback. Without `project_id`
         // the server writes a ticket that draws no number and gets no GAIA-nnn
         // identifier (`GaiaTicket::allocateNumber()` returns early), which is worse
-        // than not writing one. The agent row is unaffected: it resolves the
-        // project itself.
-        const projectId = context.project?.id;
+        // than not writing one. GAIA-664 AC-8: with no project already in scope the
+        // popup shows a Project field instead of refusing outright, so the
+        // precondition is now "a project was picked", not "one happened to be in
+        // scope" — `context.project` when there was one, the form's own pick when
+        // there was not.
+        const projectId = context.project?.id ??
+            this.form
+                ?.project ??
+            undefined;
         if (!projectId) {
-            this.message =
-                'no project in scope — open a project to create directly, or hand it to the agent';
+            this.message = 'no project selected — pick one above to create directly';
             context.requestDraw();
             return;
         }
@@ -377,7 +488,24 @@ export class CreateTicketFormScreen extends AsyncModalScreen {
             };
             return;
         }
-        const project = context.project?.slug ?? context.options?.project ?? 'gaia';
+        // GAIA-664 review F4: a guessed project was a fake resolution, not a real
+        // one — the literal `gaia` fallback sent the agent into whatever project
+        // happened to carry that slug. GAIA-664 AC-8: with no project already in
+        // scope the popup offers a Project field instead, and a pick there is as
+        // real a resolution as `context.project` — checked before the legacy
+        // `context.options?.project` default, since an explicit pick says more
+        // than an ambient one.
+        const formProjectId = this.form?.project;
+        const pickedProject = formProjectId
+            ? optionFor(this.readyValue?.projects ?? [], formProjectId)
+            : null;
+        const project = context.project?.slug ?? pickedProject?.label ?? context.options?.project;
+        if (!project) {
+            this.message =
+                'no project selected — pick one above to hand this to the agent';
+            context.requestDraw();
+            return;
+        }
         let specPath;
         try {
             specPath = join(tmpdir(), `gaia-new-ticket-${Date.now()}.json`);

package/dist/src/Entity/ticket/Screen/ticket-detail.js

@@ -10,10 +10,9 @@ const INCLUDES = [
     'conductor_id',
     'assignee_user_id',
     'comments',
-    // The Overview sidebar resolves references to names, not raw uuids: the team,
-    // the owner (Created by), and the sub-/referenced tickets in the Related tab.
+    // The Overview sidebar resolves references to names, not raw uuids: the
+    // owner (Created by), and the sub-/referenced tickets in the Related tab.
     // parent_id and blocked_by are already above.
-    'team',
     'owner_user_id',
     'sub_tickets',
     'referenced_tickets',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-gaia-ui",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "GAIA TUI: interactive terminal UI (dashboard, projects, tickets) as a dropsh `tui` renderer plugin.",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@gaia-ai/core": "^0.19.0",
-    "@gaia-ai/message": "^0.19.0"
+    "@gaia-ai/core": "^0.20.0",
+    "@gaia-ai/message": "^0.20.0"
   }
 }