tasks/v1/date_picker_range.yaml

- id: date_picker_range-antd-T01
  name: Open Booking dates calendar
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the 'Booking dates' date range picker so its calendar dropdown
    is visible. The task will finish automatically when done.
  ui_copy: 'Booking dates: [ Select date range ]'
  setup_description: Layout is an isolated card centered in the viewport with a single
    Ant Design RangePicker labeled 'Booking dates'. Theme is light with comfortable
    spacing and default component scale. The RangePicker is an input with two date
    fields (start and end) separated by a small icon separator; it is initially empty
    and shows a placeholder like 'Select date range'. Clicking anywhere in the input
    opens a popover calendar panel (two months visible side-by-side) anchored to the
    input. There are no other interactive elements on the card (no clutter).
  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: 1
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Single default RangePicker with no distractors; success only requires
      opening the popover.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Booking dates'.
    - The picker overlay/popover is open for that instance.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: open_state_equals
      target_state:
        open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Booking dates
      terminal_condition: true
  negative_cases:
  - Opening nothing (popover not visible).
  - Opening a different date picker (not applicable here, but must be guarded by instance
    id).
  - Popover opens but immediately closes before the checker fires.
  expected_interaction_path: Click inside the 'Booking dates' RangePicker input to
    open the calendar popover.
  notes: 'Instrumentation: add data-testid on the RangePicker root (e.g., booking-dates-range),
    and expose an ''open'' boolean via DOM (e.g., aria-expanded on the input or a
    popover presence check).'
- id: date_picker_range-antd-T02
  name: Set Booking dates to a short March range
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set 'Booking dates' to March 10, 2026 through March 14, 2026. The
    task will finish automatically when done.
  ui_copy: Booking dates (required)
  setup_description: Baseline isolated card centered in the viewport. It contains
    one Ant Design RangePicker labeled 'Booking dates (required)'. Theme is light,
    comfortable spacing, default scale. The RangePicker starts empty. When opened,
    the popover shows a two-month calendar view with next/previous month arrow controls
    in the header and a highlighted selection when dates are chosen. No Apply/OK button
    is shown (selection is committed when the end date is chosen 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: 4
      disambiguation_load: 1
    justification: Simple within-year range selection with clear textual target and
      default behavior (no confirm step).
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Booking dates'.
    - The selected start date equals 2026-03-10 (YYYY-MM-DD).
    - The selected end date equals 2026-03-14 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-03-10'
        end_date: '2026-03-14'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Booking dates
      terminal_condition: true
  negative_cases:
  - Only the start date is selected (end date missing).
  - The selected range is reversed or spans different days than requested.
  - The range is off by one day (e.g., Mar 9–Mar 14 or Mar 10–Mar 15).
  expected_interaction_path: Open the RangePicker → click Mar 10, 2026 as start →
    click Mar 14, 2026 as end.
  notes: Checker should normalize to canonical YYYY-MM-DD and verify start<=end.
- id: date_picker_range-antd-T03
  name: Clear a prefilled range
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the 'Booking dates' field so no start or end date is selected.
    The task will finish automatically when done.
  ui_copy: 'Booking dates: 2026-04-05 ~ 2026-04-12'
  setup_description: 'Isolated card in the center, light theme, comfortable spacing.
    One Ant Design RangePicker labeled ''Booking dates'' is prefilled with the range
    ''2026-04-05 ~ 2026-04-12''. The component uses the default clear affordance:
    a small clear (×) icon appears when hovering/focusing the input. Clicking the
    clear icon resets both start and end to empty. No other UI elements are present.'
  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: 5
      disambiguation_load: 1
    justification: The current value is visible in the input and clearing is a single
      direct action.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Booking dates'.
    - The start date is empty (null).
    - The end date is empty (null).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_is_empty
      target_state:
        start_date: null
        end_date: null
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Booking dates
      terminal_condition: true
  negative_cases:
  - Only one side cleared (start or end still set).
  - Range changed to a different value instead of being cleared.
  - Clearing a different instance (not applicable here but must be guarded by instance
    id).
  expected_interaction_path: Hover/focus the RangePicker → click the clear (×) icon.
  notes: 'Instrumentation: expose a stable selector for the clear icon (e.g., data-testid=''booking-dates-clear'').'
- id: date_picker_range-antd-T04
  name: Use a preset range chip
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: presets
  implementation_component: 'AntD: DatePicker.RangePicker (presets)'
  task_template: set_range
  secondary_template: null
  browsergym_goal: For 'Travel dates', use the preset 'Memorial Day week (May 25–May
    31, 2026)'. The task will finish automatically when done.
  ui_copy: Trip Planner → Travel dates (use a preset)
  setup_description: A form_section layout (simple trip-planning form) with light
    theme and comfortable spacing. Fields include 'Destination' (text input), 'Travel
    dates' (AntD RangePicker), and a non-functional 'Notes' textarea (distractor but
    not required). The RangePicker is empty initially. When opened, the calendar popover
    shows a 'Preset ranges' area with clickable chips such as 'Memorial Day week (May
    25–May 31, 2026)', 'Independence Day week (Jul 4–Jul 10, 2026)', and 'Labor Day
    weekend (Sep 5–Sep 7, 2026)'. Selecting a preset immediately fills the start and
    end dates in the input and closes the popover (no separate OK button).
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: Selecting a clearly labeled preset is a straightforward path; minor
      risk of choosing the wrong chip among a few.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Travel dates'.
    - The selected start date equals 2026-05-25 (YYYY-MM-DD).
    - The selected end date equals 2026-05-31 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-05-25'
        end_date: '2026-05-31'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Travel dates
      terminal_condition: true
  negative_cases:
  - Selecting the wrong preset (e.g., Independence Day week).
  - Manually selecting dates that do not match the preset range.
  - Leaving the field partially filled (only start or only end).
  expected_interaction_path: Open 'Travel dates' → click the preset chip 'Memorial
    Day week (May 25–May 31, 2026)'.
  notes: Checker can accept either preset-click or manual selection as long as the
    canonical range equals the target.
