tasks/v1/data_grid_row_selection.yaml

- id: data_grid_row_selection-antd-T01
  name: Select a single customer row
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox
  implementation_component: 'AntD: Table (rowSelection)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Customers table, select the row for Customer ID C-014 (Ava Patel). The task will finish automatically when done.
  ui_copy: Customers — Select the row for Customer ID C-014 (Ava Patel).
  setup_description: |-
    Layout is an isolated card centered in the viewport. The card title is "Customers" and it contains a single Ant Design Table with a leading checkbox selection column (rowSelection, default checkbox type).
    Spacing is comfortable and the component is default size. The table has 8 visible rows (no pagination) with columns: Customer ID, Name, Plan, Status.
    Initial state: no rows are selected. There are no other interactive widgets on the page besides the table (no clutter). Selecting a row immediately updates the checkbox and the row highlight (no Apply/OK step).
    Row labels are unique and the target row shows "C-014" in the first data column and "Ava Patel" in the Name column.
  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: 4
      disambiguation_load: 1
    justification: Single checkbox selection in a small table with unique labels and immediate visible feedback.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['cust_C014'].
    - No other rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - cust_C014
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different customer row is selected instead of C-014 (Ava Patel).
  - Multiple rows are selected (extra rows selected).
  - The checkbox appears checked but the table selection state is not updated (e.g., focus-only highlight).
  expected_interaction_path:
  - Locate the row with Customer ID C-014 (Ava Patel).
  - Click the selection checkbox at the start of that row (or the row-selection control for that row).
  notes: 'Checker hint: read AntD Table selection via controlled selectedRowKeys / rowSelection.selectedRowKeys or DOM aria-checked on the row checkbox; row key is ''cust_C014''.'
- id: data_grid_row_selection-antd-T02
  name: Select three specific customers
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox
  implementation_component: 'AntD: Table (rowSelection)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: 'In the Customers table, select exactly these rows: C-007 (Bruno Silva), C-021 (Mei Wong), and C-033 (Omar Haddad). The task will finish automatically when done.'
  ui_copy: Customers — Select C-007 (Bruno Silva), C-021 (Mei Wong), and C-033 (Omar Haddad).
  setup_description: |-
    Baseline isolated card centered in the viewport with the title "Customers". It contains one Ant Design Table with a checkbox selection column (rowSelection).
    Spacing is comfortable and size is default. The table shows 10 rows with columns: Customer ID, Name, Region, Status.
    Initial state: no rows are selected. There is no pagination and no additional controls.
    The three target rows are all visible at once and have unambiguous ID+Name pairs.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: A small, visible list requires selecting multiple checkboxes without selecting extras.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['cust_C007', 'cust_C021', 'cust_C033'].
    - No additional rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - cust_C007
        - cust_C021
        - cust_C033
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only a subset of the requested rows is selected.
  - Any extra row besides C-007, C-021, and C-033 is selected.
  - Rows are selected in a different table instance (there is only one table in this task).
  expected_interaction_path:
  - Find each target row by Customer ID and Name.
  - Click the checkbox for C-007, C-021, and C-033.
  notes: 'Row keys: cust_C007, cust_C021, cust_C033. Selection is checkbox-based.'
- id: data_grid_row_selection-antd-T03
  name: Clear all selected rows
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox + external clear control
  implementation_component: 'AntD: Table (rowSelection) + Button'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the Orders table so that no rows are selected. The task will finish automatically when done.
  ui_copy: Orders — Clear selection (0 selected).
  setup_description: |-
    The page shows a centered isolated card titled "Orders". Inside is an Ant Design Table with a checkbox selection column.
    Above the table header, a small action row shows a text like "2 selected" and a secondary button labeled "Clear selection".
    Spacing is comfortable and size is default. The table contains 7 visible rows (no pagination) with columns: Order ID, Customer, Total.
    Initial state: two rows are pre-selected (order keys ord_1002 and ord_1005 are checked). Clicking "Clear selection" sets selectedRowKeys to an empty list.
    Feedback is immediate: the selected count text updates and all row checkboxes become unchecked.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Goal is an all-clear state with a dedicated clear control and clear on-screen selected-count feedback.
  success_trigger:
    human_readable:
    - The selected row IDs equal [].
    - The Orders table shows zero selected rows.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - At least one order row remains selected.
  - Selection is cleared in some other component (there is only one selectable table here).
  - A row is visually focused but still selected (checked) in state.
  expected_interaction_path:
  - Click the 'Clear selection' button above the table (or manually uncheck the selected rows).
  notes: Clutter is 'low' because of the extra action strip above the table. Checker should verify selectedRowKeys length == 0.
- id: data_grid_row_selection-antd-T04
  name: Select all rows using header checkbox
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox (select-all header)
  implementation_component: 'AntD: Table (rowSelection)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Inventory table, select all five rows. The task will finish automatically when done.
  ui_copy: Inventory — Select all rows.
  setup_description: |-
    A centered isolated card titled "Inventory" contains an Ant Design Table with a checkbox selection column and a select-all checkbox in the header of that column.
    Spacing is comfortable and size is default. The table has exactly 5 visible rows with columns: SKU, Item, Stock.
    Initial state: no rows selected. There is no pagination and no other controls.
    Selecting all rows can be done by clicking the header checkbox (which sets all row checkboxes to checked).
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Uses the built-in select-all checkbox in a tiny table; no disambiguation or overlays.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['sku_S001', 'sku_S002', 'sku_S003', 'sku_S004', 'sku_S005'].
    - All rows are selected (header checkbox is checked, not indeterminate).
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - sku_S001
        - sku_S002
        - sku_S003
        - sku_S004
        - sku_S005
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only some rows are selected (header checkbox indeterminate).
  - Any row remains unselected.
  - Extra selection occurs outside the Inventory table (not applicable here).
  expected_interaction_path:
  - Click the select-all checkbox in the header of the selection column (or check each row checkbox).
  notes: 'Row keys: sku_S001..sku_S005. Checker should compare the set of selected row keys to the full set of row keys.'
