tasks/v2/08_tree_select_cascader_v2.yaml

- id: tree_select-antd-v2-T01
  name: 'Prefilled-neighbor decoy: set Backup service path and apply'
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: TreeSelect'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the “Backup service path” tree selector, choose “Company / Engineering / Frontend / Web” and then click “Apply routing”. Do not change the prefilled “Primary service path” selector. The task will finish automatically when done.
  ui_copy: In the “Backup service path” tree selector, choose “Company / Engineering / Frontend / Web” and then click “Apply routing”. Do not change the prefilled “Primary service path” selector. The task will finish automatically when done.
  setup_description: 'Layout is settings_panel with compact spacing, off-center placement, and medium clutter from toggles, segmented controls, and status chips above the selectors. Two Ant Design TreeSelect controls share the same compact popup tree: “Primary service path” is prefilled with `Company / Engineering / Frontend / Mobile Web`, while “Backup service path” starts empty. Both selectors sit in the same card and look nearly identical. Parent nodes are expandable; only leaves are selectable. A card-local button labeled “Apply routing” commits both selectors together.'
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - scale
    - confirmation_model
    factor_rationale: The prefilled neighboring selector creates a strong wrong-instance and wrong-sibling lure, and the small shared popup plus card-local apply step forces the agent to verify the exact selected leaf before committing.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: 'This directly targets the decoy-instance pattern from the evidence bundle: agents often know the hierarchy but drift toward the already visible neighboring value or the wrong sibling leaf before the shared save step.'
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Company', 'Engineering', 'Frontend', 'Web'].
    - The non-target tree selector "Primary service path" remains at its initial committed value.
    - The local "Apply routing" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Company
        - Engineering
        - Frontend
        - Web
        value: svc-company-eng-frontend-web
        non_target_instances_must_remain:
          Primary service path: Company / Engineering / Frontend / Mobile Web
        target_instance: Backup service path
      tolerance: null
      require_confirm: true
      confirm_control: Apply routing
      require_correct_instance: true
      target_instance_label_or_id: Backup service path
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Apply routing".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply routing" to commit the change.
  notes: Bind each TreeSelect and the shared Apply button separately so the checker can enforce correct-instance selection.
- id: tree_select-antd-v2-T02
  name: 'Table-cell rule row: scroll to final bug tag and save row'
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: TreeSelect'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the “Issue tag” tree selector for the “Gateway alert” row, select “Bugs / UI / Z-Index” and then click “Save row”. Do not edit the “Billing alert” row. The task will finish automatically when done.
  ui_copy: In the “Issue tag” tree selector for the “Gateway alert” row, select “Bugs / UI / Z-Index” and then click “Save row”. Do not edit the “Billing alert” row. The task will finish automatically when done.
  setup_description: 'Layout is table_cell with compact spacing, bottom-left placement, small scale, and medium clutter from adjacent severity badges, disabled inputs, and row action icons. Two table rows are expanded: “Gateway alert” and “Billing alert”. Each row contains a compact Ant Design TreeSelect labeled “Issue tag” and a row-local “Save row” button. In the Gateway row, the popup tree contains a long `Bugs > UI` subtree with many visually similar leaves; “Z-Index” appears near the bottom of the scrollable popup. Only the Gateway row should change.'
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_left
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - internal_scroll_region
    - instances
    factor_rationale: 'This pushes the strong v1 final-leaf failure into a denser table-cell carrier: the agent must activate the correct small in-row trigger, scroll within the popup, and avoid saving the non-target row.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The hard part is not understanding the path but acquiring the right compact cell editor, staying inside the popup scroll region, and then committing the correct row-local value.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Bugs', 'UI', 'Z-Index'].
    - The non-target tree selector "Billing alert" remains at its initial committed value.
    - The local "Save row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Bugs
        - UI
        - Z-Index
        value: tag-bugs-ui-z-index
        non_target_instances_must_remain:
          Billing alert: Bugs / API / Timeouts
        target_instance: Gateway alert
      tolerance: null
      require_confirm: true
      confirm_control: Save row
      require_correct_instance: true
      target_instance_label_or_id: Gateway alert
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Save row".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save row" to commit the change.
  notes: Instrument row identifiers and row-local save buttons; the popup container must be attributable to the source row.
- id: tree_select-antd-v2-T03
  name: 'Strict-check drawer: exact parent-plus-leaf notification scopes'
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: tree_check_strict
  implementation_component: 'AntD: TreeSelect'
  task_template: select_many
  secondary_template: open_overlay
  browsergym_goal: 'Open the “Notification scopes” drawer. In the tree selector labeled “Scopes”, select exactly these two entries: “Company / Engineering” and “Company / Engineering / Platform / Queues”. Then click “Save scopes”. The task will finish automatically when done.'
  ui_copy: 'Open the “Notification scopes” drawer. In the tree selector labeled “Scopes”, select exactly these two entries: “Company / Engineering” and “Company / Engineering / Platform / Queues”. Then click “Save scopes”. The task will finish automatically when done.'
  setup_description: Layout is drawer_flow with compact spacing and medium clutter. A right-side drawer opens over a release settings page. Inside the drawer is one Ant Design TreeSelect labeled “Scopes” configured with `treeCheckable` and `treeCheckStrictly`, so parent and child selections are independent and both appear as separate tags. The tree starts collapsed and contains `Company > Engineering > Platform > {Queues, Cache, Database}` along with several non-target branches. The drawer footer contains “Cancel” and “Save scopes”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - overlay_model
    - confirmation_model
    - precision_surface
    factor_rationale: 'Strict parent/child independence creates a real interaction-knowledge burden: the agent must intentionally keep both the parent and the leaf selected, then commit through the drawer-local save.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: This uses Ant Design’s strict check mode to create an exact-set task where selecting only the parent or only the leaf is insufficient, so the benchmark probes both idiom knowledge and confirmation.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Company', 'Engineering'], ['Company', 'Engineering', 'Platform', 'Queues']].
    - The local "Save scopes" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Company
          - Engineering
        - - Company
          - Engineering
          - Platform
          - Queues
        values:
        - company-engineering
        - company-engineering-platform-queues
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Save scopes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Save scopes".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Save scopes" to commit the change.
  notes: The checker must compare the committed selected values exactly and must not infer parent-child closure when strict mode is enabled.
- id: tree_select-antd-v2-T04
  name: Lazy-loaded modal repository path with deferred children
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: load_data
  implementation_component: 'AntD: TreeSelect'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Choose component path”. In the “Repository path” tree selector, expand the repository tree until the lazy-loaded branch reveals “packages / ui / button”, select that path, and click “Use path”. The task will finish automatically when done.
  ui_copy: Open “Choose component path”. In the “Repository path” tree selector, expand the repository tree until the lazy-loaded branch reveals “packages / ui / button”, select that path, and click “Use path”. The task will finish automatically when done.
  setup_description: Layout is modal_flow with compact spacing and medium clutter from a blurred code-review page in the background. Clicking “Choose component path” opens a modal containing one Ant Design TreeSelect labeled “Repository path”. The top levels (`repo`, `packages`, `ui`) are available immediately, but children under `ui` are loaded asynchronously via `loadData` after expansion. Nearby siblings such as `badge`, `card`, and `button-group` appear once the branch loads. The modal footer has “Cancel” and “Use path”.
  scene_context:
    theme: light
    spacing: compact
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: dialog
  design_intent:
    active_factors:
    - overlay_model
    - confirmation_model
    - clutter
    factor_rationale: 'Delayed child loading creates a legitimate wait-and-reacquire burden inside the modal: the agent must keep the popup state straight across the load transition and still commit the final leaf through the modal.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: This directly uses the async-children pattern supported by TreeSelect and turns it into a layered-state task instead of a trivial single-popup selection.
  success_trigger:
    human_readable:
    - The committed selection path equals ['repo', 'packages', 'ui', 'button'].
    - The local "Use path" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - repo
        - packages
        - ui
        - button
        value: repo-packages-ui-button
      tolerance: null
      require_confirm: true
      confirm_control: Use path
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Use path".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Use path" to commit the change.
  notes: Wait for the lazy-loaded children to appear before allowing final selection; load completion should not itself count as success.
- id: tree_select-antd-v2-T05
  name: Ambiguous duplicate leaf search with neighboring instance preserved
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: show_search
  implementation_component: 'AntD: TreeSelect'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Event city”, search for and select “USA / Massachusetts / Springfield”, then click “Apply locations”. Do not change the prefilled “Fallback city” selector. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Event city”, search for and select “USA / Massachusetts / Springfield”, then click “Apply locations”. Do not change the prefilled “Fallback city” selector. The task will finish automatically when done.
  setup_description: 'Layout is dashboard_panel with compact spacing, top-right placement, and medium clutter from summary cards and a filter strip. Two Ant Design TreeSelect controls share the same searchable tree data: “Event city” is empty, while “Fallback city” is prefilled with `USA / Illinois / Springfield`. The tree contains several duplicate leaf labels including `Springfield` under Massachusetts, Illinois, and Missouri. Search is enabled and shows matched paths, but the agent must still commit the correct instance and exact branch. A button labeled “Apply locations” commits the card.'
  scene_context:
    theme: dark
    spacing: compact
    layout: dashboard_panel
    placement: top_right
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - guidance
    - confirmation_model
    factor_rationale: 'Search reduces brute-force navigation but does not remove the core burden: duplicate leaf labels, a prefilled neighboring selector, and a shared apply step make exact branch verification necessary.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 5
    justification: The semantic target is easy to describe but hard to verify because search returns several plausible Springfields and the adjacent prefilled selector shows a tempting but wrong sibling value.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['USA', 'Massachusetts', 'Springfield'].
    - The non-target tree selector "Fallback city" remains at its initial committed value.
    - The local "Apply locations" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - USA
        - Massachusetts
        - Springfield
        value: usa-massachusetts-springfield
        non_target_instances_must_remain:
          Fallback city: USA / Illinois / Springfield
        target_instance: Event city
      tolerance: null
      require_confirm: true
      confirm_control: Apply locations
      require_correct_instance: true
      target_instance_label_or_id: Event city
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Apply locations".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply locations" to commit the change.
  notes: Do not accept any Springfield leaf outside Massachusetts; compare by committed value path, not visible leaf text alone.
- id: tree_select-antd-v2-T06
  name: 'Three-instance visual reference: choose only Fallback route'
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: TreeSelect'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the “Escalation routes” card, set only the tree selector labeled “Fallback route” to match the highlighted path in the reference card, then click “Save routes”. Do not change “Primary route” or “Secondary route”. The task will finish automatically when done.
  ui_copy: In the “Escalation routes” card, set only the tree selector labeled “Fallback route” to match the highlighted path in the reference card, then click “Save routes”. Do not change “Primary route” or “Secondary route”. The task will finish automatically when done.
  setup_description: Layout is dashboard_panel with compact spacing, off-center placement, and high clutter from activity tables, KPI chips, and a mini-log panel. The target card contains three compact Ant Design TreeSelect controls labeled “Primary route”, “Secondary route”, and “Fallback route”. A separate visual reference card shows the target highlighted as `On-call > Platform > Database`. Primary and Secondary start with different committed values and must remain unchanged. The card footer has “Save routes”.
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: off_center
    scale: small
    instances: 3
    guidance: visual
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - clutter
    - guidance
    factor_rationale: 'The reference removes instruction ambiguity but pushes the real problem into grounding and instance selection: the agent must map the visual target to the correct selector among three similar compact controls in a busy dashboard.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 5
    justification: This extends the useful v1 reference-match family by adding three compact instances and a shared commit step, so the benchmark captures wrong-instance and wrong-leaf failures together.
  success_trigger:
    human_readable:
    - The committed selection matches the reference target ref-fallback-route and equals ['On-call', 'Platform', 'Database'].
    - The non-target tree selector "Primary route" remains unchanged.
    - The non-target tree selector "Secondary route" remains unchanged.
    - The local "Save routes" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: ref-fallback-route
        selection_mode: single
        path:
        - On-call
        - Platform
        - Database
        value: on-call-platform-database
        non_target_instances_must_remain:
          Primary route: On-call / Platform / API
          Secondary route: On-call / Support / Identity
      tolerance: null
      require_confirm: true
      confirm_control: Save routes
      require_correct_instance: true
      target_instance_label_or_id: Fallback route
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a visually similar but wrong reference path.
  - Matching the reference in the wrong selector instance.
  - Matching the reference but not clicking "Save routes".
  expected_interaction_path:
  - Read the reference target.
  - Open the correct tree selector and select the matching path.
  - Click "Save routes" to commit the change.
  notes: Bind the reference card to the canonical target path but validate only the committed value of the Fallback route selector.
