- id: checkbox_tristate-antd-T01
  name: Enable email alerts (Checked)
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Email alerts” checkbox to Checked. The task will finish automatically when done.
  ui_copy: Set the “Email alerts” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: a single centered card on a blank page.

    Inside the card is one Ant Design tri-state checkbox labeled **“Email alerts”**. The checkbox supports three states (Unchecked → Partially selected → Checked) and shows the standard Ant Design visuals:
    - Checked: checkmark
    - Partially selected: horizontal dash (indeterminate)
    - Unchecked: empty box

    Initial state: **Unchecked**.

    Below the checkbox, a small read-only line shows **“Current state: Unchecked / Partial / Checked”** and updates immediately when the checkbox changes (this is only feedback; the checkbox state is what is evaluated). There are no other required controls and no other checkboxes 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: 1
      disambiguation_load: 1
    justification: Single, large default checkbox in an isolated card with immediate visual and textual feedback.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Checkbox left in the Unchecked state.
  - Checkbox left in the Partially selected (indeterminate) state.
  - Any interaction that does not result in the checkbox being Checked.
  expected_interaction_path:
  - Click the “Email alerts” checkbox once or cycle until it shows the checkmark (Checked).
  notes: Checker should read the checkbox’s tri-state via input.indeterminate / aria-checked (mixed) and checked state; use
    a stable locator such as data-testid='email-alerts-checkbox'.
- id: checkbox_tristate-antd-T02
  name: Turn off beta access (Unchecked)
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Beta access” checkbox so it ends in the Unchecked state. The task will finish automatically
    when done.
  ui_copy: Clear the “Beta access” checkbox so it ends in the Unchecked state. The task will finish automatically when done.
  setup_description: |
    Layout: a single centered card on a blank page.

    Inside the card is one Ant Design tri-state checkbox labeled **“Beta access”**. The component is the same AntD Checkbox with indeterminate support and cycles through Unchecked → Partial → Checked when clicked.

    Initial state: **Checked** (checkmark is visible).

    A subtle helper caption under the label reads “This setting can be On, Off, or Partial.” No other controls are required for success; a “Reset all” link is shown at the bottom of the card as a non-required distractor.
  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: The task is a simple reset/clear action on a single checkbox; the only challenge is recognizing the Unchecked
      end state.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Checkbox left in the Checked state.
  - Checkbox left in the Partially selected (indeterminate) state.
  - Clicking the non-required “Reset all” link without leaving the checkbox Unchecked.
  expected_interaction_path:
  - Click the “Beta access” checkbox until it becomes Unchecked (empty box).
  notes: If the harness cycles tri-state, ensure one click does not skip Unchecked. Use data-testid='beta-access-checkbox'
    for stable instance selection.
- id: checkbox_tristate-antd-T03
  name: Match shipping checkbox to reference (Indeterminate)
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the “Allow partial shipments” checkbox to the Desired state preview. The task will finish automatically
    when done.
  ui_copy: Match the “Allow partial shipments” checkbox to the Desired state preview. The task will finish automatically when
    done.
  setup_description: |
    Layout: centered isolated card.

    The card header reads **“Shipping options”**. On the left is the target Ant Design tri-state checkbox labeled **“Allow partial shipments”**.

    On the right side of the same row is a static **reference preview**: a small, non-clickable checkbox icon with the caption **“Desired state”**. The reference preview can show one of the three visuals (empty, dash, checkmark). For this instance, the preview shows the **dash** (Partially selected / indeterminate).

    Initial state of the target checkbox: **Unchecked**.

    There are no other checkboxes. A small footer shows “Tip: you can cycle through states by clicking the checkbox.” (informational only).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Only one checkbox is present; the goal is specified via a nearby visual reference, requiring minimal interpretation.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Target checkbox ends Checked when the reference shows the dash (Partial).
  - Target checkbox ends Unchecked when the reference shows the dash (Partial).
  - Matching the wrong element (the reference preview is not interactive).
  expected_interaction_path:
  - Look at the “Desired state” preview (dash).
  - Click the “Allow partial shipments” checkbox until it shows the same dash (indeterminate).
  notes: Reference preview should be rendered as non-interactive (aria-hidden). Checker must evaluate only the labeled target
    checkbox. data-testid='allow-partial-shipments'.
- id: checkbox_tristate-antd-T04
  name: 'Dark theme: enable auto-archive (Checked)'
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Auto-archive completed items” checkbox to Checked. The task will finish automatically when done.
  ui_copy: Set the “Auto-archive completed items” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: centered isolated card on a **dark theme** page (dark background, light text).

    The card contains a single Ant Design tri-state checkbox labeled **“Auto-archive completed items”**. The checkbox is rendered in default size and the label is immediately to the right.

    Initial state: **Partially selected (indeterminate)** — the box shows a horizontal dash.

    A small inline status pill to the right of the checkbox reads **“Partial”**, **“On”**, or **“Off”** and updates instantly with state changes (feedback only).

    No other checkboxes are present; there are no required Apply/Save buttons.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Dark theme slightly reduces contrast, but the task remains a direct single-checkbox state change with clear
      feedback.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Checkbox remains in the Partially selected (indeterminate) state.
  - Checkbox ends Unchecked.
  - Changing any unrelated UI (there is none) without reaching Checked.
  expected_interaction_path:
  - Click the “Auto-archive completed items” checkbox until the checkmark (Checked) is shown.
  notes: Ensure dark theme does not change checkbox hitbox. Checker reads indeterminate vs checked via DOM properties; data-testid='auto-archive-checkbox'.
