@adcops/autocore-react 3.3.105 → 3.3.109

package/src/components/tis/ResultHistoryTable.tsx

@@ -6,6 +6,8 @@ import { Tag } from 'primereact/tag';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 import { useTis } from './TisProvider';
+import { SampleSummaryPanel } from './SampleSummaryPanel';
+import './ResultHistoryTable.css';
 
 export interface ResultHistoryTableProps {
     /**
@@ -72,6 +74,7 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
     const [loading, setLoading] = useState(false);
     const [downloading, setDownloading] = useState<InFlight | null>(null);
     const [projectBusy, setProjectBusy] = useState<ProjectDownloadKind | null>(null);
+    const [excludingRunId, setExcludingRunId] = useState<string | null>(null);
     const { invoke } = useContext(EventEmitterContext);
 
     const loadTests = async () => {
@@ -169,6 +172,34 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
         }
     };
 
+    // Toggle a run's inclusion in cross-test aggregation. Excluded runs are
+    // kept on disk (not deleted) but dropped from avg/min/max/stddev/count
+    // results for their sample group. The server recomputes + rebroadcasts
+    // the sample summary on success.
+    const handleToggleExclude = async (rowData: any) => {
+        const runId = rowData?.run_id;
+        const rowMethodId = rowData?.method_id ?? methodId;
+        if (!runId || !rowMethodId || !projectId) return;
+        const nextExcluded = rowData?.excluded !== true;
+        setExcludingRunId(runId);
+        try {
+            const resp: any = await invoke('tis.set_test_excluded' as any, MessageType.Request, {
+                project_id: projectId, method_id: rowMethodId, run_id: runId, excluded: nextExcluded,
+            } as any);
+            if (!resp?.success) {
+                alert(`Failed to ${nextExcluded ? 'exclude' : 'include'} ${runId}` +
+                      (resp?.error_message ? `: ${resp.error_message}` : ''));
+                return;
+            }
+            await loadTests();
+        } catch (err) {
+            console.error('Failed to toggle exclusion', err);
+            alert(`Exclude toggle failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+            setExcludingRunId(null);
+        }
+    };
+
     const handleProjectDownload = async (kind: ProjectDownloadKind) => {
         if (!projectId) return;
         const topic = kind === 'report' ? 'tis.export_project_csv'
@@ -284,6 +315,11 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                 </div>
             </div>
 
+            {/* Per-sample cross-test rollup. Renders nothing unless a method
+                declares aggregate results_fields, so projects without the
+                feature see the history table unchanged. */}
+            <SampleSummaryPanel projectId={projectId} methodId={methodId} />
+
             <DataTable
                 value={tests}
                 loading={loading}
@@ -294,6 +330,7 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                 scrollHeight="flex"
                 tableStyle={{ minWidth: 0 }}
                 style={{ width: '100%' }}
+                rowClassName={(rowData: any) => (rowData?.excluded === true ? 'tis-row-excluded' : '')}
                 selectionMode="single"
                 onSelectionChange={(e: any) => {
                     const row = e.value;
@@ -335,6 +372,30 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                     }}
                     style={{ minWidth: '8rem' }}
                 />
+                <Column
+                    header="Include"
+                    style={{ width: '8rem' }}
+                    body={(rowData) => {
+                        const isExcluded = rowData?.excluded === true;
+                        const isBusy = excludingRunId === rowData.run_id;
+                        return (
+                            <Button
+                                icon={isBusy ? 'pi pi-spin pi-spinner'
+                                             : (isExcluded ? 'pi pi-eye-slash' : 'pi pi-check')}
+                                label={isExcluded ? 'Excluded' : 'Included'}
+                                size="small"
+                                outlined
+                                severity={isExcluded ? 'warning' : 'success'}
+                                disabled={excludingRunId !== null}
+                                onClick={() => handleToggleExclude(rowData)}
+                                tooltip={isExcluded
+                                    ? 'Excluded from cross-test results — click to include'
+                                    : 'Included in cross-test results — click to exclude'}
+                                tooltipOptions={{ position: 'left' }}
+                            />
+                        );
+                    }}
+                />
                 <Column
                     header="Download"
                     style={{ width: '14rem' }}