- id: tree_select-antd-v2-T07
  name: Replace wrong default checked leaf and keep exact two-item set
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: tree_checkable
  implementation_component: 'AntD: TreeSelect'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the “Archive scopes” tree selector, keep “Teams / Platform / Database”, remove the preselected “Teams / Platform / Cache”, add “Teams / Support / Identity”, and leave the final selection as exactly those two items. Then click “Apply archive scopes”. The task will finish automatically when done.
  ui_copy: In the “Archive scopes” tree selector, keep “Teams / Platform / Database”, remove the preselected “Teams / Platform / Cache”, add “Teams / Support / Identity”, and leave the final selection as exactly those two items. Then click “Apply archive scopes”. The task will finish automatically when done.
  setup_description: Layout is nested_scroll with compact spacing and medium clutter. The target card sits in a larger settings page that also scrolls. One Ant Design TreeSelect labeled “Archive scopes” uses checkbox selection and opens a popup tree with `Teams > Platform > {Database, Cache, Queues}` and `Teams > Support > {Identity, Billing}`. The initial selected set is `{Teams / Platform / Database, Teams / Platform / Cache}`. The popup remains open while selections change. A card-local button labeled “Apply archive scopes” commits the final set.
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - confirmation_model
    - layout
    - clutter
    factor_rationale: 'This turns recovery into part of the task instead of a byproduct: the agent must notice the wrong default chip, remove it without losing the correct one, add the new leaf, and then commit the exact final set.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 3
    justification: The selection is not from scratch; it requires controlled removal and addition inside a persistent popup, which makes state tracking and exact-set verification meaningfully harder than a vanilla multi-select.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Teams', 'Platform', 'Database'], ['Teams', 'Support', 'Identity']].
    - The local "Apply archive scopes" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Teams
          - Platform
          - Database
        - - Teams
          - Support
          - Identity
        values:
        - teams-platform-database
        - teams-support-identity
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Apply archive scopes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Apply archive scopes".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Apply archive scopes" to commit the change.
  notes: Initial selected state must be instrumented so the checker can enforce removal of Cache and retention of Database.
- id: tree_select-antd-v2-T08
  name: Nested-scroll long policy selector with final leaf confirmation
  canonical_type: tree_select
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: TreeSelect'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the “Policy path” tree selector, scroll within the popup to select “Handbook / Security / Access / VPN / Rotate keys”, then click “Apply policy”. The task will finish automatically when done.
  ui_copy: In the “Policy path” tree selector, scroll within the popup to select “Handbook / Security / Access / VPN / Rotate keys”, then click “Apply policy”. The task will finish automatically when done.
  setup_description: 'Layout is nested_scroll with compact spacing, center placement, and medium clutter from side navigation and review chips. The card contains one Ant Design TreeSelect labeled “Policy path” and a button labeled “Apply policy”. The popup tree is deep and scrollable: under `Handbook > Security > Access > VPN` there are many sibling leaves including `Issue token`, `Revoke token`, `Rotate keys`, and `Audit logs`, with the target near the bottom of the visible subtree. The selected value only appears in the input after the popup closes and the card is applied.'
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - internal_scroll_region
    - confirmation_model
    - scale
    factor_rationale: 'This preserves the strong v1 final-leaf selection story but removes the low-pressure isolated-card scene: the popup itself becomes scrollable, the control is small, and explicit confirmation is required after the popup closes.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: The agent must find and hit a compact final leaf after several successful state transitions, then verify that the selected text stuck before applying the card-local change.
  success_trigger:
    human_readable:
    - The committed selection path equals ['Handbook', 'Security', 'Access', 'VPN', 'Rotate keys'].
    - The local "Apply policy" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Handbook
        - Security
        - Access
        - VPN
        - Rotate keys
        value: handbook-security-access-vpn-rotate-keys
      tolerance: null
      require_confirm: true
      confirm_control: Apply policy
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Apply policy".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply policy" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mui-v2-T09
  name: 'Compact table cell activation: set PagerDuty and apply row'
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_table_cell
  implementation_component: 'MUI: TextField + Popover + RichTreeView in table cell'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the “Integration” tree selector for the “Password reset” row, select “Integrations / Monitoring / PagerDuty” and then click “Apply row”. Do not change the “Invoice failure” row. The task will finish automatically when done.
  ui_copy: In the “Integration” tree selector for the “Password reset” row, select “Integrations / Monitoring / PagerDuty” and then click “Apply row”. Do not change the “Invoice failure” row. The task will finish automatically when done.
  setup_description: 'Layout is table_cell with compact spacing, bottom_right placement, small scale, and medium clutter from chip filters, row badges, and inline icon buttons. Two rows are editable: “Password reset” and “Invoice failure”. Each row contains a compact MUI TextField trigger that opens a Popover with a RichTreeView. The `Monitoring` branch contains many leaves and requires scrolling within the popover to reach `PagerDuty`. Each row has its own “Apply row” button; only the Password reset row should change.'
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_right
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - scale
    - instances
    factor_rationale: 'This recreates the strongest table-cell signal from v1 with a MUI composite implementation: the bottleneck is first activating the right compact cell editor and then keeping the long popover tree anchored to the correct row.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: Structured modes can usually solve the hierarchy, but compact in-cell activation plus scrollable final-leaf targeting makes this a strong grounding-heavy tree-select task.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Integrations', 'Monitoring', 'PagerDuty'].
    - The non-target tree selector "Invoice failure" remains at its initial committed value.
    - The local "Apply row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Integrations
        - Monitoring
        - PagerDuty
        value: integrations-monitoring-pagerduty
        non_target_instances_must_remain:
          Invoice failure: Integrations / Billing / Stripe
        target_instance: Password reset
      tolerance: null
      require_confirm: true
      confirm_control: Apply row
      require_correct_instance: true
      target_instance_label_or_id: Password reset
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Apply row".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply row" to commit the change.
  notes: Use row-bound instance identifiers so the checker can attribute both popup activity and row apply to the correct row.
- id: tree_select-mui-v2-T10
  name: 'Drawer resources selector: exact checked leaf set only'
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_checkbox
  implementation_component: 'MUI: TextField + Drawer + RichTreeView checkboxSelection'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'Open the “Resource access” drawer. In the tree selector labeled “Allowed resources”, select exactly these leaves: “Resources / Dashboards / SRE”, “Resources / Runbooks / API”, and “Resources / Alerts / P1”. Parents are not valid targets. Then click “Save access”. The task will finish automatically when done.'
  ui_copy: 'Open the “Resource access” drawer. In the tree selector labeled “Allowed resources”, select exactly these leaves: “Resources / Dashboards / SRE”, “Resources / Runbooks / API”, and “Resources / Alerts / P1”. Parents are not valid targets. Then click “Save access”. The task will finish automatically when done.'
  setup_description: Layout is drawer_flow with compact spacing and medium clutter. The drawer contains one composite tree-select built from a TextField trigger and a RichTreeView with `checkboxSelection` and `multiSelect`. Parent nodes are visible but not selectable because leaf-only selection is enforced via `isItemSelectionDisabled`. Nearby distractors include a switch, a segmented control, and a disabled save hint. The final set should contain exactly three leaf items and no extras. The drawer footer contains “Save access”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - confirmation_model
    - overlay_model
    - precision_surface
    factor_rationale: Leaf-only checkbox selection plus a drawer-local save keeps the task centered on exact-set hierarchical selection rather than generic drawer handling; selecting a parent or an extra leaf must be detected and corrected before commit.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: MUI checkbox selection makes multi-select feasible, but leaf-only enforcement and exact-set validation create a real interaction-knowledge and verification burden.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Resources', 'Dashboards', 'SRE'], ['Resources', 'Runbooks', 'API'], ['Resources', 'Alerts', 'P1']].
    - The local "Save access" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Resources
          - Dashboards
          - SRE
        - - Resources
          - Runbooks
          - API
        - - Resources
          - Alerts
          - P1
        values:
        - resources-dashboards-sre
        - resources-runbooks-api
        - resources-alerts-p1
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Save access
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Save access".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Save access" to commit the change.
  notes: Use `selectedItems`/`onSelectedItemsChange` state to validate the exact committed leaf set; do not accept parent placeholders.
- id: tree_select-mui-v2-T11
  name: Lazy-loaded geography popover with deferred children
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_pro_lazy
  implementation_component: 'MUI: TextField + Popover + RichTreeViewPro dataSource'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the “Region” tree selector, expand the lazy-loaded geography tree until “Geography / Americas / Canada / Vancouver” appears, select it, and click “Apply region”. The task will finish automatically when done.
  ui_copy: In the “Region” tree selector, expand the lazy-loaded geography tree until “Geography / Americas / Canada / Vancouver” appears, select it, and click “Apply region”. The task will finish automatically when done.
  setup_description: Layout is modal_flow with compact spacing and medium clutter. A modal titled “Choose region” contains one MUI TextField trigger for the “Region” tree selector. The popup uses RichTreeViewPro with a `dataSource`, so the `Canada` children are not present until the `Americas` branch is expanded and loaded. Nearby siblings like `Toronto` and `Montreal` appear once the branch resolves. The modal footer contains “Cancel” and “Apply region”.
  scene_context:
    theme: light
    spacing: compact
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: dialog
  design_intent:
    active_factors:
    - overlay_model
    - confirmation_model
    - guidance
    factor_rationale: 'This uses the MUI X lazy-loading path explicitly: the agent must navigate a modal, wait for the loaded children, then verify the exact leaf before committing the modal-local selection.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: The task remains human-feasible but adds a real dynamic-state transition between expansion and selection, which was missing from most v1 tree-select scenes.
  success_trigger:
    human_readable:
    - The committed selection path equals ['Geography', 'Americas', 'Canada', 'Vancouver'].
    - The local "Apply region" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Geography
        - Americas
        - Canada
        - Vancouver
        value: geography-americas-canada-vancouver
      tolerance: null
      require_confirm: true
      confirm_control: Apply region
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Apply region".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply region" to commit the change.
  notes: Wait for lazy-loaded items before allowing selection; use the committed selected path, not interim loading state, for success.
