tasks/v1/button.yaml

- id: button-antd-T01
  name: Generate report (primary button click)
  canonical_type: button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the “Generate report” button in the Report card. The task will finish automatically when done.
  ui_copy: 'Goal: Click the “Generate report” button in the Report card.'
  setup_description: 'Baseline isolated card in the center of the viewport titled “Report”.

    The card contains a short paragraph (“Create a one-time report from the current data.”) and a single Ant Design primary Button labeled “Generate report”.

    The button is enabled, medium size (default), and shows no loading spinner initially.

    When clicked, the UI immediately shows a small toast message (“Report queued”) and the button label changes to “Queued” (still the same button instance).

    No other Buttons are present on the page; there are no modals, drawers, or overlays involved.

    '
  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: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single large labeled button in an uncluttered card; success is triggered by one click with immediate visible feedback.
  success_trigger:
    human_readable:
    - The “Generate report” button action is invoked exactly once.
    - The invocation must come from the only Button on the page (the Report card action).
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: button_clicked
        button_id: antd-btn-generate-report
        click_count: 1
      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:
  - Clicking anywhere else on the page without clicking “Generate report”.
  - Clicking the button more than once (click_count ≠ 1).
  - Triggering keyboard focus without activating the button (no click/activation event recorded).
  expected_interaction_path: Click the “Generate report” button once → observe toast/label change.
  notes: "Instrumentation: assign data-testid='antd-btn-generate-report' and log click_count for that id."
- id: button-antd-T02
  name: Show details popover (open overlay)
  canonical_type: button
  implementation_source: antd
  implementation_variant: popover_trigger
  implementation_component: 'AntD: Button + Popover'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the details popover by clicking the “Show details” button. The task will finish automatically when done.
  ui_copy: 'Goal: Open the details popover by clicking “Show details”.'
  setup_description: 'Baseline isolated card centered on the page titled “Plan summary”.

    Inside the card there is a single Ant Design default Button labeled “Show details”.

    The button triggers an AntD Popover on click (not hover). The popover appears directly below the button and contains a short bulleted list (3 items) describing the plan.

    Initial state: the popover is closed and no overlay is visible.

    There are no other Buttons on the page and no other overlays that could appear.

    '
  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: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: One labeled trigger button; the only extra step is that the desired state is an opened popover overlay.
  success_trigger:
    human_readable:
    - The details popover is open (visible) and anchored to the “Show details” button.
    - The open state must be the result of activating the “Show details” button.
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: antd-popover-plan-details
        is_open: true
        trigger_button_id: antd-btn-show-details
      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 popover remains closed.
  - A different overlay (if any) is open instead of the plan details popover.
  - The button receives focus but is not activated (no open event).
  expected_interaction_path: Click “Show details” → verify popover opens below the button.
  notes: Checker can read Popover open state (e.g., data-open='true') for overlay_id='antd-popover-plan-details'.
- id: button-antd-T03
  name: Unsaved changes dialog (confirm discard)
  canonical_type: button
  implementation_source: antd
  implementation_variant: modal_footer_buttons
  implementation_component: 'AntD: Modal (open) + Button (footer actions)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: In the open “Unsaved changes” dialog, click the “Discard changes” button (not Cancel). The task will finish automatically when done.
  ui_copy: 'Dialog: Unsaved changes. Choose: Cancel or Discard changes.'
  setup_description: 'The page loads with an Ant Design Modal already open (modal_flow layout).

    Modal title: “Unsaved changes”. Modal body text explains that leaving now will lose edits.

    In the footer there are exactly two AntD Buttons:

    1) “Cancel” (default button) on the left

    2) “Discard changes” (primary + danger styling) on the right

    Initial state: no selection has been made; the modal is awaiting a choice.

    Clicking one of the footer buttons immediately closes the modal and shows a small inline status line behind it (“Choice recorded: …”).

    No other Buttons exist behind the modal.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Only two clearly labeled modal buttons; the main challenge is selecting the correct instance (Discard vs Cancel).
  success_trigger:
    human_readable:
    - The modal choice state equals “discard”.
    - The recorded choice must come from clicking the “Discard changes” button in the modal footer.
    canonical_predicate:
      predicate_type: equals
      target_state:
        modal_id: antd-modal-unsaved
        choice: discard
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Discard changes
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Cancel” instead of “Discard changes”.
  - Closing the modal via the close (X) icon or clicking the mask (no choice recorded).
  - Making no selection (modal remains open and choice is unset).
  expected_interaction_path: Identify the modal footer → click “Discard changes”.
  notes: 'Instrumentation: expose modal choice state in a test store; tag buttons with data-testid (e.g., antd-btn-discard, antd-btn-cancel).'
- id: button-antd-T04
  name: Reset filters (form section button)
  canonical_type: button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: In the Filters section, click the “Reset filters” button. The task will finish automatically when done.
  ui_copy: 'Filters: Use Reset filters to clear selections.'
  setup_description: 'The page shows a form_section labeled “Filters” with several non-button controls (a text input for “Keyword”, a Select for “Status”, and two Checkboxes).

    At the bottom of the section there are two Ant Design Buttons placed side-by-side:

    • “Reset filters” (default button)

    • “Apply filters” (primary button)

    Initial state: the form shows pre-filled values (e.g., Status = “Open”, a checkbox checked), indicating that there is something to reset.

    Clicking “Reset filters” clears the form controls back to their defaults and shows a small inline message under the buttons: “Filters reset”.

    Clicking “Apply filters” would show a different message (“Filters applied”) but is not the goal.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Two labeled buttons in a simple form; success depends on choosing the correct button among Reset vs Apply.
  success_trigger:
    human_readable:
    - The Filters section reports the reset action as completed.
    - The completion must be triggered by activating the “Reset filters” button (not Apply).
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: reset_filters
        invoked: true
        source_button_id: antd-btn-reset-filters
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Reset filters
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Apply filters” instead of “Reset filters”.
  - Clearing a single input manually without using the reset button (no reset event).
  - Reset triggered more than once (reset_count ≠ 1), if the page tracks count.
  expected_interaction_path: Locate the Filters section → click “Reset filters” → observe “Filters reset”.
  notes: 'Checker: listen for reset_filters event or read a data-state flag (e.g., data-filters-reset=''true'').'