package/src/components/tis/SampleSummaryPanel.tsx

@@ -0,0 +1,171 @@
+import React, { useState, useEffect, useContext } from 'react';
+import { DataTable } from 'primereact/datatable';
+import { Column } from 'primereact/column';
+import { Dropdown } from 'primereact/dropdown';
+import { EventEmitterContext } from '../../core/EventEmitterContext';
+import { MessageType } from '../../hub/CommandMessage';
+import { useTis } from './TisProvider';
+
+/**
+ * Per-method cross-test rollup, one row per sample_id.
+ *
+ * Distinct from the per-run results overlay in <TestDataView>: this panel
+ * answers "across every run of sample X, what's the avg/min/max/stddev/count?"
+ * — the question operators ask when a sample is run repeatedly. Backed by
+ * `tis.sample_summaries`; refreshes on the server's `tis.sample_summary_updated`
+ * broadcast (a sibling finishing or an exclusion toggle).
+ *
+ * Renders nothing unless some method in the project declares aggregate
+ * results_fields. When `methodId` is omitted and more than one method has
+ * aggregates, a small method picker is shown.
+ */
+export interface SampleSummaryPanelProps {
+    /** Defaults to the active project from <TisProvider>. */
+    projectId?: string;
+    /** Lock the panel to one method. When omitted, the user picks among
+     *  methods that declare aggregate results_fields. */
+    methodId?: string;
+}
+
+interface SummaryRow {
+    sample_id: string;
+    summary: Record<string, unknown>;
+    included_count: number;
+    excluded_count: number;
+}
+
+interface AggColumn {
+    name: string;
+    header: string;
+    scale?: number;
+}
+
+export const SampleSummaryPanel: React.FC<SampleSummaryPanelProps> = (props) => {
+    const tis = useTis();
+    const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
+    const projectId = props.projectId ?? tis.selection.projectId ?? undefined;
+
+    // Methods that actually declare an aggregate results_field — the only
+    // ones worth showing here.
+    const methodsWithAggregates = React.useMemo(() => {
+        return Object.entries(tis.schemas)
+            .filter(([, m]) => ((m?.results_fields ?? []) as any[]).some((f) => f?.aggregate))
+            .map(([id]) => id);
+    }, [tis.schemas]);
+
+    const [picked, setPicked] = useState<string | undefined>(undefined);
+    const methodId = props.methodId ?? picked ?? methodsWithAggregates[0];
+
+    // Keep the local pick valid as schemas load / change.
+    useEffect(() => {
+        if (props.methodId) return;
+        if (!picked || !methodsWithAggregates.includes(picked)) {
+            setPicked(methodsWithAggregates[0]);
+        }
+    }, [props.methodId, picked, methodsWithAggregates]);
+
+    const [rows, setRows] = useState<SummaryRow[]>([]);
+    const [loading, setLoading] = useState(false);
+
+    // Columns come from the schema's aggregate results_fields (label + units),
+    // so empty-but-declared columns still show with a blank cell.
+    const aggColumns: AggColumn[] = React.useMemo(() => {
+        const schema = methodId ? (tis.schemas[methodId] as any) : undefined;
+        const fields: any[] = (schema?.results_fields ?? []).filter((f: any) => f?.aggregate);
+        return fields.map((f) => ({
+            name: f.name,
+            header: (f.label || f.name) + (f.units ? ` [${f.units}]` : ''),
+            scale: typeof f.scale === 'number' ? f.scale : undefined,
+        }));
+    }, [tis.schemas, methodId]);
+
+    useEffect(() => {
+        if (!projectId || !methodId) { setRows([]); return; }
+        let cancelled = false;
+        const load = async () => {
+            setLoading(true);
+            try {
+                const resp: any = await invoke('tis.sample_summaries' as any, MessageType.Request,
+                    { project_id: projectId, method_id: methodId } as any);
+                if (!cancelled && resp?.success) setRows(resp.data?.summaries ?? []);
+            } catch (err) {
+                console.error('Failed to load sample summaries', err);
+            } finally {
+                if (!cancelled) setLoading(false);
+            }
+        };
+        load();
+        // Any rollup change for this project+method refreshes the whole panel
+        // (cheap; also picks up brand-new sample groups the broadcast can't
+        // patch in place). Also follow the live run lifecycle like the table.
+        const onSummary = (payload: any) => {
+            if (payload?.project_id === projectId && payload?.method_id === methodId) load();
+        };
+        const id = subscribe('tis.sample_summary_updated', onSummary);
+        return () => { cancelled = true; unsubscribe(id); };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [projectId, methodId, tis.state.activeRunId, tis.state.active]);
+
+    // Feature not configured for this project → render nothing.
+    if (methodsWithAggregates.length === 0) return null;
+
+    const fmt = (v: unknown, scale?: number): string => {
+        if (v === null || v === undefined) return '—';
+        if (typeof v === 'number') {
+            if (!Number.isFinite(v)) return String(v);
+            const scaled = typeof scale === 'number' && scale !== 0 ? v * scale : v;
+            return Number.parseFloat(scaled.toPrecision(6)).toString();
+        }
+        return String(v);
+    };
+
+    return (
+        <div style={{ width: '100%', maxWidth: '100%', overflow: 'hidden', boxSizing: 'border-box', marginBottom: '1rem' }}>
+            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.5rem', gap: '0.5rem', flexWrap: 'wrap' }}>
+                <h3 style={{ margin: 0 }}>Sample Summary</h3>
+                {!props.methodId && methodsWithAggregates.length > 1 && (
+                    <Dropdown
+                        value={methodId}
+                        options={methodsWithAggregates.map((id) => ({ label: id, value: id }))}
+                        onChange={(e) => setPicked(e.value)}
+                        style={{ minWidth: '12rem' }}
+                    />
+                )}
+            </div>
+            <DataTable
+                value={rows}
+                loading={loading}
+                dataKey="sample_id"
+                emptyMessage="No samples yet."
+                scrollable
+                tableStyle={{ minWidth: 0 }}
+                style={{ width: '100%' }}
+                size="small"
+                stripedRows
+            >
+                <Column field="sample_id" header="Sample ID" sortable style={{ minWidth: '8rem' }} />
+                {aggColumns.map((c) => (
+                    <Column
+                        key={c.name}
+                        header={c.header}
+                        bodyStyle={{ fontVariantNumeric: 'tabular-nums', textAlign: 'right' }}
+                        style={{ minWidth: '7rem' }}
+                        body={(row: SummaryRow) => fmt(row.summary?.[c.name], c.scale)}
+                    />
+                ))}
+                <Column
+                    header="# Tests"
+                    bodyStyle={{ textAlign: 'right' }}
+                    style={{ width: '6rem' }}
+                    body={(row: SummaryRow) => row.included_count}
+                />
+                <Column
+                    header="Excluded"
+                    bodyStyle={{ textAlign: 'right' }}
+                    style={{ width: '6rem' }}
+                    body={(row: SummaryRow) => (row.excluded_count > 0 ? row.excluded_count : '—')}
+                />
+            </DataTable>
+        </div>
+    );
+};

package/src/components/tis/TestDataView.tsx

@@ -199,6 +199,10 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [meta, setMeta]       = useState<any>(null);
     const [cycles, setCycles]   = useState<any[]>([]);
     const [results, setResults] = useState<any>({});
+    // Server-derived cross-test aggregate results_fields (avg/min/max/stddev/
+    // count over the sample group). Overlaid on `results` for display — these
+    // fields are never in the per-test results blob.
+    const [sampleSummary, setSampleSummary] = useState<any>({});
     const [rawOpen, setRawOpen] = useState(false);
     const [configOpen, setConfigOpen] = useState(false);
 
@@ -351,6 +355,45 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [projectId, methodId, runId, throttleMs]);
 
