Initial ComponentBench data release: tasks v1+v2, cleaned human traces, difficulty audit, ontology metadata
360df42 verified | - id: calendar_embedded-antd-T01 | |
| name: Pick a single date (payday) | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: On the Project calendar, select the date 2026-02-13. The task will finish automatically when done. | |
| ui_copy: 'Project calendar — Please select: 2026-02-13' | |
| setup_description: |- | |
| Layout: isolated_card centered in the viewport (light theme, comfortable spacing, default scale). | |
| The card title reads “Project calendar”. Inside the card is an Ant Design Calendar component showing February 2026 by default. | |
| The calendar header includes month and year controls (month selector + year selector) and left/right navigation arrows. | |
| No date is selected initially; only the standard hover/active styling appears when interacting. | |
| Below the calendar there is a small readout line labeled “Selected date:” which updates live to an ISO date (YYYY-MM-DD) when a day cell is selected. | |
| There are no other interactive elements on the page (no clutter/distractors). | |
| 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: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Selecting one day in a single, full-size embedded calendar is straightforward with immediate visual highlighting and a textual readout. | |
| success_trigger: | |
| human_readable: | |
| - The AntD Calendar's selected date equals 2026-02-13. | |
| - No confirmation/apply action is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-02-13' | |
| 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 | |
| negative_cases: | |
| - Selecting 2026-02-13 in a different month/year view (e.g., 2025-02-13 or 2026-03-13). | |
| - Selecting the wrong day number (e.g., 2026-02-12 or 2026-02-14). | |
| - Only hovering the date without committing selection (Selected date readout stays empty/unchanged). | |
| expected_interaction_path: | |
| - Click the day cell labeled “13” in the February 2026 grid. | |
| notes: 'Checker hint: read selected date from controlled Calendar value (or from the page''s ''Selected date'' readout bound to Calendar onSelect).' | |
| - id: calendar_embedded-antd-T02 | |
| name: Navigate to a specific month (June 2026) | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: Navigate the calendar so it is showing June 2026. You do not need to select a day. The task will finish automatically when done. | |
| ui_copy: 'Viewing month target: June 2026' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single Ant Design Calendar. It initially renders February 2026. | |
| The header shows the current month/year and provides controls to change them (month dropdown, year dropdown, and previous/next navigation arrows). | |
| No day is pre-selected and selecting a day is allowed, but it is not required for this task. | |
| A small, non-editable label above the calendar reads “Viewing:” and mirrors the calendar’s current visible month in the format YYYY-MM. | |
| No other interactive elements are present (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The goal is purely to change the visible month using obvious header navigation; success is clearly observable via the month header and the 'Viewing' label. | |
| success_trigger: | |
| human_readable: | |
| - The Calendar is displaying month 2026-06 (June 2026) in its day grid view. | |
| - No day selection is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: displayed_month | |
| target_state: 2026-06 | |
| 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 | |
| negative_cases: | |
| - Calendar remains on any month other than June 2026 (e.g., 2026-05 or 2026-07). | |
| - Switching to a year/month panel that does not end with the day grid showing June 2026. | |
| - Selecting a day while still not displaying June 2026. | |
| expected_interaction_path: | |
| - Use the month/year controls or next/previous arrows to reach June 2026. | |
| - Stop once the header (and the 'Viewing' label) indicate 2026-06. | |
| notes: 'Checker hint: derive displayed_month from Calendar panel value in ''date'' mode (YYYY-MM).' | |
| - id: calendar_embedded-antd-T03 | |
| name: Clear the selected date | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the currently selected date in the Project calendar so that no date is selected. The task will finish automatically when done. | |
| ui_copy: Project calendar — Selected date is currently set. Clear it. | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card shows a single Ant Design Calendar on February 2026. | |
| One day is pre-selected on load: 2026-02-07 (the day cell is highlighted as selected). | |
| Below the calendar, a readout line shows “Selected date: 2026-02-07”. | |
| To the right of the readout is a small link-style control labeled “Clear selection” that resets the calendar selection to empty (no selected date). | |
| There are no other interactive widgets on the page (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The state is clearly visible and clearing requires a single obvious action with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - The Calendar has no selected date (selection cleared / null). | |
| - The 'Selected date' readout shows an empty state (e.g., '—' or '(none)'). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: 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 | |
| negative_cases: | |
| - Selecting a different date instead of clearing (any non-null selected date). | |
| - Clearing some other UI element (if any) while the calendar still shows 2026-02-07 selected. | |
| - Leaving the calendar with a pending highlight but the committed selected date not cleared. | |
| expected_interaction_path: | |
| - Click the “Clear selection” control next to the Selected date readout. | |
| - Verify the selected highlight disappears and the readout becomes empty. | |
| notes: 'Checker hint: calendar selected value should become null; accept either null or explicit ''(none)'' sentinel if used in the adapter.' | |
| - id: calendar_embedded-antd-T04 | |
| name: Select the date indicated by a reference chip | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the date marked as the Target (blue) on the Project calendar. The task will finish automatically when done. | |
| ui_copy: 'Target: blue chip + blue dot in calendar' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single Ant Design Calendar set to February 2026. | |
| Above the calendar header is a small “Target” chip: a blue pill showing the text “Target: 2026-02-18 (Wed)”. | |
| Inside the calendar grid, the target day cell (February 18) also shows a small blue dot in the corner (rendered via dateCellRender), matching the chip color. | |
| No date is selected initially. A “Selected date:” readout below the calendar updates live when you select a day. | |
| No other components are on the page (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: mixed | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: easy | |
| tier: L0 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: The target is clearly specified by both text and a matching visual marker, making it easy to identify and click the correct day. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals the Target chip date (2026-02-18). | |
| - No additional confirmation is required. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| state_field: selected_date | |
| target_state: | |
| reference_element: target_chip | |
| resolved_date_iso: '2026-02-18' | |
| 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 | |
| negative_cases: | |
| - Selecting any date other than the target (including another date that has a different dot color). | |
| - Selecting the correct day number in a different month/year. | |
| - Only matching the chip text visually without actually selecting the date (no selected state). | |
| expected_interaction_path: | |
| - Locate the blue Target chip to identify the target date. | |
| - Click the day cell for February 18. | |
| - Verify the selection highlight (and/or Selected date readout). | |
| notes: 'Checker hint: resolve reference date from the chip’s data attribute (e.g., data-target-date=''2026-02-18'') and compare to selected_date.' | |
| - id: calendar_embedded-antd-T05 | |
| name: Pick a date in the Secondary calendar (two instances) | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar (x2 instances)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: In the Secondary calendar, select the date 2026-02-24. The task will finish automatically when done. | |
| ui_copy: 'Primary calendar | Secondary calendar — choose Secondary: 2026-02-24' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card is split into two columns with two Ant Design Calendar instances: | |
| - Left calendar labeled “Primary” | |
| - Right calendar labeled “Secondary” | |
| Both calendars initially show February 2026 and start with no selected date. | |
| Each calendar has its own small “Selected date:” readout directly beneath it. | |
| The calendars are visually similar; the only distinguishing cue is the column label above each one. | |
| There is no other UI on the page (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Selecting a date is easy, but the agent must correctly disambiguate between two nearly identical calendar instances and avoid modifying the wrong one. | |
| success_trigger: | |
| human_readable: | |
| - The selected date of the Secondary calendar equals 2026-02-24. | |
| - The Primary calendar remains unmodified (still has no selected date). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-02-24' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Secondary | |
| terminal_condition: task ends when predicate holds | |
| non_target_instances_must_equal: | |
| Primary: null | |
| negative_cases: | |
| - Selecting 2026-02-24 in the Primary calendar instead of Secondary. | |
| - Selecting the correct date in Secondary but also selecting any date in Primary (wrong instance modified). | |
| - Selecting the wrong date (any day other than 2026-02-24) in Secondary. | |
| expected_interaction_path: | |
| - Locate the calendar labeled “Secondary”. | |
| - Click the day cell “24” (in February 2026). | |
| - Confirm only the Secondary readout updates. | |
| notes: 'Instrumentation: give each instance a stable container/testid (e.g., data-testid=''calendar-primary'' and ''calendar-secondary'') for instance-safe checking.' | |
| - id: calendar_embedded-antd-T06 | |
| name: Set an event date inside a form section | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: In the Event date calendar, set the date to 2026-09-09. The task will finish automatically when done. | |
| ui_copy: 'Event form — Event date: 2026-09-09' | |
| setup_description: |- | |
| Layout: form_section centered (light theme, comfortable spacing, default scale) with low clutter. | |
| The page shows an “Event details” form with several non-required fields (Title text input, Location text input, a non-functional “Timezone” dropdown). | |
| Below these fields is a labeled section “Event date” containing a single embedded Ant Design Calendar (not a popover). | |
| The calendar initially displays February 2026 and has no selected date. | |
| The calendar header includes month/year selectors; changing month/year updates the grid immediately. | |
| Beneath the calendar is a compact readout “Event date:” which mirrors the selected date in YYYY-MM-DD when a day is selected. | |
| Distractors: the form fields are clickable/focusable but do not affect task success; only the calendar selection matters. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: The target date is far from the initial month, requiring month/year navigation within the calendar while ignoring nearby form-field distractors. | |
| success_trigger: | |
| human_readable: | |
| - The Event date calendar’s selected date equals 2026-09-09. | |
| - No Apply/OK is required; selection is immediate. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-09-09' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: Event date | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Navigating to September 2026 but selecting the wrong day (not the 9th). | |
| - Selecting 2026-09-09 in the wrong year (e.g., 2025-09-09). | |
| - Interacting only with form inputs (Title/Location/Timezone) while the calendar remains unselected. | |
| expected_interaction_path: | |
| - Use the calendar header month/year controls to jump to September 2026. | |
| - Click day “9”. | |
| - Verify the “Event date” readout shows 2026-09-09. | |
| notes: Checker can bind to the controlled selected date state for the 'Event date' calendar container. | |
| - id: calendar_embedded-antd-T07 | |
| name: Navigate month with corner placement (December 2026) | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: Navigate the calendar so it shows December 2026. You do not need to select a day. The task will finish automatically when done. | |
| ui_copy: 'Go to: December 2026' | |
| setup_description: |- | |
| Layout: isolated_card anchored near the top-right of the viewport (light theme, comfortable spacing, default scale). | |
| A single Ant Design Calendar is embedded in the card. It initially shows February 2026. | |
| The card is intentionally positioned away from the center, so the header controls are closer to the screen edge. | |
| The calendar header provides month/year selectors and navigation arrows to change the visible month. | |
| A small label above the calendar reads “Currently viewing:” and mirrors the visible month as YYYY-MM. | |
| No other widgets are present (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: top_right | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The interaction is simple month navigation, but the component is placed in a corner which can increase misclick/viewport-edge issues for some agents. | |
| success_trigger: | |
| human_readable: | |
| - The calendar is displaying 2026-12 (December 2026) in day-grid view. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: displayed_month | |
| target_state: 2026-12 | |
| 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 | |
| negative_cases: | |
| - Stopping on the wrong month (e.g., 2026-11 or 2027-12). | |
| - Opening a month/year selector without the final visible grid being December 2026. | |
| - Selecting any day while still not displaying December 2026. | |
| expected_interaction_path: | |
| - Use month/year controls to reach December 2026. | |
| - Stop once the header and 'Currently viewing' label indicate 2026-12. | |
| notes: 'Placement robustness slice: top_right.' | |
| - id: calendar_embedded-antd-T08 | |
| name: Select a date and press Apply in a dark settings panel | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: In the Maintenance date calendar, select 2027-01-19 and then click Apply to confirm. The task will finish automatically when done. | |
| ui_copy: Settings → Maintenance date (requires Apply) | |
| setup_description: |- | |
| Layout: settings_panel (dark theme, comfortable spacing, default scale) centered in the viewport. | |
| The panel section is titled “Maintenance window” and contains one embedded Ant Design Calendar labeled “Maintenance date”. | |
| The calendar initially shows February 2026 with no committed selection. | |
| Interaction is two-phase: | |
| 1) Clicking a day sets a “Pending” highlight on the calendar (visual selection state). | |
| 2) The choice is only committed when the user clicks the primary button labeled “Apply” in the panel footer. | |
| The panel footer contains two buttons: “Cancel” (secondary) and “Apply” (primary). Clicking Cancel reverts any pending selection back to the last committed value (initially none). | |
| A readout line labeled “Confirmed date:” displays the committed ISO date (YYYY-MM-DD) and updates only after Apply is pressed. | |
| No other interactive controls affect success (clutter is limited to the settings panel chrome). | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: settings_panel | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 4 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: The agent must manage a staged selection (pending vs confirmed) and remember to click Apply; dark theme can reduce contrast and increase misreads. | |
| success_trigger: | |
| human_readable: | |
| - The committed/confirmed date equals 2027-01-19. | |
| - The Apply button has been pressed to confirm the selection (no pending-only state). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: confirmed_date | |
| target_state: '2027-01-19' | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Apply | |
| require_correct_instance: false | |
| target_instance_label_or_id: Maintenance date | |
| terminal_condition: task ends when predicate holds | |
| pending_state_must_be_empty: true | |
| negative_cases: | |
| - Selecting 2027-01-19 but not clicking Apply (confirmed date remains empty or previous value). | |
| - Clicking Apply with a different pending date selected (wrong confirmed date). | |
| - Clicking Cancel after selecting the correct date (reverts and should not count as success). | |
| expected_interaction_path: | |
| - Navigate the calendar to January 2027 (year/month controls). | |
| - Click day “19” to set it as pending. | |
| - Click “Apply” in the panel footer to commit. | |
| - Verify “Confirmed date” shows 2027-01-19. | |
| notes: 'Checker hint: track two states: pending_date (Calendar selection) and confirmed_date (committed state bound to readout). Require confirmed_date match and pending_state_must_be_empty.' | |
| - id: calendar_embedded-antd-T09 | |
| name: Pick the visually marked Target day (purple dot) | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar (with dateCellRender markers)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the day marked with the purple Target dot in the calendar. The task will finish automatically when done. | |
| ui_copy: 'Legend: Target = purple dot' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single Ant Design Calendar starting on March 2026. | |
| Above the calendar is a small legend with three dot labels: | |
| - Target (purple) | |
| - Busy (orange) | |
| - Holiday (gray) | |
| Several dates in March have orange or gray dots. Exactly one date has a purple dot (the Target). | |
| The calendar does NOT display a persistent “Selected date” text readout; selection is indicated only by the cell highlight. | |
| When you click a day, a short-lived toast appears for ~1s saying “Selected” (without repeating the date). | |
| There are no other interactive controls outside the calendar (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 4 | |
| depth_layering: 1 | |
| feedback_dynamics: 3 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: The target is specified visually among several similar in-cell markers, and the selected state is not redundantly shown as text, increasing ambiguity for agents. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals the date whose cell contains the purple Target dot (March 12, 2026). | |
| - No confirmation/apply is required. | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| state_field: selected_date | |
| target_state: | |
| reference_element: legend_target_purple_dot | |
| resolved_date_iso: '2026-03-12' | |
| 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 | |
| negative_cases: | |
| - Selecting a day with an orange Busy dot or gray Holiday dot instead of the purple Target dot. | |
| - Selecting a day with no dot. | |
| - Selecting March 12 in a different year/month (not March 2026). | |
| expected_interaction_path: | |
| - Locate the legend entry for Target (purple). | |
| - Scan the March 2026 grid to find the only purple dot. | |
| - Click that day cell. | |
| notes: 'Checker hint: target day cell includes a unique data-testid (e.g., data-marker=''target''); resolve to ISO date and compare with selected_date.' | |
| - id: calendar_embedded-antd-T10 | |
| name: Scroll the year dropdown to reach 2038 and pick a date | |
| canonical_type: calendar_embedded | |
| implementation_source: antd | |
| implementation_variant: null | |
| implementation_component: 'AntD: Calendar' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: Set the calendar to October 2038 and select the date 2038-10-02. The task will finish automatically when done. | |
| ui_copy: 'Pick: 2038-10-02' | |
| setup_description: |- | |
| Layout: isolated_card placed near the bottom-left of the viewport (light theme). | |
| Spacing mode is compact, making the calendar header controls and dropdown options tighter. | |
| The card contains a single Ant Design Calendar starting on February 2026 with no selected date. | |
| The header provides a year dropdown and month dropdown. The year dropdown contains a long, scrollable list of years. | |
| Selecting a year/month immediately updates the grid; selecting a day highlights it and updates a small “Selected date:” readout below the calendar. | |
| No other page elements are interactive (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: isolated_card | |
| placement: bottom_left | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Reaching a far future year requires scrolling within a compact dropdown list and then accurately selecting the correct day in the resulting month. | |
| success_trigger: | |
| human_readable: | |
| - The calendar’s selected date equals 2038-10-02. | |
| - The visible month corresponds to October 2038 (so the selection is unambiguous). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2038-10-02' | |
| 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 | |
| displayed_month_must_equal: 2038-10 | |
| negative_cases: | |
| - Selecting 2038-10-02 without actually reaching October 2038 view (e.g., clicking “02” in another month). | |
| - Selecting the wrong date in October 2038 (not the 2nd). | |
| - Stopping on October in the wrong year (e.g., 2028-10). | |
| expected_interaction_path: | |
| - Open the year dropdown and scroll to find 2038, then select it. | |
| - Select month October. | |
| - Click day “02”. | |
| notes: 'Checker hint: verify both selected_date and displayed_month to prevent false positives from same day-number in another month.' | |
| - id: calendar_embedded-mui-T01 | |
| name: Pick a single date (MUI DateCalendar) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: On the DateCalendar, select the date 2026-02-14. The task will finish automatically when done. | |
| ui_copy: 'Select date: 2026-02-14' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single MUI X DateCalendar (inline, no popover and no text field). | |
| The calendar initially shows February 2026 (referenceDate is set so February is visible) and no day is selected. | |
| The header shows the current month and year with left/right arrow buttons to navigate months. | |
| Clicking a day selects it (highlighted circle/fill on the day number). | |
| A helper line under the calendar reads “Selected date:” and updates immediately to YYYY-MM-DD when a selection is made. | |
| No other interactive elements are on the page (clutter: none). | |
| 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: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single-date selection in an inline calendar with immediate highlight and a textual value readout is low-friction. | |
| success_trigger: | |
| human_readable: | |
| - The DateCalendar selected date equals 2026-02-14. | |
| - No confirmation button is required. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-02-14' | |
| 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 | |
| negative_cases: | |
| - Selecting any date other than 2026-02-14. | |
| - Navigating months without selecting the day. | |
| - Selecting day 14 in a different month/year. | |
| expected_interaction_path: | |
| - Click the day cell labeled “14” in February 2026. | |
| notes: 'Checker hint: read selected value from DateCalendar controlled state (Day.js/Date) normalized to ISO date.' | |
| - id: calendar_embedded-mui-T02 | |
| name: Navigate to May 2026 (month navigation arrows) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: Navigate the calendar so it is showing May 2026. You do not need to select a day. The task will finish automatically when done. | |
| ui_copy: 'Viewing month target: May 2026' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| A single MUI X DateCalendar is embedded and starts on February 2026. | |
| The only navigation controls are the previous/next month arrow buttons in the calendar header. | |
| Day selection is enabled but not required. | |
| A small label above the calendar reads “Viewing:” and mirrors the current visible month as YYYY-MM for clarity. | |
| There are no other page controls (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: Month navigation uses a pair of obvious arrow buttons and the resulting state is clearly visible in the header and the 'Viewing' label. | |
| success_trigger: | |
| human_readable: | |
| - The DateCalendar is displaying 2026-05 (May 2026) in day-grid view. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: displayed_month | |
| target_state: 2026-05 | |
| 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 | |
| negative_cases: | |
| - Ending on April 2026 or June 2026 instead of May 2026. | |
| - Opening a year/month chooser (if present) without the final day grid showing May 2026. | |
| - Selecting a day while still not showing May 2026. | |
| expected_interaction_path: | |
| - Click the next-month arrow until the header shows May 2026. | |
| - Stop once the 'Viewing' label shows 2026-05. | |
| notes: 'Checker hint: derive displayed_month from the calendar''s current month state (often the first day of visible month).' | |
| - id: calendar_embedded-mui-T03 | |
| name: Clear the selected date (MUI DateCalendar) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the selected date so that no date is selected in the calendar. The task will finish automatically when done. | |
| ui_copy: Selected date is set — clear it | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single MUI X DateCalendar showing February 2026. | |
| A date is pre-selected on load: 2026-02-02 (the day has the selected styling). | |
| Under the calendar, a readout says “Selected date: 2026-02-02”. | |
| Next to the readout is a small button labeled “Clear date” (with a clear/close icon). Clicking it resets the selection to empty (null). | |
| No other interactive components are shown (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The calendar starts with a visible selection and provides a single dedicated control to reset it with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - The calendar has no selected date (value is null). | |
| - The selected styling on 2026-02-02 is removed. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: 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 | |
| negative_cases: | |
| - Selecting a different day instead of clearing (any non-null date). | |
| - Clicking Clear date but the calendar still shows a selected day. | |
| - Navigating months without clearing. | |
| expected_interaction_path: | |
| - Click the “Clear date” button next to the readout. | |
| - Verify the readout becomes empty and no day is highlighted. | |
| notes: 'Instrumentation: ensure ''Clear date'' has an accessible name and/or data-testid for reliable interaction across action spaces.' | |
| - id: calendar_embedded-mui-T04 | |
| name: 'Jump by year and month, then pick a day (views: year→month→day)' | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: 'DateCalendar (views: year, month, day)' | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Set the calendar to the date 2027-09-21. The task will finish automatically when done. | |
| ui_copy: 'Select date: 2027-09-21' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single MUI X DateCalendar configured with three enabled views: year, month, and day. | |
| The calendar starts in the year view (openTo='year') with a scrollable list/grid of years. | |
| Selecting a year switches to the month view (showing Jan–Dec). Selecting a month then switches to the day grid for that month. | |
| No date is selected initially. | |
| A persistent readout under the component shows “Selected date:” and updates to YYYY-MM-DD whenever a day is selected. | |
| No other interactive elements appear on the page (clutter: none). | |
| 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: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Reaching the target requires navigating across multiple internal views (year, then month, then day) and selecting the final date. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals 2027-09-21. | |
| - The calendar ended in day view showing September 2027 (so the day selection is unambiguous). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2027-09-21' | |
| 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 | |
| displayed_month_must_equal: 2027-09 | |
| negative_cases: | |
| - Stopping after choosing the correct year or month but not selecting the day (no selected_date). | |
| - Selecting the 21st in a different month/year. | |
| - Selecting September 21 but leaving the calendar in a different displayed month (indicative of mis-selection). | |
| expected_interaction_path: | |
| - In year view, select 2027. | |
| - In month view, select September. | |
| - In day grid, click day “21”. | |
| notes: 'Checker hint: normalize selected_date to ISO. For robustness, also validate displayed_month == 2027-09.' | |
| - id: calendar_embedded-mui-T05 | |
| name: Select the starred day (visual reference) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar | |
| implementation_component: 'MUI X: DateCalendar (custom day slot marker)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the day that has the star marker in the calendar. The task will finish automatically when done. | |
| ui_copy: Target day = star marker | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single MUI X DateCalendar showing March 2026. | |
| A small legend above the calendar shows an icon ★ with the label “Target”. | |
| Exactly one day cell in the March grid contains the ★ marker in its corner (all other markers, if any, are different shapes/colors). | |
| No date is selected initially. Clicking a day selects it and updates the “Selected date:” readout below the calendar. | |
| There are no other interactive elements on the page (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 4 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: The goal is specified by a visual marker inside the grid, requiring the agent to visually locate the unique starred cell among many similar day targets. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals the date whose day cell contains the ★ Target marker (2026-03-07). | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| state_field: selected_date | |
| target_state: | |
| reference_element: day_cell_star_marker | |
| resolved_date_iso: '2026-03-07' | |
| 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 | |
| negative_cases: | |
| - Selecting any non-starred day. | |
| - Selecting the correct day number in a different month/year. | |
| - Interacting with the legend without selecting the day cell. | |
| expected_interaction_path: | |
| - Identify the ★ Target marker in the March grid. | |
| - Click that day cell. | |
| notes: 'Checker hint: the starred day cell can expose data-target=''true'' for the checker; resolve ISO date and compare to selected_date.' | |
| - id: calendar_embedded-mui-T06 | |
| name: Pick a date in the Secondary calendar (two MUI calendars) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar (x2 instances) | |
| implementation_component: 'MUI X: DateCalendar (two instances)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: In the Secondary calendar, select the date 2026-03-18. The task will finish automatically when done. | |
| ui_copy: Primary | Secondary — set Secondary to 2026-03-18 | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains two MUI X DateCalendar instances arranged side-by-side: | |
| - “Primary” (left) | |
| - “Secondary” (right) | |
| Both calendars initially show March 2026 and both start with no selected date. | |
| Each instance has its own “Selected date:” readout directly underneath it. | |
| The calendars are identical in styling; the only difference is the label above each instance. | |
| No other interactive elements are present (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 2 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: The selection is simple, but two identical instances require correct target disambiguation and avoiding changes to the non-target calendar. | |
| success_trigger: | |
| human_readable: | |
| - Secondary calendar selected_date equals 2026-03-18. | |
| - Primary calendar remains unselected (null). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-03-18' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Secondary | |
| terminal_condition: task ends when predicate holds | |
| non_target_instances_must_equal: | |
| Primary: null | |
| negative_cases: | |
| - Selecting 2026-03-18 in Primary instead of Secondary. | |
| - Selecting the correct date in Secondary but also selecting any date in Primary. | |
| - Selecting a different date in Secondary. | |
| expected_interaction_path: | |
| - Locate the DateCalendar labeled “Secondary”. | |
| - Click day “18” in March 2026. | |
| - Confirm Primary remains unchanged. | |
| notes: 'Instrumentation: wrap each instance with data-testid=''datecalendar-primary''/''datecalendar-secondary'' to ensure instance-safe checks.' | |
| - id: calendar_embedded-mui-T07 | |
| name: Set a delivery date in a form section (with distractors) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: In the Delivery date calendar, select 2026-07-09. The task will finish automatically when done. | |
| ui_copy: 'Delivery form — Delivery date: 2026-07-09' | |
| setup_description: |- | |
| Layout: form_section centered (light theme, comfortable spacing, default scale) with low clutter. | |
| The page shows a “Delivery details” form with several focusable controls (Name input, Address input, and a non-required “Shipping speed” radio group). | |
| Under the form fields is a labeled area “Delivery date” containing one embedded MUI X DateCalendar (inline). | |
| The calendar starts on February 2026 with no date selected. | |
| Month navigation is done via the header arrow buttons; there is no popover or separate date field. | |
| A readout below the calendar displays “Delivery date:” and updates to YYYY-MM-DD upon selection. | |
| The surrounding form controls are distractors only; success depends solely on the calendar’s selected date. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: form_section | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: low | |
| difficulty: | |
| difficulty_bucket: mid | |
| tier: L1 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 2 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 2 | |
| justification: The agent must navigate several months and resist interacting with nearby form controls, while relying on the calendar highlight and readout for confirmation. | |
| success_trigger: | |
| human_readable: | |
| - The Delivery date calendar selected_date equals 2026-07-09. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-07-09' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: Delivery date | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting July 9 in the wrong year. | |
| - Navigating to July 2026 but selecting the wrong day. | |
| - Interacting only with form controls while the calendar remains unselected. | |
| expected_interaction_path: | |
| - Navigate months to July 2026 using the calendar header arrows. | |
| - Click day “9”. | |
| - Verify the “Delivery date” readout shows 2026-07-09. | |
| notes: 'Checker hint: ensure the adapter exposes selected_date for the specific labeled calendar container ''Delivery date''.' | |
| - id: calendar_embedded-mui-T08 | |
| name: Pick a date and confirm with OK (StaticDatePicker, dark theme) | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: StaticDatePicker (action bar) | |
| implementation_component: 'MUI X: StaticDatePicker' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: Select the date 2032-12-28 in the calendar and then click OK to confirm. The task will finish automatically when done. | |
| ui_copy: Static picker — requires OK | |
| setup_description: |- | |
| Layout: isolated_card centered in a dark theme (comfortable spacing, default scale). | |
| The card contains a MUI X StaticDatePicker rendered inline (no popover, no text field). | |
| The picker shows the calendar grid and also includes an action bar at the bottom with two buttons: “Cancel” and “OK”. | |
| Interaction is staged: clicking a day changes a pending selection highlight, but the committed value only updates when “OK” is pressed. | |
| A readout line beneath the component says “Confirmed date:” and updates to YYYY-MM-DD only after OK is clicked (initially shows “(none)”). | |
| The calendar starts around February 2026, so reaching 2032-12 requires using the internal year/month navigation (year view and/or repeated month navigation). | |
| No other interactive elements exist on the page (clutter: none). | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 4 | |
| semantic_observability: 3 | |
| disambiguation_load: 1 | |
| justification: The agent must navigate to a far year and manage a two-phase commit (pending selection vs confirmed value) by pressing OK in dark mode. | |
| success_trigger: | |
| human_readable: | |
| - The committed/confirmed date equals 2032-12-28. | |
| - The OK button has been pressed (no pending-only state). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: confirmed_date | |
| target_state: '2032-12-28' | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: OK | |
| require_correct_instance: false | |
| target_instance_label_or_id: null | |
| terminal_condition: task ends when predicate holds | |
| pending_state_must_be_empty: true | |
| negative_cases: | |
| - Selecting 2032-12-28 but not clicking OK (confirmed date does not change). | |
| - Clicking OK with a different date selected. | |
| - Clicking Cancel after selecting the correct date (should revert to '(none)' and not count). | |
| expected_interaction_path: | |
| - Navigate to December 2032 (using year/month navigation inside the picker). | |
| - Click day “28”. | |
| - Click “OK”. | |
| - Verify the Confirmed date readout shows 2032-12-28. | |
| notes: 'Checker hint: confirm against committed state bound to the ''Confirmed date'' readout; do not accept pending selection without OK.' | |
| - id: calendar_embedded-mui-T09 | |
| name: Select an end-of-month date in a small calendar inside a table cell | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar (small) | |
| implementation_component: 'MUI X: DateCalendar' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: In the inline calendar in the table editor, select the date 2026-11-30. The task will finish automatically when done. | |
| ui_copy: 'Table editor — pick date: 2026-11-30' | |
| setup_description: |- | |
| Layout: table_cell (light theme) with medium clutter. The page shows a simple table editor with several rows and small icon buttons (edit, filter, sort). | |
| In the highlighted table cell (“Due date”), an embedded MUI X DateCalendar is shown inline in a compact container (scale: small). | |
| The calendar starts on September 2026 with no selected date. | |
| The header month label and navigation arrows are present but slightly compressed due to the small container. | |
| Selecting a day highlights it and updates a tiny readout under the calendar labeled “Due date:” (YYYY-MM-DD). | |
| Distractors: the surrounding table controls are clickable but should be ignored; only the calendar selection determines success. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: table_cell | |
| placement: center | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Small-scale rendering tightens day targets and header controls, and the surrounding table UI adds distractors that increase misclick and disambiguation risk. | |
| success_trigger: | |
| human_readable: | |
| - The Due date calendar selected_date equals 2026-11-30. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-11-30' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: false | |
| target_instance_label_or_id: Due date | |
| terminal_condition: task ends when predicate holds | |
| negative_cases: | |
| - Selecting 2026-11-30 in a different year/month. | |
| - Selecting November 2026 but choosing the wrong day (not the 30th). | |
| - Clicking table controls without setting the calendar date. | |
| expected_interaction_path: | |
| - Navigate from September 2026 to November 2026 using the header arrows (or month selection if configured). | |
| - Click day “30”. | |
| - Verify the Due date readout shows 2026-11-30. | |
| notes: 'Robustness slice: small scale + table_cell context. Checker should target the calendar embedded within the ''Due date'' cell container.' | |
| - id: calendar_embedded-mui-T10 | |
| name: Scroll the year list (descending) to reach 1999 | |
| canonical_type: calendar_embedded | |
| implementation_source: mui | |
| implementation_variant: DateCalendar (year view, yearsOrder=desc) | |
| implementation_component: 'MUI X: DateCalendar (year view enabled)' | |
| task_template: scroll_find | |
| secondary_template: null | |
| browsergym_goal: Open the year list in the calendar and select the year 1999. You do not need to select a day. The task will finish automatically when done. | |
| ui_copy: 'Choose year: 1999' | |
| setup_description: |- | |
| Layout: isolated_card anchored near the top-left of the viewport (light theme, comfortable spacing, default scale). | |
| The card contains a single MUI X DateCalendar configured to start in year view with a long scrollable year list. | |
| The year list is shown in descending order (latest years first), spanning roughly 1900–2099. | |
| No day is selected at any point; this task is only about setting the calendar’s active year by choosing it from the list. | |
| A label above the component shows “Viewing year:” and mirrors the currently active year as a 4-digit number. | |
| There are no other interactive elements (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: top_left | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 1 | |
| target_acquisition: 3 | |
| density_choice_interference: 4 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: Selecting a far-back year requires scrolling through a dense descending year list and accurately clicking the correct year option. Corner placement adds slight viewport-edge interaction risk. | |
| success_trigger: | |
| human_readable: | |
| - The calendar’s active/displayed year equals 1999 (as reflected by the 'Viewing year' label). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: displayed_year | |
| target_state: 1999 | |
| 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 | |
| negative_cases: | |
| - Selecting any year other than 1999. | |
| - Scrolling the list without making a selection (active year remains unchanged). | |
| - Selecting a day instead of choosing the year (if the UI switches views). | |
| expected_interaction_path: | |
| - In year view, scroll through the year list until 1999 is visible. | |
| - Click the year “1999”. | |
| - Verify the 'Viewing year' label updates to 1999. | |
| notes: 'Checker hint: treat the calendar''s active year as the year of its referenceDate/currentMonth state; normalize to integer.' | |
| - id: calendar_embedded-mantine-T01 | |
| name: Pick a single date (Mantine Calendar) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom single-date selection) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: On the Calendar, select the date 2026-02-05. The task will finish automatically when done. | |
| ui_copy: 'Select date: 2026-02-05' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a single Mantine Calendar component (@mantine/dates) showing February 2026 on load. | |
| The calendar header has previous/next month chevrons and a month/year label. | |
| Single-date selection behavior is implemented on top of Calendar: clicking a day toggles it into the selected state (highlighted background). | |
| Initially, no date is selected. | |
| A readout line below the calendar shows “Selected date:” and updates to YYYY-MM-DD whenever a day is selected. | |
| No other interactive elements are present (clutter: none). | |
| 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: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Single-date selection in a single embedded calendar with a visible readout is a basic interaction. | |
| success_trigger: | |
| human_readable: | |
| - The calendar’s selected date equals 2026-02-05. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-02-05' | |
| 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 | |
| negative_cases: | |
| - Selecting a different date (not 2026-02-05). | |
| - Selecting the 5th in a different month/year. | |
| - Only navigating months without selecting the date. | |
| expected_interaction_path: | |
| - Click day “5” in February 2026. | |
| notes: 'Checker hint: selection is implemented via getDayProps; read selected state from app-level store normalized to ISO.' | |
| - id: calendar_embedded-mantine-T02 | |
| name: Navigate to July 2026 (Mantine Calendar) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: navigate_to | |
| secondary_template: null | |
| browsergym_goal: Navigate the calendar so it is showing July 2026. You do not need to select a day. The task will finish automatically when done. | |
| ui_copy: 'Go to month: July 2026' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The page contains a single Mantine Calendar showing February 2026 initially. | |
| The header provides previous/next month chevrons and a central month/year label. | |
| Day selection is enabled but not required for this task. | |
| A small label above the calendar reads “Viewing:” and mirrors the current visible month as YYYY-MM. | |
| No other widgets are present (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: The task is a straightforward month navigation with clear visible state in the header and the mirrored 'Viewing' label. | |
| success_trigger: | |
| human_readable: | |
| - The calendar’s visible month equals 2026-07 (July 2026). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: displayed_month | |
| target_state: 2026-07 | |
| 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 | |
| negative_cases: | |
| - Stopping on any month other than July 2026. | |
| - Changing year incorrectly (e.g., July 2025 or July 2027). | |
| - Selecting a day while still not displaying July 2026. | |
| expected_interaction_path: | |
| - Use the next-month chevron until the header shows July 2026. | |
| - Stop once the 'Viewing' label is 2026-07. | |
| notes: 'Checker hint: derive displayed_month from the calendar''s internal month state (YYYY-MM).' | |
| - id: calendar_embedded-mantine-T03 | |
| name: Clear the selected date (Mantine Calendar) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom single-date selection) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: clear_reset | |
| secondary_template: null | |
| browsergym_goal: Clear the selected date so that no date is selected in the calendar. The task will finish automatically when done. | |
| ui_copy: Selected date is set — clear it | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains a Mantine Calendar showing February 2026. | |
| One date is pre-selected on load: 2026-02-12 (the cell is highlighted as selected). | |
| Under the calendar, a readout displays “Selected date: 2026-02-12”. | |
| Next to the readout is a button labeled “Clear selection” that resets the selection to empty (no selected date). | |
| There are no other interactive elements (clutter: none). | |
| 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: 1 | |
| target_acquisition: 2 | |
| density_choice_interference: 1 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 1 | |
| disambiguation_load: 1 | |
| justification: A single explicit reset control clears a visible existing selection with immediate feedback. | |
| success_trigger: | |
| human_readable: | |
| - The calendar has no selected date (null/empty selection). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: 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 | |
| negative_cases: | |
| - Selecting another date instead of clearing. | |
| - Clicking Clear selection but the selected highlight remains. | |
| - Navigating months without clearing. | |
| expected_interaction_path: | |
| - Click “Clear selection”. | |
| - Verify the readout becomes empty and no day is highlighted. | |
| notes: 'Checker hint: ensure reset sets selected_date to null (not just visually unhighlight).' | |
| - id: calendar_embedded-mantine-T04 | |
| name: Select three availability dates (multi-select) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom multi-select up to 3) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: select_many | |
| secondary_template: null | |
| browsergym_goal: 'Select exactly these three dates in the calendar: 2026-02-03, 2026-02-10, and 2026-02-17. The task will finish automatically when done.' | |
| ui_copy: 'Availability (pick 3): 2026-02-03, 2026-02-10, 2026-02-17' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains one Mantine Calendar showing February 2026. | |
| This calendar is configured as a custom multi-select: clicking a day toggles its selected state, and up to 3 dates can be selected at once. | |
| Initially, no dates are selected. | |
| A small panel below the calendar lists selected dates as chips in ISO format (YYYY-MM-DD), in sorted order. | |
| There are no other interactive elements (clutter: none). | |
| 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: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: The agent must correctly click multiple distinct day cells and ensure the final selected set matches exactly, with no extra selections. | |
| success_trigger: | |
| human_readable: | |
| - The set of selected dates equals {2026-02-03, 2026-02-10, 2026-02-17}. | |
| - No additional dates are selected. | |
| canonical_predicate: | |
| predicate_type: set_equals | |
| state_field: selected_dates | |
| target_state: | |
| - '2026-02-03' | |
| - '2026-02-10' | |
| - '2026-02-17' | |
| 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 | |
| order_insensitive: true | |
| negative_cases: | |
| - Selecting only a subset of the three required dates. | |
| - Selecting the correct three but also selecting any additional date. | |
| - Selecting the right day numbers in the wrong month/year. | |
| - Leaving the calendar with pending hover but not toggling selected state. | |
| expected_interaction_path: | |
| - Click day 3, day 10, and day 17 in February 2026. | |
| - Use the selected-date chips panel to verify exactly three dates are selected. | |
| notes: 'Checker hint: normalize selected dates to ISO and compare as a set (order-insensitive).' | |
| - id: calendar_embedded-mantine-T05 | |
| name: Select a date range (start and end) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom range selection) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: set_range | |
| secondary_template: null | |
| browsergym_goal: Select the date range from 2026-03-10 to 2026-03-14 in the calendar. The task will finish automatically when done. | |
| ui_copy: 'Select range: 2026-03-10 → 2026-03-14' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme, comfortable spacing, default scale). | |
| The card contains one Mantine Calendar initially showing March 2026. | |
| The calendar is configured for range selection: | |
| - First click sets the range start (start date). | |
| - Second click sets the range end. | |
| - Days between start and end are highlighted as an in-range band. | |
| The initial state has no start and no end selected. | |
| Below the calendar, a readout shows “Range start:” and “Range end:” in YYYY-MM-DD (empty until chosen). | |
| There are no other interactive elements on the page (clutter: none). | |
| 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: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 2 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Two-step selection with an intermediate partial state (only start chosen) increases the chance of partial completion or reversed endpoints. | |
| success_trigger: | |
| human_readable: | |
| - The selected range start equals 2026-03-10 and the selected range end equals 2026-03-14. | |
| - Both endpoints must be set (no partial range). | |
| canonical_predicate: | |
| predicate_type: range_equals | |
| state_field: selected_range | |
| target_state: | |
| start: '2026-03-10' | |
| end: '2026-03-14' | |
| 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 | |
| negative_cases: | |
| - Only selecting the start date (end remains empty). | |
| - Selecting an incorrect end date (e.g., 2026-03-13 or 2026-03-15). | |
| - Reversing the range endpoints (start after end) if the UI allows it. | |
| - Selecting the right day numbers in a different month/year. | |
| expected_interaction_path: | |
| - Click March 10 to set the start. | |
| - Click March 14 to set the end. | |
| - Verify the range readout shows 2026-03-10 → 2026-03-14. | |
| notes: 'Checker hint: represent range as (start_iso, end_iso) with start<=end; do not accept partial state.' | |
| - id: calendar_embedded-mantine-T06 | |
| name: Choose a shipping date (two calendars in a form) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom single-date selection, x2) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates) (two instances)' | |
| task_template: select_one | |
| secondary_template: null | |
| browsergym_goal: In the Shipping calendar, select the date 2026-04-22. The task will finish automatically when done. | |
| ui_copy: 'Checkout form — Shipping calendar: 2026-04-22' | |
| setup_description: |- | |
| Layout: form_section centered (light theme, comfortable spacing, default scale) with low clutter. | |
| The page shows a “Checkout scheduling” form with a few distractor controls (Name input, Address input, and a non-required checkbox “Save for later”). | |
| Below the form fields are two embedded Mantine Calendar instances: | |
| - “Billing calendar” (first) | |
| - “Shipping calendar” (second) | |
| Both calendars start on April 2026 and both begin with no selected date. | |
| Each calendar has its own “Selected date:” readout beneath it. | |
| Only the Shipping calendar selection matters; Billing calendar should remain unchanged for success. | |
| 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: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 1 | |
| semantic_observability: 2 | |
| disambiguation_load: 4 | |
| justification: Two similar calendars inside a form require careful instance disambiguation while ignoring nearby input-field distractors. | |
| success_trigger: | |
| human_readable: | |
| - Shipping calendar selected_date equals 2026-04-22. | |
| - Billing calendar remains unselected (null). | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2026-04-22' | |
| tolerance: null | |
| require_confirm: false | |
| confirm_control: null | |
| require_correct_instance: true | |
| target_instance_label_or_id: Shipping calendar | |
| terminal_condition: task ends when predicate holds | |
| non_target_instances_must_equal: | |
| Billing calendar: null | |
| negative_cases: | |
| - Selecting 2026-04-22 in the Billing calendar instead of Shipping. | |
| - Selecting the correct date in Shipping but also selecting any date in Billing. | |
| - Selecting the wrong date in Shipping. | |
| expected_interaction_path: | |
| - Locate the calendar labeled “Shipping calendar”. | |
| - Click day “22” in April 2026. | |
| - Confirm only the Shipping readout updates. | |
| notes: 'Instrumentation: label each calendar container with data-testid and include the label text in the accessible name for robust targeting.' | |
| - id: calendar_embedded-mantine-T07 | |
| name: Select the neon-marked target day (dark theme) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom marker, dark theme) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: match_reference | |
| secondary_template: null | |
| browsergym_goal: Select the day marked with the neon green Target ring in the calendar. The task will finish automatically when done. | |
| ui_copy: 'Legend: Target = neon green ring' | |
| setup_description: |- | |
| Layout: isolated_card centered in dark theme (comfortable spacing, default scale). | |
| The card contains a single Mantine Calendar showing May 2026. | |
| Above the calendar is a small legend showing a neon green ring icon labeled “Target”. | |
| In the calendar grid, exactly one day cell has a neon green ring around the day number (no text label with the date is provided). | |
| Several other days have subtle gray dots (non-target markers) to increase confusability. | |
| The calendar does not show a persistent selected-date text readout; selection is indicated only by the cell highlight style. | |
| No other interactive elements are present (clutter: none). | |
| scene_context: | |
| theme: dark | |
| spacing: comfortable | |
| layout: isolated_card | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: visual | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 4 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 4 | |
| disambiguation_load: 1 | |
| justification: In dark mode, the agent must rely on a subtle visual cue (neon ring) among similar markers without a textual confirmation of the selected date. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals the day with the neon green Target ring (2026-05-09). | |
| canonical_predicate: | |
| predicate_type: matches_reference | |
| state_field: selected_date | |
| target_state: | |
| reference_element: neon_target_ring_marker | |
| resolved_date_iso: '2026-05-09' | |
| 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 | |
| negative_cases: | |
| - Selecting any day with a gray dot marker instead of the neon ring. | |
| - Selecting any unmarked day. | |
| - Selecting May 9 in a different year/month. | |
| expected_interaction_path: | |
| - Use the legend to identify the Target marker style. | |
| - Scan the May 2026 grid to find the neon green ring. | |
| - Click that day cell. | |
| notes: 'Checker hint: target day cell includes data-marker=''target''; resolve ISO date from dataset and compare.' | |
| - id: calendar_embedded-mantine-T08 | |
| name: Use level change to reach 2035-11-23 in a compact small calendar | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (level change enabled) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: open_and_select | |
| secondary_template: null | |
| browsergym_goal: Set the calendar to the date 2035-11-23. The task will finish automatically when done. | |
| ui_copy: 'Select date: 2035-11-23' | |
| setup_description: |- | |
| Layout: isolated_card centered (light theme) with compact spacing and small scale. | |
| The page contains one Mantine Calendar rendered in a smaller-than-default container. | |
| The calendar supports level changes: clicking the month/year label toggles between day view → month picker → year picker. | |
| The calendar starts in day view around February 2026 with no selection. | |
| To reach the target, the user can open the year picker, choose 2035, then choose November in the month picker, then select day 23 in the day grid. | |
| A small readout under the calendar shows “Selected date:” in YYYY-MM-DD after a day is selected. | |
| No other controls are present (clutter: none). | |
| scene_context: | |
| theme: light | |
| spacing: compact | |
| layout: isolated_card | |
| placement: center | |
| scale: small | |
| instances: 1 | |
| guidance: text | |
| clutter: none | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 4 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 1 | |
| justification: Small/compact rendering reduces target sizes for month and year options, and the multi-level navigation path (year→month→day) increases layering and interaction steps. | |
| success_trigger: | |
| human_readable: | |
| - The selected date equals 2035-11-23. | |
| - The calendar ends in day view showing November 2035. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: selected_date | |
| target_state: '2035-11-23' | |
| 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 | |
| displayed_month_must_equal: 2035-11 | |
| negative_cases: | |
| - Selecting 2035-11-23 in a different year/month due to misnavigation. | |
| - Stopping after selecting year and month but not selecting the day. | |
| - Selecting day 23 in November of another year. | |
| expected_interaction_path: | |
| - Click the month/year label to open the year picker. | |
| - Select year 2035 (may require scrolling). | |
| - Select month November. | |
| - Click day “23”. | |
| - Verify the Selected date readout shows 2035-11-23. | |
| notes: 'Checker hint: validate both selected_date and displayed_month to avoid false positives in compact UIs.' | |
| - id: calendar_embedded-mantine-T09 | |
| name: Select five workweek dates in a dashboard | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (custom multi-select) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates)' | |
| task_template: select_many | |
| secondary_template: null | |
| browsergym_goal: 'Select exactly these five dates in the calendar: 2026-06-15, 2026-06-16, 2026-06-17, 2026-06-18, and 2026-06-19. The task will finish automatically when done.' | |
| ui_copy: Dashboard — select workweek dates (5) | |
| setup_description: |- | |
| Layout: dashboard (light theme, comfortable spacing, default scale) with medium clutter. | |
| The page is a small scheduling dashboard: a left sidebar has navigation links (Overview, Teams, Reports) and the main area contains a calendar card. | |
| The calendar card contains a Mantine Calendar showing June 2026. | |
| The calendar is configured for multi-select (click to toggle selected). Multiple dates may be selected. | |
| A selected-dates panel under the calendar shows chips for all currently selected dates in ISO format. | |
| Distractors: the sidebar links and a top “Search” input are clickable but do not affect task success. | |
| The calendar is the only stateful component used for checking success. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 1 | |
| guidance: text | |
| clutter: medium | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L2 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 1 | |
| feedback_dynamics: 2 | |
| semantic_observability: 2 | |
| disambiguation_load: 3 | |
| justification: Multiple precise selections must be accumulated without extras, and dashboard clutter increases the chance of off-target interactions. | |
| success_trigger: | |
| human_readable: | |
| - The set of selected dates equals {2026-06-15, 2026-06-16, 2026-06-17, 2026-06-18, 2026-06-19}. | |
| - No other dates are selected. | |
| canonical_predicate: | |
| predicate_type: set_equals | |
| state_field: selected_dates | |
| target_state: | |
| - '2026-06-15' | |
| - '2026-06-16' | |
| - '2026-06-17' | |
| - '2026-06-18' | |
| - '2026-06-19' | |
| 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 | |
| order_insensitive: true | |
| negative_cases: | |
| - Selecting fewer than the five required dates. | |
| - Selecting the five required dates plus any additional date. | |
| - Selecting the right day numbers in a different month/year. | |
| - Clicking dashboard navigation links instead of interacting with the calendar. | |
| expected_interaction_path: | |
| - In June 2026, click day 15, 16, 17, 18, and 19. | |
| - Use the selected-date chips panel to verify exactly five chips match the required dates. | |
| notes: 'Checker hint: compare selected_dates as a set against the target set; enforce exact match (no extras).' | |
| - id: calendar_embedded-mantine-T10 | |
| name: Pick a date in Team C and apply changes (3 instances) | |
| canonical_type: calendar_embedded | |
| implementation_source: mantine | |
| implementation_variant: Calendar (x3 instances, staged apply) | |
| implementation_component: 'Mantine: Calendar (@mantine/dates) (three instances)' | |
| task_template: confirm_cancel | |
| secondary_template: null | |
| browsergym_goal: In the Team C calendar, select the date 2027-02-01 and then click Apply changes. The task will finish automatically when done. | |
| ui_copy: Team calendars — apply a date for Team C | |
| setup_description: |- | |
| Layout: dashboard (light theme, comfortable spacing, default scale) with high clutter. | |
| The page is a “Team scheduling” dashboard with a toolbar (buttons like Export, Refresh, Help) and a sidebar of navigation links. | |
| In the main area there are three calendar cards in a row, each containing a Mantine Calendar: | |
| - Team A | |
| - Team B | |
| - Team C | |
| All three calendars start on February 2027 and have no committed selection. | |
| Interaction is staged per team: clicking a day sets a pending selection highlight, but the team’s committed value updates only when the global footer button “Apply changes” is clicked. | |
| The footer contains two buttons: “Discard” and “Apply changes”. | |
| Under each calendar is a small readout “Applied date:” that shows the committed date for that team (initially “(none)”). It updates only after Apply changes. | |
| Only Team C’s applied date is the target for success; Team A and Team B must remain unchanged. | |
| scene_context: | |
| theme: light | |
| spacing: comfortable | |
| layout: dashboard | |
| placement: center | |
| scale: default | |
| instances: 3 | |
| guidance: text | |
| clutter: high | |
| difficulty: | |
| difficulty_bucket: hard | |
| tier: L3 | |
| axes_ratings: | |
| precision_requirement: 2 | |
| target_acquisition: 3 | |
| density_choice_interference: 3 | |
| depth_layering: 3 | |
| feedback_dynamics: 4 | |
| semantic_observability: 3 | |
| disambiguation_load: 5 | |
| justification: Three similar instances plus dashboard clutter create high disambiguation load, and the staged global Apply changes step adds depth and feedback complexity. | |
| success_trigger: | |
| human_readable: | |
| - Team C committed/applied date equals 2027-02-01. | |
| - Apply changes has been pressed (committed state updated). | |
| - Team A and Team B applied dates remain '(none)'. | |
| canonical_predicate: | |
| predicate_type: equals | |
| state_field: confirmed_date | |
| target_state: '2027-02-01' | |
| tolerance: null | |
| require_confirm: true | |
| confirm_control: Apply changes | |
| require_correct_instance: true | |
| target_instance_label_or_id: Team C | |
| terminal_condition: task ends when predicate holds | |
| non_target_instances_must_equal: | |
| Team A: null | |
| Team B: null | |
| pending_state_must_be_empty: true | |
| negative_cases: | |
| - Selecting the correct date in Team C but not clicking Apply changes (applied date stays '(none)'). | |
| - Applying a date in Team A or Team B (wrong instance modified). | |
| - Applying the wrong date for Team C. | |
| - Clicking Discard after selecting the correct date (reverts and should not count). | |
| expected_interaction_path: | |
| - Locate the Team C calendar card. | |
| - Navigate if needed to February 2027 (already set on load) and click day “1”. | |
| - Click “Apply changes” in the footer. | |
| - Verify Team C 'Applied date' shows 2027-02-01 and other teams remain '(none)'. | |
| notes: 'Instrumentation: each team card should have a stable identifier; checker should validate applied (committed) state, not pending selection.' | |