tasks/v1/alpha_slider.yaml

- id: alpha_slider-antd-T01
  name: Set overlay opacity to 80%
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (alpha/opacity slider)'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Overlay color opacity to 80%. The task will finish automatically when done.
  ui_copy: Set the Overlay color opacity to 80%.
  setup_description: |-
    A single centered card titled "Overlay Preview" contains:
    - A checkerboard preview box showing a blue overlay applied on top of the checkerboard.
    - A labeled control row: label "Overlay color" on the left and an AntD ColorPicker trigger on the right (a small color swatch button).
    - Clicking the swatch opens the ColorPicker popup with the standard panel (saturation square, hue slider, and an opacity/alpha slider).
    - The opacity/alpha slider is labeled "Opacity" and shows the current value as a percent text (e.g., "100%") next to the slider.
    Initial state:
    - Base color is blue (e.g., #1677FF) and opacity starts at 100%.
    Feedback:
    - Changing the opacity updates the preview box immediately; there is no separate Apply/OK button in this 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: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single instance with clear label and visible percent readout; only moderate precision is needed to reach 80% opacity.
  success_trigger:
    human_readable:
    - The 'Overlay color' instance has alpha (opacity) set to 0.80 (80%).
    - Alpha must be within ±0.02 of the target value.
    - No separate confirmation is required; live value counts.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.8
      tolerance:
        abs: 0.02
      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:
  - Opacity is set on a non-target control (e.g., hue slider moved but opacity not at target).
  - Opacity ends outside the allowed tolerance window.
  - Any change to other UI elements does not count unless the Overlay opacity itself is correct.
  expected_interaction_path:
  - Click the Overlay color swatch to open the ColorPicker popup (if closed).
  - Drag the Opacity/Alpha slider thumb until the readout shows ~80%.
  - Leave the popup open or close it; no Apply is needed.
  notes: Checker should read the committed color value for the 'Overlay color' instance and extract alpha from RGBA/HSB as needed.
- id: alpha_slider-antd-T02
  name: Drag opacity to 25% (panel already open)
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (open=true inline panel)'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: Drag the Opacity slider until the sticker opacity is 25%. The task will finish automatically when done.
  ui_copy: Drag the Opacity slider until the sticker opacity is 25%.
  setup_description: |-
    A centered card titled "Sticker Opacity" shows the AntD ColorPicker panel already open (no need to click a trigger):
    - The ColorPicker panel is rendered inline in the card (controlled with open=true), so the saturation area and sliders are visible immediately.
    - The opacity/alpha slider is labeled "Opacity" and shows a percent readout.
    - A small preview chip labeled "Sticker preview" sits above the panel and updates live.
    Initial state:
    - Opacity starts at 100% (alpha=1.0).
    Distractors:
    - Hue slider and saturation area are present but do not affect task success (only alpha is checked).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: No overlay to open; the only challenge is dragging the correct (opacity) slider among other visible controls.
  success_trigger:
    human_readable:
    - The sticker color alpha is set to 0.25 (25% opacity).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.25
      tolerance:
        abs: 0.02
      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:
  - Adjusting the hue slider or saturation panel without setting opacity to the target value.
  - Stopping at a value outside the allowed tolerance window.
  - Changing a different control that only changes the displayed color but not alpha.
  expected_interaction_path:
  - Locate the slider labeled Opacity in the open ColorPicker panel.
  - Drag the Opacity thumb left until the readout is around 25%.
  - Release the drag and verify the readout/preview.
  notes: If the AntD panel shows both hue and opacity sliders, ensure the checker binds to the alpha channel only.
- id: alpha_slider-antd-T03
  name: Reset badge opacity to 100%
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker + in-panel Reset opacity control'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Badge color opacity back to 100%. The task will finish automatically when done.
  ui_copy: Reset the Badge color opacity back to 100%.
  setup_description: |-
    A centered "Badge Style" card includes:
    - A badge preview on a checkerboard background.
    - An AntD ColorPicker trigger labeled "Badge color" that opens a popup panel with hue + opacity controls.
    - Inside the popup, the opacity slider is labeled "Opacity" with a percent readout.
    - Beneath the opacity slider, there is a small inline control: a link-style button labeled "Reset opacity".
    Initial state:
    - Badge color is set with partial transparency (about 45% opacity), so the badge looks faint.
    Feedback:
    - Clicking "Reset opacity" immediately sets opacity back to 100% and updates the badge preview and the percent readout.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: A dedicated reset control is provided and the target is the default full opacity state.
  success_trigger:
    human_readable:
    - The badge color alpha is set to 1.00 (100% opacity).
    - Alpha must be within ±0.005 of the target value.
    - No separate confirmation is required; live value counts.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 1.0
      tolerance:
        abs: 0.005
      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:
  - Opacity remains below the target (not fully opaque).
  - Reset was clicked but opacity did not actually change to the target state.
  - Changing hue/saturation without restoring full opacity.
  expected_interaction_path:
  - Open the Badge color picker popup.
  - Click the 'Reset opacity' control (or drag the opacity slider to 100%).
  - Verify the opacity readout shows 100%.
  notes: Instrument 'Reset opacity' with a stable data-testid so agents can click it; checker should still validate via alpha value.
- id: alpha_slider-antd-T04
  name: Match banner opacity to a reference swatch
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (alpha/opacity slider) with visual target swatch'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the Banner color opacity to the Target swatch shown in the card. The task will finish automatically when done.
  ui_copy: Match the Banner color opacity to the Target swatch shown in the card.
  setup_description: |-
    A centered card titled "Banner Transparency" contains:
    - Two preview swatches on a checkerboard:
      * "Current" preview (left) reflects the live banner color and its current opacity.
      * "Target" preview (right) is a fixed reference swatch that shows the desired transparency.
    - Below the previews is an AntD ColorPicker trigger labeled "Banner color".
    - Opening the ColorPicker shows the standard panel including the Opacity slider labeled "Opacity".
    Initial state:
    - Current banner opacity starts at 100% (fully opaque), so it does NOT match the Target swatch.
    Guidance:
    - The target is given visually via the Target preview swatch (no numeric target is displayed in the UI copy).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Visual reference is clear and the target transparency is moderate; slider shows live feedback while adjusting.
  success_trigger:
    human_readable:
    - The banner color alpha matches the reference Target swatch (alpha=0.60).
    - Alpha must be within ±0.03 of the target value.
    - No separate confirmation is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.6
      tolerance:
        abs: 0.03
      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:
  - Banner opacity remains closer to fully opaque than the target reference.
  - Matching the hue/saturation of the color without matching transparency (alpha).
  - Alpha ends outside the allowed tolerance window.
  expected_interaction_path:
  - Open the Banner color picker.
  - Adjust only the Opacity slider while comparing Current vs Target previews.
  - Stop when the transparency matches the Target swatch.
  notes: Checker ignores hue/saturation and validates only alpha; the Target swatch should encode the exact alpha target (0.60).
- id: alpha_slider-antd-T05
  name: Set compact tooltip opacity to 37%
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (small trigger, compact panel)'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Tooltip overlay opacity to 37%. The task will finish automatically when done.
  ui_copy: Set the Tooltip overlay opacity to 37%.
  setup_description: |-
    A centered "Tooltip Overlay" card uses compact spacing and small-sized controls:
    - Label "Tooltip overlay color" with a small AntD ColorPicker trigger (size="small").
    - Clicking opens the ColorPicker popup. Inside, the hue and opacity sliders are stacked tightly with minimal padding.
    - The opacity/alpha slider is labeled "Opacity" and shows a percent readout, but the slider thumb and track are smaller than default.
    Initial state:
    - Opacity starts at 90%.
    Feedback:
    - Preview tooltip chip updates immediately as opacity changes.
    Distractors:
    - Hue slider is adjacent and visually similar to the Opacity slider, increasing risk of adjusting the wrong slider.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small, compact sliders demand careful target acquisition and tighter precision to reach 37% without overshooting.
  success_trigger:
    human_readable:
    - The tooltip overlay color alpha is set to 0.37 (37% opacity).
    - Alpha must be within ±0.01 of the target value.
    - No separate confirmation is required; live value counts.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.37
      tolerance:
        abs: 0.01
      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:
  - Opacity ends outside the allowed tolerance window.
  - Only hue/saturation is changed while opacity remains incorrect.
  - Accidentally adjusting the hue slider instead of the Opacity slider.
  expected_interaction_path:
  - Open the Tooltip overlay ColorPicker popup.
  - Drag the Opacity slider thumb to approximately 37% (use small adjustments).
  - Verify the percent readout is ~37%.
  notes: To reduce ambiguity, label the alpha slider element with aria-label 'Opacity' or similar for reliable AX-tree parsing.
- id: alpha_slider-antd-T06
  name: Set tooltip opacity in a modal and apply
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Modal + ColorPicker (alpha slider) + Apply/Cancel footer'
  task_template: confirm_cancel
  secondary_template: set_scalar
  browsergym_goal: Open the Tooltip Style dialog, set Tooltip background opacity to 70%, then click Apply. The task will finish automatically when done.
  ui_copy: Open the Tooltip Style dialog, set Tooltip background opacity to 70%, then click Apply.
  setup_description: |-
    The page shows a centered button "Edit Tooltip Style". Clicking it opens an AntD Modal (modal_flow):
    - Inside the modal, there is a ColorPicker control labeled "Tooltip background".
    - The ColorPicker opens a popup panel (within the modal) that includes the Opacity slider labeled "Opacity" with a percent readout.
    - The modal footer contains two buttons: "Cancel" and a primary button "Apply".
    Initial state:
    - Tooltip background opacity is currently 100% in the live preview behind the modal.
    Feedback and commit behavior:
    - Adjusting opacity updates the color inside the modal immediately, but the live tooltip preview outside the modal updates ONLY after clicking "Apply".
    - Clicking "Cancel" closes the modal and discards changes.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires working inside a modal and committing changes via Apply; failure to confirm is a common agent mistake.
  success_trigger:
    human_readable:
    - The committed tooltip background alpha is 0.70 (70% opacity).
    - Alpha must be within ±0.015 of the target value.
    - The modal 'Apply' button must be clicked to commit the value.
    - The task ends when the committed state satisfies the predicate.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.7
      tolerance:
        abs: 0.015
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opacity is set correctly inside the modal but Apply is not clicked.
  - Cancel is clicked (changes discarded).
  - Committed opacity ends outside tolerance.
  - Changing the wrong control (e.g., hue) while opacity remains incorrect.
  expected_interaction_path:
  - Click 'Edit Tooltip Style' to open the modal.
  - Open the Tooltip background ColorPicker (if needed).
  - Adjust the Opacity slider to ~70%.
  - Click 'Apply' in the modal footer.
  notes: Checker should read the committed value stored in app state (after Apply), not the temporary draft value inside the modal.
- id: alpha_slider-antd-T07
  name: Scroll to watermark opacity and set to 40%
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (inline open) embedded in a settings panel'
  task_template: scroll_find
  secondary_template: set_scalar
  browsergym_goal: In the settings panel, scroll to the Watermark tint control and set its opacity to 40%. The task will finish automatically when done.
  ui_copy: In the settings panel, scroll to the Watermark tint control and set its opacity to 40%.
  setup_description: |-
    A settings panel (right-aligned in the viewport) contains multiple sections with typical app settings:
    - Sections like "Notifications", "Layout", and "Watermark" appear in a single scrollable column.
    - The target control is in the "Watermark" section near the bottom (initially below the fold), so scrolling is required.
    - In "Watermark", there is a labeled AntD ColorPicker control: "Watermark tint".
    - The ColorPicker panel is set to stay open inline when the section is in view (so the opacity slider is visible once you reach it).
    - The opacity/alpha slider is labeled "Opacity" and shows a percent readout.
    Initial state:
    - Watermark opacity starts at 60%.
    Clutter:
    - Nearby non-target controls include switches, selects, and a second ColorPicker for "Highlight color" in a different section.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires scrolling to find the correct section in a cluttered settings panel, then adjusting the opacity slider to a specific value.
  success_trigger:
    human_readable:
    - The 'Watermark tint' alpha is set to 0.40 (40% opacity).
    - Alpha must be within ±0.015 of the target value.
    - No separate confirmation is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.4
      tolerance:
        abs: 0.015
      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:
  - Changing a different ColorPicker (e.g., Highlight color) instead of Watermark tint.
  - Opacity ends outside tolerance.
  - Stopping after scrolling without actually setting the watermark opacity.
  expected_interaction_path:
  - Scroll the settings panel until the 'Watermark' section is visible.
  - Locate the 'Watermark tint' opacity slider.
  - Adjust the Opacity slider to ~40%.
  notes: For robust checking, bind the target instance by label/id ('Watermark tint') rather than DOM position since scrolling changes layout.
- id: alpha_slider-antd-T08
  name: Set Secondary overlay opacity to 20% among three tiles
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: multiple ColorPicker instances (alpha slider) in a dashboard'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Secondary overlay opacity to 20%. The task will finish automatically when done.
  ui_copy: Set the Secondary overlay opacity to 20%.
  setup_description: |-
    A dashboard-style page shows three tiles in a grid (clutter high):
    - Tile 1: "Primary overlay" with a preview card and an AntD ColorPicker control.
    - Tile 2: "Secondary overlay" with a preview card and an AntD ColorPicker control. (THIS is the target.)
    - Tile 3: "Danger overlay" with a preview card and an AntD ColorPicker control.
    Each tile's ColorPicker opens a popup panel that includes an Opacity slider labeled "Opacity".
    Initial state:
    - Primary overlay opacity = 80%.
    - Secondary overlay opacity = 50%.
    - Danger overlay opacity = 90%.
    Distractors:
    - Each tile also contains unrelated buttons (e.g., "Preview", "Reset layout") and small KPI badges.
    - The three ColorPicker triggers look very similar; only the tile header text distinguishes them.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 5
    justification: Multiple similar instances in a busy dashboard require correct disambiguation plus reasonably precise slider setting.
  success_trigger:
    human_readable:
    - Only the 'Secondary overlay' instance has alpha set to 0.20 (20% opacity).
    - Alpha must be within ±0.01 of the target value.
    - No confirmation click is required; live value counts.
    - The task ends when the predicate holds for the correct instance.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.2
      tolerance:
        abs: 0.01
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary overlay
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opacity is set correctly but on Primary overlay or Danger overlay instead of Secondary overlay.
  - Secondary overlay opacity ends outside tolerance.
  - Multiple overlays changed and Secondary overlay is not exactly at the target.
  expected_interaction_path:
  - Locate the tile titled 'Secondary overlay'.
  - Open its ColorPicker popup.
  - Adjust the Opacity slider to ~20%.
  notes: Checker must assert the correct instance by stable label (tile title) and ignore changes to other instances except as negative cases if desired.
- id: alpha_slider-antd-T09
  name: Match scrim opacity in dark theme without numeric readout
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: ColorPicker (alpha slider) with hidden numeric alpha'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the Modal scrim opacity to the Target preview. The task will finish automatically when done.
  ui_copy: Match the Modal scrim opacity to the Target preview.
  setup_description: |-
    A single card is centered on a dark theme page:
    - Title: "Modal Scrim"
    - Two large preview rectangles on a checkerboard:
      * "Current scrim" (live, updates as you adjust opacity)
      * "Target scrim" (fixed reference)
    - An AntD ColorPicker trigger labeled "Scrim color" opens the popup panel.
    - The popup includes the Opacity slider labeled "Opacity", but the numeric percent readout is intentionally hidden (minimal UI); only the thumb position and the preview changes provide feedback.
    Initial state:
    - Current scrim opacity starts at 70% (noticeably darker than the Target).
    Feedback:
    - Only the visual preview changes on the page as opacity is adjusted; no numeric alpha text is shown.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Dark theme plus lack of numeric readout forces reliance on visual comparison, increasing semantic observability demands.
  success_trigger:
    human_readable:
    - The scrim alpha matches the Target scrim reference (alpha=0.33).
    - Alpha must be within ±0.015 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.33
      tolerance:
        abs: 0.015
      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:
  - Matching the target color hue/saturation while alpha remains incorrect.
  - Alpha ends outside tolerance.
  - Adjusting a non-opacity control (e.g., hue) without reaching the target transparency.
  expected_interaction_path:
  - Open the Scrim color picker.
  - Adjust the Opacity slider while visually comparing Current vs Target previews.
  - Stop when the Current scrim matches the Target.
  notes: Because numeric alpha is hidden, checker should rely on the internal color value (alpha channel), not on reading UI text.
- id: alpha_slider-antd-T10
  name: Set Header overlay opacity to 88% in drawer and save
  canonical_type: alpha_slider
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Drawer + two ColorPicker instances + Save/Close footer'
  task_template: confirm_cancel
  secondary_template: set_scalar
  browsergym_goal: Open the Theme Tokens drawer, set Header overlay opacity to 88%, then click Save. The task will finish automatically when done.
  ui_copy: Open the Theme Tokens drawer, set Header overlay opacity to 88%, then click Save.
  setup_description: |-
    A drawer-based flow (drawer opens from the right):
    - Main page shows a button "Theme Tokens". Clicking it opens an AntD Drawer titled "Theme Tokens".
    - Inside the drawer are two very similar sections, each with its own AntD ColorPicker control:
      1) "Header overlay" (target)
      2) "Sidebar overlay"
    - Each ColorPicker opens its popup panel within the drawer and includes the Opacity slider labeled "Opacity" with a percent readout.
    - The drawer footer contains two buttons: "Close" and a primary button "Save".
    Initial state:
    - Header overlay opacity = 95%.
    - Sidebar overlay opacity = 60%.
    Commit behavior:
    - Adjustments are treated as draft while the drawer is open; the committed app state updates only after clicking "Save".
    Clutter:
    - The drawer also contains unrelated token inputs (border radius, font size) to increase distraction.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 4
    justification: Requires operating in a drawer, selecting the correct instance among two similar sections, and remembering to click Save to commit.
  success_trigger:
    human_readable:
    - The committed 'Header overlay' alpha is set to 0.88 (88% opacity).
    - Alpha must be within ±0.01 of the target value.
    - The drawer 'Save' button must be clicked to commit the value.
    - The correct instance must be modified (Header overlay, not Sidebar overlay).
    - The task ends when the committed state satisfies the predicate.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.88
      tolerance:
        abs: 0.01
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Header overlay
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Header overlay opacity is correct but Save is not clicked (draft only).
  - Sidebar overlay is changed instead of Header overlay.
  - Committed opacity ends outside tolerance.
  - Clicking Close discards changes.
  expected_interaction_path:
  - Click 'Theme Tokens' to open the drawer.
  - In the 'Header overlay' section, open the ColorPicker (if needed).
  - Adjust the Opacity slider to ~88%.
  - Click 'Save' in the drawer footer.
  notes: 'Instrumentation: assign data-testid per section (header-overlay, sidebar-overlay) and separate draft vs committed alpha in state for checker.'