+    // -----------------------------------------------------------------
+    // Cross-test aggregate summary (sample-group rollup)
+    //
+    // Keyed by sample_id, not run_id: every run of the same sample shares
+    // the rollup. Fetched once per sample and refreshed on the server's
+    // sample_summary_updated broadcast (fired when a sibling finishes or its
+    // exclusion is toggled). Empty unless the method declares aggregate
+    // results_fields.
+    // -----------------------------------------------------------------
+    const sampleId: string =
+        (typeof meta?.sample_id === 'string' && meta.sample_id)
+            ? meta.sample_id
+            : (typeof meta?.config?.sample_id === 'string' ? meta.config.sample_id : '');
+
+    useEffect(() => {
+        if (!projectId || !methodId || !sampleId) { setSampleSummary({}); return; }
+        let cancelled = false;
+        const fetchSummary = async () => {
+            try {
+                const resp: any = await invoke(
+                    'tis.sample_summary' as any, MessageType.Request as any,
+                    { project_id: projectId, method_id: methodId, sample_id: sampleId } as any);
+                if (!cancelled && resp?.success) setSampleSummary(resp.data?.summary ?? {});
+            } catch (e) {
+                console.error('[TestDataView] sample_summary fetch failed', e);
+            }
+        };
+        fetchSummary();
+        const onSummary = (payload: any) => {
+            if (payload?.project_id === projectId
+                && payload?.method_id === methodId
+                && payload?.sample_id === sampleId) {
+                setSampleSummary(payload.summary ?? {});
+            }
+        };
+        const id = subscribe('tis.sample_summary_updated', onSummary);
+        return () => { cancelled = true; unsubscribe(id); };
+    }, [projectId, methodId, sampleId, invoke, subscribe, unsubscribe]);
+
     // -----------------------------------------------------------------
     // Raw-trace data fetch (lazy)
     //
