tasks/v1/combobox_editable_multi.yaml

- id: combobox_editable_multi-antd-T01
  name: Project tech tags (3 items)
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Select React, Node.js, and Svelte in the “Project tech tags” field. The task will finish automatically when done.
  ui_copy: Select React, Node.js, and Svelte in the “Project tech tags” field. The task will finish automatically when done.
  setup_description: |-
    You are on a single centered card titled “Tagging”. The card contains one Ant Design Select component configured in tags mode (multi-value, editable).
    - Label above the field: “Project tech tags”
    - Placeholder: “Add tech tags”
    - The dropdown contains a short suggestion list (e.g., React, Vue, Svelte, Angular, Node.js, Django, Flask, Rails).
    - The field starts empty (no selected tags).
    Interaction notes:
    - Clicking the field opens a popover dropdown under the input.
    - Selecting an option adds it as a removable tag (“pill”) inside the input.
    There are no other required controls or distractors on the card.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Small option list with clear tag chips; single dropdown layer and immediate feedback.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - React
      - Node.js
      - Svelte
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Any missing tag (e.g., only React and Node.js selected).
  - Any extra tag selected beyond the three targets.
  - A typed value still sitting in the input but not committed as a tag.
  expected_interaction_path:
  - Click the Select input to open the dropdown.
  - Click React, Node.js, and Svelte to add them as tags.
  - Verify exactly those three tags are present.
  notes: |-
    Instrumentation: add data-testid="project-tech-tags" on the Select trigger; expose selected values as an array of strings from the Select value.
    Checker: treat selected tags as an order-insensitive set of strings (trim whitespace).
- id: combobox_editable_multi-antd-T02
  name: Add a custom internal label
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'')'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: In the “Internal labels” field, add the tag internal-only. The task will finish automatically when done.
  ui_copy: In the “Internal labels” field, add the tag internal-only. The task will finish automatically when done.
  setup_description: |-
    Centered card titled “Labels”. It contains a single Ant Design Select in tags mode.
    - Label: “Internal labels”
    - Placeholder: “Type a label and press Enter”
    - Suggestion dropdown includes a few common labels (e.g., beta, customer-facing, urgent) but NOT “internal-only”.
    - Initial state: empty (no tags selected).
    Behavior:
    - You can type arbitrary text; pressing Enter commits it as a new tag.
    - Selected tags appear as removable pills inside the input.
    No other components affect success.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single tag creation via typing and Enter; minimal choice complexity and clear visible result.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - internal-only
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Tag is misspelled or has different punctuation/casing (e.g., internal only).
  - The value is typed but not committed as a tag (no pill appears).
  - Extra tags are present in addition to internal-only.
  expected_interaction_path:
  - Click the input.
  - Type internal-only.
  - Press Enter to create the tag.
  notes: |-
    AntD tags-mode typically supports tokenization/Enter commit; ensure Enter creates a tag for free input.
    Instrumentation: data-testid="internal-labels" on the Select trigger.
- id: combobox_editable_multi-antd-T03
  name: Clear alert labels
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'', allowClear)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear all selected tags in the “Alert labels” field so it is empty. The task will finish automatically when done.
  ui_copy: Clear all selected tags in the “Alert labels” field so it is empty. The task will finish automatically when done.
  setup_description: |-
    Centered card titled “Alerts”. It contains one Ant Design Select in tags mode with a visible clear (×) control.
    - Label: “Alert labels”
    - Initial selected tags: “Urgent”, “Pager”, “Customer”
    - allowClear is enabled, so a small clear icon appears on the right side of the input when there is at least one tag.
    Behavior:
    - Clicking the clear icon removes all selected tags at once.
    - Individual tags are also removable via small close icons on each pill.
    No additional steps (no Save button) are required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Goal is an empty state; the component exposes a dedicated clear control and immediate visible feedback.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - At least one tag remains selected.
  - A partially cleared state (e.g., removed some but not all).
  - Typed text remains in the input as an uncommitted value.
  expected_interaction_path:
  - Click the clear (×) icon in the input to remove all tags.
  - Confirm no tags remain.
  notes: |-
    Checker: selected values must be an empty array.
    Instrumentation: data-testid="alert-labels" plus data-testid for clear icon if needed.
- id: combobox_editable_multi-antd-T04
  name: Search and pick two research topics
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'', showSearch)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the “Team topics” field, select the tags “Design Systems” and “UX Research”. The task will finish automatically when done.
  ui_copy: In the “Team topics” field, select the tags “Design Systems” and “UX Research”. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Team settings” with one Ant Design Select in tags mode.
    - Label: “Team topics”
    - Placeholder: “Search topics”
    - showSearch is enabled: typing filters the dropdown options.
    - Options list contains ~25 topics with similar wording (e.g., Design Systems, Design Ops, UX Research, User Research, Quant Research, Accessibility, Typography, Prototyping, etc.).
    - Initial state: empty selection.
    This task is intended to be completed by typing to narrow the list, then selecting the two target options.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Requires light search disambiguation among similar options, but only two selections and immediate chip feedback.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Design Systems
      - UX Research
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a near-miss option (e.g., User Research instead of UX Research).
  - Only one of the two tags selected.
  - Extra topics selected beyond the two targets.
  expected_interaction_path:
  - Click the field to open the dropdown.
  - Type 'Design' and select “Design Systems”.
  - Type 'Research' and select “UX Research”.
  notes: |-
    Checker: treat labels as exact strings.
    Instrumentation: provide stable option text content (innerText) for dropdown items.
