- id: date_input_text-antd-T01 name: AntD basic typed date in ISO format canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) with manual typing enabled' task_template: enter_formatted secondary_template: null browsergym_goal: In the Date entry card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Set Invoice date to 2026-02-14 (YYYY-MM-DD).' setup_description: |- Layout: isolated_card centered in the viewport (single card on an otherwise blank page). Component: One Ant Design DatePicker rendered inline inside the card with label “Invoice date”. The input shows a placeholder “YYYY-MM-DD”, a calendar icon on the right, and a clear (✕) icon that appears when a value is present. Initial state: the field is empty (no date selected) and no popup is open. Sub-controls/behavior: typing a date and pressing Enter (or blurring the field) commits the value; clicking the calendar icon would open a calendar popover but is not required. Distractors: none (no other inputs/buttons in the card). Feedback: once committed, the formatted date text is visible in the input. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 2 disambiguation_load: 1 justification: Single, large date input with an explicit placeholder and immediate visible feedback after typing. success_trigger: human_readable: - The DatePicker value (canonical date) equals 2026-02-14. - No confirmation button is required; the committed field value is sufficient. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-02-14' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Any other date is entered (including 2026-02-13 or 2026-02-15). - The text is typed but not committed (value remains empty / invalid). - The date is entered into a non-existent or wrong field (not applicable here, but still invalid). expected_interaction_path: Click the input → type 2026-02-14 → press Enter or click outside to commit. notes: 'Instrumentation: expose the DatePicker input as data-testid=''invoice-date''. Checker should read the component value and normalize to ISO YYYY-MM-DD.' - id: date_input_text-antd-T02 name: AntD overwrite an existing date canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) with manual typing enabled' task_template: set_scalar secondary_template: null browsergym_goal: Change the “Shipping date” field to 2026-02-20 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Shipping date should be 2026-02-20.' setup_description: |- Layout: isolated_card centered in the viewport. Component: One Ant Design DatePicker labeled “Shipping date”. Initial state: the field is pre-filled with 2026-02-01 (YYYY-MM-DD). The clear icon is available because a value is set. Sub-controls/behavior: the date can be edited by focusing the input and typing over the existing value; calendar popover is available but optional. Distractors: a non-interactive summary line under the field (“Orders ship within 2 business days.”) to look realistic. Feedback: the input text updates to the new date when committed. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Requires replacing an existing value, but the field is still isolated with clear visual confirmation. success_trigger: human_readable: - The DatePicker value (canonical date) equals 2026-02-20. - No additional Save/Apply action is required. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-02-20' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Leaving the original date (2026-02-01) unchanged. - Entering 2026-02-02 or any other off-by-one date. - Typing the date but leaving the field in an invalid/uncommitted state (checker still reads old value). expected_interaction_path: Click the input → select all (or clear) → type 2026-02-20 → commit by Enter/blur. notes: 'Instrumentation: data-testid=''shipping-date''. Consider normalizing value via onChange-emitted Dayjs/Date object to ISO.' - id: date_input_text-antd-T03 name: AntD clear a pre-filled date canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) with allowClear' task_template: clear_reset secondary_template: null browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done. ui_copy: 'Goal: Reminder date should be cleared (empty).' setup_description: |- Layout: isolated_card centered in the viewport. Component: One Ant Design DatePicker labeled “Reminder date”. Initial state: the field contains 2026-03-10 (YYYY-MM-DD). Sub-controls/behavior: a small clear (✕) icon becomes available in the input when it has a value (typical AntD allowClear behavior). Clearing removes the value and restores the placeholder. Distractors: none. Feedback: after clearing, the input shows the placeholder text again and the value becomes null/empty. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L1 axes_ratings: precision_requirement: 1 target_acquisition: 3 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: The main challenge is acquiring the small clear control; otherwise the task is straightforward with immediate feedback. success_trigger: human_readable: - The DatePicker value is empty/null (no date selected). - The field shows the empty state (placeholder visible) and no date is committed. canonical_predicate: predicate_type: equals target_state: date_iso: null tolerance: null require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text empty_ok: true negative_cases: - A date value remains set (including the original 2026-03-10). - The user types and leaves an invalid string that does not clear the underlying value. - Clearing is attempted but the value is not actually removed (e.g., only selects text). expected_interaction_path: Hover/focus the input if needed → click the clear (✕) icon (or delete the value and commit) → verify placeholder returns. notes: 'Instrumentation: data-testid=''reminder-date''. Checker should treat null/undefined/empty as cleared.' - id: date_input_text-antd-T04 name: AntD typed date in US format canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) with format MM/DD/YYYY' task_template: enter_formatted secondary_template: null browsergym_goal: Set the “Event date” field to 03/03/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Goal: Event date = 03/03/2026.' setup_description: |- Layout: isolated_card centered in the viewport. Component: One Ant Design DatePicker labeled “Event date”. Configuration: display/parse format is set to MM/DD/YYYY, and the placeholder shows “MM/DD/YYYY”. Initial state: empty. Sub-controls/behavior: typing is supported; the calendar popover exists but is optional. Distractors: none. Feedback: after commit, the input shows “03/03/2026”. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 2 disambiguation_load: 1 justification: Single field with an explicit format hint; success is an exact semantic date match. success_trigger: human_readable: - The DatePicker value (canonical date) equals 2026-03-03. - The displayed text corresponds to MM/DD/YYYY for that date. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-03-03' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text expected_display_format: MM/DD/YYYY negative_cases: - Entering 03/02/2026 or 02/03/2026 (month/day swapped). - Entering a malformed date that does not parse (field remains empty/invalid). - Leaving the field empty. expected_interaction_path: Click input → type 03/03/2026 → press Enter or blur. notes: 'Instrumentation: data-testid=''event-date''. Checker should compare parsed date, not raw text.' - id: date_input_text-antd-T05 name: AntD pick the correct field among two instances canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) x2 in a form section' task_template: set_scalar secondary_template: null browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Booking form: Set End date to 2026-05-20.' setup_description: |- Layout: form_section centered in the viewport, resembling a typical booking form. Components: Two Ant Design DatePicker inputs shown inline in the same section: 1) “Start date” (pre-filled with 2026-05-10) 2) “End date” (empty) Both fields use the same YYYY-MM-DD format and both allow manual typing. Sub-controls: each input has its own calendar icon and clear behavior. Distractors (clutter=low): there is also a “Guests” numeric input and a disabled “Promo code” text box, but they do not affect success. Feedback: the “End date” field shows the selected/typed date once committed. scene_context: theme: light spacing: comfortable layout: form_section placement: center scale: default instances: 2 guidance: text clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 2 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 3 justification: Two identical date inputs require disambiguation by label; otherwise the interaction is direct typing with immediate feedback. success_trigger: human_readable: - The “End date” DatePicker value equals 2026-05-20. - The “Start date” field may be unchanged; only the targeted instance is checked. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-05-20' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: End date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Setting the “Start date” to 2026-05-20 while leaving “End date” empty. - Entering 2026-05-02 or any other date (wrong day/month). - Typing into the field but not committing (checker still reads empty). expected_interaction_path: Locate “End date” → focus input → type 2026-05-20 → commit by Enter/blur. notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Checker must ensure correct instance by associated label.' - id: date_input_text-antd-T06 name: AntD match a date from a visual reference badge canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) with manual typing enabled' task_template: match_reference secondary_template: null browsergym_goal: Set the “Report date” field to match the date shown on the “Reference stamp” on the page. The task will finish automatically when done. ui_copy: 'Goal: Report date must match the Reference stamp.' setup_description: |- Layout: dashboard-style card with two columns, centered in the viewport. Left column: an Ant Design DatePicker labeled “Report date” (format YYYY-MM-DD) with placeholder “YYYY-MM-DD”. Right column: a prominent “Reference stamp” badge styled like a rubber stamp. It visually displays the target date as: “JUN 01 2026” Initial state: “Report date” is empty. Distractors (clutter=low): a small “Report title” text field is present but disabled and does not affect success. Feedback: after entering a valid date, the DatePicker shows the formatted date text in the input. scene_context: theme: light spacing: comfortable layout: dashboard placement: center scale: default instances: 1 guidance: visual clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 3 disambiguation_load: 2 justification: The target date is not provided in the instruction and must be read from an on-screen reference, increasing observability demand. success_trigger: human_readable: - The “Report date” DatePicker value equals the reference date 2026-06-01. - No additional confirmation action is required. canonical_predicate: predicate_type: matches_reference target_state: date_iso: '2026-06-01' reference_id: reference-stamp tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Report date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Entering any other date that does not match the Reference stamp. - Leaving the field empty. - Typing an invalid string that fails to parse (value remains null). expected_interaction_path: Read the date from the Reference stamp → focus “Report date” → type the equivalent YYYY-MM-DD value → commit. notes: 'Instrumentation: reference badge data-testid=''reference-stamp'' (for dataset generation) and input data-testid=''report-date''. Checker uses the fixed target date encoded in the task instance.' - id: date_input_text-antd-T07 name: AntD date input inside a modal with Save/Cancel canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: Modal + DatePicker (date) in a form' task_template: confirm_cancel secondary_template: null browsergym_goal: Open the “Edit reservation” dialog, set “Check-in date” to 2026-07-04 (YYYY-MM-DD), then click “Save reservation”. The task will finish automatically when done. ui_copy: Edit reservation → set Check-in date to 2026-07-04 → Save reservation. setup_description: |- Layout: modal_flow. The base page shows a small reservation summary card and a primary button “Edit reservation”. When “Edit reservation” is clicked, an Ant Design Modal opens in the center of the screen. Inside the modal is a short form with: - “Guest name” (prefilled text input; not required) - “Check-in date” (Ant Design DatePicker; format YYYY-MM-DD; manual typing enabled) Initial state: modal is closed; “Check-in date” is empty once the modal opens. Actions: modal footer has two buttons: “Cancel” (secondary) and “Save reservation” (primary). Feedback: clicking “Save reservation” closes the modal and shows a small inline success message under the reservation summary (“Saved”). scene_context: theme: light spacing: comfortable layout: modal_flow placement: center scale: default instances: 1 guidance: text clutter: low difficulty: difficulty_bucket: mid tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 3 feedback_dynamics: 3 semantic_observability: 2 disambiguation_load: 2 justification: Requires opening a modal layer and committing via an explicit Save button; success depends on both the entered date and confirmation. success_trigger: human_readable: - The “Check-in date” value in the modal form equals 2026-07-04. - The user has clicked “Save reservation” (confirmation required) and the saved value is persisted. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-07-04' tolerance: days: 0 require_confirm: true confirm_control: Save reservation require_correct_instance: true target_instance_label_or_id: Check-in date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text persisted_state_id: reservation.checkin negative_cases: - Correct date is entered but “Save reservation” is not clicked (modal left open). - Clicking “Cancel” after entering the date (should not count). - Saving with any date other than 2026-07-04. - Entering text that looks right but does not parse to a valid date value. expected_interaction_path: Click “Edit reservation” → focus Check-in date → type 2026-07-04 → commit → click “Save reservation”. notes: 'Instrumentation: modal root data-testid=''edit-reservation-modal''; input data-testid=''checkin-date''; save button data-testid=''save-reservation''. Checker should verify a persisted state update, not just transient text.' - id: date_input_text-antd-T08 name: AntD masked date input in dark compact small card canonical_type: date_input_text implementation_source: antd implementation_variant: mask_format implementation_component: 'AntD: DatePicker (date) using Mask Format demo-style input' task_template: enter_formatted secondary_template: null browsergym_goal: In the Cutoff card, enter 2026-12-31 into the “Cutoff date” field. The task will finish automatically when done. ui_copy: 'Cutoff card: Cutoff date should be 2026-12-31.' setup_description: |- Layout: isolated_card anchored at the top-right of the viewport (not centered). Theme/spacing: dark theme with compact spacing; the component uses the small size variant. Component: one Ant Design DatePicker labeled “Cutoff date”. Configuration: the field uses a mask-like date format (YYYY-MM-DD) where the caret advances by segments; the placeholder shows a partially formatted mask (e.g., “YYYY-MM-DD” with guides). Initial state: empty. No popup is open. Sub-controls/behavior: the input attempts to align to the last valid date on blur if the typed text is close but incomplete; arrow keys can move between segments; the calendar icon is present but small. Distractors: none. Feedback: once a valid date is committed, the masked field displays the fully formatted date. scene_context: theme: dark spacing: compact layout: isolated_card placement: top_right scale: small instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 3 target_acquisition: 3 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 3 disambiguation_load: 1 justification: Small, compact masked input in a corner placement increases target acquisition difficulty and requires precise formatted entry/segment editing. success_trigger: human_readable: - The “Cutoff date” value equals 2026-12-31 after the input is committed. - No Save/Apply button is required. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-12-31' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Cutoff date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text input_mode: mask negative_cases: - Entering 2026-12-13 or 2026-11-31 (wrong day/month). - Leaving the input partially filled so the underlying date value is still null/invalid. - Relying on auto-alignment to a different date than the target. expected_interaction_path: Focus the small masked field → type 2026-12-31 (or fill segments) → blur/Enter to commit. notes: 'Implementation hint: use AntD DatePicker Mask Format example configuration. Instrument input as data-testid=''cutoff-date''.' - id: date_input_text-antd-T09 name: AntD edit a date field inside a dense table row canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: Table + DatePicker (date) in table cells' task_template: table_operation secondary_template: null browsergym_goal: In the Milestones table, set the “Milestone date” for the “Beta” row to 2026-04-01 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Milestones table: Beta → Milestone date = 2026-04-01.' setup_description: |- Layout: table_cell scene with the table centered in the viewport. Component instances: three Ant Design DatePicker inputs rendered directly inside the “Milestone date” column cells (one per row). Rows: “Alpha”, “Beta”, “Gamma”. Each cell shows a small DatePicker input (size=small, format YYYY-MM-DD) with a calendar icon; manual typing is enabled. Initial state: - Alpha milestone date: 2026-03-15 - Beta milestone date: empty - Gamma milestone date: 2026-05-10 Clutter (high): table also includes an “Owner” dropdown and a “Status” tag column; these are distractors and not required. Feedback: the edited cell updates immediately after commit and the table highlights the changed cell briefly (1s). scene_context: theme: light spacing: compact layout: table_cell placement: center scale: small instances: 3 guidance: text clutter: high difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 4 density_choice_interference: 3 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 4 justification: Multiple small, similar date inputs inside a dense table require precise target acquisition and correct row disambiguation. success_trigger: human_readable: - In the “Beta” row, the “Milestone date” cell’s DatePicker value equals 2026-04-01. - Other rows’ milestone dates may remain unchanged. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-04-01' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Milestone date (Beta) terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text table_row_key: Beta table_column_key: milestone_date negative_cases: - Setting the Alpha or Gamma row’s date to 2026-04-01 instead of Beta. - Entering 2026-01-04 (month/day swapped) or any other incorrect date. - Leaving Beta empty or in an invalid state. expected_interaction_path: Find the Beta row → focus its Milestone date input → type 2026-04-01 → commit by Enter/blur. notes: 'Instrumentation: add data-row-key attributes for each row and data-testid for each cell input (e.g., milestone-date-beta). Checker should resolve the correct row via stable row key, not screen position.' - id: date_input_text-antd-T10 name: AntD match reference date with Apply in a cluttered dashboard canonical_type: date_input_text implementation_source: antd implementation_variant: null implementation_component: 'AntD: DatePicker (date) x2 + sticky Apply bar' task_template: match_reference secondary_template: null browsergym_goal: Set the “Backup deadline” field to match the date shown on the “Reference calendar” tile, then click “Apply changes”. The task will finish automatically when done. ui_copy: 'Dashboard: Backup deadline must match Reference calendar, then Apply changes.' setup_description: |- Layout: dashboard scene anchored at the bottom-right of the viewport (not centered). Components: Two Ant Design DatePicker inputs in a “Deadlines” panel: - “Primary deadline” (pre-filled with 2026-04-01) - “Backup deadline” (empty) Both use YYYY-MM-DD format and allow manual typing. Visual reference: a separate tile labeled “Reference calendar” shows the target date prominently as “APR 09 2026”. Clutter (medium): the dashboard also contains a small activity feed and two filter chips; they are irrelevant. Confirmation: a sticky footer bar contains “Discard” and a primary “Apply changes” button. Changes are not persisted until “Apply changes” is clicked. Feedback: clicking “Apply changes” shows a toast “Changes applied” and the sticky bar disappears. scene_context: theme: light spacing: comfortable layout: dashboard placement: bottom_right scale: default instances: 2 guidance: visual clutter: medium difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 3 density_choice_interference: 2 depth_layering: 2 feedback_dynamics: 3 semantic_observability: 3 disambiguation_load: 3 justification: Requires reading a visual reference, editing the correct field among two similar instances, and committing via an explicit Apply action. success_trigger: human_readable: - The “Backup deadline” DatePicker value equals the reference date 2026-04-09. - The user has clicked “Apply changes” (confirmation required) so the value is persisted. canonical_predicate: predicate_type: matches_reference target_state: date_iso: '2026-04-09' reference_id: reference-calendar-tile tolerance: days: 0 require_confirm: true confirm_control: Apply changes require_correct_instance: true target_instance_label_or_id: Backup deadline terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text persisted_state_id: deadlines.backup negative_cases: - Setting “Primary deadline” instead of “Backup deadline”. - Entering the correct date but not clicking “Apply changes”. - Clicking “Discard”. - Choosing a date that is off by one day (e.g., 2026-04-08 or 2026-04-10). expected_interaction_path: Read date on Reference calendar tile → focus Backup deadline → type corresponding YYYY-MM-DD → commit → click Apply changes. notes: 'Instrumentation: data-testid=''primary-deadline'', ''backup-deadline'', ''apply-changes'', ''reference-calendar-tile''. Checker should verify persisted state updated after Apply.' - id: date_input_text-mui-T01 name: MUI DateField basic typed date (MM/DD/YYYY) canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField' task_template: enter_formatted secondary_template: null browsergym_goal: Set the “Birthday” field to 03/15/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Goal: Birthday = 03/15/2026.' setup_description: |- Layout: isolated_card centered in the viewport. Component: One MUI X DateField labeled “Birthday”. Visuals/behavior: the field shows a placeholder like “MM/DD/YYYY” and uses a sectioned input (month/day/year sections) typical of MUI X fields. Initial state: empty; no popover is open (field-only). Sub-controls: a calendar icon is not shown (DateField only); the user edits directly in the field. Distractors: none. Feedback: once a valid date is entered, the field displays it in MM/DD/YYYY and the internal value becomes a valid date object. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 2 disambiguation_load: 1 justification: Single date field with a clear placeholder; no overlays or extra confirmations. success_trigger: human_readable: - The DateField value (canonical date) equals 2026-03-15. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-03-15' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Entering 03/05/2026 or 05/03/2026 (swapped day/month). - Leaving the field incomplete so it does not parse to a valid date value. - Leaving it empty. expected_interaction_path: Focus the DateField → type 03/15/2026 (or fill sections) → blur/Enter to commit. notes: 'Instrumentation: data-testid=''birthday-datefield''. Checker should normalize the Date value to ISO.' - id: date_input_text-mui-T02 name: MUI DateField overwrite an existing date canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField' task_template: set_scalar secondary_template: null browsergym_goal: Change the “Start date” field to 02/28/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Goal: Start date should be 02/28/2026.' setup_description: |- Layout: isolated_card centered in the viewport. Component: One MUI X DateField labeled “Start date”. Initial state: pre-filled with 02/10/2026. Behavior: the DateField uses month/day/year sections; user can edit by selecting sections and typing. Distractors: a read-only “Project name” text line above the field. Feedback: the value updates in place when the edit is committed (blur/Enter). scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Overwriting a pre-filled value adds a small edit step, but the field is isolated with clear feedback. success_trigger: human_readable: - The “Start date” DateField value equals 2026-02-28. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-02-28' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Start date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Leaving the original date (02/10/2026). - Entering 02/18/2026 or any other incorrect date. - Typing but not committing (checker still reads old value). expected_interaction_path: Focus Start date field → select/overwrite sections → type 02/28/2026 → commit. notes: 'Instrumentation: data-testid=''start-date''. For sectioned fields, checker should read the component value rather than DOM text only.' - id: date_input_text-mui-T03 name: MUI DateField clear using clearable control canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField (clearable)' task_template: clear_reset secondary_template: null browsergym_goal: Clear the “Due date” field so it becomes empty. The task will finish automatically when done. ui_copy: 'Goal: Due date should be cleared (empty).' setup_description: |- Layout: isolated_card centered in the viewport. Component: One MUI X DateField labeled “Due date” with clearable behavior enabled. Initial state: pre-filled with 04/05/2026. Sub-controls: a small clear icon button appears inside the field when it has a value (standard MUI X clearable behavior). Distractors: none. Feedback: after clearing, the field shows the placeholder “MM/DD/YYYY” again and the value becomes null. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L1 axes_ratings: precision_requirement: 1 target_acquisition: 3 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Clearing requires acquiring a small clear icon (or deleting all sections), but the page is otherwise minimal. success_trigger: human_readable: - The “Due date” DateField value is empty/null (no date selected). canonical_predicate: predicate_type: equals target_state: date_iso: null tolerance: null require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Due date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text empty_ok: true negative_cases: - A date value remains set (including 04/05/2026). - Only selecting text/sections without clearing the underlying value. - Leaving an invalid partial date that does not clear to null. expected_interaction_path: Focus Due date field → click clear icon (or delete content) → ensure placeholder returns. notes: 'Instrumentation: data-testid=''due-date''. If using MUI X clearable prop, also tag clear button data-testid=''due-date-clear''.' - id: date_input_text-mui-T04 name: MUI two DateFields in a form section (disambiguate by label) canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField x2' task_template: set_scalar secondary_template: null browsergym_goal: In the Schedule form, set the “End date” field to 05/20/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Schedule form: End date = 05/20/2026.' setup_description: |- Layout: form_section centered in the viewport with a header “Schedule”. Components: two MUI X DateField inputs stacked with labels: - “Start date” (pre-filled with 05/10/2026) - “End date” (empty) Both fields use MM/DD/YYYY and sectioned editing. Distractors (clutter=low): a “Timezone” select (disabled) and a “Notes” multiline field (optional) are visible. Feedback: entering a valid date updates the field’s displayed value and removes any placeholder sections. scene_context: theme: light spacing: comfortable layout: form_section placement: center scale: default instances: 2 guidance: text clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 2 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 3 justification: Two similar fields require selecting the correct instance; otherwise the interaction is simple sectioned typing. success_trigger: human_readable: - The “End date” DateField value equals 2026-05-20. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-05-20' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: End date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Setting “Start date” to 05/20/2026 instead of “End date”. - Entering 05/02/2026 or any other incorrect date. - Leaving End date empty. expected_interaction_path: Find End date field → focus → type 05/20/2026 → commit. notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Ensure labels are programmatically associated with inputs for accessibility-based agents.' - id: date_input_text-mui-T05 name: MUI DateField with dash separator custom format canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField (custom format YYYY-MM-DD)' task_template: enter_formatted secondary_template: null browsergym_goal: Set the “Archive date” field to 2026-06-30 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Archive date = 2026-06-30.' setup_description: |- Layout: isolated_card centered in the viewport. Component: one MUI X DateField labeled “Archive date”. Configuration: the field uses a dash-separated display/parse format (YYYY-MM-DD) and shows a placeholder like “YYYY-MM-DD”. Initial state: empty. Behavior: sectioned input still applies, but separators are dashes; users can type the full string or edit sections. Distractors: none. Feedback: the value becomes valid only when all sections form a real calendar date. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 3 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Custom formatting increases precision requirements and can trip agents that assume the default MM/DD/YYYY layout. success_trigger: human_readable: - The “Archive date” DateField value equals 2026-06-30. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-06-30' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Archive date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text expected_display_format: YYYY-MM-DD negative_cases: - Entering 06/30/2026 (slashes) if it does not parse under the configured format. - Entering 2026-30-06 (swapped month/day). - Leaving the field partially filled so it remains invalid. expected_interaction_path: Focus Archive date → type 2026-06-30 → commit by blur/Enter. notes: 'Instrumentation: data-testid=''archive-date''. Configure MUI X format explicitly so the UI is deterministic.' - id: date_input_text-mui-T06 name: MUI scroll to find a date field in settings panel canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField inside a scrollable Settings panel' task_template: scroll_find secondary_template: null browsergym_goal: In Settings, scroll to the “Data retention start date” field and set it to 08/01/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Settings: Data retention start date = 08/01/2026.' setup_description: |- Layout: settings_panel. The page has a left navigation rail (non-interactive for this task) and a main scrollable settings pane. Target component: a MUI X DateField labeled “Data retention start date” located in the “Retention” section near the bottom of the scrollable pane (initially below the fold). Initial state: the field is empty. Other content (clutter=medium): multiple toggles, helper text paragraphs, and a numeric input appear above it; none affect success. Behavior: standard sectioned MM/DD/YYYY input; no popovers. Feedback: after entry, the field displays “08/01/2026” and the section header shows a small “Unsaved changes” dot (cosmetic). scene_context: theme: light spacing: comfortable layout: settings_panel placement: bottom_left scale: default instances: 1 guidance: text clutter: medium difficulty: difficulty_bucket: mid tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 2 depth_layering: 3 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 2 justification: Requires scrolling within a settings pane to locate the correct labeled field amid moderate clutter before performing the usual date entry. success_trigger: human_readable: - The “Data retention start date” DateField value equals 2026-08-01. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-08-01' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Data retention start date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text scroll_required: true negative_cases: - Entering the date in a different setting field. - Entering any date other than 08/01/2026. - Leaving the field empty because it was not found. expected_interaction_path: Scroll the settings pane until the Retention section → focus Data retention start date → type 08/01/2026 → commit. notes: 'Instrumentation: data-testid=''retention-start-date''. Include a stable section container id for scroll targeting.' - id: date_input_text-mui-T07 name: MUI match a date from a shipping label preview canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField' task_template: match_reference secondary_template: null browsergym_goal: Set the “Ship date” field to match the date shown on the “Shipping label preview”. The task will finish automatically when done. ui_copy: 'Goal: Ship date must match the Shipping label preview.' setup_description: |- Layout: dashboard-style card centered in the viewport. Left side: a MUI X DateField labeled “Ship date” (MM/DD/YYYY). Right side: a “Shipping label preview” panel that visually prints the target date in bold, uppercase stamp style: “SEP 09 2026” Initial state: Ship date field is empty. Clutter (low): a disabled “Carrier” dropdown is visible under the preview (not required). Feedback: when a valid date is entered, the date field updates; the preview’s “Ship date” line also updates (cosmetic). scene_context: theme: light spacing: comfortable layout: dashboard placement: center scale: default instances: 1 guidance: visual clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 3 disambiguation_load: 2 justification: The instruction omits the exact date, requiring the agent to extract it from a visual preview before entering it. success_trigger: human_readable: - The “Ship date” value equals the reference date 2026-09-09. canonical_predicate: predicate_type: matches_reference target_state: date_iso: '2026-09-09' reference_id: shipping-label-preview tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Ship date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Entering a different date than shown in the preview. - Leaving the field empty or invalid. - Entering the correct date into a non-target field (if any). expected_interaction_path: Read the stamped date on the preview → enter that date into Ship date → commit. notes: 'Instrumentation: data-testid=''ship-date'' and ''shipping-label-preview''.' - id: date_input_text-mui-T08 name: MUI DatePicker field inside dark themed modal with Save canonical_type: date_input_text implementation_source: mui implementation_variant: DatePicker implementation_component: 'MUI X: DatePicker (keyboard input) inside a Dialog' task_template: confirm_cancel secondary_template: null browsergym_goal: Open the “New appointment” dialog, set “Appointment date” to 10/12/2026 (MM/DD/YYYY), then click “Save appointment”. The task will finish automatically when done. ui_copy: New appointment → Appointment date = 10/12/2026 → Save appointment. setup_description: |- Layout: modal_flow with dark theme. Base page: a small toolbar with a primary button “New appointment”. Clicking it opens a MUI Dialog in the center containing a short form: - “Title” text field (prefilled; not required) - “Appointment date” using MUI X DatePicker input field (manual typing supported; calendar popover can be opened from the field but is optional) Footer buttons: “Cancel” and “Save appointment”. Initial state: Appointment date is empty when the dialog opens. Feedback: after clicking “Save appointment”, the dialog closes and an inline confirmation text appears (“Appointment saved”). scene_context: theme: dark spacing: comfortable layout: modal_flow placement: center scale: default instances: 1 guidance: text clutter: low difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 3 feedback_dynamics: 3 semantic_observability: 2 disambiguation_load: 2 justification: Multiple-layer interaction (open dialog, edit date, then explicitly save) with dark theme reduces contrast and increases layering/feedback demands. success_trigger: human_readable: - The “Appointment date” value equals 2026-10-12. - The user clicked “Save appointment” and the saved value is persisted. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-10-12' tolerance: days: 0 require_confirm: true confirm_control: Save appointment require_correct_instance: true target_instance_label_or_id: Appointment date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text persisted_state_id: appointment.date negative_cases: - Entering the correct date but closing the dialog without saving. - Clicking “Cancel”. - Saving a different date. - Leaving the field invalid/empty. expected_interaction_path: Click New appointment → focus Appointment date field → type 10/12/2026 → commit → click Save appointment. notes: 'Instrumentation: data-testid=''new-appointment'', dialog data-testid=''appointment-dialog'', date field data-testid=''appointment-date'', save button data-testid=''save-appointment''.' - id: date_input_text-mui-T09 name: MUI edit a date field inside a compact table canonical_type: date_input_text implementation_source: mui implementation_variant: DateField implementation_component: 'MUI X: DateField in DataGrid/Table cells' task_template: table_operation secondary_template: null browsergym_goal: In the Release plan table, set the “Release date” for the “v2.0” row to 11/01/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Release plan: v2.0 → Release date = 11/01/2026.' setup_description: |- Layout: table_cell anchored near the top-left of the viewport. Theme/spacing: light theme with compact spacing; small component scale. Table: a compact release plan table with three rows: “v1.0”, “v2.0”, “v3.0”. Component instances: each row contains an inline editable MUI X DateField in the “Release date” column (MM/DD/YYYY). Initial state: - v1.0: 09/01/2026 - v2.0: empty - v3.0: 12/15/2026 Clutter (high): additional columns (“Owner”, “Risk”) include chips and icons; not required. Feedback: after a valid date is entered in the v2.0 row, the cell shows the formatted date and briefly displays a small “Edited” indicator on that row. scene_context: theme: light spacing: compact layout: table_cell placement: top_left scale: small instances: 3 guidance: text clutter: high difficulty: difficulty_bucket: hard tier: L3 axes_ratings: precision_requirement: 2 target_acquisition: 4 density_choice_interference: 3 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 4 justification: Dense table layout with multiple small, similar date fields creates high disambiguation load and target acquisition difficulty. success_trigger: human_readable: - In the “v2.0” row, the “Release date” field value equals 2026-11-01. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-11-01' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Release date (v2.0) terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text table_row_key: v2.0 table_column_key: release_date negative_cases: - Editing v1.0 or v3.0 instead of v2.0. - Entering 01/11/2026 (day/month swapped) or any other incorrect date. - Leaving the v2.0 cell empty or invalid. expected_interaction_path: Locate v2.0 row → focus Release date cell → type 11/01/2026 → commit. notes: 'Instrumentation: stable row keys; data-testid=''release-date-v2''. Checker should match by row key, not visual order.' - id: date_input_text-mui-T10 name: MUI fix a validation error and set an in-range date canonical_type: date_input_text implementation_source: mui implementation_variant: DatePicker implementation_component: 'MUI X: DatePicker (keyboard input) with min/max validation' task_template: set_scalar secondary_template: null browsergym_goal: Set the “Compliance date” field to 07/01/2026 (MM/DD/YYYY). The task will finish automatically when done. ui_copy: 'Compliance: Compliance date must be 07/01/2026.' setup_description: |- Layout: form_section anchored near the bottom-left of the viewport. Component: a single MUI X DatePicker input labeled “Compliance date” (manual typing supported). Validation configuration: the field enforces an allowed range (minDate=01/01/2026, maxDate=12/31/2026) and shows an error helper text when out of range. Initial state: the field is pre-filled with 01/01/2027 and is currently in an error state (red underline + helper text “Date must be within 2026”). Clutter (medium): there are two non-required controls nearby: a checkbox “Send reminder email” and a disabled text field “Compliance owner”. Feedback: when a valid in-range date is entered, the error state disappears and the helper text changes to “Looks good”. scene_context: theme: light spacing: comfortable layout: form_section placement: bottom_left scale: default instances: 1 guidance: text clutter: medium difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 2 feedback_dynamics: 4 semantic_observability: 2 disambiguation_load: 2 justification: The field starts in an error state with range validation, requiring the agent to correct the value and observe error feedback clearing. success_trigger: human_readable: - The “Compliance date” value equals 2026-07-01. - The field is not in an error/invalid state after commit. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-07-01' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Compliance date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text require_valid: true negative_cases: - Entering a date outside 2026 (error remains). - Entering 01/07/2026 (month/day swapped). - Leaving the invalid initial value (01/01/2027). - Typing without committing so the component value does not update. expected_interaction_path: Focus Compliance date → replace with 07/01/2026 → commit → verify error cleared. notes: 'Instrumentation: data-testid=''compliance-date''. Checker should verify both value equality and validity flag (no error).' - id: date_input_text-mantine-T01 name: Mantine DateInput basic typed ISO date canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput' task_template: enter_formatted secondary_template: null browsergym_goal: In the Date input card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Invoice date = 2026-02-14.' setup_description: |- Layout: isolated_card centered in the viewport. Component: one Mantine DateInput labeled “Invoice date”. Configuration: the input displays/accepts YYYY-MM-DD (valueFormat set accordingly) and shows placeholder “YYYY-MM-DD”. Initial state: empty; dropdown calendar is closed. Sub-controls: a calendar icon is shown inside the input; a clear button appears only when a value exists (if clearable is enabled, but not needed here). Distractors: none. Feedback: after committing a valid date, the input displays the formatted value and keeps it as the canonical date state. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 2 disambiguation_load: 1 justification: Single Mantine DateInput with explicit placeholder and immediate visible value after typing. success_trigger: human_readable: - The DateInput value (canonical date) equals 2026-02-14. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-02-14' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: false target_instance_label_or_id: null terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Entering 2026-02-41 or another invalid date string (should not parse). - Entering any other date. - Leaving the field empty. expected_interaction_path: Click input → type 2026-02-14 → blur/Enter to commit. notes: 'Instrumentation: data-testid=''invoice-date''. Checker reads Date value and normalizes to ISO.' - id: date_input_text-mantine-T02 name: Mantine overwrite an existing date value canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput' task_template: set_scalar secondary_template: null browsergym_goal: Change the “Renewal date” field to 2026-03-31 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Renewal date should be 2026-03-31.' setup_description: |- Layout: isolated_card centered in the viewport. Component: one Mantine DateInput labeled “Renewal date” with valueFormat YYYY-MM-DD. Initial state: pre-filled with 2026-03-01. Sub-controls: calendar icon is present but optional; editing can be done via typing. Distractors: none. Feedback: once a valid date is committed, the input displays the new value and any internal error state remains clear. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L0 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Requires replacing an existing value but remains a single isolated date input with clear feedback. success_trigger: human_readable: - The “Renewal date” DateInput value equals 2026-03-31. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-03-31' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Renewal date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Leaving the original date (2026-03-01). - Entering 2026-03-13 or any other incorrect date. - Typing without committing so the value doesn't update. expected_interaction_path: Focus Renewal date → select/overwrite → type 2026-03-31 → commit. notes: 'Instrumentation: data-testid=''renewal-date''.' - id: date_input_text-mantine-T03 name: Mantine clear a date with clearable button canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput (clearable)' task_template: clear_reset secondary_template: null browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done. ui_copy: 'Goal: Reminder date should be cleared (empty).' setup_description: |- Layout: isolated_card centered in the viewport. Component: one Mantine DateInput labeled “Reminder date” with clearable enabled (clear button appears in the right section when a value exists). Initial state: pre-filled with 2026-04-10. Sub-controls: calendar icon + clear (✕) button within the input’s right section. Distractors: none. Feedback: clearing removes the value and restores the placeholder “YYYY-MM-DD”. scene_context: theme: light spacing: comfortable layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: easy tier: L1 axes_ratings: precision_requirement: 1 target_acquisition: 3 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 1 justification: Clearing relies on a small right-section control, but the rest of the scene is minimal and the cleared state is obvious. success_trigger: human_readable: - The “Reminder date” DateInput value is empty/null (no date selected). canonical_predicate: predicate_type: equals target_state: date_iso: null tolerance: null require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Reminder date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text empty_ok: true negative_cases: - Any date remains set (including 2026-04-10). - Selecting text without clearing the underlying value. - Leaving an invalid partial string that does not clear to null. expected_interaction_path: Focus Reminder date → click the clear (✕) button (or delete all text) → commit/blur. notes: 'Instrumentation: data-testid=''reminder-date'' and data-testid=''reminder-date-clear'' for the clear button.' - id: date_input_text-mantine-T04 name: Mantine two DateInputs in a form section canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput x2' task_template: set_scalar secondary_template: null browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Booking form: End date = 2026-05-20.' setup_description: |- Layout: form_section centered in the viewport with header “Booking”. Components: two Mantine DateInput fields side-by-side: - “Start date” (pre-filled with 2026-05-10) - “End date” (empty) Both use valueFormat YYYY-MM-DD and allow free-form typing; calendar dropdown is available but optional. Distractors (clutter=low): a “Guests” number input and a “Room type” select are shown but not required. Feedback: after committing a valid date, the End date input shows the new value. scene_context: theme: light spacing: comfortable layout: form_section placement: center scale: default instances: 2 guidance: text clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 2 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 3 justification: Requires choosing the correct date field among two similar instances within a realistic form layout. success_trigger: human_readable: - The “End date” DateInput value equals 2026-05-20. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-05-20' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: End date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Setting “Start date” instead of “End date”. - Entering 2026-05-02 or any other incorrect date. - Leaving End date empty/invalid. expected_interaction_path: Focus End date → type 2026-05-20 → blur/Enter. notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''.' - id: date_input_text-mantine-T05 name: Mantine match a date from a packing slip preview canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput' task_template: match_reference secondary_template: null browsergym_goal: Set the “Delivery date” field to match the date shown on the “Packing slip preview”. The task will finish automatically when done. ui_copy: 'Goal: Delivery date must match the Packing slip preview.' setup_description: |- Layout: dashboard scene centered in the viewport. Left pane: Mantine DateInput labeled “Delivery date” (valueFormat YYYY-MM-DD). Right pane: “Packing slip preview” card with a large printed date line in a stylized header: “JUN 10 2026” Initial state: Delivery date input is empty. Clutter (low): the preview also shows a fake order number and address lines (non-interactive). Feedback: once a valid date is entered, the Delivery date field displays it; the preview updates a small “Delivery date” line (cosmetic). scene_context: theme: light spacing: comfortable layout: dashboard placement: center scale: default instances: 1 guidance: visual clutter: low difficulty: difficulty_bucket: mid tier: L1 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 1 semantic_observability: 3 disambiguation_load: 2 justification: The date must be extracted from an on-screen preview rather than being provided directly in text instructions. success_trigger: human_readable: - The “Delivery date” DateInput value equals the reference date 2026-06-10. canonical_predicate: predicate_type: matches_reference target_state: date_iso: '2026-06-10' reference_id: packing-slip-preview tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Delivery date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text negative_cases: - Entering a different date than shown on the preview. - Leaving the input empty or invalid. - Typing the date into a non-target field (if any). expected_interaction_path: Read date from Packing slip preview → type equivalent YYYY-MM-DD into Delivery date → commit. notes: 'Instrumentation: data-testid=''delivery-date'' and data-testid=''packing-slip-preview''.' - id: date_input_text-mantine-T06 name: Mantine scroll to locate a DateInput in settings panel canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput in a scrollable Settings panel' task_template: scroll_find secondary_template: null browsergym_goal: In Settings, scroll to the “Maintenance date” field and set it to 2026-07-15 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Settings: Maintenance date = 2026-07-15.' setup_description: |- Layout: settings_panel with a scrollable main content area. Target component: a Mantine DateInput labeled “Maintenance date” in the “System maintenance” section located near the bottom of the settings content (initially below the fold). Configuration: valueFormat YYYY-MM-DD; free-form typing enabled. Initial state: empty. Clutter (medium): several switches, sliders, and informational callouts appear above; they are distractors. Feedback: after entering a valid date, the input shows the formatted date and a small helper text appears (“Next maintenance scheduled”). scene_context: theme: light spacing: comfortable layout: settings_panel placement: bottom_right scale: default instances: 1 guidance: text clutter: medium difficulty: difficulty_bucket: mid tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 2 depth_layering: 3 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 2 justification: The agent must scroll within a settings panel to find the correct labeled DateInput amid moderate clutter before entering the target date. success_trigger: human_readable: - The “Maintenance date” DateInput value equals 2026-07-15. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-07-15' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Maintenance date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text scroll_required: true negative_cases: - Entering the date in a different field in Settings. - Entering any date other than 2026-07-15. - Leaving the Maintenance date field empty because it was not found. expected_interaction_path: Scroll to System maintenance section → focus Maintenance date → type 2026-07-15 → commit. notes: 'Instrumentation: data-testid=''maintenance-date''. Provide stable section anchors for automated scrolling.' - id: date_input_text-mantine-T07 name: Mantine DateInput with min/max and weekdays-only validation canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput with minDate/maxDate + exclude weekends' task_template: set_scalar secondary_template: null browsergym_goal: Set the “Payroll date” field to 2026-02-25 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Goal: Payroll date = 2026-02-25.' setup_description: |- Layout: isolated_card centered in the viewport. Component: one Mantine DateInput labeled “Payroll date” (valueFormat YYYY-MM-DD). Validation configuration: - minDate = 2026-02-01 - maxDate = 2026-02-28 - weekends are disabled (only weekdays are allowed) A helper hint under the input reads: “Weekdays only. Allowed range: 2026-02-01 to 2026-02-28.” Initial state: pre-filled with 2026-02-10 (a valid weekday). Behavior: if the user types a date outside the allowed range or on a weekend, the input is considered invalid and reverts to the last known valid date when blurred/committed (Mantine DateInput validation behavior). Distractors: none. Feedback: invalid entry shows a brief inline error message (“Invalid date”) before reverting; valid entry clears the error and keeps the new value. scene_context: theme: light spacing: compact layout: isolated_card placement: center scale: default instances: 1 guidance: text clutter: none difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 3 target_acquisition: 2 density_choice_interference: 1 depth_layering: 1 feedback_dynamics: 4 semantic_observability: 3 disambiguation_load: 1 justification: Strict validity constraints with automatic revert on invalid input increase feedback dynamics and require careful formatted entry. success_trigger: human_readable: - The “Payroll date” DateInput value equals 2026-02-25. - The value is valid under the configured constraints (within range and not a weekend). canonical_predicate: predicate_type: equals target_state: date_iso: '2026-02-25' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Payroll date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text require_valid: true constraints: min: '2026-02-01' max: '2026-02-28' weekdays_only: true negative_cases: - Entering a weekend date (e.g., 2026-02-28) so the input reverts. - Entering a date outside the allowed range so the input reverts. - Leaving the original date (2026-02-10). - Typing without committing (checker still reads old value). expected_interaction_path: Focus Payroll date → replace with 2026-02-25 → blur/Enter to commit → ensure it stays (no revert). notes: 'Instrumentation: data-testid=''payroll-date''. Checker should verify component value and that error state is false.' - id: date_input_text-mantine-T08 name: Mantine edit a date input inside a dense table canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput in table cells (multiple instances)' task_template: table_operation secondary_template: null browsergym_goal: In the Maintenance table, set the “Maintenance date” for the “Server B” row to 2026-09-01 (YYYY-MM-DD). The task will finish automatically when done. ui_copy: 'Maintenance table: Server B → Maintenance date = 2026-09-01.' setup_description: |- Layout: table_cell scene anchored at the bottom-right of the viewport. Theme/spacing: light theme with compact spacing; small component scale. Table: three rows labeled “Server A”, “Server B”, “Server C”. Component instances: each row has an inline Mantine DateInput in the “Maintenance date” column (valueFormat YYYY-MM-DD). Initial state: - Server A: 2026-08-15 - Server B: empty - Server C: 2026-10-20 Clutter (high): additional columns show status pills and action icons; these do not affect success. Feedback: the edited cell updates after the input is committed and briefly shows a subtle background highlight. scene_context: theme: light spacing: compact layout: table_cell placement: bottom_right scale: small instances: 3 guidance: text clutter: high difficulty: difficulty_bucket: hard tier: L3 axes_ratings: precision_requirement: 2 target_acquisition: 4 density_choice_interference: 3 depth_layering: 1 feedback_dynamics: 2 semantic_observability: 2 disambiguation_load: 4 justification: Small inputs embedded in a compact table increase pointing precision needs and disambiguation across multiple similar instances. success_trigger: human_readable: - In the “Server B” row, the “Maintenance date” DateInput value equals 2026-09-01. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-09-01' tolerance: days: 0 require_confirm: false confirm_control: null require_correct_instance: true target_instance_label_or_id: Maintenance date (Server B) terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text table_row_key: Server B table_column_key: maintenance_date negative_cases: - Editing Server A or Server C instead of Server B. - Entering 2026-01-09 or any other incorrect date. - Leaving Server B empty or invalid. expected_interaction_path: Find Server B row → focus its Maintenance date input → type 2026-09-01 → commit. notes: 'Instrumentation: stable row keys; data-testid=''maintenance-date-server-b''.' - id: date_input_text-mantine-T09 name: Mantine match reference date among three inputs and apply canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: DateInput x3 + Apply action bar' task_template: match_reference secondary_template: null browsergym_goal: Set the “Secondary window” date to match the date shown on the “Reference banner”, then click “Apply schedule”. The task will finish automatically when done. ui_copy: 'Schedule dashboard: Secondary window must match Reference banner → Apply schedule.' setup_description: |- Layout: dashboard scene anchored at the top-right of the viewport. Theme: dark. Components: three Mantine DateInput fields in a panel titled “Maintenance windows”: - “Primary window” (pre-filled with 2026-10-01) - “Secondary window” (empty) - “Fallback window” (pre-filled with 2026-10-15) Visual reference: a prominent “Reference banner” above the panel shows the target date in large type: “OCT 05 2026” Clutter (medium): the dashboard includes a small status chart placeholder and two filter chips; not required. Confirmation: a sticky action bar at the bottom of the panel has “Reset” and a primary button “Apply schedule”. Changes are only persisted after “Apply schedule”. Feedback: after Apply, a toast “Schedule applied” appears and the sticky bar collapses. scene_context: theme: dark spacing: comfortable layout: dashboard placement: top_right scale: default instances: 3 guidance: visual clutter: medium difficulty: difficulty_bucket: hard tier: L3 axes_ratings: precision_requirement: 2 target_acquisition: 3 density_choice_interference: 2 depth_layering: 2 feedback_dynamics: 3 semantic_observability: 3 disambiguation_load: 4 justification: Dark theme plus three similar inputs requires careful disambiguation, extracting the date from a reference banner, and committing via Apply. success_trigger: human_readable: - The “Secondary window” DateInput value equals the reference date 2026-10-05. - The user clicked “Apply schedule” and the value is persisted. canonical_predicate: predicate_type: matches_reference target_state: date_iso: '2026-10-05' reference_id: reference-banner tolerance: days: 0 require_confirm: true confirm_control: Apply schedule require_correct_instance: true target_instance_label_or_id: Secondary window terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text persisted_state_id: maintenance.secondary_window negative_cases: - Setting Primary or Fallback window instead of Secondary window. - Entering the correct date but not clicking Apply schedule. - Clicking Reset (should not count). - Entering any date other than the reference date. expected_interaction_path: Read date on Reference banner → edit Secondary window input → commit → click Apply schedule. notes: 'Instrumentation: data-testid=''primary-window'', ''secondary-window'', ''fallback-window'', ''apply-schedule'', ''reference-banner''. Checker verifies persisted state updated after Apply.' - id: date_input_text-mantine-T10 name: Mantine DateInput inside a drawer with Save/Cancel canonical_type: date_input_text implementation_source: mantine implementation_variant: null implementation_component: 'Mantine: Drawer + DateInput' task_template: confirm_cancel secondary_template: null browsergym_goal: Open the “Edit subscription” drawer, set “Next billing date” to 2026-11-15 (YYYY-MM-DD), then click “Save changes”. The task will finish automatically when done. ui_copy: Edit subscription → Next billing date = 2026-11-15 → Save changes. setup_description: |- Layout: drawer_flow. The base page shows a subscription summary and a button “Edit subscription”. Clicking it opens a right-side Drawer that slides in from the edge. Inside the drawer is a small form with: - “Plan” select (disabled; not required) - “Next billing date” (Mantine DateInput, valueFormat YYYY-MM-DD, manual typing enabled) Initial state: drawer is closed; when opened, Next billing date is empty. Drawer footer: “Cancel” and primary “Save changes”. Clutter (low): a short paragraph explaining billing (non-interactive). Feedback: after clicking “Save changes”, the drawer closes and the summary updates the displayed next billing date. scene_context: theme: light spacing: comfortable layout: drawer_flow placement: top_right scale: default instances: 1 guidance: text clutter: low difficulty: difficulty_bucket: hard tier: L2 axes_ratings: precision_requirement: 2 target_acquisition: 2 density_choice_interference: 1 depth_layering: 3 feedback_dynamics: 3 semantic_observability: 2 disambiguation_load: 2 justification: Requires handling a drawer overlay and explicitly saving; the date input is straightforward once located. success_trigger: human_readable: - The “Next billing date” value equals 2026-11-15. - The user clicked “Save changes” and the saved value is persisted to the summary. canonical_predicate: predicate_type: equals target_state: date_iso: '2026-11-15' tolerance: days: 0 require_confirm: true confirm_control: Save changes require_correct_instance: true target_instance_label_or_id: Next billing date terminal_condition: task_ends_when_predicate_holds canonical_type: date_input_text persisted_state_id: subscription.next_billing_date negative_cases: - Entering the correct date but clicking Cancel or closing the drawer without saving. - Saving a different date. - Leaving the field empty/invalid. expected_interaction_path: Click Edit subscription → in drawer, focus Next billing date → type 2026-11-15 → commit → click Save changes. notes: 'Instrumentation: data-testid=''edit-subscription'', drawer data-testid=''subscription-drawer'', input data-testid=''next-billing-date'', save button data-testid=''save-changes''.'