- id: button-antd-T05
  name: Save settings at bottom (scroll to find)
  canonical_type: button
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Button'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll the Settings panel until you find the “Save changes” button, then click it. The task will finish automatically when done.
  ui_copy: 'Settings panel: scroll to the bottom to Save changes.'
  setup_description: 'The UI is a settings_panel layout: a tall card with its own internal scroll region (the page itself does not need to scroll).

    The panel contains multiple setting rows with toggles and helper text; none of these rows contain Buttons.

    The only Button in the entire panel is an Ant Design primary Button labeled “Save changes” located in a sticky footer area that becomes visible only near the bottom of the panel.

    Initial state: the panel is scrolled to the top, so the footer and the “Save changes” button are not visible.

    When “Save changes” is clicked, the button briefly shows a loading spinner for ~500ms and then changes to a disabled “Saved” state.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires scrolling within a panel to reveal the only button; feedback includes a short loading state before completion.
  success_trigger:
    human_readable:
    - The “Save changes” action is invoked once from the Settings panel footer button.
    - After invocation, the button enters the Saved state (e.g., disabled with label “Saved”).
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: save_settings
        invoked: true
        source_button_id: antd-btn-save-changes
        click_count: 1
      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:
  - Stopping after scrolling without clicking the button.
  - Clicking the button multiple times (e.g., during loading) so click_count ≠ 1.
  - Scrolling the outer page instead of the settings panel scroll region so the button is never revealed.
  expected_interaction_path: Scroll inside the settings panel → reach footer → click “Save changes” → wait for Saved state.
  notes: 'Instrumentation: internal scroll container should be focusable; button has data-testid=''antd-btn-save-changes''.'
- id: button-antd-T06
  name: Match the dashed button style (visual reference)
  canonical_type: button
  implementation_source: antd
  implementation_variant: type_variants
  implementation_component: 'AntD: Button (type variants)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the button that matches the Target sample style shown in the card (same look and emphasis). The task will finish automatically when done.
  ui_copy: 'Target sample: click the matching button below.'
  setup_description: 'Centered isolated card titled “Button style matcher”.

    At the top-right of the card there is a small “Target sample” swatch that visually renders an Ant Design dashed button (outlined with a dashed border) with no special color emphasis.

    Below the sample, four AntD Buttons are displayed in a single row, all enabled and same size:

    • “Primary” (type=primary)

    • “Default” (type=default)

    • “Dashed” (type=dashed)

    • “Link” (type=link)

    Initial state: none of the buttons have been clicked; clicking any button records the selection and shows “Selected: <label>” under the row.

    Only one selection is needed; there are no additional confirmation steps.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: visual
    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: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Requires matching a visual style across several similar buttons and selecting the correct instance among four options.
  success_trigger:
    human_readable:
    - The clicked button is the one that matches the rendered Target sample style (dashed type).
    - The recorded selection equals the button labeled “Dashed”.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: antd-target-dashed
        selected_button_id: antd-btn-dashed
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Dashed
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Primary”, “Default”, or “Link” instead of the dashed-style button.
  - Selecting the correct label but via a different instance (if the page duplicates labels in tooltips).
  - No selection recorded (e.g., focusing but not activating).
  expected_interaction_path: Look at the Target sample → compare button styles → click the matching button (“Dashed”).
  notes: Checker can map reference_id to a specific button testid; maintain stable IDs for each variant.
- id: button-antd-T07
  name: Open More actions menu (small icon button in toolbar)
  canonical_type: button
  implementation_source: antd
  implementation_variant: icon_only_toolbar
  implementation_component: 'AntD: Button (icon-only) + Dropdown'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: In the top-right toolbar, click the three-dots “More actions” button to open its menu. The task will finish automatically when done.
  ui_copy: 'Toolbar: Open the More actions menu.'
  setup_description: 'Dashboard-style header toolbar anchored near the top-right of the viewport (placement=top_right).

    Spacing is compact and the toolbar controls are small (scale=small).

    The toolbar contains exactly two icon-only AntD Buttons with tooltips:

    • A “Refresh” button (circular icon)

    • A “More actions” button (vertical three-dots icon)

    Clicking “More actions” opens an AntD Dropdown menu directly under the button (the menu contains items but selecting them is not required).

    Initial state: no dropdown menu is visible.

    Hovering shows tooltips, but the menu only opens on click.

    '
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard
    placement: top_right
    scale: small
    instances: 2
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Small icon-only targets in a compact toolbar require accurate acquisition and choosing the correct icon among two similar buttons.
  success_trigger:
    human_readable:
    - The “More actions” dropdown menu is open (visible).
    - The open menu must be triggered by activating the three-dots button (not Refresh).
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: antd-dropdown-more-actions
        is_open: true
        trigger_button_id: antd-btn-more-actions
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: More actions
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opening no menu (overlay remains closed).
  - Clicking Refresh or any non-target area.
  - Showing a tooltip only (hover) without opening the dropdown menu.
  expected_interaction_path: Move to the top-right toolbar → click the three-dots icon → menu appears.
  notes: 'Instrumentation: set data-testid on both icon buttons; dropdown root uses data-overlay-id=''antd-dropdown-more-actions''.'
