tasks/v1/cascader.yaml

- id: cascader-antd-T01
  name: 'Select office location: Zhejiang / Hangzhou / West Lake'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Office location field, select Zhejiang / Hangzhou / West Lake. The task will finish automatically when done.
  ui_copy: 'Office location: select Zhejiang / Hangzhou / West Lake. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: a single AntD Cascader input labeled “Office location” with placeholder “Please select”.
    Behavior: clicking the input opens a 3-column dropdown (province → city → landmark). Selection is committed immediately when the final (leaf) item is clicked.
    Options shown (representative):
      - Zhejiang → Hangzhou → West Lake
      - Jiangsu → Nanjing → Zhong Hua Men
    Initial state: no selection (placeholder visible).
    Distractors: none; only helper text under the field describing what a cascader is.
  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: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Small option tree with clear labels and a single instance; the main challenge is completing the full 3-level path selection.
  success_trigger:
    human_readable:
    - The only Cascader on the page has selected path labels exactly equal to [Zhejiang, Hangzhou, West Lake].
    - The selected path values exactly equal ['zhejiang','hangzhou','xihu'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Zhejiang
        - Hangzhou
        - West Lake
        path_values:
        - zhejiang
        - hangzhou
        - xihu
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Zhejiang or Zhejiang / Hangzhou but not selecting the final leaf (West Lake).
  - Selecting the wrong province/city/landmark path (e.g., Jiangsu / Nanjing / Zhong Hua Men).
  - Typing text elsewhere or interacting with non-target UI (there is none) without setting the cascader value.
  expected_interaction_path:
  - Click the Office location cascader input to open the dropdown.
  - Click Zhejiang in the first column.
  - Click Hangzhou in the second column.
  - Click West Lake in the third column to commit the selection.
  notes: |-
    Instrumentation: add data-testid='office-location-cascader' on the Cascader root.
    Checker: read the committed value array from the Cascader control (value path), not just the visible text.
- id: cascader-antd-T02
  name: Change preferred warehouse to Europe / Germany / Berlin
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Change the Preferred warehouse selection to Europe / Germany / Berlin. The task will finish automatically when done.
  ui_copy: 'Preferred warehouse: set to Europe / Germany / Berlin. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Preferred warehouse”.
    Initial state: pre-selected value shown in the input as “Americas / USA / New York”.
    Options: a 3-level geography tree (Region → Country → City) with a few entries:
      - Americas → USA → New York, Chicago
      - Americas → Canada → Toronto
      - Europe → Germany → Berlin
    Behavior: selecting a new leaf replaces the existing selection immediately.
    Distractors: a short paragraph explaining that this selection affects shipping estimates.
  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: 1
      disambiguation_load: 1
    justification: There is a single field and a small tree; the only extra step is replacing an existing default value.
  success_trigger:
    human_readable:
    - The Preferred warehouse Cascader value path equals Europe → Germany → Berlin.
    - The committed value array equals ['europe','de','berlin'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Europe
        - Germany
        - Berlin
        path_values:
        - europe
        - de
        - berlin
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving the default selection unchanged (Americas / USA / New York).
  - Selecting Europe / Germany but not selecting Berlin (partial path).
  - Selecting the wrong city (e.g., Toronto or Chicago).
  expected_interaction_path:
  - Click the Preferred warehouse cascader input to open the dropdown.
  - Click Europe → Germany → Berlin to commit the new selection.
  notes: |-
    Instrumentation: data-testid='preferred-warehouse-cascader'.
    Checker should assert the underlying value path, not just the rendered string.
- id: cascader-antd-T03
  name: Clear the Product category selection
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the Product category field so it is blank. The task will finish automatically when done.
  ui_copy: 'Product category: clear the selection (leave it blank). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Product category” with allowClear enabled.
    Initial state: the cascader currently shows “Electronics / Computers / Laptops”.
    UI details: when the input is hovered, a small clear (×) icon appears on the right side of the input.
    Behavior: clicking the clear icon removes the selection and returns the input to the placeholder state.
    Distractors: none.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single-field reset using the built-in clear affordance; no navigation through options is needed.
  success_trigger:
    human_readable:
    - Product category Cascader has no selected value (empty / null value path).
    - The placeholder is visible and no selection tags/text are present.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opening the dropdown but leaving the existing selection intact.
  - Selecting a different category instead of clearing.
  - Clearing the wrong field (there is only one cascader on the page).
  expected_interaction_path:
  - Hover the Product category input if needed to reveal the clear icon.
  - Click the clear (×) icon to reset the cascader to blank.
  notes: |-
    Instrumentation: data-testid='product-category-cascader'.
    Checker: treat both null and empty-array value as 'no selection' depending on the adapter.
- id: cascader-antd-T04
  name: 'Inline panel: select Engineering / Frontend / Web Platform'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: panel
  implementation_component: 'AntD: Cascader.Panel'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Team routing panel, select Engineering / Frontend / Web Platform. The task will finish automatically when done.
  ui_copy: 'Team routing: select Engineering / Frontend / Web Platform. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: an inline AntD Cascader.Panel labeled “Team routing” (always visible; no trigger input).
    Panel layout: three adjacent columns are shown at once (Department → Team → Subteam).
    Options (representative):
      - Engineering → Frontend → Web Platform, Design Systems
      - Engineering → Backend → Payments, Data
      - Operations → IT → Helpdesk
    Initial state: nothing selected in the panel.
    Distractors: none; the panel is the only interactive component 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: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Inline panel avoids overlay management; the agent only needs to click through a short 3-level hierarchy.
  success_trigger:
    human_readable:
    - The Cascader.Panel selected path labels equal [Engineering, Frontend, Web Platform].
    - The selected path values equal ['eng','fe','web-platform'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Engineering
        - Frontend
        - Web Platform
        path_values:
        - eng
        - fe
        - web-platform
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different subteam (e.g., Engineering / Frontend / Design Systems).
  - Stopping at a non-leaf level (e.g., selecting Engineering only).
  - Interacting with the page without changing the panel selection.
  expected_interaction_path:
  - In the first column, click Engineering.
  - In the second column, click Frontend.
  - In the third column, click Web Platform.
  notes: |-
    Instrumentation: data-testid='team-routing-cascader-panel'.
    Checker: read the committed selection from the panel state; selection occurs on leaf click.
- id: cascader-antd-T05
  name: 'Dark theme: pick Europe / France / Paris'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Travel destination field, select Europe / France / Paris. The task will finish automatically when done.
  ui_copy: 'Travel destination: choose Europe / France / Paris. The task will finish automatically when done.'
  setup_description: |-
    Theme: dark.
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Travel destination”.
    Options: Region → Country → City with a small set:
      - Europe → France → Paris
      - Europe → Spain → Madrid
      - Asia → Japan → Tokyo
    Initial state: empty (placeholder visible).
    Distractors: none.
  scene_context:
    theme: dark
    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: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Same simple 3-level selection as the baseline, but in dark theme which can slightly reduce visual salience.
  success_trigger:
    human_readable:
    - Travel destination cascader selected path labels equal [Europe, France, Paris].
    - Selected path values equal ['europe','fr','paris'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Europe
        - France
        - Paris
        path_values:
        - europe
        - fr
        - paris
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting the wrong city (Madrid or Tokyo).
  - Stopping before the leaf city is selected.
  - Leaving the cascader blank.
  expected_interaction_path:
  - Click the Travel destination input to open the dropdown.
  - Click Europe → France → Paris.
  notes: 'Instrumentation: data-testid=''travel-destination-cascader''.'
- id: cascader-antd-T06
  name: 'Two instances: set Primary office to North America / Canada / Vancouver'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: Set the Primary office field to North America / Canada / Vancouver. The task will finish automatically when done.
  ui_copy: 'Primary office: North America / Canada / Vancouver. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Components: two AntD Cascader inputs using the same options tree.
      1) “Primary office” (target)
      2) “Backup office” (distractor)
    Options: Continent → Country → City:
      - North America → USA → Seattle, Austin
      - North America → Canada → Vancouver, Montreal
      - Europe → UK → London
    Initial state: Primary office is blank; Backup office is preselected to “Europe / UK / London”.
    Distractors: the two fields are visually similar; only the label distinguishes them.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 3
    justification: Selection is straightforward, but there are two identical cascaders so the agent must target the correct labeled instance.
  success_trigger:
    human_readable:
    - The cascader labeled “Primary office” has selected path labels [North America, Canada, Vancouver].
    - The cascader labeled “Backup office” may remain unchanged.
    - Primary office selected path values equal ['na','ca','vancouver'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - North America
        - Canada
        - Vancouver
        path_values:
        - na
        - ca
        - vancouver
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: primary-office
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting the Backup office instead of Primary office.
  - Selecting North America / Canada but choosing Montreal instead of Vancouver.
  - Leaving Primary office blank.
  expected_interaction_path:
  - Locate the cascader input labeled Primary office.
  - Open it and select North America → Canada → Vancouver.
  notes: |-
    Instrumentation: data-testid='cascader-primary-office' and data-testid='cascader-backup-office'.
    Checker: ensure correct-instance by binding to label or testid, not by DOM order.
- id: cascader-antd-T07
  name: Match the Target breadcrumb for Selected service
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (show full path display)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set Selected service to match the breadcrumb shown in the Target path box. The task will finish automatically when done.
  ui_copy: Match Selected service to the Target path shown. The task will finish automatically when done.
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Selected service”.
    Guidance element: a non-interactive “Target path” preview box above the cascader showing a styled breadcrumb with the desired path (e.g., Services › Consulting › Security Review).
    Options tree: Service line → Offering → Package:
      - Services → Consulting → Security Review (target)
      - Services → Consulting → Architecture Review
      - Services → Support → Priority Support
    Initial state: Selected service is blank.
    Distractors: an extra note that explains the breadcrumb is the target reference.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires mapping a visual breadcrumb reference to the cascader selection, but the option set is small and there is only one field.
  success_trigger:
    human_readable:
    - Selected service cascader selected path equals the Target path breadcrumb shown on the page.
    - The selected path labels equal [Services, Consulting, Security Review].
    - The selected path values equal ['services','consulting','security-review'].
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_element_id: target-path-breadcrumb
        path_labels:
        - Services
        - Consulting
        - Security Review
        path_values:
        - services
        - consulting
        - security-review
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different consulting package (e.g., Architecture Review).
  - Selecting only part of the path (stopping before the leaf).
  - Leaving the cascader blank while the Target breadcrumb remains visible.
  expected_interaction_path:
  - Read the Target path breadcrumb in the reference box.
  - Open Selected service cascader and click Services → Consulting → Security Review.
  notes: |-
    Instrumentation: data-testid='selected-service-cascader' and data-testid='target-path-breadcrumb'.
    Checker: for matches_reference, compare cascader value path to the reference breadcrumb’s canonical path.
- id: cascader-antd-T08
  name: Open the Support topic cascader dropdown (leave it open)
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Support topic cascader so the dropdown options are visible, and leave it open. The task will finish automatically when done.
  ui_copy: 'Support topic: open the dropdown (do not select anything). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card anchored near the top-right of the viewport.
    Component: one AntD Cascader input labeled “Support topic”, initially blank.
    Options: Topic → Subtopic → Detail (examples):
      - Account → Billing → Refunds
      - Account → Login → Password reset
      - Product → Mobile → Crashes
    Behavior: clicking the input opens a floating multi-column dropdown. Clicking outside closes it.
    Goal of this task: only the open/closed state matters; no selection should be made.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    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: 2
      disambiguation_load: 1
    justification: Tests basic ability to open an overlay without making any selection; otherwise a simple single-instance setup.
  success_trigger:
    human_readable:
    - The Support topic cascader dropdown is open/visible (popup rendered).
    - The cascader still has no committed selection (value is null/empty).
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: true
        value: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting any option in the cascader (even if the dropdown is open).
  - Opening the dropdown and then closing it before the checker runs (open=false).
  - Interacting with other UI (none) while leaving the cascader closed.
  expected_interaction_path:
  - Click the Support topic cascader input to open the dropdown.
  - Do not click any option; keep the dropdown open.
  notes: |-
    Instrumentation: data-testid='support-topic-cascader'.
    Checker: determine open state via presence of the popup element bound to this cascader instance.
- id: cascader-antd-T09
  name: 'Compact spacing: select America / New York'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (size=middle)'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Timezone field, select America / New York. The task will finish automatically when done.
  ui_copy: 'Timezone: America / New York. The task will finish automatically when done.'
  setup_description: |-
    Spacing: compact mode (reduced padding between labels and controls).
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Timezone”.
    Options: Region → City (2 levels):
      - America → New York, Los Angeles
      - Europe → London
    Initial state: blank.
    Distractors: none.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Compact spacing reduces click target size slightly, but the hierarchy is shallow and the options are few.
  success_trigger:
    human_readable:
    - Timezone cascader selected path labels equal [America, New York].
    - Selected path values equal ['america','new-york'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - America
        - New York
        path_values:
        - america
        - new-york
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting America / Los Angeles.
  - Selecting Europe / London.
  - Leaving the field blank.
  expected_interaction_path:
  - Open the Timezone cascader.
  - Click America, then click New York.
  notes: 'Instrumentation: data-testid=''timezone-cascader''.'
- id: cascader-antd-T10
  name: 'Search and select: South Campus / Art Studio (top-left placement)'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (showSearch=true)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Use the search in the Campus building selector to choose South Campus / Art Studio. The task will finish automatically when done.
  ui_copy: 'Campus building: search and pick South Campus / Art Studio. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card anchored near the top-left of the viewport.
    Component: one AntD Cascader labeled “Campus building” with showSearch enabled.
    UI behavior: opening the cascader reveals a search input; typing filters the available paths.
    Options: Campus → Building:
      - North Campus → Science Hall, Library
      - South Campus → Gym, Art Studio (target)
    Initial state: blank.
    Distractors: the dropdown still supports manual column navigation, but the intent is to use search.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Adds a search box interaction step, but the filtered results are few and the target is unique.
  success_trigger:
    human_readable:
    - Campus building cascader selected path labels equal [South Campus, Art Studio].
    - Selected path values equal ['south','art-studio'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - South Campus
        - Art Studio
        path_values:
        - south
        - art-studio
      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:
  - Typing in the search box but not selecting a result (no committed value).
  - Selecting South Campus / Gym.
  - Selecting a North Campus building.
  expected_interaction_path:
  - Open the Campus building cascader dropdown.
  - Type a query like “Art” in the search input.
  - Click the result path for South Campus / Art Studio.
  notes: |-
    Instrumentation: data-testid='campus-building-cascader'.
    Checker: verify committed value path; do not accept merely having search text present.
- id: cascader-antd-T11
  name: 'Two instances: set Billing region to United States / California / San Jose'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: Set the Billing region field to United States / California / San Jose. The task will finish automatically when done.
  ui_copy: 'Billing region: United States / California / San Jose. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Components: two similar AntD Cascader inputs stacked vertically:
      1) “Shipping region” (distractor)
      2) “Billing region” (target)
    Options: Country → State/Territory → City, with several similar city names:
      - United States → California → San Jose (target), San Diego
      - United States → Texas → San Antonio
      - Puerto Rico → (territory) → San Juan
    Initial state: Shipping region is set to “Puerto Rico / San Juan”; Billing region is blank.
    Distractors: multiple cities start with “San …”, so reading the full path is required.
  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: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires disambiguating between similar city names and choosing the correct labeled field among two instances.
  success_trigger:
    human_readable:
    - The cascader labeled “Billing region” has selected path labels [United States, California, San Jose].
    - Billing region selected path values equal ['us','ca','san-jose'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - United States
        - California
        - San Jose
        path_values:
        - us
        - ca
        - san-jose
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: billing-region
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting Shipping region instead of Billing region.
  - Selecting a different “San …” city (San Diego, San Antonio, or San Juan).
  - Stopping at United States / California without selecting the city leaf.
  expected_interaction_path:
  - Locate the Billing region cascader (not Shipping region).
  - Open it and select United States → California → San Jose.
  notes: |-
    Instrumentation: data-testid='shipping-region-cascader' and data-testid='billing-region-cascader'.
    Checker: enforce correct instance by testid/label binding.
- id: cascader-antd-T12
  name: 'Mixed guidance: match Target breadcrumb for Cost center'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set Cost center to match the Target breadcrumb shown on the page (it starts with “Finance”). The task will finish automatically when done.
  ui_copy: 'Cost center: match the Target breadcrumb (starts with Finance). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Cost center”.
    Guidance elements:
      - A “Target” breadcrumb preview directly above the field showing the full desired path as styled crumb chips.
      - A small text hint under the preview: “Target starts with Finance”.
    Options tree: Division → Department → Team:
      - Finance → Accounting → Accounts Payable (target)
      - Finance → Accounting → Accounts Receivable
      - Finance → FP&A → Forecasting
      - Operations → Procurement → Vendor Management
    Initial state: blank.
    Distractors: Finance has multiple similar teams under Accounting.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: The target is given via a reference breadcrumb plus a hint; difficulty comes from comparing the reference and selecting among similar Finance teams.
  success_trigger:
    human_readable:
    - Cost center cascader selected path equals the Target breadcrumb reference.
    - Selected path labels equal [Finance, Accounting, Accounts Payable].
    - Selected path values equal ['finance','acct','ap'].
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_element_id: target-cost-center-breadcrumb
        path_labels:
        - Finance
        - Accounting
        - Accounts Payable
        path_values:
        - finance
        - acct
        - ap
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Accounts Receivable instead of Accounts Payable.
  - Selecting a Finance path that does not match the Target breadcrumb.
  - Leaving the field blank.
  expected_interaction_path:
  - Read the Target breadcrumb (and optional hint).
  - Open Cost center cascader and select Finance → Accounting → Accounts Payable.
  notes: |-
    Instrumentation: data-testid='cost-center-cascader' and data-testid='target-cost-center-breadcrumb'.
    Checker: compare cascader value path to the reference breadcrumb’s canonical path.
- id: cascader-antd-T13
  name: 'Form section: set Department to Engineering / Platform / Infrastructure'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Project intake form, set Department to Engineering / Platform / Infrastructure. The task will finish automatically when done.
  ui_copy: 'Project intake: Department = Engineering / Platform / Infrastructure. The task will finish automatically when done.'
  setup_description: |-
    Layout: form section (a realistic intake form) centered on the page.
    Clutter: low — there are several non-required fields.
    Components on the form:
      - Text input: “Project name” (pre-filled)
      - Select: “Priority” (default set)
      - Cascader (target): “Department”
    Department options: Division → Group → Team:
      - Engineering → Platform → Infrastructure (target), Developer Experience
      - Engineering → Product → Web, Mobile
      - Sales → Enterprise → North America
    Initial state: Department is blank.
    Behavior: Department cascader commits on leaf click; no Save/Submit is required for this task.
  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: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 2
    justification: Additional form fields add mild distraction, but the cascader options are modest and clearly labeled.
  success_trigger:
    human_readable:
    - Department cascader selected path labels equal [Engineering, Platform, Infrastructure].
    - Selected path values equal ['eng','platform','infra'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Engineering
        - Platform
        - Infrastructure
        path_values:
        - eng
        - platform
        - infra
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Engineering / Platform / Developer Experience.
  - Selecting Engineering / Product / Web or another branch.
  - Changing other form fields while leaving Department unset.
  expected_interaction_path:
  - Locate the Department cascader in the form.
  - Open it and select Engineering → Platform → Infrastructure.
  notes: 'Instrumentation: data-testid=''department-cascader''.'
- id: cascader-antd-T14
  name: 'Dashboard filter: set Product taxonomy to Home / Kitchen / Coffee Makers'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: On the analytics dashboard, set the Product taxonomy filter to Home / Kitchen / Coffee Makers. The task will finish automatically when done.
  ui_copy: 'Dashboard filter: Product taxonomy = Home / Kitchen / Coffee Makers. The task will finish automatically when done.'
  setup_description: |-
    Layout: dashboard with a top filter bar.
    Clutter: medium — multiple filters and charts are present.
    Target component: an AntD Cascader in the filter bar labeled “Product taxonomy”.
    Other UI (distractors): a date range picker, a keyword search box, a region select, and several summary charts.
    Taxonomy options: Category → Subcategory → Product type:
      - Home → Kitchen → Coffee Makers (target), Cookware, Cutlery
      - Home → Lighting → Lamps
      - Electronics → Audio → Headphones
    Initial state: Product taxonomy is blank (interpreted as “All”).
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 3
    justification: The dashboard context adds competing interactive elements and a moderately dense taxonomy, but the target leaf is still easy to identify.
  success_trigger:
    human_readable:
    - Product taxonomy cascader selected path labels equal [Home, Kitchen, Coffee Makers].
    - Selected path values equal ['home','kitchen','coffee-makers'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Home
        - Kitchen
        - Coffee Makers
        path_values:
        - home
        - kitchen
        - coffee-makers
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Home / Kitchen / Cookware (neighbor leaf).
  - Interacting with other filters without setting Product taxonomy.
  - Leaving the filter at blank/all.
  expected_interaction_path:
  - Find the Product taxonomy cascader in the dashboard filter bar.
  - Open it and choose Home → Kitchen → Coffee Makers.
  notes: |-
    Instrumentation: data-testid='product-taxonomy-cascader'.
    Robustness: ensure charts are non-blocking and do not overlap the dropdown.
- id: cascader-antd-T15
  name: 'Cancel out: open Delivery zone and close without changing'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open the Delivery zone selector, then close it without changing the current selection (keep EMEA / UK / London). The task will finish automatically when done.
  ui_copy: 'Delivery zone: open then cancel (keep EMEA / UK / London). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card anchored near the bottom-left of the viewport.
    Component: one AntD Cascader labeled “Delivery zone”.
    Initial state: already selected to “EMEA / UK / London”.
    Options: Region → Country → City:
      - EMEA → UK → London (current)
      - EMEA → UAE → Dubai
      - Americas → USA → New York
    Behavior: opening the dropdown shows columns; clicking outside (or pressing Escape) closes the dropdown. Selection only changes if a new leaf is clicked.
    Goal: ensure the dropdown ends closed and the committed selection remains unchanged.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires managing overlay open/close while preserving the existing selection; success depends on both value and popup visibility.
  success_trigger:
    human_readable:
    - Delivery zone cascader dropdown is closed (open=false).
    - The committed selection remains exactly EMEA / UK / London with values ['emea','uk','london'].
    canonical_predicate:
      predicate_type: equals
      target_state:
        open: false
        path_labels:
        - EMEA
        - UK
        - London
        path_values:
        - emea
        - uk
        - london
      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:
  - Changing the selection to a different city (e.g., Dubai).
  - Leaving the dropdown open at the end.
  - Clearing the value or making the field blank.
  expected_interaction_path:
  - Click the Delivery zone input to open the dropdown.
  - Close the dropdown by clicking outside or pressing Escape, without selecting a new option.
  notes: |-
    Instrumentation: data-testid='delivery-zone-cascader'.
    Checker: must verify both selection value and open state to distinguish 'cancel' from 'do nothing'.
- id: cascader-antd-T16
  name: 'Small scale: select Hardware / Networking / Routers'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (size=small)'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Asset category field, select Hardware / Networking / Routers. The task will finish automatically when done.
  ui_copy: 'Asset category: Hardware / Networking / Routers. The task will finish automatically when done.'
  setup_description: |-
    Scale: small (the cascader input uses AntD size='small').
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Asset category”.
    Options: Category → Subcategory → Type:
      - Hardware → Networking → Routers (target), Switches
      - Hardware → Computing → Laptops
      - Software → Security → Antivirus
    Initial state: blank.
    Distractors: none, but the smaller control reduces target size.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Small scale increases pointing difficulty, while the hierarchy remains moderate and unambiguous.
  success_trigger:
    human_readable:
    - Asset category selected path labels equal [Hardware, Networking, Routers].
    - Selected path values equal ['hw','net','routers'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Hardware
        - Networking
        - Routers
        path_values:
        - hw
        - net
        - routers
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Hardware / Networking / Switches.
  - Selecting a different top-level category (Software).
  - Leaving the field blank.
  expected_interaction_path:
  - Open the Asset category cascader.
  - Select Hardware → Networking → Routers.
  notes: 'Instrumentation: data-testid=''asset-category-cascader''.'
- id: cascader-antd-T17
  name: 'Search and select among similar results: United States / California / San Jose'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (showSearch=true)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Use search in the City selector to choose United States / California / San Jose. The task will finish automatically when done.
  ui_copy: 'City selector: search and pick United States / California / San Jose. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “City” with showSearch enabled.
    Options: Country → State/Territory → City. The dataset is larger and includes many cities starting with 'San':
      - United States → California → San Jose (target), San Diego
      - United States → Texas → San Antonio
      - Puerto Rico → (territory) → San Juan
      - United States → Florida → Sarasota
    Search behavior: typing filters by path; results show full paths.
    Initial state: blank.
    Distractors: multiple search hits can appear for short queries like “San”.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Search narrows the list but introduces many confusable results; the agent must pick the correct full path from the filtered suggestions.
  success_trigger:
    human_readable:
    - City cascader selected path labels equal [United States, California, San Jose].
    - Selected path values equal ['us','ca','san-jose'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - United States
        - California
        - San Jose
        path_values:
        - us
        - ca
        - san-jose
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different 'San…' city (San Diego, San Antonio, or San Juan).
  - Typing search text but not selecting any suggestion (no committed value).
  - Selecting via columns but ending on the wrong leaf.
  expected_interaction_path:
  - Open the City cascader dropdown.
  - Type a query like “San Jo” to reduce ambiguity.
  - Click the suggestion for United States / California / San Jose.
  notes: |-
    Instrumentation: data-testid='city-cascader'.
    Checker: verify committed value path; do not accept search text alone.
- id: cascader-antd-T18
  name: 'Change-on-select: choose parent path Engineering / Platform'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (changeOnSelect=true)'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Reporting scope field, select Engineering / Platform (you do not need to pick a leaf team). The task will finish automatically when done.
  ui_copy: 'Reporting scope: Engineering / Platform. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Reporting scope” configured with changeOnSelect=true.
    Behavior: the value updates on each selection level; selecting a parent is allowed and commits immediately.
    Options: Division → Group → Team:
      - Engineering → Platform → Infrastructure, Developer Experience
      - Engineering → Product → Web, Mobile
      - Operations → IT → Helpdesk
    Initial state: blank.
    Key nuance: success requires stopping at the parent path “Engineering / Platform” (2 levels), not choosing a leaf team.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: The component commits on intermediate selections, so the agent must intentionally stop at the correct parent depth instead of continuing to a leaf.
  success_trigger:
    human_readable:
    - Reporting scope cascader selected path labels equal [Engineering, Platform] (exactly two levels).
    - Selected path values equal ['eng','platform'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Engineering
        - Platform
        path_values:
        - eng
        - platform
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Engineering / Platform / Infrastructure (too deep).
  - Selecting Engineering / Product (wrong group).
  - Leaving the field blank.
  expected_interaction_path:
  - Open the Reporting scope cascader.
  - Click Engineering in the first column.
  - Click Platform in the second column and stop (value commits at that level).
  notes: 'Instrumentation: data-testid=''reporting-scope-cascader''.'
- id: cascader-antd-T19
  name: 'Two instances: clear Secondary tag'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (allowClear=true)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the Secondary tag field so it becomes blank. The task will finish automatically when done.
  ui_copy: 'Secondary tag: clear selection (blank). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Components: two AntD Cascader inputs labeled “Primary tag” and “Secondary tag”. Both allow clearing.
    Initial state:
      - Primary tag is set to “Customer / Onboarding / High touch”.
      - Secondary tag is set to “Region / EMEA / UK”. (target to clear)
    UI behavior: each input shows a small clear icon (×) on hover.
    Distractors: the two fields are visually similar; only the label distinguishes which one to clear.
  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: 2
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 3
    justification: Clearing is simple but requires precise targeting of the clear icon on the correct instance.
  success_trigger:
    human_readable:
    - The cascader labeled “Secondary tag” has no selected value (null/empty).
    - The cascader labeled “Primary tag” may remain unchanged.
    canonical_predicate:
      predicate_type: equals
      target_state:
        value: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: secondary-tag
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clearing the Primary tag instead of Secondary tag.
  - Leaving Secondary tag selected (Region / EMEA / UK).
  - Selecting a different tag rather than clearing.
  expected_interaction_path:
  - Locate the Secondary tag cascader input.
  - Hover if needed and click its clear (×) icon.
  notes: |-
    Instrumentation: data-testid='primary-tag-cascader' and data-testid='secondary-tag-cascader'.
    Checker: enforce correct-instance; accept both null and empty-array representations for 'cleared'.
- id: cascader-antd-T20
  name: 'Settings panel: choose Access scope in inline panel (4 levels)'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: panel
  implementation_component: 'AntD: Cascader.Panel'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Access scope panel, select Organization / Europe / Dublin / Zone 2. The task will finish automatically when done.
  ui_copy: 'Access scope: Organization / Europe / Dublin / Zone 2. The task will finish automatically when done.'
  setup_description: |-
    Layout: settings panel with multiple sections.
    Clutter: low — there are a few toggles and helper texts, but only one cascader panel.
    Target component: an inline AntD Cascader.Panel labeled “Access scope”.
    Panel structure: four columns visible as you drill down (Scope → Region → Site → Zone).
    Options (representative):
      - Organization → North America → Seattle → Zone 1, Zone 2
      - Organization → Europe → Dublin → Zone 1, Zone 2 (target)
      - Team only → (no further levels)
    Initial state: no selection.
    Distractors: nearby switches like “Enable SSO” and “Read-only mode” are present but irrelevant.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Deeper 4-level hierarchy in an inline panel requires multiple precise selections, with mild distraction from surrounding settings UI.
  success_trigger:
    human_readable:
    - Access scope panel selected path labels equal [Organization, Europe, Dublin, Zone 2].
    - Selected path values equal ['org','eu','dublin','zone-2'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Organization
        - Europe
        - Dublin
        - Zone 2
        path_values:
        - org
        - eu
        - dublin
        - zone-2
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Zone 1 instead of Zone 2 under Dublin.
  - Selecting a different site (e.g., Seattle).
  - Selecting 'Team only' (wrong top-level scope).
  expected_interaction_path:
  - In the Access scope panel, click Organization.
  - Click Europe, then Dublin, then Zone 2.
  notes: |-
    Instrumentation: data-testid='access-scope-cascader-panel'.
    Checker: path length must be 4 and match values exactly.
- id: cascader-antd-T21
  name: 'Lazy-loaded options (dark): select Hardware / Printers / Setup'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (loadData)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the Knowledge base category field, select Hardware / Printers / Setup. The task will finish automatically when done.
  ui_copy: 'Knowledge base category: Hardware / Printers / Setup. The task will finish automatically when done.'
  setup_description: |-
    Theme: dark.
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Knowledge base category”, configured with loadData for lazy loading.
    Behavior: only the first column is populated initially. When a node is selected, the next column shows a loading spinner briefly and then renders fetched children.
    Option structure (as it appears after loading):
      - Hardware → Printers → Setup (target), Troubleshooting
      - Hardware → Monitors → Calibration
      - Software → VPN → Installation
    Constraints: showSearch is disabled (not available with loadData).
    Initial state: blank.
    Feedback: a subtle loading indicator appears in the dropdown column while children load.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  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: 1
    justification: Lazy loading introduces timing/feedback challenges; the agent must wait for each column to populate before making the next selection.
  success_trigger:
    human_readable:
    - Knowledge base category selected path labels equal [Hardware, Printers, Setup].
    - Selected path values equal ['hw','printers','setup'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Hardware
        - Printers
        - Setup
        path_values:
        - hw
        - printers
        - setup
      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 too quickly so the second/third column has not loaded, resulting in no committed leaf selection.
  - Selecting Hardware / Printers / Troubleshooting instead of Setup.
  - Selecting a Software category path.
  expected_interaction_path:
  - Open the Knowledge base category cascader dropdown.
  - Click Hardware and wait for the next column to load.
  - Click Printers and wait for the next column to load.
  - Click Setup to commit.
  notes: |-
    Instrumentation: data-testid='kb-category-cascader'.
    Checker: verify final committed value path; do not treat intermediate selections as success.
- id: cascader-antd-T22
  name: 'Hover-to-expand in compact spacing: Tools / Power Tools / Sanders'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (expandTrigger=''hover'')'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Inventory category field, select Tools / Power Tools / Sanders. The task will finish automatically when done.
  ui_copy: 'Inventory category: Tools / Power Tools / Sanders. The task will finish automatically when done.'
  setup_description: |-
    Spacing: compact.
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Inventory category”, configured with expandTrigger='hover'.
    Behavior: submenus open when the pointer hovers over an item in a column (not when it is clicked). The final leaf is selected by clicking.
    Options: Department → Category → Item:
      - Tools → Power Tools → Sanders (target), Drills
      - Tools → Hand Tools → Hammers
      - Supplies → Safety → Gloves
    Initial state: blank.
    Distractors: in compact mode, list items are shorter and closer together.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Hover-based expansion is harder for agents than click expansion, and compact spacing reduces target size while navigating multi-column menus.
  success_trigger:
    human_readable:
    - Inventory category selected path labels equal [Tools, Power Tools, Sanders].
    - Selected path values equal ['tools','power-tools','sanders'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Tools
        - Power Tools
        - Sanders
        path_values:
        - tools
        - power-tools
        - sanders
      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 items expecting them to expand (without hovering) and failing to reach the correct submenu.
  - Selecting Tools / Power Tools / Drills instead of Sanders.
  - Selecting a different top-level branch (Supplies).
  expected_interaction_path:
  - Open the Inventory category cascader dropdown.
  - Hover over Tools to open its submenu column.
  - Hover over Power Tools to open the third column.
  - Click Sanders to commit the leaf selection.
  notes: |-
    Instrumentation: data-testid='inventory-category-cascader'.
    Checker: verify leaf value; hover interactions are not directly checked—only final path matters.
- id: cascader-antd-T23
  name: 'Multiple mode: select exactly two cities (Paris and Osaka)'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (multiple=true, showCheckedStrategy=SHOW_CHILD)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the Cities included field, select exactly these two paths: Europe / France / Paris and Asia / Japan / Osaka. The task will finish automatically when done.'
  ui_copy: 'Cities included: select Paris and Osaka (exactly two). The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Cities included” in multiple=true mode (checkboxes shown).
    Display: showCheckedStrategy is set to SHOW_CHILD so selected leaf nodes appear as individual tags in the input.
    Options: Continent → Country → City:
      - Europe → France → Paris (target), Lyon
      - Asia → Japan → Tokyo, Osaka (target)
      - Americas → USA → New York, Chicago
    Initial state: no selections.
    Behavior: each leaf is selected by checking its checkbox (or clicking the item). Multiple selections can be made in one session.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Multiple selection requires exact set matching and careful checkbox interactions across different branches of the tree.
  success_trigger:
    human_readable:
    - 'The Cities included cascader has selected exactly the set of two leaf paths: Europe/France/Paris and Asia/Japan/Osaka.'
    - No additional paths are selected.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selected_paths:
        - path_labels:
          - Europe
          - France
          - Paris
          path_values:
          - europe
          - fr
          - paris
        - path_labels:
          - Asia
          - Japan
          - Osaka
          path_values:
          - asia
          - jp
          - osaka
        order_insensitive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only one of the two required cities.
  - Selecting Paris and Tokyo (wrong Japan city) or adding any extra city.
  - Selecting a parent node instead of the leaf city (if the UI allows it).
  expected_interaction_path:
  - Open the Cities included cascader dropdown.
  - Navigate to Europe → France and check Paris.
  - Navigate to Asia → Japan and check Osaka.
  - Ensure only two tags/selections are present.
  notes: |-
    Instrumentation: data-testid='cities-included-cascader'.
    Checker: compare sets of value paths (order-insensitive).
- id: cascader-antd-T24
  name: 'Multiple mode (visual): match the two Target selections chips'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (multiple=true)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In Teams included, select the same set of paths shown in the Target selections box. The task will finish automatically when done.
  ui_copy: 'Teams included: match the Target selections shown. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Teams included” in multiple=true mode.
    Guidance element: a “Target selections” box above the cascader shows exactly two styled chips, each chip displaying a breadcrumb path (visual reference).
    Options: Department → Team → Squad:
      - Engineering → Backend → Payments (one target)
      - Engineering → Frontend → Web Platform
      - Marketing → Events → Conferences (one target)
      - Marketing → Content → Blog
    Initial state: no selections.
    Distractors: other non-target squads exist under the same departments.
    Important: the prompt does not list the paths; the agent must copy them from the on-page Target selections reference.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires interpreting a visual reference (target chips) and matching an exact multi-selection set within a hierarchy.
  success_trigger:
    human_readable:
    - Teams included cascader selected set equals the two Target selections chips shown on the page.
    - Selected paths are exactly [Engineering/Backend/Payments] and [Marketing/Events/Conferences], order-insensitive.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_element_id: target-selections-chips
        selected_paths:
        - path_labels:
          - Engineering
          - Backend
          - Payments
          path_values:
          - eng
          - be
          - payments
        - path_labels:
          - Marketing
          - Events
          - Conferences
          path_values:
          - mkt
          - events
          - conferences
        order_insensitive: true
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only one of the two target paths.
  - Selecting the correct two plus any additional path.
  - Selecting a sibling like Engineering / Frontend / Web Platform instead of the backend payments squad.
  expected_interaction_path:
  - Read the two breadcrumb chips in the Target selections box.
  - Open Teams included cascader and select/check each matching leaf path.
  - Verify the selected tags match the two reference chips.
  notes: |-
    Instrumentation: data-testid='teams-included-cascader' and data-testid='target-selections-chips'.
    Checker: compare selected set to reference chips’ canonical paths.
- id: cascader-antd-T25
  name: 'Ambiguous leaf labels with leaf-only displayRender: choose Springfield (MA)'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (custom displayRender leaf-only)'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the Event city field, select USA / Massachusetts / Springfield. The task will finish automatically when done.
  ui_copy: 'Event city: USA / Massachusetts / Springfield. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Event city”.
    Custom rendering: displayRender is customized to show ONLY the final leaf label in the input (e.g., it will display “Springfield”, not the full path).
    Options: Country → State → City, with duplicate city names:
      - USA → Illinois → Springfield
      - USA → Massachusetts → Springfield (target)
      - USA → Oregon → Portland
      - USA → Maine → Portland
    Initial state: blank.
    Distractors: because the input displays only the leaf, the agent must rely on the dropdown columns to ensure the correct state/city branch.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Duplicate leaf labels combined with leaf-only display reduces observability; correctness requires selecting the right branch in the dropdown, not trusting the input text alone.
  success_trigger:
    human_readable:
    - Event city cascader selected path labels equal [USA, Massachusetts, Springfield].
    - Selected path values equal ['us','ma','springfield-ma'] (distinct from the Illinois Springfield value).
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - USA
        - Massachusetts
        - Springfield
        path_values:
        - us
        - ma
        - springfield-ma
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting USA / Illinois / Springfield (wrong state).
  - Selecting any Portland entry instead of Springfield.
  - Selecting only USA / Massachusetts without choosing the city leaf.
  expected_interaction_path:
  - Open the Event city cascader dropdown.
  - Select USA in the first column.
  - Select Massachusetts in the second column.
  - Select Springfield in the third column.
  notes: |-
    Instrumentation: data-testid='event-city-cascader'.
    Checker: must use underlying value path (e.g., springfield-ma vs springfield-il) to disambiguate duplicates.
- id: cascader-antd-T26
  name: 'Three instances: set Tertiary route to EU-West / Ireland / Zone 2'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: Set the Tertiary route field to EU-West / Ireland / Zone 2. The task will finish automatically when done.
  ui_copy: 'Tertiary route: EU-West / Ireland / Zone 2. The task will finish automatically when done.'
  setup_description: |-
    Layout: isolated card centered on the page.
    Components: three AntD Cascader inputs in a row, each labeled:
      - Primary route
      - Secondary route
      - Tertiary route (target)
    Options: Region → Country → Zone:
      - US-East → USA → Zone 1, Zone 2
      - EU-West → Ireland → Zone 1, Zone 2 (target)
      - APAC → Singapore → Zone 1
    Initial state:
      - Primary route preselected: US-East / USA / Zone 1
      - Secondary route preselected: APAC / Singapore / Zone 1
      - Tertiary route blank
    Distractors: three nearly identical inputs placed close together.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 5
    justification: The option tree is moderate, but heavy disambiguation is required to operate the correct one of three adjacent cascader instances.
  success_trigger:
    human_readable:
    - The cascader labeled “Tertiary route” has selected path labels [EU-West, Ireland, Zone 2].
    - Tertiary route selected path values equal ['eu-west','ie','zone-2'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - EU-West
        - Ireland
        - Zone 2
        path_values:
        - eu-west
        - ie
        - zone-2
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: tertiary-route
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Setting Primary route or Secondary route instead of Tertiary route.
  - Selecting EU-West / Ireland / Zone 1 (wrong zone).
  - Leaving Tertiary route blank.
  expected_interaction_path:
  - Locate the cascader labeled Tertiary route.
  - Open it and select EU-West → Ireland → Zone 2.
  notes: |-
    Instrumentation: data-testid='route-primary-cascader', 'route-secondary-cascader', 'route-tertiary-cascader'.
    Checker: enforce correct instance by testid/label.
- id: cascader-antd-T27
  name: 'Table cell: set Assign to for ''Password reset'' rule'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (embedded in table cell)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the routing rules table, set the Assign to field for the 'Password reset' row to Support / Tier 2 / Identity. The task will finish automatically when done.
  ui_copy: 'Table edit: Password reset → Assign to = Support / Tier 2 / Identity. The task will finish automatically when done.'
  setup_description: |-
    Layout: table cell scenario.
    Clutter: medium — a data table with multiple rows/columns plus a small toolbar (Search, Add rule) above it.
    Table: “Routing rules” with rows like:
      - Password reset (target row)
      - Refund request
      - App crash
    Only the target row’s “Assign to” column contains an interactive AntD Cascader input; other rows display read-only text.
    Cascader options: Department → Tier → Specialty:
      - Support → Tier 1 → General
      - Support → Tier 2 → Identity (target), Billing
      - Engineering → On-call → Mobile
    Initial state: target row currently shows “Support / Tier 1 / General”.
    Behavior: selecting a leaf updates the cell immediately; no additional Save action is required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: The cascader is embedded in a dense table context with multiple nearby controls; targeting the correct cell and option requires careful acquisition and disambiguation.
  success_trigger:
    human_readable:
    - The Assign to cascader in the 'Password reset' row has selected path labels [Support, Tier 2, Identity].
    - Selected path values equal ['support','t2','identity'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Support
        - Tier 2
        - Identity
        path_values:
        - support
        - t2
        - identity
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: routing-table-password-reset-assign-to
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Changing a different row (if any other editable control is present).
  - Selecting Support / Tier 2 / Billing (wrong specialty).
  - Leaving the value at Support / Tier 1 / General.
  expected_interaction_path:
  - Locate the Password reset row and its Assign to cascader cell.
  - Open the cascader dropdown.
  - Select Support → Tier 2 → Identity.
  notes: |-
    Instrumentation: add data-testid='routing-table-password-reset-assign-to' on the Cascader cell.
    Checker: locate by row key + column id (prefer stable row id over text match if available).
- id: cascader-antd-T28
  name: 'Modal flow: set Allowed destinations to Asia / Singapore / Downtown'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (inside Modal)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the Edit shipping rule modal and set Allowed destinations to Asia / Singapore / Downtown. The task will finish automatically when done.
  ui_copy: 'Edit shipping rule → Allowed destinations: Asia / Singapore / Downtown. The task will finish automatically when done.'
  setup_description: |-
    Layout: modal flow.
    Clutter: low — a simple page with a single primary button and a modal dialog.
    Entry point: a button labeled “Edit shipping rule”. Clicking it opens a modal.
    Inside the modal:
      - A short description paragraph
      - The target AntD Cascader labeled “Allowed destinations”
      - Modal footer buttons: Cancel and Save (these are NOT required for task success)
    Cascader options: Region → Country → Area:
      - Asia → Singapore → Downtown (target), Airport
      - Europe → Germany → Berlin
      - Americas → USA → New York
    Initial state: Allowed destinations is blank.
    Behavior: selection commits on leaf click within the cascader dropdown.
  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: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Adds an extra overlay layer (modal + cascader dropdown) and multiple clickable controls, increasing depth and the chance of misclicks.
  success_trigger:
    human_readable:
    - The Allowed destinations cascader inside the open modal has selected path labels [Asia, Singapore, Downtown].
    - Selected path values equal ['asia','sg','downtown'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Asia
        - Singapore
        - Downtown
        path_values:
        - asia
        - sg
        - downtown
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: allowed-destinations
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Asia / Singapore / Airport instead of Downtown.
  - Closing the modal without committing the selection (value remains blank).
  - Setting a cascader outside the modal (none exist).
  expected_interaction_path:
  - Click Edit shipping rule to open the modal.
  - In the modal, open the Allowed destinations cascader.
  - Select Asia → Singapore → Downtown.
  notes: |-
    Instrumentation: data-testid='edit-shipping-modal', data-testid='allowed-destinations-cascader'.
    Checker: bind to the cascader within the modal container to avoid matching any background elements.
- id: cascader-antd-T29
  name: 'Drawer flow: set Default assignee group to Customer Success / Enterprise / Onboarding'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader (inside Drawer)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the Assignment settings drawer and set Default assignee group to Customer Success / Enterprise / Onboarding. The task will finish automatically when done.
  ui_copy: 'Assignment settings → Default assignee group: Customer Success / Enterprise / Onboarding. The task will finish automatically when done.'
  setup_description: |-
    Layout: drawer flow.
    Clutter: low — a settings page with a single “Assignment settings” button that opens a right-side drawer.
    Entry point: click the button labeled “Assignment settings” to open a drawer.
    Inside the drawer:
      - Header with a close (×) button
      - A few toggles (e.g., “Auto-assign new tickets”)
      - Target AntD Cascader labeled “Default assignee group”
    Cascader options: Department → Segment → Team:
      - Customer Success → SMB → Renewals
      - Customer Success → Enterprise → Onboarding (target), Escalations
      - Support → Tier 1 → General
      - Support → Tier 2 → Identity
    Initial state: Default assignee group is set to “Support / Tier 1 / General”.
    Interaction nuance: the drawer may constrain available space, and the cascader dropdown must render on top of the drawer content.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Nested overlay (drawer + dropdown) plus a denser hierarchy increases layering and choice interference, especially in constrained space.
  success_trigger:
    human_readable:
    - Within the open drawer, Default assignee group cascader selected path labels equal [Customer Success, Enterprise, Onboarding].
    - Selected path values equal ['cs','ent','onboarding'].
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Customer Success
        - Enterprise
        - Onboarding
        path_values:
        - cs
        - ent
        - onboarding
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: default-assignee-group
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving the default value at Support / Tier 1 / General.
  - Selecting Customer Success / Enterprise / Escalations (sibling leaf).
  - Closing the drawer before selecting the target leaf.
  expected_interaction_path:
  - Click Assignment settings to open the drawer.
  - In the drawer, open Default assignee group cascader.
  - Select Customer Success → Enterprise → Onboarding.
  notes: |-
    Instrumentation: data-testid='assignment-settings-drawer', data-testid='default-assignee-group-cascader'.
    Checker: ensure it reads the cascader inside the drawer context.
- id: cascader-antd-T30
  name: 'Dark + visual: match Target breadcrumb for Policy category'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Cascader'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In Policy category, select the path shown in the Target breadcrumb preview. The task will finish automatically when done.
  ui_copy: 'Policy category: match the Target breadcrumb shown. The task will finish automatically when done.'
  setup_description: |-
    Theme: dark.
    Layout: isolated card centered on the page.
    Component: one AntD Cascader labeled “Policy category”.
    Guidance element: a “Target breadcrumb” preview above the field shows the desired path as styled crumb chips.
    Options: Domain → Area → Policy:
      - Compliance → Data → Retention (target)
      - Compliance → Data → Classification
      - Security → Access → MFA
    Initial state: blank.
    Distractors: the Compliance/Data branch has multiple similar policy leaves.
  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: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Visual reference matching in dark theme requires accurately interpreting the on-page breadcrumb and selecting the corresponding leaf among similar siblings.
  success_trigger:
    human_readable:
    - Policy category cascader selection matches the Target breadcrumb preview.
    - Selected path labels equal [Compliance, Data, Retention] and values equal ['compliance','data','retention'].
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_element_id: target-policy-breadcrumb
        path_labels:
        - Compliance
        - Data
        - Retention
        path_values:
        - compliance
        - data
        - retention
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting Compliance / Data / Classification (wrong sibling leaf).
  - Selecting a Security policy path instead.
  - Leaving the field blank while the Target breadcrumb is visible.
  expected_interaction_path:
  - Read the Target breadcrumb preview.
  - Open Policy category cascader and select Compliance → Data → Retention.
  notes: |-
    Instrumentation: data-testid='policy-category-cascader' and data-testid='target-policy-breadcrumb'.
    Checker: compare cascader value path to reference breadcrumb canonical path.