- id: combobox_editable_multi-antd-T05
  name: Choose primary interests (two fields)
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the “Primary interests” field, select Hiking, Photography, and Cooking. The task will finish automatically when done.
  ui_copy: In the “Primary interests” field, select Hiking, Photography, and Cooking. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Profile”. The card contains TWO Ant Design Select components in tags mode stacked vertically.
    - Field 1 label: “Primary interests” (target)
      - Starts empty
    - Field 2 label: “Secondary interests” (distractor)
      - Starts with one tag already selected: “Reading”
    Both fields look visually similar and have their own dropdowns with overlapping options (e.g., Hiking, Photography, Cooking, Travel, Reading, Music, Gaming).
    The task requires editing ONLY the “Primary interests” field and leaving the “Secondary interests” field unchanged.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 4
    justification: Two near-identical instances increase disambiguation load; otherwise the selection is straightforward.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - 'Changes applied to the correct labeled instance: Primary interests.'
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Hiking
      - Photography
      - Cooking
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Primary interests
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Tags are set on the wrong field (Secondary interests modified).
  - Primary interests is missing one of the required tags.
  - Extra tags added to Primary interests beyond the three targets.
  expected_interaction_path:
  - Click the “Primary interests” input (not Secondary).
  - Select Hiking, Photography, and Cooking from the dropdown (or type and press Enter).
  - Verify Secondary interests remains as “Reading”.
  notes: |-
    Instrumentation: wrap each instance with data-testid using its label, e.g., data-testid="primary-interests" and "secondary-interests".
    Checker must assert the target instance value equals the target set and that non-target instances are unchanged (optional negative-case audit).
- id: combobox_editable_multi-antd-T06
  name: Stakeholder departments in a form
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'', allowClear)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: Set “Stakeholder departments” to Design, Legal, and Security. The task will finish automatically when done.
  ui_copy: Set “Stakeholder departments” to Design, Legal, and Security. The task will finish automatically when done.
  setup_description: |-
    Layout is a “Project intake” form section (not a single isolated card). The target combobox appears mid-page in a typical form.
    - Target field label: “Stakeholder departments”
    - Ant Design Select in tags mode with showSearch enabled and allowClear enabled.
    - Initial selected tags: “Design” and “Product”
    - Options list includes ~12 departments with similar names (Design, Product, Data, Legal, Security, Sales, Support, Finance, HR, Marketing, Operations, IT).
    Clutter/distractors:
    - Above: Text input “Project name”, a DatePicker “Kickoff date”, and a Switch “Requires approval”.
    - Below: a textarea “Notes” and two buttons “Cancel” and “Submit” (buttons do nothing for success).
    To succeed, the field must end with exactly Design, Legal, and Security (Product must be removed).
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 3
    justification: Requires both removing an existing tag and adding two new ones within a cluttered form, but state remains clearly visible.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Design
      - Legal
      - Security
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving “Product” selected (final set not exact).
  - Selecting a wrong department (e.g., Data instead of Legal).
  - Only adding Legal/Security without removing Product.
  expected_interaction_path:
  - Focus the “Stakeholder departments” field.
  - Remove the “Product” tag using its close icon or backspace.
  - Add “Legal” and “Security” from the dropdown.
  - Confirm the selected tags are exactly Design, Legal, Security.
  notes: |-
    Checker: compare exact set; ignore order.
    Consider instrumenting each tag pill with data-value attribute for robust extraction.
- id: combobox_editable_multi-antd-T07
  name: Match release labels from preview
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'')'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Make the “Release labels” field match the chips shown in the “Target selection” preview. The task will finish automatically when done.
  ui_copy: Make the “Release labels” field match the chips shown in the “Target selection” preview. The task will finish automatically when done.
  setup_description: |-
    Dark theme isolated card titled “Release manager”. The card is split into two columns:
    Left column (interactive):
    - Ant Design Select in tags mode labeled “Release labels”
    - Placeholder: “Add release labels”
    - Initial selected tags: “canary”
    Right column (reference, non-interactive):
    - A read-only row labeled “Target selection” showing the desired labels as colored chips.
    - The preview shows exactly three chips: “staging”, “prod-hotfix”, and “canary”.
    The dropdown suggestion list contains many environment-related options (canary, staging, production, prod-hotfix, hotfix, rollback, etc.).
    To succeed, the selected tags in “Release labels” must exactly match the reference chips (order does not matter).
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Target is specified visually, requiring the agent to read and match reference chips; dark theme slightly reduces contrast and observability.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - staging
      - prod-hotfix
      - canary
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selected tags do not exactly match the preview chips (missing or extra).
  - Near-miss option chosen (e.g., production instead of prod-hotfix).
  - Leaving the initial canary tag but failing to add the other required tags.
  expected_interaction_path:
  - Inspect the “Target selection” preview chips.
  - In “Release labels”, remove/add tags until it matches the preview.
  notes: |-
    Guidance is visual; the page must render a deterministic reference chip list for the checker.
    Instrumentation: data-testid="release-labels" and data-testid="target-selection-preview" exposing the reference list.