- id: data_grid_row_selection-antd-T05
  name: Scroll within table to select a transaction
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox + scrollable body
  implementation_component: 'AntD: Table (rowSelection)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Transactions table, scroll to find transaction TX-1049 and select its row. The task will finish automatically when done.
  ui_copy: Transactions — Select TX-1049.
  setup_description: |-
    Layout is an isolated card anchored at the bottom-left of the viewport (not centered). The card title is "Transactions".
    The Ant Design Table uses a fixed height with a scrollable tbody (vertical scroll within the table). Row selection is via the leftmost checkbox column.
    Spacing is comfortable and size is default. The table contains 40 transactions (TX-1010 through TX-1049), but only about 10 are visible at a time due to the scroll container.
    Initial state: no rows are selected. There are no other widgets on the page.
    The target row TX-1049 is near the bottom, requiring scrolling inside the table body to reveal it.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires internal scrolling to reveal the target row before selecting its checkbox.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['tx_TX1049'].
    - No other transaction rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - tx_TX1049
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different transaction is selected (e.g., TX-1048 instead of TX-1049).
  - Multiple transactions are selected.
  - The page scrolls but the table body does not scroll to reveal TX-1049 (row never selected).
  expected_interaction_path:
  - Scroll inside the Transactions table body until TX-1049 is visible.
  - Click the checkbox for TX-1049.
  notes: 'Instrumentation: ensure the scroll container is within the component subtree so agents must scroll the correct element. Row key: tx_TX1049.'
- id: data_grid_row_selection-antd-T06
  name: Select a reviewer in a modal and confirm
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.radio (modal)
  implementation_component: 'AntD: Modal + Table (rowSelection type=''radio'')'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Choose reviewer” dialog, select E-006 (Nora Diaz) in the table, and click OK. The task will finish automatically when done.
  ui_copy: 'Button: Choose reviewer. Dialog: Choose reviewer (select one) with OK/Cancel.'
  setup_description: |-
    The page uses a modal_flow layout: the main view shows a single primary button labeled "Choose reviewer".
    Clicking it opens an Ant Design Modal titled "Choose reviewer". Inside the modal is a Table with a single-selection control (rowSelection.type='radio'), so only one row can be selected.
    Spacing is comfortable and scale is default. The modal table shows 8 employees with columns: Employee ID, Name, Team.
    Initial state: no row selected in the modal. The modal footer has buttons "Cancel" and a primary "OK".
    Feedback: selecting a row checks its radio control and highlights the row; clicking OK closes the modal and commits the selection to the underlying state.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires opening a modal, making a single-row selection, and confirming with OK to commit.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['emp_E006'].
    - The selection is committed (modal closed via OK).
    - No other employee is selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - emp_E006
      tolerance: null
      require_confirm: true
      confirm_control: OK
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - The dialog is opened but OK is not clicked (selection not confirmed).
  - A different employee is selected (wrong ID or name).
  - More than one row is selected (should be impossible in radio mode, but still disallowed).
  expected_interaction_path:
  - Click the 'Choose reviewer' button to open the modal.
  - Select the row for E-006 (Nora Diaz) using the radio control.
  - Click 'OK' in the modal footer.
  notes: Checker should verify final committed selection state (outside-modal store) equals ['emp_E006'] AND that the modal is closed after OK.
- id: data_grid_row_selection-antd-T07
  name: Search then select in the correct segment table
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox + search filter + 2 instances
  implementation_component: 'AntD: Form layout + Table (rowSelection) x2 + Input.Search'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: In the Prospects table, use the search field to find U-118 (Kara Novak) and select that row. The task will finish automatically when done.
  ui_copy: Audience segment — Prospects table and Customers table. Select U-118 (Kara Novak) in Prospects.
  setup_description: |-
    The page is a form_section for "Create campaign" with light clutter: a couple of text inputs (Campaign name, Budget) and a disabled toggle appear above the audience segment.
    The audience segment contains TWO Ant Design Tables side-by-side, each with its own heading and checkbox row selection column:
      1) "Prospects" table (left)
      2) "Customers" table (right)
    Each table has an Input.Search field directly above it that filters rows within that table only.
    Spacing is comfortable and scale is default. Both tables show about 12 rows with columns: User ID, Name, Region.
    Initial state: no rows selected in either table, and no search filters applied.
    The target row "U-118 — Kara Novak" exists only in the Prospects table. Selecting a row takes effect immediately (no Apply button).
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 3
    justification: Requires choosing the correct table instance and optionally using a local search field before selecting the correct row.
  success_trigger:
    human_readable:
    - The check is applied to the "Prospects table" grid instance only.
    - The selected row IDs equal ['user_U118'].
    - In the Customers table, no rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - user_U118
        other_instances_selected_row_ids:
          Customers table: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Prospects table
      terminal_condition: true
  negative_cases:
  - U-118 (Kara Novak) is selected in the Customers table (wrong instance).
  - A different user row is selected in the Prospects table.
  - Multiple rows are selected in either table.
  expected_interaction_path:
  - In the Prospects section, click into the Prospects search field and type 'U-118' or 'Kara'.
  - Select the row U-118 (Kara Novak) using its checkbox in the Prospects table.
  notes: 'Instrumentation: add data-testid for each table container (''prospects-grid'', ''customers-grid'') to disambiguate instances; use row keys user_U118 etc.'
- id: data_grid_row_selection-antd-T08
  name: Select archived projects in a dashboard with two tables
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox + 2 instances (dashboard)
  implementation_component: 'AntD: Table (rowSelection) x2'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the “Archived projects” table, select project codes AR-017 and AR-023. Do not select anything in “Active projects”. The task will finish automatically when done.
  ui_copy: Dashboard — Active projects | Archived projects. Select AR-017 and AR-023 in Archived projects.
  setup_description: |-
    The scene is a dashboard with two cards in a two-column layout. Each card contains an Ant Design Table with checkbox row selection:
      • Left card: "Active projects"
      • Right card: "Archived projects"
    Both tables share the same columns (Project code, Name, Owner) and have visually similar rows, increasing confusion.
    Spacing is comfortable, scale is default. A small KPI strip and a refresh icon appear above the tables (medium clutter), but they do not affect success.
    Initial state: no rows are selected in either table. No overlays are involved and selection applies immediately.
    The target rows AR-017 and AR-023 are present in the Archived projects table; Active projects contains similar codes like AC-017 and AC-023 as distractors.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 4
    justification: Two similar table instances and confusable codes create high disambiguation load even though the interaction is simple checkboxes.
  success_trigger:
    human_readable:
    - The check is applied to the "Archived projects table" grid instance only.
    - The selected row IDs equal ['arch_AR017', 'arch_AR023'].
    - In the Active projects table, no rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - arch_AR017
        - arch_AR023
        other_instances_selected_row_ids:
          Active projects table: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Archived projects table
      terminal_condition: true
  negative_cases:
  - AR-017/AR-023 are selected in the Active projects table (wrong instance).
  - Only one of the two archived project rows is selected.
  - Any extra project row is selected in either table.
  expected_interaction_path:
  - Locate the 'Archived projects' table card.
  - Check the selection boxes for AR-017 and AR-023 in that table.
  - Verify the Active projects table still has zero selections.
  notes: Checker should verify selection sets per table instance. Instrument instance containers with stable IDs (e.g., data-testid='active-projects-grid', 'archived-projects-grid').