- id: date_picker_range-antd-T05
  name: Type a contract period in YYYY-MM-DD
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: format_yyyy_mm_dd
  implementation_component: 'AntD: DatePicker.RangePicker (format + mask)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In 'Contract period', enter the date range 2026-06-01 through 2026-06-15.
    The task will finish automatically when done.
  ui_copy: Contract period (YYYY-MM-DD)
  setup_description: Isolated card centered in the viewport, but with compact spacing
    and a small-sized Ant Design RangePicker labeled 'Contract period (YYYY-MM-DD)'.
    The input uses a strict display/entry format of YYYY-MM-DD for both start and
    end and shows a mask while typing. The field starts empty. Clicking into either
    side of the RangePicker allows keyboard entry. The calendar popover can also be
    used, but the intended easy path is typing the dates. The value is committed when
    the input loses focus or when Enter is pressed.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: Requires precise formatted keyboard entry in a compact/small control;
      feedback is immediate but format mistakes are likely.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Contract period'.
    - The selected start date equals 2026-06-01 (YYYY-MM-DD).
    - The selected end date equals 2026-06-15 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-06-01'
        end_date: '2026-06-15'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Contract period
      terminal_condition: true
  negative_cases:
  - Typing an invalid format (e.g., 06/01/2026) that is not accepted by the field.
  - Only one side entered (start or end missing).
  - Off-by-one endpoints (e.g., ending 2026-06-14 or 2026-06-16).
  expected_interaction_path: Click start input → type 2026-06-01 → move to end input
    → type 2026-06-15 → press Enter or blur.
  notes: Checker should parse the component value to canonical ISO dates; tolerate
    intermediate typing states until committed.
- id: date_picker_range-antd-T06
  name: Navigate the calendar to August 2026
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: Open 'Plan window' and navigate the calendar until August 2026
    is visible (you do not need to select dates). The task will finish automatically
    when done.
  ui_copy: 'Plan window — Target month: August 2026'
  setup_description: 'Isolated card centered in the viewport with dark theme (dark
    background, light text). One Ant Design RangePicker labeled ''Plan window'' is
    empty. A small helper badge above the input reads ''Target month: August 2026''
    (visual reinforcement). Opening the RangePicker shows a popover with two month
    panels and header navigation arrows. The initial visible months are near the current
    reference month (February 2026). No dates need to be selected; the goal is purely
    to navigate the visible month.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires repeated navigation actions and recognizing month/year
      in a dark theme; no precise date selection needed.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Plan window'.
    - The date range picker overlay is open.
    - The calendar view shows 2026-08 (YYYY-MM) as left panel month.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: calendar_view_month_equals
      target_state:
        target_month: 2026-08
        match_mode: left_panel
      tolerance:
        months: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Plan window
      terminal_condition: true
  negative_cases:
  - Calendar popover is not open (month cannot be verified).
  - A different month is shown (e.g., July 2026 or September 2026) when the checker
    runs.
  - Navigating only the right panel such that August 2026 is not the leftmost visible
    month (for this task).
  expected_interaction_path: Open 'Plan window' → click next-month arrow until Aug
    2026 appears in the left calendar header.
  notes: 'Instrumentation: expose visible month labels for both panels (e.g., data-testid
    for left-month-label and right-month-label).'
- id: date_picker_range-antd-T07
  name: Set the Comparison period in a dashboard filter bar
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the dashboard filters, set the 'Comparison period' to January
    20, 2026 through February 5, 2026. The task will finish automatically when done.
  ui_copy: 'Analytics Dashboard → Filters: Primary period, Comparison period'
  setup_description: 'A dashboard layout with a top filter bar. The page includes
    two Ant Design RangePickers of the same type: ''Primary period'' and ''Comparison
    period'' (instances=2). Both are initially empty and look identical except for
    their labels. The filter bar also contains non-required controls: a ''Region''
    dropdown, a ''Channel'' dropdown, and a search box (distractors). The ''Comparison
    period'' picker is placed at the top-right area of the viewport. When opened,
    its calendar popover shows January 2026 and February 2026 side-by-side, so the
    requested cross-month range can be selected without extra month navigation.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: top_right
    scale: default
    instances: 2
    guidance: mixed
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 4
    justification: Requires selecting the correct instance among two similar pickers
      in a cluttered filter bar and selecting a cross-month range.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Comparison period'.
    - The selected start date equals 2026-01-20 (YYYY-MM-DD).
    - The selected end date equals 2026-02-05 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-01-20'
        end_date: '2026-02-05'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Comparison period
      terminal_condition: true
  negative_cases:
  - Setting the correct range on 'Primary period' instead of 'Comparison period'.
  - Selecting only the start date (Jan 20) without completing the end date (Feb 5).
  - Selecting a nearby but incorrect range (e.g., ending Feb 4 or Feb 6).
  expected_interaction_path: Click 'Comparison period' input → select Jan 20, 2026
    → select Feb 5, 2026 → popover closes.
  notes: Checker must verify the correct-instance requirement (e.g., by input id).
- id: date_picker_range-antd-T08
  name: Cancel changes in a need-confirm RangePicker
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: needConfirm
  implementation_component: 'AntD: DatePicker.RangePicker (needConfirm=true)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open 'Blackout dates', then click the picker’s Cancel button so
    the value stays July 10, 2026 through July 12, 2026 (do not apply any new dates).
    The task will finish automatically when done.
  ui_copy: 'Maintenance Settings → Blackout dates: 2026-07-10 ~ 2026-07-12'
  setup_description: A settings page with a primary button 'Edit blackout dates'.
    Clicking it opens a modal dialog (modal_flow). Inside the modal is a single Ant
    Design RangePicker labeled 'Blackout dates' with needConfirm enabled, so the calendar
    panel includes explicit action buttons (OK and Cancel). The RangePicker is prefilled
    with '2026-07-10 ~ 2026-07-12'. The rest of the modal contains read-only text
    explaining what blackout dates mean (non-interactive). The task is to open the
    picker panel and use Cancel to ensure no new selection is applied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 1
    justification: Adds modal + explicit cancel/accept semantics; requires discarding
      edits via the component’s own Cancel control.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Blackout dates'.
    - The picker overlay is closed after pressing Cancel.
    - The selected range remains 2026-07-10 to 2026-07-12 (no change from last accepted
      value).
    - A Cancel action was used to discard edits (not just closing the overlay).
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: cancel_discards_changes
      target_state:
        start_date: '2026-07-10'
        end_date: '2026-07-12'
        cancel_clicked: true
        overlay_open: false
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Cancel
      require_correct_instance: true
      target_instance_label_or_id: Blackout dates
      terminal_condition: true
  negative_cases:
  - Pressing OK/Confirm (or otherwise applying) after changing dates.
  - Changing the stored value away from 2026-07-10 ~ 2026-07-12.
  - Closing the popover by clicking outside without using the Cancel button (should
    not count).
  - Clicking Cancel on the modal instead of the picker (if a modal-level cancel exists).
  expected_interaction_path: Click 'Edit blackout dates' → open 'Blackout dates' picker
    → click the picker’s Cancel action → verify value unchanged.
  notes: 'Instrumentation: need a reliable signal that the picker-level Cancel button
    was pressed (e.g., event hook sets data-state cancel_clicked=true). Also expose
    the last accepted range value separately from temporary hover/preview state.'
