tasks/v1/listbox_single.yaml

- id: listbox_single-antd-T01
  name: 'Preferred channel: choose Email'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Preferred notification channel” list, select “Email”. The task will finish automatically when done.
  ui_copy: 'Preferred notification channel: SMS, Email, Push. Select Email.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Notification settings” contains a vertical AntD Menu styled as a standalone listbox (no submenus). The list
    has three items: “SMS”, “Email”, and “Push”. Exactly one item can be selected at a time; the selected item is highlighted.
    Initial selection is “SMS”. There are no other interactive controls on the card.'
  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: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Three clearly labeled options with immediate visual highlight; no overlay or confirmation.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: email'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: email
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “SMS” or “Push” instead of “Email”.
  - Changing a different component (none exist) without selecting an item in the listbox.
  - Partial state where no item is selected (should not occur in this configuration).
  expected_interaction_path: Click the “Email” item in the Menu listbox.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T02
  name: 'Language listbox: select English (US)'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Language” list, select “English (US)”. The task will finish automatically when done.
  ui_copy: 'Language: English (UK), English (US), Español, Français. Select English (US).'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Language” contains a vertical selectable AntD Menu acting as a listbox. Items appear with small leading icons
    (flag glyphs) and text labels: “English (UK)”, “English (US)”, “Español”, “Français”. Only one can be selected. Initial
    selection is “English (UK)”. No search box or extra buttons 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: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: A short visible list with distinctive labels; selection change applies immediately.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: en-US'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: en-US
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “English (UK)” or any non-target language.
  - Selecting based only on the icon without selecting the correct labeled item.
  - Leaving the selection unchanged at “English (UK)”.
  expected_interaction_path: Click “English (US)” in the listbox.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T03
  name: 'Sidebar navigation: go to Billing'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline) used as sidebar nav'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: In the sidebar, select “Billing”. The task will finish automatically when done.
  ui_copy: 'Sidebar: Overview, Projects, Billing, Team. Select Billing.'
  setup_description: 'Scene: light theme, comfortable spacing, dashboard layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A dashboard layout
    shows a left sidebar (about 240px wide) containing an AntD Menu in inline mode with four items: “Overview”, “Projects”,
    “Billing”, “Team”. The main content area shows read-only placeholder cards (recent invoices, usage chart) that update
    when a sidebar item is selected, but no other controls are needed. Initial sidebar selection is “Overview”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    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: 2
    justification: Still a short list, but placed in a busier dashboard with more visual clutter and a smaller click target
      in the sidebar.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: billing'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: billing
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a non-target sidebar item (Overview/Projects/Team).
  - Clicking content cards in the main panel without changing the sidebar selection.
  - Selecting “Billing” in any non-target menu (there is only one listbox).
  expected_interaction_path: Click “Billing” in the left sidebar menu.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T04
  name: 'Active project: clear selection'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the current selection in the “Active project” list so that no project is selected. The task will
    finish automatically when done.
  ui_copy: 'Active project list (currently: Apollo). Button: Clear selection.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered isolated
    card titled “Active project” contains a standalone AntD Menu listbox with five items: “Apollo”, “Beacon”, “Cascade”, “Drift”,
    “Eon”. Exactly one item can be selected, but the card also provides a small text button labeled “Clear selection” above
    the list. Initial selection is “Apollo”. When cleared, no item remains highlighted and a small caption under the list
    reads “No active project selected”. The Clear button is the only extra control; it does not affect any other component
    state.'
  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: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Clearing requires using a small auxiliary control but the resulting state is clearly indicated as “No active
      project selected”.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: null (no selection)'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different project instead of clearing to no selection.
  - Clicking “Clear selection” but the listbox still has an item highlighted.
  - Clearing a different listbox (none exist).
  expected_interaction_path: Click “Clear selection” above the listbox; verify nothing is highlighted.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T05
  name: 'Two categories: set Secondary to Hardware'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Secondary category” list, select “Hardware”. The task will finish automatically when done.
  ui_copy: Primary category list and Secondary category list. Select Hardware in Secondary category.
  setup_description: 'Scene: light theme, comfortable spacing, form_section layout, placed at center of the viewport. Component
    scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is low. A form_section layout
    shows two side-by-side cards. Left card: “Primary category” listbox (AntD Menu) with items “Software”, “Hardware”, “Services”,
    initial selection “Software”. Right card: “Secondary category” listbox (same component) with the same items, initial selection
    “Services”. Each listbox has its own label above it. No other controls are required. The task targets the right-hand list
    labeled “Secondary category”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two identical lists require correctly disambiguating by label before selecting the option.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Secondary category'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: hardware'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: hardware
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary category
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Hardware” in the “Primary category” list (wrong instance).
  - Selecting any non-target option in the Secondary category list.
  - Leaving the Secondary category unchanged at “Services”.
  expected_interaction_path: Locate the right listbox labeled “Secondary category” → click “Hardware”.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T06
  name: Match the reference icon in Quick actions
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the “Quick actions” list, select the item that matches the reference icon shown above the list. The
    task will finish automatically when done.
  ui_copy: 'Reference icon: 🧾. Quick actions: Upload, Invoice, Export, Archive (each with an icon).'
  setup_description: 'Scene: dark theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is visual; clutter is none. A centered isolated
    card in dark theme titled “Quick actions” shows a small reference chip above a vertical AntD Menu listbox. The chip displays
    only an icon (no text): 🧾. The listbox contains four items, each with a leading icon and text: “Upload” (⬆️), “Invoice”
    (🧾), “Export” (📤), “Archive” (🗄️). Only one can be selected. Initial selection is “Upload”. The goal is specified visually
    via the reference icon chip.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Target is specified visually and the theme is dark, but icons are distinct and the list is short.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: invoice'
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        match_rule:
          reference_element: reference_chip
          match_field: leading_icon
          reference_value: 🧾
        expected_selected_option:
          value: invoice
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting an item whose text matches but icon does not (not applicable here, but still must be the icon match).
  - Selecting any non-target action.
  - Leaving selection on “Upload”.
  expected_interaction_path: Visually match 🧾 → click “Invoice” in the listbox.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T07
  name: 'Report frequency: set Weekly and save'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Set “Report frequency” to “Weekly” and click “Save changes”. The task will finish automatically when done.
  ui_copy: 'Report frequency list (Daily, Weekly, Monthly). Buttons: Save changes, Cancel.'
  setup_description: 'Scene: light theme, comfortable spacing, settings_panel layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is medium. A settings_panel
    layout shows several read-only toggles and inputs as distractors (timezone text, a disabled switch, and a help link).
    In the middle, a labeled card “Report frequency” contains a selectable AntD Menu listbox with items “Daily”, “Weekly”,
    “Monthly”. Initial selection is “Monthly”, but changes are not committed until the user clicks the primary button “Save
    changes” at the bottom of the panel. A secondary “Cancel” button reverts to the last saved value. After saving, a small
    toast “Saved” appears.'
  scene_context:
    theme: light
    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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires understanding a two-phase commit (select then Save) amidst moderate settings clutter.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: weekly'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: weekly
      tolerance: null
      require_confirm: true
      confirm_control: Save changes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Weekly” but not clicking “Save changes”.
  - Clicking “Cancel” after selecting “Weekly” (reverts; should not count).
  - Saving with “Daily” or “Monthly” selected.
  expected_interaction_path: Click “Weekly” in the listbox → click “Save changes”.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T08
  name: 'Time zone list: scroll to Pacific/Honolulu'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Menu (selectable, mode=inline, single-select)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the “Time zone” list, select “Pacific/Honolulu”. The task will finish automatically when done.
  ui_copy: Time zone list (scrollable). Select Pacific/Honolulu.
  setup_description: 'Scene: light theme, compact spacing, isolated_card layout, placed at center of the viewport. Component
    scale is small. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Time zone” contains a scrollable AntD Menu listbox constrained to about 220px height in compact spacing and
    small scale. The list contains ~50 IANA time zones sorted alphabetically (e.g., “America/New_York”, “Europe/London”, …,
    “Pacific/Honolulu”, “Pacific/Tahiti”). Only one can be selected. Initial selection is “America/New_York”. The target item
    is not visible initially and requires scrolling within the listbox (not the page).'
  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: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Dense, scrollable list in compact/small mode increases option confusability and makes within-list scrolling
      necessary.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: Pacific/Honolulu'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: Pacific/Honolulu
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a nearby time zone (e.g., Pacific/Tahiti) instead of Pacific/Honolulu.
  - Scrolling the page without scrolling the listbox, leaving selection unchanged.
  - Selecting the correct item in the wrong instance (only one listbox here).
  expected_interaction_path: Scroll inside the listbox until “Pacific/Honolulu” is visible → click it.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T09
  name: 'Change role: open dialog, choose Editor, apply'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Modal + Menu (selectable) inside modal'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Change role”, select “Editor” in the role list, then click “Apply”. The task will finish automatically
    when done.
  ui_copy: 'Button: Change role. Dialog: Role list (Viewer, Editor, Admin). Buttons: Apply, Cancel.'
  setup_description: 'Scene: light theme, comfortable spacing, modal_flow layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered card
    titled “Team member” shows a summary row and a primary button “Change role”. Clicking it opens an AntD Modal dialog containing
    a standalone selectable Menu listbox labeled “Role” with items “Viewer”, “Editor”, “Admin”. Initial selection in the modal
    is “Viewer”. Selection changes are only committed to the page after clicking the modal primary button “Apply”; “Cancel”
    closes the modal without saving. On successful apply, the modal closes and a small inline label under the button updates
    to the saved role.'
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires opening a modal overlay, making a selection inside it, and confirming with an Apply action.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: editor'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: editor
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Editor” but closing the modal without clicking “Apply”.
  - Clicking “Apply” with a different role selected.
  - Changing a role label outside the modal (none exist).
  expected_interaction_path: Click “Change role” → in modal click “Editor” → click “Apply”.
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-antd-T10
  name: 'Invoices table: set status for Invoice #1024'
  canonical_type: listbox_single
  implementation_source: antd
  implementation_variant: menu_inline
  implementation_component: 'AntD: Table cell with inline Menu listbox per row (single-select)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: 'In the invoices table, for “Invoice #1024”, set the “Status” list to “Overdue”. The task will finish automatically
    when done.'
  ui_copy: 'Invoices table with rows (#1024 and #1025) and a Status list in each row. Set #1024 to Overdue.'
  setup_description: 'Scene: light theme, comfortable spacing, table_cell layout, placed at bottom_right of the viewport.
    Component scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is none. A table_cell
    layout anchors a compact AntD Table near the bottom-right of the viewport. The table has two rows: “Invoice #1024” and
    “Invoice #1025”. In the “Status” column, each row contains a small inline selectable AntD Menu listbox with three options:
    “Paid”, “Pending”, “Overdue”. Each row’s listbox has its own selection highlight. Initial selections: #1024 = “Pending”,
    #1025 = “Paid”. There are no other controls (no pagination, no toolbar), so the primary challenge is selecting the correct
    listbox instance in the correct row.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: bottom_right
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 5
    justification: Two small, similar listboxes embedded in table rows require precise clicking and careful row-level disambiguation.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Row: Invoice #1024 / Column: Status'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: overdue'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: overdue
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Invoice #1024 / Column: Status'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - 'Setting “Overdue” in the Status listbox for Invoice #1025 (wrong instance).'
  - 'Selecting “Paid” or “Pending” for Invoice #1024.'
  - 'Clicking elsewhere in the table without changing the #1024 Status selection.'
  expected_interaction_path: 'Find row “Invoice #1024” → in its Status listbox click “Overdue”.'
  notes: 'Instrumentation: add data-cb-listbox-root to the Menu root and data-cb-option-value to each Menu.Item key/value;
    expose the committed vs staged selection state when require_confirm=true (e.g., data-cb-committed-value).'