- id: data_grid_row_selection-antd-T09
  name: Match a reference chip list to select SKUs
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox (compact density) + reference panel
  implementation_component: 'AntD: Table (rowSelection) + Tag/Badge reference list'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the SKUs table, select the rows that match the three reference chips shown in the “Pick these SKUs” panel. The task will finish automatically when done.
  ui_copy: 'SKUs — Pick these SKUs: [SKU-1A7] [SKU-1B7] [SKU-2A7].'
  setup_description: |-
    The UI is an isolated card centered on the page in compact spacing mode (tighter row height and smaller checkboxes).
    The card is split into two columns:
      • Left: an Ant Design Table titled "SKUs" with checkbox row selection and 20 visible rows.
      • Right: a small reference panel titled "Pick these SKUs" that displays three colored chips (tags) with the exact SKU codes to select.
    The table columns are SKU Code, Description, Category. Many rows share similar prefixes (e.g., SKU-1A6, SKU-1A7, SKU-1A8), creating confusable distractors.
    Initial state: no rows are selected. There is no pagination and no Apply step; selection updates immediately and each selected row checkbox becomes checked.
    Guidance is mixed: the user matches the visual chips to the textual SKU codes in the table.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 2
    justification: Compact spacing plus many confusable SKU codes increases choice interference; target is provided via a reference panel rather than direct text-only instruction.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['sku_1A7', 'sku_1B7', 'sku_2A7'].
    - No other SKU rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - sku_1A7
        - sku_1B7
        - sku_2A7
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A near-miss SKU is selected (e.g., SKU-1A6 or SKU-1A8 instead of SKU-1A7).
  - Only some of the referenced SKUs are selected.
  - Any extra SKU row is selected.
  expected_interaction_path:
  - Read the three SKU codes in the 'Pick these SKUs' chip panel.
  - In the table, find each matching SKU code and check its row-selection checkbox.
  notes: Reference panel is non-interactive; success depends only on the table selection set. Row keys are sku_1A7, sku_1B7, sku_2A7.
- id: data_grid_row_selection-antd-T10
  name: Select invoices across pages in dark theme
  canonical_type: data_grid_row_selection
  implementation_source: antd
  implementation_variant: rowSelection.checkbox + pagination (dark theme)
  implementation_component: 'AntD: Table (rowSelection) with pagination'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Invoices table, select invoice INV-1003 and invoice INV-1011. Use the pagination controls if needed. The task will finish automatically when done.
  ui_copy: Invoices — Select INV-1003 and INV-1011 (selection persists across pages).
  setup_description: |-
    The page uses the baseline isolated card layout but in a dark theme. A single card titled "Invoices" contains an Ant Design Table with checkbox row selection and pagination controls at the bottom.
    Spacing is comfortable and scale is default. Page size is 5 rows, with 3 pages total. Columns are Invoice ID, Client, Amount, Due date.
    Initial state: no rows are selected. Selection is configured to persist across pagination (so selecting a row on page 1 remains selected after moving to page 2/3).
    INV-1003 is visible on page 1. INV-1011 is on page 3. The agent must navigate between pages and ensure both invoices are selected at the same time.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 2
    justification: Dark theme plus pagination introduces extra substeps; maintaining a multi-row selection across pages is error-prone.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['inv_1003', 'inv_1011'].
    - Selections persist across pagination and both target invoices are selected simultaneously.
    - No additional invoices are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - inv_1003
        - inv_1011
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only INV-1003 is selected (INV-1011 missing) or only INV-1011 is selected.
  - An invoice with a similar ID (e.g., INV-1010) is selected by mistake.
  - Extra invoices are selected beyond the two targets.
  expected_interaction_path:
  - On page 1, select INV-1003 via its row checkbox.
  - Use the pagination control to go to page 3.
  - Select INV-1011 via its row checkbox.
  - Optionally verify the selection count shows 2 selected.
  notes: Ensure selection is controlled (selectedRowKeys state) so it persists across pages. Checker should not depend on current page visibility; it should read the full selectedRowKeys state.
- id: data_grid_row_selection-mui-T01
  name: Single-row selection by clicking a row
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid single selection (row click)
  implementation_component: 'MUI X: DataGrid (row selection)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Support tickets grid, select ticket T-104 (Login issue). The task will finish automatically when done.
  ui_copy: Support tickets — Select ticket T-104 (Login issue).
  setup_description: |-
    A centered isolated card titled "Support tickets" contains a single MUI X DataGrid.
    The grid is in its default configuration for single row selection: clicking a row selects/highlights it.
    Spacing is comfortable and scale is default. There are 8 rows visible (no pagination). Columns: Ticket ID, Subject, Priority.
    Initial state: no row is selected. There are no extra controls (no toolbar, no filters). Feedback is immediate via row highlight and aria-selected state.
  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: 4
      disambiguation_load: 1
    justification: Direct row click selects a single row in a small grid with clear labels.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['T-104'].
    - No other row is selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - T-104
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different ticket row is selected (wrong Ticket ID).
  - No row is selected (only focus/hover without selection).
  - Multiple rows are selected (should not happen in this configuration).
  expected_interaction_path:
  - Find the row with Ticket ID T-104 and subject 'Login issue'.
  - Click the row to select it.
  notes: 'Checker hint: read DataGrid rowSelectionModel / selected row IDs (e.g., via apiRef.getSelectedRows or controlled model).'