- id: date_picker_range-antd-T09
  name: Set Secondary maintenance window among three pickers
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker.RangePicker'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set the 'Secondary maintenance window' to September 2, 2026 through
    September 9, 2026. The task will finish automatically when done.
  ui_copy: 'Maintenance Windows: Primary, Secondary, Reporting'
  setup_description: 'A settings_panel layout with a left navigation sidebar and a
    right content area. The content area uses compact spacing and contains three visually
    similar Ant Design RangePickers (instances=3) stacked vertically:

    1) ''Primary maintenance window'' (prefilled),

    2) ''Secondary maintenance window'' (empty — this is the target),

    3) ''Reporting window'' (prefilled).

    Additional distractors include two toggle switches (''Email alerts'', ''Auto-reschedule'')
    and a Save button that does nothing for the task. Selecting a range does not require
    pressing OK; the RangePicker commits on end-date selection.'
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: High disambiguation load with three same-type instances and compact
      spacing; must modify the correct labeled picker.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Secondary maintenance window'.
    - The selected start date equals 2026-09-02 (YYYY-MM-DD).
    - The selected end date equals 2026-09-09 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-09-02'
        end_date: '2026-09-09'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary maintenance window
      terminal_condition: true
  negative_cases:
  - Setting the requested range on 'Primary maintenance window' or 'Reporting window'
    instead of 'Secondary maintenance window'.
  - Selecting a partial range (only Sep 2 selected).
  - Off-by-one endpoints (e.g., Sep 1–Sep 9 or Sep 2–Sep 10).
  expected_interaction_path: Locate 'Secondary maintenance window' → open its calendar
    → click Sep 2 then Sep 9 → verify input shows the range.
  notes: Checker must bind to instance ids (e.g., data-testid secondary-window-range)
    rather than relying on DOM order.
- id: date_picker_range-antd-T10
  name: Set an open-ended range (start only) with OK
  canonical_type: date_picker_range
  implementation_source: antd
  implementation_variant: allowEmpty_end + needConfirm
  implementation_component: 'AntD: DatePicker.RangePicker (allowEmpty=[false,true],
    needConfirm=true)'
  task_template: set_range
  secondary_template: null
  browsergym_goal: Set 'Project window' to start on October 3, 2026 and leave the
    end date empty, then click OK to confirm. The task will finish automatically when
    done.
  ui_copy: Project window (end date optional)
  setup_description: An isolated card placed near the bottom-left of the viewport
    (placement bottom_left) using a dark theme. The card contains a single Ant Design
    RangePicker labeled 'Project window (end date optional)'. The RangePicker is configured
    to allow the end date to be empty (allowEmpty for end=true) and uses needConfirm=true,
    so the calendar panel shows OK/Cancel actions. The input starts with both values
    empty; helper text below the field says 'If the end date is unknown, leave it
    blank and confirm.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 1
    justification: Nonstandard open-ended range plus required OK confirmation; must
      avoid accidentally setting an end date.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Project window'.
    - The selected start date equals 2026-10-03 (YYYY-MM-DD).
    - The end date is empty (null).
    - If the picker has a confirm action, it has been accepted/applied.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_open_end_equals
      target_state:
        start_date: '2026-10-03'
        end_date: null
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: OK
      require_correct_instance: true
      target_instance_label_or_id: Project window
      terminal_condition: true
  negative_cases:
  - Setting any end date instead of leaving it empty.
  - Picking the correct start date but forgetting to click OK/Confirm.
  - Entering a start date close to Oct 3 but not exact (e.g., Oct 2 or Oct 4).
  expected_interaction_path: Open 'Project window' → select Oct 3, 2026 as start →
    ensure end remains blank → click OK.
  notes: Checker must treat end_date=null as a valid canonical state for this task
    (enabled by allowEmpty).
- id: date_picker_range-mui-T01
  name: Open Booking dates picker (desktop popover)
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: DesktopDateRangePicker
  implementation_component: 'MUI X: DesktopDateRangePicker (DateRangePicker)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the 'Booking dates' date range picker so the calendar popover
    is visible. The task will finish automatically when done.
  ui_copy: Booking dates — MM/DD/YYYY – MM/DD/YYYY
  setup_description: Baseline isolated card centered in the viewport with a single
    MUI X DateRangePicker labeled 'Booking dates'. It uses the desktop variant (popover)
    with a single input field displaying the range in the format 'MM/DD/YYYY – MM/DD/YYYY'.
    A calendar icon button at the end of the input also opens the popover. The field
    starts empty. There are no other interactive elements on the page.
  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: 1
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Single date range picker; only requires opening its popover.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Booking dates'.
    - The picker overlay/popover is open for that instance.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: open_state_equals
      target_state:
        open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Booking dates
      terminal_condition: true
  negative_cases:
  - Popover not visible (picker not opened).
  - Opening a different overlay on the page (should not exist).
  expected_interaction_path: Click the input or calendar icon to open the DateRangePicker
    popover.
  notes: MUI X Date Range Picker docs describe desktop vs mobile variants and popover
    behavior. (Ensure stable test ids for the field and popover root.)
