@adcops/autocore-react 3.3.115 → 3.3.118

package/src/components/tis/TestSetupView.tsx

@@ -6,7 +6,7 @@
  * the same tabbed layout and scroll behaviour without copy-pasting a
  * per-project `TestInformationView`.
  *
- * Two tabs, both self-driving from <TisProvider> (no prop threading):
+ * Up to three tabs, all self-driving from <TisProvider> (no prop threading):
  *
  *   Project tab  — <ProjectSelector> stays pinned at the top; the
  *                  <ResultHistoryTable> (Test History) scrolls beneath
@@ -14,6 +14,16 @@
  *   Test tab     — <TestSetupForm>. Its "Test Setup" header (Sample ID,
  *                  Test Method, Configuration) stays pinned; the "Test
  *                  Configuration" field list scrolls when it overflows.
+ *   Cycle tab    — <CycleConfigForm>, the per-row annotation recorded onto
+ *                  each cycle. Present only when the selected method
+ *                  declares `cycle_config_fields`, and badged when a
+ *                  required entry is missing. Auto-selected when a run
+ *                  goes active: Test setup is a pre-run concern, the
+ *                  annotation is a during-run one.
+ *
+ * The Cycle tab is deliberately not the only place this state is visible —
+ * an operator about to press Start is looking at the footer, not at a tab.
+ * Put <CycleStatusStrip> beside the Start button for that.
  *
  * The whole view fills its parent's height and confines overflow to the
  * inner scroll regions, so the tab strip and the section headers stay
@@ -22,11 +32,13 @@
  * `min-height: 0`, or a fixed-height panel) to get that behaviour.
  */
 
-import React from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { TabView, TabPanel } from 'primereact/tabview';
 import { ProjectSelector } from './ProjectSelector';
 import { ResultHistoryTable } from './ResultHistoryTable';
 import { TestSetupForm } from './TestSetupForm';