- id: tree_select-mui-v2-T12
  name: Search ambiguous Archive result and preserve sibling selector
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_search
  implementation_component: 'MUI: TextField + Popover + filter input + RichTreeView'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Destination”, search for and select “Projects / Alpha / Archive”, then click “Apply move”. Do not change the prefilled “Fallback destination” selector. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Destination”, search for and select “Projects / Alpha / Archive”, then click “Apply move”. Do not change the prefilled “Fallback destination” selector. The task will finish automatically when done.
  setup_description: 'Layout is dashboard_panel with compact spacing, top_left placement, and medium clutter. Two MUI composite tree-select controls appear in a “Move content” card: “Destination” is empty, and “Fallback destination” is prefilled with `Templates / Archive`. The popover contains a small search input above a RichTreeView. Typing `Archive` filters multiple matching branches including `Projects / Alpha / Archive`, `Projects / Beta / Archive`, and `Templates / Archive`. A button labeled “Apply move” commits both selectors.'
  scene_context:
    theme: dark
    spacing: compact
    layout: dashboard_panel
    placement: top_left
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - guidance
    - confirmation_model
    factor_rationale: 'Filtered results make the task manageable without turning it into a trivial search lookup: several Archive leaves remain, one sibling selector already shows a wrong but tempting Archive path, and the change must still be committed explicitly.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 5
    justification: This is a search-based disambiguation task rather than a simple text-entry shortcut, because multiple filtered Archive leaves stay plausible and only one belongs to the target selector.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Projects', 'Alpha', 'Archive'].
    - The non-target tree selector "Fallback destination" remains at its initial committed value.
    - The local "Apply move" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Projects
        - Alpha
        - Archive
        value: projects-alpha-archive
        non_target_instances_must_remain:
          Fallback destination: Templates / Archive
        target_instance: Destination
      tolerance: null
      require_confirm: true
      confirm_control: Apply move
      require_correct_instance: true
      target_instance_label_or_id: Destination
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Apply move".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply move" to commit the change.
  notes: Use the committed value path for both selectors; the visible filtered result list alone is not sufficient for success.
- id: tree_select-mui-v2-T13
  name: Prefilled-neighbor billing taxonomy in compact settings panel
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_simple_tree_view
  implementation_component: 'MUI: TextField + Popover + SimpleTreeView'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Billing category”, choose “Finance / Payroll / Taxes” and then click “Save section”. Do not change the prefilled “Shipping category” selector. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Billing category”, choose “Finance / Payroll / Taxes” and then click “Save section”. Do not change the prefilled “Shipping category” selector. The task will finish automatically when done.
  setup_description: Layout is settings_panel with compact spacing, off-center placement, and high clutter from unrelated toggles, status chips, and help text. Two compact composite tree-select controls sit in the same section. “Shipping category” is prefilled with `Finance / Payroll / Benefits`, while “Billing category” is empty. The popup uses a SimpleTreeView with small row height and no search. A section-level button labeled “Save section” commits the card state.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: small
    instances: 2
    guidance: text
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - clutter
    - scale
    factor_rationale: The task inherits the decoy-instance idea from the evidence but moves it into a denser MUI settings panel where the compact trigger and prefilled sibling value both compete for attention.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The path itself is not exotic, but the compact crowded scene and the prefilled sibling selector create strong wrong-instance and wrong-sibling pressure before the save step.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Finance', 'Payroll', 'Taxes'].
    - The non-target tree selector "Shipping category" remains at its initial committed value.
    - The local "Save section" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Finance
        - Payroll
        - Taxes
        value: finance-payroll-taxes
        non_target_instances_must_remain:
          Shipping category: Finance / Payroll / Benefits
        target_instance: Billing category
      tolerance: null
      require_confirm: true
      confirm_control: Save section
      require_correct_instance: true
      target_instance_label_or_id: Billing category
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Save section".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save section" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mui-v2-T14
  name: Drawer reference match among three escalation routes
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_reference
  implementation_component: 'MUI: TextField + Drawer + RichTreeView'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Open “Edit escalation routes”. In the tree selector labeled “Fallback route”, select the same path highlighted in the reference card, then click “Save routes”. Do not change “Primary route” or “Secondary route”. The task will finish automatically when done.
  ui_copy: Open “Edit escalation routes”. In the tree selector labeled “Fallback route”, select the same path highlighted in the reference card, then click “Save routes”. Do not change “Primary route” or “Secondary route”. The task will finish automatically when done.
  setup_description: Layout is drawer_flow with compact spacing, right-edge placement, and high clutter. The drawer contains three composite tree-select controls labeled “Primary route”, “Secondary route”, and “Fallback route”. A small visual reference card pinned above them highlights the target path `Ops / Platform / Database`. Only the Fallback route should change; the other two begin with committed non-target values and must remain untouched. The drawer footer contains “Save routes”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: top_right
    scale: small
    instances: 3
    guidance: mixed
    clutter: high
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - instances
    - guidance
    - overlay_model
    factor_rationale: The drawer makes the carrier realistic, but the real pressure comes from reading the visual reference and applying it to the correct one of three nearly identical selectors without disturbing the other two.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 5
    justification: 'This is a deliberately high-disambiguation reference-matching task: the hierarchy is clear, but the selector instance and compact control geometry are not.'
  success_trigger:
    human_readable:
    - The committed selection matches the reference target ref-mui-fallback-route and equals ['Ops', 'Platform', 'Database'].
    - The non-target tree selector "Primary route" remains unchanged.
    - The non-target tree selector "Secondary route" remains unchanged.
    - The local "Save routes" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: ref-mui-fallback-route
        selection_mode: single
        path:
        - Ops
        - Platform
        - Database
        value: ops-platform-database
        non_target_instances_must_remain:
          Primary route: Ops / Platform / API
          Secondary route: Ops / Support / Identity
      tolerance: null
      require_confirm: true
      confirm_control: Save routes
      require_correct_instance: true
      target_instance_label_or_id: Fallback route
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a visually similar but wrong reference path.
  - Matching the reference in the wrong selector instance.
  - Matching the reference but not clicking "Save routes".
  expected_interaction_path:
  - Read the reference target.
  - Open the correct tree selector and select the matching path.
  - Click "Save routes" to commit the change.
  notes: The checker should validate the committed selected path against the bound reference target, not the reference widget itself.
- id: tree_select-mui-v2-T15
  name: Scrollable final leaf in nested-scroll service selector
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_scroll
  implementation_component: 'MUI: TextField + Popover + RichTreeView'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the “Service” tree selector, scroll within the popover to select “Services / Compute / Jobs / Retry Queue”, then click “Apply service”. The task will finish automatically when done.
  ui_copy: In the “Service” tree selector, scroll within the popover to select “Services / Compute / Jobs / Retry Queue”, then click “Apply service”. The task will finish automatically when done.
  setup_description: Layout is nested_scroll with compact spacing, bottom_left placement, and medium clutter. The page itself scrolls, and the MUI popover tree also becomes scrollable once opened. The selector sits in a compact service settings card. Under `Services / Compute / Jobs` there are many siblings—`Scheduler`, `Worker`, `Retry Queue`, `Dead Letter`, and more—with the target near the bottom of the popover viewport. A card-level button labeled “Apply service” commits the value.
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: bottom_left
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - internal_scroll_region
    - placement
    - scale
    factor_rationale: The task compounds two scroll contexts and a small popover target area, which stresses last-mile leaf grounding and confirmation after the popover closes.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: This recreates the scrollable-final-leaf weakness with a different implementation stack and a more demanding nested-scroll scene than the v1 isolated-card tasks.
  success_trigger:
    human_readable:
    - The committed selection path equals ['Services', 'Compute', 'Jobs', 'Retry Queue'].
    - The local "Apply service" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Services
        - Compute
        - Jobs
        - Retry Queue
        value: services-compute-jobs-retry-queue
      tolerance: null
      require_confirm: true
      confirm_control: Apply service
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Apply service".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply service" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mui-v2-T16
  name: Exact two-item replacement set after wrong default selection
  canonical_type: tree_select
  implementation_source: mui
  implementation_variant: composite_rich_tree_checkbox
  implementation_component: 'MUI: TextField + Popover + RichTreeView checkboxSelection'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Included signals”, keep “Metrics / API / p95”, remove the preselected “Metrics / API / p99”, add “Logs / App / Error”, and finish with exactly those two items. Then click “Save signals”. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Included signals”, keep “Metrics / API / p95”, remove the preselected “Metrics / API / p99”, add “Logs / App / Error”, and finish with exactly those two items. Then click “Save signals”. The task will finish automatically when done.
  setup_description: Layout is settings_panel with compact spacing and medium clutter. The card contains one checkbox-style MUI tree-select whose initial selected set is `{Metrics / API / p95, Metrics / API / p99}`. The popup remains open while the checked state changes. Other branches include `Logs / App / Error`, `Logs / App / Warn`, `Metrics / Web / p95`, and several near siblings. A card-local button labeled “Save signals” commits the exact set.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - confirmation_model
    - clutter
    - guidance
    factor_rationale: 'The task is intentionally stateful: it starts from a plausible but wrong set, so the agent must uncheck one item, keep one, add another from a different branch, and then verify the final exact set before saving.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 3
    justification: This is a true recovery-and-verification variant rather than a clean-slate multi-select, and the near-sibling metrics/logging items make wrong-set drift plausible.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Metrics', 'API', 'p95'], ['Logs', 'App', 'Error']].
    - The local "Save signals" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Metrics
          - API
          - p95
        - - Logs
          - App
          - Error
        values:
        - metrics-api-p95
        - logs-app-error
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Save signals
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Save signals".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Save signals" to commit the change.
  notes: The initial selected values should be instrumented so success requires removal of p99 and retention of p95.
- id: tree_select-mantine-v2-T17
  name: 'Checked-state settings panel: exact sync folder set'
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_checkbox
  implementation_component: 'Mantine: TextInput + Popover + Tree with Checkbox.Indicator'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the tree selector labeled “Folders to sync”, select exactly these folders: “Sync / Photos / 2024”, “Sync / Docs / Taxes”, and “Sync / Music / Playlists”. Then click “Apply sync”. The task will finish automatically when done.'
  ui_copy: 'In the tree selector labeled “Folders to sync”, select exactly these folders: “Sync / Photos / 2024”, “Sync / Docs / Taxes”, and “Sync / Music / Playlists”. Then click “Apply sync”. The task will finish automatically when done.'
  setup_description: Layout is settings_panel with compact spacing, off-center placement, and medium clutter from unrelated toggles, select inputs, and a storage meter. The target is a composite Mantine tree-select built from a TextInput trigger, Popover, and `Tree` with checkbox indicators rendered via `renderNode`. The tree uses `useTree` checked state, so parents can become indeterminate while leaves are checked. The final set must contain exactly three leaves and no extras. A section button labeled “Apply sync” commits the checked state.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - precision_surface
    - confirmation_model
    - clutter
    factor_rationale: Mantine’s checked-state tree is a good composite tree-select substrate because parent indeterminate states are visible but not sufficient; the benchmark stays centered on exact leaf-set control and commit verification.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: This uses Mantine’s checked-state tree pattern to create an exact-set hierarchical selection task with clear but nontrivial feedback and a shared apply step.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Sync', 'Photos', '2024'], ['Sync', 'Docs', 'Taxes'], ['Sync', 'Music', 'Playlists']].
    - The local "Apply sync" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Sync
          - Photos
          - '2024'
        - - Sync
          - Docs
          - Taxes
        - - Sync
          - Music
          - Playlists
        values:
        - sync-photos-2024
        - sync-docs-taxes
        - sync-music-playlists
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Apply sync
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Apply sync".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Apply sync" to commit the change.
  notes: Validate the committed leaf set from the composite wrapper rather than from visible pills alone; indeterminate parent state must not count as success.