- id: alpha_slider-mui-T01
  name: Set highlight opacity to 60%
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider (opacity) + checkerboard preview (composite)'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Highlight opacity to 60%. The task will finish automatically when done.
  ui_copy: Set the Highlight opacity to 60%.
  setup_description: |-
    A centered card titled "Highlight Opacity" contains a simple MUI composite opacity control:
    - A checkerboard preview square labeled "Highlight preview" that updates live.
    - A single MUI Slider labeled "Opacity" (min 0, max 100) with the current value shown as a value label and as text "Opacity: XX%".
    Initial state:
    - Opacity starts at 100%.
    No overlay, no extra controls, and only one slider instance on the page.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single large slider with explicit numeric feedback makes setting 60% straightforward.
  success_trigger:
    human_readable:
    - The opacity slider value corresponds to alpha=0.60 (60%).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.6
      tolerance:
        abs: 0.02
      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:
  - Opacity ends outside tolerance.
  - Changing unrelated inputs (if any) without setting the slider value.
  - Interacting with the page without adjusting the opacity slider.
  expected_interaction_path:
  - Locate the slider labeled Opacity.
  - Drag the thumb or click on the track until the value reads about 60%.
  - Stop when the value/preview updates to the target.
  notes: MUI has no native color picker; this task uses a first-party MUI Slider as an opacity control with a preview swatch.