- id: listbox_single-mui-T01
  name: 'Coffee roast: choose Dark roast'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Coffee roast” list, select “Dark roast”. The task will finish automatically when done.
  ui_copy: 'Coffee roast: Light, Medium, Dark. Select Dark roast.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Coffee roast” contains a Material UI List rendered as a vertical listbox. Each option is a ListItemButton
    with a single-line label: “Light roast”, “Medium roast”, “Dark roast”. Exactly one option can be selected; the selected
    item uses the MUI selected state styling. Initial selection is “Medium roast”. No other controls 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: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Short visible list with immediate selected highlighting and no distractors.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: dark'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: dark
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Light roast” or “Medium roast” instead of “Dark roast”.
  - Leaving the selection unchanged at “Medium roast”.
  - Interacting with the card header without selecting an item.
  expected_interaction_path: Click the “Dark roast” list item.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T02
  name: 'Quick filter nav: select Today'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List used as left navigation (ListItemButton selected)'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: In the quick filter list, select “Today”. The task will finish automatically when done.
  ui_copy: 'Quick filters: All, Today, This week, This month. Select Today.'
  setup_description: 'Scene: light theme, comfortable spacing, dashboard layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A dashboard layout
    shows a compact left column titled “Quick filters” containing a MUI List with four ListItemButton options: “All”, “Today”,
    “This week”, “This month”. The main area shows a read-only table preview that changes when a filter is selected, but no
    interaction with it is required. Initial filter is “All”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    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: 2
    justification: List is simple but placed in a busier layout with competing content.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: today'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: today
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “This week” or “This month” instead of “Today”.
  - Clicking rows in the preview table without changing the filter selection.
  - Leaving the selection on “All”.
  expected_interaction_path: Click “Today” in the quick filter list.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T03
  name: 'Shipping method: clear selection'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the “Shipping method” list so that no method is selected. The task will finish automatically
    when done.
  ui_copy: 'Shipping method (currently: Express). Button: Clear.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered isolated
    card titled “Shipping method” contains a MUI List styled as a single-select listbox with four options: “Standard”, “Express”,
    “Overnight”, “Pickup”. The “Express” item is initially selected. Above the list is a small MUI Button labeled “Clear”
    that resets the listbox to an empty selection; when cleared, no item is highlighted and a caption below the list reads
    “No shipping method selected”. No other components affect task completion.'
  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: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires using a dedicated clear control and confirming the empty selection state, which is explicitly
      shown.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: null (no selection)'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different shipping method instead of clearing to no selection.
  - Clicking “Clear” but an item remains highlighted (selection not cleared).
  - Clearing a non-existent second listbox (only one is present).
  expected_interaction_path: Click the “Clear” button above the list; ensure no item remains selected.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T04
  name: 'Payment methods: set Primary to Card'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Primary payment method” list, select “Card”. The task will finish automatically when done.
  ui_copy: Primary payment method and Backup payment method lists. Select Card in Primary.
  setup_description: 'Scene: light theme, comfortable spacing, form_section layout, placed at center of the viewport. Component
    scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is low. A form_section layout
    shows two stacked cards. The first card is labeled “Primary payment method” and contains a single-select MUI List with
    options “Card”, “Bank transfer”, “PayPal”, initial selection “PayPal”. The second card is labeled “Backup payment method”
    with the same options, initial selection “Card”. Each list uses ListItemButton selected styling. The task target is the
    first list labeled “Primary payment method”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two similar listboxes increase disambiguation load; otherwise selection is straightforward.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Primary payment method'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: card'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: card
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Primary payment method
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Card” in the Backup payment method list (wrong instance).
  - Selecting any non-target option in the Primary list.
  - Leaving Primary selection unchanged at “PayPal”.
  expected_interaction_path: Find the “Primary payment method” list → click “Card”.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T05
  name: Pick the item with the star badge
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Select the list item that matches the reference badge shown above the list. The task will finish automatically
    when done.
  ui_copy: 'Reference badge: ⭐. List: Starter, Pro, Team, Enterprise (each shows a badge icon).'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is visual; clutter is low. A centered isolated
    card titled “Plan” shows a small reference badge above a MUI List: a single star icon ⭐. The listbox contains four ListItemButton
    options, each with a leading badge icon and label: “Starter” (🟦), “Pro” (⭐), “Team” (👥), “Enterprise” (🏢). Only one can
    be selected. Initial selection is “Starter”. The goal is conveyed only by the badge icon reference.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires matching a visual cue to the correct row; labels are clear once the right row is identified.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: pro'
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        match_rule:
          reference_element: reference_badge
          match_field: leading_icon
          reference_value: ⭐
        expected_selected_option:
          value: pro
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a plan whose label is “Pro” but the badge does not match (checker uses canonical option value, not just the
    label).
  - Selecting any non-star plan.
  - Leaving “Starter” selected.
  expected_interaction_path: Identify the row with ⭐ → click that list item.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T06
  name: 'Choose template from drawer: Meeting notes'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Drawer + List (ListItemButton selected) inside drawer'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Choose template”, then select “Meeting notes” from the template list. The task will finish automatically
    when done.
  ui_copy: 'Button: Choose template. Drawer: Templates list. Select Meeting notes.'
  setup_description: 'Scene: light theme, comfortable spacing, drawer_flow layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered card
    titled “New document” includes a button labeled “Choose template”. Clicking it opens a right-side MUI Drawer containing
    a single-select MUI List labeled “Templates” with options: “Blank”, “Meeting notes”, “Project brief”, “Retrospective”.
    Initial selection in the drawer is “Blank”. Selection applies immediately (no Save button) and the drawer stays open.
    A close icon exists but is not required. The main page behind the drawer contains read-only preview text.'
  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: 1
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires opening a drawer overlay and selecting within it; selection has immediate effect but overlay layering
      adds complexity.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: meeting_notes'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: meeting_notes
      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:
  - Not opening the drawer and attempting to click behind it.
  - Selecting a different template (Blank/Project brief/Retrospective).
  - Opening the drawer but leaving “Blank” selected.
  expected_interaction_path: Click “Choose template” → in drawer click “Meeting notes”.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T07
  name: 'Priority: set High and apply'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Set “Priority” to “High” and click “Apply”. The task will finish automatically when done.
  ui_copy: 'Priority list: Low, Medium, High. Buttons: Apply, Reset.'
  setup_description: 'Scene: light theme, comfortable spacing, settings_panel layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is medium. A settings_panel
    layout contains several distracting controls (a disabled text field, a help accordion link, and a non-functional toggle).
    The “Priority” section contains a MUI List listbox with three options: “Low”, “Medium”, “High”. Initial selection is “Medium”.
    Changes are staged until the user clicks the primary button “Apply” below the list. There is also a “Reset” button that
    restores the last applied selection. After Apply, a Snackbar toast appears briefly reading “Changes applied”. The task
    only succeeds when the applied (committed) priority equals “High”.'
  scene_context:
    theme: light
    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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Two-phase commit (Apply) with additional distractor controls and transient toast feedback.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: high'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: high
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “High” but not clicking “Apply”.
  - Clicking “Reset” after selecting “High” (reverts to Medium).
  - Applying with “Low” or “Medium” selected.
  expected_interaction_path: Click “High” in list → click “Apply”.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T08
  name: 'Animal list: scroll to Zebra'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the “Favorite animal” list, select “Zebra”. The task will finish automatically when done.
  ui_copy: Favorite animal list (scrollable A–Z). Select Zebra.
  setup_description: 'Scene: light theme, compact spacing, isolated_card layout, placed at center of the viewport. Component
    scale is small. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Favorite animal” contains a scrollable MUI List constrained to ~200px height, rendered in compact spacing
    and small scale. It includes ~26–35 alphabetically sorted animals (Aardvark, Bear, Cat, …, Yak, Zebra). Only one item
    can be selected. Initial selection is “Cat”. The target “Zebra” is near the bottom and requires scrolling inside the list
    container. The page itself does not need scrolling.'
  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: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Long dense list in a small scroll area demands within-component scrolling and careful selection among many
      similar rows.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: zebra'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: zebra
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Yak” or any near-bottom neighbor instead of “Zebra”.
  - Scrolling the page instead of the list container, leaving Zebra unreachable.
  - Leaving the selection unchanged at “Cat”.
  expected_interaction_path: Scroll inside the list until Zebra appears → click “Zebra”.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T09
  name: 'Dark mode: set Region to North America (two lists)'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: List + ListItemButton (selected)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Region” list, select “North America”. The task will finish automatically when done.
  ui_copy: 'Two lists: Region and Segment. Select North America in Region.'
  setup_description: 'Scene: dark theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card in dark theme contains two vertically stacked single-select MUI List listboxes. The first is labeled “Region” with
    four options: “North America”, “Europe”, “Asia-Pacific”, “Latin America” (initial selection: “Europe”). The second is
    labeled “Segment” with options “SMB”, “Mid-market”, “Enterprise” (initial selection: “SMB”). Each option is a ListItemButton
    that shows selected styling when active. There are no other controls or panels. The task targets the listbox labeled “Region”.'
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two stacked listboxes in dark theme require disambiguation by label; selection is immediate but errors
      are easy to make when targets look similar.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Region'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: north_america'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: north_america
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Region
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “North America” in the “Segment” listbox (wrong instance).
  - Selecting a different region such as Europe or Asia-Pacific in the Region list.
  - Leaving Region unchanged at “Europe”.
  expected_interaction_path: Locate the list labeled “Region” → click “North America”.
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mui-T10
  name: 'Orders table: set status for Order #A-17 to Refunded'
  canonical_type: listbox_single
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Table with per-row List listbox in Status column'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: 'In the orders table, for “Order #A-17”, set the “Status” list to “Refunded”. The task will finish automatically
    when done.'
  ui_copy: Orders table with rows A-17 and A-18. Each row has a Status list. Set A-17 to Refunded.
  setup_description: 'Scene: light theme, comfortable spacing, table_cell layout, placed at top_right of the viewport. Component
    scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is none. A table_cell scene
    anchors a compact table near the top-right of the viewport. The table has two rows: “Order #A-17” and “Order #A-18”. In
    the “Status” column of each row is a compact single-select MUI List listbox with four options: “Processing”, “Shipped”,
    “Delivered”, “Refunded”. Each row has its own selected highlight. Initial selections: A-17 = “Delivered”; A-18 = “Shipped”.
    There is no toolbar or pagination; the core difficulty is selecting the correct row’s listbox and choosing the correct
    status.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: top_right
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 5
    justification: Small, repeated listboxes inside table cells require careful row disambiguation and precise click targeting.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Row: Order #A-17 / Column: Status'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: refunded'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: refunded
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Order #A-17 / Column: Status'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - 'Setting “Refunded” for Order #A-18 (wrong instance).'
  - 'Selecting any non-refunded status for Order #A-17.'
  - Clicking the row without changing the selected option.
  expected_interaction_path: 'Locate row “Order #A-17” → click “Refunded” in its Status listbox.'
  notes: 'Instrumentation: add data-cb-listbox-root to the List element and data-cb-option-value to each ListItemButton; if
    a staged Apply step exists, expose committed selection separately from current highlight.'