- id: data_grid_row_selection-mui-T02
  name: Select multiple rows with checkbox selection
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection
  implementation_component: 'MUI X: DataGrid (checkboxSelection)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Releases grid, select versions v2.1.0 and v2.3.0. The task will finish automatically when done.
  ui_copy: Releases — Select v2.1.0 and v2.3.0.
  setup_description: |-
    Baseline isolated card centered in the viewport titled "Releases". It contains one MUI X DataGrid with checkboxSelection enabled (a checkbox column appears at the left).
    Spacing is comfortable and scale is default. The grid shows 12 release rows (all visible; no pagination) with columns: Version, Date, Channel.
    Initial state: no rows selected. Clicking a row checkbox selects it; multiple selections are allowed.
    The target versions v2.1.0 and v2.3.0 are both visible at once.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Two explicit targets with visible checkboxes; main risk is selecting an extra row.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['v2.1.0', 'v2.3.0'].
    - No other versions are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - v2.1.0
        - v2.3.0
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only one of the two versions is selected.
  - A different version (e.g., v2.2.0) is selected instead.
  - Extra versions are selected beyond the two targets.
  expected_interaction_path:
  - Locate v2.1.0 and v2.3.0 rows.
  - Click the checkbox for each target row.
  notes: In MUI X DataGrid, checkboxSelection adds a dedicated selection column. Verify selection by reading rowSelectionModel ids.
- id: data_grid_row_selection-mui-T03
  name: Clear selection using toolbar button
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection + toolbar clear
  implementation_component: 'MUI X: DataGrid (checkboxSelection) + Toolbar'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the Files grid so that zero rows are selected. The task will finish automatically when done.
  ui_copy: Files — 2 selected — Clear selection
  setup_description: |-
    A centered isolated card titled "Files" contains a MUI X DataGrid with checkboxSelection enabled and a simple toolbar row above it.
    The toolbar shows text "2 selected" and a button labeled "Clear selection".
    Spacing is comfortable and size is default. The grid shows 9 file rows (no pagination) with columns: File, Owner, Modified.
    Initial state: two rows are pre-selected (file_Alpha.pdf and file_Bravo.pdf). Clicking "Clear selection" resets the rowSelectionModel to empty and updates the selected count.
    No other interactive widgets are present.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Reset-to-empty is clearly indicated and can be achieved via a dedicated clear control with immediate feedback.
  success_trigger:
    human_readable:
    - The selected row IDs equal [].
    - The grid shows zero selected rows.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - At least one row remains selected.
  - Selection is cleared visually but the underlying rowSelectionModel is non-empty.
  - A row is still selected due to keyboard focus or highlight state.
  expected_interaction_path:
  - Click 'Clear selection' in the toolbar (or uncheck the selected rows).
  notes: Checker should verify rowSelectionModel resolves to an empty selection set (include/exclude model normalized).
- id: data_grid_row_selection-mui-T04
  name: Quick filter then select a city
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid row selection + toolbar quick filter
  implementation_component: 'MUI X: DataGrid (row selection) + Quick Filter toolbar'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Use the grid’s search box to find the city Dover (City ID 17) and select that row. The task will finish automatically when done.
  ui_copy: Cities — Search… (quick filter) — Select Dover (City ID 17).
  setup_description: |-
    A centered isolated card titled "Cities" contains a MUI X DataGrid with a toolbar enabled.
    The toolbar includes a single search input labeled "Search…" (quick filter) that filters visible rows as you type.
    Spacing is comfortable and scale is default. The grid contains 30 rows and uses standard DataGrid scrolling (all rows are reachable in the same view with scroll).
    Columns: City ID, City, Country. Initial state: no row selected and the search box is empty.
    The target row has City ID 17 and City "Dover". There are distractors like "Dover Heights" and "Dovercourt" to encourage using the ID for disambiguation.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Adds a search/filter substep and confusable names, but the target is uniquely identified by an ID.
  success_trigger:
    human_readable:
    - The selected row IDs equal [17].
    - No other city rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - 17
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different 'Dover*' row is selected (wrong City ID).
  - No row is selected (search typed but row not selected).
  - Multiple city rows are selected.
  expected_interaction_path:
  - Click the Search box in the toolbar and type 'Dover' or '17'.
  - Click the row for City ID 17 (Dover) to select it.
  notes: Use numeric row IDs for DataGrid rows (id=17). Checker should read selected row IDs from the grid selection model.
- id: data_grid_row_selection-mui-T05
  name: Scroll to a far row and select it
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid single selection (virtualized long list)
  implementation_component: 'MUI X: DataGrid (row selection, virtualization)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Products grid, scroll down to product ID 187 (Pineapple) and select that row. The task will finish automatically when done.
  ui_copy: Products — Select product 187 (Pineapple).
  setup_description: |-
    The grid appears in an isolated card anchored at the top-right of the viewport.
    It is a MUI X DataGrid with many rows (200 products) and built-in virtualization; only a small window of rows is rendered at any time.
    Spacing is comfortable and scale is default. Columns: Product ID, Name, Category.
    Initial state: no row selected, and the scroll position is at the very top (showing low product IDs).
    The target product ID 187 (Name: Pineapple) requires substantial scrolling within the DataGrid’s internal scroller to reach and select.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires scrolling within a virtualized grid to reach a distant target row.
  success_trigger:
    human_readable:
    - The selected row IDs equal [187].
    - No other product row is selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - 187
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A nearby product ID (e.g., 186 or 188) is selected instead.
  - The page scrolls but the grid scroller does not reach product 187.
  - Multiple rows are selected.
  expected_interaction_path:
  - Scroll within the Products grid until product ID 187 is visible.
  - Click the row for ID 187 (Pineapple) to select it.
  notes: 'Instrumentation: ensure the DataGrid has a fixed height so scrolling occurs within the grid. Checker reads selected id from rowSelectionModel.'
- id: data_grid_row_selection-mui-T06
  name: Select multiple members in a dialog and apply
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection (dialog apply)
  implementation_component: 'MUI: Dialog + MUI X DataGrid (checkboxSelection)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Add members” dialog, select member IDs M-12, M-19, and M-23, then click Add selected. The task will finish automatically when done.
  ui_copy: 'Button: Add members. Dialog: Add members (select rows) with Add selected/Cancel.'
  setup_description: |-
    The scene uses a modal_flow: the base page shows a button labeled "Add members".
    Clicking it opens a MUI Dialog titled "Add members". The dialog body contains a MUI X DataGrid with checkboxSelection enabled.
    Spacing is comfortable and scale is default. The DataGrid shows 15 members with columns: Member ID, Name, Role.
    Initial state: no rows selected in the dialog. The dialog footer has a primary button labeled "Add selected" and a secondary "Cancel".
    Feedback: selecting rows checks their boxes; clicking "Add selected" closes the dialog and commits the selected member IDs to an underlying selection state.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Overlay depth plus an explicit Apply action increases complexity compared to inline selection.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['M-12', 'M-19', 'M-23'].
    - The dialog is closed via the 'Add selected' action and the selection is committed.
    - No extra members are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - M-12
        - M-19
        - M-23
      tolerance: null
      require_confirm: true
      confirm_control: Add selected
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - The correct rows are selected but 'Add selected' is not clicked (not confirmed).
  - Only a subset of the target members is selected.
  - Extra member rows are selected in addition to M-12, M-19, and M-23.
  expected_interaction_path:
  - Click 'Add members' to open the dialog.
  - Check the boxes for M-12, M-19, and M-23 in the grid.
  - Click 'Add selected' in the dialog footer.
  notes: Checker should verify committed selection state (post-confirm) equals the three IDs and the dialog is closed.