- id: tree_select-mantine-v2-T18
  name: 'Decoy prefilled neighbor: choose Escalation target only'
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_single
  implementation_component: 'Mantine: TextInput + Popover + Tree'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Escalation target”, choose “Company / Engineering / Platform / Database” and then click “Save targets”. Do not change the prefilled “Current target” selector. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Escalation target”, choose “Company / Engineering / Platform / Database” and then click “Save targets”. Do not change the prefilled “Current target” selector. The task will finish automatically when done.
  setup_description: 'Layout is dashboard_panel with compact spacing, top_right placement, and medium clutter from alert summary cards and a change log widget. Two composite Mantine tree-select controls are shown side by side: “Current target” is prefilled with `Company / Engineering / Platform / API`, while “Escalation target” starts empty. Both use the same Tree data and identical compact TextInput triggers. A card-local button labeled “Save targets” commits the pair.'
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: top_right
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - scale
    - confirmation_model
    factor_rationale: The challenge is choosing the blank target selector rather than the already visible current value, then selecting the correct sibling leaf in a compact composite popover before the shared save.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: This ports the strong prefilled-neighbor decoy pattern to the Mantine composite tree-select, which is valuable because the target and decoy use identical custom triggers and popovers.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Company', 'Engineering', 'Platform', 'Database'].
    - The non-target tree selector "Current target" remains at its initial committed value.
    - The local "Save targets" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Company
        - Engineering
        - Platform
        - Database
        value: company-engineering-platform-database
        non_target_instances_must_remain:
          Current target: Company / Engineering / Platform / API
        target_instance: Escalation target
      tolerance: null
      require_confirm: true
      confirm_control: Save targets
      require_correct_instance: true
      target_instance_label_or_id: Escalation target
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Save targets".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save targets" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mantine-v2-T19
  name: 'Scrollable popover: select deep ARIA roles topic'
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_scroll
  implementation_component: 'Mantine: TextInput + Popover + ScrollArea + Tree'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Topic”, scroll within the popover to select “Topics / Accessibility / ARIA / Roles”, then click “Apply topic”. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Topic”, scroll within the popover to select “Topics / Accessibility / ARIA / Roles”, then click “Apply topic”. The task will finish automatically when done.
  setup_description: Layout is nested_scroll with compact spacing, bottom_right placement, and medium clutter. The composite Mantine tree-select uses a Popover whose tree body is wrapped in a ScrollArea, while the page itself also scrolls. The `Accessibility` branch has many ARIA-related leaves and sub-branches; `Roles` sits below the initially visible items. A small “Apply topic” button commits the selected path.
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - internal_scroll_region
    - placement
    - scale
    factor_rationale: 'This is a direct response to the scrollable-final-leaf evidence: the agent must distinguish page scroll from popup scroll, then land the final leaf in a compact custom tree popover.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: The scroll burden and compact custom rendering make this a high-pressure final-leaf task even though the instruction itself is straightforward.
  success_trigger:
    human_readable:
    - The committed selection path equals ['Topics', 'Accessibility', 'ARIA', 'Roles'].
    - The local "Apply topic" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Topics
        - Accessibility
        - ARIA
        - Roles
        value: topics-accessibility-aria-roles
      tolerance: null
      require_confirm: true
      confirm_control: Apply topic
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Apply topic".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Apply topic" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mantine-v2-T20
  name: Search ambiguous Guinea branch with exact apply
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_search
  implementation_component: 'Mantine: TextInput + Popover + filter input + Tree'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the tree selector labeled “Country”, search for and select “Countries / Africa / Guinea-Bissau”, then click “Save destination”. The task will finish automatically when done.
  ui_copy: In the tree selector labeled “Country”, search for and select “Countries / Africa / Guinea-Bissau”, then click “Save destination”. The task will finish automatically when done.
  setup_description: Layout is inline_surface with compact spacing, off-center placement, and medium clutter from adjacent delivery settings. The popover contains a small search input above a Mantine Tree. Typing `Guinea` reveals several plausible leaves including `Countries / Africa / Guinea`, `Countries / Africa / Equatorial Guinea`, and `Countries / Africa / Guinea-Bissau`. The input field updates only after an explicit “Save destination” click below the selector.
  scene_context:
    theme: light
    spacing: compact
    layout: inline_surface
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - guidance
    - clutter
    - confirmation_model
    factor_rationale: 'Search narrows the tree but does not trivialize it: several Guinea variants remain, so the agent must read the full branch path and then still commit the correct value explicitly.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: This is a high-interference search task built around visually similar leaf labels rather than around raw tree depth.
  success_trigger:
    human_readable:
    - The committed selection path equals ['Countries', 'Africa', 'Guinea-Bissau'].
    - The local "Save destination" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Countries
        - Africa
        - Guinea-Bissau
        value: countries-africa-guinea-bissau
      tolerance: null
      require_confirm: true
      confirm_control: Save destination
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Choosing the correct path but not clicking "Save destination".
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save destination" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: tree_select-mantine-v2-T21
  name: Visual reference among three channels in compact dashboard
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_reference
  implementation_component: 'Mantine: TextInput + Popover + Tree'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the “Alert channels” card, set only the tree selector labeled “Secondary channel” to match the highlighted path in the reference chip, then click “Apply channels”. Do not change “Primary channel” or “Fallback channel”. The task will finish automatically when done.
  ui_copy: In the “Alert channels” card, set only the tree selector labeled “Secondary channel” to match the highlighted path in the reference chip, then click “Apply channels”. Do not change “Primary channel” or “Fallback channel”. The task will finish automatically when done.
  setup_description: Layout is dashboard_panel with compact spacing, center placement, and high clutter from charts, badges, and two unrelated small panels. The target card contains three Mantine composite tree-select controls labeled “Primary channel”, “Secondary channel”, and “Fallback channel”. A visual reference chip above the card highlights `Channels / Ops / Database`. Only Secondary should change; the other two have committed non-target values that must remain untouched. A footer button labeled “Apply channels” commits the card.
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: center
    scale: small
    instances: 3
    guidance: mixed
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - clutter
    - guidance
    factor_rationale: This turns the useful v1 Mantine reference task into a harder three-instance dashboard problem, where the reference is helpful but the real challenge is mapping it to the correct compact selector under high clutter.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 5
    justification: The hierarchy is not the bottleneck; the differentiator is whether the agent can target the correct selector instance and verify the reference match in a busy compact dashboard card.
  success_trigger:
    human_readable:
    - The committed selection matches the reference target ref-mantine-secondary-channel and equals ['Channels', 'Ops', 'Database'].
    - The non-target tree selector "Primary channel" remains unchanged.
    - The non-target tree selector "Fallback channel" remains unchanged.
    - The local "Apply channels" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        reference_id: ref-mantine-secondary-channel
        selection_mode: single
        path:
        - Channels
        - Ops
        - Database
        value: channels-ops-database
        non_target_instances_must_remain:
          Primary channel: Channels / Ops / API
          Fallback channel: Channels / Support / Identity
      tolerance: null
      require_confirm: true
      confirm_control: Apply channels
      require_correct_instance: true
      target_instance_label_or_id: Secondary channel
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a visually similar but wrong reference path.
  - Matching the reference in the wrong selector instance.
  - Matching the reference but not clicking "Apply channels".
  expected_interaction_path:
  - Read the reference target.
  - Open the correct tree selector and select the matching path.
  - Click "Apply channels" to commit the change.
  notes: The checker should validate the committed selected path against the bound reference target, not the reference widget itself.
- id: tree_select-mantine-v2-T22
  name: Drawer exact checked set with indeterminate parents
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_checkbox
  implementation_component: 'Mantine: TextInput + Drawer + Tree with Checkbox.Indicator'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'Open the “Projects to notify” drawer. In the tree selector labeled “Projects”, select exactly these leaves: “Projects / Alpha / QA”, “Projects / Beta / QA”, and “Projects / Beta / Design”. Then click “Save projects”. The task will finish automatically when done.'
  ui_copy: 'Open the “Projects to notify” drawer. In the tree selector labeled “Projects”, select exactly these leaves: “Projects / Alpha / QA”, “Projects / Beta / QA”, and “Projects / Beta / Design”. Then click “Save projects”. The task will finish automatically when done.'
  setup_description: Layout is drawer_flow with compact spacing and medium clutter. The drawer contains one composite Mantine tree-select using checkbox indicators inside a custom `renderNode`. Parents can become indeterminate, but success is based only on the exact leaf set. The `Projects` tree includes `Alpha`, `Beta`, and `Gamma`, each with child leaves such as `QA`, `Design`, and `Docs`. The drawer footer contains “Save projects”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - overlay_model
    - precision_surface
    - confirmation_model
    factor_rationale: 'Indeterminate parents provide useful but incomplete feedback: the agent still has to manage the exact leaf set correctly and then commit it through a drawer-local save step.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: This is a legitimate exact-set tree-select task for the Mantine composite because the checkbox rendering creates clear but nontrivial parent-state feedback rather than a plain text list.
  success_trigger:
    human_readable:
    - The committed selected set equals exactly [['Projects', 'Alpha', 'QA'], ['Projects', 'Beta', 'QA'], ['Projects', 'Beta', 'Design']].
    - The local "Save projects" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        selection_mode: multiple
        paths:
        - - Projects
          - Alpha
          - QA
        - - Projects
          - Beta
          - QA
        - - Projects
          - Beta
          - Design
        values:
        - projects-alpha-qa
        - projects-beta-qa
        - projects-beta-design
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Save projects
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only a subset of the requested items.
  - Selecting any extra node outside the requested exact set.
  - Reaching the correct set but not clicking "Save projects".
  expected_interaction_path:
  - Open the target tree selector.
  - Check or select each requested item while avoiding extra selections.
  - Click "Save projects" to commit the change.
  notes: Compare committed selected values as an order-invariant exact set.
- id: tree_select-mantine-v2-T23
  name: Auth row table-cell tree selector with local save
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_table_cell
  implementation_component: 'Mantine: TextInput + Popover + Tree in table cell'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the “Policy path” tree selector for the “Auth” row, select “Handbook / Policies / Access / Tokens” and then click “Save row”. Do not change the “Billing” row. The task will finish automatically when done.
  ui_copy: In the “Policy path” tree selector for the “Auth” row, select “Handbook / Policies / Access / Tokens” and then click “Save row”. Do not change the “Billing” row. The task will finish automatically when done.
  setup_description: Layout is table_cell with compact spacing, bottom_left placement, small scale, and medium clutter from row badges and icon buttons. The “Auth” and “Billing” rows each contain a compact Mantine composite tree-select with identical triggers. The tree for Auth contains `Handbook > Policies > Access > {Keys, Tokens, Sessions}` and additional non-target branches. Each row has a local “Save row” button. Only the Auth row should change.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_left
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - instances
    - scale
    factor_rationale: 'This is the Mantine counterpart to the compact in-cell activation problem: the agent must target the right row trigger, navigate the correct path, and commit through the right row-local save.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The hierarchy is short, but the table-cell carrier and duplicate compact triggers make acquisition and correct-row verification the dominant challenge.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Handbook', 'Policies', 'Access', 'Tokens'].
    - The non-target tree selector "Billing" remains at its initial committed value.
    - The local "Save row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Handbook
        - Policies
        - Access
        - Tokens
        value: handbook-policies-access-tokens
        non_target_instances_must_remain:
          Billing: Handbook / Policies / Billing / Invoices
        target_instance: Auth
      tolerance: null
      require_confirm: true
      confirm_control: Save row
      require_correct_instance: true
      target_instance_label_or_id: Auth
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Save row".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save row" to commit the change.
  notes: Bind each row trigger and row-local save separately; table-row disambiguation is a required part of success.