- id: listbox_single-mantine-T01
  name: 'Workspace theme: choose Ocean'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): Stack of NavLink items with active state (single-select listbox)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Workspace theme” list, select “Ocean”. The task will finish automatically when done.
  ui_copy: 'Workspace theme: Sand, Forest, Ocean, Mono. Select Ocean.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered isolated
    card titled “Workspace theme” contains a vertical listbox built from Mantine NavLink components inside a Stack. Each row
    is a NavLink with only a label: “Sand”, “Forest”, “Ocean”, “Mono”. Exactly one row is active at a time; the active row
    is visually highlighted using NavLink’s active styling. Initial active selection is “Sand”. No other interactive controls
    appear 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: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Short list with clear text labels and immediate active highlight.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: ocean'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: ocean
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Sand”, “Forest”, or “Mono” instead of “Ocean”.
  - Leaving the selection unchanged at “Sand”.
  - Activating a non-list element (none exist).
  expected_interaction_path: Click “Ocean” NavLink row.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T02
  name: 'Settings navigation: go to Security'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): NavLink list used as sidebar nav'
  task_template: navigate_to
  secondary_template: null
  browsergym_goal: In the settings sidebar, select “Security”. The task will finish automatically when done.
  ui_copy: 'Sidebar: Profile, Notifications, Security, Integrations. Select Security.'
  setup_description: 'Scene: light theme, comfortable spacing, dashboard layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A dashboard layout
    shows a left sidebar card labeled “Settings” containing a listbox built from Mantine NavLink items: “Profile”, “Notifications”,
    “Security”, “Integrations”. The active item is highlighted. The main panel shows read-only placeholder content that changes
    based on the active sidebar item but is not required for success. Initial active item is “Profile”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    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: 2
    justification: Simple list selection but placed in a busier dashboard layout.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: security'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: security
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Profile”, “Notifications”, or “Integrations” instead of “Security”.
  - Clicking within the main panel without changing the active sidebar item.
  - Leaving “Profile” active.
  expected_interaction_path: Click “Security” in the sidebar list.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T03
  name: 'Default view: reset to none'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): Stack of NavLink items with active state (single-select listbox)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the “Default view” list so that no view is selected. The task will finish automatically when done.
  ui_copy: 'Default view (currently: Kanban). Button: Reset to none.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered isolated
    card titled “Default view” contains a composite listbox made from Mantine NavLink rows: “List”, “Board”, “Calendar”, “Kanban”.
    The “Kanban” row is initially active. Above the list is a subtle Mantine Button labeled “Reset to none” that clears the
    active selection; when cleared, no NavLink row is highlighted and a caption appears: “No default view selected”. No other
    inputs are present.'
  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: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Uses an explicit reset control and provides clear textual feedback for the empty-selection state.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: null (no selection)'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting another view instead of clearing to no selection.
  - Clicking “Reset to none” but a view remains highlighted.
  - Clearing the wrong component (only one listbox exists).
  expected_interaction_path: Click “Reset to none” → verify no row is highlighted.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T04
  name: 'Devices: set Backup to Tablet'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): Stack of NavLink items with active state (single-select listbox)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Backup device” list, select “Tablet”. The task will finish automatically when done.
  ui_copy: Primary device list and Backup device list. Select Tablet in Backup device.
  setup_description: 'Scene: light theme, comfortable spacing, form_section layout, placed at center of the viewport. Component
    scale is default. Page contains 2 instance(s) of this listbox type; guidance is text; clutter is low. A form_section layout
    shows two cards stacked vertically. The top card is labeled “Primary device” and contains a NavLink-based single-select
    list with options “Laptop”, “Desktop”, “Tablet”, “Phone”; initial active is “Laptop”. The second card is labeled “Backup
    device” with the same options; initial active is “Phone”. Both lists look identical and are close together. The task target
    is the second list labeled “Backup device”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two visually similar listboxes require choosing the correct instance by its label.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Backup device'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: tablet'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: tablet
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Backup device
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Tablet” in the Primary device list (wrong instance).
  - Selecting a non-target option in the Backup device list.
  - Leaving Backup device unchanged at “Phone”.
  expected_interaction_path: Locate the “Backup device” card → click “Tablet”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T05
  name: 'Match the colored dot: choose Violet'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): NavLink rows with leading color dots and active state'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Select the list item that matches the reference color dot shown above the list. The task will finish automatically
    when done.
  ui_copy: 'Reference dot: 🟣. List: Red, Green, Blue, Violet (each with a color dot).'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is visual; clutter is none. A centered isolated
    card titled “Accent color” shows a small reference swatch above the list: a violet dot 🟣. Below it is a NavLink-based
    listbox with four rows; each row shows a leading color dot and label: “Red” (🔴), “Green” (🟢), “Blue” (🔵), “Violet” (🟣).
    Only one row is active. Initial active row is “Blue”. The goal is specified visually by the reference dot.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Visual matching is required but the list is short and the dot colors are distinct.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: violet'
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        match_rule:
          reference_element: reference_swatch
          match_field: leading_icon
          reference_value: 🟣
        expected_selected_option:
          value: violet
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Blue” (initial) or any non-violet color.
  - Selecting based on label guess without matching the reference swatch.
  - Leaving the active row unchanged.
  expected_interaction_path: Match 🟣 → click “Violet”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T06
  name: 'Billing cycle: set Monthly and save'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): Stack of NavLink items with active state (single-select listbox)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Set “Billing cycle” to “Monthly” and click “Save”. The task will finish automatically when done.
  ui_copy: 'Billing cycle list: Weekly, Monthly, Yearly. Buttons: Save, Cancel.'
  setup_description: 'Scene: light theme, comfortable spacing, settings_panel layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is medium. A settings_panel
    layout includes several distractors (a read-only text summary, a help link, and a non-interactive progress bar). The “Billing
    cycle” section contains a NavLink-based listbox with options “Weekly”, “Monthly”, “Yearly”; initial active is “Yearly”.
    Changes are staged until the user clicks the primary button “Save” below the list; a secondary “Cancel” button reverts
    to the last saved value. After saving, a small inline message appears: “Saved”.'
  scene_context:
    theme: light
    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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires a staged selection plus explicit Save action within a moderately cluttered panel.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: monthly'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: monthly
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Monthly” but not clicking “Save”.
  - Clicking “Cancel” after changing selection (reverts).
  - Saving with “Weekly” or “Yearly” selected.
  expected_interaction_path: Click “Monthly” → click “Save”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T07
  name: 'Pick a label in modal: Legal'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Modal + composite NavLink listbox inside modal'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Pick a label”, select “Legal” in the label list, then click “Done”. The task will finish automatically
    when done.
  ui_copy: 'Button: Pick a label. Modal: Label list (Finance, Legal, Marketing, Sales). Button: Done.'
  setup_description: 'Scene: light theme, comfortable spacing, modal_flow layout, placed at center of the viewport. Component
    scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is low. A centered card
    titled “Document labels” includes a button labeled “Pick a label”. Clicking it opens a Mantine Modal. Inside the modal
    is a scroll-free NavLink-based listbox labeled “Labels” with four options: “Finance”, “Legal”, “Marketing”, “Sales”. Initial
    selection is “Finance”. The selection is not committed until the user clicks the modal primary button “Done”; “Cancel”
    closes without saving. On success, the modal closes and the selected label is shown as a chip on the base page.'
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: Modal layering plus required confirmation (Done) increases depth and feedback complexity.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: legal'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: legal
      tolerance: null
      require_confirm: true
      confirm_control: Done
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Legal” but closing the modal without clicking “Done”.
  - Clicking “Done” with another label selected.
  - Selecting “Legal” in any background list (none exist).
  expected_interaction_path: Click “Pick a label” → in modal click “Legal” → click “Done”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T08
  name: 'City list: scroll to São Paulo'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): ScrollArea + grouped NavLink rows (active state)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the “City” list, select “São Paulo”. The task will finish automatically when done.
  ui_copy: City list (scrollable, grouped by region). Select São Paulo.
  setup_description: 'Scene: light theme, compact spacing, isolated_card layout, placed at center of the viewport. Component
    scale is small. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A centered card titled
    “City” contains a scrollable listbox built from Mantine NavLink rows inside a ScrollArea (height ~220px) in compact spacing
    and small scale. Options are grouped with visual headings (not selectable) such as “North America”, “Europe”, “South America”.
    Within “South America”, items include “Bogotá”, “Buenos Aires”, “Lima”, “São Paulo”. Some unrelated items elsewhere are
    disabled (grayed out) to resemble real availability. Initial active selection is “Lima”. The target “São Paulo” is not
    visible initially and requires scrolling within the ScrollArea.'
  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: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Dense grouped options in a small scroll area require careful scrolling and correct targeting among similar
      city names.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: sao_paulo'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: sao_paulo
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a nearby city (e.g., Buenos Aires or Bogotá) instead of São Paulo.
  - Clicking the group heading (not selectable) and assuming it counts as selection.
  - Scrolling the page instead of the list ScrollArea, leaving the target unreachable.
  expected_interaction_path: Scroll inside the list until “São Paulo” is visible → click it.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T09
  name: 'Visibility: set Private and save (dark, bottom-left)'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): Stack of NavLink items with active state (single-select listbox)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Set “Visibility” to “Private” and click “Save changes”. The task will finish automatically when done.
  ui_copy: 'Visibility list: Public, Team-only, Private. Button: Save changes.'
  setup_description: 'Scene: dark theme, comfortable spacing, isolated_card layout, placed at bottom_left of the viewport.
    Component scale is default. Page contains 1 instance(s) of this listbox type; guidance is text; clutter is none. A single
    isolated card is anchored near the bottom-left of the viewport and rendered in dark theme. The card title is “Visibility”.
    Inside is a NavLink-based single-select listbox with three options: “Public”, “Team-only”, “Private”. Initial active option
    is “Team-only”. Below the list is a primary button labeled “Save changes”. Selection changes are staged; the new visibility
    is only committed after clicking “Save changes”. After saving, a small “Saved” toast appears briefly.'
  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: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: Non-center placement in dark theme increases miss-click risk, and success requires an explicit save/commit
      action.
  success_trigger:
    human_readable:
    - 'Target listbox instance: the only listbox on the page'
    - Selection is committed only after clicking the confirm control.
    - 'Selected option value equals: private'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: private
      tolerance: null
      require_confirm: true
      confirm_control: Save changes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Private” but not clicking “Save changes”.
  - Saving while “Public” or “Team-only” is active.
  - Clicking outside the card (no effect) and assuming the change was saved.
  expected_interaction_path: Click “Private” → click “Save changes”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'