- id: combobox_editable_multi-antd-T08
  name: Pick four countries from a long dropdown
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'')'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In “Allowed countries”, select Uruguay, Uzbekistan, Vietnam, and Zimbabwe. The task will finish automatically when done.
  ui_copy: In “Allowed countries”, select Uruguay, Uzbekistan, Vietnam, and Zimbabwe. The task will finish automatically when done.
  setup_description: |-
    The Select is rendered in the bottom-right corner of the viewport inside a small compact card titled “Geo rules”.
    - Theme: light
    - Spacing: compact (tight padding and smaller text)
    - Component scale: small (Select size=small)
    - Label: “Allowed countries”
    - Initial state: empty
    - The dropdown contains a long alphabetized list of ~80 country options and uses a scrollable menu; the target countries are not visible when the dropdown first opens.
    Clutter is minimal: only a short description text above the field.
    To succeed, you must add exactly the four specified countries as tags.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: bottom_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Small/compact rendering increases click precision; long scrollable option list raises search and selection interference.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Uruguay
      - Uzbekistan
      - Vietnam
      - Zimbabwe
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a wrong country with similar prefix (e.g., Venezuela instead of Vietnam).
  - Only selecting some of the four countries.
  - Selecting any extra country beyond the four targets.
  expected_interaction_path:
  - Click the small Select input to open the dropdown.
  - Scroll the dropdown list until each target country is visible, clicking each to add as a tag.
  - Verify exactly four tags are present.
  notes: |-
    To support scroll_find evaluation, ensure the dropdown list is scrollable and the targets are initially off-screen.
    Instrumentation: expose dropdown list container for scroll events; data-testid="allowed-countries".
- id: combobox_editable_multi-antd-T09
  name: Edit notification tags in a modal and save
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Modal + Select (mode=''tags'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Edit notification tags”, set “Notification tags” to Email and SMS, then click “Save changes”. The task will finish automatically when done.
  ui_copy: Open “Edit notification tags”, set “Notification tags” to Email and SMS, then click “Save changes”. The task will finish automatically when done.
  setup_description: |-
    Layout is a modal flow:
    - On the base page (centered card “Notifications”), there is a button labeled “Edit notification tags”.
    - Clicking it opens an Ant Design Modal dialog.
    Inside the modal:
    - One Ant Design Select in tags mode labeled “Notification tags” (target).
    - Initial selected tag: “Push”
    - Options include: Email, SMS, Push, Slack.
    - Modal footer has two buttons: “Cancel” and primary “Save changes”.
    Feedback:
    - After clicking “Save changes”, the modal closes and a small toast “Saved” appears (toast is not required for success, only helpful feedback).
    Success requires both the correct tag set and that “Save changes” has been clicked.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a modal layer, editing the tags, and committing via an explicit Save button.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - 'Confirmation control clicked: Save changes.'
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Email
      - SMS
      tolerance: null
      require_confirm: true
      confirm_control: Save changes
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Correct tags selected but “Save changes” not clicked.
  - Modal closed via “Cancel” or outside click (if enabled).
  - Leaving the initial “Push” tag selected along with Email/SMS (extra tag).
  expected_interaction_path:
  - Click “Edit notification tags” to open the modal.
  - In “Notification tags”, remove “Push” and add “Email” and “SMS”.
  - Click “Save changes”.
  notes: |-
    Checker should record a commit flag when the Save button is clicked, in addition to verifying the selected set at commit time.
    Instrumentation: data-testid on open-modal button, modal container, target Select, and Save button.
- id: combobox_editable_multi-antd-T10
  name: Replace tags under a max limit
  canonical_type: combobox_editable_multi
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Select (mode=''tags'', maxCount=4)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In “Assigned labels”, end up with exactly alpha, gamma, omega, and theta selected. The task will finish automatically when done.
  ui_copy: In “Assigned labels”, end up with exactly alpha, gamma, omega, and theta selected. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Label assignment”.
    - Target component: Ant Design Select in tags mode with a helper text “Max 4 labels”.
    - maxCount is set to 4 (the component blocks adding a 5th label).
    - Initial selected tags (4): alpha, beta, gamma, delta
    - Options dropdown includes: alpha, beta, gamma, delta, omega, theta, kappa, lambda.
    The task requires replacing some tags while respecting the max selection limit, ending with exactly alpha, gamma, omega, theta.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: Max-count constraint forces correct removal before additions; mistakes can temporarily block further input and require recovery.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - alpha
      - gamma
      - omega
      - theta
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Trying to add omega/theta without freeing a slot (max reached) and leaving the final set incorrect.
  - Ending with any extra tag (e.g., beta still selected).
  - Ending with fewer than 4 tags selected.
  expected_interaction_path:
  - Remove beta and delta tags using the close icons/backspace.
  - Add omega and theta from the dropdown (or by typing + Enter).
  - Verify the final four tags are alpha, gamma, omega, theta.
  notes: |-
    Checker: exact set match; also ensure the component did not accept a 5th value (should be impossible).
    Instrumentation: expose current selected array and maxCount setting for debugging.
- id: combobox_editable_multi-mui-T01
  name: Pick two fruits
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the “Favorite fruits” field, select Apple and Banana. The task will finish automatically when done.
  ui_copy: In the “Favorite fruits” field, select Apple and Banana. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Preferences”. The card contains one Material UI Autocomplete configured for multiple selection.
    - Label: “Favorite fruits”
    - Placeholder: “Choose fruits”
    - Options list contains ~10 fruits (Apple, Banana, Orange, Grape, Mango, etc.).
    - Initial state: empty (no chips selected).
    Interaction:
    - Clicking into the input opens a dropdown list (popper) of options.
    - Clicking an option adds it as a chip inside the input.
    No other fields on the card.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Simple multi-select with a short list; state is clearly visible as chips.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Apple
      - Banana
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Only one of the two fruits selected.
  - Any extra fruit chip selected.
  - Typed text not committed as a chip (should not count).
  expected_interaction_path:
  - Click the Autocomplete input to open options.
  - Click Apple and Banana to add chips.
  - Verify only Apple and Banana chips are present.
  notes: 'Instrumentation: data-testid="favorite-fruits"; ensure each option has stable text for extraction.'
- id: combobox_editable_multi-mui-T02
  name: Add two custom issue labels
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple, freeSolo)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Add the labels blocked and needs-review in the “Issue labels” field. The task will finish automatically when done.
  ui_copy: Add the labels blocked and needs-review in the “Issue labels” field. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Issue triage”.
    - Component: Material UI Autocomplete configured with multiple=true and freeSolo=true so it accepts arbitrary values as chips.
    - Label: “Issue labels”
    - Placeholder: “Type a label and press Enter”
    - Suggestions include common labels (bug, feature, urgent), but the target labels “blocked” and “needs-review” are not present as predefined options.
    - Initial state: empty selection.
    Behavior:
    - Typing a value and pressing Enter creates a chip.
    - Chips can be removed with their small close icon.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Requires committing two free-text values as chips (Enter twice), but no complex navigation or option ambiguity.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - blocked
      - needs-review
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Misspelling or wrong punctuation (e.g., needs review without hyphen).
  - Only one of the two labels is present.
  - Extra labels present in addition to the two targets.
  expected_interaction_path:
  - Click the input.
  - Type blocked and press Enter to create a chip.
  - Type needs-review and press Enter to create a chip.
  notes: |-
    Checker: exact string match, case-sensitive as displayed.
    Instrumentation: expose chips list via aria-label or data-testid on each Chip.