- id: checkbox_tristate-antd-T05
  name: Set Primary consent to Partial (Indeterminate)
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Primary consent” checkbox to Partially selected (indeterminate). The task will finish automatically
    when done.
  ui_copy: Set the “Primary consent” checkbox to Partially selected (indeterminate). The task will finish automatically when
    done.
  setup_description: |
    Layout: **form_section** card titled “Consent settings”, centered in the viewport.

    There are **two** Ant Design tri-state checkboxes stacked vertically:
    1) **“Primary consent”** (target)
    2) **“Secondary consent”** (distractor of the same component type)

    Each checkbox cycles through Unchecked → Partial → Checked when clicked. Labels are similar and both are enabled.

    Initial states:
    - Primary consent: **Unchecked**
    - Secondary consent: **Checked**

    Below the checkboxes are non-required form fields (a text input for “Contact email” and a dropdown for “Region”), included only as low clutter.

    There is no Save/Apply; state changes are immediate.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires disambiguating between two similar tri-state checkboxes in a small form section and setting a
      non-default (indeterminate) state.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Primary consent' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Primary consent
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting “Secondary consent” to indeterminate while leaving “Primary consent” unchanged.
  - Leaving “Primary consent” Unchecked or Checked.
  - Toggling both checkboxes so the target is not indeterminate at the end.
  expected_interaction_path:
  - Locate the checkbox labeled “Primary consent”.
  - Click it until it shows the dash (Partially selected / indeterminate).
  notes: Provide stable label association (e.g., <label for=...>) so the checker can map instance by accessible name. data-testid='consent-primary'/'consent-secondary'.
- id: checkbox_tristate-antd-T06
  name: 'Compact panel: disable daily summary emails (Unchecked)'
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Daily summary emails” checkbox to Unchecked. The task will finish automatically when done.
  ui_copy: Set the “Daily summary emails” checkbox to Unchecked. The task will finish automatically when done.
  setup_description: |
    Layout: **settings_panel** anchored in the **top-right** of the viewport.

    The panel uses **compact spacing** and the tri-state checkbox is rendered in a **small** size variant (smaller box and tighter label spacing than default).

    Target component: one Ant Design tri-state checkbox labeled **“Daily summary emails”**. It cycles through Unchecked → Partial → Checked on click.

    Initial state: **Checked**.

    Clutter: medium but realistic. The same panel includes:
    - Two Ant Design Switch toggles (“Push notifications”, “Sound effects”) as distractors
    - A disabled tri-state checkbox (“Admin-only setting”) shown below, clearly disabled (cannot be changed)

    No confirmation button is required; changes are immediate.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Compact spacing and small scale increase target acquisition demands, but only one enabled tri-state checkbox
      is evaluated.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Leaving “Daily summary emails” in Checked or Partially selected state.
  - Interacting only with the switch toggles and not changing the target checkbox.
  - Attempting to change the disabled checkbox (it should not change and does not count as success).
  expected_interaction_path:
  - In the top-right settings panel, find “Daily summary emails”.
  - Click the checkbox until it becomes Unchecked (empty box).
  notes: For small/compact variants, ensure the clickable input (not just the icon) is reliably hittable. data-testid='daily-summary-checkbox'.
- id: checkbox_tristate-antd-T07
  name: Open Notifications panel and enable usage analytics
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: disclose
  secondary_template: toggle_state
  browsergym_goal: Open the “Notifications” section and set the “Usage analytics” checkbox to Checked. The task will finish
    automatically when done.
  ui_copy: Open the “Notifications” section and set the “Usage analytics” checkbox to Checked. The task will finish automatically
    when done.
  setup_description: |
    Layout: **form_section** titled “Account preferences”, centered.

    The section contains an Ant Design **Collapse/Accordion** with three panels:
    - “Profile”
    - **“Notifications”** (contains the target)
    - “Security”

    Only one panel is open at a time; initially **“Profile”** is open and “Notifications” is collapsed.

    Inside the “Notifications” panel (once expanded) is a single Ant Design tri-state checkbox labeled **“Usage analytics”** with a short description under it (“Help improve the product”). It cycles Unchecked → Partial → Checked.

    Initial state of “Usage analytics”: **Unchecked**.

    Clutter: medium. The opened panels also contain unrelated fields (text input for display name, a select for language), but none are required for success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires a disclosure step to reveal the checkbox, adding UI layering while keeping the target state change
      simple.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Leaving the “Usage analytics” checkbox Unchecked or Partially selected.
  - Expanding the wrong accordion panel and never reaching the target checkbox.
  - Changing other fields without setting “Usage analytics” to Checked.
  expected_interaction_path:
  - Expand the accordion panel titled “Notifications”.
  - Find the “Usage analytics” checkbox.
  - Click until it is Checked (checkmark).
  notes: Instrument accordion panel headers with stable text. Checker should ignore whether the panel remains open; only checkbox
    state matters. data-testid='usage-analytics-checkbox'.
- id: checkbox_tristate-antd-T08
  name: 'Modal: set folder access to Partial and confirm'
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: confirm_cancel
  secondary_template: toggle_state
  browsergym_goal: Open “Edit folder permissions”, set “Folder access” to Partially selected (indeterminate), then click OK.
    The task will finish automatically when done.
  ui_copy: Open “Edit folder permissions”, set “Folder access” to Partially selected (indeterminate), then click OK. The task
    will finish automatically when done.
  setup_description: |
    Layout: **modal_flow**.

    On the base page (centered card) there is a primary button labeled **“Edit folder permissions”**. Clicking it opens an Ant Design Modal titled **“Folder permissions”**.

    Inside the modal body is one Ant Design tri-state checkbox labeled **“Folder access”** with helper text (“Allow access for some subfolders”). The checkbox cycles Unchecked → Partial → Checked when clicked.

    Initial state when the modal opens: **Checked**.

    Modal footer contains two buttons:
    - “Cancel”
    - **“OK”** (commits the change)

    Important behavior: the page only commits/saves the permission state when **OK** is clicked. If the modal is closed with Cancel or the close (×), the checkbox state reverts to the previous saved value.

    No other tri-state checkboxes exist in the modal.
  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: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires operating inside a modal and committing the change with OK; missing the confirm step is a common
      failure mode.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Change is committed by clicking 'OK'.
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      tolerance: null
      require_confirm: true
      confirm_control: OK
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting the checkbox to the correct state but closing the modal with “Cancel” or the close (×).
  - Leaving the checkbox Checked or Unchecked when clicking OK.
  - Changing state in the modal but not clicking OK to commit.
  expected_interaction_path:
  - Click “Edit folder permissions” to open the modal.
  - In the modal, click “Folder access” until it becomes Partially selected (dash).
  - Click “OK” to commit.
  notes: Checker should verify the committed state after OK (e.g., stored value mirrored in a hidden model or read-only summary)
    rather than transient UI before confirmation. data-testid='folder-access-checkbox', modal OK button text='OK'.