- id: alpha_slider-mui-T02
  name: Drag snap-to-marks opacity to 25%
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider with marks (restricted values) + preview (composite)'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: Drag the Opacity slider to 25%. The task will finish automatically when done.
  ui_copy: Drag the Opacity slider to 25%.
  setup_description: |-
    A centered card titled "Snap-to-marks Opacity" uses a discrete MUI Slider:
    - Slider label: "Opacity"
    - The slider shows marks at 0%, 25%, 50%, 75%, and 100%.
    - The slider is restricted to the marked values (step is disabled so it can only land on a mark).
    - A small checkerboard preview updates live and a text line shows the selected percent.
    Initial state:
    - Opacity starts at 100% (on the 100% mark).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Discrete marks remove precision demands; user just needs to drag to the 25% mark.
  success_trigger:
    human_readable:
    - The opacity slider is set exactly to the 25% mark (alpha=0.25).
    - Because the slider snaps to marks, equality is required (no tolerance needed).
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        alpha: 0.25
      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:
  - Slider stops on a different mark (0%, 50%, 75%, or 100%).
  - Changing other UI elements without setting the Opacity mark.
  - Leaving the thumb between marks (should not be possible if step is disabled).
  expected_interaction_path:
  - Grab the Opacity slider thumb.
  - Drag left until it snaps to the 25% mark.
  - Release and confirm the displayed value is 25%.
  notes: 'Implementation hint: use marks with step=null to restrict to the mark values (per MUI Slider docs).'