- id: data_grid_row_selection-mui-T07
  name: Select rows that match a status color legend
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection + visual status markers
  implementation_component: 'MUI X: DataGrid (checkboxSelection) with custom cell renderer'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the Build jobs grid, select all rows that have the same status dot shown in the legend (the orange dot). The task will finish automatically when done.
  ui_copy: 'Build jobs — Legend: select rows with the orange status dot.'
  setup_description: |-
    A centered isolated card titled "Build jobs" contains a MUI X DataGrid with checkboxSelection enabled.
    Above the grid, a small legend displays a single orange circular dot next to the text "Select rows with this status dot".
    In the grid, the first column after the checkbox column is "Status" and renders only a colored dot (no text). Other columns are Job ID and Branch.
    Spacing is comfortable and scale is default. The grid shows 12 rows, all visible without pagination.
    Initial state: no rows selected. Exactly 3 rows have the orange dot; the rest use green/gray dots as distractors.
    Guidance is visual: the target set is defined by matching the dot color in the legend to the dot color in each row.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires mapping a visual legend to rows; status is not expressed as text inside the grid cells.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['job_402', 'job_407', 'job_411'].
    - Only rows with the orange status dot are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - job_402
        - job_407
        - job_411
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A row with a non-orange status dot is selected.
  - Not all orange-dot rows are selected.
  - Extra rows are selected beyond the orange-dot set.
  expected_interaction_path:
  - Look at the legend to identify the target dot color (orange).
  - Scan the Status column for orange dots and check the corresponding row checkboxes.
  notes: For checking, use stable row IDs job_402/job_407/job_411; status dot is purely visual, so rely on row IDs rather than status text.
- id: data_grid_row_selection-mui-T08
  name: Disambiguate between two grids in a dashboard
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection x2 (dashboard)
  implementation_component: 'MUI X: DataGrid (checkboxSelection) x2'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Closed requests grid, select request IDs CR-19 and CR-22. Do not select anything in Open requests. The task will finish automatically when done.
  ui_copy: Requests dashboard — Open requests | Closed requests. Select CR-19 and CR-22 in Closed.
  setup_description: |-
    The scene is a dashboard with two side-by-side cards, each containing a MUI X DataGrid with checkboxSelection:
      • Left card: "Open requests"
      • Right card: "Closed requests"
    Both grids have the same columns (Request ID, Title, Owner) and similar-looking IDs (e.g., OR-19 vs CR-19).
    Spacing is comfortable and scale is default. Additional dashboard clutter includes a date range chip row and a small sparkline chart above the cards (medium clutter), but no interaction is needed.
    Initial state: no rows selected in either grid. Selection updates immediately on checkbox click.
    The target rows are CR-19 and CR-22 in the Closed requests grid only.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 4
    justification: Two grids with similar ID patterns create high disambiguation risk; selecting the wrong instance is easy.
  success_trigger:
    human_readable:
    - The check is applied to the "Closed requests grid" grid instance only.
    - The selected row IDs equal ['CR-19', 'CR-22'].
    - The Open requests grid has zero selected rows.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - CR-19
        - CR-22
        other_instances_selected_row_ids:
          Open requests grid: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Closed requests grid
      terminal_condition: true
  negative_cases:
  - Selections are made in Open requests instead of Closed requests (wrong instance).
  - Only one of CR-19 or CR-22 is selected.
  - Any additional row is selected in either grid.
  expected_interaction_path:
  - Locate the 'Closed requests' card.
  - Check the boxes for CR-19 and CR-22.
  - Verify Open requests remains unselected.
  notes: 'Instrumentation: add data-testid to each grid container to disambiguate (''open-requests-grid'', ''closed-requests-grid'').'
- id: data_grid_row_selection-mui-T09
  name: Select two customers across paginated pages
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection + pagination
  implementation_component: 'MUI X: DataGrid (checkboxSelection) with client-side pagination'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Customers grid, select Customer ID 2 and Customer ID 11. Use the page controls if needed. The task will finish automatically when done.
  ui_copy: Customers — Select IDs 2 and 11.
  setup_description: |-
    The page shows an isolated card centered in the viewport titled "Customers" with a MUI X DataGrid.
    Checkbox selection is enabled. The grid uses client-side pagination with page size 5 and 3 pages total; page navigation controls appear in the footer.
    Spacing is comfortable and scale is default. Columns: Customer ID, Name, Plan.
    Initial state: no rows selected and the grid starts on page 1 (showing Customer IDs 1–5).
    Customer ID 2 is on page 1; Customer ID 11 is on page 3. Selection persists when navigating pages, so both must be selected at the same time.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 2
    justification: Pagination adds substeps and requires maintaining the correct selection set while switching pages.
  success_trigger:
    human_readable:
    - The selected row IDs equal [2, 11].
    - No additional customers are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - 2
        - 11
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only one of the two customers is selected.
  - A different ID (e.g., 12) is selected due to page navigation confusion.
  - Extra customers are selected beyond IDs 2 and 11.
  expected_interaction_path:
  - On page 1, check the box for Customer ID 2.
  - Use the pagination controls to go to page 3.
  - Check the box for Customer ID 11.
  - Optionally verify the selected count is 2 (if shown).
  notes: Checker should read rowSelectionModel and normalize include/exclude selection model to a concrete selected ID set.