- id: button-antd-T08
  name: Download from table row (dense table cell icon button)
  canonical_type: button
  implementation_source: antd
  implementation_variant: icon_only_table
  implementation_component: 'AntD: Button (icon-only) in Table'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Downloads table, click the download icon button in the row labeled “Project Aurora”. The task will finish automatically when done.
  ui_copy: 'Downloads table: Download the file for Project Aurora.'
  setup_description: 'A compact table_cell layout with dark theme enabled.

    The table has three rows with left-aligned project names: “Project Aurora”, “Project Borealis”, and “Project Cirrus”.

    The rightmost column is an Actions column that contains exactly one small icon-only AntD Button per row (a downward arrow download icon).

    Spacing is compact and buttons are rendered at small size, making the clickable area tight.

    Initial state: no row has been downloaded; no confirmation dialogs appear.

    Clicking a row’s download button triggers an inline status chip in that row (“Downloaded”) and records which row action was invoked.

    There are no other Buttons outside the table.

    '
  scene_context:
    theme: dark
    spacing: compact
    layout: table_cell
    placement: center
    scale: small
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Small icon-only buttons inside a compact dark table increase acquisition difficulty and require correct row-to-action mapping among multiple similar instances.
  success_trigger:
    human_readable:
    - The download action is invoked for the row with key/name “Project Aurora”.
    - The invoked action must come from the download button in that same row.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: table_row_action
        table_id: antd-downloads-table
        row_key: Project Aurora
        action: download
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Project Aurora row download button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking the download button in a different row (Borealis or Cirrus).
  - Clicking the row text itself (no button action event).
  - Activating the correct row more than once if the checker expects a single invocation (download_count ≠ 1).
  expected_interaction_path: Scan left column for “Project Aurora” → move to its Actions cell → click the download icon button.
  notes: 'Checker: table exposes stable row_key; each row action button emits {row_key, action} to a log.'
- id: button-antd-T09
  name: Enable Do Not Disturb (toggle-style button)
  canonical_type: button
  implementation_source: antd
  implementation_variant: toggle_style
  implementation_component: 'AntD: Button (stateful toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Turn on “Do Not Disturb” by clicking its button until it appears pressed (ON). The task will finish automatically when done.
  ui_copy: 'Do Not Disturb: OFF → click to turn ON.'
  setup_description: 'An isolated notification card anchored near the bottom-left of the viewport (placement=bottom_left).

    The card contains exactly two Ant Design Buttons:

    • “Do Not Disturb” (toggle-style button). It switches between OFF and ON on each click and exposes aria-pressed=true when ON.

    • “Send test notification” (a regular primary button) which does not toggle.

    Initial state: Do Not Disturb is OFF (aria-pressed=false) and visually appears as a default button.

    When ON, the Do Not Disturb button changes to a highlighted style and a small status line under it reads “DND is ON”.

    There are no modals or dropdowns; the only state change needed is the toggle state of the Do Not Disturb button.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Requires recognizing and achieving a specific toggle state (aria-pressed=true) while avoiding a nearby distractor button.
  success_trigger:
    human_readable:
    - The “Do Not Disturb” button has toggle state ON (aria-pressed=true).
    - The correct button instance is the one labeled “Do Not Disturb”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        button_id: antd-btn-dnd-toggle
        aria_pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Do Not Disturb
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving Do Not Disturb OFF (aria-pressed=false).
  - Clicking “Send test notification” instead of toggling DND.
  - Toggling Do Not Disturb ON and then OFF again (final aria-pressed=false).
  expected_interaction_path: Locate “Do Not Disturb” → click until it shows ON/pressed → stop when ON.
  notes: 'Instrumentation: bind aria-pressed on the toggle button; expose button_id=''antd-btn-dnd-toggle''.'
- id: button-antd-T10
  name: Confirm destructive action in Popconfirm (Yes, delete)
  canonical_type: button
  implementation_source: antd
  implementation_variant: popconfirm
  implementation_component: 'AntD: Popconfirm + Button'
  task_template: confirm_cancel
  secondary_template: open_overlay
  browsergym_goal: Delete the token by clicking “Delete token” and then clicking “Yes, delete” in the confirmation pop-up. The task will finish automatically when done.
  ui_copy: 'Danger zone: Delete token (requires confirmation).'
  setup_description: 'Centered isolated card titled “Danger zone”.

    The card contains one Ant Design danger Button labeled “Delete token”. Clicking it opens an AntD Popconfirm overlay anchored to the button.

    The Popconfirm contains a short warning sentence and two small Buttons inside the overlay:

    • “Cancel”

    • “Yes, delete” (danger/primary styling)

    Initial state: Popconfirm is closed; no overlay is visible.

    After clicking “Yes, delete”, the overlay closes and the card shows a status line “Token deleted”.

    Clicking “Cancel” closes the overlay without deleting.

    No other Buttons exist on the page.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires a two-step confirmation flow with a layered popover and small confirm/cancel buttons; mistakes are easy due to proximity and similar affordances.
  success_trigger:
    human_readable:
    - The confirmation state for deleting the token is set to confirmed.
    - The final confirming click is on the Popconfirm button labeled “Yes, delete”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: token_delete_confirmed
        confirmed: true
        confirm_button_id: antd-btn-popconfirm-yes-delete
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Yes, delete
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Delete token” but not confirming (Popconfirm closes or remains open with confirmed=false).
  - Clicking “Cancel” in the Popconfirm.
  - Clicking outside to dismiss the Popconfirm without confirming.
  - Confirming a different destructive action (if any) instead of Delete token.
  expected_interaction_path: Click “Delete token” → Popconfirm appears → click “Yes, delete”.
  notes: 'Checker: maintain boolean token_delete_confirmed; tag Popconfirm buttons with stable testids.'
- id: button-mui-T01
  name: Add to cart (contained button click)
  canonical_type: button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Button'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the “Add to cart” button on the product card. The task will finish automatically when done.
  ui_copy: 'Product card: Add to cart'
  setup_description: 'Baseline isolated product card centered on the page titled “Canvas Backpack”.

    The card shows a price line and a short description, plus a single MUI contained Button labeled “Add to cart”.

    The button is enabled and medium size (default). No other buttons or links are present.

    When clicked, a small snackbar appears at the bottom (“Added to cart”) and the button text changes to “Added”.

    The success condition is tied to the activation of this button.

    '
  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: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single, clearly labeled contained button with immediate snackbar feedback.
  success_trigger:
    human_readable:
    - The “Add to cart” button action is invoked exactly once.
    - The invocation corresponds to the product card’s primary action button.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: button_clicked
        button_id: mui-btn-add-to-cart
        click_count: 1
      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:
  - No click recorded on the Add to cart button.
  - Multiple activations (click_count ≠ 1).
  - Keyboard focus changes without activation (no click/press event).
  expected_interaction_path: Click “Add to cart” once → snackbar appears.
  notes: "Instrumentation: data-testid='mui-btn-add-to-cart'; log click_count."