- id: date_picker_range-mui-T02
  name: Select a short date range in March
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: DesktopDateRangePicker
  implementation_component: 'MUI X: DesktopDateRangePicker (DateRangePicker)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set 'Booking dates' to 03/10/2026 through 03/14/2026. The task
    will finish automatically when done.
  ui_copy: Booking dates
  setup_description: Isolated card centered in the viewport with one MUI X desktop
    DateRangePicker labeled 'Booking dates'. The calendar opens in a popover when
    the input is focused. The popover shows a month grid with navigation arrows and
    highlights the selected start, end, and in-between days. The value commits as
    soon as the end date is selected (no separate OK button). The input initially
    shows an empty placeholder 'MM/DD/YYYY – MM/DD/YYYY'.
  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: 4
      disambiguation_load: 1
    justification: Straightforward two-click range selection with visible textual
      feedback in the field.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Booking dates'.
    - The selected start date equals 2026-03-10 (YYYY-MM-DD).
    - The selected end date equals 2026-03-14 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-03-10'
        end_date: '2026-03-14'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Booking dates
      terminal_condition: true
  negative_cases:
  - Only the start date is chosen (end date missing).
  - Wrong endpoints (off-by-one).
  - Setting a range in a different month/year.
  expected_interaction_path: Open picker → click Mar 10, 2026 → click Mar 14, 2026.
  notes: Checker should read the normalized value from the picker state rather than
    the localized input string.
- id: date_picker_range-mui-T03
  name: Clear an inline StaticDateRangePicker
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: StaticDateRangePicker + actionBar(clear)
  implementation_component: 'MUI X: StaticDateRangePicker / StaticDateRangePicker
    (date range) with action bar'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selected range in 'Reporting range' so it becomes empty.
    The task will finish automatically when done.
  ui_copy: 'Reporting range: 04/17/2026 – 04/21/2026'
  setup_description: Isolated card in the center with a static (inline) MUI X date
    range picker labeled 'Reporting range'. Unlike the popover variant, the calendar
    grid is always visible (no overlay). The component is prefilled with 04/17/2026
    – 04/21/2026. Below the calendar there is an action bar containing a 'Clear' button.
    Clicking 'Clear' resets the range to empty (both start and end become null).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: A single visible Clear control resets the value; state is clearly
      observable.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Reporting range'.
    - The start date is empty (null).
    - The end date is empty (null).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_is_empty
      target_state:
        start_date: null
        end_date: null
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Reporting range
      terminal_condition: true
  negative_cases:
  - Only one date cleared (start or end remains set).
  - Changing to a different non-empty range instead of clearing.
  - Clicking Cancel/OK without clearing (if present).
  expected_interaction_path: Click the 'Clear' button in the picker action bar.
  notes: 'Instrumentation: expose action bar buttons with stable labels/ids (clear,
    cancel, ok).'
- id: date_picker_range-mui-T04
  name: Type start and end into a multi-input field
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: MultiInputDateRangeField
  implementation_component: 'MUI X: DateRangePicker (slots.field=MultiInputDateRangeField)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In 'Warranty period', set Start to 05/01/2026 and End to 05/31/2026
    using the text fields. The task will finish automatically when done.
  ui_copy: Warranty period → Start / End
  setup_description: A form_section layout for product settings. The date range control
    is a MUI X DateRangePicker configured with a MultiInputDateRangeField, rendering
    two separate text fields labeled 'Start' and 'End' with placeholders 'MM/DD/YYYY'.
    The calendar popover can be opened, but the intended path is keyboard input. The
    range is considered set when both fields contain valid dates and the picker commits
    the value (pressing Enter or blurring the field). Other fields on the form (SKU
    text input, 'Active' checkbox) are present as low clutter but are not required.
  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: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: Requires correct formatted entry across two coordinated fields
      and committing the value.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Warranty period'.
    - The selected start date equals 2026-05-01 (YYYY-MM-DD).
    - The selected end date equals 2026-05-31 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-05-01'
        end_date: '2026-05-31'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Warranty period
      terminal_condition: true
  negative_cases:
  - Only Start or only End is filled.
  - Invalid date format that is not accepted by the field.
  - End date earlier than Start date.
  expected_interaction_path: Click Start → type 05/01/2026 → click End → type 05/31/2026
    → press Enter or blur.
  notes: 'Checker: read canonical picker value (two dates) rather than raw text, since
    localization may vary.'
- id: date_picker_range-mui-T05
  name: Use a shortcut chip to set a sprint window
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: StaticDateRangePicker + shortcuts
  implementation_component: 'MUI X: StaticDateRangePicker (range) with PickersShortcuts'
  task_template: set_range
  secondary_template: null
  browsergym_goal: In 'Sprint window', select the shortcut 'Sprint 3 (02/09/2026–02/20/2026)'
    and click OK to apply it. The task will finish automatically when done.
  ui_copy: Sprint window — choose a shortcut
  setup_description: 'Isolated card centered in the viewport containing a static (always-visible)
    MUI X date range picker labeled ''Sprint window''. On the left side of the calendar
    is a shortcuts column with clickable items (chips), including:

    - ''Sprint 1 (01/12/2026–01/23/2026)''

    - ''Sprint 2 (01/26/2026–02/06/2026)''

    - ''Sprint 3 (02/09/2026–02/20/2026)''

    - ''Reset''

    The picker has an action bar at the bottom with ''Cancel'' and ''OK''. Clicking
    a shortcut updates the highlighted range; clicking OK is required to accept/apply
    the currently highlighted range.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    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: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires selecting the correct shortcut among several and then
      using the explicit OK action to apply.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Sprint window'.
    - The selected start date equals 2026-02-09 (YYYY-MM-DD).
    - The selected end date equals 2026-02-20 (YYYY-MM-DD).
    - If the picker has a confirm action, it has been accepted/applied.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-02-09'
        end_date: '2026-02-20'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: OK
      require_correct_instance: true
      target_instance_label_or_id: Sprint window
      terminal_condition: true
  negative_cases:
  - Selecting the wrong shortcut (e.g., Sprint 2).
  - Highlighting Sprint 3 but not clicking OK.
  - Using Reset so the range becomes empty.
  expected_interaction_path: Click shortcut 'Sprint 3 (02/09/2026–02/20/2026)' → click
    OK.
  notes: Checker should ensure OK was pressed (e.g., by reading acceptedValue vs draftValue
    if available).