- id: data_grid_row_selection-mui-T10
  name: Compact dark settings panel selection with Apply
  canonical_type: data_grid_row_selection
  implementation_source: mui
  implementation_variant: DataGrid checkboxSelection (compact density) + Apply confirm
  implementation_component: 'MUI: Settings panel layout + MUI X DataGrid (checkboxSelection)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: In the Feature flags grid, select FF-12, FF-19, and FF-23, then click Apply. The task will finish automatically when done.
  ui_copy: Feature flags — Select FF-12, FF-19, FF-23 — Apply
  setup_description: |-
    The scene is a settings_panel in dark theme. A left sidebar shows non-interactive navigation items (Profile, Billing, Flags), and the main panel shows "Feature flags".
    The main panel contains a MUI X DataGrid with checkboxSelection enabled, rendered in compact spacing with a small visual scale (smaller typography and tighter row height).
    The grid shows 25 rows (no pagination) with columns: Flag key, Description, Environment. Many flag keys share the "FF-" prefix.
    At the bottom of the panel, there is a sticky action bar with a primary button labeled "Apply".
    Initial state: no flags selected. Selection changes are not considered committed until Apply is clicked (Apply closes the pending state and shows a small toast "Selection applied").
  scene_context:
    theme: dark
    spacing: compact
    layout: settings_panel
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: Small, compact targets in dark theme plus an explicit Apply step increases both acquisition difficulty and recovery cost.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['FF-12', 'FF-19', 'FF-23'].
    - The Apply action has been used to commit the selection.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - FF-12
        - FF-19
        - FF-23
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - The correct rows are selected but Apply is not clicked (not confirmed).
  - Any extra flag row is selected beyond FF-12, FF-19, FF-23.
  - A similarly numbered flag (e.g., FF-13) is selected instead due to compact density.
  expected_interaction_path:
  - In the Feature flags grid, check the boxes for FF-12, FF-19, and FF-23.
  - Click the 'Apply' button in the sticky action bar.
  notes: 'Checker should gate success on both: (1) selected IDs set equals targets and (2) Apply has been clicked (e.g., via a committed-state flag / toast event).'
- id: data_grid_row_selection-mantine-T01
  name: Select a single employee row (composed table)
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Table + Checkbox (composed row selection)'
  task_template: select_one
  secondary_template: null
  browsergym_goal: In the Employees table, select employee E-03 (Rita Singh). The task will finish automatically when done.
  ui_copy: Employees — Select E-03 (Rita Singh).
  setup_description: |-
    The page is a centered isolated card titled "Employees". It contains a Mantine Table where the first column is a Checkbox used to select each row (composed row-selection pattern).
    Spacing is comfortable and scale is default. The table has 9 visible rows and columns: Employee ID, Name, Department.
    Initial state: no rows are selected. There is no pagination, no search, and no additional widgets (no clutter).
    Selecting a row immediately checks the checkbox and highlights the row background (local state update, no Apply/OK).
  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: 4
      disambiguation_load: 1
    justification: Single checkbox selection in a small composed table with immediate visual feedback.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['emp_E03'].
    - No other employees are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - emp_E03
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different employee is selected instead of E-03 (Rita Singh).
  - Multiple employee rows are selected.
  - The checkbox is toggled but the composed selection state is not updated.
  expected_interaction_path:
  - Find the row with Employee ID E-03 and Name Rita Singh.
  - Click the checkbox in that row.
  notes: 'Composite implementation: store selected row IDs in local state and mirror to DOM via data-selected and aria-checked attributes for robust checking.'
- id: data_grid_row_selection-mantine-T02
  name: Select two teams for a roster export
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Table + Checkbox (composed row selection)'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Teams table, select T-07 (Design) and T-12 (Marketing). The task will finish automatically when done.
  ui_copy: Teams — Select T-07 (Design) and T-12 (Marketing).
  setup_description: |-
    A centered isolated card titled "Teams" contains a Mantine Table with a leading Checkbox column for row selection.
    Spacing is comfortable and scale is default. The table shows 12 rows (no pagination) with columns: Team ID, Team name, Members.
    Initial state: no teams selected. Selecting rows updates a small text below the table ("Selected: N") but no confirmation is required.
    Both target rows are visible without scrolling.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Two explicit row checkboxes in a small table; success depends on selecting exactly the targets.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['team_T07', 'team_T12'].
    - No other teams are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - team_T07
        - team_T12
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - Only one of the requested teams is selected.
  - Any extra team is selected beyond T-07 and T-12.
  - The wrong table row is selected due to misreading the ID.
  expected_interaction_path:
  - Locate rows T-07 (Design) and T-12 (Marketing).
  - Click the checkbox for each target row.
  notes: Row IDs are team_T07 and team_T12. Compose selection column using Mantine Checkbox component.
- id: data_grid_row_selection-mantine-T03
  name: Clear all selected rows in a composed table
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite + external clear control
  implementation_component: 'Mantine: Table + Checkbox (composed) + Button'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the selection in the Devices table so that no rows are selected. The task will finish automatically when done.
  ui_copy: Devices — 3 selected — Clear
  setup_description: |-
    A centered isolated card titled "Devices" contains a Mantine Table with row selection composed from a Checkbox column.
    Above the table header, a small action row shows "3 selected" and a subtle button labeled "Clear".
    Spacing is comfortable and scale is default. The table has 10 visible rows with columns: Device ID, Name, Owner.
    Initial state: three devices are pre-selected (dev_D02, dev_D05, dev_D09). Clicking Clear resets the internal selected IDs set to empty and unchecks all row checkboxes.
    Feedback is immediate: the selected count changes to "0 selected".
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 1
    justification: Dedicated clear control and clear selected-count feedback make reset straightforward.
  success_trigger:
    human_readable:
    - The selected row IDs equal [].
    - The Devices table has zero selected rows.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - At least one device remains selected.
  - Selection is cleared visually but internal selected IDs set is not empty.
  - A device is still selected due to partial UI update.
  expected_interaction_path:
  - Click the 'Clear' button above the table (or manually uncheck the selected rows).
  notes: Composite checker should read selected IDs from a single source of truth (React state) and/or DOM attributes on row checkboxes.