- id: combobox_editable_multi-mui-T03
  name: Clear selected colors
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple, clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Selected colors” field so no chips remain. The task will finish automatically when done.
  ui_copy: Clear the “Selected colors” field so no chips remain. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Palette”.
    - Component: Material UI Autocomplete with multiple selection enabled.
    - Label: “Selected colors”
    - Initial selected chips: Red, Green, Blue
    - A clear indicator (×) button appears inside the input on the right when the field has a value (default behavior when disableClearable is false).
    Behavior:
    - Clicking the clear indicator removes all selected chips at once.
    - Alternatively, chips can be removed individually.
    No other controls are required for completion.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Clearing to empty is simple and feedback is immediate; dedicated clear control reduces steps.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Any chip remains after the action.
  - Only some chips removed (partial clear).
  expected_interaction_path:
  - Click the clear (×) icon in the input.
  - Verify the input shows no chips.
  notes: 'Instrumentation: data-testid="selected-colors"; provide data-testid for clear-indicator if necessary.'
- id: combobox_editable_multi-mui-T04
  name: Search-select four 'In-*' movies
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In “Movie picks”, select Inception, Interstellar, Inside Out, and Iron Man. The task will finish automatically when done.
  ui_copy: In “Movie picks”, select Inception, Interstellar, Inside Out, and Iron Man. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Movie night”.
    - Material UI Autocomplete configured for multiple selection from a predefined options list (no freeSolo).
    - Label: “Movie picks”
    - Options list contains ~50 movies. Several share similar prefixes and short names, including:
      - Inception
      - Interstellar
      - Inside Out
      - Iron Man
      - (and other distractors like Inferno, Insomnia, It, etc.)
    - Initial state: empty selection.
    The intended interaction is to type partial titles to filter the list and select the four target movies as chips.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Moderate option count with similar distractors increases interference; requires repeated search-select actions for four items.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Inception
      - Interstellar
      - Inside Out
      - Iron Man
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a distractor with a similar name (e.g., Inferno instead of Inception).
  - Missing one of the four movies.
  - Selecting any extra movie beyond the four targets.
  expected_interaction_path:
  - Click the input to open suggestions.
  - Type and select each target movie, one by one, creating four chips total.
  notes: |-
    Checker: exact set match.
    Instrumentation: include aria-labels for options so screen-reader trees are informative.
- id: combobox_editable_multi-mui-T05
  name: Add CC recipients (two fields)
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the “CC” field, add Alice Johnson and Bob Smith. The task will finish automatically when done.
  ui_copy: In the “CC” field, add Alice Johnson and Bob Smith. The task will finish automatically when done.
  setup_description: |-
    Layout is an email-compose form section with multiple inputs (cluttered but realistic).
    There are TWO Material UI Autocomplete fields stacked near the top:
    - “To” (distractor): already contains one chip “Primary Team”
    - “CC” (target): starts empty
    Both are multiple-selection Autocomplete components backed by the same contacts list (~20 names).
    Other clutter:
    - Subject text field, message textarea, and a small “Send” button (not required).
    You must add exactly two chips to the CC field: Alice Johnson and Bob Smith, without changing the To field.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 4
    justification: Two similar Autocomplete instances in a busy form require careful targeting and disambiguation.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - 'Changes applied to the correct labeled instance: CC.'
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Alice Johnson
      - Bob Smith
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: CC
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Adding the recipients to the To field instead of CC.
  - Only one of the two required CC recipients selected.
  - Extra CC recipients selected beyond the two targets.
  expected_interaction_path:
  - Click into the “CC” Autocomplete (not “To”).
  - Select Alice Johnson and Bob Smith from the suggestions (typing may help).
  notes: 'Instrumentation: data-testid="to-recipients" and "cc-recipients". Checker should verify target instance only.'