- id: tree_select-mantine-v2-T24
  name: High-clutter four-instance backup taxonomy panel
  canonical_type: tree_select
  implementation_source: mantine
  implementation_variant: composite_tree_single
  implementation_component: 'Mantine: TextInput + Popover + Tree'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the high-clutter settings panel, edit only the tree selector labeled “Backup taxonomy” so that it is set to “Catalog / Hardware / Storage / Snapshots”, then click “Save panel”. Do not change the other three selectors. The task will finish automatically when done.
  ui_copy: In the high-clutter settings panel, edit only the tree selector labeled “Backup taxonomy” so that it is set to “Catalog / Hardware / Storage / Snapshots”, then click “Save panel”. Do not change the other three selectors. The task will finish automatically when done.
  setup_description: 'Layout is settings_panel with high_contrast theme, compact spacing, small scale, and high clutter. Four Mantine composite tree-select controls are stacked in one panel: “Primary taxonomy”, “Backup taxonomy”, “Customer taxonomy”, and “Internal taxonomy”. Each uses the same compact trigger and Popover + Tree structure. Only “Backup taxonomy” starts empty; the other three have committed values and must remain unchanged. Above the selectors are several toggles, pills, and segmented controls. A single “Save panel” button commits all four selectors.'
  scene_context:
    theme: high_contrast
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: small
    instances: 4_plus
    guidance: text
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - theme
    - clutter
    factor_rationale: 'This intentionally uses the strongest macro levers from the scene-factor analysis: four same-type instances, high clutter, compact geometry, and one shared commit step. The hierarchy itself remains normal so the task stays human-solvable.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The content path is simple; the difficulty comes from correctly finding and editing only one of four compact selectors in a high-pressure panel and preserving the rest through a shared save.
  success_trigger:
    human_readable:
    - The committed selection path for the target tree selector equals ['Catalog', 'Hardware', 'Storage', 'Snapshots'].
    - The non-target tree selector "Primary taxonomy" remains at its initial committed value.
    - The non-target tree selector "Customer taxonomy" remains at its initial committed value.
    - The non-target tree selector "Internal taxonomy" remains at its initial committed value.
    - The local "Save panel" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        selection_mode: single
        path:
        - Catalog
        - Hardware
        - Storage
        - Snapshots
        value: catalog-hardware-storage-snapshots
        non_target_instances_must_remain:
          Primary taxonomy: Catalog / Hardware / Compute / VMs
          Customer taxonomy: Catalog / Support / Tickets / Priority
          Internal taxonomy: Catalog / Ops / Alerts / Sev1
        target_instance: Backup taxonomy
      tolerance: null
      require_confirm: true
      confirm_control: Save panel
      require_correct_instance: true
      target_instance_label_or_id: Backup taxonomy
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a sibling or ancestor path instead of the requested final path.
  - Modifying the wrong tree selector instance.
  - Choosing the correct path but not clicking "Save panel".
  - Changing any non-target tree selector instance.
  expected_interaction_path:
  - Open the target tree selector.
  - Expand the required ancestors and select the requested path.
  - Click "Save panel" to commit the change.
  notes: Instrument the trigger, popup root, and committed selected path for the target instance.