- id: button-mui-T02
  name: Open shortcuts menu (large icon button)
  canonical_type: button
  implementation_source: mui
  implementation_variant: icon_only
  implementation_component: 'MUI: IconButton + Menu'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Click the “Keyboard shortcuts” icon button to open its menu. The task will finish automatically when done.
  ui_copy: 'Help: Open the Keyboard shortcuts menu.'
  setup_description: 'Baseline isolated help card centered in the viewport titled “Help”.

    The card contains a single large MUI IconButton (size=large) with a keyboard icon and an accessible label “Keyboard shortcuts”.

    Clicking the IconButton opens a simple MUI Menu anchored to the button with two items (“Basics”, “Navigation”); selecting items is not required.

    Initial state: the menu is closed and no overlay is visible.

    No other Buttons or IconButtons are present.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Only one large icon button; the goal is the menu open state, which is clearly observable.
  success_trigger:
    human_readable:
    - The shortcuts menu overlay is open and anchored to the Keyboard shortcuts icon button.
    - The open state is triggered by activating that IconButton.
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: mui-menu-shortcuts
        is_open: true
        trigger_button_id: mui-iconbtn-shortcuts
      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 menu remains closed.
  - Only a tooltip/focus ring appears without opening the menu.
  - Any other overlay is opened (should not exist in this scene).
  expected_interaction_path: Click the keyboard IconButton → menu appears.
  notes: Checker can read Menu open state via aria-expanded on trigger or an overlay root testid.
- id: button-mui-T03
  name: Permission dialog (click Allow)
  canonical_type: button
  implementation_source: mui
  implementation_variant: dialog_actions
  implementation_component: 'MUI: Dialog (open) + Button (actions)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: In the open permission dialog, click “Allow” (not Cancel). The task will finish automatically when done.
  ui_copy: 'Permission required: Cancel or Allow.'
  setup_description: 'The page loads with a MUI Dialog already open (modal_flow layout).

    Dialog title: “Allow location access?” Body text explains it is used to show nearby stores.

    The Dialog actions area contains exactly two MUI Buttons:

    • “Cancel” (text/neutral)

    • “Allow” (contained/primary)

    Initial state: no selection is made.

    Clicking a button closes the dialog and records the choice as a one-word status (“Choice: allow” or “Choice: cancel”) in the page content behind the dialog.

    No other Buttons exist behind the dialog.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Two clearly labeled dialog buttons with distinct emphasis; must pick the correct instance.
  success_trigger:
    human_readable:
    - The dialog choice equals “allow”.
    - The choice must be recorded by clicking the “Allow” button in the dialog actions.
    canonical_predicate:
      predicate_type: equals
      target_state:
        dialog_id: mui-dialog-location
        choice: allow
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Allow
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Cancel”.
  - Closing the dialog via escape or clicking the backdrop (choice remains unset).
  - No choice recorded (dialog remains open).
  expected_interaction_path: Focus dialog actions → click “Allow”.
  notes: 'Instrumentation: expose dialog choice in state; testids: mui-btn-allow, mui-btn-cancel.'
- id: button-mui-T04
  name: Select Italic in toggle button group
  canonical_type: button
  implementation_source: mui
  implementation_variant: toggle_group_exclusive
  implementation_component: 'MUI: ToggleButtonGroup + ToggleButton'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the formatting toolbar, select “Italic” so it is the active option. The task will finish automatically when done.
  ui_copy: 'Formatting: Bold | Italic | Underline'
  setup_description: 'Centered isolated card titled “Formatting”.

    A MUI ToggleButtonGroup (exclusive selection) displays three ToggleButtons in a row: “Bold”, “Italic”, and “Underline”.

    Each button has both an icon and a text label; selected state is indicated by a filled background and aria-pressed=true on the active button.

    Initial state: “Bold” is selected by default.

    Clicking a different ToggleButton switches the selection exclusively (only one can be active at a time).

    No other Buttons are present.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Requires selecting the correct option among three similar toggle buttons and verifying the active/pressed state.
  success_trigger:
    human_readable:
    - The active selection value of the ToggleButtonGroup equals “italic”.
    - The “Italic” button is the only button with aria-pressed=true.
    canonical_predicate:
      predicate_type: equals
      target_state:
        group_id: mui-toggle-format
        selected_value: italic
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Italic
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving Bold selected (selected_value ≠ italic).
  - Selecting Underline instead of Italic.
  - Multiple selections active at once (if exclusivity breaks, aria-pressed true on more than one).
  expected_interaction_path: Locate formatting group → click “Italic” → confirm it becomes selected.
  notes: Checker reads group value from state or DOM (e.g., data-selected='italic').
- id: button-mui-T05
  name: Match the outlined-with-icon button (visual reference)
  canonical_type: button
  implementation_source: mui
  implementation_variant: variant_and_icon
  implementation_component: 'MUI: Button (variant/style variants)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the button that matches the Target sample shown (same variant and icon placement). The task will finish automatically when done.
  ui_copy: 'Target sample: click the matching button.'
  setup_description: 'Isolated card centered on the page titled “Find the matching button”.

    A “Target sample” preview shows an outlined MUI Button with a leading (start) icon and the label “Export”.

    Below the preview, four enabled MUI Buttons are shown, each with a distinct combination of variant and icon placement:

    1) “Export” (contained, start icon)

    2) “Export” (outlined, start icon)

    3) “Export” (outlined, end icon)

    4) “Export” (text, no icon)

    All four share the same text label, so the only reliable cue is the visual styling and icon placement.

    Clicking any option records the chosen button id and shows “Selected option recorded”.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: All options share the same label, so the agent must use visual cues (outlined border and icon position) to disambiguate among four similar buttons.
  success_trigger:
    human_readable:
    - The selected button matches the Target sample (outlined variant with a start icon).
    - The recorded selected_button_id equals the outlined+start-icon option.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: mui-target-outlined-starticon
        selected_button_id: mui-btn-export-outlined-start
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Outlined Export (start icon)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Choosing the contained variant (wrong emphasis).
  - Choosing the outlined button with the icon on the right (wrong icon placement).
  - Choosing the text button with no icon.
  - Selecting based only on label without matching style (label is identical for all).
  expected_interaction_path: Inspect Target sample → compare border and icon side → click the matching outlined+start-icon button.
  notes: 'Instrumentation: give each button a unique data-testid; reference_id maps to one of them.'