- id: date_picker_range-mui-T06
  name: Navigate picker to November 2026
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: DesktopDateRangePicker
  implementation_component: 'MUI X: DesktopDateRangePicker (DateRangePicker)'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: Open 'Archive window' and navigate the calendar until November
    2026 is visible. You do not need to select any dates. The task will finish automatically
    when done.
  ui_copy: Archive window — navigate calendar
  setup_description: An isolated card centered in the viewport with one MUI X desktop
    DateRangePicker labeled 'Archive window'. The field is empty. When opened, the
    popover shows one calendar month at a time with left/right navigation arrows in
    the header. The picker starts near February 2026. The goal is to use the month
    navigation controls until the month label shows 'November 2026'.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Tests calendar navigation via header controls and recognizing the
      visible month label.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Archive window'.
    - The date range picker overlay is open.
    - The calendar view shows 2026-11 (YYYY-MM) as any visible month.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: calendar_view_month_equals
      target_state:
        target_month: 2026-11
        match_mode: any_visible
      tolerance:
        months: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Archive window
      terminal_condition: true
  negative_cases:
  - Popover not open (no visible month to verify).
  - Stopping on October or December 2026 instead of November 2026.
  - Navigating the wrong component instance (not applicable here).
  expected_interaction_path: Open 'Archive window' → click next-month arrow repeatedly
    until November 2026 appears.
  notes: Checker can read the calendar header text and normalize to YYYY-MM.
- id: date_picker_range-mui-T07
  name: Cancel a dialog-based range selection
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: MobileDateRangePicker dialog
  implementation_component: 'MUI X: MobileDateRangePicker (DateRangePicker) with action
    bar'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open the 'Billing cycle' date range picker and click Cancel so
    no changes are applied (the range should remain empty). The task will finish automatically
    when done.
  ui_copy: Billing cycle — (empty)
  setup_description: 'A drawer_flow layout: the page has a right-side drawer titled
    ''Subscription settings'' already open. Inside the drawer is a MUI X DateRangePicker
    labeled ''Billing cycle''. It is configured to use a dialog/modal style (mobile
    variant), so opening it shows the calendar in a modal with an action bar containing
    ''Cancel'' and ''OK''. The field starts empty. The task is specifically to use
    the picker-level Cancel action to dismiss without setting any range.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Tests layered modal/dialog interaction and explicit cancel semantics;
      value remains empty if cancel is used.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Billing cycle'.
    - The accepted range remains empty (start=null, end=null).
    - A picker-level Cancel action was used to close the dialog (cancel_clicked=true).
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: cancel_discards_changes
      target_state:
        start_date: null
        end_date: null
        cancel_clicked: true
        overlay_open: false
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Cancel
      require_correct_instance: true
      target_instance_label_or_id: Billing cycle
      terminal_condition: true
  negative_cases:
  - Closing the dialog without pressing Cancel (e.g., clicking backdrop) — should
    not count.
  - Selecting any start or end date so the value is no longer empty.
  - Clicking OK instead of Cancel.
  expected_interaction_path: Open 'Billing cycle' picker → click Cancel in the action
    bar.
  notes: 'Instrumentation: track cancel button click separately from generic dialog
    close events.'
- id: date_picker_range-mui-T08
  name: Match a reference promo window
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: StaticDateRangePicker (2 calendars) + reference
  implementation_component: 'MUI X: StaticDateRangePicker (range) with action bar'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the 'Promo window' date range to match the reference card labeled
    'Reference A', then click OK. The task will finish automatically when done.
  ui_copy: Reference A (target range) + Promo window picker
  setup_description: 'Isolated card centered in the viewport with dark theme. The
    card is split into two columns:

    - Left: a ''Reference A'' card showing the target window. It contains a small
    mini-calendar strip with highlighted days and a caption reading ''Dec 1–Dec 15,
    2026''.

    - Right: a static MUI X date range picker labeled ''Promo window'' with two calendars
    visible side-by-side (December 2026 and January 2027). The picker has an action
    bar with ''Cancel'' and ''OK''. The current value is empty.

    The task is to replicate the reference range in the picker and accept it with
    OK.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 1
    justification: Goal is specified via an external reference card and requires applying
      with OK; selection spans many similar day cells.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Promo window'.
    - The selected range matches the reference card 'Reference A'.
    - In canonical form, the selected range equals 2026-12-01 to 2026-12-15 (YYYY-MM-DD).
    - If the picker has a confirm action, it has been accepted/applied.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: Reference A
        start_date: '2026-12-01'
        end_date: '2026-12-15'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: OK
      require_correct_instance: true
      target_instance_label_or_id: Promo window
      terminal_condition: true
  negative_cases:
  - Selecting a range that does not match the reference (wrong start or end).
  - Selecting the correct range but not clicking OK.
  - Interpreting the reference as inclusive/exclusive incorrectly (must match exact
    days).
  expected_interaction_path: Read Reference A → click Dec 1 then Dec 15 in 'Promo
    window' → click OK.
  notes: 'Checker: for matches_reference tasks, store the reference card’s canonical
    start/end in task config for verification.'
- id: date_picker_range-mui-T09
  name: Set Cohort comparison range in a busy dashboard
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: DateRangePicker (responsive)
  implementation_component: 'MUI X: DateRangePicker (responsive/desktop)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the dashboard, set the 'Cohort comparison' date range to 01/05/2026
    through 01/19/2026. The task will finish automatically when done.
  ui_copy: Growth Dashboard — Date filters
  setup_description: 'A dashboard layout with high clutter: top navigation, a left
    sidebar, multiple charts, and a dense filter row. In the filter row there are
    three MUI X DateRangePickers (instances=3) with identical styling and placeholders:

    • ''Signup window'' (prefilled)

    • ''Cohort comparison'' (empty — target)

    • ''Export window'' (prefilled)

    Other distractors in the same row include two Select dropdowns and an ''Apply
    filters'' button (does not affect success). The target picker is anchored near
    the top-left area of the viewport.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: top_left
    scale: default
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: High clutter and multiple same-type instances require careful disambiguation
      and precise selection within a dense filter row.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Cohort comparison'.
    - The selected start date equals 2026-01-05 (YYYY-MM-DD).
    - The selected end date equals 2026-01-19 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-01-05'
        end_date: '2026-01-19'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Cohort comparison
      terminal_condition: true
  negative_cases:
  - Setting the range on 'Signup window' or 'Export window' instead of 'Cohort comparison'.
  - Partial selection (only start date).
  - Off-by-one endpoints.
  expected_interaction_path: Locate 'Cohort comparison' → open popover → pick Jan
    5 and Jan 19 → verify field updates.
  notes: Use explicit instance ids for each DateRangePicker; do not rely on screen
    position for checking.
