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

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

@@ -1,11 +1,11 @@
 import { existsSync } from 'node:fs';
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { columnNode, textNode } from '../../../lib/vnode.js';
-import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { listRowIds, listTableTree } from '../../collection.js';
 import { CONDUCTOR_TABLE, listConductorRows, listProjectNames, } from '../Data/conductors.js';
 import { tailConductorLog } from '../Data/log-tail.js';
 import { createConductorProcessHost } from '../Data/process.js';
-const REFRESH_MS = 5_000;
 /**
  * The open row's log block: where it is, and its tail.
  *
@@ -24,7 +24,14 @@ const logFor = (row) => row.isLocal
         heading: `log — ${row.label} runs on another machine; no log here`,
         lines: [],
     };
-export class ConductorsScreen extends BaseScreen {
+/**
+ * Conductors list — a normal {@link AsyncScreen}.
+ *
+ * Refresh is the shared mechanism (GAIA-376 `ui-refresh` file + `R`), not a
+ * screen-private timer. Enter loads; navigation away cancels in-flight reads
+ * via the async lifecycle.
+ */
+export class ConductorsScreen extends AsyncScreen {
     static route = {
         id: 'conductors',
         path: '/conductors',
@@ -32,70 +39,41 @@ export class ConductorsScreen extends BaseScreen {
     };
     id = ConductorsScreen.route.id;
     frameId = 'conductors';
-    rows = [];
-    projectNames = new Map();
     selectedIndex = 0;
     logFor = null;
-    status = '';
-    reading = false;
-    timer = null;
     busyIds = new Set();
-    activation = 0;
     topTab() {
         return { level: 'root', tab: 'conductors' };
     }
-    // GAIA-285 spec D5/D6 — the shared `R` lands here; the 5 s tick passes
-    // `quiet` so only an EXPLICIT reload states its loading in the footer.
-    quietRead = false;
-    get busy() {
-        return this.reading && !this.quietRead;
-    }
     reload(context) {
-        void this.refresh(context);
+        this.retry(context);
     }
-    enter(context) {
-        const activation = ++this.activation;
-        void this.refresh(context, true, activation);
-        this.stopTimer();
-        this.timer = setInterval(() => void this.refresh(context, false, undefined, true), REFRESH_MS);
-        this.timer.unref?.();
+    get rows() {
+        return this.readyValue?.rows ?? [];
+    }
+    async load(context) {
+        if (!context.services)
+            throw new Error('Conductors requires services');
+        const client = context.services.client;
+        const [projectNames, rows] = await Promise.all([
+            listProjectNames(client),
+            listConductorRows(client, {
+                now: context.nowSeconds?.() ?? Math.floor(Date.now() / 1000),
+                exists: existsSync,
+            }),
+        ]);
+        return { rows, projectNames };
     }
-    leave() {
-        this.activation++;
-        this.stopTimer();
+    renderLoading() {
+        return ['Loading conductors…'];
     }
-    /**
-     * GAIA-340 D1 — the list as the renderable tree the screen hands over, and
-     * since GAIA-345 that tree is the SHARED table's (AC 1/2).
-     *
-     * There is no `conductor-list` component any more: the eight columns, the
-     * noun and the empty message are `CONDUCTOR_TABLE`, declared beside the row
-     * mapper that produces the rows. What this screen still owns is the CONTEXT
-     * the columns read — the frame's clock, which conductors have an action in
-     * flight, and the project names its own small read resolved — because none of
-     * those is a property of a `gaia_conductor` record.
-     *
-     * THE OPEN LOG IS NOT A ROW OF THE LIST, so it is not in the table: it is
-     * neither keyed on a conductor nor laid out in the columns, and a log line
-     * keyed under the list's ids could collide with a row's. It stays its own
-     * block below the table, whose lines are keyed by position — honest for a
-     * block replaced wholesale on every read that indexes nothing outside itself.
-     * The wrapper is stated on EVERY frame, log or no log, so the body's root
-     * node keeps one identity across the keypress that opens one.
-     *
-     * MOUNTED WHOLE, so the bound on its nodes is the data's own: one box of 8
-     * cells per conductor, over the conductors of one user on one control plane,
-     * plus at most 40 log lines. `@opentui/core@0.5.1` hands out 16 382 before it
-     * throws, so this screen windows nothing of its own — deliberately, not by
-     * omission.
-     */
-    surface(context) {
-        const open = this.rows.find((row) => row.id === this.logFor);
+    renderReady(data, context) {
+        const open = data.rows.find((row) => row.id === this.logFor);
         const log = open ? logFor(open) : undefined;
-        return columnNode('conductor-list', listTableTree(CONDUCTOR_TABLE, this.rows, {
+        return columnNode('conductor-list', listTableTree(CONDUCTOR_TABLE, data.rows, {
             nowSeconds: context.nowSeconds?.() ?? Math.floor(Date.now() / 1000),
             busyIds: this.busyIds,
-            projectNames: this.projectNames,
+            projectNames: data.projectNames,
         }, { selectedIndex: this.selectedIndex }), ...(log
             ? [
                 textNode({ id: 'conductor-log-gap', content: '' }),
@@ -104,19 +82,26 @@ export class ConductorsScreen extends BaseScreen {
             ]
             : []));
     }
-    present(context) {
-        return presentation(this.surface(context), {
-            selectable: this.rows.length,
+    didLoad(data) {
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, data.rows.length - 1));
+    }
+    chrome(_context) {
+        const rows = this.rows;
+        return {
+            selectable: rows.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each row lands on (GAIA-340 Task 11), read off the
-            // SAME configuration that keys the rows — so the click target and the row
-            // node cannot be spelled two ways (GAIA-345 D2). The log's lines are not
-            // in here, which is the other half of "a log is not a list row".
-            rowIds: listRowIds(CONDUCTOR_TABLE, this.rows),
+            rowIds: listRowIds(CONDUCTOR_TABLE, rows),
             title: 'GAIA conductors',
-            meta: `${this.rows.length} conductor(s)  ·  s start · x stop${this.status ? `  ·  ${this.status}` : ''}`,
-            status: ' ↑↓ select · Enter log · s start · x stop · Tab tabs · q quit ',
-        });
+            meta: `${rows.length} conductor(s)`,
+        };
+    }
+    actions() {
+        return [
+            actionItem('conductors-start', 's', 'start'),
+            actionItem('conductors-stop', 'x', 'stop'),
+            actionItem('conductors-enter', 'Enter', 'log'),
+            actionItem('conductors-tab', 'Tab', 'tabs'),
+        ];
     }
     select(index, context) {
         if (index < 0 || index >= this.rows.length)
@@ -134,6 +119,8 @@ export class ConductorsScreen extends BaseScreen {
         return true;
     }
     handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
         if (input === 's' || input === 'x') {
             void this.act(input === 's' ? 'start' : 'stop', context);
             return true;
@@ -147,87 +134,42 @@ export class ConductorsScreen extends BaseScreen {
         return false;
     }
     reset() {
-        this.leave();
-        this.rows = [];
-        this.projectNames.clear();
         this.selectedIndex = 0;
         this.logFor = null;
-        this.status = '';
         this.busyIds.clear();
-    }
-    async refresh(context, includeProjects = false, activation = this.activation, quiet = false) {
-        if (this.reading || !context.services)
-            return;
-        this.reading = true;
-        this.quietRead = quiet;
-        try {
-            if (includeProjects && this.projectNames.size === 0) {
-                const names = await listProjectNames(context.services.client);
-                if (activation !== this.activation)
-                    return;
-                this.projectNames = names;
-            }
-            const rows = await listConductorRows(context.services.client, {
-                now: context.nowSeconds?.() ?? Math.floor(Date.now() / 1000),
-                exists: existsSync,
-            });
-            if (activation !== this.activation)
-                return;
-            this.rows = rows;
-            this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.rows.length - 1));
-        }
-        finally {
-            this.reading = false;
-            this.quietRead = false;
-        }
-        // After the finally, so the frame this triggers already reads busy=false —
-        // drawn from inside the try it would restate `Loading…` one last time.
-        if (context.isActive())
-            context.requestDraw();
+        super.reset();
     }
     async act(action, context) {
         const row = this.rows[this.selectedIndex];
         if (!row || this.busyIds.has(row.id))
             return;
-        if (!row.isLocal) {
-            this.status = `${row.label} runs on another machine — no action from here`;
-            context.requestDraw();
+        if (!row.isLocal)
             return;
-        }
-        if (action === 'start' && row.derivedStatus === 'running') {
-            this.status = `${row.label} is already running`;
-            context.requestDraw();
+        if (action === 'start' && row.derivedStatus === 'running')
             return;
-        }
         this.busyIds.add(row.id);
-        this.status = `${action}…`;
         context.requestDraw();
         const host = context.services?.conductorProcess ?? createConductorProcessHost();
         try {
-            const result = action === 'start'
-                ? await host.start({
+            if (action === 'start') {
+                await host.start({
                     workspaceRoot: row.workspaceRoot,
                     conductorName: row.conductorName,
-                })
-                : await host.stop({
+                });
+            }
+            else {
+                await host.stop({
                     pid: row.lastPid,
                     workspaceRoot: row.workspaceRoot,
                 });
-            this.status = result.message;
+            }
         }
-        catch (caught) {
-            this.status = caught instanceof Error ? caught.message : String(caught);
+        catch {
+            // Outcome lives in the reloaded row state, not a footer notice.
         }
         finally {
             this.busyIds.delete(row.id);
-            await this.refresh(context);
-            if (context.isActive())
-                context.requestDraw();
+            this.retry(context);
         }
     }
-    stopTimer() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = null;
-    }
 }

package/dist/src/Entity/project/Screen/project-picker.d.ts

@@ -1,4 +1,7 @@
-import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 /**
  * A project that claims the repo.
  *
@@ -15,7 +18,11 @@ export interface ProjectPickerInput {
     readonly repo: string;
 }
 export declare const projectPickerInputContext: import("../../../Routing/context.js").ContextKey<ProjectPickerInput>;
-export declare class ProjectPickerScreen extends BaseScreen {
+/**
+ * Project picker — normal {@link AsyncScreen}. Candidates arrive via navigation
+ * context; refresh is the shared R / ui-refresh path.
+ */
+export declare class ProjectPickerScreen extends AsyncScreen<ProjectPickerInput> {
     readonly frameId = "project-picker";
     topTab(): {
         readonly level: "root";
@@ -31,48 +38,30 @@ export declare class ProjectPickerScreen extends BaseScreen {
         context: (_params: Readonly<Record<string, string>>, state: unknown, base: import("../../../Routing/context.js").ContextBag) => import("../../../Routing/context.js").ContextBag;
     };
     readonly id: string;
-    private candidates;
-    private repo;
     selectedIndex: number;
-    enter(context: ScreenContext): void;
+    reload(context: ScreenContext): void;
+    get candidates(): readonly PickerCandidate[];
+    get repo(): string;
     get rows(): readonly PickerCandidate[];
+    protected load(context: ScreenContext): Promise<ProjectPickerInput>;
+    protected renderLoading(): string[];
     /**
      * The question this screen asks, and the one place it is written.
      *
-     * Both surfaces open with it — the tree as a keyed row above the table, the
-     * pipe as its first line — so composing it twice is how the two would come to
-     * disagree about the repo they name.
+     * Both surfaces open with it — the tree via meta, the pipe as its first line —
+     * so composing it twice is how the two would come to disagree about the repo.
      */
     private headingText;
-    /** The candidate the cursor stands on, clamped: an out-of-range index must
-     *  move the marker, never lose it. */
     private selected;
+    protected renderReady(data: ProjectPickerInput): VNode;
     /**
      * F5 — the pipe's own output, and it stays `string[]`.
      *
-     * GAIA-345 D7/D8 — built from the SAME configuration the tree is, through
-     * `listTableRows` and `lineText`, plus the two heading lines and the trailing
-     * hint, which are the screen's and not rows of the list. The bytes are
-     * unchanged by construction rather than by a comparison somebody has to
-     * remember to make, and `tests/Entity/project/Screen/project-picker.test.ts`
-     * pins them line for line against the pre-conversion capture.
+     * GAIA-345 D7/D8 — built from the SAME configuration the tree is.
      */
     renderNonInteractive(): string[];
-    /**
-     * The picker's body: the question, a blank, then the list (GAIA-345 D8).
-     *
-     * The two heading rows are composed AROUND the table's node because they are
-     * not rows of it — they name no candidate, they are not selectable, and they
-     * carry no entry in `rowIds`. That is also what the old `selRow` offset of 2
-     * was compensating for before the kernel started finding the cursor by node.
-     *
-     * MOUNTED WHOLE — no window of its own, and the bound is named rather than
-     * assumed: a row is one `gaia_project` that claims the cwd's remote, which is
-     * the multisite topology GAIA-126/137 designs for. That is a handful of sites
-     * per repo, against `@opentui/core@0.5.1`'s ceiling of 16 382 renderables.
-     */
-    private surface;
-    present(_context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    protected chrome(_context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
     handleInput(input: string, context: ScreenContext): boolean;
     activate(index: number, context: ScreenContext): boolean;
     select(index: number, context: ScreenContext): boolean;

package/dist/src/Entity/project/Screen/project-picker.js

@@ -11,10 +11,10 @@
 // GAIA-345 D8 — `Component/project-picker/` is GONE and its two survivors live
 // here, in their only consumer: the candidate type and the one-column table the
 // two surfaces are both made of.
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { lineText, } from '../../../Component/section-list/index.js';
-import { columnNode, textNode } from '../../../lib/vnode.js';
 import { defineContext } from '../../../Routing/context.js';
-import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { listRowIds, listTableRows, listTableTree, } from '../../collection.js';
 /**
  * The picker as a configuration (GAIA-345 D8) — one column, and NO HEADER.
@@ -54,7 +54,11 @@ const clamp = (selected, length) => {
         return 0;
     return Math.max(0, Math.min(Math.trunc(selected), length - 1));
 };
-export class ProjectPickerScreen extends BaseScreen {
+/**
+ * Project picker — normal {@link AsyncScreen}. Candidates arrive via navigation
+ * context; refresh is the shared R / ui-refresh path.
+ */
+export class ProjectPickerScreen extends AsyncScreen {
     frameId = 'project-picker';
     topTab() {
         return { level: 'root', tab: 'projects' };
@@ -69,47 +73,53 @@ export class ProjectPickerScreen extends BaseScreen {
             : base,
     };
     id = ProjectPickerScreen.route.id;
-    candidates = [];
-    repo = '';
     selectedIndex = 0;
-    enter(context) {
-        const input = context.contexts?.has(projectPickerInputContext)
-            ? context.contexts.get(projectPickerInputContext)
-            : undefined;
-        if (input) {
-            this.candidates = [...input.candidates];
-            this.repo = input.repo;
-            this.selectedIndex = 0;
-        }
-        context.requestDraw();
+    reload(context) {
+        this.retry(context);
+    }
+    get candidates() {
+        return this.readyValue?.candidates ?? [];
+    }
+    get repo() {
+        return this.readyValue?.repo ?? '';
     }
     get rows() {
         return this.candidates;
     }
+    load(context) {
+        if (context.contexts?.has(projectPickerInputContext)) {
+            const input = context.contexts.get(projectPickerInputContext);
+            return Promise.resolve({
+                candidates: [...input.candidates],
+                repo: input.repo,
+            });
+        }
+        return Promise.resolve({ candidates: [], repo: '' });
+    }
+    renderLoading() {
+        return ['Loading projects…'];
+    }
     /**
      * The question this screen asks, and the one place it is written.
      *
-     * Both surfaces open with it — the tree as a keyed row above the table, the
-     * pipe as its first line — so composing it twice is how the two would come to
-     * disagree about the repo they name.
+     * Both surfaces open with it — the tree via meta, the pipe as its first line —
+     * so composing it twice is how the two would come to disagree about the repo.
      */
     headingText() {
         return `Several gaia projects claim ${this.repo} — which one?`;
     }
-    /** The candidate the cursor stands on, clamped: an out-of-range index must
-     *  move the marker, never lose it. */
     selected() {
         return this.candidates[clamp(this.selectedIndex, this.candidates.length)];
     }
+    renderReady(data) {
+        return listTableTree(PICKER_TABLE, data.candidates, this.selected(), {
+            selectedIndex: clamp(this.selectedIndex, data.candidates.length),
+        });
+    }
     /**
      * F5 — the pipe's own output, and it stays `string[]`.
      *
-     * GAIA-345 D7/D8 — built from the SAME configuration the tree is, through
-     * `listTableRows` and `lineText`, plus the two heading lines and the trailing
-     * hint, which are the screen's and not rows of the list. The bytes are
-     * unchanged by construction rather than by a comparison somebody has to
-     * remember to make, and `tests/Entity/project/Screen/project-picker.test.ts`
-     * pins them line for line against the pre-conversion capture.
+     * GAIA-345 D7/D8 — built from the SAME configuration the tree is.
      */
     renderNonInteractive() {
         return [
@@ -120,46 +130,27 @@ export class ProjectPickerScreen extends BaseScreen {
             'Run gaia ui project:<name> to choose directly.',
         ];
     }
-    /**
-     * The picker's body: the question, a blank, then the list (GAIA-345 D8).
-     *
-     * The two heading rows are composed AROUND the table's node because they are
-     * not rows of it — they name no candidate, they are not selectable, and they
-     * carry no entry in `rowIds`. That is also what the old `selRow` offset of 2
-     * was compensating for before the kernel started finding the cursor by node.
-     *
-     * MOUNTED WHOLE — no window of its own, and the bound is named rather than
-     * assumed: a row is one `gaia_project` that claims the cwd's remote, which is
-     * the multisite topology GAIA-126/137 designs for. That is a handful of sites
-     * per repo, against `@opentui/core@0.5.1`'s ceiling of 16 382 renderables.
-     */
-    surface() {
-        return columnNode('project-picker', textNode({
-            id: 'project-picker-heading',
-            content: this.headingText(),
-        }), textNode({ id: 'project-picker-heading-gap', content: '' }), listTableTree(PICKER_TABLE, this.candidates, this.selected(), {
-            selectedIndex: clamp(this.selectedIndex, this.candidates.length),
-        }));
-    }
-    present(_context) {
-        return presentation(this.surface(), {
+    chrome(_context) {
+        return {
             selectable: this.candidates.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each candidate lands on (GAIA-340 Task 11), read
-            // off the SAME configuration that keys the rows — which retires the
-            // hand-spelled `project-picker-candidate-<id>` the screen used to publish
-            // beside a row keyed the same way by a second expression (GAIA-345 D2).
             rowIds: listRowIds(PICKER_TABLE, this.candidates),
             title: 'Which project?',
-            meta: `${this.candidates.length} project(s) claim ${this.repo}  ·  Enter open · Esc dashboard`,
-            status: ' ↑↓ select · Enter open · Esc dashboard · q quit ',
-        });
+            meta: `${this.candidates.length} project(s) claim ${this.repo} · ${this.headingText()}`,
+        };
+    }
+    actions() {
+        return [actionItem('picker-enter', 'Enter', 'open')];
     }
     handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
         if (input === 'j' || input === 'down')
             this.selectedIndex = Math.min(this.selectedIndex + 1, this.candidates.length - 1);
         else if (input === 'k' || input === 'up')
             this.selectedIndex = Math.max(this.selectedIndex - 1, 0);
+        else if (input === 'enter')
+            return this.activate(this.selectedIndex, context);
         else
             return false;
         context.requestDraw();
@@ -184,8 +175,7 @@ export class ProjectPickerScreen extends BaseScreen {
         return true;
     }
     reset() {
-        this.candidates = [];
-        this.repo = '';
         this.selectedIndex = 0;
+        super.reset();
     }
 }

package/dist/src/Entity/project/Screen/projects-screen.d.ts

@@ -1,6 +1,7 @@
 import type { VNode } from '@opentui/core';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
-import { type ScreenContext } from '../../../Screen/screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 import { type ProjectRow } from '../Data/projects.js';
 /**
  * GAIA-340 D1 — the ready page is a renderable TREE; `loading` and `error` are
@@ -44,7 +45,8 @@ export declare class ProjectsScreen extends AsyncScreen<ProjectRow[]> {
     protected load(context: ScreenContext): Promise<ProjectRow[]>;
     protected renderLoading(): string[];
     protected renderReady(rows: ProjectRow[]): VNode;
-    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
     activate(index: number, context: ScreenContext): boolean;
     select(index: number, context: ScreenContext): boolean;
     handleInput(input: string, context: ScreenContext): boolean;

package/dist/src/Entity/project/Screen/projects-screen.js

@@ -1,6 +1,6 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { ListCursor } from '../../../lib/cursor.js';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
-import { presentation } from '../../../Screen/screen.js';
 import { listRowIds, listTableTree } from '../../collection.js';
 import { loadProjectRows, PROJECT_TABLE, } from '../Data/projects.js';
 /**
@@ -69,19 +69,22 @@ export class ProjectsScreen extends AsyncScreen {
             selectedIndex: this.selectedIndex,
         });
     }
-    present(context) {
+    chrome(context) {
         const rows = this.rows;
-        return presentation(this.surface(context), {
+        return {
             selectable: rows.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each row lands on (GAIA-340 Task 11), read off the
-            // SAME configuration that keys the rows — so the click target and the row
-            // node cannot be spelled two ways (GAIA-345 D2).
+            // Click targets match listTableTree row ids (GAIA-345 D2).
             rowIds: listRowIds(PROJECT_TABLE, rows),
             title: 'GAIA projects',
             meta: `${rows.length} registered project(s)  ·  ${context.services?.baseUrl ?? ''}`,
-            status: ' ↑↓ select · Enter open · n new · Tab tabs · q quit ',
-        });
+        };
+    }
+    actions() {
+        return [
+            actionItem('projects-new', 'n', 'new'),
+            actionItem('projects-tab', 'Tab', 'tabs'),
+        ];
     }
     activate(index, context) {
         const row = this.readyValue?.[index];

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

@@ -8,12 +8,20 @@
 //
 // GAIA-340 D1 — the FIRST block to hand its content over as renderables rather
 // than as rows of text: the sections are built once, keyed, and turned into a
-// VNode tree. It shares the minimal-markdown rule with the blocks that still
-// compose rows (`markdownRow`), so a body line renders the same either way.
+// VNode tree.
+//
+// GAIA-372 D9 — IT IS `markdownRow`'S ONLY CALLER NOW, and the ATX-only rule is
+// THIS SCREEN'S rule rather than a rule shared with the ticket detail. A run log
+// entry is MACHINE OUTPUT, not authored Markdown: an agent line full of `*`, `_`
+// and backticks would be re-styled and have characters deleted by a renderer
+// meant for prose. So the log keeps the narrow rule while the ticket detail's
+// `gaia_rich` bodies go through `Component/markdown/`. Nothing about this screen's
+// behaviour changed; routing the log through the full subset is a separate
+// ticket, not a silent side effect of that one.
 //
 // Read-only by design (the ticket's own out-of-scope list): no write, no edit, no
 // navigation out of it except Esc.
-import { markdownRow } from '../../../../Component/section-list/index.js';
+import { markdownRow } from '../../../../Component/markdown/index.js';
 import { asString } from '../../../../lib/format.js';
 import { columnNode, textNode } from '../../../../lib/vnode.js';
 /** The sideloaded `gaia_run` with this id, or undefined. */
@@ -208,10 +216,10 @@ function flatRows(document, runId) {
         { key: `section-${section.key}`, text: section.heading, bold: true },
         ...section.rows.map((entry) => ({
             key: entry.key,
-            // The same minimal-markdown rule the row surface applies, from the same
-            // function — an ATX heading inside a body renders bold with its markers
-            // stripped, and a log line starting with `#` must not render one way on
-            // screen and another way in a pipe.
+            // The log's OWN minimal-markdown rule (GAIA-372 D9): an ATX heading inside
+            // a log entry renders bold with its markers stripped, and a log line
+            // starting with `#` must not render one way on screen and another way in a
+            // pipe. Nothing else in an entry is parsed, deliberately — see the header.
             ...markdownRow(entry.text),
         })),
         // The blank row between two sections, which the flattened surface pushed

package/dist/src/Entity/run/Data/query.d.ts

@@ -20,3 +20,13 @@ export declare function buildRunQueryParams(projectId: string, criteria: RunCrit
     size: number;
     index: number;
 }): DrupalJsonApiParams;
+/**
+ * Build the JSON:API query for one assignee's runs (GAIA-377 D2).
+ *
+ * Runs carry no user of their own — attribution is
+ * `ticket_id.assignee_user_id.id`, matching StatisticsCounter::SOURCES.
+ */
+export declare function buildUserRunQueryParams(userId: string, criteria: RunCriteria, page?: {
+    size: number;
+    index: number;
+}): DrupalJsonApiParams;

package/dist/src/Entity/run/Data/query.js

@@ -25,6 +25,22 @@ export function describeCriteria(criteria) {
 export function buildRunQueryParams(projectId, criteria, page = { size: LIST_PAGE_SIZE, index: 0 }) {
     const params = new DrupalJsonApiParams();
     params.addFilter('ticket_id.project_id.id', projectId);
+    applyRunCriteria(params, criteria, page);
+    return params;
+}
+/**
+ * Build the JSON:API query for one assignee's runs (GAIA-377 D2).
+ *
+ * Runs carry no user of their own — attribution is
+ * `ticket_id.assignee_user_id.id`, matching StatisticsCounter::SOURCES.
+ */
+export function buildUserRunQueryParams(userId, criteria, page = { size: LIST_PAGE_SIZE, index: 0 }) {
+    const params = new DrupalJsonApiParams();
+    params.addFilter('ticket_id.assignee_user_id.id', userId);
+    applyRunCriteria(params, criteria, page);
+    return params;
+}
+function applyRunCriteria(params, criteria, page) {
     if (criteria.closed !== null)
         params.addFilter('closed', criteria.closed ? '1' : '0');
     params.addInclude(['ticket_id']);
@@ -37,5 +53,4 @@ export function buildRunQueryParams(projectId, criteria, page = { size: LIST_PAG
     // Page one carries no offset, so its query is the shortest it can be.
     if (page.index > 0)
         params.addPageOffset(page.index * page.size);
-    return params;
 }