+import { CycleConfigForm } from './CycleConfigForm';
+import { useTis } from './TisProvider';
 
 export interface TestSetupViewProps {
     /** Extra class names applied to the root element. */
@@ -40,9 +52,25 @@ export const TestSetupView: React.FC<TestSetupViewProps> = ({ className, style }
         ? `ac-test-setup-view ${className}`
         : 'ac-test-setup-view';
 
+    const tis = useTis();
+    const hasCycleConfig = tis.cycleConfigFields.length > 0;
+    const cycleIncomplete = hasCycleConfig && !tis.cycleConfig.ready;
+
+    // Which tab is showing. Controlled so the view can move the operator to
+    // the Cycle tab when a run goes active — the annotation is what they
+    // need next, and Test setup is already done by then.
+    const [activeIndex, setActiveIndex] = useState(0);
+    const prevActive = useRef(false);
+    useEffect(() => {
+        if (tis.state.active && !prevActive.current && hasCycleConfig) {
+            setActiveIndex(2);
+        }
+        prevActive.current = tis.state.active;
+    }, [tis.state.active, hasCycleConfig]);
+
     return (
         <div className={rootClass} style={style}>
-            <TabView>
+            <TabView activeIndex={activeIndex} onTabChange={(e) => setActiveIndex(e.index)}>
                 {/* Project tab: pick or create a project, then browse its
                     history. ResultHistoryTable is project-scoped (across
                     methods) by default, so this is the natural place to
@@ -66,6 +94,35 @@ export const TestSetupView: React.FC<TestSetupViewProps> = ({ className, style }
                 <TabPanel header="Test">
                     <TestSetupForm />
                 </TabPanel>
+
+                {/* Cycle tab: per-row operator annotation. Rendered only
+                    when the method declares any — a method that records
+                    nothing by hand shouldn't grow an empty tab. The header
+                    carries a warning marker when a required entry is
+                    missing, so the state is legible from the tab strip
+                    without opening it. */}
+                {hasCycleConfig && (
+                    <TabPanel
+                        header={
+                            <span style={{ display: 'inline-flex', alignItems: 'center', gap: '0.4rem' }}>
+                                Cycle
+                                {cycleIncomplete && (
+                                    <i
+                                        className="pi pi-exclamation-circle"
+                                        style={{ color: 'var(--red-500)' }}
+                                        aria-label="Cycle Configuration incomplete"
+                                    />
+                                )}
+                            </span>
+                        }
+                    >
+                        <div className="ac-test-setup-view__tab">
+                            <div className="ac-test-setup-view__scroll">
+                                <CycleConfigForm />
+                            </div>
+                        </div>
+                    </TabPanel>
+                )}
             </TabView>
         </div>
     );

package/src/components/tis/TisProvider.tsx

@@ -29,6 +29,7 @@ import React, {
 } from 'react';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
+import type { CycleConfigScope, TestFieldDef } from './TestFieldRow';
 
 // -------------------------------------------------------------------------
 // Types
@@ -68,6 +69,37 @@ export interface TisLiveState {
     lastStartError: string;
 }
 
+/**
+ * Live Cycle Configuration state for the selected (project, method) —
+ * the operator's per-row annotation. Mirrors the server's
+ * `tis.cycle_config` payload one-for-one; the server owns every rule
+ * (which boundary latches, when autoclear fires, whether the gate is
+ * satisfied) so the HMI never has to re-derive them and can never
+ * disagree with the `tis.cycle_ready` scalar the machine gates on.
+ */
+export interface TisCycleConfigState {
+    projectId: string;
+    methodId: string;
+    /** `'run'` = one latch per Start; `'cycle'` = one per cycle. */
+    scope: CycleConfigScope;
+    /** Method asks for the entry dialog at each boundary. */
+    promptBeforeCycle: boolean;
+    /** What the operator has entered but no row has consumed yet (RAW). */
+    values: Record<string, any>;
+    /** The snapshot the cycle now running will be stamped with, or null
+     *  when nothing is latched. Non-null means the fields are locked for
+     *  the row in flight — editing them targets the *next* row. */
+    latched: Record<string, any> | null;
+    /** False while any `required` field is empty. The same condition
+     *  drives `tis.cycle_ready`, which gates the machine. */
+    ready: boolean;
+    /** Names of the required-but-empty fields, in declared order. */
+    missing: string[];
+    /** A `prompt_before_cycle` method has reached a boundary with nothing
+     *  latched — the edge on which <CycleConfigDialog> opens. */
+    promptDue: boolean;
+}
+
 export interface TisSelection {
     projectId: string;
     methodId: string;
@@ -208,6 +240,31 @@ export interface TisContextValue {
      *  operator accepts a different one in the picker dialog. */
     setConfigurationName: (name: string) => void;
 
+    // -----------------------------------------------------------------
+    // Cycle Configuration — the operator's per-row annotation. Lives on
+    // the provider (like `stagedConfig`) so the Cycle tab, the status
+    // strip beside Start, and the prompt dialog all read one state and
+    // the values survive a tab switch.
+    // -----------------------------------------------------------------
+
+    /** Live state for the selected method. Server-owned; every mutation
+     *  round-trips so the HMI and the `tis.cycle_ready` gate agree. */
+    cycleConfig: TisCycleConfigState;
+    /** The selected method's `cycle_config_fields`, in declared order.
+     *  Empty when the method doesn't use the feature — which is the
+     *  signal to hide the Cycle tab entirely. */
+    cycleConfigFields: TestFieldDef[];
+    /** Merge a sparse patch of RAW values into the operator's pending
+     *  entry. An explicit null/'' clears a field. Resolves once the
+     *  server has applied it and the state has been refreshed. */
+    setCycleConfigValues: (patch: Record<string, any>) => Promise<void>;
+    /** Wipe every pending value regardless of `autoclear`. Leaves the
+     *  latch alone — a cycle already running keeps its label. */
+    clearCycleConfig: () => Promise<void>;
+    /** Re-read Cycle Configuration state from the server. Called on
+     *  selection change; broadcasts keep it fresh after that. */
+    refreshCycleConfig: () => Promise<void>;
+
     /** Fetch the run list for a (project, method?) pair. Method may be
      *  omitted to aggregate runs across every method in the project —
      *  the History tab uses this. */
@@ -232,6 +289,29 @@ const EMPTY_SELECTION: TisSelection = {
     projectId: '', methodId: '', sampleId: '', runId: '',
 };
 
+/** No method selected, or a method that declares no annotation columns.
+ *  `ready: true` is the safe default — a method without cycle_config_fields
+ *  must never look gated. */
+const EMPTY_CYCLE_CONFIG: TisCycleConfigState = {
+    projectId: '', methodId: '', scope: 'run', promptBeforeCycle: false,
+    values: {}, latched: null, ready: true, missing: [], promptDue: false,
+};
+
+/** Normalise a server `tis.cycle_config` payload into provider state. */
+const cycleConfigFromPayload = (p: any): TisCycleConfigState => ({
+    projectId:         String(p?.project_id ?? ''),
+    methodId:          String(p?.method_id ?? ''),
+    scope:             p?.scope === 'cycle' ? 'cycle' : 'run',
+    promptBeforeCycle: !!p?.prompt_before_cycle,
+    values:            (p?.values && typeof p.values === 'object') ? p.values : {},
+    latched:           (p?.latched && typeof p.latched === 'object') ? p.latched : null,
+    // Absent `ready` means a server that predates the field — treat as
+    // ungated rather than locking an operator out of a working machine.
+    ready:             p?.ready !== false,
+    missing:           Array.isArray(p?.missing) ? p.missing : [],
+    promptDue:         !!p?.prompt_due,
+});
+
 const TisContext = createContext<TisContextValue>({
     schemas: {},
     projectAssetRefs: [],
@@ -255,6 +335,11 @@ const TisContext = createContext<TisContextValue>({
     markDefaultsAppliedForMethod: () => {},
     configurationName: '',
     setConfigurationName: () => {},
+    cycleConfig: EMPTY_CYCLE_CONFIG,
+    cycleConfigFields: [],
+    setCycleConfigValues: async () => {},
+    clearCycleConfig: async () => {},
+    refreshCycleConfig: async () => {},
     fetchRuns: async () => [],
     fetchRun: async () => null,
     runCache: {},
@@ -699,6 +784,90 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
         setConfigurationName('');
     }, []);
 
+    // -----------------------------------------------------------------
+    // Cycle Configuration
+    //
+    // The server owns the rules — which boundary latches, when autoclear
+    // fires, whether the gate is satisfied — so this is a cache of its
+    // state, refreshed on selection change and kept live by the
+    // `tis.cycle_config` broadcast. Every mutation round-trips and adopts
+    // the reply, so the HMI can't drift from the `tis.cycle_ready` scalar
+    // the machine is actually gated on.
+    // -----------------------------------------------------------------
+    const [cycleConfig, setCycleConfigStateRaw] = useState<TisCycleConfigState>(EMPTY_CYCLE_CONFIG);
+
+    const cycleConfigFields = useMemo<TestFieldDef[]>(() => {
+        const arr = selection.methodId
+            ? schemas[selection.methodId]?.cycle_config_fields
+            : undefined;
+        return Array.isArray(arr) ? arr : [];
+    }, [schemas, selection.methodId]);
+
+    const refreshCycleConfig = useCallback(async () => {
+        const projectId = selection.projectId;
+        const methodId  = selection.methodId;
+        if (!methodId) { setCycleConfigStateRaw(EMPTY_CYCLE_CONFIG); return; }
+        try {
+            const resp: any = await invoke('tis.cycle_config' as any, MessageType.Request, {
+                project_id: projectId, method_id: methodId,
+            } as any);
+            if (resp?.success) {
+                setCycleConfigStateRaw(cycleConfigFromPayload(resp.data));
+                return;
+            }
+            // An older server without the verb, or a method the project
+            // doesn't declare. Either way there is nothing to gate on.
+            setCycleConfigStateRaw(EMPTY_CYCLE_CONFIG);
+        } catch (e) {
+            console.warn('[TisProvider] tis.cycle_config failed:', e);
+            setCycleConfigStateRaw(EMPTY_CYCLE_CONFIG);
+        }
+    }, [invoke, selection.projectId, selection.methodId]);
+
+    const setCycleConfigValues = useCallback(async (patch: Record<string, any>) => {
+        const projectId = selection.projectId;
+        const methodId  = selection.methodId;
+        if (!methodId) return;
+        try {
+            const resp: any = await invoke('tis.set_cycle_config' as any, MessageType.Request, {
+                project_id: projectId, method_id: methodId, values: patch,
+            } as any);
+            if (resp?.success) setCycleConfigStateRaw(cycleConfigFromPayload(resp.data));
+            else console.warn('[TisProvider] tis.set_cycle_config rejected:', resp?.error_message);
+        } catch (e) {
+            console.error('[TisProvider] tis.set_cycle_config failed:', e);
+        }
+    }, [invoke, selection.projectId, selection.methodId]);
+
+    const clearCycleConfig = useCallback(async () => {
+        const projectId = selection.projectId;
+        const methodId  = selection.methodId;
+        if (!methodId) return;
+        try {
+            const resp: any = await invoke('tis.clear_cycle_config' as any, MessageType.Request, {
+                project_id: projectId, method_id: methodId,
+            } as any);
+            if (resp?.success) setCycleConfigStateRaw(cycleConfigFromPayload(resp.data));
+        } catch (e) {
+            console.error('[TisProvider] tis.clear_cycle_config failed:', e);
+        }
+    }, [invoke, selection.projectId, selection.methodId]);
+
+    useEffect(() => { void refreshCycleConfig(); }, [refreshCycleConfig]);
+
+    useEffect(() => {
+        // Server-pushed state: latch taken, autoclear fired, gate re-armed.
+        // Payloads for another method are ignored so a multi-method HMI
+        // doesn't show one method's annotation while another is selected.
+        const onCycleConfig = (payload: any) => {
+            const mid = String(payload?.method_id ?? '');
+            if (mid && selection.methodId && mid !== selection.methodId) return;
+            setCycleConfigStateRaw(cycleConfigFromPayload(payload));
+        };
+        const id = subscribe('tis.cycle_config', onCycleConfig);
+        return () => { unsubscribe(id); };
+    }, [subscribe, unsubscribe, selection.methodId]);
+
     const value: TisContextValue = useMemo(() => ({
         schemas, projectAssetRefs, defaultMethodId, schemasLoaded,
         state, selection, setSelection,
@@ -707,6 +876,8 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
         stagedConfig, setStagedConfig, clearStagedConfig,
         defaultsAppliedForMethod, markDefaultsAppliedForMethod,
         configurationName, setConfigurationName,
+        cycleConfig, cycleConfigFields,
+        setCycleConfigValues, clearCycleConfig, refreshCycleConfig,
         fetchRuns, fetchRun, runCache,
     }), [
         schemas, projectAssetRefs, defaultMethodId, schemasLoaded,
@@ -716,6 +887,8 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
         stagedConfig, setStagedConfig, clearStagedConfig,
         defaultsAppliedForMethod, markDefaultsAppliedForMethod,
         configurationName, setConfigurationName,
+        cycleConfig, cycleConfigFields,
+        setCycleConfigValues, clearCycleConfig, refreshCycleConfig,
         fetchRuns, fetchRun, runCache,
     ]);
 
@@ -729,6 +902,24 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
 export const useTis           = () => useContext(TisContext);
 export const useTisSchemas    = () => useContext(TisContext).schemas;
 export const useTisState      = () => useContext(TisContext).state;
+
+/**
+ * Cycle Configuration for the selected method: the live state, the field
+ * declarations, and the two mutators.
+ *
+ * `fields.length === 0` means the method doesn't use per-row annotation —
+ * hide the Cycle tab and the status strip rather than showing an empty one.
+ */
+export const useTisCycleConfig = () => {
+    const { cycleConfig, cycleConfigFields, setCycleConfigValues, clearCycleConfig } =
+        useContext(TisContext);
+    return {
+        ...cycleConfig,
+        fields: cycleConfigFields,
+        setValues: setCycleConfigValues,
+        clear: clearCycleConfig,
+    };
+};
 /**
  * Tuple of `[selection, setSelection]`.
  *

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

@@ -50,6 +50,7 @@ const EMPTY_METHOD: TestMethod = {
     description: '',
     project_fields: [],
     config_fields: [],
+    cycle_config_fields: [],
     cycle_fields: [],
     results_fields: [],
     views: {},

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

@@ -0,0 +1,93 @@
+/**
+ * CycleConfigSection — the two method-level settings that decide how the
+ * operator's per-row annotation behaves. The columns themselves are
+ * authored in the Fields tab; this is the state machine around them.
+ *
+ * The scope choice is the load-bearing one. A machine that records many
+ * cycles from one Start is not pausing for input between them, so its
+ * annotation has to latch once per Start ('run'). A machine the operator
+ * drives one cycle at a time — the six-position sweep — annotates each row
+ * separately ('cycle'), which means the gate re-arms between cycles and
+ * the control program must wait on `tis.cycle_ready`.
+ */
+
+import { Dropdown } from 'primereact/dropdown';
+import { Checkbox } from 'primereact/checkbox';
+import { FormSection } from '../../forms/FormSection';
+import { FormRow } from '../../forms/FormRow';
+import type { CycleConfigScope, TestField, TestMethod } from '../types';
+
+const SCOPES: { label: string; value: CycleConfigScope }[] = [
+    { label: 'run — one entry per Start, stamped on every cycle of the run', value: 'run' },
+    { label: 'cycle — one entry per cycle, re-entered between cycles', value: 'cycle' },
+];
+
+export interface CycleConfigSectionProps {
+    method: TestMethod;
+    onChange: (next: TestMethod) => void;
+}
+
+export const CycleConfigSection: React.FC<CycleConfigSectionProps> = ({ method, onChange }) => {
+    const fields = (method.cycle_config_fields as TestField[]) ?? [];
+    const scope: CycleConfigScope = method.cycle_config_scope === 'cycle' ? 'cycle' : 'run';
+
+    /**
+     * Write a key only when it differs from the server-side default,
+     * deleting it otherwise. Both of these are `#[serde(default)]` in Rust,
+     * so materialising `"cycle_config_scope": "run"` into every method would
+     * add noise to test_methods.json that means nothing — and an editor that
+     * writes defaults it was only shown is how a review session ends up
+     * changing methods nobody touched.
+     */
+    const setOrDrop = <K extends 'cycle_config_scope' | 'prompt_before_cycle'>(
+        key: K, value: TestMethod[K], isDefault: boolean,
+    ) => {
+        const next: TestMethod = { ...method };
+        if (isDefault) delete next[key];
+        else next[key] = value;
+        onChange(next);
+    };
+
+    return (
+        <FormSection
+            title="Cycle Configuration"
+            description={
+                'How the operator-entered annotation columns behave. Add the columns themselves ' +
+                'on the Fields tab under "Cycle Configuration Fields".'
+            }
+        >
+            {fields.length === 0 && (
+                <div style={{ color: '#6b7280', marginBottom: '0.75rem' }}>
+                    This method declares no Cycle Configuration fields, so these settings have no effect.
+                </div>
+            )}
+            <FormRow
+                label="Scope"
+                hint={
+                    'When the operator\'s entry is latched and cleared. Choose "cycle" only if the ' +
+                    'machine actually waits between cycles — under "cycle" the gate drops after every ' +
+                    'row and the control program must hold until tis.cycle_ready comes back true.'
+                }
+            >
+                <Dropdown
+                    value={scope}
+                    options={SCOPES}
+                    onChange={(e) => setOrDrop('cycle_config_scope', e.value, e.value === 'run')}
+                />
+            </FormRow>
+            <FormRow
+                label="Prompt before cycle"
+                hint={
+                    'Open the entry dialog at the boundary instead of relying on the operator having ' +
+                    'filled the Cycle tab. Costs a confirmation each time — worth it when a mislabelled ' +
+                    'row means re-running the sample, not worth it for a non-critical note.'
+                }
+            >
+                <Checkbox
+                    checked={!!method.prompt_before_cycle}
+                    onChange={(e) => setOrDrop('prompt_before_cycle', !!e.checked, !e.checked)}
+                />
+            </FormRow>
+        </FormSection>
+    );
+};

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

@@ -9,6 +9,7 @@ import type { TestField, TestMethod, FieldArrayKey } from '../types';
 const TITLES: Record<FieldArrayKey, string> = {
     project_fields: 'Project Fields',
     config_fields: 'Config Fields',
+    cycle_config_fields: 'Cycle Configuration Fields',
     cycle_fields: 'Cycle Fields',
     results_fields: 'Results Fields',
 };
@@ -16,6 +17,7 @@ const TITLES: Record<FieldArrayKey, string> = {
 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_config_fields: 'Operator-entered annotation recorded onto every cycle row (e.g. which of six positions this is). Shown on the HMI Cycle tab and written as the first Cycle Data columns after the row index. Mark them Required so the machine cannot start unannotated, and Autoclear so the next row cannot inherit a stale value.',
     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. A field can also be a cross-test Aggregate (avg/min/max/stddev/count over tests sharing a sample_id).',
 };
@@ -130,6 +132,13 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                             style={{ width: '8rem' }}
                         />
                     )}
+                    {arrayKey === 'cycle_config_fields' && (
+                        <Column
+                            header="Autoclear"
+                            body={(r: TestField) => r.autoclear ? '✓' : ''}
+                            style={{ width: '6rem' }}
+                        />
+                    )}
                     <Column header="" body={rowActions} style={{ width: '10rem' }} />
                 </DataTable>
             </FormSection>
@@ -138,6 +147,7 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                 initial={editingIdx !== null ? (fields[editingIdx] ?? null) : null}
                 siblingNames={fields.map(f => f.name)}
                 isResultsField={arrayKey === 'results_fields'}
+                isCycleConfigField={arrayKey === 'cycle_config_fields'}
                 cycleFieldNames={(method.cycle_fields ?? []).map(f => f.name).filter(Boolean)}
                 resultsFieldNames={(method.results_fields ?? []).map(f => f.name).filter(Boolean)}
                 onCancel={() => setDialogOpen(false)}

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

@@ -13,6 +13,7 @@ import { Button } from 'primereact/button';
 import { CodeEditor } from '../../CodeEditor';
 import { IdentitySection } from './IdentitySection';
 import { FieldArrayEditor } from './FieldArrayEditor';
+import { CycleConfigSection } from './CycleConfigSection';
 import { ConfigurationsEditor } from './ConfigurationsEditor';
 import { ViewsEditor } from './ViewsEditor';
 import { RawDataEditor } from './RawDataEditor';
@@ -104,7 +105,6 @@ export const MethodFormEditor: React.FC<MethodFormEditorProps> = ({
                     {dirty && <span style={{ marginLeft: '0.5rem', color: '#ea580c' }}>•</span>}
                     {validationErrors.length > 0 && (
                         <span
-                            title={validationErrors.map(e => e.message).join('\n')}
                             style={{
                                 marginLeft: '0.5rem',
                                 background: '#fef2f2',
@@ -113,7 +113,6 @@ export const MethodFormEditor: React.FC<MethodFormEditorProps> = ({
                                 borderRadius: 4,
                                 fontSize: '0.75rem',
                                 fontWeight: 600,
-                                cursor: 'help',
                             }}
                         >
                             {validationErrors.length} issue{validationErrors.length === 1 ? '' : 's'}
@@ -130,16 +129,49 @@ export const MethodFormEditor: React.FC<MethodFormEditorProps> = ({
                 </div>
             </div>
 
+            {/* Validation issues, spelled out. These disable Apply, so the
+                operator has to be able to READ them — the count used to live
+                in a hover `title`, which on the touchscreen HMIs this ships
+                to is no affordance at all: Apply was greyed out and nothing
+                on screen said why. (gen4_ac, 2026-08-12: a method whose only
+                problem was a false-positive chart-axis error couldn't be
+                edited at all, and the reason was invisible.) */}
+            {validationErrors.length > 0 && (
+                <div
+                    style={{
+                        padding: '0.5rem 1rem',
+                        background: '#fef2f2',
+                        color: '#991b1b',
+                        borderBottom: '1px solid #fecaca',
+                        fontSize: '0.85rem',
+                    }}
+                >
+                    <strong>
+                        Fix {validationErrors.length === 1 ? 'this issue' : 'these issues'} before applying:
+                    </strong>
+                    <ul style={{ margin: '0.25rem 0 0 1.25rem' }}>
+                        {validationErrors.map((e, i) => (
+                            <li key={i}>{e.message}</li>
+                        ))}
+                    </ul>
+                </div>
+            )}
+
             <div style={{ flex: 1, minHeight: 0, overflow: 'auto' }}>
                 <TabView activeIndex={activeTab} onTabChange={(e) => setActiveTab(e.index)}>
                     <TabPanel header="Identity">
                         <IdentitySection method={draft} onChange={handleFormChange} />
                     </TabPanel>
                     <TabPanel header="Fields">
-                        <FieldArrayEditor arrayKey="project_fields" method={draft} onChange={handleFormChange} />
-                        <FieldArrayEditor arrayKey="config_fields"  method={draft} onChange={handleFormChange} />
-                        <FieldArrayEditor arrayKey="cycle_fields"   method={draft} onChange={handleFormChange} />
-                        <FieldArrayEditor arrayKey="results_fields" method={draft} onChange={handleFormChange} />
+                        <FieldArrayEditor arrayKey="project_fields"      method={draft} onChange={handleFormChange} />
+                        <FieldArrayEditor arrayKey="config_fields"       method={draft} onChange={handleFormChange} />
+                        {/* Cycle Configuration sits directly above Cycle
+                            Fields: the two together are one row, annotation
+                            columns first. */}
+                        <FieldArrayEditor arrayKey="cycle_config_fields" method={draft} onChange={handleFormChange} />
+                        <CycleConfigSection method={draft} onChange={handleFormChange} />
+                        <FieldArrayEditor arrayKey="cycle_fields"        method={draft} onChange={handleFormChange} />
+                        <FieldArrayEditor arrayKey="results_fields"      method={draft} onChange={handleFormChange} />
                     </TabPanel>
                     <TabPanel header="Configurations">
                         <ConfigurationsEditor method={draft} onChange={handleFormChange} />

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

@@ -45,6 +45,9 @@ export interface TestFieldDialogProps {
     /** True when this field belongs to `results_fields` — only then is the
      *  cross-test Aggregate section shown. */
     isResultsField?: boolean;
+    /** True when this field belongs to `cycle_config_fields` — only then is
+     *  the Autoclear option shown, and only there does it do anything. */
+    isCycleConfigField?: boolean;
     /** Candidate target field names for an aggregate's `of`, by source. */
     cycleFieldNames?: string[];
     resultsFieldNames?: string[];
@@ -54,7 +57,8 @@ const blank: TestField = { name: '', type: 'f32' };
 
 export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
     visible, initial, onCancel, onSave, siblingNames,
-    isResultsField = false, cycleFieldNames = [], resultsFieldNames = [],
+    isResultsField = false, isCycleConfigField = false,
+    cycleFieldNames = [], resultsFieldNames = [],
 }) => {
     const [draft, setDraft] = useState<TestField>(blank);
     // `default` is edited as free text so a numeric literal, a string, or an
@@ -162,12 +166,28 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
                     onChange={(e) => setDraft({ ...draft, label: e.target.value || undefined })}
                 />
             </FormRow>
-            <FormRow label="Required">
+            <FormRow
+                label="Required"
+                hint={isCycleConfigField
+                    ? 'Blocks the machine until the operator fills this in — tis.cycle_ready stays false and start_test is refused. This is what stops an unannotated row from being recorded.'
+                    : undefined}
+            >
                 <Checkbox
                     checked={!!draft.required}
                     onChange={(e) => setDraft({ ...draft, required: !!e.checked })}
                 />
             </FormRow>
+            {isCycleConfigField && (
+                <FormRow
+                    label="Autoclear"
+                    hint="Clear the operator's entry once a row has recorded it, so the next row can't inherit a stale value. Fires after each cycle under 'cycle' scope, at the end of the run under 'run' scope. Pair with Required — on its own it turns stale data into silently missing data."
+                >
+                    <Checkbox
+                        checked={!!draft.autoclear}
+                        onChange={(e) => setDraft({ ...draft, autoclear: !!e.checked })}
+                    />
+                </FormRow>
+            )}
             <FormRow label="Source" hint="Optional gm.* variable to bind this field to.">
                 <InputText
                     value={draft.source ?? ''}

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

@@ -31,9 +31,16 @@ export const ViewsEditor: React.FC<ViewsEditorProps> = ({ method, onChange }) =>
     const knownKeys: string[] = [
         ...((method.project_fields ?? []) as TestField[]).map(f => f.name),
         ...((method.config_fields  ?? []) as TestField[]).map(f => f.name),
+        // Annotation columns live on the cycle row like any measured one, so
+        // a cycle_scatter can plot against them (e.g. peak load by position).
+        ...((method.cycle_config_fields ?? []) as TestField[]).map(f => f.name),
         ...((method.cycle_fields   ?? []) as TestField[]).map(f => f.name),
         ...((method.results_fields ?? []) as TestField[]).map(f => f.name),
         ...Object.keys((method.raw_data as any)?.columns ?? {}),
+        // Written onto every row by the server, not declared anywhere —
+        // offered here so "peak load by cycle" is a pick, not a guess.
+        'cycle_index',
+        'timestamp',
     ];
 
     const openNew = () => { setEditingId(null); setDialogOpen(true); };