tasks/v1/calendar_embedded.yaml

- 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.'