- id: checkbox_tristate-antd-T09
  name: 'Dashboard: match Team visibility to Partial'
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Team visibility” checkbox to match the Desired state indicator (Partial). The task will finish
    automatically when done.
  ui_copy: Set the “Team visibility” checkbox to match the Desired state indicator (Partial). The task will finish automatically
    when done.
  setup_description: |
    Layout: **dashboard** with multiple statistic cards and controls; the target area is anchored near the **bottom-left** of the viewport.

    There are **three** Ant Design tri-state checkboxes presented as compact “visibility” cards in a row:
    - “Personal visibility”
    - **“Team visibility”** (target)
    - “Org visibility”

    Each card contains a tri-state checkbox (same component) and a short subtitle. All three are enabled and visually similar.

    Guidance is **mixed**:
    - Above the row is a small read-only reference badge that shows an icon of the desired checkbox state and the text **“Desired: Partial”**.
    - The badge is not clickable; it is only a reference.

    Initial states:
    - Personal visibility: Checked
    - Team visibility: Unchecked
    - Org visibility: Indeterminate

    Clutter: high. The dashboard also contains unrelated buttons (“Export”, “Refresh”), a search input, and a table preview beneath the cards. None of these are required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: bottom_left
    scale: default
    instances: 3
    guidance: mixed
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 4
    justification: High clutter and multiple similar instances increase disambiguation load; the goal is specified by a mixed
      text+icon reference rather than only text.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Team visibility' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Team visibility
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting the wrong visibility checkbox to Partial while leaving “Team visibility” incorrect.
  - Leaving “Team visibility” Unchecked or Checked.
  - Clicking the reference badge (it is non-interactive) and not changing the target checkbox.
  expected_interaction_path:
  - Locate the visibility card labeled “Team visibility”.
  - 'Use the reference badge (“Desired: Partial”) as the target state.'
  - Click the Team visibility checkbox until it shows the dash (indeterminate).
  notes: Ensure each card’s checkbox has a unique accessible name including the card title. data-testid='visibility-personal/team/org'.
- id: checkbox_tristate-antd-T10
  name: 'Settings scroll: set Sync health to Unchecked'
  canonical_type: checkbox_tristate
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Checkbox (indeterminate)'
  task_template: scroll_find
  secondary_template: toggle_state
  browsergym_goal: Scroll to the “Sync health” setting and set its checkbox to Unchecked. The task will finish automatically
    when done.
  ui_copy: Scroll to the “Sync health” setting and set its checkbox to Unchecked. The task will finish automatically when
    done.
  setup_description: |
    Layout: **settings_panel** page with a left sidebar and a scrollable main content column (standard settings layout).

    The main column contains a long list of settings grouped under headings (“General”, “Notifications”, “Sync”). The target tri-state checkbox is in the **“Sync”** group, which is **below the initial fold**; the agent must scroll the main content to reach it.

    Target component: one Ant Design tri-state checkbox labeled **“Sync health”** with helper text (“Allow partial sync when offline”). The checkbox cycles through Unchecked → Partial → Checked.

    Initial state: **Indeterminate**.

    Clutter: medium. Nearby settings include switches and radio buttons with similar typography, but they are not tri-state checkboxes.

    No Save/Apply button; the checkbox state updates immediately.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: The checkbox is off-screen at load and embedded in a realistic settings page, requiring scrolling and careful
      identification of the correct setting.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Toggling a different setting control (switch/radio) instead of the “Sync health” checkbox.
  - Leaving “Sync health” in Indeterminate or Checked state.
  - Scrolling to the area but not changing the checkbox state.
  expected_interaction_path:
  - Scroll the main settings content down to the “Sync” section.
  - Find the checkbox labeled “Sync health”.
  - Click it until it becomes Unchecked.
  notes: Mark the scroll container with data-testid for reliable automation. Checker should locate by accessible name 'Sync
    health'. data-testid='sync-health-checkbox'.
- id: checkbox_tristate-mui-T01
  name: Set Include attachments to Partial
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Include attachments” checkbox to Partially selected (indeterminate). The task will finish automatically
    when done.
  ui_copy: Set the “Include attachments” checkbox to Partially selected (indeterminate). The task will finish automatically
    when done.
  setup_description: |
    Layout: centered isolated card using Material UI styling.

    The card contains one MUI Checkbox with a FormControlLabel reading **“Include attachments”**. The checkbox is configured as a tri-state control for this benchmark and cycles through Unchecked → Partial (indeterminate) → Checked when activated.

    Initial state: **Unchecked**.

    A small caption under the control reads “Current: Off / Partial / On” and updates immediately (feedback only). No other checkboxes or required 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: 2
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single checkbox with explicit label and immediate feedback; only needs selecting the indeterminate state.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Leaving the checkbox Unchecked.
  - Leaving the checkbox Checked.
  - Interacting with the page without reaching the Partial (indeterminate) state.
  expected_interaction_path:
  - Click the “Include attachments” checkbox until it shows the indeterminate dash (Partial).
  notes: In MUI, indeterminate may be represented via aria-checked='mixed' and/or data-indeterminate; checker should normalize
    to canonical tristate. data-testid='include-attachments-checkbox'.