- id: button-mui-T06
  name: Agree at bottom of terms (scroll to find)
  canonical_type: button
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Button'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll through the Terms panel and click the “I agree” button at the end. The task will finish automatically when done.
  ui_copy: 'Terms: Scroll to the end to agree.'
  setup_description: 'The scene is a settings_panel-style card with an internal scroll area containing long Terms text (multiple paragraphs).

    The only actionable control is a single MUI contained Button labeled “I agree” placed at the very bottom of the scroll content.

    Initial state: the scroll position is at the top; the “I agree” button is not visible until the user scrolls near the end.

    The button is enabled and becomes visible without any other prerequisite (no checkboxes).

    After clicking “I agree”, the button becomes disabled and the card shows a confirmation line “Thank you for agreeing”.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: The main challenge is locating the button via scrolling within a long panel; the button itself is clearly labeled once visible.
  success_trigger:
    human_readable:
    - The “I agree” action is invoked once from the Terms panel button.
    - The terms_agreed state becomes true.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: terms_agreed
        value: true
        source_button_id: mui-btn-i-agree
      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:
  - Scrolling but not clicking the “I agree” button.
  - Clicking any other element in the text (no agree event).
  - Clicking “I agree” more than once if the scene tracks agree_count (agree_count ≠ 1).
  expected_interaction_path: Scroll inside Terms panel → reach bottom → click “I agree”.
  notes: Checker can observe terms_agreed boolean or click event log for mui-btn-i-agree.
- id: button-mui-T07
  name: View invoice from table row
  canonical_type: button
  implementation_source: mui
  implementation_variant: table_row_action
  implementation_component: 'MUI: Button (size=small) in Table cell'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the invoices table, click the “View” button on the row for “Invoice 0931”. The task will finish automatically when done.
  ui_copy: 'Invoices table: View Invoice 0931.'
  setup_description: 'A table_cell layout showing a compact invoices table with three rows: “Invoice 0929”, “Invoice 0930”, and “Invoice 0931”.

    Each row has an Actions column containing exactly one small MUI Button labeled “View”.

    The table uses compact spacing so the rows and action buttons are tightly packed.

    Initial state: no invoice is opened; no row is selected.

    Clicking a row’s “View” button records a table action event and shows a right-side preview pane title “Previewing: <invoice id>”.

    No other Buttons exist outside the table.

    '
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Requires mapping the correct row label to its adjacent action button in a compact table where buttons look identical across rows.
  success_trigger:
    human_readable:
    - A table row action event is recorded for row “Invoice 0931” with action “view”.
    - The event must originate from the View button in that row.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: table_row_action
        table_id: mui-invoices-table
        row_key: Invoice 0931
        action: view
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Invoice 0931 row View button
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking View for Invoice 0929 or 0930.
  - Clicking the invoice text cell instead of the View button (no action event).
  - Triggering multiple view events (view_count ≠ 1), if tracked.
  expected_interaction_path: Find row “Invoice 0931” → click its View button.
  notes: 'Checker: stable row_key values; each View button has a data-row-key attribute for the checker.'
- id: button-mui-T08
  name: Open overflow menu in dark toolbar (small icon target)
  canonical_type: button
  implementation_source: mui
  implementation_variant: icon_toolbar_overflow
  implementation_component: 'MUI: IconButton + Menu'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: In the dark top-right toolbar, click the three-dots overflow button to open the menu. The task will finish automatically when done.
  ui_copy: 'Toolbar (dark): Open overflow menu.'
  setup_description: 'Dashboard header toolbar in dark theme, anchored at the top-right of the viewport (placement=top_right).

    The toolbar is in compact mode and uses small IconButtons.

    There are exactly two adjacent MUI IconButtons:

    • “Search” (magnifying glass icon)

    • “Overflow menu” (vertical three-dots icon)

    Clicking the overflow IconButton opens a Menu anchored to it. The menu content is visible once open, but selecting items is not required.

    Initial state: the menu is closed.

    Because of the dark theme and compact spacing, icon contrast and hit targets are smaller than baseline.

    '
  scene_context:
    theme: dark
    spacing: compact
    layout: dashboard
    placement: top_right
    scale: small
    instances: 2
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Small icon-only targets in a dark, compact toolbar increase acquisition difficulty; must choose the correct icon to open the intended menu.
  success_trigger:
    human_readable:
    - The overflow menu overlay is open (visible).
    - The open state is triggered by activating the three-dots IconButton (not Search).
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: mui-menu-overflow
        is_open: true
        trigger_button_id: mui-iconbtn-overflow
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Overflow menu
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking Search instead of the overflow IconButton.
  - Menu remains closed after interactions.
  - Only tooltip/focus appears without opening the menu.
  expected_interaction_path: Move to top-right toolbar → click three-dots icon → menu opens.
  notes: Checker reads menu open state (aria-expanded=true on trigger) and overlay root id.