- id: data_grid_row_selection-mantine-T04
  name: Scroll to a far audit log row and select it
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite + ScrollArea (sticky header)
  implementation_component: 'Mantine: ScrollArea + Table (stickyHeader) + Checkbox (composed selection)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the Audit log table, scroll to find entry AL-049 and select that row. The task will finish automatically when done.
  ui_copy: Audit log — Select AL-049.
  setup_description: |-
    The card is anchored at the bottom-right of the viewport. It is titled "Audit log".
    Inside the card, the table is placed within a fixed-height ScrollArea; the Mantine Table header is sticky so column labels remain visible while scrolling.
    Row selection is composed: each row begins with a Checkbox cell.
    Spacing is comfortable and scale is default. The table contains 50 entries (AL-000 to AL-049) but only ~12 are visible at a time.
    Initial state: no rows selected. There are no other controls.
    The target AL-049 is at the bottom and requires scrolling inside the ScrollArea to reveal and select it.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: bottom_right
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires interacting with an internal scroll container to reach a distant row before selecting its checkbox.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['audit_AL049'].
    - No other audit rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - audit_AL049
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A nearby entry (e.g., AL-048) is selected instead.
  - The page scrolls but the ScrollArea does not (AL-049 never becomes visible/selected).
  - Multiple entries are selected.
  expected_interaction_path:
  - Scroll within the Audit log ScrollArea until AL-049 is visible.
  - Click the checkbox for AL-049.
  notes: Use data-row-id attributes (e.g., audit_AL049) and ensure the scroll container is within the component subtree for accurate scroll_find evaluation.
- id: data_grid_row_selection-mantine-T05
  name: Select approvers in a modal and save
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite (modal apply)
  implementation_component: 'Mantine: Modal + Table + Checkbox (composed selection)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Choose approvers” modal, select A-02, A-05, and A-09, then click Save. The task will finish automatically when done.
  ui_copy: 'Button: Choose approvers. Modal: Choose approvers with Save/Cancel.'
  setup_description: |-
    The base page shows a single button labeled "Choose approvers" (modal_flow).
    Clicking it opens a Mantine Modal titled "Choose approvers". Inside the modal is a Mantine Table with a leading Checkbox column (composed row selection).
    Spacing is comfortable and scale is default. The modal table shows 10 approver rows with columns: Approver ID, Name, Department.
    Initial state: no approvers selected. The modal footer has "Cancel" and a primary "Save" button.
    Feedback: checking a row updates the checkbox and highlights the row; clicking Save closes the modal and commits the selected approver IDs.
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 4
      disambiguation_load: 1
    justification: Requires opening a modal, selecting multiple rows, and confirming with Save to commit.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['appr_A02', 'appr_A05', 'appr_A09'].
    - Selection is committed after Save (modal closed).
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - appr_A02
        - appr_A05
        - appr_A09
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - The correct approvers are selected but Save is not clicked (not confirmed).
  - Only a subset of the target approvers is selected.
  - Extra approvers are selected beyond A-02, A-05, and A-09.
  expected_interaction_path:
  - Click 'Choose approvers' to open the modal.
  - Check rows A-02, A-05, and A-09.
  - Click 'Save' in the modal footer.
  notes: 'Checker should gate success on both: committed selection state equals target IDs and modal is closed.'
- id: data_grid_row_selection-mantine-T06
  name: Match reference list to select shipments
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite + reference panel
  implementation_component: 'Mantine: Table + Checkbox (composed) + Badge/Chip reference list'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the Shipments table, select the rows that match the three shipment codes shown in the reference list. The task will finish automatically when done.
  ui_copy: 'Shipments — Reference: SHP-201, SHP-214, SHP-219.'
  setup_description: |-
    A centered isolated card titled "Shipments" is split into two parts.
    On the left is a Mantine Table with a Checkbox column for row selection. On the right is a small reference list titled "Select these shipments" showing three codes as badges: SHP-201, SHP-214, SHP-219.
    Spacing is comfortable and scale is default. The table shows 18 rows with columns: Shipment code, Destination, Carrier.
    Initial state: no rows selected. There is no pagination and selection is applied immediately.
    Some shipment codes are visually similar (e.g., SHP-218 vs SHP-219), making careful matching necessary.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 2
    justification: Mixed guidance and similar-looking codes increase choice interference, but all rows are visible and there is no overlay/confirm step.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['shp_201', 'shp_214', 'shp_219'].
    - No other shipment rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - shp_201
        - shp_214
        - shp_219
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A near-miss shipment (e.g., SHP-218) is selected instead of SHP-219.
  - Only some of the referenced shipments are selected.
  - Extra shipments are selected beyond the three targets.
  expected_interaction_path:
  - Read the three shipment codes from the reference list.
  - Find each code in the table and check its row checkbox.
  notes: 'Reference list is non-interactive. Row keys: shp_201, shp_214, shp_219.'
- id: data_grid_row_selection-mantine-T07
  name: Select rows in the correct table instance (timesheet)
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite x2 (form section)
  implementation_component: 'Mantine: Table + Checkbox (composed selection) x2'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Non-billable hours table, select entries NB-04 and NB-07. Do not select anything in Billable hours. The task will finish automatically when done.
  ui_copy: Timesheet — Billable hours | Non-billable hours. Select NB-04 and NB-07 in Non-billable.
  setup_description: |-
    The page is a form_section titled "Weekly timesheet". It contains two stacked sections, each with a Mantine Table and checkbox-based row selection (composed):
      • "Billable hours" table
      • "Non-billable hours" table
    Both tables use the same layout and similar entry IDs (B-04 vs NB-04), increasing the chance of selecting the wrong instance.
    Spacing is comfortable and scale is default. Light clutter includes two read-only summary fields above (Total hours, Week).
    Initial state: no rows selected in either table; selection is immediate (no Apply).
    The target entries NB-04 and NB-07 exist only in the Non-billable hours table.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 4
      disambiguation_load: 4
    justification: Two visually similar table instances with confusable IDs significantly increases disambiguation load.
  success_trigger:
    human_readable:
    - The check is applied to the "Non-billable hours table" grid instance only.
    - The selected row IDs equal ['nb_NB04', 'nb_NB07'].
    - No rows are selected in Billable hours.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - nb_NB04
        - nb_NB07
        other_instances_selected_row_ids:
          Billable hours table: []
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Non-billable hours table
      terminal_condition: true
  negative_cases:
  - Selections are made in Billable hours (wrong instance).
  - Only one of NB-04/NB-07 is selected in Non-billable hours.
  - Extra entries are selected in either table.
  expected_interaction_path:
  - Locate the Non-billable hours section.
  - Check the boxes for NB-04 and NB-07 in that table.
  - Ensure Billable hours remains unselected.
  notes: 'Add stable container IDs for each table (e.g., data-testid=''billable-grid'', ''nonbillable-grid''). Row keys: nb_NB04, nb_NB07.'