- id: cascader-antd-v2-T01
  name: Lazy-loaded drawer category with deferred final submenu
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: lazy_load
  implementation_component: 'AntD: Cascader'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Knowledge base category” drawer. In the cascader labeled “Category”, select “Hardware / Printers / Setup”, then click “Save category”. The task will finish automatically when done.
  ui_copy: Open the “Knowledge base category” drawer. In the cascader labeled “Category”, select “Hardware / Printers / Setup”, then click “Save category”. The task will finish automatically when done.
  setup_description: Layout is drawer_flow with compact spacing and medium clutter. A right-side drawer opens over a documentation settings page. Inside is one compact Ant Design Cascader labeled “Category”. The first levels `Hardware` and `Printers` are available immediately, but the leaf options under `Printers` load lazily after expansion. Once loaded, the final column contains nearby siblings such as `Install`, `Setup`, and `Troubleshooting`. The drawer footer contains “Cancel” and “Save category”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - overlay_model
    - confirmation_model
    - clutter
    factor_rationale: This uses Cascader lazy loading in a realistic drawer carrier, so the agent must keep popup state straight across the loading transition and still commit the final leaf explicitly.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: The task remains semantically clear, but delayed child reveal plus a drawer-local save step creates the layered-state and recovery pressure that the cascader evidence said was diagnostically useful.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Hardware', 'Printers', 'Setup'].
    - The local "Save category" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Hardware
        - Printers
        - Setup
        path_values:
        - hardware
        - printers
        - setup
      tolerance: null
      require_confirm: true
      confirm_control: Save category
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Save category".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save category" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T02
  name: Compact hover-expand table row assign-to path
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: hover_expand
  implementation_component: 'AntD: Cascader'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the routing rules table, set the “Assign to” cascader for the “Password reset” row to “Support / Tier 2 / Identity”, then click “Save row”. Do not change any other row. The task will finish automatically when done.
  ui_copy: In the routing rules table, set the “Assign to” cascader for the “Password reset” row to “Support / Tier 2 / Identity”, then click “Save row”. Do not change any other row. The task will finish automatically when done.
  setup_description: Layout is table_cell with compact spacing, bottom_left placement, small scale, and medium clutter from row badges, action icons, and adjacent filters. The “Password reset” and “Billing dispute” rows each contain a compact Ant Design Cascader labeled “Assign to”. This cascader uses `expandTrigger="hover"` so the next column appears as the pointer moves through the active option. Only the Password reset row should change, and each row has its own “Save row” button.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_left
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - scale
    - instances
    factor_rationale: This keeps the cascader primary while raising acquisition difficulty through a compact table-cell trigger and hover-sensitive layered columns, which are exactly where weaker modes lost visual anchoring in v1.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The hard part is activating the correct row-local trigger and staying anchored to the right popup column as hover expansion and compact geometry make the menu transient and narrow.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Support', 'Tier 2', 'Identity'].
    - The non-target cascader "Billing dispute" remains at its initial committed value.
    - The local "Save row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Support
        - Tier 2
        - Identity
        path_values:
        - support
        - tier2
        - identity
        target_instance: Password reset
        non_target_instances_must_remain:
          Billing dispute: Support / Tier 1 / Billing
      tolerance: null
      require_confirm: true
      confirm_control: Save row
      require_correct_instance: true
      target_instance_label_or_id: Password reset
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Save row".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save row" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T03
  name: 'Multiple re-ground after first chip: exact Paris and Osaka'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the “Cities included” cascader, select exactly these two paths: “Europe / France / Paris” and “Asia / Japan / Osaka”. Then click “Apply cities”. The task will finish automatically when done.'
  ui_copy: 'In the “Cities included” cascader, select exactly these two paths: “Europe / France / Paris” and “Asia / Japan / Osaka”. Then click “Apply cities”. The task will finish automatically when done.'
  setup_description: Layout is settings_panel with compact spacing, off-center placement, and medium clutter from toggles and schedule controls. The Ant Design Cascader labeled “Cities included” uses `multiple` mode. The popup stays open after a selection, but once the first path is chosen a chip appears inside the input and the remaining popup geometry shifts slightly. Nearby distractors include `Tokyo`, `Kyoto`, and `Lyon`. A section button labeled “Apply cities” commits the exact path set.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - confirmation_model
    - clutter
    - guidance
    factor_rationale: 'This is the explicit re-ground-after-first-chip variant recommended by the component report: the challenge starts after the first correct leaf changes the visible input and the agent must continue selecting without hallucinating completion.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: Exact multi-select cascaders are hard because the popup state and selected chips evolve after every correct choice, so the agent has to re-anchor before committing the final exact set.
  success_trigger:
    human_readable:
    - The committed selected path set equals exactly [['Europe', 'France', 'Paris'], ['Asia', 'Japan', 'Osaka']].
    - The local "Apply cities" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        paths_labels:
        - - Europe
          - France
          - Paris
        - - Asia
          - Japan
          - Osaka
        paths_values:
        - - europe
          - france
          - paris
        - - asia
          - japan
          - osaka
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Apply cities
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Reaching the correct set but not clicking "Apply cities".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Apply cities" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T04
  name: 'Visual target chips: exact three-path team set in drawer'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple_responsive
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: Open the “Teams included” drawer. In the cascader labeled “Teams included”, select the same three paths shown in the target chips card, then click “Save teams”. The task will finish automatically when done.
  ui_copy: Open the “Teams included” drawer. In the cascader labeled “Teams included”, select the same three paths shown in the target chips card, then click “Save teams”. The task will finish automatically when done.
  setup_description: 'Layout is drawer_flow with compact spacing, top_right placement, and high clutter. The drawer contains one Ant Design multiple Cascader labeled “Teams included” and a visual target card showing three chips for the desired paths: `Engineering / Platform / API`, `Engineering / Support / Identity`, and `Customer Success / Enterprise / Onboarding`. The input uses responsive tag layout, so after selections are added the visible chip arrangement can wrap. The drawer footer contains “Save teams”.'
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: top_right
    scale: small
    instances: 1
    guidance: mixed
    clutter: high
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - guidance
    - overlay_model
    - confirmation_model
    factor_rationale: The target set is specified visually, but the real burden is controlling a multiple cascader whose tags wrap and whose popup state changes after each correct path, then committing through the drawer.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: This is a genuinely hard multi-select reference task because the selected tags and popup layout keep moving while the agent is still responsible for reaching an exact three-path set.
  success_trigger:
    human_readable:
    - The committed selected path set matches the reference target ref-cascader-team-chips and equals [['Engineering', 'Platform', 'API'], ['Engineering', 'Support', 'Identity'], ['Customer Success', 'Enterprise', 'Onboarding']].
    - The local "Save teams" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        paths_labels:
        - - Engineering
          - Platform
          - API
        - - Engineering
          - Support
          - Identity
        - - Customer Success
          - Enterprise
          - Onboarding
        paths_values:
        - - engineering
          - platform
          - api
        - - engineering
          - support
          - identity
        - - customer-success
          - enterprise
          - onboarding
        order_invariant: true
        reference_id: ref-cascader-team-chips
      tolerance: null
      require_confirm: true
      confirm_control: Save teams
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Reaching the correct set but not clicking "Save teams".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Save teams" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T05
  name: Leaf-only displayRender with ambiguous Springfield branch
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: leaf_only_display_render
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “Event city”, select “USA / Massachusetts / Springfield”, then click “Apply city”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Event city”, select “USA / Massachusetts / Springfield”, then click “Apply city”. The task will finish automatically when done.
  setup_description: Layout is settings_panel with compact spacing, center placement, and medium clutter. One Ant Design Cascader labeled “Event city” uses a custom `displayRender` that shows only the final leaf text after selection, not the full breadcrumb. The hierarchy contains duplicate `Springfield` leaves under Massachusetts, Illinois, and Missouri. The popup columns are otherwise standard. A button labeled “Apply city” commits the current path.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - confirmation_model
    - clutter
    - guidance
    factor_rationale: Leaf-only display feedback weakens post-selection observability, so the agent must not rely on the input alone when several duplicate Springfield leaves exist.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: The hierarchy is familiar, but duplicate leaf labels plus reduced breadcrumb feedback make exact branch verification much harder than a normal single-select cascader.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['USA', 'Massachusetts', 'Springfield'].
    - The local "Apply city" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - USA
        - Massachusetts
        - Springfield
        path_values:
        - usa
        - massachusetts
        - springfield-ma
      tolerance: null
      require_confirm: true
      confirm_control: Apply city
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply city".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply city" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T06
  name: 'Three routes with prefilled neighbor: set only Tertiary route'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: three_instances
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: Set only the cascader labeled “Tertiary route” to “EU-West / Ireland / Zone 2”, then click “Apply routes”. Do not change the prefilled “Primary route” or “Secondary route”. The task will finish automatically when done.
  ui_copy: Set only the cascader labeled “Tertiary route” to “EU-West / Ireland / Zone 2”, then click “Apply routes”. Do not change the prefilled “Primary route” or “Secondary route”. The task will finish automatically when done.
  setup_description: 'Layout is dashboard_panel with compact spacing, off-center placement, and medium clutter from KPI cards and an activity feed. Three compact Ant Design Cascaders appear in one routing card: “Primary route” is prefilled with `EU-West / Ireland / Zone 1`, “Secondary route” is prefilled with `EU-Central / Germany / Zone 1`, and “Tertiary route” is empty. All three use the same 3-level region tree. A card-local button labeled “Apply routes” commits the card.'
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: off_center
    scale: small
    instances: 3
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - scale
    - confirmation_model
    factor_rationale: 'This mirrors the strongest tree-select decoy pattern in cascader form: two plausible prefilled values compete visually with the only empty target selector, and the final zone choice is a narrow last-mile leaf.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The hierarchy is not the bottleneck here; the differentiator is correct instance selection and precise final-leaf grounding before the shared apply step.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['EU-West', 'Ireland', 'Zone 2'].
    - The non-target cascader "Primary route" remains at its initial committed value.
    - The non-target cascader "Secondary route" remains at its initial committed value.
    - The local "Apply routes" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - EU-West
        - Ireland
        - Zone 2
        path_values:
        - eu-west
        - ireland
        - zone-2
        target_instance: Tertiary route
        non_target_instances_must_remain:
          Primary route: EU-West / Ireland / Zone 1
          Secondary route: EU-Central / Germany / Zone 1
      tolerance: null
      require_confirm: true
      confirm_control: Apply routes
      require_correct_instance: true
      target_instance_label_or_id: Tertiary route
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Apply routes".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply routes" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T07
  name: Compact row-embedded trigger in rules table
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: compact_embedded_trigger
  implementation_component: 'AntD: Cascader'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the routing rules table, set the “Category” cascader for the “Auth lockout” row to “Support / Tier 2 / Identity”, then click “Save row”. Do not change the “Billing retry” row. The task will finish automatically when done.
  ui_copy: In the routing rules table, set the “Category” cascader for the “Auth lockout” row to “Support / Tier 2 / Identity”, then click “Save row”. Do not change the “Billing retry” row. The task will finish automatically when done.
  setup_description: Layout is table_cell with compact spacing, bottom_right placement, small scale, and medium clutter. The “Auth lockout” and “Billing retry” rows are both editable and each exposes a compact Ant Design Cascader inside the Category cell. The trigger sits close to row chrome and action icons. The hierarchy itself is short, but the popup is anchored tightly to the row and only the Auth lockout row should be saved with the new value. Each row has a local “Save row” button.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_right
    scale: small
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - instances
    - scale
    factor_rationale: 'This is the compact embedded trigger variant the report explicitly recommended: the hierarchy is simple on purpose so the benchmark measures acquisition of the right small trigger and stable column anchoring.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 5
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The row carrier forces the agent to first ground the correct compact trigger and then keep the layered popup tied to the right row-local save action.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Support', 'Tier 2', 'Identity'].
    - The non-target cascader "Billing retry" remains at its initial committed value.
    - The local "Save row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Support
        - Tier 2
        - Identity
        path_values:
        - support
        - tier-2
        - identity
        target_instance: Auth lockout
        non_target_instances_must_remain:
          Billing retry: Support / Tier 1 / Billing
      tolerance: null
      require_confirm: true
      confirm_control: Save row
      require_correct_instance: true
      target_instance_label_or_id: Auth lockout
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Save row".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save row" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T08
  name: Modal shipping rule with deep destination leaf
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: modal_confirm
  implementation_component: 'AntD: Cascader'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Edit shipping rule”. In the cascader labeled “Allowed destinations”, select “Asia / Singapore / Downtown”, then click “Save rule”. The task will finish automatically when done.
  ui_copy: Open “Edit shipping rule”. In the cascader labeled “Allowed destinations”, select “Asia / Singapore / Downtown”, then click “Save rule”. The task will finish automatically when done.
  setup_description: Layout is modal_flow with compact spacing and medium clutter from the blurred dashboard behind it. The Ant Design Modal contains one compact Cascader labeled “Allowed destinations”. The destination tree has several three-level city branches under Asia, including `Airport`, `Downtown`, and `Harbor` under Singapore. The selection is not committed until the modal-local “Save rule” button is clicked.
  scene_context:
    theme: light
    spacing: compact
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: dialog
  design_intent:
    active_factors:
    - overlay_model
    - confirmation_model
    - placement
    factor_rationale: This keeps the path simple but pushes it into a modal draft so the agent must complete the cascader path and the modal confirmation boundary correctly.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: The extra hardening comes from the modal flow and explicit save boundary, not from adversarial labels or hidden tolerances.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Asia', 'Singapore', 'Downtown'].
    - The local "Save rule" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Asia
        - Singapore
        - Downtown
        path_values:
        - asia
        - singapore
        - downtown
      tolerance: null
      require_confirm: true
      confirm_control: Save rule
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Save rule".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save rule" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T09
  name: Drawer assignee group with sibling decoys and explicit save
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: drawer_confirm
  implementation_component: 'AntD: Cascader'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Assignment settings”. In the cascader labeled “Default assignee group”, select “Customer Success / Enterprise / Onboarding”, then click “Save settings”. The task will finish automatically when done.
  ui_copy: Open “Assignment settings”. In the cascader labeled “Default assignee group”, select “Customer Success / Enterprise / Onboarding”, then click “Save settings”. The task will finish automatically when done.
  setup_description: Layout is drawer_flow with compact spacing, top_left placement, and medium clutter from sidebar chips and read-only counters. The drawer contains one Ant Design Cascader labeled “Default assignee group”. Under `Customer Success > Enterprise` the final column contains `Onboarding`, `Adoption`, and `Renewal`, all visually similar. The drawer footer contains “Save settings”.
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - placement
    - overlay_model
    - confirmation_model
    factor_rationale: 'A corner-anchored drawer slightly raises acquisition burden, but the core challenge is still cascader-specific: final-sibling disambiguation inside a shifting overlay followed by explicit commit.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: This is a clean drawer-local variant that stays true to the component while still shifting away from low-pressure center-card scenes.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Customer Success', 'Enterprise', 'Onboarding'].
    - The local "Save settings" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Customer Success
        - Enterprise
        - Onboarding
        path_values:
        - customer-success
        - enterprise
        - onboarding
      tolerance: null
      require_confirm: true
      confirm_control: Save settings
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Save settings".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save settings" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T10
  name: Dark visual breadcrumb match with exact policy branch
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: visual_breadcrumb
  implementation_component: 'AntD: Cascader'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the cascader labeled “Policy category”, select the path shown in the breadcrumb reference card, then click “Apply policy”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Policy category”, select the path shown in the breadcrumb reference card, then click “Apply policy”. The task will finish automatically when done.
  setup_description: Layout is dashboard_panel with dark theme, compact spacing, off-center placement, and medium clutter. One Ant Design Cascader labeled “Policy category” sits below a read-only breadcrumb reference card showing the target path `Policies / Access / Password reset`. The cascader uses standard three-column popup behavior, and the card-level “Apply policy” button commits the selection.
  scene_context:
    theme: dark
    spacing: compact
    layout: dashboard_panel
    placement: off_center
    scale: default
    instances: 1
    guidance: visual
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - guidance
    - theme
    - confirmation_model
    factor_rationale: The breadcrumb reference is intentionally helpful but not richly explanatory; the real burden is still mapping that reference to the correct three-column popup path and explicitly committing it under dark compact rendering.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: This preserves the useful visual-match family from v1 while removing the low-pressure centered isolated-card scene.
  success_trigger:
    human_readable:
    - The committed cascader path matches the reference target ref-policy-breadcrumb and equals ['Policies', 'Access', 'Password reset'].
    - The local "Apply policy" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        path_labels:
        - Policies
        - Access
        - Password reset
        path_values:
        - policies
        - access
        - password-reset
        reference_id: ref-policy-breadcrumb
      tolerance: null
      require_confirm: true
      confirm_control: Apply policy
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply policy".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply policy" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T11
  name: Intermediate-path commit with changeOnSelect and decoy selector
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: change_on_select
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “Reporting scope”, select the intermediate path “Engineering / Platform” and then click “Apply scope”. Do not change the prefilled “Billing scope” cascader. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Reporting scope”, select the intermediate path “Engineering / Platform” and then click “Apply scope”. Do not change the prefilled “Billing scope” cascader. The task will finish automatically when done.
  setup_description: 'Layout is settings_panel with compact spacing, off-center placement, and medium clutter. Two Ant Design Cascaders appear in the same card: “Reporting scope” is empty, and “Billing scope” is prefilled with `Finance / Payroll`. The target cascader uses `changeOnSelect`, so selecting the second-level node commits a valid intermediate path without requiring a leaf. Nearby branches include `Engineering / Product`, `Finance / Platform`, and `Engineering / Platform / API`. A card-local “Apply scope” button commits both selectors.'
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - confirmation_model
    - guidance
    factor_rationale: Intermediate-path commitment is a real Cascader feature, but it becomes hard when a neighboring cascader is already filled and a deeper third column still appears, tempting the agent to over-select or target the wrong instance.
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 5
    justification: 'This is not a toy partial-path task: the agent must understand that a mid-path is the intended terminal state, ignore a prefilled sibling selector, and still commit the correct intermediate value explicitly.'
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Engineering', 'Platform'].
    - The non-target cascader "Billing scope" remains at its initial committed value.
    - The local "Apply scope" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Engineering
        - Platform
        path_values:
        - engineering
        - platform
        target_instance: Reporting scope
        non_target_instances_must_remain:
          Billing scope: Finance / Payroll
      tolerance: null
      require_confirm: true
      confirm_control: Apply scope
      require_correct_instance: true
      target_instance_label_or_id: Reporting scope
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Apply scope".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply scope" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T12
  name: Search duplicate city names and save exact San Jose branch
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: show_search
  implementation_component: 'AntD: Cascader'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “City selector”, use search to choose “United States / California / San Jose”, then click “Apply city”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “City selector”, use search to choose “United States / California / San Jose”, then click “Apply city”. The task will finish automatically when done.
  setup_description: Layout is inline_surface with compact spacing, center placement, and medium clutter from surrounding logistics controls. The Ant Design Cascader labeled “City selector” has `showSearch` enabled. Typing `San Jose` reveals several matched paths including `United States / California / San Jose`, `Costa Rica / San José / Escazú`, and `Philippines / Nueva Ecija / San Jose`. Direct hierarchical navigation is possible but inconvenient because the tree contains many branches. A local “Apply city” button commits the selected path.
  scene_context:
    theme: dark
    spacing: compact
    layout: inline_surface
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: autocomplete
  design_intent:
    active_factors:
    - guidance
    - clutter
    - confirmation_model
    factor_rationale: 'Search is justified here because the ambiguity remains after filtering: several San Jose variants survive, so the agent must still verify the full matched path and explicitly apply it.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: 'This fixes a v1 weakness by making search operationally meaningful: using the search narrows the tree, but exact branch confirmation is still required because multiple matched San Jose paths remain plausible.'
  success_trigger:
    human_readable:
    - The committed cascader path equals ['United States', 'California', 'San Jose'].
    - The local "Apply city" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - United States
        - California
        - San Jose
        path_values:
        - united-states
        - california
        - san-jose-us
      tolerance: null
      require_confirm: true
      confirm_control: Apply city
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply city".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply city" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T13
  name: Replace one wrong default chip and finish with exact two-city set
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple_replace_default
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the cascader labeled “Cities included”, keep “Europe / France / Paris”, remove the preselected “Europe / Spain / Madrid”, add “Asia / Japan / Osaka”, and finish with exactly those two paths. Then click “Save cities”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Cities included”, keep “Europe / France / Paris”, remove the preselected “Europe / Spain / Madrid”, add “Asia / Japan / Osaka”, and finish with exactly those two paths. Then click “Save cities”. The task will finish automatically when done.
  setup_description: 'Layout is settings_panel with compact spacing, off-center placement, and medium clutter. The multiple Ant Design Cascader labeled “Cities included” starts with two chips already selected: `Europe / France / Paris` and `Europe / Spain / Madrid`. The goal is to preserve Paris, remove Madrid, and add Osaka. The popup stays open as selections change, so the chip layout and visible columns shift after every action. A button labeled “Save cities” commits the exact final set.'
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - confirmation_model
    - clutter
    - guidance
    factor_rationale: 'This turns recovery into a first-class cascader task: the agent must manage removal and addition inside a persistent multiple-selection popup while preserving one correct default chip and committing the final exact set.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: Because the task starts from a plausible but wrong default state, it stresses chip-state tracking and exact-set verification more than a clean-slate two-path selection does.
  success_trigger:
    human_readable:
    - The committed selected path set equals exactly [['Europe', 'France', 'Paris'], ['Asia', 'Japan', 'Osaka']].
    - The local "Save cities" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        paths_labels:
        - - Europe
          - France
          - Paris
        - - Asia
          - Japan
          - Osaka
        paths_values:
        - - europe
          - france
          - paris
        - - asia
          - japan
          - osaka
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Save cities
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Reaching the correct set but not clicking "Save cities".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Save cities" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T14
  name: Responsive tags exact set in compact dashboard filter
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple_responsive_tags
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the “Teams included” cascader, select exactly these three paths: “Support / Tier 2 / Identity”, “Support / Tier 2 / Billing”, and “Platform / Database / Primary”. Then click “Apply filters”. The task will finish automatically when done.'
  ui_copy: 'In the “Teams included” cascader, select exactly these three paths: “Support / Tier 2 / Identity”, “Support / Tier 2 / Billing”, and “Platform / Database / Primary”. Then click “Apply filters”. The task will finish automatically when done.'
  setup_description: Layout is dashboard_panel with compact spacing, bottom_right placement, small scale, and high clutter. The multiple Ant Design Cascader is embedded in a filter strip and uses responsive tag layout plus a narrow input width, so selected tags wrap and partially collapse as the set grows. The hierarchy contains nearby siblings such as `Support / Tier 1 / Identity` and `Platform / Database / Replica`. A filter-strip button labeled “Apply filters” commits the exact set.
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - clutter
    - scale
    - confirmation_model
    factor_rationale: 'This task makes visible tag feedback less stable without hiding it: as the input wraps and collapses, the agent has to verify the exact path set rather than relying on a clean, static chip list.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: Responsive tags and a compact filter strip make this a stronger exact-set cascader task than a plain full-width multiple selector, while remaining human-solvable and realistic.
  success_trigger:
    human_readable:
    - The committed selected path set equals exactly [['Support', 'Tier 2', 'Identity'], ['Support', 'Tier 2', 'Billing'], ['Platform', 'Database', 'Primary']].
    - The local "Apply filters" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        paths_labels:
        - - Support
          - Tier 2
          - Identity
        - - Support
          - Tier 2
          - Billing
        - - Platform
          - Database
          - Primary
        paths_values:
        - - support
          - tier-2
          - identity
        - - support
          - tier-2
          - billing
        - - platform
          - database
          - primary
        order_invariant: true
      tolerance: null
      require_confirm: true
      confirm_control: Apply filters
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Reaching the correct set but not clicking "Apply filters".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Apply filters" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T15
  name: Lazy-loaded compact form row with nested page and popup scroll
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: lazy_load_scroll
  implementation_component: 'AntD: Cascader'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the compact form row labeled “Knowledge base path”, expand the lazy-loaded cascader until “Hardware / Networking / Routers” appears, select it, and click “Apply row”. The task will finish automatically when done.
  ui_copy: In the compact form row labeled “Knowledge base path”, expand the lazy-loaded cascader until “Hardware / Networking / Routers” appears, select it, and click “Apply row”. The task will finish automatically when done.
  setup_description: Layout is nested_scroll with compact spacing, off-center placement, and medium clutter. The page itself scrolls and contains several stacked form rows; the target row is visible but its compact Ant Design Cascader trigger is embedded between text inputs and chips. The `Hardware` subtree loads children lazily after expansion, and the final `Routers` option appears below the initial popup viewport inside a scrollable column. A row-local “Apply row” button commits the change.
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: off_center
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - internal_scroll_region
    - layout
    - scale
    factor_rationale: This combines two strong cascader stressors—lazy loading and popup scrolling—inside a compact embedded row, but still keeps the target path semantically straightforward and human-feasible.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: The task is hard because the correct column contents are both delayed and partly offscreen, which makes state tracking and popup-specific scrolling necessary before the apply step.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Hardware', 'Networking', 'Routers'].
    - The local "Apply row" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Hardware
        - Networking
        - Routers
        path_values:
        - hardware
        - networking
        - routers
      tolerance: null
      require_confirm: true
      confirm_control: Apply row
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply row".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply row" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T16
  name: Dark hover-expand policy path with narrow final leaf
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: hover_expand
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “Policy path”, select “Policies / Access / Password reset”, then click “Save policy”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Policy path”, select “Policies / Access / Password reset”, then click “Save policy”. The task will finish automatically when done.
  setup_description: Layout is settings_panel with dark theme, compact spacing, small scale, and medium clutter. The Ant Design Cascader uses `expandTrigger="hover"` and sits beside two unrelated compact controls. The final column contains several visually similar leaves including `Password change`, `Password reset`, and `Passwordless login`. The panel footer contains “Save policy”.
  scene_context:
    theme: dark
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - theme
    - scale
    - clutter
    factor_rationale: This keeps the task within normal cascader semantics but raises the visual burden with hover-triggered columns, dark compact rendering, and a narrow final-leaf discrimination problem.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 1
    justification: This is a clean grounding-heavy cascader task that does not depend on search or hidden shortcuts; the difficulty is concentrated in final-leaf targeting under compact dark hover-driven columns.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Policies', 'Access', 'Password reset'].
    - The local "Save policy" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Policies
        - Access
        - Password reset
        path_values:
        - policies
        - access
        - password-reset
      tolerance: null
      require_confirm: true
      confirm_control: Save policy
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Save policy".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save policy" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T17
  name: Two identical leaf labels with leaf-only display and wrong-instance lure
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: leaf_only_display_render
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “Report city”, select “USA / Massachusetts / Springfield” and then click “Apply cities”. Do not change the prefilled “Fallback city” cascader. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Report city”, select “USA / Massachusetts / Springfield” and then click “Apply cities”. Do not change the prefilled “Fallback city” cascader. The task will finish automatically when done.
  setup_description: 'Layout is dashboard_panel with compact spacing, top_left placement, and medium clutter. Two Ant Design Cascaders sit in one card: “Report city” is empty and “Fallback city” is prefilled with `USA / Illinois / Springfield`. Both use `displayRender` that shows only the leaf text after selection, so either committed value would appear as `Springfield` in the input. A card-local button labeled “Apply cities” commits both selectors.'
  scene_context:
    theme: light
    spacing: compact
    layout: dashboard_panel
    placement: top_left
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - guidance
    - confirmation_model
    factor_rationale: The task combines duplicate leaf labels, weak leaf-only feedback, and a prefilled neighboring selector, so correct-instance selection and exact branch verification are both necessary.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 5
    justification: Because both target and decoy would display as the same final leaf text, this is a stronger cascader disambiguation task than a plain duplicate-leaf selection.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['USA', 'Massachusetts', 'Springfield'].
    - The non-target cascader "Fallback city" remains at its initial committed value.
    - The local "Apply cities" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - USA
        - Massachusetts
        - Springfield
        path_values:
        - usa
        - massachusetts
        - springfield-ma
        target_instance: Report city
        non_target_instances_must_remain:
          Fallback city: USA / Illinois / Springfield
      tolerance: null
      require_confirm: true
      confirm_control: Apply cities
      require_correct_instance: true
      target_instance_label_or_id: Report city
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Apply cities".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply cities" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T18
  name: Visual reference for intermediate changeOnSelect scope
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: change_on_select
  implementation_component: 'AntD: Cascader'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the cascader labeled “Reporting scope”, select the same intermediate path shown in the reference breadcrumb card, then click “Apply scope”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Reporting scope”, select the same intermediate path shown in the reference breadcrumb card, then click “Apply scope”. The task will finish automatically when done.
  setup_description: Layout is inline_surface with compact spacing, off-center placement, and medium clutter. The Ant Design Cascader labeled “Reporting scope” uses `changeOnSelect`, so an intermediate two-level path can be the final answer. A breadcrumb reference card shows the target `Engineering / Platform` without the deeper descendants. The popup still reveals a third column with leaves such as `API`, `Queues`, and `Cache`, which should not be selected. A local “Apply scope” button commits the chosen path.
  scene_context:
    theme: light
    spacing: compact
    layout: inline_surface
    placement: off_center
    scale: default
    instances: 1
    guidance: mixed
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - guidance
    - confirmation_model
    - overlay_model
    factor_rationale: 'This makes intermediate-path commitment explicit and observable: the reference card says what the final breadcrumb should be, but the visible deeper leaves are a deliberate over-selection temptation.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 1
    justification: The task probes whether the agent can stop at the correct non-leaf selection instead of treating deeper visible leaves as mandatory, then explicitly commit that intermediate state.
  success_trigger:
    human_readable:
    - The committed cascader path matches the reference target ref-reporting-scope and equals ['Engineering', 'Platform'].
    - The local "Apply scope" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        path_labels:
        - Engineering
        - Platform
        path_values:
        - engineering
        - platform
        reference_id: ref-reporting-scope
      tolerance: null
      require_confirm: true
      confirm_control: Apply scope
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply scope".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply scope" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T19
  name: 'Four-instance high-clutter routing panel: edit only Backup route'
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: four_instances
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the high-clutter routing panel, set only the cascader labeled “Backup route” to “North America / Canada / Vancouver”, then click “Save panel”. Do not change the other three cascaders. The task will finish automatically when done.
  ui_copy: In the high-clutter routing panel, set only the cascader labeled “Backup route” to “North America / Canada / Vancouver”, then click “Save panel”. Do not change the other three cascaders. The task will finish automatically when done.
  setup_description: 'Layout is settings_panel with high_contrast theme, compact spacing, small scale, and high clutter. Four Ant Design Cascaders are stacked in one routing panel: “Primary route”, “Secondary route”, “Backup route”, and “Archive route”. All use the same compact three-column popup. Only Backup route starts empty; the other three have committed values and must remain unchanged. Above them are toggles, chips, and segmented controls. A single “Save panel” button commits all four routes.'
  scene_context:
    theme: high_contrast
    spacing: compact
    layout: settings_panel
    placement: off_center
    scale: small
    instances: 4_plus
    guidance: text
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - instances
    - theme
    - clutter
    factor_rationale: This intentionally applies the strongest macro levers—four same-type instances, compact controls, and high clutter—while keeping the actual hierarchy ordinary so the task remains solvable and diagnostic.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 5
    justification: The hierarchy is simple, but the shared save and four-instance high-pressure scene create a strong wrong-instance and wrong-save benchmark signal.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['North America', 'Canada', 'Vancouver'].
    - The non-target cascader "Primary route" remains at its initial committed value.
    - The non-target cascader "Secondary route" remains at its initial committed value.
    - The non-target cascader "Archive route" remains at its initial committed value.
    - The local "Save panel" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - North America
        - Canada
        - Vancouver
        path_values:
        - north-america
        - canada
        - vancouver
        target_instance: Backup route
        non_target_instances_must_remain:
          Primary route: North America / USA / Seattle
          Secondary route: Europe / Germany / Berlin
          Archive route: Asia / Japan / Tokyo
      tolerance: null
      require_confirm: true
      confirm_control: Save panel
      require_correct_instance: true
      target_instance_label_or_id: Backup route
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Modifying the wrong cascader instance.
  - Selecting the correct path but not clicking "Save panel".
  - Changing any non-target cascader instance.
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save panel" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T20
  name: Nested-scroll deep leaf near bottom of scrollable third column
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: popup_scroll
  implementation_component: 'AntD: Cascader'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the cascader labeled “Access scope”, scroll within the cascader popup as needed and select “Organization / Europe / Dublin / Zone 2”, then click “Apply scope”. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Access scope”, scroll within the cascader popup as needed and select “Organization / Europe / Dublin / Zone 2”, then click “Apply scope”. The task will finish automatically when done.
  setup_description: Layout is nested_scroll with compact spacing, center placement, and medium clutter. The outer page scrolls, and the target card contains a compact Ant Design Cascader with a 4-level hierarchy. Under `Organization > Europe > Dublin`, the final `Zone` options extend beyond the initial third-column viewport, so the cascader menu itself must be scrolled to reach `Zone 2`. A small “Apply scope” button below the card commits the value.
  scene_context:
    theme: light
    spacing: compact
    layout: nested_scroll
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: true
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - internal_scroll_region
    - scale
    - layout
    factor_rationale: 'This isolates a hard cascader pattern that v1 only touched lightly: the page and the popup both scroll, and the final leaf sits below the initial column viewport, so the agent must control the menu itself instead of only the page.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 2
    justification: The task is hard because the relevant popup column, not just the page, has to be scrolled before the final leaf can even be clicked and committed.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Organization', 'Europe', 'Dublin', 'Zone 2'].
    - The local "Apply scope" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Organization
        - Europe
        - Dublin
        - Zone 2
        path_values:
        - organization
        - europe
        - dublin
        - zone-2
      tolerance: null
      require_confirm: true
      confirm_control: Apply scope
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply scope".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply scope" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T21
  name: Search exact repeated-name branch inside modal selector
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: show_search
  implementation_component: 'AntD: Cascader'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Open “Choose office city”. In the cascader labeled “Office city”, use search to choose “Brazil / São Paulo / Santo André”, then click “Save city”. The task will finish automatically when done.
  ui_copy: Open “Choose office city”. In the cascader labeled “Office city”, use search to choose “Brazil / São Paulo / Santo André”, then click “Save city”. The task will finish automatically when done.
  setup_description: Layout is modal_flow with compact spacing and medium clutter. The modal contains one Ant Design Cascader with `showSearch` enabled. Typing `Santo` returns several matched paths including `Brazil / São Paulo / Santo André`, `Brazil / São Paulo / Santo Amaro`, and `Dominican Republic / Santo Domingo / Zona Colonial`. Direct hierarchical navigation is possible but much slower because the geography tree is large. The modal footer contains “Save city”.
  scene_context:
    theme: dark
    spacing: compact
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: dialog
  design_intent:
    active_factors:
    - guidance
    - overlay_model
    - confirmation_model
    factor_rationale: 'Search is the intended access path here, but it does not collapse the task to a single obvious match: several repeated Santo branches remain, so the agent must still verify the full path before modal save.'
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: This is a search-based exact-branch task built around repeated leaf and city-prefix names rather than around a trivial two-result filter.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Brazil', 'São Paulo', 'Santo André'].
    - The local "Save city" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Brazil
        - São Paulo
        - Santo André
        path_values:
        - brazil
        - sao-paulo
        - santo-andre
      tolerance: null
      require_confirm: true
      confirm_control: Save city
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Save city".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Save city" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.
- id: cascader-antd-v2-T22
  name: Table-row exact two-path set with row-local save
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple_table_row
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the “Teams included” cascader for the “Enterprise onboarding” row, select exactly these two paths: “Support / Tier 2 / Identity” and “Customer Success / Enterprise / Onboarding”. Then click “Save row”. Do not change the “Trial conversion” row. The task will finish automatically when done.'
  ui_copy: 'In the “Teams included” cascader for the “Enterprise onboarding” row, select exactly these two paths: “Support / Tier 2 / Identity” and “Customer Success / Enterprise / Onboarding”. Then click “Save row”. Do not change the “Trial conversion” row. The task will finish automatically when done.'
  setup_description: Layout is table_cell with compact spacing, off-center placement, small scale, and high clutter. The “Enterprise onboarding” and “Trial conversion” rows each contain a multiple Ant Design Cascader labeled “Teams included” and a row-local “Save row” button. After each correct path is chosen, chips are inserted into the compact cell input, which slightly changes the visible geometry before the next path is selected. Only the Enterprise onboarding row should change.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: off_center
    scale: small
    instances: 2
    guidance: text
    clutter: high
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: table
  design_intent:
    active_factors:
    - layout
    - instances
    - clutter
    factor_rationale: This merges two of the strongest cascader levers—row-local activation and multi-select re-grounding—without introducing extra workflow components beyond the row save.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 5
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 5
    justification: The exact set is modest, but compact row geometry, tag shifts after the first selection, and row-local save semantics make it a strong mixed cascader task.
  success_trigger:
    human_readable:
    - The committed selected path set equals exactly [['Support', 'Tier 2', 'Identity'], ['Customer Success', 'Enterprise', 'Onboarding']].
    - The non-target cascader "Trial conversion" remains unchanged.
    - The local "Save row" control has been clicked.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
        paths_labels:
        - - Support
          - Tier 2
          - Identity
        - - Customer Success
          - Enterprise
          - Onboarding
        paths_values:
        - - support
          - tier-2
          - identity
        - - customer-success
          - enterprise
          - onboarding
        order_invariant: true
        target_instance: Enterprise onboarding
        non_target_instances_must_remain:
          Trial conversion: Support / Tier 1 / Billing
      tolerance: null
      require_confirm: true
      confirm_control: Save row
      require_correct_instance: true
      target_instance_label_or_id: Enterprise onboarding
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Applying the exact set to the wrong cascader instance.
  - Reaching the correct set but not clicking "Save row".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Save row" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T23
  name: Drawer visual chip match after popup shifts and wraps
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: multiple_visual
  implementation_component: 'AntD: Cascader'
  task_template: select_many
  secondary_template: null
  browsergym_goal: Open the “Assignment rules” drawer. In the cascader labeled “Assignee groups”, select the same two paths shown in the target chips card, then click “Save groups”. The task will finish automatically when done.
  ui_copy: Open the “Assignment rules” drawer. In the cascader labeled “Assignee groups”, select the same two paths shown in the target chips card, then click “Save groups”. The task will finish automatically when done.
  setup_description: 'Layout is drawer_flow with compact spacing, off-center placement, and high clutter. The drawer contains one multiple Ant Design Cascader labeled “Assignee groups” and a visual target card showing exactly two chips: `Support / Tier 2 / Identity` and `Platform / Database / Primary`. The input width is narrow enough that chips reflow after the first selection. The popup remains open while multiple values are chosen. The drawer footer contains “Save groups”.'
  scene_context:
    theme: light
    spacing: compact
    layout: drawer_flow
    placement: off_center
    scale: small
    instances: 1
    guidance: visual
    clutter: high
  component_context:
    overlay_model: nested_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: drawer
  design_intent:
    active_factors:
    - guidance
    - overlay_model
    - clutter
    factor_rationale: The target is visually specified, but the difficulty comes from tracking popup and chip state while the narrow drawer input wraps and reflows after each added path, then committing the exact set.
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: 'This is the strong visual multi-select variant from the cascader report: the agent must match a reference set while coping with dynamic popup and chip layout changes, not just read a text instruction.'
  success_trigger:
    human_readable:
    - The committed selected path set matches the reference target ref-assignee-group-chips and equals [['Support', 'Tier 2', 'Identity'], ['Platform', 'Database', 'Primary']].
    - The local "Save groups" control has been clicked.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        paths_labels:
        - - Support
          - Tier 2
          - Identity
        - - Platform
          - Database
          - Primary
        paths_values:
        - - support
          - tier-2
          - identity
        - - platform
          - database
          - primary
        order_invariant: true
        reference_id: ref-assignee-group-chips
      tolerance: null
      require_confirm: true
      confirm_control: Save groups
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting only part of the requested set.
  - Selecting any extra path outside the requested exact set.
  - Reaching the correct set but not clicking "Save groups".
  expected_interaction_path:
  - Open the target cascader.
  - Select each requested path while verifying the updated popup and tag state after every addition or removal.
  - Click "Save groups" to commit the change.
  notes: Compare committed selected cascader paths as an order-invariant exact set.