- id: checkbox_tristate-mui-T02
  name: Match Compress output to desired preview (Checked)
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the “Compress output” checkbox to the Desired state preview. The task will finish automatically when
    done.
  ui_copy: Match the “Compress output” checkbox to the Desired state preview. The task will finish automatically when done.
  setup_description: |
    Layout: centered isolated card titled “Export options”.

    Left side: one MUI tri-state checkbox labeled **“Compress output”**.

    Right side: a static “Desired state” preview, rendered as a small non-interactive checkbox icon (MUI icon styling) with no click handler. For this task, the preview shows the **checkmark** (Checked).

    Initial state of “Compress output”: **Indeterminate** (dash icon).

    No other instances; no additional form controls.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    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: Only one checkbox is present; the goal is conveyed via a nearby visual preview, but the target control
      is easy to acquire.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Leaving the target checkbox Indeterminate while the desired preview shows Checked.
  - Leaving the target checkbox Unchecked.
  - Attempting to click the non-interactive preview instead of the actual checkbox.
  expected_interaction_path:
  - Look at the Desired state preview (checkmark).
  - Click “Compress output” until it becomes Checked.
  notes: Make the desired preview aria-hidden and non-focusable. Checker evaluates only the labeled checkbox. data-testid='compress-output-checkbox'.
- id: checkbox_tristate-mui-T03
  name: 'Bottom-right card: enable Location access'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Location access” checkbox to Checked. The task will finish automatically when done.
  ui_copy: Set the “Location access” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: isolated card anchored near the **bottom-right** of the viewport (slightly away from the edges).

    The card contains a single MUI tri-state checkbox labeled **“Location access”** with helper text (“Allow precise location”). It cycles Unchecked → Partial → Checked.

    Initial state: **Unchecked**.

    No other controls are required. A small “Learn more” link is present as a distractor but does not affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_right
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Corner placement makes the control slightly less central to acquire, but the task remains a straightforward
      single-checkbox toggle.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Checkbox ends Unchecked.
  - Checkbox ends Indeterminate.
  - Clicking “Learn more” without setting the checkbox to Checked.
  expected_interaction_path:
  - In the bottom-right card, click the “Location access” checkbox until it is Checked.
  notes: Placement changes should not clip the checkbox. data-testid='location-access-checkbox'.
- id: checkbox_tristate-mui-T04
  name: Clear Product updates (Unchecked)
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Set the “Product updates” checkbox to Unchecked. The task will finish automatically when done.
  ui_copy: Set the “Product updates” checkbox to Unchecked. The task will finish automatically when done.
  setup_description: |
    Layout: **form_section** titled “Notification preferences”.

    There are **two** MUI tri-state checkboxes (FormControlLabel) stacked with short descriptions:
    - “Marketing emails”
    - **“Product updates”** (target)

    Both cycle through Unchecked → Partial → Checked.

    Initial state:
    - Marketing emails: Indeterminate
    - Product updates: Checked

    Clutter: low. Beneath them is a non-required text field “Preferred send time”.

    No Save button; checkbox changes apply immediately.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar instances require disambiguation; the task is a reset/clear to the Unchecked state for a specific
      labeled option.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Product updates' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Product updates
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Clearing the wrong checkbox (e.g., Marketing emails) while Product updates remains Checked/Partial.
  - Leaving Product updates in Checked or Indeterminate state.
  - Interacting only with the text field and not setting the checkbox.
  expected_interaction_path:
  - Find the checkbox labeled “Product updates”.
  - Click it until it becomes Unchecked (empty box).
  notes: Ensure accessible names match the visible labels. data-testid='marketing-emails-checkbox'/'product-updates-checkbox'.
- id: checkbox_tristate-mui-T05
  name: 'Advanced tab: set Experimental caching to Partial'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: navigate_to
  secondary_template: toggle_state
  browsergym_goal: Go to the “Advanced” tab and set the “Experimental caching” checkbox to Partially selected (indeterminate).
    The task will finish automatically when done.
  ui_copy: Go to the “Advanced” tab and set the “Experimental caching” checkbox to Partially selected (indeterminate). The
    task will finish automatically when done.
  setup_description: |
    Layout: **settings_panel** with a tab bar at the top of the panel.

    Tabs:
    - “General” (selected by default)
    - **“Advanced”** (contains the target)

    The “General” tab shows unrelated controls (a switch and a text field). The target tri-state checkbox is only visible after switching to the “Advanced” tab.

    In “Advanced”, there is a single MUI tri-state checkbox labeled **“Experimental caching”**. It cycles Unchecked → Partial → Checked.

    Initial state (when first viewing “Advanced”): **Unchecked**.

    No explicit Save button; the checkbox state changes immediately.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires navigating to the correct tab before interacting with the checkbox; otherwise the checkbox interaction
      itself is simple.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Staying on the General tab and never changing the target checkbox.
  - Setting “Experimental caching” to Checked or leaving it Unchecked.
  - Changing unrelated controls in the General tab only.
  expected_interaction_path:
  - Click the “Advanced” tab.
  - Find “Experimental caching”.
  - Click the checkbox until it is Partially selected (indeterminate).
  notes: Tab buttons should have stable accessible names. Checker evaluates the checkbox state regardless of the active tab
    after completion. data-testid='experimental-caching-checkbox'.
