@adcops/autocore-react 3.3.113 → 3.3.116

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';
@@ -136,10 +137,15 @@ export const MethodFormEditor: React.FC<MethodFormEditorProps> = ({
                         <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,6 +31,9 @@ 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 ?? {}),

package/src/components/tis-editor/types.ts

@@ -31,6 +31,15 @@ export interface TestField {
      *  non-excluded runs sharing this test's sample_id. When set, the field
      *  is NOT supplied by the analysis script — the server computes it. */
     aggregate?: AggregateSpec;
+    /** cycle_fields only: operator-correctable after recording. Measured
+     *  columns must stay unflagged. cycle_config_fields don't need it —
+     *  they're annotation and are always correctable. */
+    editable?: boolean;
+    /** cycle_config_fields only: clear the operator's entry once a row has
+     *  recorded it, so the next row can't inherit a stale annotation. Pair
+     *  it with `required` — on its own it turns stale data into silently
+     *  missing data. */
+    autoclear?: boolean;
 }
 
 export type AggFn = 'avg' | 'min' | 'max' | 'stddev' | 'count';
@@ -113,11 +122,30 @@ export interface TestConfiguration {
     defaults?: Record<string, unknown>;
 }
 
+/**
+ * Which boundary an operator annotates `cycle_config_fields` at.
+ *
+ *   'run'    one latch per Start — the same values stamp every cycle of the
+ *            run and clear when it closes. Default; correct for a machine
+ *            that records many cycles from one Start.
+ *   'cycle'  one latch per cycle — values clear after each recorded row and
+ *            the gate re-arms, so every row is annotated separately.
+ */
+export type CycleConfigScope = 'run' | 'cycle';
+
 export interface TestMethod {
     label?: string;
     description?: string;
     project_fields?: TestField[];
     config_fields?: TestField[];
+    /** Operator-entered per-row annotation, recorded as the first Cycle Data
+     *  columns after the row index. */
+    cycle_config_fields?: TestField[];
+    /** Boundary at which cycle_config_fields latch and autoclear. */
+    cycle_config_scope?: CycleConfigScope;
+    /** Open the Cycle Configuration dialog at the boundary rather than
+     *  relying on the operator having filled the Cycle tab. */
+    prompt_before_cycle?: boolean;
     cycle_fields?: TestField[];
     results_fields?: TestField[];
     raw_data?: RawDataShape | null;
@@ -128,4 +156,9 @@ export interface TestMethod {
     [key: string]: unknown; // tolerate unknown server-side fields
 }
 
-export type FieldArrayKey = 'project_fields' | 'config_fields' | 'cycle_fields' | 'results_fields';
+export type FieldArrayKey =
+    | 'project_fields'
+    | 'config_fields'
+    | 'cycle_config_fields'
+    | 'cycle_fields'
+    | 'results_fields';

package/src/components/tis-editor/validation.ts

@@ -10,7 +10,9 @@ import type {
     TestField, TestMethod, ChartAxis, ChartSeries,
 } from './types';
 
-const FIELD_ARRAY_KEYS = ['project_fields', 'config_fields', 'cycle_fields', 'results_fields'] as const;
+const FIELD_ARRAY_KEYS = [
+    'project_fields', 'config_fields', 'cycle_config_fields', 'cycle_fields', 'results_fields',
+] as const;
 
 export interface ValidationError {
     /** Dotted path: "<arrayKey>.<index>.<sub>" or "views.<viewId>.x" etc. */
@@ -49,7 +51,7 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
     const resultTypes = new Map<string, string>(
         ((m.results_fields as TestField[] | undefined) ?? []).map((f) => [f.name, String(f.type)])
     );
-    for (const key of ['project_fields', 'config_fields', 'cycle_fields'] as const) {
+    for (const key of ['project_fields', 'config_fields', 'cycle_config_fields', 'cycle_fields'] as const) {
         ((m[key] as TestField[] | undefined) ?? []).forEach((f, i) => {
             if (f.aggregate) {
                 errs.push({ path: `${key}.${i}.aggregate`, message: `${methodId}.${key}.${f.name}: aggregate is only valid on results_fields` });
@@ -74,6 +76,22 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
         }
     });
 
+    // A cycle_config_field and a cycle_field share one row namespace in
+    // cycles.jsonl — the same name in both means the operator's annotation
+    // and a measured value would fight over one column. Mirrors the
+    // server-side check in validate_method.
+    const cycleFieldNames = new Set<string>(
+        ((m.cycle_fields as TestField[] | undefined) ?? []).map(f => f.name).filter(Boolean),
+    );
+    ((m.cycle_config_fields as TestField[] | undefined) ?? []).forEach((f, i) => {
+        if (f.name && cycleFieldNames.has(f.name)) {
+            errs.push({
+                path: `cycle_config_fields.${i}.name`,
+                message: `${methodId}: "${f.name}" is declared as both a cycle_config_field and a cycle_field. They share one row namespace; rename one.`,
+            });
+        }
+    });
+
     // Build sets for axis-reference resolution.
     const knownFields = new Set<string>();
     for (const key of FIELD_ARRAY_KEYS) {