- id: combobox_editable_multi-mui-T06
  name: Match status labels from reference chips
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple, freeSolo)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Make the “Status labels” selection match the chips shown under “Target labels”. The task will finish automatically when done.
  ui_copy: Make the “Status labels” selection match the chips shown under “Target labels”. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Workflow labels”.
    Left side (interactive):
    - Material UI Autocomplete with multiple=true and freeSolo=true labeled “Status labels”.
    - Initial chips: none.
    Right side (reference, non-interactive):
    - A row labeled “Target labels” displays the desired chips.
    - The target chips shown are: “P1”, “Customer”, “UI”.
    The suggestions list includes P0, P1, P2, Customer, Internal, UI, Backend, Docs, etc.
    To succeed, the selected chips in “Status labels” must exactly match the reference chips (order-insensitive).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Goal is specified visually, requiring correct reading and matching of reference chips; otherwise interaction is standard.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - P1
      - Customer
      - UI
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selected chips do not match the reference (missing or extra).
  - Confusing similar labels (e.g., P0 vs P1).
  - Typed but uncommitted input value without chip creation.
  expected_interaction_path:
  - Inspect the reference chips under “Target labels”.
  - Add/remove chips in “Status labels” until it matches exactly.
  notes: 'Instrumentation: data-testid on the reference chip container so the oracle can expose target_state for the checker.'
- id: combobox_editable_multi-mui-T07
  name: Set regions inside an advanced-filters drawer
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Drawer + Autocomplete (multiple)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Advanced filters” and set “Regions” to North America, Europe, and Asia. The task will finish automatically when done.
  ui_copy: Open “Advanced filters” and set “Regions” to North America, Europe, and Asia. The task will finish automatically when done.
  setup_description: |-
    This page uses a drawer flow:
    - The main page is a dashboard header with a button “Advanced filters” (top-right).
    - Clicking it opens a right-side Drawer containing filter controls.

    Inside the drawer there are TWO similar multi-select Autocomplete fields:
    - “Regions” (target): Material UI Autocomplete (multiple) with options North America, South America, Europe, Asia, Africa, Oceania. Initial selection: empty.
    - “Countries” (distractor): another Material UI Autocomplete (multiple) listing a handful of countries. Initial selection: “Canada”.

    Other drawer clutter:
    - A date range input and two checkboxes (not required).

    No Apply/Save click is required for success; the task ends when the Regions chips equal the target set. You must avoid changing the Countries field.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_right
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Opening a drawer and choosing the correct one of two similar Autocomplete instances increases disambiguation demands in a dense filter panel.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - 'Changes applied to the correct labeled instance: Regions.'
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - North America
      - Europe
      - Asia
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Regions
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Drawer opened but Regions not set correctly.
  - Selecting regions in the wrong field (Countries changed instead of Regions).
  - Missing one of the three required regions.
  - Selecting any extra region beyond the three targets.
  expected_interaction_path:
  - Click “Advanced filters” to open the drawer.
  - Interact with the “Regions” Autocomplete (not “Countries”).
  - Select North America, Europe, and Asia.
  notes: |-
    Instrumentation: data-testid="open-advanced-filters", drawer container id, data-testid="regions-autocomplete", and data-testid="countries-autocomplete".
    Checker should verify the target instance labeled “Regions”.
- id: combobox_editable_multi-mui-T08
  name: Scroll to pick two elements (no filtering)
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple, custom filterOptions=identity)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In “Allowed elements”, select Zinc and Zirconium. The task will finish automatically when done.
  ui_copy: In “Allowed elements”, select Zinc and Zirconium. The task will finish automatically when done.
  setup_description: |-
    The Autocomplete is rendered in the top-right corner in a small compact card titled “Materials”.
    - Theme: light
    - Spacing: compact
    - Component scale: small
    - Target field: Material UI Autocomplete with multiple selection, label “Allowed elements”.
    - Options list contains ~60 chemical elements in alphabetical order.
    Important behavior for this task:
    - The dropdown list is NOT filtered by typing (custom filterOptions returns the full list), so you must scroll the list to reach items near the end.
    - The list is scrollable; Zinc and Zirconium are off-screen when first opened.
    Initial state: empty.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Small compact target plus long unfiltered list forces manual scrolling and careful clicking among dense options.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Zinc
      - Zirconium
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a near-by element by mistake (e.g., Zinc selected but Zirconium missed).
  - Any extra element selected beyond Zinc and Zirconium.
  - Typing text without selecting (no chips created).
  expected_interaction_path:
  - Click the input to open the dropdown.
  - Scroll the list near the end and click Zinc and Zirconium.
  - Verify exactly two chips are present.
  notes: |-
    To make scroll_find meaningful, implement filterOptions so typing does not reduce the option list.
    Instrumentation: provide a stable role=listbox for the options container to support scroll detection.
- id: combobox_editable_multi-mui-T09
  name: Edit allowed domains in a dialog and save
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Dialog + Autocomplete (multiple, freeSolo)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Edit allowed domains”, set “Allowed domains” to example.com and research.org, then click “Save”. The task will finish automatically when done.
  ui_copy: Open “Edit allowed domains”, set “Allowed domains” to example.com and research.org, then click “Save”. The task will finish automatically when done.
  setup_description: |-
    Modal flow with a Material UI Dialog:
    - Main page shows a settings card “Email security” with a button “Edit allowed domains”.
    - Clicking it opens a Dialog.
    Inside the Dialog:
    - Target field: Autocomplete with multiple=true and freeSolo=true labeled “Allowed domains”.
    - Initial chips: “example.net”
    - There is helper text under the field: “Press Enter to add a domain”.
    - Dialog actions: “Cancel” and primary “Save”.
    Success requires the selected chips to be exactly example.com and research.org AND the Save button to be clicked.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires replacing an existing chip with two exact free-text values and committing via a dialog Save action.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - 'Confirmation control clicked: Save.'
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - example.com
      - research.org
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Correct domains entered but Save not clicked.
  - Leaving the original example.net chip selected (extra).
  - Entering malformed or misspelled domains (e.g., example,com).
  expected_interaction_path:
  - Click “Edit allowed domains” to open the dialog.
  - Remove the existing chip example.net.
  - Type example.com and press Enter; type research.org and press Enter.
  - Click “Save”.
  notes: |-
    Checker should evaluate the value at the time Save is clicked; also track a commit flag.
    Instrumentation: data-testid for open button, dialog root, input, and Save action.