@@ -721,7 +764,10 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
 
             <div className="p-card" style={{ padding: '1rem' }}>
                 <h3 style={{ marginTop: 0 }}>Results</h3>
-                <ResultsGrid schema={schema.results_fields} values={results} />
+                {/* Overlay the server-derived cross-test rollup (avg/min/max/
+                    stddev/count) onto this run's own results. Aggregate fields
+                    are never in `results` — the summary is their only source. */}
+                <ResultsGrid schema={schema.results_fields} values={{ ...results, ...sampleSummary }} />
             </div>
 
             {/*

package/src/components/tis/TestSetupForm.tsx

@@ -60,6 +60,11 @@ export interface TestFieldDef {
      *  Cycle and results values are scaled by the corresponding paths
      *  in TestDataView; the server scales CSV exports too. */
     scale?: number;
+    /** Optional inclusive bounds (display units, same convention as `default`
+     *  and `scale`) for the operator's numeric entry. The numeric input
+     *  rejects values outside `[min, max]`; non-numeric fields ignore them. */
+    min?: number;
+    max?: number;
     /** Optional fixed set of choices. When present, the field renders
      *  as a dropdown and the operator must pick one of the declared
      *  values rather than typing freely. Each entry is either a bare
@@ -186,6 +191,62 @@ const displayToRaw = (display: any, scale: number | undefined): any => {
 const hasDescription = (f: TestFieldDef): boolean =>
     typeof f.description === 'string' && f.description.length > 0;
 
+/** Matches an FQDN default token like `${gm.safe_speed}` (whole-string). */
+const DEFAULT_TOKEN_RE = /^\$\{\s*([^}]+?)\s*\}$/;
+
+/**
+ * Resolve a field's `default` to a RAW value for seeding stagedConfig at
+ * method-load time. Two forms:
+ *
+ *  - **Literal** (number/string/bool) — authored in DISPLAY units, converted
+ *    to raw via the field's `scale` (the long-standing convention).
+ *  - **FQDN token** `${<fqdn>}` — snapshots the *current* value of that tag
+ *    (read live from the controller, already RAW). Lets an author tie a
+ *    config_field's load-time default to a value on screen — e.g. a "safe
+ *    speed" the operator set — so re-loading the method always re-seeds the
+ *    safe value, while still letting the operator override it afterwards.
+ *    Distinct from `source`, which is a live two-way binding; a token default
+ *    is a one-time seed.
+ *
+ * Returns `{ raw, ok }`. `ok === false` means an `${fqdn}` token whose tag is
+ * unknown or has no value yet — the caller skips seeding that field rather
+ * than writing garbage.
+ */
+const resolveDefaultRaw = (
+    field: TestFieldDef,
+    findTagByFqdn: (fqdn: string) => { tagName: string } | undefined,
+    rawValues: Record<string, unknown>,
+): { raw: any; ok: boolean } => {
+    const d = field.default;
+    if (typeof d === 'string') {
+        const m = d.match(DEFAULT_TOKEN_RE);
+        if (m) {
+            const tag = findTagByFqdn(m[1]);
+            const v = tag ? rawValues[tag.tagName] : undefined;
+            if (v === undefined || v === null) return { raw: undefined, ok: false };
+            return { raw: v, ok: true }; // tag value is already RAW
+        }
+    }
+    return { raw: displayToRaw(d, field.scale), ok: true };
+};
+
+/**
+ * Range check for a numeric field's stored RAW value against its declared
+ * `min`/`max` (authored in DISPLAY units). Returns a short human-readable
+ * reason ("must be ≥ 5") when out of range, or null when in range / not
+ * applicable (empty value, no bounds, or non-numeric). Storage is raw, so we
+ * convert to display first to compare against the author's display-unit bounds.
+ */
+const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
+    if (raw === undefined || raw === '' || raw === null) return null;
+    if (f.min == null && f.max == null) return null;
+    const disp = Number(rawToDisplay(Number(raw), f.scale));
+    if (!Number.isFinite(disp)) return null;
+    if (f.min != null && disp < f.min) return `must be ≥ ${f.min}`;
+    if (f.max != null && disp > f.max) return `must be ≤ ${f.max}`;
+    return null;
+};
+
 /**
  * Normalise a field's `options` (bare scalars and/or `{label, value}`
  * pairs) into the `{ label, value }[]` shape PrimeReact's Dropdown
@@ -401,13 +462,31 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
                 if (field.default === undefined || field.default === null) continue;
+                // A source-bound field's default must only SEED when GM has no
+                // value yet — never clobber an existing one. The defaults effect
+                // re-runs after every completed run (clearStagedConfig resets the
+                // marker), so without this guard the operator's setting (e.g.
+                // cof_window_pct) is reset to the literal default on each load.
+                // When GM already holds a value, keep it; the source-seed effect
+                // below mirrors the live value into stagedConfig.
+                if (field.source) {
+                    const liveTag = findTagByFqdn(field.source);
+                    const liveVal = liveTag ? rawValues[liveTag.tagName] : undefined;
+                    if (liveVal !== undefined && liveVal !== null) continue;
+                }
+                // Resolve the default to a RAW value. Literals are authored in
+                // DISPLAY units (converted via `scale`); an `${fqdn}` token
+                // snapshots that tag's current (already-raw) value so a
+                // load-time default can track a value on screen. A token that
+                // can't resolve (tag unknown / not yet read) leaves the field
+                // unset rather than seeding garbage.
+                const { raw: rawDefault, ok } = resolveDefaultRaw(field, findTagByFqdn, rawValues);
+                if (!ok) {
+                    console.warn(
+                        `[TestSetupForm] default token ${String(field.default)} for "${field.name}" did not resolve; leaving it unset.`);
+                    continue;
+                }
                 if (next === prev) next = { ...prev };
-                // Schema defaults are authored in DISPLAY units (per
-                // the agreed convention) so the value the author reads
-                // in project.json matches the field's `units` label.
-                // Convert to raw before storing in stagedConfig / GM
-                // so the rest of the pipeline sees the canonical value.
-                const rawDefault = displayToRaw(field.default, field.scale);
                 next[field.name] = rawDefault;
                 if (field.source) {
                     // Mirror handleFieldChange: write to GM so the
@@ -430,7 +509,7 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         });
 
         tis.setConfigurationName(firstConfig ? firstConfig.name : '');
-    }, [schema, methodId, write, tis.defaultsAppliedForMethod, tis.markDefaultsAppliedForMethod, tis.setConfigurationName]);
+    }, [schema, methodId, write, rawValues, findTagByFqdn, tis.defaultsAppliedForMethod, tis.markDefaultsAppliedForMethod, tis.setConfigurationName]);
 
     // Seed and live-update config_fields that declare a `source`.
     useEffect(() => {
@@ -467,10 +546,10 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
 
         for (const field of schema.config_fields) {
             if (field.name === 'sample_id') continue;
-            if (field.required) {
-                const v = config[field.name];
-                if (v === undefined || v === '' || v === null) { valid = false; break; }
-            }
+            const v = config[field.name];
+            const empty = v === undefined || v === '' || v === null;
+            if (field.required && empty) { valid = false; break; }
+            if (rangeIssue(field, v)) { valid = false; break; }
         }
 
         setIsValid(valid);
@@ -501,9 +580,11 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     ]);
 
     const isFieldValid = (field: TestFieldDef) => {
-        if (!field.required) return true;
         const v = config[field.name];
-        return v !== undefined && v !== '' && v !== null;
+        const empty = v === undefined || v === '' || v === null;
+        if (field.required && empty) return false;
+        if (rangeIssue(field, v)) return false;
+        return true;
     };
 
     const handleSampleIdChange = (value: string) => {
@@ -595,6 +676,11 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                         value={config[field.name] != null
                             ? Number(rawToDisplay(Number(config[field.name]), field.scale))
                             : null}
+                        // min/max are authored in display units, matching the
+                        // value rendered above — ValueInput rejects out-of-range
+                        // entries on accept.
+                        min={field.min}
+                        max={field.max}
                         onValueChanged={(val) => handleFieldChange(field, val)}
                         className={!valid ? 'p-invalid' : ''}
                     />
@@ -682,11 +768,14 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         if (schema) {
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
-                if (!field.required) continue;
                 const v = config[field.name];
-                if (v === undefined || v === '' || v === null) {
+                const empty = v === undefined || v === '' || v === null;
+                if (field.required && empty) {
                     issues.push(`Required field "${labelOf(field)}" is empty.`);
+                    continue;
                 }
+                const re = rangeIssue(field, v);
+                if (re) issues.push(`"${labelOf(field)}" ${re}.`);
             }
         }
         return issues;

package/src/components/tis-editor/editor/FieldArrayEditor.tsx

@@ -17,7 +17,14 @@ const DESCRIPTIONS: Record<FieldArrayKey, string> = {
     project_fields: 'System-level fields (operator, station). Filled by the HMI but not cycled.',
     config_fields:  'Operator-input config (speeds, loads). Snapshotted into test.json on start.',
     cycle_fields:   'Per-cycle capture. One row appended to cycles.jsonl per cycle.',
-    results_fields: 'Post-test summary (min/max/avg, pass/fail). Written once at finish.',
+    results_fields: 'Post-test summary (min/max/avg, pass/fail). Written once at finish. A field can also be a cross-test Aggregate (avg/min/max/stddev/count over tests sharing a sample_id).',
+};
+
+/** Short human label for a field's aggregate spec, e.g. "avg(cof)" / "count". */
+const aggregateLabel = (f: TestField): string => {
+    const a = f.aggregate;
+    if (!a) return '';
+    return a.fn === 'count' ? 'count' : `${a.fn}(${a.of ?? '?'})`;
 };
 
 export interface FieldArrayEditorProps {
@@ -116,6 +123,13 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                         style={{ width: '4rem' }}
                     />
                     <Column field="label" header="Label" />
+                    {arrayKey === 'results_fields' && (
+                        <Column
+                            header="Aggregate"
+                            body={(r: TestField) => aggregateLabel(r)}
+                            style={{ width: '8rem' }}
+                        />
+                    )}
                     <Column header="" body={rowActions} style={{ width: '10rem' }} />
                 </DataTable>
             </FormSection>
@@ -123,6 +137,9 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                 visible={dialogOpen}
                 initial={editingIdx !== null ? (fields[editingIdx] ?? null) : null}
                 siblingNames={fields.map(f => f.name)}
+                isResultsField={arrayKey === 'results_fields'}
+                cycleFieldNames={(method.cycle_fields ?? []).map(f => f.name).filter(Boolean)}
+                resultsFieldNames={(method.results_fields ?? []).map(f => f.name).filter(Boolean)}
                 onCancel={() => setDialogOpen(false)}
                 onSave={handleSaveField}
             />