tasks/v1/date_picker_single.yaml

- id: date_picker_single-antd-T01
  name: Set delivery date to 2026-02-14
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the date in the "Delivery date" picker to 2026-02-14.
    The task will finish automatically when done.
  ui_copy: |-
    Delivery date

    Set the date in the "Delivery date" picker to 2026-02-14.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A single isolated card is centered in the viewport (isolated_card, center). Theme is light with comfortable spacing and default-sized controls.

    Target component: One Ant Design DatePicker labeled "Delivery date" with a calendar icon. The input is initially empty and shows a placeholder "Select date".
    - Interaction: Clicking the input opens a popover calendar panel (month grid) anchored to the input.
    - Sub-controls: Previous/next month chevrons in the header; month/year selector in the header; day cells in a 7x6 grid.
    - Format: The input displays the selected date in ISO-like format (YYYY-MM-DD).

    Distractors: None beyond a non-interactive helper text line under the field ("Choose a single date").

    Feedback: When a day is clicked, the input value updates immediately and the popover closes.
  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: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single default DatePicker with one-step selection from the open calendar; state is visible directly in
      the input.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-02-14.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '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:
  - A different date is selected (any date other than 2026-02-14).
  - The user clicks a date cell but the input remains empty (selection not applied).
  - A date is entered in the wrong field (not applicable here because there is only one instance).
  expected_interaction_path:
  - Click the "Delivery date" input to open the calendar popover.
  - Navigate to February 2026 if needed.
  - Click day 14.
  notes: |-
    Instrumentation: add data-testid="delivery-date" to the DatePicker input element and expose its bound value for the checker.
    Checker: read canonical date as YYYY-MM-DD from the component value (dayjs) and compare for exact equality.
- id: date_picker_single-antd-T02
  name: Type appointment date 2026-03-05
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: |-
    In the "Appointment date" field, type the date 2026-03-05 and make sure it is accepted.
    The task will finish automatically when done.
  ui_copy: |-
    Appointment date

    In the "Appointment date" field, type the date 2026-03-05 and make sure it is accepted.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A centered isolated card in light theme with comfortable spacing.

    Target component: One Ant Design DatePicker labeled "Appointment date". The input is initially empty.
    - The input supports direct typing. A small helper text under the field says: "Format: YYYY-MM-DD".
    - When the user types a complete valid date and presses Enter (or the input loses focus), the DatePicker parses it and stores the canonical date.
    - If the user types an invalid date, the input shows a red error style and the value is not committed.

    Distractors: None.

    Feedback: Once accepted, the input renders the normalized value as "2026-03-05" and the calendar popover (if open) reflects the same selection.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires correct formatted text entry and commit (Enter/blur), but there is only one field and no disambiguation.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-03-05.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-03-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:
  - The field contains an invalid or partial string (e.g., '2026-03-' or '03/05/2026') and the component value is not set.
  - A different date is committed (not 2026-03-05).
  - The text appears in the input but the component stays in an error/invalid state.
  expected_interaction_path:
  - Click the "Appointment date" input.
  - Type 2026-03-05.
  - Press Enter or click outside to commit.
  notes: |-
    Implementation hint: configure AntD DatePicker `format="YYYY-MM-DD"` and ensure keyboard input is enabled.
    Checker should validate the underlying value (dayjs) rather than raw input text.
- id: date_picker_single-antd-T03
  name: Clear the selected renewal date
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: |-
    Clear the date in the "Renewal date" picker so that it is empty.
    The task will finish automatically when done.
  ui_copy: |-
    Renewal date (currently set)

    Clear the date in the "Renewal date" picker so that it is empty.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One Ant Design DatePicker labeled "Renewal date".
    - Initial state: The input already contains "2026-01-15".
    - The DatePicker is configured with `allowClear=true`, so a clear (x) control appears inside the input on hover/focus.
    - Clicking the clear control removes the selected date and returns the input to the placeholder state.

    Distractors: A secondary non-date text input ("Notes") appears below but does not affect success.

    Feedback: Clearing removes the date text immediately; no confirmation dialog is used.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  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: 2
      disambiguation_load: 1
    justification: The task is a single clear action on a standard affordance with immediate feedback.
  success_trigger:
    human_readable:
    - Date picker must have selected date = empty (no date).
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: 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:
  - The input still contains any date value after the interaction.
  - A different control is cleared (e.g., clearing the Notes input).
  - The date text is removed visually but the component value is still non-null (not truly cleared).
  expected_interaction_path:
  - Focus/hover the "Renewal date" input to reveal the clear (x) icon.
  - Click the clear icon.
  notes: |-
    Checker: treat cleared state as value === null.
    Instrumentation: ensure the clear icon is reachable via a stable selector (e.g., data-testid="renewal-date-clear").
- id: date_picker_single-antd-T04
  name: Confirm invoice date with OK (dark theme)
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: |-
    Set the date in the "Invoice date" picker to 2026-02-02, then click "OK" in the picker to confirm.
    The task will finish automatically when done.
  ui_copy: |-
    Invoice date

    Set the date in the "Invoice date" picker to 2026-02-02, then click "OK" in the picker to confirm.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A single centered card in dark theme (dark background, light text). Spacing is comfortable and control scale is default.

    Target component: One Ant Design DatePicker labeled "Invoice date".
    - Configuration: `needConfirm=true` so the calendar panel includes a footer with "OK" and "Cancel".
    - Initial state: empty input.
    - Interaction: Clicking the input opens a popover calendar. Clicking a day highlights it but does not finalize the value until "OK" is clicked.

    Distractors: None.

    Feedback: After pressing "OK", the popover closes and the input updates to the confirmed value.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Adds an explicit confirmation step (OK) in a dark theme, but the target date is nearby and there is only
      one picker instance.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-02-02.
    - Selection must be confirmed by clicking the picker 'OK' control.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-02-02'
      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
  negative_cases:
  - A date is clicked but "OK" is not pressed (value remains unconfirmed).
  - '"Cancel" is pressed or the popover is dismissed without confirming, leaving the value empty.'
  - A different date than 2026-02-02 is confirmed.
  expected_interaction_path:
  - Click the "Invoice date" input to open the popover.
  - Navigate to February 2026 if necessary.
  - Click day 2 to select it.
  - Click "OK" in the picker footer.
  notes: |-
    AntD supports a confirm button via `needConfirm` (see DatePicker docs). Ensure the OK button has a stable selector.
    Checker must ensure final committed value equals 2026-02-02 (not just the hovered/preview value).