- id: cascader-antd-v2-T24
  name: ChangeOnSelect plus lazy-loaded final subtree in compact form
  canonical_type: cascader
  implementation_source: antd
  implementation_variant: lazy_load_change_on_select
  implementation_component: 'AntD: Cascader'
  task_template: hierarchical_path_select
  secondary_template: null
  browsergym_goal: In the cascader labeled “Support area”, select the intermediate path “Hardware / Printers” after the lazy-loaded branch appears, then click “Apply area”. Do not choose a final leaf. The task will finish automatically when done.
  ui_copy: In the cascader labeled “Support area”, select the intermediate path “Hardware / Printers” after the lazy-loaded branch appears, then click “Apply area”. Do not choose a final leaf. The task will finish automatically when done.
  setup_description: Layout is inline_surface with compact spacing, top_right placement, and medium clutter. The Ant Design Cascader uses both lazy-loaded children and `changeOnSelect`. The first time `Hardware` is expanded, its `Printers` and `Networking` children are loaded asynchronously. Once `Printers` appears, the task is complete at that intermediate path; a third column with leaves such as `Install`, `Setup`, and `Troubleshooting` may also appear but should not be selected. A local “Apply area” button commits the chosen path.
  scene_context:
    theme: light
    spacing: compact
    layout: inline_surface
    placement: top_right
    scale: default
    instances: 1
    guidance: mixed
    clutter: medium
  component_context:
    overlay_model: single_overlay
    internal_scroll_region: false
    confirmation_model: explicit_apply
    precision_surface: discrete
    secondary_supporting_primitive: popover
  design_intent:
    active_factors:
    - guidance
    - confirmation_model
    - overlay_model
    factor_rationale: 'This is a true mixed cascader task: the agent must handle lazy loading, recognize that a non-leaf path is the requested terminal state because of changeOnSelect, resist the visible final-leaf temptation, and then apply the result.'
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 5
      semantic_observability: 4
      disambiguation_load: 1
    justification: By combining lazy loading with intermediate-path commitment, the task stresses exactly the layered-state verification and over-selection errors that plain leaf-only cascader tasks do not reveal.
  success_trigger:
    human_readable:
    - The committed cascader path equals ['Hardware', 'Printers'].
    - The local "Apply area" control has been clicked.
    canonical_predicate:
      predicate_type: path_equals
      target_state:
        path_labels:
        - Hardware
        - Printers
        path_values:
        - hardware
        - printers
      tolerance: null
      require_confirm: true
      confirm_control: Apply area
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Stopping on an ancestor or choosing a sibling path instead of the requested target.
  - Selecting the correct path but not clicking "Apply area".
  expected_interaction_path:
  - Open the target cascader and traverse the hierarchy to the requested path.
  - Click "Apply area" to commit the change.
  notes: Read the committed cascader value path from the wrapper rather than relying only on rendered text.