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

package/dist/src/Component/section-list/index.js

@@ -1,4 +1,7 @@
-import { cellsRow, textNode } from '../../lib/vnode.js';
+import { cellsRow, textNode, } from '../../lib/vnode.js';
+import { plainLine } from '../markdown/index.js';
+/** Whether a line is columns rather than prose — `cells` is the discriminant. */
+const isCells = (line) => typeof line !== 'string' && 'cells' in line;
 /**
  * A line as the text a surface with no layout prints.
  *
@@ -6,29 +9,58 @@ import { cellsRow, textNode } from '../../lib/vnode.js';
  * puts between two cells: the pipe and the tree then say the same thing about
  * what separates two columns, and only the alignment inside a column is the
  * renderer's own.
+ *
+ * GAIA-372 D4 — for a {@link StyledLine} this returns the RENDERED text, which is the
+ * whole of how parity is achieved: `SectionRow.text` carries it and the pipe
+ * prints exactly that, so `gaia ui <id> | cat` and the interactive tree are the
+ * same rendering by construction. The tree merely adds the attributes a pipe
+ * cannot carry. There is no raw-only pipe path left to disagree (AC-3).
  */
-export const lineText = (line) => typeof line === 'string'
-    ? line
-    : line.cells
-        .map((cell) => cell.text)
-        .join(' ')
-        .replace(/\s+$/, '');
+export const lineText = (line) => {
+    if (typeof line === 'string')
+        return line;
+    if (isCells(line)) {
+        return line.cells
+            .map((cell) => cell.text)
+            .join(' ')
+            .replace(/\s+$/, '');
+    }
+    return line.text;
+};
 /**
- * The MINIMAL MARKDOWN rule: an ATX heading (`#`…`######`) renders as bold with
- * the markers stripped — the same rule a section heading follows. Bullets and
- * code fences stay raw by design (explicit v1 decision).
+ * Any body line as a RENDERED line — GAIA-372 D3/D8.
  *
- * ONE function, because every renderer of a body line goes through it:
- * {@link sectionRows} for a flat section, {@link expandableRows} for a
- * collapsible one, and `Entity/run/Component/run-detail` for a log entry. The
- * Description block is rendered by two of them at once — flat on the piped
- * render, expandable on the Overview tab — and a rule living in only one would
- * make the same body look different depending on which renderer reached it.
+ * A plain or columned row is LIFTED (one unparsed span) rather than refused,
+ * because a consumer that needs rendered lines — the collapsible Description
+ * entry, whose extract reads `line.heading` — is handed a `Description` section
+ * whose empty state is the plain string `No description.` Lifting never parses,
+ * so nothing here can re-introduce a Markdown rule on the plain path.
  */