- id: data_grid_row_selection-mantine-T08
  name: Select all except two using indeterminate header checkbox
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite (select-all header, compact spacing)
  implementation_component: 'Mantine: Table + Checkbox (with indeterminate) composed selection'
  task_template: select_many
  secondary_template: null
  browsergym_goal: In the Accounts table, select all rows except SYS (System) and ADM (Admin). The task will finish automatically when done.
  ui_copy: Accounts — Select all except SYS (System) and ADM (Admin).
  setup_description: |-
    A centered isolated card titled "Accounts" contains a Mantine Table with a selection Checkbox in the header (select-all) and one Checkbox per row.
    The page is in compact spacing mode (tighter row height). The header checkbox supports an indeterminate state when some but not all rows are selected.
    The table shows 12 rows with columns: Account ID, Name, Type. Two special rows are SYS (System) and ADM (Admin); the other 10 rows are regular accounts A-01 through A-10.
    Initial state: no rows selected. There is no pagination and selection updates immediately.
    The intended interaction is: select all, then deselect SYS and ADM (or equivalently, select only the 10 regular accounts).
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 2
    justification: Requires managing a large selection set and correctly leaving out two specific rows; compact density raises misclick risk.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['acct_A01', 'acct_A02', 'acct_A03', 'acct_A04', 'acct_A05', 'acct_A06', 'acct_A07', 'acct_A08', 'acct_A09', 'acct_A10'].
    - SYS and ADM are not selected; all A-01 through A-10 are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - acct_A01
        - acct_A02
        - acct_A03
        - acct_A04
        - acct_A05
        - acct_A06
        - acct_A07
        - acct_A08
        - acct_A09
        - acct_A10
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - SYS (System) is selected.
  - ADM (Admin) is selected.
  - Any regular account A-01..A-10 is missing from the selection.
  - Extra rows are selected beyond the intended set (should be impossible, but still disallowed).
  expected_interaction_path:
  - Click the header select-all checkbox to select all rows.
  - Uncheck SYS (System) and ADM (Admin) row checkboxes.
  - Verify all A-01..A-10 remain selected.
  notes: Implement header checkbox indeterminate state using Mantine Checkbox indeterminate support; checker should verify exact selected IDs set.
- id: data_grid_row_selection-mantine-T09
  name: Small-scale search then select in a long table
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite + search filter (small scale)
  implementation_component: 'Mantine: TextInput (search) + Table + Checkbox (composed selection)'
  task_template: search_and_select
  secondary_template: null
  browsergym_goal: Use the search box to find EMP-22 (Mila Torres) and select that row in the Directory table. The task will finish automatically when done.
  ui_copy: Directory — Search employees… — Select EMP-22 (Mila Torres).
  setup_description: |-
    The page is an isolated card centered in the viewport titled "Directory" rendered at a small scale (smaller fonts and tighter controls).
    Above the Mantine Table is a TextInput labeled "Search employees…" that filters the table rows as you type (client-side filter).
    The table uses a composed checkbox selection column. It contains 40 employee rows with columns: Employee ID, Name, Location.
    Initial state: no rows selected and the search input is empty.
    There are confusable names such as "Mila Torres" and "Mila Torres-Gray"; the target is uniquely identified by Employee ID EMP-22.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: small
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 2
    justification: Small-scale controls plus a search/filter step and confusable names increases acquisition difficulty and selection mistakes.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['emp_EMP22'].
    - No other directory rows are selected.
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - emp_EMP22
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - A different Mila row is selected (wrong employee ID).
  - Multiple employees are selected.
  - Search is used but no selection is made.
  expected_interaction_path:
  - Click the search input and type 'EMP-22' or 'Mila'.
  - Select the row EMP-22 (Mila Torres) by clicking its checkbox.
  notes: Search input is non-essential for checker; success depends only on final selected IDs. Provide data-row-id='emp_EMP22'.
- id: data_grid_row_selection-mantine-T10
  name: 'Dark dashboard: match pinned incidents and apply'
  canonical_type: data_grid_row_selection
  implementation_source: mantine
  implementation_variant: composite (dark dashboard + Apply)
  implementation_component: 'Mantine: Table + Checkbox (composed selection) + Button'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: In the Incidents table, select the rows that match the three pinned incident cards, then click Apply. The task will finish automatically when done.
  ui_copy: 'Incidents — Pinned incidents: INC-709, INC-712, INC-728 — Apply'
  setup_description: |-
    The scene is a dashboard in dark theme. The main card is titled "Incidents" and contains:
      • A left area with a Mantine Table that has a composed checkbox selection column.
      • A right side panel titled "Pinned incidents" showing three compact cards with incident IDs (INC-709, INC-712, INC-728) and a small severity icon.
    Below the table is a sticky action bar with a primary button labeled "Apply".
    Spacing is comfortable and scale is default. The incidents table has 25 rows with columns: Incident ID, Service, Updated.
    Initial state: no incidents selected. Many IDs are similar (INC-728 vs INC-729), and the dark theme reduces contrast, increasing misread risk.
    Selection is only committed when Apply is clicked; after Apply, a toast "Selection applied" appears (feedback). Guidance is mixed: match the pinned (visual) cards to the table IDs.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 4
      depth_layering: 2
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 3
    justification: Dark, cluttered dashboard plus mixed reference matching and an Apply commit step increases both error likelihood and recovery cost.
  success_trigger:
    human_readable:
    - The selected row IDs equal ['inc_709', 'inc_712', 'inc_728'].
    - Selection is committed after Apply (toast/committed flag present).
    canonical_predicate:
      predicate_type: equals
      target_state:
        selected_row_ids:
        - inc_709
        - inc_712
        - inc_728
      tolerance: null
      require_confirm: true
      confirm_control: Apply
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: true
  negative_cases:
  - The correct rows are selected but Apply is not clicked (not confirmed).
  - A near-miss incident (e.g., INC-729) is selected instead of INC-728.
  - Extra incidents are selected beyond the three pinned targets.
  expected_interaction_path:
  - Read the three incident IDs in the 'Pinned incidents' panel.
  - In the table, check the boxes for INC-709, INC-712, and INC-728.
  - Click 'Apply' in the sticky action bar.
  notes: Checker should gate success on committed selection state and exact selected IDs set. Pin panel is non-interactive; it only provides reference.