- id: button-mui-T09
  name: Pin the note (aria-pressed icon toggle)
  canonical_type: button
  implementation_source: mui
  implementation_variant: icon_toggle
  implementation_component: 'MUI: IconButton (toggle aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Pin the note by toggling the “Pin” icon button until it is ON (pressed). The task will finish automatically when done.
  ui_copy: 'Note actions: Pin (toggle) and Star (toggle).'
  setup_description: 'An isolated note card anchored near the bottom-right of the viewport (placement=bottom_right).

    The card has a small actions row with exactly two small MUI IconButtons, each behaves as a toggle and exposes aria-pressed:

    • “Pin” (pin icon)

    • “Star” (star icon)

    Initial state: both toggles are OFF (aria-pressed=false), and the icons appear as outlines.

    When a toggle is ON, the icon appears filled and aria-pressed=true.

    The task only requires turning ON the Pin toggle; Star should remain OFF.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_right
    scale: small
    instances: 2
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 3
    justification: Small icon toggle buttons require precise acquisition and correct interpretation of pressed state; also must avoid toggling a nearby similar control.
  success_trigger:
    human_readable:
    - The “Pin” icon button is ON (aria-pressed=true).
    - The “Star” icon button remains OFF (aria-pressed=false).
    canonical_predicate:
      predicate_type: equals
      target_state:
        pin_button_id: mui-iconbtn-pin
        pin_aria_pressed: true
        star_button_id: mui-iconbtn-star
        star_aria_pressed: false
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Pin
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Pin remains OFF (aria-pressed=false).
  - Star is toggled ON (aria-pressed=true) even if Pin is ON.
  - Toggling Pin ON and then OFF again (final state OFF).
  expected_interaction_path: Locate action icons → click Pin until pressed → ensure Star is unchanged.
  notes: Checker reads aria-pressed attributes on both IconButtons.
- id: button-mui-T10
  name: Delete project with dialog confirmation
  canonical_type: button
  implementation_source: mui
  implementation_variant: dialog_confirm_flow
  implementation_component: 'MUI: Button + Dialog (confirmation)'
  task_template: confirm_cancel
  secondary_template: open_overlay
  browsergym_goal: Delete the project by clicking “Delete project” and then clicking “Delete” in the confirmation dialog. The task will finish automatically when done.
  ui_copy: 'Danger zone: Delete project (confirmation required).'
  setup_description: 'Centered “Danger zone” card with a single prominent MUI contained Button labeled “Delete project”.

    Clicking “Delete project” opens a MUI Dialog asking for confirmation.

    The Dialog actions contain exactly two Buttons:

    • “Cancel”

    • “Delete” (destructive, emphasized)

    Initial state: the dialog is closed and no confirmation choice is recorded.

    The confirm button labels are short and similar, and the dialog sits above a dimmed backdrop.

    On successful confirmation (“Delete”), the dialog closes and the card shows a status line “Project deleted”.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two-step destructive confirmation with a dialog layer; must trigger the dialog and then choose the correct action among Cancel/Delete.
  success_trigger:
    human_readable:
    - The project_delete_confirmed state becomes true.
    - The confirming click is on the dialog action button labeled “Delete”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: project_delete_confirmed
        confirmed: true
        confirm_button_id: mui-btn-dialog-delete
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Delete (dialog)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking “Delete project” but then cancelling or dismissing the dialog (confirmed=false).
  - Clicking “Cancel” in the dialog.
  - Closing the dialog without making a choice (escape/backdrop) so no confirmation is recorded.
  - Confirming the wrong destructive action if multiple cards exist (should not in this scene).
  expected_interaction_path: Click “Delete project” → wait for dialog → click “Delete”.
  notes: 'Instrumentation: dialog buttons have stable ids; checker monitors project_delete_confirmed boolean.'
- id: button-mantine-T01
  name: Send invite (Mantine button click)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Button'
  task_template: activate
  secondary_template: null
  browsergym_goal: Click the “Send invite” button in the Invite card. The task will finish automatically when done.
  ui_copy: 'Invite card: Send invite'
  setup_description: 'Baseline isolated card centered in the viewport titled “Invite teammate”.

    The card contains helper text and a single Mantine Button labeled “Send invite”.

    The button is enabled, default size, and not in loading state.

    When clicked, a small inline notification appears (“Invite sent”) and the button label changes to “Sent”.

    No other Buttons or ActionIcons are present.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single labeled button with immediate visible state change; minimal clutter.
  success_trigger:
    human_readable:
    - The “Send invite” button action is invoked exactly once.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: button_clicked
        button_id: mantine-btn-send-invite
        click_count: 1
      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:
  - No click recorded on the Send invite button.
  - Clicking more than once (click_count ≠ 1).
  - Focusing the button without activation.
  expected_interaction_path: Click “Send invite” once → see “Invite sent”.
  notes: "Instrumentation: data-testid='mantine-btn-send-invite'; log click_count."
- id: button-mantine-T02
  name: Open info popover (Mantine)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: popover_trigger
  implementation_component: 'Mantine: Button + Popover'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the info popover by clicking the “Show info” button. The task will finish automatically when done.
  ui_copy: 'Info: Click Show info to open the popover.'
  setup_description: 'Baseline isolated card centered on the page titled “Subscription”.

    The card includes a single Mantine Button labeled “Show info”.

    Clicking it opens a Mantine Popover directly under the button with a short explanation (two sentences).

    Initial state: Popover is closed.

    There are no other buttons or interactive icons in the card.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: One labeled trigger; success is simply the popover open state.
  success_trigger:
    human_readable:
    - The info popover is open and anchored to the “Show info” button.
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: mantine-popover-subscription-info
        is_open: true
        trigger_button_id: mantine-btn-show-info
      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:
  - Popover remains closed.
  - Only focus/hover effects appear without opening the popover.
  - Any other overlay is opened (none should exist).
  expected_interaction_path: Click “Show info” → popover appears.
  notes: Checker reads Popover opened state via data-open attr on overlay root.
- id: button-mantine-T03
  name: Reset profile form (single reset button)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Button'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: In the Profile form, click the “Reset form” button. The task will finish automatically when done.
  ui_copy: 'Profile form: Reset form'
  setup_description: 'A form_section titled “Profile” with several non-button inputs (Name, Title, and a Select for Department).

    The fields are pre-filled to indicate there are changes to clear.

    At the bottom of the section there is exactly one Mantine Button labeled “Reset form”.

    Clicking it restores all fields to their default values and shows a small text confirmation under the button (“Form reset”).

    There are no other Buttons; navigation links in the header are plain text links, not buttons.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single reset button in a simple form section; minor clutter from surrounding inputs but no competing buttons.
  success_trigger:
    human_readable:
    - The profile form reset action is invoked from the “Reset form” button.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: profile_form_reset
        invoked: true
        source_button_id: mantine-btn-reset-form
      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:
  - Editing fields manually without using the reset button (no reset event).
  - No reset action recorded.
  - Triggering reset multiple times if the scene tracks reset_count (reset_count ≠ 1).
  expected_interaction_path: Locate “Reset form” at bottom of Profile section → click once → observe “Form reset”.
  notes: 'Checker can listen for profile_form_reset event; data-testid=''mantine-btn-reset-form''.'