- id: checkbox_tristate-mui-T06
  name: 'Filters popover: enable Include archived'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: open_overlay
  secondary_template: toggle_state
  browsergym_goal: Open Filters and set the “Include archived” checkbox to Checked. The task will finish automatically when
    done.
  ui_copy: Open Filters and set the “Include archived” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: **dashboard** header row with a “Filters” button.

    The tri-state checkbox is inside a MUI Popover:
    - Clicking the **“Filters”** button opens a small popover panel anchored under the button.
    - The popover contains one MUI tri-state checkbox labeled **“Include archived”** plus a non-required text field “Search”.

    The checkbox cycles Unchecked → Partial → Checked.

    Initial state when the popover opens: **Unchecked**.

    No Apply button; changes apply immediately while the popover is open. The popover can be left open or closed; only the checkbox state is evaluated.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires opening a popover overlay to reach the checkbox; otherwise the state change is direct and observable.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Failing to open the Filters popover and never changing the checkbox.
  - Leaving “Include archived” Unchecked or Indeterminate.
  - Typing in the Search field without setting the checkbox to Checked.
  expected_interaction_path:
  - Click the “Filters” button to open the popover.
  - In the popover, find “Include archived”.
  - Click until it becomes Checked.
  notes: Popover should trap focus minimally but allow clicking checkbox. Use data-testid='filters-button' and 'include-archived-checkbox'.
- id: checkbox_tristate-mui-T07
  name: 'Dark panel: disable Share anonymized data'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Share anonymized data” checkbox to Unchecked. The task will finish automatically when done.
  ui_copy: Set the “Share anonymized data” checkbox to Unchecked. The task will finish automatically when done.
  setup_description: |
    Layout: **settings_panel** in **dark theme** (dark surfaces, light text).

    The panel contains one MUI tri-state checkbox labeled **“Share anonymized data”** with a short helper line below it (“Used to improve recommendations”). The checkbox cycles Unchecked → Partial → Checked.

    Initial state: **Indeterminate**.

    Clutter: medium. Nearby are two MUI switches (“Email notifications”, “Crash reports”), but they are standard two-state switches, not tri-state checkboxes.

    No confirm button; state updates instantly.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: Dark theme and nearby distractor switches slightly increase perceptual load, but only a single tri-state
      checkbox needs to reach Unchecked.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Leaving “Share anonymized data” Indeterminate or Checked.
  - Toggling only the nearby switches without changing the checkbox.
  - Changing the checkbox but not ending in Unchecked.
  expected_interaction_path:
  - Locate “Share anonymized data” in the dark settings panel.
  - Click the checkbox until it is Unchecked.
  notes: Ensure sufficient contrast for the indeterminate dash in dark theme. data-testid='share-anonymized-data-checkbox'.
- id: checkbox_tristate-mui-T08
  name: 'Dialog: set Write access to Partial and Apply'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: confirm_cancel
  secondary_template: toggle_state
  browsergym_goal: Open “Edit role”, set “Write access” to Partially selected (indeterminate), then click Apply. The task
    will finish automatically when done.
  ui_copy: Open “Edit role”, set “Write access” to Partially selected (indeterminate), then click Apply. The task will finish
    automatically when done.
  setup_description: |
    Layout: **modal_flow**.

    The page shows a “Role settings” card with a button **“Edit role”**. Clicking it opens a MUI Dialog titled **“Edit role permissions”**.

    Inside the dialog are **two** MUI tri-state checkboxes:
    - “Read access”
    - **“Write access”** (target)

    Each cycles Unchecked → Partial → Checked.

    Initial states when the dialog opens:
    - Read access: Checked
    - Write access: Unchecked

    Dialog footer buttons:
    - “Cancel” (closes without saving; reverts to previous saved values)
    - **“Apply”** (commits the new values)

    Important behavior: the committed role permissions only update after clicking **Apply**.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 4
    justification: Multiple similar tri-state checkboxes inside a modal plus a required Apply step increases both disambiguation
      and feedback/commit complexity.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Write access' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Change is committed by clicking 'Apply'.
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: true
      target_instance_label_or_id: Write access
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Changing “Read access” instead of “Write access”.
  - Setting “Write access” to the correct state but clicking Cancel (or closing the dialog) instead of Apply.
  - Clicking Apply while “Write access” is not Indeterminate.
  - Leaving the dialog open without clicking Apply (no commit).
  expected_interaction_path:
  - Click “Edit role” to open the dialog.
  - In the dialog, find “Write access”.
  - Click it until it becomes Partially selected (indeterminate).
  - Click “Apply” to commit.
  notes: Use accessible names for each checkbox; for committed-state checking, mirror saved values in a read-only summary
    outside the dialog after Apply. data-testid='write-access-checkbox', apply-button='apply-role'.
- id: checkbox_tristate-mui-T09
  name: 'Compact grid: match Sync status to Partial'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Sync status” checkbox to match the Desired state (Partial). The task will finish automatically
    when done.
  ui_copy: Set the “Sync status” checkbox to match the Desired state (Partial). The task will finish automatically when done.
  setup_description: |
    Layout: **form_section** rendered as a dense preferences grid in the **top-left** of the viewport.

    The grid uses **compact spacing** and the checkbox is rendered with MUI’s **small** size (smaller icon and label text). The target is a single tri-state checkbox labeled **“Sync status”**.

    Guidance is **mixed**:
    - Next to the section title is a small read-only chip showing an icon and text **“Desired: Partial”**.

    Initial state of “Sync status”: **Checked**.

    Clutter: medium. Two nearby controls (a small select “Sync mode” and a switch “Background sync”) sit adjacent in the grid and can be mistaken for the target.

    No Save button; changes are immediate.
  scene_context:
    theme: light
    spacing: compact
    layout: form_section
    placement: top_left
    scale: small
    instances: 1
    guidance: mixed
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: Small/compact rendering in a dense grid increases pointing accuracy demands, and the goal uses a mixed
      reference (chip) rather than only text.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Leaving “Sync status” Checked or Unchecked.
  - Toggling the nearby switch instead of the checkbox.
  - Matching the chip visually but ending in the wrong state.
  expected_interaction_path:
  - Find the “Sync status” checkbox in the top-left grid.
  - 'Use the “Desired: Partial” chip as the target state.'
  - Click until the checkbox shows the indeterminate dash.
  notes: For small MUI checkboxes, ensure the label click toggles the same input for easier acquisition. data-testid='sync-status-checkbox'.