- id: date_picker_single-antd-T05
  name: Set Billing date in a compact form with two pickers
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the "Billing" section, set the "Billing date" picker to 2026-04-21.
    The task will finish automatically when done.
  ui_copy: |-
    Billing (form section)

    In the "Billing" section, set the "Billing date" picker to 2026-04-21.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A form section layout (form_section) centered on the page. Theme is light. Spacing is compact (labels and inputs are closer together) with default control scale.

    Target components: Two Ant Design DatePicker instances appear in the same form group:
    1) "Billing date" (TARGET) - initially empty, placeholder "YYYY-MM-DD".
    2) "Shipping date" (distractor) - prefilled with "2026-04-25".
    Both DatePickers open the same style popover calendar with month navigation.

    Distractors / clutter: The form also includes a small text input ("Invoice #") and a toggle ("Send receipt"), but they do not affect success.

    Feedback: Selecting a day updates the corresponding input immediately. Because spacing is compact, the two date fields are visually close and easy to confuse.
  scene_context:
    theme: light
    spacing: compact
    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: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two nearby date pickers in a compact form increase disambiguation and target acquisition difficulty while
      the date selection itself remains standard.
  success_trigger:
    human_readable:
    - Target instance (Billing date) must have selected date = 2026-04-21.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-04-21'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Billing date
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The "Shipping date" picker is changed but "Billing date" is not set to 2026-04-21.
  - The "Billing date" is set to a different day in April 2026.
  - A date is typed but left invalid/uncommitted (field shows error state).
  expected_interaction_path:
  - Locate the "Billing date" field (not the prefilled Shipping date).
  - Open its calendar popover.
  - Navigate to April 2026 if needed.
  - Click day 21.
  notes: |-
    Instrumentation: each picker should have a distinct data-testid, e.g., billing-date and shipping-date.
    Checker must read only the target instance value and ignore other pickers.