- id: date_picker_range-mui-T10
  name: Select a cross-year fiscal close range with 3 calendars
  canonical_type: date_picker_range
  implementation_source: mui
  implementation_variant: DesktopDateRangePicker (calendars=3, closeOnSelect=false)
  implementation_component: 'MUI X: DateRangePicker (desktop) with 3 calendars and
    action bar'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set 'Fiscal close' to December 29, 2026 through January 6, 2027,
    then click OK to apply. The task will finish automatically when done.
  ui_copy: Fiscal close (compact)
  setup_description: 'An isolated card placed at the bottom-right of the viewport.
    The page uses compact spacing and the date range picker is rendered in a small
    size. It contains a single MUI X DateRangePicker labeled ''Fiscal close''. The
    picker is configured to show 3 calendars side-by-side in the popover (December
    2026, January 2027, February 2027) to support wide-range selection. It also requires
    explicit confirmation: after selecting start and end, the action bar shows an
    ''OK'' button that must be pressed to apply (closeOnSelect is disabled). The field
    starts empty.'
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 1
    justification: Small/compact targets plus a wide, cross-year range and a required
      OK confirmation increase both acquisition and sequencing difficulty.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Fiscal close'.
    - The selected start date equals 2026-12-29 (YYYY-MM-DD).
    - The selected end date equals 2027-01-06 (YYYY-MM-DD).
    - If the picker has a confirm action, it has been accepted/applied.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-12-29'
        end_date: '2027-01-06'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: OK
      require_correct_instance: true
      target_instance_label_or_id: Fiscal close
      terminal_condition: true
  negative_cases:
  - Selecting the correct dates but not clicking OK.
  - Selecting an adjacent cross-year range (off-by-one).
  - Only selecting a start date without completing the end date.
  expected_interaction_path: Open picker → click Dec 29, 2026 → click Jan 6, 2027
    → click OK.
  notes: Checker should confirm the accepted value (post-OK) rather than intermediate
    draft selection.
- id: date_picker_range-mantine-T01
  name: Open Trip dates dropdown
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput type=range
  implementation_component: 'Mantine: DatePickerInput (type=''range'')'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the 'Trip dates' date range picker so the calendar dropdown
    is visible. The task will finish automatically when done.
  ui_copy: Trip dates — Pick dates range
  setup_description: Baseline isolated card centered in the viewport with a single
    Mantine DatePickerInput configured with type='range' and labeled 'Trip dates'.
    Theme is light with comfortable spacing. The input starts empty and shows a placeholder
    'Pick dates range'. Clicking the input opens a Popover dropdown containing a calendar
    month grid for selecting a start and end date. No other interactive elements are
    present.
  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: 1
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Single default DatePickerInput; only requires opening the popover.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Trip dates'.
    - The picker overlay/popover is open for that instance.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: open_state_equals
      target_state:
        open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Trip dates
      terminal_condition: true
  negative_cases:
  - Popover dropdown not visible.
  - Opening a different popover (should not exist).
  expected_interaction_path: Click the 'Trip dates' input to open the dropdown calendar.
  notes: 'Instrumentation: use Mantine Popover opened state or presence of dropdown
    element to determine open=true.'
- id: date_picker_range-mantine-T02
  name: Select a February weekend trip range
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput type=range
  implementation_component: 'Mantine: DatePickerInput (type=''range'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set 'Trip dates' to February 10, 2026 through February 14, 2026.
    The task will finish automatically when done.
  ui_copy: Trip dates
  setup_description: Isolated card centered in the viewport with one Mantine DatePickerInput
    (type='range') labeled 'Trip dates'. The calendar opens in a Popover dropdown.
    The initial visible month is February 2026. Selecting the start and end dates
    highlights the in-between days and fills the input with the chosen range immediately
    (no separate Apply/OK control).
  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: 4
      disambiguation_load: 1
    justification: Simple date range selection in the currently visible month with
      immediate input feedback.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Trip dates'.
    - The selected start date equals 2026-02-10 (YYYY-MM-DD).
    - The selected end date equals 2026-02-14 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-02-10'
        end_date: '2026-02-14'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Trip dates
      terminal_condition: true
  negative_cases:
  - Selecting only a start date (end missing).
  - Selecting the wrong endpoints (off-by-one).
  - Selecting dates in the wrong month/year.
  expected_interaction_path: Open dropdown → click Feb 10, 2026 → click Feb 14, 2026.
  notes: Mantine DatePickerInput supports type='range' for range selection.
- id: date_picker_range-mantine-T03
  name: Clear a preselected range with clear button
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput range + clearable
  implementation_component: 'Mantine: DatePickerInput (type=''range'', clearable=true)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the 'Availability' date range so it is empty. The task will
    finish automatically when done.
  ui_copy: 'Availability: Jan 23, 2026 – Jan 30, 2026'
  setup_description: Isolated card centered in the viewport with one Mantine DatePickerInput
    configured as a range picker (type='range') and labeled 'Availability'. The field
    is prefilled with a range (Jan 23, 2026 – Jan 30, 2026) and has clearable=true,
    which shows a small clear (×) button in the right section of the input when hovered/focused.
    Clicking the clear button resets both start and end to null.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: Clear button provides a direct reset action and the current value
      is visible.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Availability'.
    - The start date is empty (null).
    - The end date is empty (null).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_is_empty
      target_state:
        start_date: null
        end_date: null
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Availability
      terminal_condition: true
  negative_cases:
  - Only one side cleared (start or end still set).
  - Changing to a different non-empty range.
  - Clearing the wrong instance (not applicable here but must be guarded).
  expected_interaction_path: Hover/focus the input → click the clear (×) icon.
  notes: Mantine docs note clearable adds a clear button in the right section unless
    rightSection is overridden.