- id: checkbox_tristate-mui-T10
  name: 'Drawer scroll: set Retention policy to Checked'
  canonical_type: checkbox_tristate
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Checkbox (indeterminate) + FormControlLabel'
  task_template: scroll_find
  secondary_template: toggle_state
  browsergym_goal: Open Bulk edit and set the “Retention policy” checkbox to Checked. The task will finish automatically when
    done.
  ui_copy: Open Bulk edit and set the “Retention policy” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: **drawer_flow**.

    On the main page (a table-like list) there is a button labeled **“Bulk edit”**. Clicking it opens a MUI Drawer that slides in from the right.

    Inside the drawer is a vertically scrollable list of bulk-edit options with section headers (“Basics”, “Notifications”, “Retention”). The target tri-state checkbox is in the **“Retention”** section and is **not visible at initial drawer scroll position**.

    Target component: one MUI tri-state checkbox labeled **“Retention policy”** (helper text: “Keep some items when storage is low”). It cycles Unchecked → Partial → Checked.

    Initial state: **Indeterminate**.

    Clutter: medium. The drawer contains several unrelated inputs (a date field and a dropdown) above the target. No Apply button is required; state changes apply immediately within the drawer.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a drawer and scrolling within it to reach the target checkbox; nested scrolling and overlay
      context increase interaction complexity.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Failing to open the Bulk edit drawer.
  - Scrolling but toggling a different option instead of “Retention policy”.
  - Leaving “Retention policy” Unchecked or Indeterminate.
  expected_interaction_path:
  - Click “Bulk edit” to open the right-side drawer.
  - Scroll inside the drawer to the “Retention” section.
  - Find “Retention policy” and click until it is Checked.
  notes: Drawer content should have a single scroll container. Add data-testid for the drawer and target checkbox. data-testid='bulk-edit-button','retention-policy-checkbox'.
- id: checkbox_tristate-mantine-T01
  name: Set Auto-renew to Partial
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Auto-renew subscription” checkbox to Partially selected (indeterminate). The task will finish
    automatically when done.
  ui_copy: Set the “Auto-renew subscription” checkbox to Partially selected (indeterminate). The task will finish automatically
    when done.
  setup_description: |
    Layout: centered isolated card using Mantine default styles.

    The card contains a single Mantine tri-state Checkbox labeled **“Auto-renew subscription”**. The checkbox supports an indeterminate (mixed) state and, for this benchmark, cycles through Unchecked → Partial (indeterminate) → Checked when clicked.

    Initial state: **Checked**.

    A small read-only text line under the checkbox shows “Current state: Checked / Partial / Unchecked” and updates immediately (feedback only). No other controls are required.
  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: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single, default-size checkbox with explicit label and a clear feedback line; only requires reaching the
      indeterminate state.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Leaving the checkbox Checked.
  - Leaving the checkbox Unchecked.
  - Interacting with the page without ending in the Partial (indeterminate) state.
  expected_interaction_path:
  - Click the “Auto-renew subscription” checkbox until it shows the indeterminate dash (Partial).
  notes: Mantine indeterminate visuals may appear as checked styles with a dash; checker should prioritize indeterminate/mixed
    over checked when reading state. data-testid='auto-renew-checkbox'.
- id: checkbox_tristate-mantine-T02
  name: Clear Weekly report (Unchecked)
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Weekly report” checkbox so it ends Unchecked. The task will finish automatically when done.
  ui_copy: Clear the “Weekly report” checkbox so it ends Unchecked. The task will finish automatically when done.
  setup_description: |
    Layout: centered isolated card titled “Reports”.

    The card contains a single Mantine tri-state Checkbox labeled **“Weekly report”**. It cycles Unchecked → Partial → Checked.

    Initial state: **Indeterminate** (dash).

    A small helper note under the control reads “You can choose On, Off, or Partial.” No other checkboxes are on the page. A non-required “Reset to defaults” button appears in the card footer as a distractor.
  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: Simple single-checkbox clear action; the only requirement is recognizing and reaching the Unchecked state.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Leaving the checkbox Indeterminate.
  - Leaving the checkbox Checked.
  - Clicking “Reset to defaults” but not ending with the checkbox Unchecked.
  expected_interaction_path:
  - Click the “Weekly report” checkbox until it becomes Unchecked (empty box).
  notes: Ensure the distractor reset button does not automatically satisfy the task unless it truly leaves the checkbox Unchecked.
    data-testid='weekly-report-checkbox'.
- id: checkbox_tristate-mantine-T03
  name: Match Show to teammates to desired preview (Unchecked)
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the “Show to teammates” checkbox to the Desired state preview. The task will finish automatically
    when done.
  ui_copy: Match the “Show to teammates” checkbox to the Desired state preview. The task will finish automatically when done.
  setup_description: |
    Layout: centered isolated card titled “Content visibility”.

    Target control: one Mantine tri-state Checkbox labeled **“Show to teammates”**.

    To the right of the checkbox is a static “Desired state” preview: a small, non-clickable checkbox icon with a caption. For this task, the preview shows the **empty box** (Unchecked).

    Initial state of “Show to teammates”: **Checked**.

    No additional controls are required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    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: One checkbox with a clear nearby visual target; minimal distraction and no layering.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Leaving the checkbox Checked when the preview indicates Unchecked.
  - Leaving the checkbox Indeterminate when the preview indicates Unchecked.
  - Interacting with the preview (it is not clickable) instead of the checkbox.
  expected_interaction_path:
  - Observe the Desired state preview (empty box).
  - Click “Show to teammates” until it becomes Unchecked.
  notes: Make the preview icon aria-hidden and non-focusable. data-testid='show-to-teammates-checkbox'.