- id: combobox_editable_multi-mui-T10
  name: Match 6 categories with collapsed chips (dark)
  canonical_type: combobox_editable_multi
  implementation_source: mui
  implementation_variant: null
  implementation_component: 'MUI: Autocomplete (multiple, limitTags=2)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Make the “Categories” field match the chips shown in “Target categories”. The task will finish automatically when done.
  ui_copy: Make the “Categories” field match the chips shown in “Target categories”. The task will finish automatically when done.
  setup_description: |-
    Dark theme isolated card titled “Content routing”.
    Interactive area:
    - Material UI Autocomplete with multiple selection labeled “Categories”.
    - It is configured with limitTags=2 so when the field is not focused, only two chips are shown and the rest collapse into a “+N” indicator.
    - Initial chips: none.
    Reference area (non-interactive):
    - A row labeled “Target categories” shows the required chips: News, Sports, Finance, Travel, Tech, Health (6 total).
    Options list includes those categories plus a few distractors (Entertainment, Weather, Science).
    This task is difficult because the selected state may be partially collapsed; the agent may need to focus the input to reveal all chips for verification.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 2
    justification: Matching six items is exacting, and chip-collapsing plus dark theme reduces easy verification of the full selected set.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - News
      - Sports
      - Finance
      - Travel
      - Tech
      - Health
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selected chips do not exactly match the reference set (missing or extra).
  - Picking a distractor category (e.g., Science) instead of a target.
  - Only some chips selected (partial match).
  expected_interaction_path:
  - Inspect the Target categories chip row.
  - Select the six required categories in the Categories Autocomplete.
  - Focus the field if needed to confirm all selected chips.
  notes: 'Instrumentation: ensure collapsed-chip state still exposes full value via aria or internal value array for the checker.'
- id: combobox_editable_multi-mantine-T01
  name: Select two framework tags from suggestions
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: MultiSelect
  implementation_component: 'Mantine: MultiSelect (searchable)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the “Framework tags” field, select React and Svelte. The task will finish automatically when done.
  ui_copy: In the “Framework tags” field, select React and Svelte. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Stack”. The card contains one Mantine MultiSelect component (multi-value combobox with search).
    - Label: “Framework tags”
    - Placeholder: “Pick value”
    - The MultiSelect is searchable (typing filters options).
    - Options data: React, Angular, Vue, Svelte, Solid, Ember.
    - Initial state: empty (no selected values).

    Interaction notes:
    - Clicking the input opens a dropdown list.
    - Clicking an option adds it as a pill/value inside the input.
    - This MultiSelect does NOT allow arbitrary custom values; you must pick from the provided options.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Short fixed option list with clear pill feedback; no free-text creation reduces ambiguity.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - React
      - Svelte
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Only one of the two tags selected.
  - Any extra tag selected.
  - Typed value not committed as a pill.
  expected_interaction_path:
  - Click the TagsInput to open suggestions.
  - Click React and Svelte to add them as pills.
  notes: 'Instrumentation: data-testid="framework-tags"; Mantine MultiSelect value is an array of strings (use that for checking).'
- id: combobox_editable_multi-mantine-T02
  name: Enter a custom tag (free input)
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Add the tag needs-review in the “Review tags” field. The task will finish automatically when done.
  ui_copy: Add the tag needs-review in the “Review tags” field. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Review settings”.
    - Component: Mantine TagsInput with no suggestions (data is empty).
    - Label: “Review tags”
    - Placeholder: “Press Enter to submit a tag”
    - Initial state: empty.
    Behavior:
    - Typing a value and pressing Enter creates a new pill/tag.
    - Duplicate values are not allowed (default behavior).
    No other controls.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single free-text tag creation with immediate visible pill feedback.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - needs-review
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Misspelling or wrong punctuation (e.g., needs review).
  - Value typed but not committed as a pill.
  - Any extra tag present.
  expected_interaction_path:
  - Click the input, type needs-review, press Enter.
  notes: Mantine TagsInput accepts free input; ensure Enter commits a tag for the checker to observe.
