tasks/v1/icon_button.yaml

- id: icon_button-antd-T01
  name: Refresh preview icon button
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only via icon prop, shape=''circle'')'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the circular icon button labeled “Refresh preview” in the Preview card. The task will finish automatically when done.
  ui_copy: |-
    Preview
    Refresh preview (icon button)
  setup_description: |
    Layout: isolated_card centered in the viewport.

    The page shows a single card titled “Preview”. In the card header (right-aligned) there is one Ant Design icon-only Button rendered as a circular button (shape="circle") with a refresh/reload icon. Next to the button is a small text label “Refresh preview” (so the control is identifiable without hovering).

    Component configuration:
    - Single icon-only Button; default size; comfortable spacing.
    - The button has aria-label="Refresh preview".
    - Initial state: data-cb-activated="false".

    Feedback:
    - On activation, the button sets data-cb-activated="true" and a non-blocking toast “Preview refreshed” appears (toast is not required for success).

    Distractors:
    - None (clean single-component 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: 1
      disambiguation_load: 1
    justification: Single large, clearly labeled icon button in a clean card; immediate feedback and no competing instances.
  success_trigger:
    human_readable:
    - The AntD icon button with aria-label “Refresh preview” has data-cb-activated="true".
    - No other instance checks are needed because there is only one icon button on the page.
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The icon button was not activated (data-cb-activated remains "false").
  - Focus is moved to the button but it is never activated (no click/Enter/Space).
  expected_interaction_path:
  - Locate the “Refresh preview” circular icon button in the Preview card header.
  - Click the icon button once (or focus it and press Enter/Space).
  notes: 'Implementation note: Ant Design uses Button for icon-only buttons via the icon prop / icon children. Checker hint: set data-cb-activated on the button element itself when it receives an activation event.'
- id: icon_button-antd-T02
  name: Toggle Favorite on (star icon)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only, type=''text'', toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Turn on Favorite by toggling the star icon button so Favorite shows as On. The task will finish automatically when done.
  ui_copy: |-
    Document: “Quarterly Summary”
    Favorite: Off
    [Star icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Document actions” shows the document name “Quarterly Summary”. To the right of the “Favorite” row there is a single icon-only AntD Button (type="text") showing a star outline icon. The row also contains a status text “Favorite: Off/On”.

    Component configuration:
    - One icon button only.
    - The button behaves as a toggle and exposes aria-pressed="false|true".
    - Initial state: aria-pressed="false"; status text reads “Favorite: Off”.

    Feedback:
    - Clicking toggles aria-pressed and swaps the status text to “Favorite: On”.
    - No Apply/OK step; state updates immediately.

    Distractors:
    - None (only the Favorite toggle is 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: 1
      disambiguation_load: 1
    justification: Single toggle icon button with an explicit On/Off text indicator; immediate feedback and no distractors.
  success_trigger:
    human_readable:
    - The star icon button has aria-pressed="true" (Favorite is On).
    - 'The visible status text reads “Favorite: On” (used as a secondary sanity check).'
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Favorite star button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Favorite remains Off (aria-pressed="false").
  - The wrong state is achieved (e.g., toggled On then toggled back Off).
  expected_interaction_path:
  - Locate the “Favorite” row and its star icon button.
  - Click the star icon button once to switch it to On.
  notes: Checker should primarily rely on aria-pressed for the toggle state; status text is optional for additional observability.
- id: icon_button-antd-T03
  name: Expand details (chevron icon disclose)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only, type=''text'', aria-expanded)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Expand the Shipping details section using the chevron icon button so it shows as Expanded. The task will finish automatically when done.
  ui_copy: |-
    Shipping details (Collapsed)
    [Chevron-down icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A single card titled “Order”. Inside the card there is a section header “Shipping details” with a chevron icon-only Button aligned to the far right of the header line.

    Component configuration:
    - One icon-only AntD Button (type="text") used purely as a disclosure control.
    - The button has aria-label="Expand shipping details".
    - The button reflects state with aria-expanded="false|true".
    - Initial state: aria-expanded="false"; the header shows a small badge “Collapsed”.

    Feedback:
    - On activation, aria-expanded becomes "true" and the badge changes to “Expanded”. A details block appears below (content is not required for success).

    Distractors:
    - None; only one disclosure icon button is 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: A single disclosure icon button with clear expanded/collapsed feedback; minimal interaction depth.
  success_trigger:
    human_readable:
    - The chevron icon button (aria-label “Expand shipping details”) has aria-expanded="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        expanded: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Shipping details disclosure button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The section remains collapsed (aria-expanded="false").
  - The user scrolls or focuses the section but does not activate the disclosure button.
  expected_interaction_path:
  - Find the “Shipping details” header.
  - Click the chevron icon button on the right to expand it.
  notes: Use aria-expanded as the canonical expanded/collapsed signal for the disclosure icon button.
- id: icon_button-antd-T04
  name: Reset sort mode to None (cycle icon button)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only, cycles internal mode)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Sort mode back to “None” using the sort icon button. The task will finish automatically when done.
  ui_copy: |-
    Sort mode: Z→A
    [Sort icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “List controls” contains one row labeled “Sort mode”. On the left, the current mode is shown as plain text (one of: “None”, “A→Z”, “Z→A”). On the right side of the row there is an icon-only AntD Button with a generic sort icon.

    Component configuration:
    - One icon-only Button, default size, comfortable spacing.
    - The button has aria-label="Change sort mode".
    - Clicking the icon button cycles the mode in a fixed order:
      None → A→Z → Z→A → None …
    - Initial state: mode text shows “Z→A”, and the button has data-cb-mode="za".

    Feedback:
    - The mode text updates immediately after each click.
    - No Apply/OK required.

    Distractors:
    - None (only the sort icon button is interactive).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Requires repeated activation until a specific labeled state is reached, but the state is explicitly shown as text and there are no distractors.
  success_trigger:
    human_readable:
    - The sort icon button’s canonical mode equals “none” (data-cb-mode="none").
    - 'The visible label reads “Sort mode: None”.'
    canonical_predicate:
      predicate_type: equals
      target_state:
        mode: none
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Sort mode icon button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving the mode at A→Z or Z→A (not reset).
  - Stopping on the wrong cycle state even if the button was clicked at least once.
  expected_interaction_path:
  - Locate the “Sort mode” row and its sort icon button.
  - Click the icon button until the mode text becomes “None”.
  notes: Checker should read the canonical mode from a stable attribute on the icon button (e.g., data-cb-mode) rather than inferring from icon graphics.
- id: icon_button-antd-T05
  name: Set View mode to List (icon button group)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (3 icon-only buttons acting as a single-select group)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Display settings panel, set View mode to “List”. The task will finish automatically when done.
  ui_copy: |-
    Display settings
    View mode: Grid
    [Grid icon] [List icon] [Cards icon]
  setup_description: |
    Layout: settings_panel centered in the viewport.

    A settings panel titled “Display settings” contains several non-interactive rows (static text) and one interactive row labeled “View mode”. In that row, three icon-only AntD Buttons are presented side-by-side:
    - Grid (icon resembles small squares)
    - List (icon resembles horizontal lines)
    - Cards (icon resembles stacked rectangles)

    Component configuration:
    - Three icon-only Buttons styled as a segmented selection group.
    - Each button has a stable aria-label (“View mode: Grid”, “View mode: List”, “View mode: Cards”) and uses aria-pressed to indicate selection.
    - Initial state: Grid is selected (aria-pressed="true" on Grid); the panel also shows “View mode: Grid” as text on the right.

    Feedback:
    - Clicking one option sets it to aria-pressed="true" and clears aria-pressed on the others.
    - The right-side text updates to reflect the current selection.
    - No Apply/OK required.

    Distractors / clutter (low):
    - The panel also shows two static rows (“Theme”, “Font size”) with non-interactive values, but there are no other buttons or toggles.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 3
    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: 2
    justification: Multiple adjacent icon buttons require selecting the correct option in a small group; selection is visible but still requires correct targeting.
  success_trigger:
    human_readable:
    - 'In the View mode icon-button group, the List option is selected (aria-pressed="true" on “View mode: List”).'
    - The group-level canonical selection equals "list".
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: list
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: View mode group
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Grid or Cards instead of List.
  - Clicking List but selection does not change (e.g., click blocked) so aria-pressed remains on a different option.
  - Changing selection in a different group (if any) must not count as success.
  expected_interaction_path:
  - Locate the “View mode” row in the Display settings panel.
  - Click the icon button for List.
  - 'Verify the row text updates to “View mode: List”.'
  notes: Checker should compute selected_option from which button in the group has aria-pressed="true" (or from a group wrapper data-cb-selected="list").
- id: icon_button-antd-T06
  name: Match the target icon (visual reference)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (4 icon-only buttons; one matches a reference icon)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the icon button that matches the Target icon shown in the reference box. The task will finish automatically when done.
  ui_copy: |-
    Target icon:
    [reference icon]
    Choose the matching icon button:
    [Option buttons]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    The card is titled “Icon match”. At the top of the card there is a “Target icon” reference box that displays a single monochrome SVG icon (no text label describing it). Below the reference box are four AntD icon-only Buttons (default size, comfortable spacing) arranged in a 2×2 grid. Each button shows one candidate icon.

    Component configuration:
    - Four icon-only AntD Buttons; each has a generic aria-label (“Option 1”, “Option 2”, “Option 3”, “Option 4”) so the label does not reveal the icon.
    - Each option button has a hidden stable attribute data-icon-key (e.g., “bell”, “bell-off”, “flag”, “tag”).
    - The reference box also has a hidden data-reference-icon-key that matches exactly one of the option buttons’ data-icon-key values.
    - Initial state: all option buttons have data-cb-activated="false".

    Feedback:
    - When an option is activated, it sets its own data-cb-activated="true" and shows a thin focus/active ring.
    - No confirmation step.

    Distractors:
    - None besides the four candidate icon buttons (all are part of this single match task).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 2
    justification: Requires visual matching among multiple similar icons; state change is subtle (activation flag) and there is no textual description of the target icon.
  success_trigger:
    human_readable:
    - Let K be the reference icon key from the Target icon box. The option icon button whose data-icon-key equals K has data-cb-activated="true".
    - No other option button activation counts unless it is the matching one.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_binding: data-reference-icon-key
        match_attribute: data-icon-key
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Option button matching reference icon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Activating a non-matching option button (wrong icon).
  - Activating multiple options without the matching one being activated.
  - Only hovering/focusing an option without activating it (data-cb-activated stays false).
  expected_interaction_path:
  - Inspect the Target icon reference box.
  - Compare it to the four option icons.
  - Click the option icon button that matches the reference.
  notes: 'Instrumentation: expose a stable data-reference-icon-key on the reference box and data-icon-key on each option to enable a deterministic checker without revealing the answer in visible text.'
- id: icon_button-antd-T07
  name: Scroll to find Help icon button (dashboard)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only, shape=''circle'')'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll through the Activity dashboard and click the “Help & support” icon button. The task will finish automatically when done.
  ui_copy: |-
    Activity dashboard
    …(long feed)…
    Help & support [Question-mark icon button]
  setup_description: |
    Layout: dashboard with the target anchored near the bottom-right of the viewport once scrolled into view.

    The page is a dashboard titled “Activity” with a long vertical feed (enough content to require scrolling). Near the end of the feed, there is a small card titled “Need help?” containing a circular icon-only AntD Button with a question-mark icon and a visible label “Help & support”.

    Component configuration:
    - One icon-only Button (shape="circle"), default size, comfortable spacing.
    - aria-label="Help & support".
    - Initial state: data-cb-activated="false".

    Clutter (medium):
    - The feed contains multiple non-interactive activity items and a few passive badges/labels, but no other icon buttons.

    Feedback:
    - Clicking the Help icon button sets data-cb-activated="true" and shows an inline message “Support panel opened” (message itself is not required for success).
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: bottom_right
    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: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: The primary challenge is locating the control via scrolling within a moderately cluttered dashboard; once found, the button is clearly labeled.
  success_trigger:
    human_readable:
    - The “Help & support” icon button has data-cb-activated="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Help & support button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not scrolling far enough to reach the “Need help?” card, so the button is never activated.
  - Clicking within the feed but not activating the Help icon button (data-cb-activated remains false).
  expected_interaction_path:
  - Scroll down the Activity dashboard until the “Need help?” card is visible.
  - Click the circular question-mark icon button labeled “Help & support”.
  notes: Ensure the help button remains a standard button element (not a link) so activation is unambiguous for the checker.
- id: icon_button-antd-T08
  name: Toggle Mute alerts in Secondary toolbar (two toolbars)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (4 icon-only buttons across two labeled toolbars; toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: In the Secondary toolbar, turn on “Mute alerts” using its icon button so it shows as On. The task will finish automatically when done.
  ui_copy: |-
    Primary toolbar: Mute alerts (Off) | Pin (Off)
    Secondary toolbar: Mute alerts (Off) | Pin (Off)
  setup_description: |
    Layout: isolated_card centered in the viewport.

    The card is titled “Toolbar settings” and contains two stacked toolbars with identical controls:
    1) “Primary toolbar”
    2) “Secondary toolbar”

    Each toolbar has two small, compact icon-only AntD Buttons with visible text labels to their right:
    - “Mute alerts” (bell-with-slash icon)
    - “Pin” (pushpin icon)

    Component configuration:
    - Total icon-button instances: 4 (2 per toolbar).
    - Spacing mode is compact; icon buttons are rendered in a small size tier (smaller hit targets and tighter spacing).
    - Each “Mute alerts” button is a toggle with aria-pressed="false|true" and an adjacent status chip “Off/On”.
    - Initial state: both toolbars show “Mute alerts: Off” (aria-pressed="false" on both Mute buttons).

    Feedback:
    - Clicking a Mute alerts icon button toggles only that toolbar’s mute state and updates the adjacent chip to “On”.
    - No Apply/OK.

    Distractors (low):
    - The “Pin” icon buttons are present and visually similar in size/weight to the Mute buttons, but clearly labeled.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 4
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Two near-identical toolbars create disambiguation pressure, and the compact/small icon buttons increase targeting difficulty.
  success_trigger:
    human_readable:
    - The “Mute alerts” icon button in the Secondary toolbar has aria-pressed="true".
    - The Primary toolbar’s “Mute alerts” button state is irrelevant to success but must not be used to satisfy the predicate (correct-instance requirement).
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Secondary toolbar: Mute alerts'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Toggling “Mute alerts” in the Primary toolbar instead of the Secondary toolbar.
  - Clicking the “Pin” icon button(s) but leaving Secondary “Mute alerts” Off.
  - Secondary “Mute alerts” is toggled On and then toggled back Off.
  expected_interaction_path:
  - Locate the Secondary toolbar section.
  - Within that toolbar, click the small “Mute alerts” icon button once.
  - Verify the Secondary status chip reads “On”.
  notes: Checker should identify the Secondary toolbar instance by a stable container label (e.g., data-toolbar="secondary") and then read aria-pressed on the contained Mute alerts button.
- id: icon_button-antd-T09
  name: Dark theme icon match (small icons)
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (4 small icon-only buttons; visual match in dark theme)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the dark-themed Icon match card, click the icon button that matches the Target icon. The task will finish automatically when done.
  ui_copy: |-
    Icon match (dark)
    Target icon: [reference]
    [4 small option icon buttons]
  setup_description: |
    Layout: isolated_card placed near the top-left of the viewport.

    The page uses a dark theme. A single card titled “Icon match” appears toward the top-left. The card contains a Target icon reference box (monochrome icon on a dark background) and four small icon-only AntD Buttons arranged in a 2×2 grid.

    Component configuration:
    - Total instances: 4 icon buttons.
    - Scale: small (reduced button size and smaller icon glyphs).
    - Each option has aria-label “Option 1–4” (generic) and hidden data-icon-key.
    - The reference box has hidden data-reference-icon-key.
    - Initial state: all option buttons have data-cb-activated="false".

    Feedback:
    - On activation, the chosen option sets data-cb-activated="true". The visual feedback is subtle (slightly brighter border).

    Distractors:
    - None other than the four candidates; the difficulty comes from dark theme + small scale + visual similarity.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: small
    instances: 4
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 3
    justification: Small targets on a dark theme combined with purely visual matching makes both acquisition and observability challenging.
  success_trigger:
    human_readable:
    - Using the reference icon key K, the option button with data-icon-key=K has data-cb-activated="true".
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_binding: data-reference-icon-key
        match_attribute: data-icon-key
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Option button matching reference icon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Activating any non-matching option button.
  - Only visually focusing/hovering without activation.
  - Activating multiple options but not the correct one.
  expected_interaction_path:
  - Compare the Target icon to the four small option icons.
  - Click the matching small icon button.
  notes: To keep the task non-adversarial, ensure all icons have sufficient contrast against the dark background (even though they are still visually similar).
- id: icon_button-antd-T10
  name: 'Pin a specific table row (Invoice #2041)'
  canonical_type: icon_button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button (icon-only pin buttons inside table cells)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: 'In the Invoices table, pin the row for “Invoice #2041” using its pin icon button. The task will finish automatically when done.'
  ui_copy: |-
    Invoices table
    Row: Invoice #2041 … [Pin icon button]
  setup_description: |
    Layout: table_cell centered in the viewport.

    The page shows a small Ant Design table titled “Invoices” with three rows:
    - Invoice #2039
    - Invoice #2041
    - Invoice #2042

    Each row has a rightmost “Pin” column that contains an icon-only AntD Button with a pushpin icon. The invoice identifier is shown in the first column as text.

    Component configuration:
    - Total icon-button instances: 3 (one per row).
    - Each pin button is a toggle with aria-pressed="false|true".
    - Initial state: all rows are unpinned (aria-pressed="false" on all three pin buttons).

    Clutter (high for this small scene):
    - Besides the three pin buttons, the table has sortable column headers (non-interactive in this task) and per-row metadata text, which increases visual clutter and scanning requirements.

    Feedback:
    - When pinned, that row’s pin button becomes aria-pressed="true" and the row shows a small “Pinned” tag. No confirmation step.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 5
    justification: Requires selecting the correct icon button embedded in a table row, with multiple near-identical pin controls and high disambiguation load.
  success_trigger:
    human_readable:
    - 'The pin icon button in the row whose first cell text equals “Invoice #2041” has aria-pressed="true".'
    - Pin buttons in other rows do not satisfy the correct-instance requirement.
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Invoice #2041 → Pin button'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - 'Pinning the wrong row (e.g., #2039 or #2042).'
  - 'Interacting with the table headers or row text without pinning #2041.'
  - 'Pinning #2041 and then unpinning it (ending in aria-pressed="false").'
  expected_interaction_path:
  - 'Scan the table to find the row labeled “Invoice #2041”.'
  - In that row, click the pin icon button in the Pin column.
  - Confirm the row shows as pinned (aria-pressed="true").
  notes: Checker should locate the row by its visible invoice id text and then query the contained pin button’s aria-pressed state (avoids reliance on DOM order).
- id: icon_button-mui-T01
  name: Activate Search icon button
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the icon button labeled “Search” in the Quick actions card. The task will finish automatically when done.
  ui_copy: |-
    Quick actions
    Search [magnifying-glass icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Quick actions” shows a single MUI IconButton with a magnifying-glass icon. The text label “Search” is displayed next to the icon button (not inside it) for clarity.

    Component configuration:
    - One MUI IconButton (default size) with aria-label="Search".
    - Initial state: data-cb-activated="false".

    Feedback:
    - On activation, the IconButton sets data-cb-activated="true" and an inline status text appears: “Search activated”.

    Distractors:
    - None; there are no other icon buttons or controls.
  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 clearly labeled IconButton with immediate feedback; no competing targets.
  success_trigger:
    human_readable:
    - The MUI IconButton with aria-label “Search” has data-cb-activated="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Search IconButton
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The Search IconButton is not activated (data-cb-activated remains false).
  - Only focusing/hovering the IconButton without activation.
  expected_interaction_path:
  - Find the Quick actions card.
  - Click the Search IconButton once.
  notes: 'Checker hint: set data-cb-activated on the IconButton root element on click/keyboard activation.'
- id: icon_button-mui-T02
  name: Toggle Mute microphone On
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Turn on “Mute microphone” by toggling the microphone icon button so it shows as On. The task will finish automatically when done.
  ui_copy: |-
    Call controls
    Mute microphone: Off
    [Mic icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Call controls” contains one control row labeled “Mute microphone”. On the right is a single MUI IconButton showing a microphone icon. A status label on the left reads “Mute microphone: Off/On”.

    Component configuration:
    - One IconButton with aria-label="Mute microphone".
    - Toggle semantics: aria-pressed="false|true".
    - Initial state: aria-pressed="false"; status text reads “Off”.

    Feedback:
    - Clicking toggles aria-pressed and updates the status text to “On”.
    - No confirmation step.

    Distractors:
    - None; only this toggle IconButton is 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: Single toggle IconButton with explicit On/Off text feedback; low acquisition and disambiguation demands.
  success_trigger:
    human_readable:
    - The “Mute microphone” IconButton has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Mute microphone IconButton
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Mute microphone remains Off (aria-pressed="false").
  - Toggling On and then toggling back Off.
  expected_interaction_path:
  - Locate the “Mute microphone” row in Call controls.
  - Click the microphone IconButton once to switch to On.
  notes: Prefer aria-pressed as the canonical toggle signal for the checker.
- id: icon_button-mui-T03
  name: Choose Center alignment (icon button group)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (3 buttons acting as single-select group)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: Set Text alignment to “Center” using the alignment icon buttons. The task will finish automatically when done.
  ui_copy: |-
    Text alignment: Left
    [Align left] [Align center] [Align right]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A “Text formatting” card contains a row labeled “Text alignment” with three adjacent MUI IconButtons:
    - Align left
    - Align center
    - Align right

    Component configuration:
    - Total instances: 3 icon buttons.
    - Each IconButton has a descriptive aria-label (“Align left”, “Align center”, “Align right”).
    - Exactly one option is selected at a time using aria-pressed.
    - Initial state: “Align left” is selected (aria-pressed="true" on left).

    Feedback:
    - Clicking an option sets it selected (aria-pressed="true") and clears the others.
    - A small text readout on the row updates (e.g., “Text alignment: Center”).

    Distractors:
    - None; only these three icon buttons are interactive.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small set of three adjacent choices with clear labels and immediate selection feedback.
  success_trigger:
    human_readable:
    - In the alignment group, the “Align center” IconButton has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: center
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Text alignment group
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving alignment on Left or setting it to Right.
  - Selecting multiple options (should not be possible; if it occurs, do not count as success unless Center is the canonical selection).
  expected_interaction_path:
  - Find the Text alignment row.
  - Click the “Align center” IconButton.
  - Verify the readout changes to Center.
  notes: Checker can compute selected_option from aria-pressed across the three IconButtons.
- id: icon_button-mui-T04
  name: Expand Advanced filters (top-right disclosure)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (disclosure with aria-expanded)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Expand the Advanced filters section using the expand icon button. The task will finish automatically when done.
  ui_copy: Advanced filters (Collapsed) [Expand icon button]
  setup_description: |
    Layout: isolated_card with the target anchored at the top-right.

    A card titled “Filters” contains a section header “Advanced filters”. On the far right of that header line (top-right area of the card) there is a single MUI IconButton with an expand-more chevron icon.

    Component configuration:
    - One IconButton with aria-label="Expand advanced filters".
    - State is reflected via aria-expanded="false|true".
    - Initial state: aria-expanded="false"; the header shows a small “Collapsed” badge.

    Feedback:
    - Activating the icon button sets aria-expanded="true" and reveals a content area below. The badge changes to “Expanded”.

    Distractors:
    - The card contains two static filter summary lines (“Status: Any”, “Owner: Anyone”), but there are no other buttons or toggles.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: The disclosure control is small and located in the top-right, requiring accurate acquisition and header scanning in a slightly cluttered card.
  success_trigger:
    human_readable:
    - The expand IconButton has aria-expanded="true" for the Advanced filters section.
    canonical_predicate:
      predicate_type: equals
      target_state:
        expanded: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Advanced filters disclosure IconButton
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The section remains collapsed (aria-expanded="false").
  - Scrolling within the card without expanding the section.
  expected_interaction_path:
  - Locate the “Advanced filters” header near the top-right of the card.
  - Click the expand icon button to open it.
  notes: Use aria-expanded on the IconButton (or its controlled region) as the canonical expanded signal.
- id: icon_button-mui-T05
  name: Match the reference icon (4 IconButtons)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (4 options; visual match)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the icon button that matches the Target icon shown in the reference box. The task will finish automatically when done.
  ui_copy: |-
    Target icon: [reference]
    Options: [4 icon buttons]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Pick the matching icon” shows a Target icon reference box at the top (icon only, no descriptive text). Under it are four MUI IconButtons arranged in a single row with equal spacing.

    Component configuration:
    - Total instances: 4 IconButtons.
    - Each has a generic aria-label (“Option A”, “Option B”, “Option C”, “Option D”).
    - Each option IconButton has hidden data-icon-key; the reference has hidden data-reference-icon-key.
    - Initial state: all options have data-cb-activated="false".

    Feedback:
    - Activating an option sets data-cb-activated="true" on that IconButton and shows a subtle check mark overlay on the button.

    Distractors:
    - None outside the four options.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 2
    justification: Visual comparison among four options increases choice interference; the target is not described in text.
  success_trigger:
    human_readable:
    - Let K be the reference key from the Target icon box. The IconButton whose data-icon-key equals K has data-cb-activated="true".
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_binding: data-reference-icon-key
        match_attribute: data-icon-key
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Option IconButton matching reference icon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Activating an option whose icon does not match the reference.
  - Leaving all options unactivated.
  - Activating multiple options without activating the matching one.
  expected_interaction_path:
  - Compare the Target icon to each of the four option icons.
  - Click the matching IconButton.
  notes: Avoid using visible option labels that describe the icon; keep guidance purely visual while preserving accessibility via generic aria-labels.
- id: icon_button-mui-T06
  name: Open Help popover (IconButton trigger)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (Popover trigger)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Help popover by activating the “Help” icon button. The task will finish automatically when done.
  ui_copy: |-
    Need help? [Help icon button]
    (Click to open help popover)
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Need help?” contains a short sentence and a single MUI IconButton with a question-mark icon. The IconButton acts as the trigger for a small help popover.

    Component configuration:
    - One IconButton with aria-label="Help".
    - The button controls a popover and reflects open/closed state via aria-expanded="false|true".
    - Initial state: aria-expanded="false"; popover is closed.

    Overlay behavior:
    - Activating the IconButton opens a popover anchored to the button with a short help text and a “Got it” label (non-interactive text; no buttons to click).
    - The task does NOT require interacting with the popover content; only opening it matters.

    Feedback:
    - When open, aria-expanded becomes "true" and the IconButton also sets data-cb-overlay-open="true" for robust checking.

    Distractors:
    - None (single control).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires correctly triggering an overlay state (popover open) and interpreting overlay feedback, but still involves only one clearly labeled icon button.
  success_trigger:
    human_readable:
    - The “Help” IconButton indicates the popover is open (aria-expanded="true" and/or data-cb-overlay-open="true").
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Help popover IconButton
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The popover remains closed (aria-expanded="false").
  - Clicking inside the card text but not activating the IconButton.
  - Opening and then closing the popover (ending closed).
  expected_interaction_path:
  - Locate the Help IconButton in the Need help? card.
  - Click the IconButton to open the popover.
  - Stop once the popover is open.
  notes: Checker should treat aria-expanded="true" on the trigger as sufficient; data-cb-overlay-open can be a fallback if needed.
- id: icon_button-mui-T07
  name: Scroll to Diagnostics info icon (dark settings panel)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (info icon)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the dark-themed Settings panel, scroll to the Diagnostics section and click the “Diagnostics info” icon button. The task will finish automatically when done.
  ui_copy: |-
    Settings (dark)
    …(multiple sections)…
    Diagnostics  [Info icon button]
  setup_description: |
    Layout: settings_panel centered in the viewport; dark theme enabled.

    A tall settings panel titled “Settings” contains multiple sections stacked vertically (Account, Privacy, Notifications, Diagnostics), requiring scrolling within the page to reach the lower sections. In the “Diagnostics” header line there is a small MUI IconButton with an info icon and a visible helper label “Info” next to it.

    Component configuration:
    - One target IconButton with aria-label="Diagnostics info".
    - Initial state: data-cb-activated="false".
    - The IconButton is in default size, but in a dark theme the icon contrast is slightly lower than in light theme.

    Clutter (medium):
    - Several sections contain non-interactive text, toggles shown as disabled (non-interactive), and status badges. No other icon buttons exist.

    Feedback:
    - Clicking the IconButton sets data-cb-activated="true" and reveals an inline text line “Diagnostics info opened” under the header (inline text not required for success).
  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: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 4
    justification: Requires scrolling to a specific section in a moderately cluttered panel and locating a small icon target in dark mode.
  success_trigger:
    human_readable:
    - The “Diagnostics info” IconButton has data-cb-activated="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Diagnostics info IconButton
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not reaching the Diagnostics section (button never activated).
  - Clicking other elements in Settings without activating the Diagnostics info IconButton.
  expected_interaction_path:
  - Scroll down until the Diagnostics section header is visible.
  - Click the small info IconButton in that header.
  notes: Keep non-target controls disabled/non-interactive to preserve single-component success dependence.
- id: icon_button-mui-T08
  name: Star Project Beta (3 similar instances)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (star toggle) in a list'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: In the Projects list, turn on the star for “Project Beta” using its star icon button. The task will finish automatically when done.
  ui_copy: |-
    Projects
    Project Alpha [Star]
    Project Beta [Star]
    Project Gamma [Star]
  setup_description: |
    Layout: form_section centered in the viewport.

    A section titled “Projects” lists three project rows (Alpha, Beta, Gamma). Each row ends with a MUI IconButton showing a star outline icon. The project name is visible as text at the start of the row.

    Component configuration:
    - Total instances: 3 star IconButtons (one per row).
    - Each is a toggle with aria-pressed="false|true" and aria-label formatted as “Star Project Alpha/Beta/Gamma”.
    - Initial state: all are Off (aria-pressed="false").

    Feedback:
    - Clicking a row’s star toggles it On (aria-pressed="true") and the star icon becomes filled.
    - No confirmation step.

    Clutter (low):
    - Each row also contains a small non-interactive status chip (e.g., “Active”), but there are no other icon buttons.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    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: Multiple identical icon buttons in a list require correct row association; the star state is primarily indicated by icon fill and aria-pressed.
  success_trigger:
    human_readable:
    - The star IconButton for the row labeled “Project Beta” has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Project Beta → Star IconButton'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Starring Project Alpha or Project Gamma instead of Beta.
  - Leaving Project Beta unstarred (aria-pressed="false").
  - Turning Beta On and then Off again.
  expected_interaction_path:
  - Locate the row labeled “Project Beta”.
  - Click the star IconButton at the end of that row.
  - Verify the star is On for Beta.
  notes: Checker should identify the correct instance by the visible row label text and then read aria-pressed on the star IconButton in that row.
- id: icon_button-mui-T09
  name: Select Compact density (4 small icon buttons)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (4 buttons acting as single-select density group)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: Set Density to “Compact” using the density icon buttons. The task will finish automatically when done.
  ui_copy: |-
    Density: Comfortable
    [Comfortable] [Compact] [Condensed] [Auto]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Table density” contains a single row labeled “Density” with four small MUI IconButtons in a tight horizontal group. Each option is represented by an icon (varying line spacing) and also has an accessible label.

    Component configuration:
    - Spacing: compact; Scale: small (small hit targets, minimal gaps).
    - Total instances: 4 IconButtons.
    - Each IconButton has aria-label: “Density: Comfortable”, “Density: Compact”, “Density: Condensed”, “Density: Auto”.
    - Exactly one is selected at a time using aria-pressed.
    - Initial state: Comfortable selected.

    Feedback:
    - Selecting an option updates a small readout text “Density: …” on the left.
    - No confirmation step.

    Distractors:
    - None; only the 4 density icon buttons are interactive.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 4
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 5
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Small, tightly packed icon buttons increase acquisition difficulty; four options introduce moderate choice interference.
  success_trigger:
    human_readable:
    - 'In the Density group, the “Density: Compact” IconButton has aria-pressed="true".'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: compact
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Density group
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Comfortable, Condensed, or Auto instead of Compact.
  - Accidentally toggling Compact on and then switching away from it.
  expected_interaction_path:
  - Find the Density row.
  - 'Click the small IconButton labeled “Density: Compact”.'
  - 'Confirm the readout shows “Density: Compact”.'
  notes: For robustness, ensure each IconButton’s accessible label is present even if the visible label is not.
- id: icon_button-mui-T10
  name: Lock the API Key row (table cell IconButton)
  canonical_type: icon_button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: IconButton (lock toggle) inside table cells'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Secrets table, lock the row labeled “API Key” using its lock icon button. The task will finish automatically when done.
  ui_copy: |-
    Secrets table
    API Key … [Lock icon button]
    Webhook Secret … [Lock]
    DB Password … [Lock]
    SMTP Token … [Lock]
  setup_description: |
    Layout: table_cell centered in the viewport.

    A compact table titled “Secrets” has four rows:
    - API Key
    - Webhook Secret
    - DB Password
    - SMTP Token

    In the rightmost column, each row contains a MUI IconButton with a lock icon. The row label is plain text in the first column.

    Component configuration:
    - Total instances: 4 lock IconButtons (one per row).
    - Each lock IconButton is a toggle using aria-pressed and aria-label “Lock API Key”, “Lock Webhook Secret”, etc.
    - Initial state: all unlocked (aria-pressed="false").

    Clutter (high):
    - Each row also shows masked values (•••••), a last-rotated date, and subtle divider lines, increasing visual density.

    Feedback:
    - Clicking the lock IconButton sets aria-pressed="true" and changes a small inline label in that row from “Unlocked” to “Locked”.
    - No confirmation step.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 4
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 5
    justification: High disambiguation due to multiple identical controls embedded in a dense table; requires correct row association and accurate clicking.
  success_trigger:
    human_readable:
    - The lock IconButton in the row labeled “API Key” has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: API Key → Lock IconButton'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Locking any row other than API Key.
  - Leaving API Key unlocked (aria-pressed="false").
  - Locking API Key then unlocking it again.
  expected_interaction_path:
  - Scan the first column to find the “API Key” row.
  - Click the lock IconButton in that row.
  - Verify the row indicates Locked.
  notes: The checker should locate the row by its visible label text and read aria-pressed from the contained IconButton.
- id: icon_button-mantine-T01
  name: Activate Settings ActionIcon
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the icon button labeled “Settings” in the Preferences card. The task will finish automatically when done.
  ui_copy: |-
    Preferences
    Settings [gear icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Preferences” shows one Mantine ActionIcon with a gear icon. A visible text label “Settings” appears next to the ActionIcon for easy identification.

    Component configuration:
    - One Mantine ActionIcon (default size) rendered as a regular <button>.
    - Accessibility: the ActionIcon includes aria-label="Settings" (and optionally title="Settings").
    - Initial state: data-cb-activated="false".

    Feedback:
    - On activation, the ActionIcon sets data-cb-activated="true" and an inline status text “Settings opened” appears.

    Distractors:
    - None; single control in a clean 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: 1
      disambiguation_load: 1
    justification: Single large ActionIcon with clear label and immediate feedback; no distractors.
  success_trigger:
    human_readable:
    - The ActionIcon with aria-label “Settings” has data-cb-activated="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Settings ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The ActionIcon is not activated (data-cb-activated remains false).
  - Only hovering/focusing without activation.
  expected_interaction_path:
  - Locate the Settings ActionIcon in the Preferences card.
  - Click it once.
  notes: 'Checker hint: write activation state to a stable data-cb-activated attribute on the <button>.'
- id: icon_button-mantine-T02
  name: Toggle Like On (heart ActionIcon)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Turn on Like by toggling the heart icon button so it shows as On. The task will finish automatically when done.
  ui_copy: |-
    Post: “Release notes”
    Like: Off
    [Heart icon button]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Post” displays the title “Release notes”. On the right side of a row labeled “Like” there is a Mantine ActionIcon showing a heart outline icon. A status text reads “Like: Off/On”.

    Component configuration:
    - One ActionIcon with aria-label="Like".
    - Toggle semantics: aria-pressed="false|true".
    - Initial state: aria-pressed="false"; status shows Off.

    Feedback:
    - Clicking toggles aria-pressed and updates the status text to “On”; the heart icon becomes filled.
    - No Apply/OK.

    Distractors:
    - None.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single toggle ActionIcon with explicit text feedback; minimal acquisition and choice complexity.
  success_trigger:
    human_readable:
    - The Like ActionIcon has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Like ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Like remains Off (aria-pressed="false").
  - Toggling On and then toggling back Off.
  expected_interaction_path:
  - Find the Like row.
  - Click the heart ActionIcon once to switch it On.
  notes: If you visually indicate the On state via color, also keep aria-pressed in sync so the checker can remain semantic.
- id: icon_button-mantine-T03
  name: Expand FAQ answer (chevron ActionIcon)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (disclosure, aria-expanded)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Expand the FAQ answer using the chevron icon button so it shows as Expanded. The task will finish automatically when done.
  ui_copy: 'FAQ: “How do I reset my password?” (Collapsed) [Chevron icon button]'
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A single FAQ card shows one question: “How do I reset my password?”. On the far right of the question header is a Mantine ActionIcon with a chevron-down icon.

    Component configuration:
    - One ActionIcon with aria-label="Expand FAQ answer".
    - State reflected via aria-expanded="false|true".
    - Initial state: aria-expanded="false" and a small “Collapsed” marker is shown.

    Feedback:
    - Activating the chevron ActionIcon sets aria-expanded="true" and reveals the answer text. The marker changes to “Expanded”.

    Distractors:
    - None; only this disclosure ActionIcon is interactive.
  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: Single disclosure control with clear expanded/collapsed state and no competing elements.
  success_trigger:
    human_readable:
    - The FAQ disclosure ActionIcon has aria-expanded="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        expanded: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: FAQ disclosure ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The FAQ remains collapsed (aria-expanded="false").
  - Only scrolling or selecting text without activating the disclosure icon.
  expected_interaction_path:
  - Locate the FAQ question header.
  - Click the chevron ActionIcon on the right to expand it.
  notes: Use aria-expanded as the canonical state for the disclosure ActionIcon.
- id: icon_button-mantine-T04
  name: Set Theme mode to Dark (ActionIcon group)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (3 buttons acting as single-select group)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In Appearance settings, set Theme mode to “Dark”. The task will finish automatically when done.
  ui_copy: |-
    Appearance
    Theme mode: Light
    [Sun] [Moon] [Auto]
  setup_description: |
    Layout: settings_panel centered in the viewport.

    An “Appearance” settings panel includes a row labeled “Theme mode” with three Mantine ActionIcons arranged horizontally:
    - Light (sun icon)
    - Dark (moon icon)
    - Auto (monitor/system icon)

    Component configuration:
    - Total instances: 3 ActionIcons.
    - Each ActionIcon has aria-label “Theme: Light”, “Theme: Dark”, “Theme: Auto”.
    - Exactly one is selected at a time using aria-pressed.
    - Initial state: Light selected (aria-pressed="true" on Light). A readout text shows “Theme mode: Light”.

    Feedback:
    - Selecting an option updates aria-pressed across the group and updates the readout text.
    - No confirmation step.

    Distractors (low):
    - The panel also contains two static rows (“Accent color”, “Text size”) that are non-interactive for this task.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 3
    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: 2
    justification: Requires selecting the correct option in a small icon-only group within a settings context; selection feedback is clear but targets are adjacent.
  success_trigger:
    human_readable:
    - 'In the Theme mode group, the “Theme: Dark” ActionIcon has aria-pressed="true".'
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_option: dark
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Theme mode group
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving Theme mode on Light or selecting Auto instead of Dark.
  - Changing any other (non-interactive) rows does not count as success.
  expected_interaction_path:
  - Locate the Theme mode row in Appearance settings.
  - 'Click the moon ActionIcon (Theme: Dark).'
  - 'Verify the readout shows “Theme mode: Dark”.'
  notes: Checker can compute selected_option from aria-pressed across the three ActionIcons.
- id: icon_button-mantine-T05
  name: Match target icon (ActionIcon) near top-left
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (4 options; visual match)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the icon button that matches the Target icon shown in the reference box. The task will finish automatically when done.
  ui_copy: |-
    Target icon: [reference]
    Options: [4 ActionIcons]
  setup_description: |
    Layout: isolated_card placed near the top-left of the viewport.

    A small card titled “Icon match” is positioned near the top-left. The card shows a Target icon reference box (icon only) and four Mantine ActionIcons arranged in a 2×2 grid beneath it.

    Component configuration:
    - Total instances: 4 ActionIcons.
    - Each ActionIcon has a generic aria-label (“Option 1–4”), plus hidden data-icon-key.
    - The reference box has hidden data-reference-icon-key.
    - Initial state: all options have data-cb-activated="false".

    Feedback:
    - Activating an option sets data-cb-activated="true" and adds a subtle outline around the button.

    Distractors:
    - None beyond the four options.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 4
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 2
    justification: Visual matching among multiple icons plus non-central placement increases acquisition and perceptual load.
  success_trigger:
    human_readable:
    - Let K be the target reference key. The ActionIcon with data-icon-key=K has data-cb-activated="true".
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_binding: data-reference-icon-key
        match_attribute: data-icon-key
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Option ActionIcon matching reference icon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Activating a non-matching option.
  - Leaving all options unactivated.
  - Activating multiple options without the matching one.
  expected_interaction_path:
  - Compare the Target icon to the four candidate icons.
  - Click the matching ActionIcon.
  notes: Use hidden keys for matching to keep the visible prompt purely visual, while enabling a deterministic checker.
- id: icon_button-mantine-T06
  name: Reset sort state to None (cycle ActionIcon)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (cycles sort mode)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Sort order back to “None” using the sort icon button. The task will finish automatically when done.
  ui_copy: |-
    Sort order: A→Z
    [Sort ActionIcon]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Sorting” contains one row labeled “Sort order”. The current sort order is displayed as text (“None”, “A→Z”, or “Z→A”). On the right is a Mantine ActionIcon showing a sort icon.

    Component configuration:
    - One ActionIcon with aria-label="Change sort order".
    - Clicking cycles through: None → A→Z → Z→A → None …
    - The ActionIcon stores its canonical mode as data-cb-mode ("none" | "az" | "za").
    - Initial state: “A→Z” (data-cb-mode="az").

    Feedback:
    - The displayed text updates instantly after each click.
    - No confirmation step.

    Distractors:
    - None.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 1
      disambiguation_load: 1
    justification: Requires iterating through a cyclic state machine to reach the default; feedback is clear but may require multiple actions.
  success_trigger:
    human_readable:
    - The sort ActionIcon’s canonical mode equals “none” (data-cb-mode="none").
    - 'The visible label reads “Sort order: None”.'
    canonical_predicate:
      predicate_type: equals
      target_state:
        mode: none
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Sort order ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping at A→Z or Z→A instead of None.
  - Clicking the ActionIcon at least once but not reaching the None state.
  expected_interaction_path:
  - Locate the Sort order row.
  - Click the sort ActionIcon until the displayed order is “None”.
  notes: Prefer an explicit data-cb-mode attribute for checking rather than trying to infer state from icon rotation or styling.
- id: icon_button-mantine-T07
  name: Bookmark the Secondary item (two instances)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (bookmark toggle) with two labeled instances'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Bookmark the Secondary item by turning on its bookmark icon button. The task will finish automatically when done.
  ui_copy: |-
    Bookmarks
    Primary item [Bookmark]
    Secondary item [Bookmark]
  setup_description: |
    Layout: isolated_card centered in the viewport.

    A card titled “Bookmarks” lists two items stacked vertically:
    - “Primary item”
    - “Secondary item”

    Each item row ends with a Mantine ActionIcon showing a bookmark icon.

    Component configuration:
    - Total instances: 2 bookmark ActionIcons.
    - Each is a toggle using aria-pressed and has aria-label “Bookmark Primary item” / “Bookmark Secondary item”.
    - Initial state: both unbookmarked (aria-pressed="false").

    Clutter (low):
    - Each row also shows a short description line under the title (non-interactive), which adds scanning load but does not add new controls.

    Feedback:
    - When bookmarked, the ActionIcon becomes aria-pressed="true" and the row shows a small “Saved” tag.
    - No confirmation step.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 5
    justification: Two nearly identical icon buttons require correct instance selection based on nearby labels; mis-clicking the wrong row is a common failure mode.
  success_trigger:
    human_readable:
    - The bookmark ActionIcon for the row labeled “Secondary item” has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Secondary item → Bookmark ActionIcon'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Bookmarking the Primary item instead of the Secondary item.
  - Leaving Secondary unbookmarked (aria-pressed="false").
  - Bookmarking Secondary and then unbookmarking it.
  expected_interaction_path:
  - Locate the row labeled “Secondary item”.
  - Click the bookmark ActionIcon at the end of that row.
  - Verify the Secondary row shows as saved.
  notes: If the UI uses only color to indicate the pressed state, ensure aria-pressed is always updated for semantic checking.
- id: icon_button-mantine-T08
  name: Open info popover (dark + small ActionIcon)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (popover trigger)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Info popover by activating the “Info” icon button. The task will finish automatically when done.
  ui_copy: |-
    Info (dark)
    [Info icon button] (opens popover)
  setup_description: |
    Layout: isolated_card centered in the viewport; dark theme enabled.

    A dark-themed card titled “Info” contains a short paragraph and a single small Mantine ActionIcon with an “i” info icon. The ActionIcon toggles a small popover.

    Component configuration:
    - One ActionIcon (scale: small) with aria-label="Info".
    - The ActionIcon reflects open state via aria-expanded and/or data-cb-overlay-open.
    - Initial state: aria-expanded="false" and data-cb-overlay-open="false".

    Overlay behavior:
    - Activating the ActionIcon opens a popover anchored to the button with a short explanatory message (no interactive controls inside the popover).

    Feedback:
    - When open, the ActionIcon sets aria-expanded="true" and data-cb-overlay-open="true". Visual feedback is subtle due to dark theme.

    Distractors:
    - None.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Small target in dark mode plus the need to reach a specific overlay-open state increases acquisition and feedback complexity.
  success_trigger:
    human_readable:
    - The Info ActionIcon indicates its popover is open (aria-expanded="true" and/or data-cb-overlay-open="true").
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_open: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Info ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The popover remains closed (aria-expanded="false").
  - Opening and then closing the popover (ending closed).
  expected_interaction_path:
  - Locate the small Info ActionIcon in the card.
  - Click it to open the popover.
  - Stop once the popover is open.
  notes: Use aria-expanded as the primary semantic signal for popover open state; data-cb-overlay-open can be used for redundancy.
- id: icon_button-mantine-T09
  name: Scroll to Sync section and click Retry ActionIcon (dashboard clutter)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (retry/refresh)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: On the Status dashboard, scroll to the Sync section and click the “Retry sync” icon button. The task will finish automatically when done.
  ui_copy: |-
    Status dashboard
    …(multiple cards)…
    Sync
    Retry sync [refresh icon button]
  setup_description: |
    Layout: dashboard centered in the viewport.

    The page is a dashboard titled “Status” with multiple metric cards and sections stacked vertically, requiring scrolling. One section lower on the page is titled “Sync”. In the Sync header area there is a Mantine ActionIcon with a refresh/retry icon and a visible label “Retry sync”.

    Component configuration:
    - One target ActionIcon with aria-label="Retry sync".
    - Initial state: data-cb-activated="false".

    Clutter (high):
    - The dashboard includes multiple cards with charts, numbers, and badges (all non-interactive for this task), increasing visual noise and making the target harder to locate.

    Feedback:
    - Clicking the Retry sync ActionIcon sets data-cb-activated="true" and briefly shows a “Retry started” status line (not required for success).
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 5
    justification: High clutter and required scrolling dominate difficulty; the target itself is straightforward once located.
  success_trigger:
    human_readable:
    - The “Retry sync” ActionIcon has data-cb-activated="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        activated: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: Retry sync ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not scrolling to the Sync section, leaving the ActionIcon unactivated.
  - Clicking other dashboard cards or text without activating Retry sync.
  expected_interaction_path:
  - Scroll down the Status dashboard until the Sync section is visible.
  - Click the “Retry sync” ActionIcon.
  notes: Keep all other UI elements non-interactive for this task to preserve component-level focus (only the Retry ActionIcon affects success).
- id: icon_button-mantine-T10
  name: Archive Report — Q4 (table row ActionIcon)
  canonical_type: icon_button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: ActionIcon (archive toggle) inside table cells'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Reports table, archive “Report — Q4” using its archive icon button. The task will finish automatically when done.
  ui_copy: |-
    Reports table
    Report — Q3 … [Archive]
    Report — Q4 … [Archive]
    Report — Q5 … [Archive]
    Report — Q6 … [Archive]
  setup_description: |
    Layout: table_cell centered in the viewport.

    A table titled “Reports” contains four rows:
    - Report — Q3
    - Report — Q4
    - Report — Q5
    - Report — Q6

    In the last column of each row there is a Mantine ActionIcon with an archive box icon.

    Component configuration:
    - Total instances: 4 archive ActionIcons.
    - Each is a toggle with aria-pressed and aria-label “Archive Report — Q3/Q4/Q5/Q6”.
    - Initial state: all unarchived (aria-pressed="false").

    Clutter (high):
    - Each row also shows a “Last updated” timestamp and an owner name, making the table visually dense.

    Feedback:
    - When archived, the ActionIcon becomes aria-pressed="true" and the row shows a small “Archived” pill.
    - No confirmation step.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 4
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 5
    justification: Dense table with multiple identical ActionIcons requires careful row identification and accurate selection of the correct instance.
  success_trigger:
    human_readable:
    - The archive ActionIcon in the row labeled “Report — Q4” has aria-pressed="true".
    canonical_predicate:
      predicate_type: equals
      target_state:
        pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: 'Row: Report — Q4 → Archive ActionIcon'
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Archiving any report other than Q4.
  - Leaving Report — Q4 unarchived (aria-pressed="false").
  - Archiving Q4 and then unarchiving it again.
  expected_interaction_path:
  - Find the table row labeled “Report — Q4”.
  - Click the archive ActionIcon in that row.
  - Verify the row indicates Archived.
  notes: Checker should locate the row by visible report title and then inspect aria-pressed on the contained ActionIcon for a robust, library-agnostic success condition.