-export function markdownRow(line) {
-    const md = /^(#{1,6})\s+(.*)$/.exec(line);
-    return md ? { text: md[2] ?? '', bold: true } : { text: line, bold: false };
-}
+export const styledOf = (line) => typeof line === 'string' || isCells(line) ? plainLine(lineText(line)) : line;
+/**
+ * One body line as the row it is — the ONE place D3's three variants are read
+ * apart, so a flat section and a collapsible entry cannot answer differently for
+ * the same line.
+ */
+const bodyRow = (key, line) => {
+    // Columns are never read as Markdown: a run number opens with `#`, and the ATX
+    // rule would both bold the row and eat the number.
+    if (isCells(line)) {
+        return { key, text: lineText(line), bold: false, cells: line.cells };
+    }
+    // A plain string is PLAIN. Nothing parses it (D3) — which is what puts
+    // `Assignment`, `Branch`, `Links` and `Labels` structurally out of reach.
+    if (typeof line === 'string')
+        return { key, text: line, bold: false };
+    return {
+        key,
+        text: line.text,
+        // An ATX heading inside a body is the ROW's weight, exactly as it was; what
+        // decides it is now the rendered line's own flag rather than a re-match.
+        bold: line.heading,
+        runs: line.runs,
+    };
+};
 /**
  * A heading as an id fragment: `PER USER` → `per-user`.
  *
@@ -41,6 +73,57 @@ export const sectionKey = (heading) => heading
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-|-$/g, '');
+/**
+ * The same, for a heading that is DATA rather than one of the built-in set —
+ * GAIA-373 AC-10.
+ *
+ * {@link sectionKey} is LOSSY: it lowercases and collapses every run of
+ * non-alphanumeric characters onto one `-`. That is injective over the closed
+ * built-in headings (`Per user`, `Latest summary`), and it stops being injective
+ * the moment a contributed panel heads its sections with whatever it is
+ * listing. The shipped artifacts viewer heads them with paths under the ticket's
+ * tree, so `/`, `.` and `-` all land on the same character and two ordinary
+ * captures collapse onto one key:
+ *
+ *     playwright/logs/walk.txt  ->  playwright-logs-walk-txt
+ *     playwright/logs-walk.txt  ->  playwright-logs-walk-txt
+ *
+ * A key is an IDENTITY — `Kernel/mount.ts` refuses a repeated id, and it refuses
+ * it while MOUNTING, past the host's guard around `panel.sections()` and on a
+ * draw path with no `catch` — so a lossy key is not a cosmetic collision, it is
+ * the cockpit going down on a message naming neither the addon nor the file.
+ *
+ * SO THE SEPARATORS ARE ENCODED RATHER THAN COLLAPSED. Every UTF-8 byte outside
+ * `[a-z0-9]` becomes `_<hex>`, two digits, lower case. The escape has a fixed
+ * length and `_` is itself escaped (`_5f`), so the mapping is reversible and
+ * therefore injective — including over case (`README.txt` and `readme.txt` are
+ * two files on this filesystem) and over a heading that already looks like an
+ * escape.
+ *
+ * WHY THE OUTPUT CARRIES NO `-`, which is a second property and not a side
+ * effect. A key never becomes an id on its own: it is always suffixed
+ * (`-heading`, `-gap`, `-empty`, `-header`, `-<index>`). Injectivity of the key
+ * alone would not settle the id, because the suffix boundary would be
+ * ambiguous — with `-` allowed inside a key, section `a` at body index 12 and
+ * section `a-1` at body index 2 would both be `a-12`. With no `-` inside a key
+ * the first `-` after the screen's own prefix always ends the key, so a key and
+ * its suffix are both recovered from an id and two ids can only be equal when
+ * both halves are. Within one section the suffixes are distinct by construction:
+ * the indices are digits and the four literals are not.
+ *
+ * NOT THE BUILT-IN PATH. `sectionRows` and the ticket detail's tabs keep
+ * {@link sectionKey} as their default, so no built-in node id moves (AC-2) — a
+ * `_` in a key is exactly the mark of a heading that came from a contribution.
+ *
+ * WHAT THIS STILL DOES NOT FIX, said plainly: two panel sections carrying the
+ * SAME heading. No injective map over headings can separate two identical
+ * headings, so that case remains the loud refusal it is today. It is out of
+ * scope for GAIA-373 and belongs to whatever gives a panel section an identity
+ * distinct from its title.
+ */
+export const panelSectionKey = (heading) => Array.from(new TextEncoder().encode(heading), (byte) => (byte >= 0x30 && byte <= 0x39) || (byte >= 0x61 && byte <= 0x7a)
+    ? String.fromCharCode(byte)
+    : `_${byte.toString(16).padStart(2, '0')}`).join('');
 /**
  * Flatten `{heading, lines}` sections into KEYED rows: the heading, its body,
  * and the blank line that closes the section.
@@ -51,21 +134,18 @@ export const sectionKey = (heading) => heading
  * property that lets the Dashboard hand over renderables while its pipe keeps
  * emitting the bytes it always did (spec F5).
  */
-export function sectionRows(sections) {
+export function sectionRows(sections, 
+// GAIA-373 — HOW a heading becomes a key, as an argument. The built-in
+// derivation stays the default so every existing caller keys exactly as it
+// did (AC-2); a caller whose headings are data passes
+// {@link panelSectionKey}, which is injective over them.
+keyOf = sectionKey) {
     const out = [];
     for (const section of sections) {
-        const id = sectionKey(section.heading);
+        const id = keyOf(section.heading);
         out.push({ key: `${id}-heading`, text: section.heading, bold: true });
         section.lines.forEach((line, index) => {
-            const key = `${id}-${index}`;
-            // Columns are never read as markdown: a run number opens with `#`, and the
-            // ATX rule would both bold the row and eat the number.
-            if (typeof line !== 'string') {
-                out.push({ key, text: lineText(line), bold: false, cells: line.cells });
-                return;
-            }
-            const { text, bold } = markdownRow(line);
-            out.push({ key, text, bold });
+            out.push(bodyRow(`${id}-${index}`, line));
         });
         out.push({ key: `${id}-gap`, text: '', bold: false });
     }
@@ -85,10 +165,17 @@ export const sectionRowNode = (prefix, row, selected = false) => row.cells === u
         content: row.text,
         bold: row.bold,
         selected,
+        // GAIA-372 D5 — spread rather than passed as `undefined`, for
+        // `exactOptionalPropertyTypes`: a row with no runs declares none, and
+        // `linked()` then returns the plain string it always did.
+        ...(row.runs === undefined ? {} : { runs: row.runs }),
     })
     : cellsRow(`${prefix}-${row.key}`, row.cells, selected);
 // The same rows as plain text plus the INDICES that are bold (section headings +
-// markdown ATX headings) — the shape the row surface needs. Headings carry NO
+// a rendered body's own ATX headings) — the shape the row surface needs. The
+// RUNS are dropped on this path by definition: a pipe carries no styling, and
+// `row.text` is already the rendered text, so what it prints is what the tree
+// draws minus the attributes (GAIA-372 D4). Headings carry NO
 // ANSI here: the draw step applies bold after fit(), so sanitizeDisplay never
 // sees (and never strips) the ESC.
 export function flattenSections(sections) {
@@ -138,8 +225,7 @@ export function expandableRows(entries, { expanded = new Set(), emptyMessage, em
         });
         const body = expanded.has(i) ? entry.expanded : entry.collapsed;
         body.forEach((line, index) => {
-            const { text, bold } = markdownRow(line);
-            rows.push({ key: `${entry.key}-${index}`, text, bold });
+            rows.push(bodyRow(`${entry.key}-${index}`, line));
         });
     });
     return { rows, headerRows, selectable: entries.length };