- id: alpha_slider-mui-T03
  name: Enter opacity as a percentage (85%)
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider + TextField (opacity %) (composite)'
  task_template: enter_formatted
  secondary_template: set_scalar
  browsergym_goal: In the Opacity (%) field, enter 85 and commit it (press Enter). The task will finish automatically when done.
  ui_copy: In the Opacity (%) field, enter 85 and commit it (press Enter).
  setup_description: |-
    A centered card titled "Opacity Input" provides two linked sub-controls for the same alpha value:
    - A MUI Slider labeled "Opacity" (0–100).
    - A MUI TextField labeled "Opacity (%)" to the right of the slider. It accepts an integer percent (0–100).
    Behavior:
    - Typing a number and pressing Enter commits the value and updates the slider thumb position immediately.
    - Dragging the slider also updates the TextField.
    Initial state:
    - Opacity starts at 50% (TextField shows 50).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 1
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Direct numeric entry with immediate feedback reduces motor control demands compared to dragging.
  success_trigger:
    human_readable:
    - The opacity value is set to alpha=0.85 (85%).
    - Alpha must be within ±0.01 of the target value.
    - No separate confirmation click is required beyond committing the field (Enter or blur).
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.85
      tolerance:
        abs: 0.01
      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:
  - Entering an out-of-range value (e.g., >100 or <0) that is rejected or clamped.
  - Typing 85 but not committing the field (value remains at the old opacity).
  - Opacity ends outside tolerance (e.g., 75% or 95%).
  expected_interaction_path:
  - Click the 'Opacity (%)' input.
  - Type 85.
  - Press Enter (or click outside) to commit and verify the slider/preview updates.
  notes: Checker should read the underlying alpha state (0–1) derived from the slider value / 100.
- id: alpha_slider-mui-T04
  name: Reset opacity to 100% with a reset control
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider + Reset button (composite)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Opacity back to 100%. The task will finish automatically when done.
  ui_copy: Reset the Opacity back to 100%.
  setup_description: |-
    A centered card titled "Overlay Controls" contains two stacked controls:
    - Target: a MUI Slider labeled "Opacity" (0–100) controlling the overlay alpha.
    - Distractor: a MUI Slider labeled "Blur" controlling a visual blur amount (not checked for success).
    To the right of the Opacity row, there is a small text button labeled "Reset opacity".
    Initial state:
    - Opacity starts at 35%.
    - Blur starts at 8 (arbitrary).
    Feedback:
    - Clicking "Reset opacity" immediately sets Opacity back to 100% and updates the preview and the slider thumb.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Presence of a similar distractor slider and a small reset control increases the chance of mis-targeting.
  success_trigger:
    human_readable:
    - The Opacity slider state is restored to alpha=1.00 (100%).
    - Alpha must be within ±0.005 of the target value.
    - No modal confirmation is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 1.0
      tolerance:
        abs: 0.005
      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:
  - Resetting or changing the Blur slider instead of Opacity.
  - Opacity remains partially transparent (not at full opacity).
  - Opacity ends outside tolerance.
  expected_interaction_path:
  - Find the row labeled Opacity.
  - Click 'Reset opacity' (or drag the slider to 100%).
  - Confirm the preview looks fully opaque and the value reads 100%.
  notes: If providing a reset button, attach data-testid='reset-opacity' for reliable control selection.
