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

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

@@ -14,8 +14,8 @@ export declare const ROOT_TABS: readonly [{
     readonly id: "conductors";
     readonly label: "Conductors";
 }, {
-    readonly id: "users";
-    readonly label: "Users";
+    readonly id: "teams";
+    readonly label: "Teams";
 }];
 /** The project level: the tabs of an opened project. */
 export declare const PROJECT_TABS: readonly [{
@@ -65,11 +65,36 @@ export declare const TICKET_TABS: readonly [{
     readonly id: "runs";
     readonly label: "Runs";
 }];
+/**
+ * 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";
@@ -81,7 +106,13 @@ export declare const USER_TABS: readonly [{
     readonly id: "runs";
     readonly label: "Runs";
 }];
-/** The tab bars, keyed by level — the one place a level is named. */
+/**
+ * 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";
@@ -93,8 +124,8 @@ export declare const TAB_LEVELS: {
         readonly id: "conductors";
         readonly label: "Conductors";
     }, {
-        readonly id: "users";
-        readonly label: "Users";
+        readonly id: "teams";
+        readonly label: "Teams";
     }];
     readonly project: readonly [{
         readonly id: "dashboard";
@@ -122,6 +153,13 @@ 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";
@@ -174,6 +212,12 @@ export type TabLocation = {
     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[];

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
@@ -31,7 +35,10 @@
 //
 // 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 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
@@ -52,8 +59,28 @@ export const ROOT_TABS = [
     { id: 'dashboard', label: 'Dashboard' },
     { id: 'projects', label: 'Projects' },
     { id: 'conductors', label: 'Conductors' },
-    // GAIA-377 D1 — arrives with its screens; see USER_TABS.
-    { id: 'users', label: 'Users' },
+    // 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 = [
@@ -89,22 +116,51 @@ export const TICKET_TABS = [
     { id: 'related', label: 'Related' },
     { id: 'runs', label: 'Runs' },
 ];
+/**
+ * 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. */
+/**
+ * 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. */

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.

package/dist/src/Entity/conductor/Data/own-conductor.js

@@ -49,7 +49,13 @@ export function selectOwnConductor(doc, gaiaDir) {
         ? str((doc.included ?? []).find((inc) => inc.id === projectId)?.attributes
             ?.name)
         : undefined;
-    return { machineId: str(own.attributes?.machine_id), project };
+    // GAIA-353 renamed the registration key machine_id → conductor_id; accept
+    // the legacy attribute during cutover so a pre-upgrade control plane still
+    // preselects this checkout's conductor.
+    return {
+        machineId: str(own.attributes?.conductor_id) ?? str(own.attributes?.machine_id),
+        project,
+    };
 }
 /**
  * Read the conductor collection and resolve this checkout's own record.

package/dist/src/Entity/statistics/Data/statistics.d.ts

@@ -51,6 +51,24 @@ export interface StatisticsBlock {
     total: StatisticsWindows;
     byProject?: StatisticsRow[];
     byUser?: StatisticsRow[];
+    /**
+     * GAIA-391 (AC4): the crew axis the server has served since GAIA-321.
+     *
+     * A team row is expanded from the per-USER counts onto every active team the
+     * assignee belongs to, so a dual-member's ticket is counted once per team and
+     * `sum(byTeam.*.window)` MAY EXCEED `total.window`. That is the server's own
+     * documented intent, not drift — which is why the summing invariant `byUser`
+     * carries (spec D8) is deliberately not claimed for this axis anywhere.
+     *
+     * Absent, never empty, when the read was team-scoped: the server omits it, the
+     * same way it omits `byProject` under `?project_id=` (spec D5).
+     *
+     * GAIA-319 D7 — a crew whose workspace the CALLER does not belong to is
+     * DROPPED, not folded, so this axis never carries an `id: null` row and the
+     * rows present may be fewer than the instance's crews. That is a disclosure
+     * boundary rather than a count: the axis reports what the caller may see.
+     */
+    byTeam?: StatisticsRow[];
     byDay?: StatisticsDayRow[];
 }
 /** The whole document, as the Dashboard consumes it. */
@@ -80,6 +98,41 @@ export type StatisticsResult = {
 };
 /** How an `id: null` breakdown row is named on screen (spec D8/D11). */
 export declare const UNATTRIBUTED_LABEL = "\u2014 unattributed";
+/**
+ * `byTeam` with the part of the total no crew accounts for, as a real row.
+ *
+ * GAIA-391 round 4. The dashboard drew three breakdown axes identically while
+ * only two of them added up, and only `byUser` had a NAME for what it could not
+ * attribute — so a crew axis reporting 1 against a total of 2 was, at the
+ * surface, indistinguishable from a broken expansion. Measured on this branch's
+ * control plane as uid 4: `runs.total` 2, `byProject` 2, `byUser` 1 +
+ * unattributed 1, `byTeam` 1, because the second run's ticket carried no
+ * assignee. An operator read it as a defect within minutes.
+ *
+ * THE SERVER IS NOT THE THING BEING CHANGED. `by_team` still carries no
+ * `id: null` row and {@link rowsOf} still does not invent one — that is
+ * GAIA-321 D6, and the parse is asserted to leave it alone. This is the
+ * RENDERING's own row, derived here so both the interactive and the piped
+ * surface get it from one place, and labelled with the very same
+ * {@link UNATTRIBUTED_LABEL} `byUser` uses: the problem was three axes drawn
+ * alike, so a fourth visual language would not be a fix.
+ *
+ * The shortfall is computed PER WINDOW, because the axis can be exact in one
+ * window and short in another, and it is clamped at zero for the one documented
+ * case where the axis legitimately OVER-reports: a dual member's row is counted
+ * once per crew (GAIA-321 D6), and a negative shortfall is not a shortfall.
+ *
+ * `undefined` in, `undefined` out. A team-scoped read omits the axis (spec D5)
+ * and deriving a row there would draw a `PER TEAM` heading whose single row is
+ * the whole total, on the one screen already scoped to a single crew. An axis
+ * that is present but EMPTY is a different thing and does get the row: the
+ * server computed it and nothing landed in it.
+ *
+ * @param block One entity type's figures, as {@link loadStatistics} parsed them.
+ *
+ * @returns The crew rows to draw, or `undefined` when there is no crew axis.
+ */
+export declare function teamRowsWithUnattributed(block: StatisticsBlock): StatisticsRow[] | undefined;
 /**
  * Closed tickets per run for each trailing window (GAIA-377 D4).
  *
@@ -98,15 +151,39 @@ export declare const formatClosedPerRun: (value: number | null) => string;
  * Read the control plane's ticket and run statistics — the ONE source of every
  * figure the Dashboard renders (AC-8).
  *
+ * NOT INSTANCE-WIDE since GAIA-319: the endpoint scopes every count to the
+ * requesting account's workspace memberships (`StatisticsCounter`,
+ * `TeamStatistics`, `StatisticsResource`), unless that account holds
+ * `administer gaia` and bypasses the scope. The document's SHAPE is unchanged —
+ * the same `total` plus `by_project` / `by_user` / `by_team` / `by_day`, with the
+ * same rows — so nothing in this parser moved, and that is exactly what the
+ * GAIA-319 cases in `tests/Entity/statistics/Data/statistics.test.ts` pin.
+ *
+ * Two of that scoping's effects are worth knowing HERE, because they look like
+ * client bugs and are not:
+ *
+ *  - a person the caller may not name is FOLDED into the `by_user` row with
+ *    `id: null` (D6), which this file renders as {@link UNATTRIBUTED_LABEL};
+ *  - a crew outside the caller's workspaces is DROPPED from `by_team` (D7), so
+ *    `sum(byTeam)` under-reports the instance rather than carrying a residual row.
+ *
+ * And one this client cannot fix: an account with no workspace memberships gets a
+ * document full of ZEROES, which the Dashboard reads as "no activity". Nothing in
+ * the payload distinguishes that from a quiet month, so the CLI does not claim to.
+ *
  * With `projectId` the read is scoped and the server drops `by_project` from
  * both blocks (spec D5). With `userId` (GAIA-377 D3) it drops `by_user` and
- * keeps `by_project`. The parameter names are `project_id` / `user_id` and NOT
- * bare letters: JSON:API requires an implementation-specific query parameter to
+ * keeps `by_project`. With `teamId` (GAIA-391 AC4, over the `?team_id=` GAIA-321
+ * already serves) it drops `by_team` and narrows the counts to the team's ACTIVE
+ * members. All three compose with AND, as the server's own resource documents.
+ * The parameter names are `project_id` / `user_id` / `team_id` and NOT bare
+ * letters: JSON:API requires an implementation-specific query parameter to
  * contain at least one non-`a-z` character, and Drupal enforces it.
  *
  * The client is the caller's, singular and used once: the TUI reads everything
- * through `services.client` (the `session` profile), and `pm` cannot read
- * `gaia_run` — a loader that reached for another client would render zero runs
- * as a real measurement (spec R3).
+ * through `services.client`. Reaching for a second client would render zero runs
+ * as a real measurement (spec R3) — the reason has changed with GAIA-391 (there
+ * is one identity now, not a read profile that can see runs and a write profile
+ * that cannot), but the rule has not: one figure, one source.
  */
-export declare function loadStatistics(client: DropshClient, projectId?: string, userId?: string): Promise<StatisticsResult>;
+export declare function loadStatistics(client: DropshClient, projectId?: string, userId?: string, teamId?: string): Promise<StatisticsResult>;

package/dist/src/Entity/statistics/Data/statistics.js

@@ -41,11 +41,13 @@ function blockOf(value) {
     const b = (value ?? {});
     const byProject = rowsOf(b.by_project);
     const byUser = rowsOf(b.by_user);
+    const byTeam = rowsOf(b.by_team);
     const byDay = dayRowsOf(b.by_day);
     return {
         total: windowsOf(b.total),
         ...(byProject ? { byProject } : {}),
         ...(byUser ? { byUser } : {}),
+        ...(byTeam ? { byTeam } : {}),
         ...(byDay ? { byDay } : {}),
     };
 }
@@ -100,6 +102,56 @@ function jsonApiErrorDetail(caught) {
     // fall back to a non-empty marker rather than to `undefined`.
     return typeof detail === 'string' && detail !== '' ? detail : 'HTTP 404';
 }
+/**
+ * `byTeam` with the part of the total no crew accounts for, as a real row.
+ *
+ * GAIA-391 round 4. The dashboard drew three breakdown axes identically while
+ * only two of them added up, and only `byUser` had a NAME for what it could not
+ * attribute — so a crew axis reporting 1 against a total of 2 was, at the
+ * surface, indistinguishable from a broken expansion. Measured on this branch's
+ * control plane as uid 4: `runs.total` 2, `byProject` 2, `byUser` 1 +
+ * unattributed 1, `byTeam` 1, because the second run's ticket carried no
+ * assignee. An operator read it as a defect within minutes.
+ *
+ * THE SERVER IS NOT THE THING BEING CHANGED. `by_team` still carries no
+ * `id: null` row and {@link rowsOf} still does not invent one — that is
+ * GAIA-321 D6, and the parse is asserted to leave it alone. This is the
+ * RENDERING's own row, derived here so both the interactive and the piped
+ * surface get it from one place, and labelled with the very same
+ * {@link UNATTRIBUTED_LABEL} `byUser` uses: the problem was three axes drawn
+ * alike, so a fourth visual language would not be a fix.
+ *
+ * The shortfall is computed PER WINDOW, because the axis can be exact in one
+ * window and short in another, and it is clamped at zero for the one documented
+ * case where the axis legitimately OVER-reports: a dual member's row is counted
+ * once per crew (GAIA-321 D6), and a negative shortfall is not a shortfall.
+ *
+ * `undefined` in, `undefined` out. A team-scoped read omits the axis (spec D5)
+ * and deriving a row there would draw a `PER TEAM` heading whose single row is
+ * the whole total, on the one screen already scoped to a single crew. An axis
+ * that is present but EMPTY is a different thing and does get the row: the
+ * server computed it and nothing landed in it.
+ *
+ * @param block One entity type's figures, as {@link loadStatistics} parsed them.
+ *
+ * @returns The crew rows to draw, or `undefined` when there is no crew axis.
+ */
+export function teamRowsWithUnattributed(block) {
+    const rows = block.byTeam;
+    if (rows === undefined)
+        return undefined;
+    const shortfall = (window) => Math.max(0, block.total[window] - rows.reduce((sum, row) => sum + row[window], 0));
+    const residual = {
+        id: null,
+        label: UNATTRIBUTED_LABEL,
+        day: shortfall('day'),
+        week: shortfall('week'),
+        month: shortfall('month'),
+    };
+    if (residual.day === 0 && residual.week === 0 && residual.month === 0)
+        return rows;
+    return [...rows, residual];
+}
 /**
  * Closed tickets per run for each trailing window (GAIA-377 D4).
  *
@@ -121,18 +173,42 @@ export const formatClosedPerRun = (value) => value === null ? '—' : value.toFi
  * Read the control plane's ticket and run statistics — the ONE source of every
  * figure the Dashboard renders (AC-8).
  *
+ * NOT INSTANCE-WIDE since GAIA-319: the endpoint scopes every count to the
+ * requesting account's workspace memberships (`StatisticsCounter`,
+ * `TeamStatistics`, `StatisticsResource`), unless that account holds
+ * `administer gaia` and bypasses the scope. The document's SHAPE is unchanged —
+ * the same `total` plus `by_project` / `by_user` / `by_team` / `by_day`, with the
+ * same rows — so nothing in this parser moved, and that is exactly what the
+ * GAIA-319 cases in `tests/Entity/statistics/Data/statistics.test.ts` pin.
+ *
+ * Two of that scoping's effects are worth knowing HERE, because they look like
+ * client bugs and are not:
+ *
+ *  - a person the caller may not name is FOLDED into the `by_user` row with
+ *    `id: null` (D6), which this file renders as {@link UNATTRIBUTED_LABEL};
+ *  - a crew outside the caller's workspaces is DROPPED from `by_team` (D7), so
+ *    `sum(byTeam)` under-reports the instance rather than carrying a residual row.
+ *
+ * And one this client cannot fix: an account with no workspace memberships gets a
+ * document full of ZEROES, which the Dashboard reads as "no activity". Nothing in
+ * the payload distinguishes that from a quiet month, so the CLI does not claim to.
+ *
  * With `projectId` the read is scoped and the server drops `by_project` from
  * both blocks (spec D5). With `userId` (GAIA-377 D3) it drops `by_user` and
- * keeps `by_project`. The parameter names are `project_id` / `user_id` and NOT
- * bare letters: JSON:API requires an implementation-specific query parameter to
+ * keeps `by_project`. With `teamId` (GAIA-391 AC4, over the `?team_id=` GAIA-321
+ * already serves) it drops `by_team` and narrows the counts to the team's ACTIVE
+ * members. All three compose with AND, as the server's own resource documents.
+ * The parameter names are `project_id` / `user_id` / `team_id` and NOT bare
+ * letters: JSON:API requires an implementation-specific query parameter to
  * contain at least one non-`a-z` character, and Drupal enforces it.
  *
  * The client is the caller's, singular and used once: the TUI reads everything
- * through `services.client` (the `session` profile), and `pm` cannot read
- * `gaia_run` — a loader that reached for another client would render zero runs
- * as a real measurement (spec R3).
+ * through `services.client`. Reaching for a second client would render zero runs
+ * as a real measurement (spec R3) — the reason has changed with GAIA-391 (there
+ * is one identity now, not a read profile that can see runs and a write profile
+ * that cannot), but the rule has not: one figure, one source.
  */
-export async function loadStatistics(client, projectId, userId) {
+export async function loadStatistics(client, projectId, userId, teamId) {
     const params = new DrupalJsonApiParams();
     if (projectId !== undefined) {
         params.addCustomParam({ project_id: projectId });
@@ -140,6 +216,9 @@ export async function loadStatistics(client, projectId, userId) {
     if (userId !== undefined) {
         params.addCustomParam({ user_id: userId });
     }
+    if (teamId !== undefined) {
+        params.addCustomParam({ team_id: teamId });
+    }
     let doc;
     try {
         doc = (await client.get('gaia/statistics', params));

package/dist/src/Entity/statistics/Screen/dashboard.js

@@ -3,7 +3,7 @@ import { lineText, sectionRowNode, sectionRows, } from '../../../Component/secti
 import { statsPanelRows, } from '../../../Component/stats-panel/index.js';
 import { columnNode } from '../../../lib/vnode.js';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
-import { closedPerRun, formatClosedPerRun, loadStatistics, } from '../Data/statistics.js';
+import { closedPerRun, formatClosedPerRun, loadStatistics, teamRowsWithUnattributed, } from '../Data/statistics.js';
 /** Rows that are plain text, keyed under one name: a failure or empty state. */
 const plainRows = (key, lines) => lines.map((text, index) => ({ key: `${key}-${index}`, text, bold: false }));
 /** The Tab hint is a TERMINAL affordance; a pipe has no tabs (spec D9). */
@@ -219,10 +219,11 @@ const totalRows = (block) => [
     { label: WINDOWS[2] ?? '', numbers: [block.total.month] },
 ];
 /**
- * The breakdown groups of one axis (`by_project` or `by_user`), titled.
+ * The breakdown groups of one axis (`by_project`, `by_user` or `by_team`), titled.
  *
  * The title and the rows come from the SAME literal pair, so a third entity type
- * is added in one place and cannot be named one way and grouped another.
+ * is added in one place and cannot be named one way and grouped another — which
+ * is what made GAIA-391's `by_team` axis a one-line addition to the list below.
  */
 const groups = (statistics, pick) => [
     ['Tickets', pick(statistics.tickets)],
@@ -267,6 +268,19 @@ function statisticsSections(statistics) {
     for (const [heading, pick] of [
         ['PER PROJECT', (block) => block.byProject],
         ['PER USER', (block) => block.byUser],
+        // GAIA-391 (AC4): the crew axis, drawn LAST because it is the narrowest
+        // reading of the same figures — and because `PER USER` owns the selection
+        // cursor below, which keys its row ids off its own header offset. A team row
+        // is deliberately not selectable: the team detail is reached from the Teams
+        // list, its own route, and a second entrance here would put one destination
+        // behind two cursors on one screen.
+        //
+        // Round 4 — picked through `teamRowsWithUnattributed` rather than straight
+        // off the block, so the axis that carries no sum invariant SAYS SO on
+        // screen, in the row `PER USER` already uses for the same thing. Three axes
+        // drawn identically while one silently under-reported is what an operator
+        // read as a defect; the derivation is documented where it lives.
+        ['PER TEAM', (block) => teamRowsWithUnattributed(block)],
     ]) {
         const rowGroups = groups(statistics, pick);
         if (rowGroups.length === 0)