- id: date_picker_range-mantine-T04
  name: Use a presets list to set conference dates
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput range + presets
  implementation_component: 'Mantine: DatePickerInput (type=''range'', presets)'
  task_template: set_range
  secondary_template: null
  browsergym_goal: For 'Conference dates', choose the preset 'Conference (Mar 18–Mar
    22, 2026)'. The task will finish automatically when done.
  ui_copy: Conference dates — presets available
  setup_description: 'A form_section layout with light theme and comfortable spacing.
    The main control is a Mantine DatePickerInput labeled ''Conference dates'' configured
    with type=''range''. When opened, the calendar dropdown shows a presets list next
    to the calendar with clickable items:

    - ''Conference (Mar 18–Mar 22, 2026)''

    - ''Training week (Apr 6–Apr 10, 2026)''

    - ''Customer visits (May 4–May 8, 2026)''

    - ''Reset''

    Selecting a preset immediately fills the input with the preset range (no separate
    Apply/OK). Other form fields (Company name, Email) are present as low clutter.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: Requires finding and clicking the correct preset item; small risk
      of choosing a similar preset.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Conference dates'.
    - The selected start date equals 2026-03-18 (YYYY-MM-DD).
    - The selected end date equals 2026-03-22 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-03-18'
        end_date: '2026-03-22'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Conference dates
      terminal_condition: true
  negative_cases:
  - Selecting the wrong preset (e.g., Training week).
  - Manually selecting different dates that do not match the preset range.
  - Selecting Reset so the field is empty.
  expected_interaction_path: Open 'Conference dates' → click preset 'Conference (Mar
    18–Mar 22, 2026)'.
  notes: Mantine DatePickerInput supports presets; for range mode each preset value
    is a tuple of two dates.
- id: date_picker_range-mantine-T05
  name: Navigate a modal date picker to June 2026
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput range + dropdownType=modal
  implementation_component: 'Mantine: DatePickerInput (type=''range'', dropdownType=''modal'')'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: Open 'Vacation window' and navigate the calendar until June 2026
    is visible (no need to select dates). The task will finish automatically when
    done.
  ui_copy: Vacation window — opens in modal
  setup_description: Isolated card centered in the viewport with a Mantine DatePickerInput
    labeled 'Vacation window'. It is configured as a range picker (type='range') and
    uses dropdownType='modal', meaning the calendar opens in a full modal overlay
    instead of a small popover. The field is empty. When opened, the modal shows a
    month header with navigation controls (previous/next). The initial month is February
    2026. The goal is to navigate until the header shows June 2026; no dates need
    to be selected.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Adds a modal layer and requires recognizing month navigation state;
      no precision date selection required.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Vacation window'.
    - The date range picker overlay is open.
    - The calendar view shows 2026-06 (YYYY-MM) as any visible month.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: calendar_view_month_equals
      target_state:
        target_month: 2026-06
        match_mode: any_visible
      tolerance:
        months: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Vacation window
      terminal_condition: true
  negative_cases:
  - Modal not open (no visible month).
  - Stopping on May or July 2026 instead of June 2026.
  - Navigating the wrong component (not applicable here).
  expected_interaction_path: Open 'Vacation window' → click next-month until June
    2026 appears in the modal header.
  notes: 'Instrumentation: for dropdownType=''modal'', expose modal open state and
    calendar header month text.'
- id: date_picker_range-mantine-T06
  name: Select a single-day range
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: range + allowSingleDateInRange
  implementation_component: 'Mantine: DatePickerInput (type=''range'', allowSingleDateInRange=true)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set 'One-day outage' to April 8, 2026 (start and end should both
    be April 8, 2026). The task will finish automatically when done.
  ui_copy: One-day outage — single-day range allowed
  setup_description: Isolated card centered in the viewport with one Mantine DatePickerInput
    labeled 'One-day outage'. It is configured as a range picker (type='range') and
    allowSingleDateInRange=true, so a range of length 1 day is valid. The input starts
    empty. The calendar dropdown opens in a popover showing April 2026. To create
    a single-day range, the user selects April 8, 2026 as both start and end (e.g.,
    by selecting the same date twice or completing the range on the same day).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Single-day range is a non-default behavior and can be easy to accidentally
      deselect without the special prop.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'One-day outage'.
    - The selected start date equals 2026-04-08 (YYYY-MM-DD).
    - The selected end date equals 2026-04-08 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-04-08'
        end_date: '2026-04-08'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: One-day outage
      terminal_condition: true
  negative_cases:
  - Selecting April 8 as start but leaving end empty (partial).
  - Selecting a multi-day range (end not equal to start).
  - Selecting April 7 or April 9 by mistake (off-by-one).
  expected_interaction_path: Open dropdown → select Apr 8, 2026 as start → select
    Apr 8, 2026 again to set end the same day.
  notes: Checker should accept start=end as valid for this task (allowSingleDateInRange
    must be enabled in the page config).
- id: date_picker_range-mantine-T07
  name: Pick a workdays-only range in a compact inline calendar
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePicker inline range (excludeDate, 2 columns)
  implementation_component: 'Mantine: DatePicker (type=''range'', numberOfColumns=2,
    excludeDate=weekends)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Set the 'Workdays-only window' to January 12, 2026 through January
    16, 2026. The task will finish automatically when done.
  ui_copy: Workdays-only window (weekends disabled)
  setup_description: An isolated card centered in the viewport containing an inline
    Mantine DatePicker (not an input) configured with type='range'. The page uses
    compact spacing and the calendar is rendered in a small size. Two months are shown
    side-by-side (numberOfColumns=2). Weekends are disabled via excludeDate (Saturday/Sunday
    cells appear disabled and cannot be selected). There is a small readout text below
    the calendar showing the currently selected start and end dates in ISO form, for
    observability. The initial value is empty.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    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: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Small dense calendar targets plus disabled-date styling requires
      careful clicking on the correct enabled days.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Workdays-only window'.
    - The selected start date equals 2026-01-12 (YYYY-MM-DD).
    - The selected end date equals 2026-01-16 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-01-12'
        end_date: '2026-01-16'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Workdays-only window
      terminal_condition: true
  negative_cases:
  - Selecting a range that includes the wrong endpoints (e.g., Jan 13–Jan 16).
  - Trying to select a disabled weekend day (should not result in success).
  - Leaving selection partial (only start date).
  expected_interaction_path: Click Jan 12, 2026 → click Jan 16, 2026 on the inline
    calendar.
  notes: Checker reads the DatePicker value state; excludeDate weekends is only a
    distractor/constraint, not part of the predicate.