- id: alpha_slider-mui-T05
  name: Match heatmap overlay opacity to target preview
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider (opacity) + current/target preview chips (composite)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the Heatmap overlay opacity to the Target preview in the form section. The task will finish automatically when done.
  ui_copy: Match the Heatmap overlay opacity to the Target preview in the form section.
  setup_description: |-
    A form section titled "Map appearance" contains typical form fields (clutter low):
    - TextField "Layer name" (distractor)
    - Switch "Show labels" (distractor)
    - Target control: "Heatmap overlay opacity" row with:
      * A checkerboard preview chip labeled "Current"
      * A second preview chip labeled "Target" (fixed reference)
      * A MUI Slider labeled "Opacity" (0–100) directly beneath the previews
    Initial state:
    - Current opacity starts at 80%, clearly darker than the Target.
    Guidance:
    - The desired transparency is provided visually by the Target preview chip.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: User must visually match transparency using the preview; numeric value is not the primary guidance.
  success_trigger:
    human_readable:
    - The heatmap overlay alpha matches the Target preview (alpha=0.45).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.45
      tolerance:
        abs: 0.02
      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:
  - Adjusting other form fields without matching the opacity.
  - Opacity ends outside tolerance.
  - Matching the overall color (if any) but not the transparency.
  expected_interaction_path:
  - Locate the 'Heatmap overlay opacity' row in the form section.
  - Adjust the Opacity slider while comparing Current vs Target previews.
  - Stop when the previews match.
  notes: The checker should compute alpha = sliderValue/100 for this composite and ignore other form fields.
- id: alpha_slider-mui-T06
  name: Scroll to overlays section and set map opacity to 40%
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider embedded in a long settings panel (composite)'
  task_template: scroll_find
  secondary_template: set_scalar
  browsergym_goal: Scroll to the Overlays section and set Map overlay opacity to 40%. The task will finish automatically when done.
  ui_copy: Scroll to the Overlays section and set Map overlay opacity to 40%.
  setup_description: |-
    A settings panel page contains a long scrollable column of settings (medium clutter):
    - Top sections: "General", "Performance", "Labels" with various toggles and dropdowns (distractors).
    - Near the bottom is the "Overlays" section (initially below the fold).
    - In "Overlays", the target control is a MUI Slider labeled "Map overlay opacity" with a small checkerboard preview.
    Initial state:
    - Map overlay opacity starts at 55%.
    Feedback:
    - Slider updates the preview immediately; no Apply button.
  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: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Finding the correct section requires scrolling through distractors; once found, setting 40% is moderately precise.
  success_trigger:
    human_readable:
    - The 'Map overlay opacity' alpha is set to 0.40 (40%).
    - Alpha must be within ±0.015 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.4
      tolerance:
        abs: 0.015
      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 in the wrong section and adjusting a different slider.
  - Opacity ends outside tolerance.
  - Only scrolling without setting the opacity value.
  expected_interaction_path:
  - Scroll down until the Overlays section is visible.
  - Locate the 'Map overlay opacity' slider.
  - Adjust the slider to ~40%.
  notes: For automated checking, ensure the slider has a stable aria-label like 'Map overlay opacity'.
- id: alpha_slider-mui-T07
  name: Set small corner toast opacity to 15%
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Slider size="small" in corner card (composite)'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Toast opacity to 15%. The task will finish automatically when done.
  ui_copy: Set the Toast opacity to 15%.
  setup_description: |-
    A small card is anchored in the bottom-right corner of the viewport:
    - Title: "Toast Opacity"
    - A compact MUI Slider (size="small") labeled "Opacity" controls the alpha of a toast preview.
    - The slider thumb and track are smaller than default; spacing is still comfortable, but the overall card is narrower.
    - A text line under the slider shows "Current opacity: XX%".
    Initial state:
    - Opacity starts at 50%.
    No overlay or extra controls.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Small slider in a corner requires more careful pointer control to reach a low opacity target (15%).
  success_trigger:
    human_readable:
    - The toast opacity alpha is set to 0.15 (15%).
    - Alpha must be within ±0.015 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.15
      tolerance:
        abs: 0.015
      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:
  - Opacity ends outside tolerance (too transparent or too opaque).
  - Clicking elsewhere without changing the slider value.
  - Setting a different value because the value label is not always visible.
  expected_interaction_path:
  - Locate the bottom-right 'Toast Opacity' card.
  - Drag the small Opacity slider thumb left until the text readout is near 15%.
  - Release and verify the readout.
  notes: Place the component in bottom_right to test coordinate-action robustness and edge-of-viewport interactions.
- id: alpha_slider-mui-T08
  name: Set overlay opacity to 70% in dialog and apply
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Dialog + Slider (opacity) + Apply/Cancel actions (composite)'
  task_template: confirm_cancel
  secondary_template: set_scalar
  browsergym_goal: Open the Overlay settings dialog, set Overlay opacity to 70%, then click Apply changes. The task will finish automatically when done.
  ui_copy: Open the Overlay settings dialog, set Overlay opacity to 70%, then click Apply changes.
  setup_description: |-
    A modal workflow:
    - Main page shows a preview card and a button "Edit overlay settings".
    - Clicking the button opens a MUI Dialog titled "Overlay settings".
    - Inside the dialog is the target MUI Slider labeled "Overlay opacity" (0–100) with a small checkerboard preview.
    - Dialog actions include "Cancel" and a primary button "Apply changes".
    Commit behavior:
    - While the dialog is open, adjustments are treated as draft; the committed preview on the main page updates only after clicking "Apply changes".
    Initial state:
    - Committed opacity is 100% before opening the dialog.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 2
    justification: The agent must work within a dialog and remember to commit with Apply; draft vs committed state increases feedback complexity.
  success_trigger:
    human_readable:
    - The committed overlay opacity alpha is 0.70 (70%).
    - Alpha must be within ±0.01 of the target value.
    - The 'Apply changes' button must be clicked to commit.
    - The task ends when the committed state satisfies the predicate.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.7
      tolerance:
        abs: 0.01
      require_confirm: true
      confirm_control: Apply changes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the correct value but clicking Cancel (discarding changes).
  - Leaving the dialog without clicking Apply changes.
  - Committed opacity ends outside tolerance.
  expected_interaction_path:
  - Click 'Edit overlay settings' to open the dialog.
  - Adjust the 'Overlay opacity' slider to ~70%.
  - Click 'Apply changes'.
  notes: Checker must validate the committed value (outside-dialog state) to catch the common 'forgot to apply' failure.