- id: button-mantine-T04
  name: Match the light variant button (visual reference)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: variant_palette
  implementation_component: 'Mantine: Button (variant options)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Click the button that matches the Target sample style shown (same variant and emphasis). The task will finish automatically when done.
  ui_copy: 'Target sample: choose the matching button.'
  setup_description: 'Centered isolated card titled “Choose by style”.

    A small “Target sample” preview shows a Mantine Button in the light variant (soft background, not fully filled) with the label “Continue”.

    Below it, four Mantine Buttons are shown in a row, all labeled “Continue” but each using a different variant:

    • Filled

    • Outline

    • Light

    • Subtle

    All are enabled and the same size; because labels are identical, the match must be based on the visual variant.

    Clicking an option records selected_button_id and shows a confirmation line “Selection saved”.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Four visually similar buttons share the same label; the agent must identify the correct variant based on the target sample.
  success_trigger:
    human_readable:
    - The selected button matches the Target sample (Light variant).
    - The recorded selected_button_id equals the Light variant option.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: mantine-target-variant-light
        selected_button_id: mantine-btn-continue-light
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Continue (Light)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Filled/Outline/Subtle instead of Light.
  - Making no selection (no selected_button_id recorded).
  - Selecting based on label only (label is identical).
  expected_interaction_path: Inspect Target sample → compare variant styling → click Light variant button.
  notes: 'Instrumentation: each option has unique testid; reference_id maps to one.'
- id: button-mantine-T05
  name: Apply changes at end of settings panel (scroll find)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Button'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll the Settings panel until you reach the “Apply changes” button, then click it. The task will finish automatically when done.
  ui_copy: 'Settings: Scroll to Apply changes.'
  setup_description: 'A settings_panel layout: a tall card with its own internal scroll region containing multiple settings blocks (Switches, sliders, and helper text).

    The only Button in the panel is a Mantine Button labeled “Apply changes” located at the bottom of the scrollable content.

    Initial state: scrolled to the top; the Apply button is not visible.

    When clicked, the Apply button enters a loading state (shows a loader and is disabled) briefly, then changes its label to “Applied”.

    No additional confirmations or dialogs appear.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires scrolling inside a panel to find the only button; includes a short loading feedback phase.
  success_trigger:
    human_readable:
    - The apply_settings action is invoked once from the “Apply changes” button.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: apply_settings
        invoked: true
        source_button_id: mantine-btn-apply-changes
        click_count: 1
      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:
  - Scrolling without clicking the Apply changes button.
  - Clicking the button more than once (click_count ≠ 1).
  - Interacting with other settings controls without applying (no apply event).
  expected_interaction_path: Scroll inside settings panel → reach bottom → click “Apply changes” → wait for Applied state.
  notes: Checker can watch apply_settings event or read a data-applied flag.
- id: button-mantine-T06
  name: Mute alerts (toggle-style button)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: toggle_style
  implementation_component: 'Mantine: Button (stateful toggle via aria-pressed)'
  task_template: toggle_state
  secondary_template: null
  browsergym_goal: Turn on “Mute alerts” by clicking its button until it is ON (pressed). The task will finish automatically when done.
  ui_copy: 'Alerts: Mute alerts (toggle) and Send test alert.'
  setup_description: 'Centered isolated card titled “Alerts”.

    The card has exactly two Mantine Buttons stacked vertically:

    • “Mute alerts” (toggle-style button). It flips ON/OFF on each click and exposes aria-pressed.

    • “Send test alert” (regular button) which only triggers a toast and does not toggle.

    Initial state: Mute alerts is OFF (aria-pressed=false) and a status line reads “Alerts are audible”.

    When ON, the status line changes to “Alerts are muted” and the button appears pressed.

    No other interactive controls are present.

    '
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires reaching a specific toggle state (ON) but the control is large and clearly labeled with visible status text.
  success_trigger:
    human_readable:
    - The “Mute alerts” button toggle state is ON (aria-pressed=true).
    canonical_predicate:
      predicate_type: equals
      target_state:
        button_id: mantine-btn-mute-alerts
        aria_pressed: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Mute alerts
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving Mute alerts OFF (aria-pressed=false).
  - Clicking Send test alert instead of toggling mute.
  - Toggling Mute alerts ON and then OFF again (final state OFF).
  expected_interaction_path: Click “Mute alerts” until ON → stop when status shows muted.
  notes: 'Instrumentation: bind aria-pressed to toggle state; stable testid for the toggle button.'
- id: button-mantine-T07
  name: Open More menu via ActionIcon (compact dashboard)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: action_icon_toolbar
  implementation_component: 'Mantine: ActionIcon + Menu'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: In the top-right header, click the three-dots ActionIcon to open the “More” menu. The task will finish automatically when done.
  ui_copy: 'Header: Open More menu.'
  setup_description: 'Dashboard header area anchored near the top-right of the viewport.

    The UI uses compact spacing and small controls.

    There are exactly two Mantine ActionIcon components placed side-by-side:

    • “Refresh” (circular arrow icon)

    • “More” (vertical three-dots icon)

    Clicking the “More” ActionIcon opens a Menu anchored to it.

    Initial state: menu is closed; no overlay is visible.

    Because ActionIcons are icon-only and small, accurate clicking is required to avoid triggering the neighboring Refresh icon.

    '
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard
    placement: top_right
    scale: small
    instances: 2
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 3
    justification: Small icon-only ActionIcons in a compact header increase target acquisition difficulty and require correct icon disambiguation.
  success_trigger:
    human_readable:
    - The “More” menu overlay is open and anchored to the three-dots ActionIcon.
    canonical_predicate:
      predicate_type: equals
      target_state:
        overlay_id: mantine-menu-more
        is_open: true
        trigger_button_id: mantine-actionicon-more
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: More
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking Refresh instead of More.
  - Menu remains closed after interactions.
  - Only focus ring appears without opening the menu.
  expected_interaction_path: Go to top-right header → click three-dots ActionIcon → menu opens.
  notes: Checker reads menu open state; ActionIcons have aria-labels and stable testids.