- id: combobox_editable_multi-mantine-T03
  name: Clear all priority tags
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput (clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Priority tags” field so it has no values. The task will finish automatically when done.
  ui_copy: Clear the “Priority tags” field so it has no values. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Priorities”.
    - Component: Mantine TagsInput with clearable=true.
    - Label: “Priority tags”
    - Initial pills: urgent, vip
    - A clear button appears in the right section when there are selected values.
    Behavior:
    - Clicking the clear button removes all pills at once.
    - Individual pills can also be removed.
    No confirm/save step is required.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Empty target state with dedicated clear control and straightforward feedback.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - At least one pill remains.
  - Only one pill removed (partial clear).
  expected_interaction_path:
  - Click the clear button in the right section of the TagsInput.
  - Verify no pills remain.
  notes: 'Instrumentation: data-testid="priority-tags" and optionally data-testid="priority-tags-clear".'
- id: combobox_editable_multi-mantine-T04
  name: Set exclude tags without touching include tags
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the “Exclude tags” field, set the tags to spam and test. The task will finish automatically when done.
  ui_copy: In the “Exclude tags” field, set the tags to spam and test. The task will finish automatically when done.
  setup_description: |-
    Layout is a filter form section with two similar Mantine TagsInput fields:
    - “Include tags” (distractor): initial pills = important
    - “Exclude tags” (target): initial pills = none
    Both support free input and also show a small suggestions dropdown with a few common tags (important, spam, test, internal, external).
    Other clutter: a Select “Sort by” and a Button “Run report” (not required).
    The goal is to set ONLY Exclude tags to exactly {spam, test}.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 4
    justification: Two similar fields in a form increase disambiguation; entering two exact tags is otherwise straightforward.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - 'Changes applied to the correct labeled instance: Exclude tags.'
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - spam
      - test
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Exclude tags
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Adding spam/test to Include tags instead of Exclude tags.
  - Only one of the two tags present in Exclude tags.
  - Any extra tag present in Exclude tags beyond spam and test.
  expected_interaction_path:
  - Click into “Exclude tags”.
  - Type spam, press Enter; type test, press Enter (or pick from suggestions).
  - Verify “Include tags” still has only important.
  notes: 'Instrumentation: data-testid="include-tags" and "exclude-tags".'
- id: combobox_editable_multi-mantine-T05
  name: Match tags from target preview
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Make the “Customer segments” field match the pills shown in “Target segments”. The task will finish automatically when done.
  ui_copy: Make the “Customer segments” field match the pills shown in “Target segments”. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “Segmentation”.
    - Left: Mantine TagsInput labeled “Customer segments” (interactive).
      - Initial pills: none
      - Suggestions include: SMB, Mid-market, Enterprise, Education, Healthcare, Government, Consumer.
    - Right: non-interactive pill row labeled “Target segments” showing the desired set: Enterprise, Healthcare, Government.
    The agent must match the TagsInput selection to the reference pill row exactly (order-insensitive).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Visual target reference requires reading and matching a pill preview; otherwise the interaction is standard.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Enterprise
      - Healthcare
      - Government
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selected pills do not exactly match the Target segments pills.
  - Selecting a distractor segment (e.g., Education).
  - Partial match (only one or two of the required segments).
  expected_interaction_path:
  - Inspect the Target segments pill row.
  - Select/add/remove pills in Customer segments until it matches.
  notes: 'Instrumentation: data-testid="customer-segments" and "target-segments-preview".'
- id: combobox_editable_multi-mantine-T06
  name: Commit a tag explicitly (no accept-on-blur)
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput (acceptValueOnBlur=false)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: In “On-call reviewers”, add Sam Lee as a tag. The task will finish automatically when done.
  ui_copy: In “On-call reviewers”, add Sam Lee as a tag. The task will finish automatically when done.
  setup_description: |-
    Centered isolated card titled “On-call rotation”.
    - Component: Mantine TagsInput labeled “On-call reviewers”.
    - Configuration: acceptValueOnBlur is set to false, so typed text is NOT added when the input loses focus; it is only added when:
      (a) pressing Enter, or (b) clicking a suggestion.
    - The UI shows helper text under the input: “Press Enter to add”.
    - Suggestions include: Sam Lee, Priya Patel, Jordan Kim, Mei Chen.
    - Initial state: empty.
    To succeed, the value must be committed as an actual pill/tag (not just typed text).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires an explicit commit action (Enter/click suggestion) rather than relying on blur, increasing feedback and commit dynamics.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Sam Lee
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Sam Lee is typed in the input but not added as a pill.
  - A different reviewer is selected (e.g., Jordan Kim).
  - Extra reviewer pills are added beyond Sam Lee.
  expected_interaction_path:
  - Click the TagsInput and type 'Sam Lee' (or pick it from suggestions).
  - Press Enter or click the Sam Lee suggestion to commit the pill.
  notes: 'Instrumentation: expose both input text (searchValue) and committed value array; checker must look only at committed value array.'
- id: combobox_editable_multi-mantine-T07
  name: Paste a formatted tag line (split chars)
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput (splitChars)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In “Batch tags”, paste the text “alpha|beta gamma” so it becomes three separate tags. The task will finish automatically when done.
  ui_copy: In “Batch tags”, paste the text “alpha|beta gamma” so it becomes three separate tags. The task will finish automatically when done.
  setup_description: |-
    The component is placed in the bottom-left of the viewport inside a small utility card titled “Batch entry”.
    - Placement: bottom_left
    - Theme: light
    - Component: Mantine TagsInput labeled “Batch tags”
    - Configuration: splitChars is set to [',', ' ', '|'] so pasted/typed values are split into multiple tags.
    - Initial state: empty.
    The UI includes a short helper text: “Paste tags separated by commas, spaces, or |”.
    To succeed, the single pasted string must result in exactly three pills: alpha, beta, gamma.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: Formatted paste must be parsed into multiple tags; failures often look superficially correct (one tag vs three), making commit/format precision important.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - alpha
      - beta
      - gamma
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - The entire string becomes one tag (alpha|beta gamma) instead of being split.
  - Only two tags created (e.g., alpha and beta gamma).
  - Any extra tag created beyond alpha, beta, gamma.
  expected_interaction_path:
  - Click the Batch tags input.
  - Paste alpha|beta gamma.
  - 'Verify three pills appear: alpha, beta, gamma.'
  notes: |-
    To keep this task unambiguous, display helper text indicating the accepted separators.
    Checker should normalize whitespace and ensure the committed tags are exactly alpha, beta, gamma.
- id: combobox_editable_multi-mantine-T08
  name: Replace tags with a max of 3 (compact small)
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput (maxTags=3)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: Set “Top keywords” to exactly billing, overdue, and escalation. The task will finish automatically when done.
  ui_copy: Set “Top keywords” to exactly billing, overdue, and escalation. The task will finish automatically when done.
  setup_description: |-
    Compact small card titled “Keyword cap” (centered).
    - Spacing: compact
    - Scale: small
    - Component: Mantine TagsInput labeled “Top keywords”
    - Configuration: maxTags=3 (cannot add a 4th keyword).
    - Initial pills (3): invoice, payment, refund
    - Suggestions list includes: invoice, payment, refund, billing, overdue, escalation, dispute, chargeback.
    Task: replace the existing three tags with billing, overdue, escalation. Because of maxTags, you must remove existing pills before adding new ones.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: Max-tags constraint forces correct removal and replacement under compact/small rendering, increasing error recovery cost.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - billing
      - overdue
      - escalation
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving any original keyword pill (invoice/payment/refund) selected.
  - Ending with fewer than 3 keywords.
  - Ending with an extra/different keyword (e.g., dispute).
  expected_interaction_path:
  - Remove the three existing pills (invoice, payment, refund).
  - Add billing, overdue, and escalation (via suggestions or typing + Enter).
  - Verify exactly three pills match the target set.
  notes: |-
    Checker should assert exact set and that tag count equals 3.
    Instrumentation: expose maxTags and current tags array for debugging.
- id: combobox_editable_multi-mantine-T09
  name: Set required tags in a drawer and apply
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: Drawer + TagsInput'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open “Edit filters”, set “Required tags” to billing, overdue, and escalated, then click “Apply”. The task will finish automatically when done.
  ui_copy: Open “Edit filters”, set “Required tags” to billing, overdue, and escalated, then click “Apply”. The task will finish automatically when done.
  setup_description: |-
    Drawer flow in a dashboard:
    - Main page shows a table of invoices and a button “Edit filters”.
    - Clicking “Edit filters” opens a left-side Drawer.
    Inside the drawer:
    - Target field: Mantine TagsInput labeled “Required tags”.
    - Initial pills: none.
    - Suggestions include many invoice-related tags (billing, overdue, escalated, paid, refunded, disputed, high-risk).
    - Drawer footer has buttons: “Cancel” and primary “Apply”.
    Feedback:
    - After clicking Apply, the drawer closes and a small inline status text updates to “Filters applied” (not required for success).
    Success requires the tags to match exactly AND the Apply button to be clicked.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 4
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires opening a drawer, making three selections, and committing via Apply within a cluttered dashboard context.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - 'Confirmation control clicked: Apply.'
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - billing
      - overdue
      - escalated
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Correct tags selected but Apply not clicked.
  - Clicking Cancel (or closing the drawer) instead of applying.
  - Missing one required tag or selecting extra tags.
  expected_interaction_path:
  - Click “Edit filters” to open the drawer.
  - Add billing, overdue, and escalated as pills.
  - Click “Apply”.
  notes: |-
    Checker should evaluate the committed tags at the time Apply is clicked.
    Instrumentation: data-testid for open button, drawer root, required-tags input, and Apply action.
- id: combobox_editable_multi-mantine-T10
  name: Match 5 destinations in a dark dashboard
  canonical_type: combobox_editable_multi
  implementation_source: mantine
  implementation_variant: TagsInput
  implementation_component: 'Mantine: TagsInput (with grouped suggestions)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In “Preferred destinations”, select Tokyo, Toronto, Tunis, Tallinn, and Tbilisi. The task will finish automatically when done.
  ui_copy: In “Preferred destinations”, select Tokyo, Toronto, Tunis, Tallinn, and Tbilisi. The task will finish automatically when done.
  setup_description: |-
    Dark theme dashboard layout with multiple panels (charts, side navigation, and a table).
    - Target panel: “Travel profile” card located near the center of the dashboard.
    - Component: Mantine TagsInput labeled “Preferred destinations”, with a large grouped suggestions dataset (~120 city names grouped by first letter).
    - Initial state: empty.
    - When the dropdown opens, only the first ~10 options are visible; the list is scrollable.
    The five target cities are in the “T” section and are not all visible at once; you will likely need to scroll within the suggestions list and select the correct cities.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 3
      density_choice_interference: 5
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 3
    justification: Large grouped option list in a cluttered dark dashboard increases search/scroll burden and option confusability (similar city names), with moderate observability.
  success_trigger:
    human_readable:
    - Selected values in the target combobox equal the target set (order-insensitive).
    - No extra values are selected.
    - No confirmation click is required.
    - Only one instance is present; instance disambiguation is not applicable.
    canonical_predicate:
      predicate_type: set_equals
      target_state:
      - Tokyo
      - Toronto
      - Tunis
      - Tallinn
      - Tbilisi
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a wrong city with a similar name (e.g., Turin instead of Tunis).
  - Missing any of the five target cities.
  - Selecting any extra destination beyond the five targets.
  expected_interaction_path:
  - Click the TagsInput to open the dropdown.
  - Scroll within the dropdown to the 'T' cities and select the five targets.
  - Verify exactly five destination pills are present.
  notes: |-
    To support scroll_find, ensure the dropdown is scrollable and not all T-options are initially visible.
    Instrumentation: data-testid="preferred-destinations" and stable group/option labels for the checker.