- id: date_picker_single-antd-T06
  name: Set 'Ship by' date from a table cell (small control)
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the Orders table, set the "Ship by" date picker to 2026-12-01.
    The task will finish automatically when done.
  ui_copy: |-
    Orders

    In the Orders table, set the "Ship by" date picker to 2026-12-01.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A table_cell layout showing an "Orders" table anchored near the bottom-right of the viewport (placement=bottom_right). Theme is light with comfortable spacing, but the date picker control itself uses the AntD `size="small"` setting (scale=small).

    Target component: One Ant Design DatePicker embedded inside the "Ship by" column for the first row (Order #1024).
    - Initial state: empty.
    - Interaction: Clicking inside the table cell focuses the DatePicker input and opens the calendar popover.
    - Popover placement is configured to prefer bottomRight alignment to the input.

    Distractors: Other rows contain non-editable dates rendered as plain text (not DatePicker components). The table also has a sortable header row and a search box above it.

    Feedback: After selecting a date, the table cell shows the formatted value and the popover closes.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Small embedded input inside a table increases target acquisition difficulty and adds realistic clutter,
      but the date choice is straightforward once opened.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-12-01.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-12-01'
      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:
  - A date is entered into the table search box instead of the Ship by picker.
  - A different date is selected or the field remains empty.
  - A date is changed in a non-target row (should not count; target cell must be correct).
  expected_interaction_path:
  - 'Locate Order #1024 row and the "Ship by" cell with the small DatePicker.'
  - Click the DatePicker input to open the calendar.
  - Navigate to December 2026 if needed.
  - Select day 1.
  notes: |-
    Instrumentation: add row and column testids to uniquely identify the target cell (e.g., data-testid="order-1024-ship-by").
    Checker: verify only that the bound value for this instance equals 2026-12-01.
- id: date_picker_single-antd-T07
  name: Pick a far past date (1998-12-31) from top-left
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: |-
    Set the "Date of birth" picker to 1998-12-31.
    The task will finish automatically when done.
  ui_copy: |-
    Profile

    Set the "Date of birth" picker to 1998-12-31.
    The task will finish automatically when done.
  setup_description: |-
    Scene: An isolated card positioned near the top-left of the viewport (placement=top_left). Light theme, comfortable spacing, default scale.

    Target component: One Ant Design DatePicker labeled "Date of birth".
    - Initial state: empty.
    - Opening the picker shows the calendar around the current month/year by default.
    - To reach 1998, the user must use the header controls (month/year selector and/or year panel) and navigate across many years before selecting December 31.

    Distractors: None.

    Feedback: The input updates immediately upon selecting a day (no extra confirmation).
  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: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Selecting a specific date decades in the past requires multi-step year/month navigation within the picker,
      increasing depth and interaction complexity.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 1998-12-31.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '1998-12-31'
      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:
  - Any date other than 1998-12-31 is selected.
  - The year is set correctly but the wrong month/day is selected (partial navigation).
  - The input text is edited but left invalid/uncommitted.
  expected_interaction_path:
  - Open the "Date of birth" DatePicker.
  - Switch to year selection (via header) and navigate to 1998.
  - Select December.
  - Click day 31.
  notes: |-
    Consider exposing a stable selector for header controls (prev/next year, month/year label) to help with automation and logging.
    Checker should compare canonical date value (YYYY-MM-DD) exactly.
- id: date_picker_single-antd-T08
  name: Select an enabled weekday with weekends disabled
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the "Follow-up date" picker to 2026-01-15.
    The task will finish automatically when done.
  ui_copy: |-
    Support ticket settings

    Set the "Follow-up date" picker to 2026-01-15.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A settings panel layout (settings_panel) with a left-hand label column and right-hand controls. Theme is light, spacing is comfortable, scale is default. The panel includes several unrelated toggles and dropdowns (clutter=medium).

    Target component: One Ant Design DatePicker labeled "Follow-up date".
    - Initial state: empty.
    - Constraint: Weekends (Saturday and Sunday) are disabled via `disabledDate` and appear greyed out and non-clickable.
    - The current month shown on open is January 2026.

    Distractors: Other controls include: "Priority" select, "Auto-close after (days)" numeric input, and a toggle "Email notifications". None affect success.

    Feedback: Clicking a disabled day has no effect; clicking an enabled day sets the value and closes the popover.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    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: 4
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Disabled dates create dense interference in the calendar grid and require the agent to distinguish clickable
      vs non-clickable days with subtle visual feedback.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-01-15.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-01-15'
      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:
  - A disabled weekend date is clicked (no change) and the target date is not set.
  - A different enabled weekday is selected.
  - The picker is left open with a highlighted date but the input value remains empty (no commit).
  expected_interaction_path:
  - Open the "Follow-up date" DatePicker.
  - In January 2026, click day 15 (an enabled weekday).
  notes: |-
    Implementation: use AntD DatePicker `disabledDate` to disable weekends.
    Checker: assert stored value equals 2026-01-15.
- id: date_picker_single-antd-T09
  name: Match the primary event date to a visual reference
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: |-
    Set the "Primary event date" picker to match the date shown on the Reference card.
    The task will finish automatically when done.
  ui_copy: |-
    Event scheduling

    Set the "Primary event date" picker to match the date shown on the Reference card.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card in light theme with comfortable spacing.

    Reference: At the top of the card there is a non-interactive "Reference date" card showing a stylized calendar tile (month abbreviation + day number) and a small mini-month calendar with one day highlighted. This reference corresponds to a single target date.

    Target components: Two Ant Design DatePicker instances are stacked below the reference:
    - "Primary event date" (TARGET) - initially empty.
    - "Backup event date" (distractor) - initially set to "2027-10-03".

    Interaction: Each DatePicker opens its own popover calendar. To match the reference, the agent must navigate to the correct month/year (October 2027) and click the correct day.

    Distractors: A non-functional "Timezone" dropdown is present but does not affect success (clutter=low).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: The target is specified visually via a reference card and requires navigating to a far future month/year
      while disambiguating between two similar date pickers.
  success_trigger:
    human_readable:
    - Target instance (Primary event date) must have selected date = 2027-10-10.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2027-10-10'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Primary event date
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The "Backup event date" is changed but "Primary event date" does not match the reference.
  - The correct month/year is reached but the wrong day is selected (off by one).
  - A date close to the target is selected (e.g., 2027-10-09 or 2027-10-11).
  expected_interaction_path:
  - Read the date from the visual Reference card (month/day/year).
  - Open the "Primary event date" DatePicker (not Backup).
  - Navigate to October 2027 using year/month controls.
  - Select day 10.
  notes: |-
    Instrumentation: add data-testid="ref-date" for the reference card and data-testid for each DatePicker.
    Checker can use a fixed target (2027-10-10) or dynamically parse the reference card and compare.
- id: date_picker_single-antd-T10
  name: Set pickup date inside a modal
  canonical_type: date_picker_single
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: |-
    Open the "Schedule pickup" dialog and set the "Pickup date" picker to 2026-07-04.
    The task will finish automatically when done.
  ui_copy: |-
    Pickups

    Open the "Schedule pickup" dialog and set the "Pickup date" picker to 2026-07-04.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Modal flow (modal_flow) in a light theme with comfortable spacing.

    Entry point: The page shows a header "Pickups" and a primary button labeled "Schedule pickup". Clicking it opens an Ant Design Modal dialog.

    Target component: Inside the modal, there is one Ant Design DatePicker labeled "Pickup date".
    - Initial state: empty.
    - Interaction: Clicking the input opens a popover calendar within the modal (still a floating layer anchored to the input).

    Distractors: The modal also contains a text area ("Pickup notes") and two buttons at the bottom ("Cancel" and "Create pickup"). They do not affect success; the task completes based only on the DatePicker value.

    Feedback: Selecting a date updates the input immediately; the "Create pickup" button becomes enabled, but clicking it is not required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    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: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a modal and then interacting with a nested popover inside it, adding layering while keeping
      the date choice itself simple.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-07-04.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-07-04'
      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:
  - The modal is opened but the Pickup date remains empty.
  - A different date is selected (not 2026-07-04).
  - The user clicks "Create pickup" without setting the correct date (should not count).
  expected_interaction_path:
  - Click "Schedule pickup" to open the modal dialog.
  - Click the "Pickup date" input to open the calendar popover.
  - Navigate to July 2026 if needed.
  - Select day 4.
  notes: |-
    Instrumentation: modal root should have a stable id; the DatePicker input inside should be uniquely identifiable (data-testid="pickup-date").
    Checker should read the DatePicker value regardless of whether the modal is open or closed.
- id: date_picker_single-mui-T01
  name: Pick project start date (desktop popover)
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DesktopDatePicker
  implementation_component: 'MUI X: DesktopDatePicker (DatePicker wrapper)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the "Project start date" picker to 2026-03-05.
    The task will finish automatically when done.
  ui_copy: |-
    Project start date

    Set the "Project start date" picker to 2026-03-05.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing, default scale.

    Target component: One MUI X DesktopDatePicker labeled "Project start date".
    - Initial state: empty field with placeholder "YYYY-MM-DD".
    - Interaction: Clicking the field or the calendar icon opens a desktop popover with a month view calendar.
    - Sub-controls: Month navigation arrows in the header; month/year label opens higher-level views depending on configuration.

    Distractors: None.

    Feedback: Selecting a day updates the field immediately and closes the popover (desktop close-on-select behavior).
  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: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Default single-instance desktop date picker with immediate commit and clear visibility of the selected
      value.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-03-05.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-03-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:
  - Any date other than 2026-03-05 is selected.
  - The user opens the picker but leaves the field empty.
  - The date is typed but not accepted (component value remains null).
  expected_interaction_path:
  - Open the picker from the field.
  - Navigate to March 2026 if necessary.
  - Select day 5.
  notes: |-
    MUI X DatePicker supports different wrapper variants (desktop vs mobile) and closeOnSelect defaults differ (see MUI X DatePicker API).
    Instrumentation: expose the value in ISO (YYYY-MM-DD) for the checker regardless of displayed format.
- id: date_picker_single-mui-T02
  name: Confirm a date in mobile dialog (OK required)
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: MobileDatePicker
  implementation_component: 'MUI X: MobileDatePicker'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: |-
    Set the "Travel date" picker to 2026-04-21 and press "OK" to confirm.
    The task will finish automatically when done.
  ui_copy: |-
    Travel date

    Set the "Travel date" picker to 2026-04-21 and press "OK" to confirm.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One MUI X MobileDatePicker labeled "Travel date".
    - Initial state: empty.
    - Interaction: Activating the field opens a modal dialog date picker (mobile variant).
    - Action bar: The dialog shows "Cancel" and "OK" (accept) actions. A date click highlights the day but does not commit until "OK" is pressed.

    Distractors: None.

    Feedback: Pressing "OK" commits the selected date into the field and closes the dialog.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires handling the mobile dialog action bar and confirming with OK, but otherwise uses a single, clear
      date picker.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-04-21.
    - Selection must be confirmed by clicking the picker 'OK' control.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-04-21'
      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
  negative_cases:
  - A date is selected but "OK" is not pressed (dialog closes via other means or remains open).
  - '"Cancel" is pressed, leaving the field empty.'
  - A different date than 2026-04-21 is confirmed.
  expected_interaction_path:
  - Open the Travel date picker (dialog).
  - Navigate to April 2026 if needed.
  - Select day 21.
  - Press "OK".
  notes: MUI X action bar supports accept/cancel/clear/today actions (see MUI X custom components docs). Ensure the accept
    button label is stable (e.g., 'OK').
- id: date_picker_single-mui-T03
  name: Clear a prefilled date using the action bar
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DatePicker (responsive)
  implementation_component: 'MUI X: DatePicker with ActionBar (clear)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: |-
    Clear the "Reminder date" picker so that it has no date selected.
    The task will finish automatically when done.
  ui_copy: |-
    Reminder date (prefilled)

    Clear the "Reminder date" picker so that it has no date selected.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One MUI X DatePicker labeled "Reminder date".
    - Initial state: field shows "2026-01-15".
    - Configuration: The picker is configured to display an ActionBar even in desktop mode with a single "Clear" action.
    - Interaction: Open the picker; then use the "Clear" action to reset the value to empty.

    Distractors: None.

    Feedback: Clicking "Clear" empties the field and closes the picker.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: A short, structured flow (open picker -> Clear) with explicit action bar controls and clear end-state visibility.
  success_trigger:
    human_readable:
    - Date picker must have selected date = empty (no date).
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: 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:
  - The value remains set to any date after the interaction.
  - The user clears text visually but the picker value is still non-null.
  - The wrong field is cleared (not applicable here because there is only one picker).
  expected_interaction_path:
  - Open the Reminder date picker.
  - Click the "Clear" action in the action bar.
  notes: MUI X PickersActionBar supports a 'clear' action that resets to empty (see MUI X custom components docs).
- id: date_picker_single-mui-T04
  name: Set Due date in settings panel with two pickers
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DatePicker (responsive)
  implementation_component: 'MUI X: DatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the Task settings panel, set the "Due date" picker to 2026-12-01.
    The task will finish automatically when done.
  ui_copy: |-
    Task settings

    In the Task settings panel, set the "Due date" picker to 2026-12-01.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Settings panel layout (settings_panel) with medium clutter. Light theme, comfortable spacing, default scale.

    Target components: Two MUI X DatePicker fields are shown under a "Dates" subsection:
    - "Start date" (distractor) - prefilled with "2026-11-20".
    - "Due date" (TARGET) - empty.
    The fields have similar styling and are vertically adjacent.

    Distractors: Other settings include a slider ("Effort"), a status dropdown, and a multiline description field.

    Feedback: Selecting a day commits immediately (desktop behavior) and the chosen date appears in the Due date field.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two similar date pickers in a cluttered settings panel increases disambiguation and the chance of modifying
      the wrong field.
  success_trigger:
    human_readable:
    - Target instance (Due date) must have selected date = 2026-12-01.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-12-01'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Due date
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Only Start date is changed while Due date remains unset or incorrect.
  - Due date is set to any other date besides 2026-12-01.
  - The picker view is navigated but no selection is committed.
  expected_interaction_path:
  - Identify the "Due date" field (not Start date).
  - Open its date picker.
  - Navigate to December 2026 if needed.
  - Select day 1.
  notes: |-
    Instrumentation: assign distinct testids for start-date and due-date fields.
    Checker should read the value associated with the Due date field only.
- id: date_picker_single-mui-T05
  name: Enter a date in MM/DD/YYYY format
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DatePicker (field input)
  implementation_component: 'MUI X: DatePicker (single input field)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: |-
    In the "Holiday date" field, enter the date 07/04/2026.
    The task will finish automatically when done.
  ui_copy: |-
    Holiday date

    In the "Holiday date" field, enter the date 07/04/2026.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One MUI X DatePicker with a single text field labeled "Holiday date".
    - Field behavior: the input is a structured date field (segmented month/day/year). Users can type digits and move between sections with keyboard navigation.
    - Format hint under the field: "MM/DD/YYYY".
    - Initial state: empty (shows placeholder underscores).
    - Invalid input shows an error helper text "Invalid date" and does not commit a value.

    Distractors: None.

    Feedback: When the entered date is valid, the internal picker value updates immediately and the calendar (if opened) reflects the entered date.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: Structured formatted input requires precise digit entry in the correct sections; validation feedback can
      block progress until the format is correct.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-07-04.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-07-04'
      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:
  - The field shows 07/04/2026 text but the component remains invalid and value is not set.
  - A different date is parsed (e.g., 04/07/2026).
  - Only partial segments are filled (e.g., month/day without year).
  expected_interaction_path:
  - Focus the "Holiday date" field.
  - Type 07/04/2026 using the field's segments (or paste if supported).
  - Ensure no validation error remains.
  notes: |-
    Use MUI X DatePicker with a DateField/SingleInput field and set the display format to MM/DD/YYYY.
    Checker should validate the parsed date value, not the literal string rendering.
- id: date_picker_single-mui-T06
  name: Navigate to next month in dark theme
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DesktopDatePicker
  implementation_component: 'MUI X: DesktopDatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the "Report date" picker to 2026-02-14.
    The task will finish automatically when done.
  ui_copy: |-
    Report date

    Set the "Report date" picker to 2026-02-14.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card in dark theme with comfortable spacing.

    Target component: One MUI X DesktopDatePicker labeled "Report date".
    - Initial state: empty.
    - Reference month: When opened, the calendar view starts on January 2026 (so selecting a February date requires moving to the next month).
    - Interaction: Use the header next-month control to move from January to February, then select day 14.

    Distractors: None.

    Feedback: On desktop, selecting a day commits immediately and closes the popover.
  scene_context:
    theme: dark
    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: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Dark theme can reduce contrast for subtle controls, and the task requires an extra navigation step to the
      next month.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-02-14.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '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:
  - A January 2026 date is selected instead of February 14.
  - The picker remains open with no committed value.
  - The input shows a different date than 2026-02-14.
  expected_interaction_path:
  - Open the Report date picker.
  - Click the next-month arrow to go to February 2026.
  - Select day 14.
  notes: MUI X DatePicker supports month navigation in the calendar header; ensure header buttons are accessible in dark theme.
- id: date_picker_single-mui-T07
  name: Set a dashboard filter date (bottom-left, cluttered)
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DesktopDatePicker
  implementation_component: 'MUI X: DesktopDatePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the dashboard filters, set "Created on" to 2026-06-30.
    The task will finish automatically when done.
  ui_copy: |-
    Analytics dashboard

    In the dashboard filters, set "Created on" to 2026-06-30.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A dashboard layout with a left filter sidebar and a main content area containing charts and a small data table (clutter=high). The filter sidebar is anchored near the bottom-left of the viewport (placement=bottom_left). Theme is light; spacing is comfortable. The date field uses a smaller size variant (scale=small) to fit the sidebar.

    Target component: One MUI X DesktopDatePicker labeled "Created on".
    - Initial state: empty.
    - Interaction: Clicking the small field opens a popover calendar. Selecting a day commits immediately.

    Distractors: Nearby filters include a keyword search box, a status dropdown, and several checkboxes. The main area contains interactive chart tooltips that may capture attention but are not required.

    Feedback: The chosen date appears in the field; a small "Filters updated" toast appears but does not affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: bottom_left
    scale: small
    instances: 1
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: mid
    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: High clutter and a small sidebar field increase the chance of mis-clicks and require careful target acquisition,
      even though the date choice is a single selection.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-06-30.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-06-30'
      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:
  - A different filter is modified while "Created on" remains empty or incorrect.
  - A different date is selected.
  - The user types into the keyword search box instead of the date field.
  expected_interaction_path:
  - Locate the "Created on" filter field in the sidebar.
  - Open the date picker popover.
  - Navigate to June 2026 if needed.
  - Select day 30.
  notes: |-
    Instrumentation: add data-testid="filter-created-on" on the field.
    Checker reads only the Created on picker value.
- id: date_picker_single-mui-T08
  name: Pick a far future date using year navigation (2037-11-05)
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DatePicker (responsive)
  implementation_component: 'MUI X: DatePicker'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: |-
    Set the "Warranty expiration" date picker to 2037-11-05.
    The task will finish automatically when done.
  ui_copy: |-
    Product warranty

    Set the "Warranty expiration" date picker to 2037-11-05.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One MUI X DatePicker labeled "Warranty expiration".
    - Initial state: empty.
    - Opening the picker shows a month view around a near-term reference date.
    - To reach year 2037, the user must switch to the year selection view (via the header/toolbar) and scroll/select the correct year, then navigate to November and select day 5.

    Distractors: None.

    Feedback: Once a full date is selected, the picker commits the value (desktop behavior) and shows it in the field.
  scene_context:
    theme: light
    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: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires multi-step navigation across years and months within the picker, increasing depth and the risk
      of selecting an adjacent year or day.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2037-11-05.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2037-11-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:
  - Year 2037 is selected but the wrong month/day is chosen.
  - A nearby year (e.g., 2036 or 2038) is chosen.
  - The picker is left without committing the full date.
  expected_interaction_path:
  - Open the Warranty expiration picker.
  - Switch to year view and select 2037.
  - Navigate/select November.
  - Select day 5.
  notes: MUI X DatePicker supports multiple views and year selection; ensure year list is keyboard/scroll accessible for agents.
- id: date_picker_single-mui-T09
  name: Match pay date to reference card and confirm (mobile)
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: MobileDatePicker
  implementation_component: 'MUI X: MobileDatePicker with ActionBar'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: |-
    Set the "Pay date" picker to match the date shown on the Paycheck card, then press "OK" to confirm.
    The task will finish automatically when done.
  ui_copy: |-
    Payroll

    Set the "Pay date" picker to match the date shown on the Paycheck card, then press "OK" to confirm.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A centered isolated card in light theme with comfortable spacing.

    Reference: A "Paycheck card" at the top shows the next pay date in two ways (mixed guidance):
    - A bold text line (e.g., "Next pay date: Mon, May 18, 2026").
    - A small calendar tile icon showing the month abbreviation and day number.

    Target component: One MUI X MobileDatePicker labeled "Pay date".
    - Initial state: empty.
    - Interaction: Opening the picker shows a modal dialog calendar.
    - Action bar: Contains "Cancel" and "OK". The date is only committed when "OK" is pressed.

    Distractors: A non-interactive "Pay cycle" dropdown and a toggle "Email payslip" appear below (clutter=low).

    Feedback: After pressing "OK", the dialog closes and the Pay date field shows the selected date.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: The target must be inferred from a reference card and then confirmed via the mobile action bar, adding
      both disambiguation and multi-step interaction depth.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-05-18.
    - Selection must be confirmed by clicking the picker 'OK' control.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-05-18'
      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
  negative_cases:
  - The selected date does not match the Paycheck card reference.
  - The correct date is selected but "OK" is not pressed (value not accepted).
  - A different date is confirmed (including off-by-one due to month navigation).
  expected_interaction_path:
  - Read the target date from the Paycheck card.
  - Open the Pay date picker (dialog).
  - Navigate to the correct month/year and select the day.
  - Press "OK" to accept.
  notes: MUI X action bar actions include accept/cancel/clear/today (see MUI X docs). Configure the dialog to require accept
    (OK) for commit.
- id: date_picker_single-mui-T10
  name: Set meeting date from a drawer using visual reference
  canonical_type: date_picker_single
  implementation_source: mui
  implementation_variant: DesktopDatePicker
  implementation_component: 'MUI X: DatePicker inside MUI Drawer'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: |-
    Open the "Scheduler" drawer and set the "Meeting date" picker to match the date shown in the Agenda preview.
    The task will finish automatically when done.
  ui_copy: |-
    Scheduler

    Open the "Scheduler" drawer and set the "Meeting date" picker to match the date shown in the Agenda preview.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Drawer flow (drawer_flow). The main page has a header "Scheduler" and a button "Open scheduler". Clicking it opens a right-side drawer (placement=top_right for the target area). Theme is light with comfortable spacing.

    Reference: Inside the drawer, an "Agenda preview" card shows a non-interactive calendar pill with the target date (visual reference: month abbreviation + day number + year).

    Target components: Two MUI X DatePicker fields appear in the drawer:
    - "Meeting date" (TARGET) - empty.
    - "Reminder date" (distractor) - prefilled with a different date.

    Interaction: Opening "Meeting date" shows a popover calendar layered above the drawer. The agent must navigate to the month/year indicated by the Agenda preview and select the matching day.

    Distractors: The drawer also contains a participant autocomplete field and a Save button; neither affects success (clutter=medium).
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_right
    scale: default
    instances: 2
    guidance: visual
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 5
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Nested overlays (drawer + picker popover) combined with visual-only target specification and multiple similar
      instances significantly increases interaction depth and disambiguation load.
  success_trigger:
    human_readable:
    - Target instance (Meeting date) must have selected date = 2026-09-09.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-09-09'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Meeting date
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The Reminder date is changed while Meeting date does not match the Agenda preview.
  - A date is selected that is close but not equal to the referenced date.
  - The drawer is not opened and the picker is never reached (Meeting date remains empty).
  expected_interaction_path:
  - Click "Open scheduler" to open the drawer.
  - Read the target date from the Agenda preview.
  - Open the "Meeting date" picker.
  - Navigate to the correct month/year and select the matching day.
  notes: |-
    Instrumentation: drawer root should have a stable selector; agenda preview should have data-testid="agenda-preview-date".
    Checker should ensure it reads the Meeting date picker instance inside the drawer, not any background fields.
- id: date_picker_single-mantine-T01
  name: Pick event date with DatePickerInput
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput (type="default")'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the "Event date" picker to 2026-03-05.
    The task will finish automatically when done.
  ui_copy: |-
    Event date

    Set the "Event date" picker to 2026-03-05.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing, default scale.

    Target component: One Mantine DatePickerInput labeled "Event date" (single-date default type).
    - Initial state: empty input with placeholder "Pick date".
    - Interaction: Clicking the input opens a popover calendar (Mantine Popover). Selecting a day sets the value.
    - The selected date is displayed in the input in a readable format and also stored as a Date value.

    Distractors: None.

    Feedback: Selecting a day updates the input immediately and closes the popover.
  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: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single default Mantine DatePickerInput with standard popover selection and immediate visible feedback.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-03-05.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-03-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:
  - Any other date is selected.
  - The input remains empty after interaction.
  - The picker is opened but selection is not committed to the input value.
  expected_interaction_path:
  - Click the Event date input.
  - Navigate to March 2026 if needed.
  - Select day 5.
  notes: Mantine DatePickerInput supports popover and modal dropdown types and a clearable button (see Mantine docs).
- id: date_picker_single-mantine-T02
  name: Type a date into DateInput
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DateInput
  implementation_component: 'Mantine: DateInput'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: |-
    In the "Birthday" field, enter the date 2026-04-21.
    The task will finish automatically when done.
  ui_copy: |-
    Birthday

    In the "Birthday" field, enter the date 2026-04-21.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One Mantine DateInput labeled "Birthday".
    - Initial state: empty.
    - The input supports free-form typing as well as opening a calendar popover.
    - A helper text under the field indicates the expected format: "YYYY-MM-DD".
    - Invalid text shows an inline error state and does not set the underlying value.

    Distractors: None.

    Feedback: When a valid date is entered and committed (blur/Enter), the input displays the normalized value and the internal Date value is updated.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires correct formatted typing and validation pass, but interaction is confined to a single obvious
      input.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-04-21.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-04-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
  negative_cases:
  - The field contains an invalid or partial date string and the value is not set.
  - A different date is parsed/committed.
  - The text is entered but left uncommitted (value remains null).
  expected_interaction_path:
  - Focus the Birthday input.
  - Type 2026-04-21.
  - Press Enter or blur the field to commit.
  notes: |-
    Instrumentation: expose the parsed Date value for the checker.
    Mantine DateInput is documented as a free date input and supports DatePicker props (see Mantine docs).
- id: date_picker_single-mantine-T03
  name: Clear a clearable DatePickerInput
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput (clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: |-
    Clear the "Reminder" date so that no date is selected.
    The task will finish automatically when done.
  ui_copy: |-
    Reminder (prefilled)

    Clear the "Reminder" date so that no date is selected.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One Mantine DatePickerInput labeled "Reminder".
    - Initial state: the input contains a prefilled date "2026-01-15".
    - Configuration: `clearable=true`, which shows a clear (x) button in the right section of the input when a value is present.
    - Clicking the clear button removes the value and returns the input to its placeholder state.

    Distractors: None.

    Feedback: Clearing is immediate with no confirmation.
  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: 2
      disambiguation_load: 1
    justification: Single clear action using a standard clearable affordance with immediate, visible state change.
  success_trigger:
    human_readable:
    - Date picker must have selected date = empty (no date).
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: 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:
  - Any date value remains selected after the interaction.
  - The user deletes visible text but the component value is still not null.
  - The calendar popover is opened but the value is not cleared.
  expected_interaction_path:
  - Click the clear (x) button in the Reminder input.
  notes: Mantine DatePickerInput supports `clearable` to display a clear button (see Mantine docs). Ensure the clear button
    has a stable selector for agents.
- id: date_picker_single-mantine-T04
  name: Set Check-in date in compact form with two pickers
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the Reservation form, set the "Check-in date" picker to 2026-07-04.
    The task will finish automatically when done.
  ui_copy: |-
    Reservation

    In the Reservation form, set the "Check-in date" picker to 2026-07-04.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Form section layout (form_section) centered on the page. Theme is light. Spacing is compact so labels and inputs are closer than default.

    Target components: Two Mantine DatePickerInput controls appear side-by-side in the same row:
    - "Check-in date" (TARGET) - empty.
    - "Arrival time" - a plain time dropdown (distractor).
    Below them there is another DatePickerInput labeled "Check-out date" (distractor) prefilled with a different date.

    Interaction: The Check-in DatePickerInput opens a popover calendar. Selecting a day sets the value.

    Clutter: Low (a couple of extra fields and a "Guests" number input).

    Feedback: Selecting a day updates only the active input; compact spacing makes it easier to click the wrong field.
  scene_context:
    theme: light
    spacing: compact
    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: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Compact spacing and multiple date-related fields increase disambiguation load despite a standard single-date
      selection interaction.
  success_trigger:
    human_readable:
    - Target instance (Check-in date) must have selected date = 2026-07-04.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-07-04'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Check-in date
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The "Check-out date" is changed instead of "Check-in date".
  - Check-in date remains empty or is set to a different day.
  - A date is typed but not accepted (invalid state).
  expected_interaction_path:
  - Click the "Check-in date" input.
  - Navigate to July 2026 if needed.
  - Select day 4.
  notes: Even though multiple date-related fields exist, only the labeled "Check-in date" DatePickerInput instance should
    be checked for success.
- id: date_picker_single-mantine-T05
  name: Set backup date in dark settings panel
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    In the Backup settings panel, set the "Next backup date" picker to 2026-12-01.
    The task will finish automatically when done.
  ui_copy: |-
    Backup settings

    In the Backup settings panel, set the "Next backup date" picker to 2026-12-01.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Settings panel layout (settings_panel) in dark theme with comfortable spacing and default scale.

    Target component: One Mantine DatePickerInput labeled "Next backup date".
    - Initial state: empty.
    - Interaction: Clicking the input opens a popover calendar.

    Distractors (medium clutter): toggles for "Automatic backups", a select for "Retention period", and a slider for "Bandwidth limit".

    Feedback: Selecting a day updates the input immediately. Dark theme reduces contrast between selected and unselected day styles.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Dark theme and realistic settings clutter add modest target acquisition and disambiguation difficulty while
      keeping the interaction path short.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-12-01.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-12-01'
      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:
  - Any other date is selected.
  - The date is set in an unrelated field (e.g., retention period) instead of the date picker.
  - The input remains empty.
  expected_interaction_path:
  - Open the Next backup date picker.
  - Navigate to December 2026 if needed.
  - Select day 1.
  notes: Mantine DatePickerInput supports standard Input props and should be labeled for accessibility (see Mantine docs).
- id: date_picker_single-mantine-T06
  name: Set a small launch date picker in the top-right
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput (size="xs" approx)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: |-
    Set the "Launch date" picker to 2026-02-14.
    The task will finish automatically when done.
  ui_copy: |-
    Marketing

    Set the "Launch date" picker to 2026-02-14.
    The task will finish automatically when done.
  setup_description: |-
    Scene: An isolated card anchored near the top-right of the viewport (placement=top_right). Light theme, comfortable spacing. The DatePickerInput uses a small size variant (scale=small) to mimic a compact toolbar form.

    Target component: One Mantine DatePickerInput labeled "Launch date".
    - Initial state: empty.
    - Interaction: Clicking the small input opens the popover calendar.

    Distractors: None.

    Feedback: Selecting a day sets the value immediately and closes the popover.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small control size and off-center placement increase target acquisition difficulty compared to baseline,
      but selection remains a single-step calendar click.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-02-14.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '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:
  - Any date other than 2026-02-14 is selected.
  - The popover is opened but the value remains empty.
  - The user clicks outside and dismisses the popover without committing a selection.
  expected_interaction_path:
  - Click the Launch date input in the top-right card.
  - Navigate to February 2026 if needed.
  - Select day 14.
  notes: |-
    Implementation_component is marked 'approx' for size prop naming; verify Mantine size prop for DatePickerInput in the adapter.
    Checker reads the underlying Date value.
- id: date_picker_single-mantine-T07
  name: Choose a far past date on an inline calendar
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePicker
  implementation_component: 'Mantine: DatePicker (inline calendar)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: |-
    On the inline calendar, select the date 1998-12-31.
    The task will finish automatically when done.
  ui_copy: |-
    Company founding date

    On the inline calendar, select the date 1998-12-31.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: A Mantine DatePicker rendered inline (always visible calendar, not inside an input).
    - Initial state: no date selected; the calendar initially shows a near-term month/year.
    - Interaction: The user must use the calendar header controls to navigate across years to reach December 1998, then click day 31.
    - Because the calendar is inline, there is no popover open/close step; all complexity comes from within-component navigation.

    Distractors: None.

    Feedback: Clicking a day highlights the selection immediately within the calendar.
  scene_context:
    theme: light
    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: 4
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Inline calendar requires extensive within-component navigation to reach a date decades in the past, increasing
      depth and the chance of selecting an adjacent year/month.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 1998-12-31.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '1998-12-31'
      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:
  - Any date other than 1998-12-31 is selected.
  - The calendar is navigated to the correct year but the wrong day/month is clicked.
  - The selection is made on the wrong month view (e.g., December 1999).
  expected_interaction_path:
  - Use header controls to move to year 1998 and month December.
  - Click day 31 in the grid.
  notes: |-
    Instrumentation: inline DatePicker root should expose current selected date and current view (month/year) for debugging.
    Checker reads selected date from component state.
- id: date_picker_single-mantine-T08
  name: Match a visual reference in a modal dropdown
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput (dropdownType=modal)
  implementation_component: 'Mantine: DatePickerInput (dropdownType="modal")'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: |-
    Set the "Conference date" picker to match the date shown on the Ticket preview.
    The task will finish automatically when done.
  ui_copy: |-
    Conference registration

    Set the "Conference date" picker to match the date shown on the Ticket preview.
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Reference: A non-interactive "Ticket preview" component shows the target date as a stylized ticket with a large month/day and a small year label (visual reference).

    Target component: One Mantine DatePickerInput labeled "Conference date", configured with `dropdownType="modal"` so that activating the input opens the calendar inside a Mantine Modal rather than a popover (as documented).
    - Initial state: empty.
    - Interaction: The modal calendar includes header controls for navigating months/years.

    Distractors: A checkbox ("I need accessibility accommodations") and a text input ("Badge name") appear below (clutter=low).

    Feedback: Selecting the date updates the input and closes the modal.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 5
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Visual-only target plus a modal-based picker (extra overlay layer) increases depth and observability demands,
      especially when navigating to a future year.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2028-08-22.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2028-08-22'
      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:
  - The selected date does not match the Ticket preview reference.
  - The calendar is navigated to the right month but the wrong day is selected.
  - The modal is dismissed without committing a selection (value remains empty).
  expected_interaction_path:
  - Read the target date from the Ticket preview (month/day/year).
  - Open the Conference date picker (modal opens).
  - Navigate to August 2028.
  - Select day 22.
  notes: |-
    Mantine docs: DatePickerInput supports opening the picker in a modal via `dropdownType="modal"`.
    Instrumentation: ticket preview should have data-testid="ticket-date" for optional dynamic checking.
- id: date_picker_single-mantine-T09
  name: Set Milestone B date in a table using a mixed reference
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DatePickerInput
  implementation_component: 'Mantine: DatePickerInput in table cells'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: |-
    In the Milestones table, set the "Milestone B" date picker to match the date shown in the Reference chip.
    The task will finish automatically when done.
  ui_copy: |-
    Milestones

    In the Milestones table, set the "Milestone B" date picker to match the date shown in the Reference chip.
    The task will finish automatically when done.
  setup_description: |-
    Scene: A table_cell layout containing a "Milestones" table with three rows (A, B, C). Theme is light with comfortable spacing. Clutter is high due to table controls (sorting, row actions, search) and additional columns.

    Reference: Above the table, a "Reference chip" shows the target date in mixed form:
    - A short formatted text date (e.g., "Tue Oct 6, 2026").
    - A small calendar icon with the day number.

    Target components: Each milestone row has a Mantine DatePickerInput in the "Target date" column:
    - Milestone A date (distractor)
    - Milestone B date (TARGET)
    - Milestone C date (distractor)
    Initial state: all three date inputs are empty.

    Interaction: Click into the Milestone B date cell to open its popover calendar and pick the referenced date.

    Feedback: The chosen date appears in the Milestone B cell; other rows remain unchanged.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 3
    guidance: mixed
    clutter: high
  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: 3
      disambiguation_load: 5
    justification: Three similar date pickers embedded in table cells plus high clutter creates heavy disambiguation and target
      acquisition demands; the target date is provided via a mixed reference element.
  success_trigger:
    human_readable:
    - Target instance (Milestone B) must have selected date = 2026-10-06.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-10-06'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Milestone B
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Milestone A or C is set correctly but Milestone B is not.
  - Milestone B is set to a different date than the reference.
  - The correct date is selected in the calendar but applied to the wrong row.
  expected_interaction_path:
  - Read the target date from the Reference chip.
  - Find the Milestone B row and its Target date cell.
  - Open the DatePickerInput popover.
  - Navigate to October 2026 if needed and select day 6.
  notes: |-
    Instrumentation: include row-level identifiers (milestone-a/b/c) and a testid for the Reference chip.
    Checker must only verify the Milestone B date picker value.
- id: date_picker_single-mantine-T10
  name: Enter a date with DD/MM/YYYY valueFormat
  canonical_type: date_picker_single
  implementation_source: mantine
  implementation_variant: DateInput (valueFormat=DD/MM/YYYY)
  implementation_component: 'Mantine: DateInput (custom valueFormat)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: |-
    In the "Invoice date" field, enter 23/11/2026 (format: DD/MM/YYYY).
    The task will finish automatically when done.
  ui_copy: |-
    Invoice date

    In the "Invoice date" field, enter 23/11/2026 (format: DD/MM/YYYY).
    The task will finish automatically when done.
  setup_description: |-
    Scene: Centered isolated card, light theme, comfortable spacing.

    Target component: One Mantine DateInput labeled "Invoice date".
    - Configuration: The displayed/parsed format is set to DD/MM/YYYY (via `valueFormat` / parsing configuration in the adapter).
    - Initial state: empty.
    - Validation: If the user enters a string that does not match the required format, the field shows an error message "Use DD/MM/YYYY".

    Distractors: None.

    Feedback: When the input is valid and committed, the internal date value updates to the parsed canonical date.
  scene_context:
    theme: light
    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: 4
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: Non-default date format requires precise formatted entry and correct parsing/validation before the component
      state updates.
  success_trigger:
    human_readable:
    - Date picker must have selected date = 2026-11-23.
    - Task ends immediately when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date: '2026-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
  negative_cases:
  - The date is entered in a different format (e.g., 11/23/2026) and is rejected or parsed incorrectly.
  - Only a partial date is entered (missing year or separators).
  - The field shows the right characters but remains in an error state and value is not set.
  expected_interaction_path:
  - Focus the Invoice date input.
  - Type 23/11/2026.
  - Commit the value (Enter/blur) and ensure the error message is gone.
  notes: |-
    Mantine DatePickerInput docs mention `valueFormat`/`valueFormatter` for formatting the displayed value; ensure the adapter enables matching parsing for DateInput.
    Checker should validate parsed canonical date equals 2026-11-23.