- id: listbox_single-mantine-T10
  name: 'Three filters: set Notifications to Mentions only'
  canonical_type: listbox_single
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine (composite): three filter listboxes built from NavLink rows'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the “Notifications” list, select “Mentions only”. The task will finish automatically when done.
  ui_copy: 'Filters: Notifications, Digest, Channel. Select Mentions only in Notifications.'
  setup_description: 'Scene: light theme, comfortable spacing, isolated_card layout, placed at center of the viewport. Component
    scale is default. Page contains 3 instance(s) of this listbox type; guidance is mixed; clutter is none. A centered isolated
    card titled “Notification filters” contains three compact NavLink-based listboxes stacked vertically, each with a label
    above it. (1) “Notifications” options: “All activity”, “Mentions only”, “None” (initial: “All activity”). (2) “Digest”
    options: “Off”, “Daily”, “Weekly” (initial: “Weekly”). (3) “Channel” options: “Email”, “Push”, “SMS” (initial: “Email”).
    Above the first list, a helper line reads: “Choose the option that limits alerts to mentions.” This provides mixed guidance
    (text hint + the visible option label). The task targets the listbox labeled “Notifications”.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 5
    justification: Three similar stacked listboxes require careful instance disambiguation; the target option is easy to misapply
      to the wrong list.
  success_trigger:
    human_readable:
    - 'Target listbox instance: Notifications'
    - Selection is considered set immediately (no confirm required).
    - 'Selected option value equals: mentions_only'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option:
          value: mentions_only
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Notifications
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting “Mentions only” in the Digest or Channel listbox (wrong instance).
  - Selecting “None” or leaving “All activity” active in Notifications.
  - Changing any other listbox while Notifications remains unchanged.
  expected_interaction_path: Locate “Notifications” → click “Mentions only”.
  notes: 'This is a Mantine composite implementation (NavLink list used as a listbox). Instrumentation: wrap the NavLink stack
    with role=''listbox'' and each row with role=''option'' + aria-selected; also add data-cb-option-value on each option
    for reliable checking, and expose committed value when require_confirm=true.'