package/dist/src/Component/top-tabs/index.d.ts

@@ -13,6 +13,9 @@ export declare const ROOT_TABS: readonly [{
 }, {
     readonly id: "conductors";
     readonly label: "Conductors";
+}, {
+    readonly id: "teams";
+    readonly label: "Teams";
 }];
 /** The project level: the tabs of an opened project. */
 export declare const PROJECT_TABS: readonly [{
@@ -62,7 +65,54 @@ export declare const TICKET_TABS: readonly [{
     readonly id: "runs";
     readonly label: "Runs";
 }];
-/** The tab bars, keyed by level — the one place a level is named. */
+/**
+ * The team level: Overview · Users for one crew — GAIA-391 AC4, by operator
+ * ruling.
+ *
+ * The level the `users` root tab BECAME. It sits between root and user, so the
+ * navigation reads root → team → user: which crews are there, who is in this
+ * one, what has that person done. Destinations, not modes — each tab is its own
+ * screen, so Tab runs a real `Router.navigate` and `teamId` is preserved
+ * (`Routing/registry.ts` keeps the params for this scope for the same reason it
+ * keeps them for `project` and `user`).
+ *
+ * `overview` is also declared on the user level, which GAIA-256 D2 already made
+ * legal: ids are not globally unique, every function here is level-parameterised,
+ * and one bar is on screen at a time.
+ */
+export declare const TEAM_TABS: readonly [{
+    readonly id: "overview";
+    readonly label: "Overview";
+}, {
+    readonly id: "users";
+    readonly label: "Users";
+}];
+/**
+ * The user level: Overview · Tickets · Runs for one person (GAIA-377 D1).
+ *
+ * Destinations, not modes — each tab is its own screen in the slice that owns
+ * its query (D2), so Tab runs a real `Router.navigate` and preserves `userId`.
+ *
+ * UNCHANGED by GAIA-391: the ruling moved this level's PARENT (it hangs off
+ * {@link TEAM_TABS} now instead of off a root `users` tab), not its contents.
+ */
+export declare const USER_TABS: readonly [{
+    readonly id: "overview";
+    readonly label: "Overview";
+}, {
+    readonly id: "tickets";
+    readonly label: "Tickets";
+}, {
+    readonly id: "runs";
+    readonly label: "Runs";
+}];
+/**
+ * The tab bars, keyed by level — the one place a level is named.
+ *
+ * Declared in DEPTH order (root → project → ticket, then team → user), which is
+ * documentation rather than mechanism: nothing reads this object in key order
+ * since GAIA-256 D2 deleted `locateTab`, the one function that did.
+ */
 export declare const TAB_LEVELS: {
     readonly root: readonly [{
         readonly id: "dashboard";
@@ -73,6 +123,9 @@ export declare const TAB_LEVELS: {
     }, {
         readonly id: "conductors";
         readonly label: "Conductors";
+    }, {
+        readonly id: "teams";
+        readonly label: "Teams";
     }];
     readonly project: readonly [{
         readonly id: "dashboard";
@@ -100,6 +153,23 @@ export declare const TAB_LEVELS: {
         readonly id: "runs";
         readonly label: "Runs";
     }];
+    readonly team: readonly [{
+        readonly id: "overview";
+        readonly label: "Overview";
+    }, {
+        readonly id: "users";
+        readonly label: "Users";
+    }];
+    readonly user: readonly [{
+        readonly id: "overview";
+        readonly label: "Overview";
+    }, {
+        readonly id: "tickets";
+        readonly label: "Tickets";
+    }, {
+        readonly id: "runs";
+        readonly label: "Runs";
+    }];
 };
 /** The name of a level that carries a top-level tab bar. */
 export type TabLevel = keyof typeof TAB_LEVELS;
@@ -117,13 +187,40 @@ export type TopTabId = {
  * Where a screen sits in the navigation: which bar it draws, and which tab of
  * that bar is its own. A discriminated union over the levels, so a location can
  * never pair one level's name with another level's tab id.
+ *
+ * GAIA-373 D5/D6 — the `ticket` arm is the one that is NOT a literal union, and
+ * it is also the one that carries an optional bar of its own. Both halves have
+ * the same cause: the ticket level is not a DESTINATION level.
+ * `router.navigateTab` is never reached for it, because `selectTopTab` claims
+ * every ticket tab (GAIA-346 D4), so the literal union that protects root/project
+ * NAVIGATION has no target here — while a contributed section mode
+ * (`gaia/artifacts`) is data from the contribution store and cannot be a literal
+ * in this file at all. Root and project keep theirs intact, so
+ * `topTabBar('root', 'runs')` is still a TS2345.
+ *
+ * `tabs` is read by BOTH bar builders below and by the kernel's Tab cycle, so
+ * the bar drawn, the bar clicked and the bar cycled are three readings of one
+ * field rather than three answers.
  */
 export type TabLocation = {
-    [L in TabLevel]: {
-        level: L;
-        tab: TabIdOf<L>;
-    };
-}[TabLevel];
+    level: 'root';
+    tab: TabIdOf<'root'>;
+} | {
+    level: 'project';
+    tab: TabIdOf<'project'>;
+} | {
+    level: 'ticket';
+    tab: string;
+    tabs?: readonly TopTab[];
+} | {
+    level: 'team';
+    tab: TabIdOf<'team'>;
+} | {
+    level: 'user';
+    tab: TabIdOf<'user'>;
+};
+/** The entries a location draws: its own, else its level's registry. */
+export declare const tabsOfLocation: (location: TabLocation) => readonly TopTab[];
 /**
  * The bar as the PIECES it is drawn from: one part per tab, carrying that tab's
  * id, with the joins between them carrying none.
@@ -191,5 +288,11 @@ export declare function topTabParts<L extends TabLevel>(level: L, activeId: TabI
  * companion of {@link tabBarFor}, and the pairing it needs was already checked
  * when the location was built. Keeping the two in step is what makes "the bar you
  * see is the bar you click" true by construction: both read `location`.
+ *
+ * GAIA-373 — `TabBarPart<string>` rather than the `TopTabId` default, and that
+ * is an honest widening rather than a lost check: a location may carry a bar of
+ * its own now, whose entries are CONTRIBUTED (`gaia/artifacts`) and by
+ * construction outside every union derived from `TAB_LEVELS`. The level-typed
+ * {@link topTabParts} keeps the narrow ids for callers that name a level.
  */
-export declare function tabPartsFor(location: TabLocation): TabBarPart[];
+export declare function tabPartsFor(location: TabLocation): TabBarPart<string>[];

package/dist/src/Component/top-tabs/index.js

@@ -1,13 +1,17 @@
 // GAIA-239: THE registry — the single place the set, the order and the labels of
-// the top-level tabs are written. Navigation has THREE levels, and every screen
+// the top-level tabs are written. Navigation has FIVE levels, and every screen
 // shows exactly ONE tab bar: the one of its own level.
 //
-//   root     dashboard, projects, project-picker  → Dashboard · Projects
+//   root     dashboard, projects, project-picker  → Dashboard · Projects ·
+//                                                    Conductors · Teams
 //   project  dashboard, project, ticket-agents,   → Dashboard · Tickets ·
 //            project-runs                           Ticket-Agents · Runs
 //   ticket   overview, comments, related, runs    → the sections of one open
 //                                                    ticket, in the bar row every
 //                                                    other level uses (GAIA-346)
+//   team     one crew                             → Overview · Users (GAIA-391)
+//   user     one person                           → Overview · Tickets · Runs
+//                                                    (GAIA-377)
 //
 // `tickets` is the project/ticket drill-down; `ticket-agents` is the managed
 // create-agent list (GAIA-190); `runs` is the project-scoped run overview
@@ -29,10 +33,12 @@
 // level — the bar you Tab through or click IS the current level's bar — so it
 // pairs the target with `here.level` directly and `locateTab` is deleted.
 //
-// Only tabs that are actually navigable are listed. A planned screen (`Users`)
-// arrives with its own ticket and adds its entry here then — a tab drawn before
-// its screen exists would advertise navigation the operator cannot take, which
-// is the very defect GAIA-239 removes.
+// Only tabs that are actually navigable are listed. GAIA-377 added `Users` with
+// its screens; a tab drawn before its screen exists would advertise navigation
+// the operator cannot take, which is the very defect GAIA-239 removes. The same
+// rule runs the other way, and GAIA-391 is where it did: a LEVEL is declared
+// with the screens that occupy it, so `team` arrives with the crew overview and
+// the crew's Users list, not before them.
 //
 // GAIA-232 added `conductors`, and put it on the ROOT level although the note
 // above once reserved it for the project level. A conductor is an operator
@@ -53,6 +59,28 @@ export const ROOT_TABS = [
     { id: 'dashboard', label: 'Dashboard' },
     { id: 'projects', label: 'Projects' },
     { id: 'conductors', label: 'Conductors' },
+    // GAIA-391 AC4 — `teams` is the LAST root tab, and there is deliberately no
+    // `users` beside it any more.
+    //
+    // ROOT level for teams, by GAIA-232's argument for Conductors: a team is the
+    // level that cuts ACROSS customer projects (GAIA-321), so "which crews are
+    // there" has to be answerable without first choosing a project.
+    //
+    // THIS REVISES AN INFORMATION-ARCHITECTURE DECISION THAT BELONGS TO GAIA-377,
+    // NOT TO GAIA-391. GAIA-377 D1 shipped `users` as a root tab and declared
+    // {@link USER_TABS} as the level below it; GAIA-391 moved that whole level
+    // under the team level by OPERATOR RULING, so the root bar reads
+    // `Dashboard · Projects · Conductors · Teams` and a person is reached through
+    // the crew they are in: Teams → one crew → Users → one person. Recorded here
+    // because a silent removal would later read as a regression against 377, and
+    // because the previous comment on this list argued the OPPOSITE order
+    // ("people, then the crews they are in") — an argument this ruling overturns
+    // rather than an accident.
+    //
+    // Users did NOT become unreachable, which is what makes the move a move: the
+    // team level carries the tab ({@link TEAM_TABS}), and the Dashboard's PER USER
+    // rows still open one person directly.
+    { id: 'teams', label: 'Teams' },
 ];
 /** The project level: the tabs of an opened project. */
 export const PROJECT_TABS = [
@@ -88,12 +116,57 @@ export const TICKET_TABS = [
     { id: 'related', label: 'Related' },
     { id: 'runs', label: 'Runs' },
 ];
-/** The tab bars, keyed by level — the one place a level is named. */
+/**
+ * The team level: Overview · Users for one crew — GAIA-391 AC4, by operator
+ * ruling.
+ *
+ * The level the `users` root tab BECAME. It sits between root and user, so the
+ * navigation reads root → team → user: which crews are there, who is in this
+ * one, what has that person done. Destinations, not modes — each tab is its own
+ * screen, so Tab runs a real `Router.navigate` and `teamId` is preserved
+ * (`Routing/registry.ts` keeps the params for this scope for the same reason it
+ * keeps them for `project` and `user`).
+ *
+ * `overview` is also declared on the user level, which GAIA-256 D2 already made
+ * legal: ids are not globally unique, every function here is level-parameterised,
+ * and one bar is on screen at a time.
+ */
+export const TEAM_TABS = [
+    { id: 'overview', label: 'Overview' },
+    { id: 'users', label: 'Users' },
+];
+/**
+ * The user level: Overview · Tickets · Runs for one person (GAIA-377 D1).
+ *
+ * Destinations, not modes — each tab is its own screen in the slice that owns
+ * its query (D2), so Tab runs a real `Router.navigate` and preserves `userId`.
+ *
+ * UNCHANGED by GAIA-391: the ruling moved this level's PARENT (it hangs off
+ * {@link TEAM_TABS} now instead of off a root `users` tab), not its contents.
+ */
+export const USER_TABS = [
+    { id: 'overview', label: 'Overview' },
+    { id: 'tickets', label: 'Tickets' },
+    { id: 'runs', label: 'Runs' },
+];
+/**
+ * The tab bars, keyed by level — the one place a level is named.
+ *
+ * Declared in DEPTH order (root → project → ticket, then team → user), which is
+ * documentation rather than mechanism: nothing reads this object in key order
+ * since GAIA-256 D2 deleted `locateTab`, the one function that did.
+ */
 export const TAB_LEVELS = {
     root: ROOT_TABS,
     project: PROJECT_TABS,
     ticket: TICKET_TABS,
+    team: TEAM_TABS,
+    user: USER_TABS,
 };
+/** The entries a location draws: its own, else its level's registry. */
+export const tabsOfLocation = (location) => 'tabs' in location && location.tabs
+    ? location.tabs
+    : TAB_LEVELS[location.level];
 /** What joins two tabs in the rendered bar — part of neither tab's span. */
 const SEPARATOR = '  ';
 /** One tab's rendered segment: bracketed when active, space-padded otherwise. */
@@ -133,7 +206,7 @@ export function topTabBar(level, activeId) {
  * not ask the compiler to correlate two independently narrowed properties.
  */
 export function tabBarFor(location) {
-    return renderBar(TAB_LEVELS[location.level], location.tab);
+    return renderBar(tabsOfLocation(location), location.tab);
 }
 // GAIA-256 spec D2 — `locateTab` USED TO LIVE HERE and is deliberately gone.
 //
@@ -168,7 +241,13 @@ export function topTabParts(level, activeId) {
  * companion of {@link tabBarFor}, and the pairing it needs was already checked
  * when the location was built. Keeping the two in step is what makes "the bar you
  * see is the bar you click" true by construction: both read `location`.
+ *
+ * GAIA-373 — `TabBarPart<string>` rather than the `TopTabId` default, and that
+ * is an honest widening rather than a lost check: a location may carry a bar of
+ * its own now, whose entries are CONTRIBUTED (`gaia/artifacts`) and by
+ * construction outside every union derived from `TAB_LEVELS`. The level-typed
+ * {@link topTabParts} keeps the narrow ids for callers that name a level.
  */
 export function tabPartsFor(location) {
-    return renderParts(TAB_LEVELS[location.level], location.tab);
+    return renderParts(tabsOfLocation(location), location.tab);
 }

package/dist/src/Entity/collection.js

@@ -50,7 +50,7 @@ function readTotal(doc) {
  * back is `pad`'s reason for existing: `cellFill` fills to a width the COLUMN
  * DECLARES, never to one measured off the page.
  * Reaching `lib/width.ts` for the measurement is a DELIBERATE decision on top of
- * A2 already being reported as missed (`docs/evidence/GAIA-340/teardown-a2.txt`)
+ * A2 already being reported as missed (`docs/evidence/GAIA-340/teardown-a2.txt`, in git history since GAIA-371)
  * — the module survives this ticket, so the alternative is not "no measurement"
  * but "an illegible cut", and R5's rule against re-implementing it under another
  * name is honoured by calling it rather than copying it.

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

@@ -223,9 +223,10 @@ export interface ConductorRowContext {
 /**
  * The conductor collection as cockpit rows, in server order.
  *
- * Swallows a read failure into an empty list on purpose: the Conductors screen
- * re-reads every 5 s, so one failed poll must leave the screen navigable rather
- * than replace it with an error.
+ * Sideloads `machine` so capacity (GAIA-353 D5/D10) comes from the host budget,
+ * not removed conductor fields. Swallows a read failure into an empty list on
+ * purpose: the Conductors screen re-reads every 5 s, so one failed poll must
+ * leave the screen navigable rather than replace it with an error.
  */
 export declare const listConductorRows: (client: DropshClient, ctx: ConductorRowContext) => Promise<ConductorRow[]>;
 /**

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

@@ -4,14 +4,19 @@
 // service that applied them would be unusable for any other purpose. The two read
 // strategies are both just reading, so both live here.
 import { toUnixSeconds } from '@gaia-ai/core';
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
 import { humanizeAge } from '../../../lib/format.js';
 import { listOutcome, listPreferringWrite, } from '../../transport.js';
 import { deriveConductorStatus } from './liveness.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const toConductor = (r) => ({
     id: r.id,
-    label: str(r.attr('label')) ?? str(r.attr('machine_id')) ?? r.id,
-    machineId: str(r.attr('machine_id')),
+    label: str(r.attr('label')) ??
+        str(r.attr('conductor_id')) ??
+        str(r.attr('machine_id')) ??
+        r.id,
+    // Registration key (GAIA-353 renamed machine_id → conductor_id).
+    machineId: str(r.attr('conductor_id')) ?? str(r.attr('machine_id')),
     status: str(r.attr('status')),
     projectId: r.rel('project_id'),
 });
@@ -242,19 +247,68 @@ export const CONDUCTOR_TABLE = {
     ],
 };
 const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
-const toConductorRow = (r, ctx) => {
+/** Id of a single-valued relationship linkage (`data` object), or null. */
+function singleRelId(rel) {
+    const data = rel?.data;
+    if (!data || Array.isArray(data))
+        return null;
+    return data.id ?? null;
+}
+/**
+ * Dropsh's collection path hands Resource accessors; the cockpit row path uses
+ * client.get so it can sideload `machine`. Map the raw JSON:API resource into
+ * the same attr/rel surface toConductor already speaks.
+ */
+function asResource(raw) {
+    return {
+        id: raw.id ?? '',
+        type: raw.type ?? '',
+        attr: (key) => raw.attributes?.[key],
+        rel: (key) => singleRelId(raw.relationships?.[key]),
+        rels: (key) => {
+            const data = raw.relationships?.[key]?.data;
+            if (!data)
+                return [];
+            if (Array.isArray(data)) {
+                return data
+                    .map((d) => d.id)
+                    .filter((id) => typeof id === 'string');
+            }
+            return data.id ? [data.id] : [];
+        },
+    };
+}
+/** Host capacity from the sideloaded machine, with cutover fallbacks (GAIA-353). */
+function capacityOf(raw, machinesById) {
+    const machineId = singleRelId(raw.relationships?.machine);
+    const machine = machineId ? machinesById.get(machineId) : undefined;
+    const attrs = raw.attributes ?? {};
+    return {
+        // Prefer machine.current_load; process telemetry / legacy conductor attrs
+        // only when the host row is missing during cutover.
+        currentLoad: num(machine?.attributes?.current_load) ??
+            num(attrs.reported_load) ??
+            num(attrs.current_load) ??
+            0,
+        // max_parallel is machine-owned SoT; legacy conductor attr is last resort.
+        maxParallel: num(machine?.attributes?.max_parallel) ?? num(attrs.max_parallel) ?? 0,
+    };
+}
+const toConductorRow = (raw, ctx, machinesById) => {
+    const r = asResource(raw);
     const workspaceRoot = str(r.attr('workspace_root')) ?? '';
     // ISO-8601 over the wire, not the unix integer the field name implies — a
     // `typeof === 'number'` guard here is what made a live conductor read `stale`.
     const lastSeen = toUnixSeconds(r.attr('last_seen')) ?? 0;
     const leaseExpiresAt = toUnixSeconds(r.attr('lease_expires_at')) ?? 0;
+    const { currentLoad, maxParallel } = capacityOf(raw, machinesById);
     return {
         ...toConductor(r),
         workspaceRoot,
         lastSeen,
         leaseExpiresAt,
-        currentLoad: num(r.attr('current_load')) ?? 0,
-        maxParallel: num(r.attr('max_parallel')) ?? 0,
+        currentLoad,
+        maxParallel,
         lastPid: num(r.attr('last_pid')),
         conductorName: str(r.attr('conductor_name')),
         // `present: true` because the row IS a control-plane record — which is why
@@ -273,13 +327,25 @@ const toConductorRow = (r, ctx) => {
 /**
  * The conductor collection as cockpit rows, in server order.
  *
- * Swallows a read failure into an empty list on purpose: the Conductors screen
- * re-reads every 5 s, so one failed poll must leave the screen navigable rather
- * than replace it with an error.
+ * Sideloads `machine` so capacity (GAIA-353 D5/D10) comes from the host budget,
+ * not removed conductor fields. Swallows a read failure into an empty list on
+ * purpose: the Conductors screen re-reads every 5 s, so one failed poll must
+ * leave the screen navigable rather than replace it with an error.
  */
 export const listConductorRows = async (client, ctx) => {
-    const outcome = await listOutcome(client, 'gaia_conductor', (r) => toConductorRow(r, ctx));
-    return outcome.rows;
+    const params = new DrupalJsonApiParams().addInclude(['machine']);
+    try {
+        const doc = (await client.get('gaia_conductor/gaia_conductor', params));
+        const machinesById = new Map();
+        for (const inc of doc.included ?? []) {
+            if (inc.id)
+                machinesById.set(inc.id, inc);
+        }
+        return (doc.data ?? []).map((raw) => toConductorRow(raw, ctx, machinesById));
+    }
+    catch {
+        return [];
+    }
 };
 /**
  * Project uuid → name, for the Conductors screen's project column.