- id: alpha_slider-mui-T09
  name: Set overlay opacity to 55% (two opacity sliders present)
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Two Slider instances (overlay vs shadow opacity) (composite)'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Overlay opacity to 55%. The task will finish automatically when done.
  ui_copy: Set the Overlay opacity to 55%.
  setup_description: |-
    A dashboard card titled "Card Styling" contains two opacity sliders (same canonical type, instances=2):
    - Slider A (target): labeled "Overlay opacity"
    - Slider B (distractor): labeled "Shadow opacity"
    Both are MUI Sliders (0–100) with similar appearance and both update small preview chips next to their labels.
    Initial state:
    - Overlay opacity = 30%
    - Shadow opacity = 70%
    Clutter:
    - Additional dashboard elements (mini chart, metrics) appear above the sliders, but they are not interactive for this task.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 5
    justification: Two visually similar opacity sliders require careful label-based disambiguation; adjusting the wrong one is a common failure mode.
  success_trigger:
    human_readable:
    - The 'Overlay opacity' instance alpha is set to 0.55 (55%).
    - Alpha must be within ±0.01 of the target value.
    - The correct instance must be modified (Overlay opacity, not Shadow opacity).
    - The task ends when the predicate holds for the correct instance.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.55
      tolerance:
        abs: 0.01
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Overlay opacity
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting Shadow opacity to 55% while Overlay opacity remains incorrect.
  - Overlay opacity ends outside tolerance.
  - Changing both sliders and leaving overlay incorrect.
  expected_interaction_path:
  - Locate the slider labeled 'Overlay opacity'.
  - Adjust it to about 55% (use value label or text readout if present).
  - Avoid changing 'Shadow opacity'.
  notes: To support checker and disambiguation analysis, expose stable ids per slider (e.g., data-testid='overlay-opacity-slider').
- id: alpha_slider-mui-T10
  name: Match header scrim opacity to target (dark theme, 2 instances)
  canonical_type: alpha_slider
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Two Slider instances with current/target previews (composite)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the dark Scrim Opacity card, set the Header scrim to match the Target (35% opacity). The task will finish automatically when done.
  ui_copy: In the dark Scrim Opacity card, set the Header scrim to match the Target (35% opacity).
  setup_description: |-
    A dark theme card titled "Scrim Opacity" contains TWO opacity controls (instances=2):
    - Row 1 (target): "Header scrim"
    - Row 2: "Footer scrim"
    Each row shows:
    - A live "Current" preview chip and a fixed "Target" preview chip on checkerboard.
    - A MUI Slider labeled "Opacity" directly below the previews for that row.
    Guidance:
    - Mixed: the Target chip is shown visually, and a small caption under the Header Target chip reads "Target: 35%".
    Initial state:
    - Header scrim opacity = 80%
    - Footer scrim opacity = 20%
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Dark theme plus two similar instances increases mis-target risk; 35% requires moderately tight precision.
  success_trigger:
    human_readable:
    - The 'Header scrim' instance alpha matches the target (alpha=0.35).
    - Alpha must be within ±0.01 of the target value.
    - The correct instance must be modified (Header scrim).
    - No confirmation click is required.
    - The task ends when the predicate holds for the correct instance.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.35
      tolerance:
        abs: 0.01
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Header scrim
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Adjusting Footer scrim instead of Header scrim.
  - Header scrim alpha ends outside tolerance.
  - Matching the visual chip but leaving alpha slightly outside tolerance.
  expected_interaction_path:
  - Locate the 'Header scrim' row.
  - Adjust its Opacity slider while comparing Current vs Target (and the 35% caption).
  - Stop when the header matches the target.
  notes: 'Useful for testing mixed guidance: both visual reference and explicit numeric target are present.'