- id: button-mantine-T08
  name: Download report from table row (ActionIcon in table)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: action_icon_table
  implementation_component: 'Mantine: ActionIcon in Table cell'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the reports table, click the download ActionIcon on the row labeled “Report Q3”. The task will finish automatically when done.
  ui_copy: 'Reports table: Download Report Q3.'
  setup_description: 'A table_cell layout showing a compact reports table with three rows: “Report Q1”, “Report Q2”, and “Report Q3”.

    Each row has a rightmost Actions cell containing exactly one small Mantine ActionIcon with a download arrow icon.

    Rows are tightly spaced (compact mode), and ActionIcons are small and visually identical across rows.

    Initial state: no downloads have been triggered.

    Clicking a row’s download ActionIcon records a table action event and shows a small “Downloaded” indicator in that row.

    There are no other Buttons or ActionIcons outside the table.

    '
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: center
    scale: small
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Small, identical icon buttons repeated across table rows require precise clicking and correct row association under compact density.
  success_trigger:
    human_readable:
    - A download action is recorded for row “Report Q3”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: table_row_action
        table_id: mantine-reports-table
        row_key: Report Q3
        action: download
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Report Q3 row download ActionIcon
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Downloading a different report row (Q1 or Q2).
  - Clicking the row label text instead of the ActionIcon (no action event).
  - Triggering multiple downloads if the checker expects a single action (download_count ≠ 1).
  expected_interaction_path: Locate row “Report Q3” → click its download ActionIcon.
  notes: 'Checker uses stable row_key; each ActionIcon can carry data-row-key for attribution.'
- id: button-mantine-T09
  name: Remove member with inline confirmation (dark theme)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: confirm_popover
  implementation_component: 'Mantine: ActionIcon + Popover (confirmation) + Buttons'
  task_template: confirm_cancel
  secondary_template: open_overlay
  browsergym_goal: Remove the member by clicking the trash ActionIcon and then clicking “Remove” in the confirmation popover. The task will finish automatically when done.
  ui_copy: 'Team member: Remove (confirmation required).'
  setup_description: 'Dark theme isolated member card centered in the viewport titled “Team member”.

    The card shows a member name and role, and a single small trash-can Mantine ActionIcon labeled “Remove member”.

    Clicking the trash ActionIcon opens a confirmation popover anchored to it with two small buttons:

    • “Cancel”

    • “Remove” (destructive)

    Initial state: confirmation popover is closed and no removal is recorded.

    After clicking “Remove”, the popover closes and the card shows “Member removed” with the ActionIcon disabled.

    Clicking “Cancel” or dismissing the popover leaves the member intact.

    '
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 3
    justification: Destructive confirmation requires a multi-step overlay interaction with small targets in dark theme, increasing layering and acquisition difficulty.
  success_trigger:
    human_readable:
    - The member_removed state is true.
    - The final confirming click is on the popover button labeled “Remove”.
    canonical_predicate:
      predicate_type: equals
      target_state:
        event: member_removed
        value: true
        confirm_button_id: mantine-btn-confirm-remove
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Remove (confirm)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking the trash ActionIcon but not confirming (member_removed=false).
  - Clicking “Cancel” in the confirmation popover.
  - Dismissing the popover by clicking outside or pressing escape without confirming.
  - Removing the wrong member card if multiple were present (this scene has one).
  expected_interaction_path: Click trash ActionIcon → popover opens → click “Remove”.
  notes: 'Instrumentation: expose member_removed boolean; tag confirm/cancel buttons with stable testids.'
- id: button-mantine-T10
  name: Match reference and section (Secondary actions in dark theme)
  canonical_type: button
  implementation_source: mantine
  implementation_variant: match_reference_with_section
  implementation_component: 'Mantine: Button (multiple instances)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the dark Actions panel, click the button in the “Secondary actions” area that matches the Target sample style. The task will finish automatically when done.
  ui_copy: 'Actions panel: Secondary actions — choose the matching button.'
  setup_description: 'Dark theme form_section titled “Actions”.

    The section is split into two labeled areas stacked vertically:

    • “Primary actions”

    • “Secondary actions”

    Each area contains exactly two Mantine Buttons, for a total of four buttons (all enabled).

    All four buttons share the same text label “Continue”, but each has a different visual style (variant and icon placement).

    A “Target sample” preview is shown at the top of the section and visually depicts the desired style: an outlined button with a right-arrow icon on the right side.

    The goal is specifically to click the matching button under “Secondary actions” (not the visually similar option under Primary actions).

    Clicking any button records selected_button_id and shows “Selection recorded”.

    '
  scene_context:
    theme: dark
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 4
    guidance: mixed
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 5
    justification: All buttons share the same label and are split across two sections; the agent must use both the visual reference and the correct section constraint to disambiguate among four instances in dark theme.
  success_trigger:
    human_readable:
    - The clicked button is the one under “Secondary actions” that matches the Target sample (outlined with right icon).
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: mantine-target-outlined-righticon
        selected_button_id: mantine-btn-secondary-continue-outlined-right
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary actions → Continue (outlined, right icon)
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking the matching style under “Primary actions” (wrong section).
  - Clicking any other style under Secondary actions that does not match the Target sample.
  - Choosing based on label only (all labels identical).
  - No selection recorded.
  expected_interaction_path: Check Target sample → locate Secondary actions area → compare the two buttons there → click the one matching outline + right icon.
  notes: 'Instrumentation: each button has stable testid encoding section and style; reference_id resolves to exactly one button.'