- id: date_picker_range-mantine-T08
  name: Set Secondary window with two similar inputs
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput type=range (multiple instances)
  implementation_component: 'Mantine: DatePickerInput (type=''range'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the settings panel, set the 'Secondary window' to August 3,
    2026 through August 11, 2026. The task will finish automatically when done.
  ui_copy: 'Windows: Primary window, Secondary window'
  setup_description: 'A settings_panel layout with a sidebar and a content form. In
    the content area there are two Mantine DatePickerInput components configured with
    type=''range'' (instances=2): ''Primary window'' (prefilled) and ''Secondary window''
    (empty — target). Both inputs have the same placeholder and calendar icon, making
    them visually similar. Additional clutter includes a ''Timezone'' select and a
    non-functional ''Save changes'' button. Selecting a range updates the input immediately
    (no Apply/OK).'
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 4
    justification: Requires selecting the correct instance among two similar range
      inputs within a cluttered settings panel.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Secondary window'.
    - The selected start date equals 2026-08-03 (YYYY-MM-DD).
    - The selected end date equals 2026-08-11 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-08-03'
        end_date: '2026-08-11'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary window
      terminal_condition: true
  negative_cases:
  - Setting the requested range in 'Primary window' instead of 'Secondary window'.
  - Partial selection (missing end date).
  - Off-by-one endpoints.
  expected_interaction_path: Open 'Secondary window' dropdown → click Aug 3 → click
    Aug 11 → verify value updates.
  notes: Checker must bind to the labeled field (e.g., aria-labelledby or data-testid)
    to enforce correct-instance.
- id: date_picker_range-mantine-T09
  name: Match a highlighted reference range (visual)
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput range + visual reference
  implementation_component: 'Mantine: DatePickerInput (type=''range'')'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the 'Selected window' date range to match the highlighted days
    shown in the 'Reference B' mini-calendar. The task will finish automatically when
    done.
  ui_copy: Reference B (highlighted) + Selected window
  setup_description: 'An isolated card centered in the viewport with two elements:

    1) A ''Reference B'' mini-calendar for March 2026 that highlights a contiguous
    date range using a colored background band. The reference card intentionally does
    not print the start/end as text; the only cue is the highlight on the mini-calendar.

    2) A Mantine DatePickerInput (type=''range'') labeled ''Selected window'', initially
    empty.

    The agent must visually read the highlighted start and end days from the reference
    mini-calendar and then select the same range in the DatePickerInput.'
  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: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Target is specified visually via highlight rather than explicit
      text, reducing semantic observability and increasing interpretation load.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Selected window'.
    - The selected range matches the reference card 'Reference B'.
    - In canonical form, the selected range equals 2026-03-07 to 2026-03-12 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: Reference B
        start_date: '2026-03-07'
        end_date: '2026-03-12'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Selected window
      terminal_condition: true
  negative_cases:
  - Choosing any range that does not match the highlighted reference exactly.
  - Partial selection (only start date).
  - Mistaking the highlight boundaries by one day.
  expected_interaction_path: Inspect Reference B highlight → open 'Selected window'
    → click Mar 7 → click Mar 12.
  notes: Checker must store reference canonical start/end (here 2026-03-07 to 2026-03-12)
    even though it is not written in the UI.
- id: date_picker_range-mantine-T10
  name: Set a table-cell renewal window across years
  canonical_type: date_picker_range
  implementation_source: mantine
  implementation_variant: DatePickerInput range in table_cell (dropdownType=modal)
  implementation_component: 'Mantine: DatePickerInput (type=''range'', dropdownType=''modal'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the Contracts table, set the 'Renewal window' for 'Acme Corp'
    to December 29, 2026 through January 3, 2027. The task will finish automatically
    when done.
  ui_copy: Contracts table — Renewal window
  setup_description: 'A table_cell layout with dark theme: a dense contracts table
    fills most of the viewport. Each of three rows has a Mantine DatePickerInput configured
    as a range picker (instances=3) in the ''Renewal window'' column. The rows are
    labeled ''Acme Corp'' (target), ''Beta LLC'', and ''Cyan Inc''. Because the picker
    is inside a scrollable table container, it uses dropdownType=''modal'' so the
    calendar opens in a full modal overlay. The target cell (''Acme Corp'' → ''Renewal
    window'') starts empty. The table also contains other interactive elements (checkboxes,
    a search box, pagination), making clutter high.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: table_cell
    placement: top_left
    scale: default
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 5
    justification: High clutter and multiple table-row instances plus a cross-year
      range and modal opening require careful instance targeting and navigation.
  success_trigger:
    human_readable:
    - The target date range picker instance is 'Acme Corp / Renewal window'.
    - The selected start date equals 2026-12-29 (YYYY-MM-DD).
    - The selected end date equals 2027-01-03 (YYYY-MM-DD).
    - No additional confirm/apply action is required.
    - Task ends when these conditions hold.
    canonical_predicate:
      predicate_type: range_equals
      target_state:
        start_date: '2026-12-29'
        end_date: '2027-01-03'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Acme Corp / Renewal window
      terminal_condition: true
  negative_cases:
  - Setting the correct dates in the wrong row (e.g., Beta LLC) or wrong column.
  - Partial selection (missing end date).
  - Off-by-one endpoints around the year boundary.
  expected_interaction_path: Find 'Acme Corp' row → click its 'Renewal window' input
    → in modal calendar select Dec 29, 2026 then Jan 3, 2027 → close modal.
  notes: Checker should identify the target instance by row key + column (e.g., data-testid='row-acme-renewal-range').