- id: checkbox_tristate-mantine-T04
  name: Enable Email digest (Checked)
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Email digest” checkbox to Checked. The task will finish automatically when done.
  ui_copy: Set the “Email digest” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: **form_section** titled “Digest delivery”, centered.

    There are **two** Mantine tri-state checkboxes:
    - **“Email digest”** (target)
    - “SMS digest” (distractor)

    Both are enabled and cycle Unchecked → Partial → Checked.

    Initial states:
    - Email digest: Unchecked
    - SMS digest: Indeterminate

    Clutter: low. A non-required input “Digest frequency” (dropdown) is shown below.

    No Save/Apply control; state changes are immediate.
  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: 3
    justification: Requires selecting the correct labeled instance among two similar tri-state checkboxes in a small form
      section.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Email digest' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Email digest
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting “SMS digest” to Checked while leaving “Email digest” unchanged.
  - Leaving “Email digest” Unchecked or Indeterminate.
  - Changing only the dropdown without setting the checkbox.
  expected_interaction_path:
  - Find the checkbox labeled “Email digest”.
  - Click it until it shows the checkmark (Checked).
  notes: Ensure labels are connected for reliable instance mapping. data-testid='email-digest-checkbox'/'sms-digest-checkbox'.
- id: checkbox_tristate-mantine-T05
  name: 'Accordion: set Search indexing to Partial'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: disclose
  secondary_template: toggle_state
  browsergym_goal: Open the “Indexing” section and set the “Search indexing” checkbox to Partially selected (indeterminate).
    The task will finish automatically when done.
  ui_copy: Open the “Indexing” section and set the “Search indexing” checkbox to Partially selected (indeterminate). The task
    will finish automatically when done.
  setup_description: |
    Layout: **form_section** titled “Privacy”, centered, using Mantine Accordion.

    Accordion items:
    - “Visibility”
    - **“Indexing”** (contains the target)
    - “Data export”

    Initially, the “Visibility” item is open and “Indexing” is collapsed.

    Inside the “Indexing” accordion panel is one Mantine tri-state checkbox labeled **“Search indexing”** with a brief description (“Allow partial indexing for shared pages”). The checkbox cycles Unchecked → Partial → Checked.

    Initial state: **Unchecked**.

    Clutter: medium. Other accordion panels contain unrelated toggles and a link, but none are required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: An accordion disclosure step is required to reveal the checkbox; after disclosure, the state change is
      straightforward.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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 “Indexing” accordion item.
  - Leaving “Search indexing” Unchecked or Checked.
  - Toggling controls in other accordion items without setting the target state.
  expected_interaction_path:
  - Open the accordion item titled “Indexing”.
  - Find “Search indexing”.
  - Click the checkbox until it becomes Partially selected (indeterminate).
  notes: Accordion headings should be accessible buttons. data-testid='search-indexing-checkbox'.
- id: checkbox_tristate-mantine-T06
  name: 'Compact corner: enable Show online status'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Show online status” checkbox to Checked. The task will finish automatically when done.
  ui_copy: Set the “Show online status” checkbox to Checked. The task will finish automatically when done.
  setup_description: |
    Layout: **settings_panel** anchored near the **bottom-left** of the viewport.

    The panel uses **compact spacing** and renders the Mantine Checkbox in a **small** size (smaller box and label text).

    Target component: one Mantine tri-state checkbox labeled **“Show online status”**. It cycles Unchecked → Partial → Checked.

    Initial state: **Indeterminate**.

    Clutter: low. One nearby button “Manage blocked users” is present but not required.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: bottom_left
    scale: small
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small, compact rendering and non-central placement increase pointing difficulty while keeping the interaction
      path short.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      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:
  - Leaving “Show online status” Unchecked or Indeterminate.
  - Clicking “Manage blocked users” without setting the checkbox to Checked.
  expected_interaction_path:
  - In the bottom-left panel, click “Show online status” until it becomes Checked.
  notes: For compact/small variants, ensure label click area is included to reduce miss-clicks. data-testid='show-online-status-checkbox'.
- id: checkbox_tristate-mantine-T07
  name: 'Modal: turn off Delete protection and Save'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: confirm_cancel
  secondary_template: toggle_state
  browsergym_goal: Open “Edit delete protection”, set “Delete protection” to Unchecked, then click Save. The task will finish
    automatically when done.
  ui_copy: Open “Edit delete protection”, set “Delete protection” to Unchecked, then click Save. The task will finish automatically
    when done.
  setup_description: |
    Layout: **modal_flow**.

    The base page shows a “Danger zone” card with a button labeled **“Edit delete protection”**. Clicking it opens a Mantine Modal titled **“Delete protection”**.

    Inside the modal is one Mantine tri-state checkbox labeled **“Delete protection”** with helper text (“Prevent accidental deletion; can be On, Off, or Partial”). It cycles Unchecked → Partial → Checked.

    Initial state: **Checked**.

    Modal footer buttons:
    - “Cancel” (closes without saving; restores previous state)
    - **“Save”** (commits the change)

    Important behavior: the saved setting only updates after clicking **Save**.
  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: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires interacting within a modal and confirming with Save; the commit requirement increases failure
      risk even though only one checkbox is present.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: unchecked.'
    - Change is committed by clicking 'Save'.
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      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:
  - Setting the checkbox to Unchecked but closing the modal with Cancel or the close (×).
  - Clicking Save while the checkbox is not Unchecked.
  - Changing state but never clicking Save to commit.
  expected_interaction_path:
  - Click “Edit delete protection” to open the modal.
  - Click the “Delete protection” checkbox until it becomes Unchecked.
  - Click “Save” to commit.
  notes: For commit checking, mirror the saved value in a read-only summary on the underlying page after Save. data-testid='delete-protection-checkbox',
    save-button='save-delete-protection'.