- id: alpha_slider-mantine-T01
  name: Set button opacity to 50% (AlphaSlider)
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Button background opacity to 50%. The task will finish automatically when done.
  ui_copy: Set the Button background opacity to 50%.
  setup_description: |-
    A centered card titled "Primary Button Opacity" uses Mantine's standalone AlphaSlider:
    - A checkerboard preview swatch labeled "Button background" shows the current transparency.
    - Under the preview is a Mantine AlphaSlider (color is fixed to a blue base, e.g., #1c7ed6).
    - A text line above the slider displays the current value as both: "Alpha: 1.00" and "Opacity: 100%".
    Initial state:
    - Alpha starts at 1.00 (fully opaque).
    Feedback:
    - Moving the slider updates the preview swatch and the text value immediately.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single standalone AlphaSlider with explicit numeric feedback makes reaching 50% easy.
  success_trigger:
    human_readable:
    - The button background alpha is set to 0.50 (50% opacity).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.5
      tolerance:
        abs: 0.02
      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:
  - Alpha ends outside tolerance.
  - Interacting with the page without changing the AlphaSlider value.
  expected_interaction_path:
  - Locate the AlphaSlider under 'Primary Button Opacity'.
  - Drag the slider thumb until the displayed alpha/opacity is about 0.50 / 50%.
  - Release and verify the value.
  notes: Mantine provides AlphaSlider as a standalone component; expose aria-label via alphaLabel when possible for screen reader/AX-tree observability.
- id: alpha_slider-mantine-T02
  name: Drag watermark opacity to 20% (large AlphaSlider)
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider (large size)'
  task_template: drag_operation
  secondary_template: null
  browsergym_goal: Drag the Watermark opacity slider to 20%. The task will finish automatically when done.
  ui_copy: Drag the Watermark opacity slider to 20%.
  setup_description: |-
    A centered card titled "Watermark Opacity" uses a large Mantine AlphaSlider for easy dragging:
    - The AlphaSlider is rendered with a larger size (lg/xl styling) and a wide track.
    - A preview rectangle labeled "Watermark sample" sits above it on a checkerboard background.
    - A text readout shows "Opacity: XX%".
    Initial state:
    - Opacity starts at 100%.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: large
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Large slider track and simple goal make the drag straightforward even for coordinate-based agents.
  success_trigger:
    human_readable:
    - The watermark alpha is set to 0.20 (20% opacity).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.2
      tolerance:
        abs: 0.02
      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:
  - Opacity ends outside tolerance.
  - Leaving the slider at the initial value.
  expected_interaction_path:
  - Locate the Watermark AlphaSlider.
  - Drag the thumb left until the readout is near 20%.
  - Release and verify.
  notes: 'Good baseline drag test: large target, minimal clutter.'
- id: alpha_slider-mantine-T03
  name: Reset badge opacity to 100%
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider + Reset button'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Reset the Badge opacity back to 100%. The task will finish automatically when done.
  ui_copy: Reset the Badge opacity back to 100%.
  setup_description: |-
    A centered card titled "Badge Transparency" contains:
    - A checkerboard preview chip showing the current badge background.
    - A Mantine AlphaSlider controlling the badge alpha.
    - A small button labeled "Reset" aligned to the right of the slider row.
    Initial state:
    - Badge alpha starts at 0.65 (65% opacity), so the badge looks slightly transparent.
    Behavior:
    - Clicking "Reset" sets alpha back to 1.00 immediately and updates the preview and value text.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Reset target is the default full opacity and a dedicated Reset button is available.
  success_trigger:
    human_readable:
    - The badge alpha is set to 1.00 (100% opacity).
    - Alpha must be within ±0.005 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 1.0
      tolerance:
        abs: 0.005
      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:
  - Opacity remains below full (alpha < 0.995).
  - Changing some other control without restoring full opacity.
  expected_interaction_path:
  - Click the 'Reset' button (or drag the AlphaSlider to the far right).
  - Verify the value shows 1.00 / 100%.
  notes: Attach data-testid='mantine-reset-alpha' for the reset control; checker should still validate alpha from state.
- id: alpha_slider-mantine-T04
  name: Enter alpha as a decimal (0.75)
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider + NumberInput (alpha 0–1)'
  task_template: enter_formatted
  secondary_template: set_scalar
  browsergym_goal: Set alpha to 0.75 using the Alpha (0–1) input (commit the value). The task will finish automatically when done.
  ui_copy: Set alpha to 0.75 using the Alpha (0–1) input (commit the value).
  setup_description: |-
    A centered card titled "RGBA Alpha" provides two linked sub-controls for the same alpha value:
    - Mantine AlphaSlider (value in range 0.00–1.00).
    - Mantine NumberInput labeled "Alpha (0–1)" with step 0.01 and 2-decimal formatting.
    Behavior:
    - Changing either control updates the other immediately after commit (Enter or blur for the NumberInput).
    - The current value is shown as "Alpha: 0.xx".
    Initial state:
    - Alpha starts at 0.40.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires entering a formatted decimal value (0–1) and committing the input so the slider state updates.
  success_trigger:
    human_readable:
    - The alpha value is set to 0.75.
    - Alpha must be within ±0.01 of the target value.
    - The NumberInput must be committed (Enter or blur) if used; live state must reflect the target.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.75
      tolerance:
        abs: 0.01
      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:
  - Typing 0.75 but not committing (alpha remains at the old value).
  - Entering 75 instead of 0.75 (wrong format).
  - Alpha ends outside tolerance.
  expected_interaction_path:
  - Click the 'Alpha (0–1)' input.
  - Type 0.75.
  - Press Enter (or click outside) to commit and verify the AlphaSlider updates.
  notes: Checker should validate the underlying alpha float (0–1) stored in state, not just the formatted text.
- id: alpha_slider-mantine-T05
  name: Match overlay opacity using Mantine ColorPicker
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: ColorPicker
  implementation_component: 'Mantine: ColorPicker (format="rgba", includes alpha slider)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Using the ColorPicker, match the Card overlay opacity to the Target overlay swatch. The task will finish automatically when done.
  ui_copy: Using the ColorPicker, match the Card overlay opacity to the Target overlay swatch.
  setup_description: |-
    A centered card titled "Card Overlay (ColorPicker)" uses Mantine ColorPicker in RGBA mode:
    - The ColorPicker is rendered inline (not in a popover) so the saturation area, hue slider, and alpha slider are all visible.
    - Because format is RGBA, the component shows a color preview (checkerboard) and includes an alpha slider.
    - A separate fixed "Target overlay" preview swatch is shown to the right for visual matching.
    Initial state:
    - The base color is fixed (blue) and the starting alpha is 1.00 (fully opaque).
    Distractors:
    - The saturation area and hue slider are interactive and visually prominent, but success is based ONLY on alpha.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Full ColorPicker introduces multiple similar controls; user must identify and adjust only the alpha slider while matching a visual reference.
  success_trigger:
    human_readable:
    - The card overlay alpha matches the Target overlay swatch (alpha=0.40).
    - Alpha must be within ±0.02 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.4
      tolerance:
        abs: 0.02
      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:
  - Changing hue/saturation without matching transparency.
  - Alpha ends outside tolerance.
  - Matching the overall look by changing color instead of opacity (alpha still wrong).
  expected_interaction_path:
  - Locate the alpha slider within the ColorPicker (usually below the hue slider).
  - Adjust the alpha slider while comparing to the Target overlay swatch.
  - Stop when transparency matches.
  notes: Checker should extract alpha from the current RGBA value emitted by Mantine ColorPicker.
- id: alpha_slider-mantine-T06
  name: Expand advanced section and set watermark opacity to 55%
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: Accordion + AlphaSlider'
  task_template: disclose
  secondary_template: set_scalar
  browsergym_goal: Expand "Advanced transparency" and set Watermark opacity to 55%. The task will finish automatically when done.
  ui_copy: Expand "Advanced transparency" and set Watermark opacity to 55%.
  setup_description: |-
    A form section titled "Image watermark" includes an accordion for advanced options:
    - Above the accordion are basic fields (TextInput "Watermark text", Select "Position") as distractors.
    - An accordion item labeled "Advanced transparency" is collapsed by default.
    - Inside the accordion content is the target Mantine AlphaSlider labeled "Watermark opacity" and a checkerboard preview.
    Initial state:
    - Watermark alpha starts at 1.00.
    Interaction requirement:
    - The AlphaSlider is not visible until the accordion is expanded.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires disclosing an accordion section before interacting with the slider; adds one layer of UI depth and distractors.
  success_trigger:
    human_readable:
    - The watermark opacity alpha is set to 0.55 (55%).
    - Alpha must be within ±0.02 of the target value.
    - No separate confirmation is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.55
      tolerance:
        abs: 0.02
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not expanding the accordion (slider never changed).
  - Adjusting a non-target control (position/text) instead of opacity.
  - Alpha ends outside tolerance.
  expected_interaction_path:
  - Click the 'Advanced transparency' accordion header to expand it.
  - Locate the 'Watermark opacity' AlphaSlider.
  - Adjust it to ~55%.
  notes: Good for testing interplay of disclosure + slider; checker still only depends on alpha state.
- id: alpha_slider-mantine-T07
  name: Set Sidebar table-row opacity to 30%
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider embedded in Table cell'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the table, set the Sidebar opacity to 30%. The task will finish automatically when done.
  ui_copy: In the table, set the Sidebar opacity to 30%.
  setup_description: |-
    A small table (table_cell layout) shows per-area opacity controls:
    - Two rows: "Header" and "Sidebar".
    - Each row has a Mantine AlphaSlider embedded in the right-hand cell (instances=2 of the same canonical type).
    - Sliders are compact to fit the table row height; each row also shows a tiny checkerboard preview square.
    Initial state:
    - Header alpha = 0.80
    - Sidebar alpha = 0.50
    Clutter:
    - The table has only these two rows and minimal extra UI; the main challenge is selecting the correct row's slider.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Embedded table-cell sliders are small and there are two similar instances; requires precise adjustment on the correct row.
  success_trigger:
    human_readable:
    - The 'Sidebar' instance alpha is set to 0.30 (30% opacity).
    - Alpha must be within ±0.01 of the target value.
    - The correct instance must be modified (Sidebar row).
    - The task ends when the predicate holds for the correct instance.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.3
      tolerance:
        abs: 0.01
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Sidebar
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the Header row to 30% instead of Sidebar.
  - Sidebar alpha ends outside tolerance.
  - Changing both rows and leaving Sidebar incorrect.
  expected_interaction_path:
  - Locate the 'Sidebar' row in the table.
  - Drag the AlphaSlider in that row to about 30%.
  - Verify you did not change the Header row slider.
  notes: Ensure each row has a stable identifier so the checker can bind to 'Sidebar' vs 'Header' instances.
- id: alpha_slider-mantine-T08
  name: Match backdrop opacity to target (dark theme, no numeric readout)
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider (visual-only feedback)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Match the Backdrop opacity to the Target preview. The task will finish automatically when done.
  ui_copy: Match the Backdrop opacity to the Target preview.
  setup_description: |-
    A dark theme page with a single centered card titled "Backdrop Transparency":
    - Two large preview rectangles on a checkerboard: "Current" (live) and "Target" (fixed reference).
    - A Mantine AlphaSlider (color fixed) sits below the previews.
    - The UI is minimal: the numeric alpha/percent readout is not shown; only the previews provide feedback.
    Initial state:
    - Current alpha starts at 0.80, visibly darker than the Target.
    Guidance:
    - Visual-only matching against the Target preview.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 5
      disambiguation_load: 1
    justification: No numeric feedback forces pure visual matching in dark theme; semantic observability is the main difficulty driver.
  success_trigger:
    human_readable:
    - The backdrop alpha matches the Target preview (alpha=0.42).
    - Alpha must be within ±0.015 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.42
      tolerance:
        abs: 0.015
      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 when the preview is close but alpha is outside tolerance.
  - Adjusting the slider without matching the Target transparency.
  expected_interaction_path:
  - Compare the Current and Target previews.
  - Adjust the AlphaSlider until the Current preview matches the Target.
  - Stop when the transparency visually aligns.
  notes: Hide numeric value text intentionally for this task; checker still validates alpha from internal state.
- id: alpha_slider-mantine-T09
  name: Set scrim opacity in modal via ColorInput and save
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: ColorInput
  implementation_component: 'Mantine: ColorInput (rgba) inside Modal'
  task_template: confirm_cancel
  secondary_template: open_and_select
  browsergym_goal: Open the Scrim settings, set Scrim color opacity to 33%, then click Save. The task will finish automatically when done.
  ui_copy: Open the Scrim settings, set Scrim color opacity to 33%, then click Save.
  setup_description: |-
    A modal workflow for editing a scrim color:
    - Main page shows a button "Edit scrim".
    - Clicking opens a modal titled "Scrim settings".
    - Inside the modal is a Mantine ColorInput labeled "Scrim color" (configured in RGBA so alpha is available).
    - Clicking the ColorInput swatch opens its dropdown/popover with a ColorPicker that includes an alpha slider.
    - Modal footer has "Cancel" and a primary "Save" button.
    Commit behavior:
    - Changes are considered draft while the modal is open; the committed scrim preview updates only after clicking Save.
    Initial state:
    - Committed scrim alpha is 1.00 before opening.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 2
    justification: Nested overlays (modal + ColorInput popover) and required Save confirmation create layered interaction and feedback challenges.
  success_trigger:
    human_readable:
    - The committed scrim alpha is set to 0.33 (33% opacity).
    - Alpha must be within ±0.01 of the target value.
    - The modal 'Save' button must be clicked to commit the value.
    - The task ends when the committed state satisfies the predicate.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.33
      tolerance:
        abs: 0.01
      require_confirm: true
      confirm_control: Save
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting opacity correctly in the popover but not clicking Save (draft only).
  - Clicking Cancel (discarding changes).
  - Committed alpha ends outside tolerance.
  - Closing the ColorInput popover without setting alpha.
  expected_interaction_path:
  - Click 'Edit scrim' to open the modal.
  - Click the 'Scrim color' ColorInput to open the color picker popover.
  - Adjust the alpha slider to ~33%.
  - Click 'Save' in the modal footer.
  notes: 'Use stable ids for: open-modal button, ColorInput trigger, and modal Save button. Checker should read committed RGBA state after Save.'
- id: alpha_slider-mantine-T10
  name: Set small corner tooltip tint to 58%
  canonical_type: alpha_slider
  implementation_source: mantine
  implementation_variant: AlphaSlider
  implementation_component: 'Mantine: AlphaSlider (xs) in corner card'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the Tooltip tint opacity to 58%. The task will finish automatically when done.
  ui_copy: Set the Tooltip tint opacity to 58%.
  setup_description: |-
    A small card is anchored near the top-right corner of the viewport:
    - Title: "Tooltip Tint"
    - A compact Mantine AlphaSlider (xs styling) controls the tooltip tint alpha.
    - A small text readout shows "Opacity: XX%" but the space is tight and the slider thumb is small.
    Initial state:
    - Opacity starts at 90%.
    No other interactive controls are present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 5
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Very small slider in a corner requires precise pointer/keyboard control to hit 58% without overshooting.
  success_trigger:
    human_readable:
    - The tooltip tint alpha is set to 0.58 (58% opacity).
    - Alpha must be within ±0.01 of the target value.
    - No confirmation click is required.
    - The task ends when the predicate holds.
    canonical_predicate:
      predicate_type: within_tolerance
      target_state:
        alpha: 0.58
      tolerance:
        abs: 0.01
      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:
  - Opacity ends outside tolerance.
  - Leaving the slider at the initial value.
  - Setting a nearby value (e.g., 55% or 60%) that is outside tolerance.
  expected_interaction_path:
  - Locate the top-right 'Tooltip Tint' card.
  - Adjust the small AlphaSlider thumb to ~58% (may require fine drag or arrow keys).
  - Verify the readout.
  notes: Useful for edge-of-viewport and small-target robustness slices; ensure the slider remains fully visible (no clipping at viewport edge).