- id: checkbox_tristate-mantine-T08
  name: 'Dark dashboard: set Workspace visibility to On (Checked)'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Workspace visibility” checkbox to match the Desired indicator (On). The task will finish automatically
    when done.
  ui_copy: Set the “Workspace visibility” checkbox to match the Desired indicator (On). The task will finish automatically
    when done.
  setup_description: |
    Layout: **dashboard** in **dark theme** with multiple cards and a dense header (search, user menu, action buttons).

    In the “Visibility” dashboard card there are **three** Mantine tri-state checkboxes displayed as rows with icons:
    - “Project visibility”
    - **“Workspace visibility”** (target)
    - “Org visibility”

    All three checkboxes are enabled and look similar. Each cycles Unchecked → Partial → Checked.

    Guidance is **mixed**:
    - At the top of the card is a small read-only indicator showing an icon and text **“Desired for Workspace: On”** (On corresponds to Checked).

    Initial states:
    - Project visibility: Checked
    - Workspace visibility: Indeterminate
    - Org visibility: Unchecked

    Clutter: high. The card also contains a small activity chart and two buttons (“Invite”, “Manage”), but they are not required.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 3
    guidance: mixed
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 4
    justification: Dark theme plus high clutter and multiple similar instances raise disambiguation and perceptual demands;
      the goal uses a mixed indicator rather than only direct text on the control.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Workspace visibility' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: checked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: checked
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Workspace visibility
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting the wrong visibility checkbox to Checked while Workspace visibility remains Indeterminate.
  - Leaving Workspace visibility Unchecked or Indeterminate.
  - Clicking dashboard buttons without achieving the required checkbox state.
  expected_interaction_path:
  - In the Visibility card, find the row labeled “Workspace visibility”.
  - 'Use the indicator “Desired for Workspace: On” as the target.'
  - Click the checkbox until it is Checked.
  notes: Ensure each row label is part of the checkbox accessible name. data-testid='visibility-workspace-checkbox'.
- id: checkbox_tristate-mantine-T09
  name: 'Table header: set Archived filter to Partial'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Set the “Archived filter” checkbox to Partially selected (indeterminate). The task will finish automatically
    when done.
  ui_copy: Set the “Archived filter” checkbox to Partially selected (indeterminate). The task will finish automatically when
    done.
  setup_description: |
    Layout: **table_cell** context in the **top-right** of the viewport.

    A compact data table (“Projects”) is visible with a sticky header row. In the header cell for the “Archived” column there is a small Mantine tri-state checkbox labeled **“Archived filter”** (label appears as a tooltip on hover and as an aria-label for accessibility). The checkbox is rendered in a **small** size and the table uses **compact** spacing.

    The tri-state checkbox cycles Unchecked → Partial → Checked.

    Initial state: **Unchecked**.

    Clutter: medium. The table header also includes sort icons, a search field above the table, and other column filter chips. None are required for success.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: Small, compact placement inside a dense table header makes the target harder to acquire and the state harder
      to perceive, even though it is a single checkbox.
  success_trigger:
    human_readable:
    - 'Target tri-state checkbox is in state: indeterminate.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: indeterminate
      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:
  - Leaving the Archived filter checkbox Unchecked or Checked.
  - Clicking other table header controls (sort/filter chips) without setting the checkbox state.
  - Changing table search text only without setting the checkbox state.
  expected_interaction_path:
  - Locate the Projects table header.
  - Find the small checkbox labeled “Archived filter”.
  - Click it until it becomes Partially selected (indeterminate).
  notes: Provide an explicit aria-label for the header checkbox so it can be uniquely identified. data-testid='archived-filter-checkbox'.
- id: checkbox_tristate-mantine-T10
  name: 'Dashboard scroll: clear Staging rollout (Unchecked)'
  canonical_type: checkbox_tristate
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Checkbox (indeterminate)'
  task_template: scroll_find
  secondary_template: toggle_state
  browsergym_goal: Scroll to “Staging rollout” and set its checkbox to Unchecked. The task will finish automatically when
    done.
  ui_copy: Scroll to “Staging rollout” and set its checkbox to Unchecked. The task will finish automatically when done.
  setup_description: |
    Layout: **dashboard** with a main scrollable content column (the page itself scrolls).

    Near the top of the dashboard is a “Rollout controls” card that contains a long list of environments and toggles. The list is long enough that the entries for staging and production are **below the initial fold**, requiring scrolling to reach them.

    Within the Rollout controls card there are **two** Mantine tri-state checkboxes with very similar labels:
    - **“Staging rollout”** (target)
    - “Production rollout” (distractor)

    Both cycle Unchecked → Partial → Checked.

    Initial states:
    - Staging rollout: Checked
    - Production rollout: Indeterminate

    Clutter: high but realistic for a dashboard. Above the card are filters and a date range picker; within the card are several unrelated controls (buttons “Pause all”, “Resume”, and a search box for environments). None are required for success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 5
    justification: Requires scrolling to reach the target plus disambiguating between two nearly identical tri-state checkboxes
      in a high-clutter dashboard, making wrong-instance errors likely.
  success_trigger:
    human_readable:
    - Only the checkbox labeled 'Staging rollout' is evaluated (other instances are ignored).
    - 'Target tri-state checkbox is in state: unchecked.'
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state: unchecked
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Staging rollout
      terminal_condition: task_ends_when_predicate_holds
  negative_cases:
  - Setting “Production rollout” to Unchecked while leaving “Staging rollout” unchanged.
  - Leaving “Staging rollout” Checked or Indeterminate.
  - Changing other dashboard controls (filters/search/buttons) without setting the target checkbox to Unchecked.
  expected_interaction_path:
  - Scroll down to the Rollout controls card entries for staging/production.
  - Find the checkbox labeled “Staging rollout”.
  - Click it until it becomes Unchecked (empty box).
  notes: To prevent ambiguous label matching, ensure accessible names include the full environment label. data-testid='staging-rollout-checkbox'/'production-rollout-checkbox'.