tasks/v1/clipboard_copy.yaml

- id: clipboard_copy-antd-T01
  name: Copy invite code (inline text)
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the invite code INV-48219 to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: 'Invite code: INV-48219 (use the copy icon to copy it).'
  setup_description: |
    Layout: isolated_card, centered in the viewport.
    The card title is “Team invitations”. Under the title there is a single row labeled “Invite code”.
    To the right of the invite code value (shown as monospace text “INV-48219”) there is an Ant Design Typography copy icon (copyable Text).

    Component behavior:
    - Clicking the copy icon writes the full invite code to the clipboard and shows a small “Copied” tooltip/toast near the icon for ~2 seconds.
    - No additional confirmation is required.

    Distractors: none (only explanatory text below the row). Initial state: nothing has been copied yet (no “Copied” tooltip visible).
  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: 2
      disambiguation_load: 1
    justification: Single visible value with a standard inline copy icon; success is immediate with clear 'Copied' feedback.
  success_trigger:
    human_readable:
    - Clipboard text equals "INV-48219".
    - No confirmation is required (copy occurs on icon click).
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: INV-48219
      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:
  - Clipboard contains any other text (including extra whitespace or a different invite code).
  - User clicks around but does not trigger the copy action (clipboard unchanged).
  expected_interaction_path:
  - Locate the Invite code row.
  - Click the copy icon next to INV-48219.
  - Optionally observe the 'Copied' tooltip.
  notes: 'Instrumentation: attach a data-testid to the copy icon (e.g., data-testid=''copy-invite-code'') and log last copied value for the checker.'
- id: clipboard_copy-antd-T02
  name: Copy tracking number from reference badge
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Copy the tracking number shown in the Reference badge to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: Reference badge shows a tracking number. Tracking number row has a copy icon.
  setup_description: |
    Layout: isolated_card, centered.
    The card is titled “Shipment summary”. At the top of the card there is a colored badge labeled “Reference” that displays the target tracking number in large monospace text: “TRK-90817”.

    Below the badge there is one row labeled “Tracking number”. The same value “TRK-90817” is displayed as Ant Design Typography.Text with the copyable icon at the end.

    Component behavior:
    - Clicking the copy icon copies the full tracking number.
    - A small tooltip “Copied” appears next to the icon briefly. No Apply/OK step.

    Distractors: none. Initial state: not copied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Only one copyable field; the target is visually provided by a prominent Reference badge and the copy feedback is immediate.
  success_trigger:
    human_readable:
    - Clipboard text equals "TRK-90817" (the tracking number shown in the Reference badge).
    - No confirmation is required.
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: TRK-90817
      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:
  - Clipboard contains a different tracking number or any extra characters.
  - Copy action not triggered (clipboard unchanged).
  expected_interaction_path:
  - Read the tracking number from the Reference badge (TRK-90817).
  - Click the copy icon in the Tracking number row.
  - Optionally confirm the 'Copied' tooltip appears.
  notes: Checker can also cross-validate that the copied text matches the Reference badge text at runtime to guard against accidental page edits.
- id: clipboard_copy-antd-T03
  name: Copy Secondary API key (two fields)
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the Secondary API key KEY-SECONDARY-7F2 to your clipboard using the copy icon next to it. The task will finish automatically when done.
  ui_copy: 'API keys: Primary and Secondary, each with its own copy icon.'
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “API keys”. It contains two stacked rows:
    1) “Primary API key” with value “KEY-PRIMARY-4C9”
    2) “Secondary API key” with value “KEY-SECONDARY-7F2”

    Each value is rendered as Ant Design Typography.Text with the copyable icon at the end of the line.
    Component behavior: clicking a row’s copy icon writes that row’s value to the clipboard and shows a short “Copied” tooltip near the icon.

    Distractors: a short help paragraph below explaining what API keys are. Initial state: neither key has been copied.
    Requirement: there are 2 instances of the clipboard_copy component; the target is the “Secondary API key” row.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar copy icons require choosing the correct labeled row, but values are clearly visible and feedback is immediate.
  success_trigger:
    human_readable:
    - Clipboard text equals "KEY-SECONDARY-7F2".
    - The copy action must originate from the “Secondary API key” instance (not Primary).
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: KEY-SECONDARY-7F2
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Secondary API key
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Primary API key (clipboard becomes KEY-PRIMARY-4C9).
  - Copying a value that matches the target text but from the wrong instance (if values ever collide).
  - Not triggering a copy action (clipboard unchanged).
  expected_interaction_path:
  - Locate the 'Secondary API key' row.
  - Click the copy icon at the end of that row.
  - Optionally observe 'Copied'.
  notes: 'Instrumentation: each copy icon should have a stable instance id (e.g., data-testid=''copy-primary'', ''copy-secondary'') so the checker can verify correct-instance.'
- id: clipboard_copy-antd-T04
  name: Copy Support ID from profile form
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the Support ID SUP-13579 to your clipboard using the copy control next to it. The task will finish automatically when done.
  ui_copy: Profile form includes a read-only Support ID with a copy icon.
  setup_description: |
    Layout: form_section, centered.
    The page shows a “Profile” form with several standard inputs (Name, Email, Time zone) and two buttons at the bottom (“Save” and “Cancel”) that are present only as clutter.

    The clipboard_copy component appears in a read-only row labeled “Support ID”.
    - The value “SUP-13579” is displayed as Ant Design Typography.Text.
    - A copyable icon is shown at the end of the value.

    Component behavior:
    - Clicking the copy icon writes “SUP-13579” to the clipboard and shows a brief “Copied” tooltip.
    - Save/Cancel buttons do nothing relevant to the task.

    Initial state: nothing copied yet; no tooltips visible.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    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: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Slightly cluttered form context, but only one copy control is present and the target value is clearly labeled.
  success_trigger:
    human_readable:
    - Clipboard text equals "SUP-13579".
    - No confirmation is required.
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: SUP-13579
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking Save/Cancel without copying (clipboard unchanged).
  - Clipboard contains any text other than SUP-13579.
  expected_interaction_path:
  - Find the Support ID row in the form.
  - Click the copy icon next to SUP-13579.
  notes: Consider adding an aria-label like 'Copy Support ID' to the icon button for accessibility and easier AX-based agents.
- id: clipboard_copy-antd-T05
  name: Reveal-on-hover copy for truncated token
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable, ellipsis)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Copy the access token tok_live_7c8a1f3e9d2b to your clipboard, then paste it into the verification input and click Verify. The copy icon may only appear when you hover the token row. The task will finish automatically when done.
  ui_copy: Access token is displayed with ellipsis; copy icon appears on hover. Paste into verify input to confirm.
  setup_description: |
    Layout: isolated_card anchored near the top-right of the viewport (placement=top_right).
    The card title is “Developer access”. It contains a single row labeled “Access token”.

    The token is long and displayed with Typography.Text ellipsis, so only the beginning is visible, e.g. “tok_live_7c8a1…”.
    The copy icon (Typography copyable control) is hidden until the user hovers/focuses the token line; on hover it fades in at the end of the row.

    Component behavior:
    - Clicking the revealed copy icon copies the FULL underlying token value “tok_live_7c8a1f3e9d2b” (not the truncated rendering).
    - A small “Copied” tooltip appears.

    Below the token row there is a verification section: an input field ("Paste token here") and a "Verify" button.
    The user must paste the copied token into the input and click Verify to confirm success.

    Distractors: none. Initial state: copy icon hidden until hover; nothing copied; verify input empty.
  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: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 1
    justification: The copy affordance is disclosed only on hover and the value is visually truncated, increasing acquisition and observability difficulty.
  success_trigger:
    human_readable:
    - Verification input value equals the full token "tok_live_7c8a1f3e9d2b" after clicking Verify.
    - Task ends when the verify button is clicked and the input matches.
    canonical_predicate:
      predicate_type: equals
      target_state:
        verify_input_text: tok_live_7c8a1f3e9d2b
      tolerance: null
      require_confirm: true
      confirm_control: verify_button
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Pasting only the visible truncated substring instead of the full token.
  - Failing to reveal/click the copy icon and typing the token manually with a typo.
  - Clicking Verify with an empty or partial input.
  expected_interaction_path:
  - Move mouse over the Access token row to reveal the copy icon.
  - Click the copy icon.
  - Optionally observe the 'Copied' tooltip.
  notes: 'Implementation note: keep the full token in the DOM (e.g., data-full-value) so the copy handler and checker can access it even when visually ellipsized.'
- id: clipboard_copy-antd-T06
  name: Copy token from modal details
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Modal + Typography.Text (copyable)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the details dialog and copy the Personal token PAT-44F8-19D2 to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: A 'View token' button opens a dialog containing the Personal token with a copy icon.
  setup_description: |
    Layout: modal_flow, centered.
    The page shows a card titled “Personal access”. In the card there is a primary button labeled “View token”.

    When “View token” is clicked, an Ant Design Modal opens (centered overlay). Inside the modal:
    - A row labeled “Personal token” displays the value “PAT-44F8-19D2” in monospace Typography.Text.
    - The value has a copyable icon at the end (clipboard_copy component).
    - The modal has standard “Close” (X) in the corner and a footer button “Done” (both are distractors; either can close the modal).

    Component behavior:
    - The copy action is performed by clicking the copy icon next to the token.
    - After copying, a small “Copied” tooltip appears next to the icon; the modal remains open.

    Initial state: modal is closed; token is not visible until the modal is opened.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a modal overlay before the copy control is available; feedback is transient and the overlay adds interaction depth.
  success_trigger:
    human_readable:
    - Clipboard text equals "PAT-44F8-19D2".
    - No additional confirmation beyond triggering the copy action.
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: PAT-44F8-19D2
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opening the modal but not copying the token (clipboard unchanged).
  - Copying any other text (e.g., selecting and copying the label).
  expected_interaction_path:
  - Click 'View token' to open the modal.
  - In the modal, click the copy icon next to PAT-44F8-19D2.
  notes: Checker should ignore closing the modal; success depends only on clipboard content.
- id: clipboard_copy-antd-T07
  name: Scroll to Webhooks section and copy secret
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable) in settings panel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll to the Webhooks section and copy the signing secret whsec_9A2D7C11 to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: Settings panel with multiple sections; Webhooks section contains Signing secret with a copy icon.
  setup_description: |
    Layout: settings_panel, centered. The page is taller than the viewport.
    A vertical settings panel contains multiple sections stacked top-to-bottom:
    - General
    - Notifications
    - Security
    - Webhooks (this one is near the bottom, below the fold)

    Each section has a heading and a few irrelevant toggles/inputs as clutter (they are not required for success).
    In the Webhooks section there is a row labeled “Signing secret” with value “whsec_9A2D7C11”.
    The value is displayed as Typography.Text with a copyable icon (clipboard_copy component).

    Component behavior:
    - Clicking the copy icon copies the signing secret and shows a brief “Copied” tooltip.

    Initial state: page starts scrolled near the top (General section visible). Webhooks section is not visible until scrolling down.
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires scrolling and locating the correct section among several similar settings sections before performing a standard copy action.
  success_trigger:
    human_readable:
    - Clipboard text equals "whsec_9A2D7C11".
    - No confirmation is required.
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: whsec_9A2D7C11
      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:
  - Copying a different value from another section (e.g., a support email).
  - Scrolling but not triggering the copy control (clipboard unchanged).
  expected_interaction_path:
  - Scroll down until the Webhooks section heading is visible.
  - Find the Signing secret row.
  - Click its copy icon.
  notes: 'Robustness: ensure headings are actual text nodes so agents can scroll-find via OCR/AX.'
- id: clipboard_copy-antd-T08
  name: Copy STAGING webhook URL from table
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Table cell with Typography.Text (copyable)'
  task_template: activate
  secondary_template: null
  browsergym_goal: In the Environments table, copy the webhook URL from the STAGING row to your clipboard. The task will finish automatically when done.
  ui_copy: Environments table with DEV, STAGING, PROD rows; each row has a webhook URL with a copy icon.
  setup_description: |
    Layout: table_cell, anchored near the bottom-right of the viewport.
    The page shows an Ant Design Table titled “Environments”. The table has 3 rows:
    - DEV (green tag)
    - STAGING (orange tag)
    - PROD (red tag)

    Columns:
    1) Environment (tag + label)
    2) Webhook URL (long URL rendered with ellipsis)
    3) Action (a small copyable icon at the end of the URL text)

    Each row’s Webhook URL is an Ant Design Typography.Text with copyable icon. URLs are distinct:
    - DEV: https://hooks.example.com/dev/2b7c0e
    - STAGING: https://hooks.example.com/stg/9f2c1a
    - PROD: https://hooks.example.com/prod/51aa0d

    Component behavior:
    - Clicking the copy icon for a given row copies that row’s FULL URL.
    - A brief “Copied” tooltip appears near the clicked icon.

    Distractors: column sorting arrows and a search input above the table (not required). Initial state: no copies performed.
    Requirement: instances=3 (one per row). Target instance is the STAGING row.
  scene_context:
    theme: light
    spacing: comfortable
    layout: table_cell
    placement: bottom_right
    scale: default
    instances: 3
    guidance: mixed
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Small copy targets inside a dense table and three similar rows require careful disambiguation; URLs are visually truncated with ellipsis.
  success_trigger:
    human_readable:
    - Clipboard text equals "https://hooks.example.com/stg/9f2c1a".
    - The copy action must originate from the STAGING row instance (not DEV/PROD).
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: https://hooks.example.com/stg/9f2c1a
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: STAGING row
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the DEV or PROD webhook URL instead of STAGING.
  - Copying only the truncated visible portion of the URL (if a fallback copy occurs).
  - Interacting with table sort/search without copying (clipboard unchanged).
  expected_interaction_path:
  - Locate the Environments table and find the STAGING row.
  - Click the copy icon associated with the STAGING Webhook URL.
  notes: 'Instrumentation: give each row a stable key (dev/staging/prod) and log lastCopySourceKey when copy triggers.'
- id: clipboard_copy-antd-T09
  name: Copy Billing reference in dark compact panel
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable) in compact mode'
  task_template: activate
  secondary_template: null
  browsergym_goal: In the Billing section, copy the Billing reference BILL-REF-60218 to your clipboard using its copy icon. The task will finish automatically when done.
  ui_copy: Billing panel (dark, compact) shows Billing reference and Shipping reference, each with a copy icon.
  setup_description: |
    Layout: settings_panel, centered.
    Universal factors: theme=dark, spacing=compact, scale=small.

    The page is a “Checkout settings” panel with two adjacent compact cards in a single column:
    - Card A: “Billing”
    - Card B: “Shipping”

    Each card contains a labeled reference value rendered as small monospace Typography.Text with a copyable icon:
    - Billing card: “Billing reference” value “BILL-REF-60218”
    - Shipping card: “Shipping reference” value “SHIP-REF-60218”

    The copy icons are small and close to the text due to compact spacing. A subtle tooltip “Copied” appears on success.

    Distractors: a couple of disabled toggles (e.g., “Enable VAT”) inside each card; not required.
    Requirement: instances=2; target instance is the “Billing reference” in the Billing card.
  scene_context:
    theme: dark
    spacing: compact
    layout: settings_panel
    placement: center
    scale: small
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Dark theme plus compact/small styling makes the copy affordance harder to acquire, and the two similar references increase disambiguation load.
  success_trigger:
    human_readable:
    - Clipboard text equals "BILL-REF-60218".
    - Copy must come from the Billing reference instance (not Shipping).
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: BILL-REF-60218
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Billing reference
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Shipping reference (SHIP-REF-60218).
  - Clicking near the icon but missing it (no clipboard change).
  - Copying only part of the reference due to selection instead of the copy icon.
  expected_interaction_path:
  - Find the Billing card and locate the Billing reference row.
  - Click the small copy icon next to BILL-REF-60218.
  notes: Add clear labels/aria-labels like 'Copy billing reference' to help accessibility-tree agents in dark/compact mode.
- id: clipboard_copy-antd-T10
  name: Confirm copying recovery codes
  canonical_type: clipboard_copy
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (copyable) + Modal confirmation'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Copy the recovery codes to your clipboard. When prompted, click “Copy anyway” to confirm. The task will finish automatically when done.
  ui_copy: Security card shows Recovery codes with a copy icon; clicking it asks for confirmation before copying.
  setup_description: |2
            Layout: modal_flow, centered.
            The page shows a “Security” card with a section titled “Recovery codes”. The codes are displayed in a preformatted block (3 lines).
            Next to the section header there is a small copy icon (clipboard_copy control) styled like Ant Design’s copyable affordance.

            Confirmation flow (sensitive copy):
            - Clicking the copy icon does NOT immediately write to the clipboard.
            - Instead, an Ant Design Modal appears titled “Copy recovery codes?” with warning text.
            - The modal has two buttons: “Cancel” and a primary “Copy anyway”.
            - Only clicking “Copy anyway” performs the clipboard write of the full multi-line recovery code block.
            - After copying, a toast “Copied” appears; the modal auto-closes.

            Initial state: modal closed; nothing copied.
            Target clipboard text (exact, including newlines):
            RCV-9911-ALPHA
    RCV-9912-BRAVO
    RCV-9913-CHARLIE
  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: 2
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 2
    justification: Copy requires a confirmation modal with an explicit 'Copy anyway' action; the copied value is multi-line, increasing observability and feedback complexity.
  success_trigger:
    human_readable:
    - User confirms the sensitive-copy dialog by clicking “Copy anyway”.
    - Clipboard text equals the full recovery-code block exactly (3 lines).
    - Task ends when the predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: |-
          RCV-9911-ALPHA
          RCV-9912-BRAVO
          RCV-9913-CHARLIE
      tolerance: null
      require_confirm: true
      confirm_control: Copy anyway
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Dismissing the dialog with Cancel or closing it (no copy performed).
  - Copying only a single line instead of the full block.
  - Copying the block but failing to press “Copy anyway” (if the icon click alone is attempted).
  expected_interaction_path:
  - Click the copy icon next to the Recovery codes header.
  - In the modal, click 'Copy anyway'.
  - Optionally observe the 'Copied' toast.
  notes: Checker should verify that the clipboard write event occurs after confirm, not on the initial icon click (to enforce require_confirm semantics).
- id: clipboard_copy-mui-T01
  name: Copy order ID (IconButton)
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: IconButton + Tooltip (navigator.clipboard.writeText)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the order ID ORD-77104 to your clipboard using the copy icon button. The task will finish automatically when done.
  ui_copy: Order details card shows Order ID ORD-77104 with a copy icon button.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Order details”. It shows a labeled value row:
    - Label: “Order ID”
    - Value: “ORD-77104”
    - To the right of the value is a Material UI IconButton with a copy glyph (e.g., ContentCopy icon) and a Tooltip that reads “Copy”.

    Implementation note: MUI does not ship a dedicated CopyButton component, so this is a composite built from IconButton + Tooltip and a copy handler that calls navigator.clipboard.writeText(value).

    Component behavior:
    - Clicking the copy IconButton writes “ORD-77104” to the clipboard.
    - The icon briefly changes state (e.g., checkmark) and/or shows a small “Copied” snackbar message at the bottom.

    Distractors: none. Initial state: not copied; snackbar hidden.
  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: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single IconButton with standard tooltip; one visible value to copy and immediate snackbar feedback.
  success_trigger:
    human_readable:
    - Clipboard text equals "ORD-77104".
    - No confirmation step is required.
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: ORD-77104
      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:
  - Clipboard contains any other text.
  - Hovering the tooltip without clicking the IconButton (clipboard unchanged).
  expected_interaction_path:
  - Locate the Order ID row.
  - Click the copy IconButton next to ORD-77104.
  notes: 'Instrumentation: expose the copied value via window.__lastClipboardWrite for deterministic checking instead of relying on OS clipboard permissions.'
- id: clipboard_copy-mui-T02
  name: Copy share link (Button)
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Button (Copy) + Snackbar (navigator.clipboard.writeText)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the share link https://share.example.com/s/AB12CD to your clipboard using the Copy link button. The task will finish automatically when done.
  ui_copy: A 'Copy link' button copies the share link shown on the card.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Share this page”. It displays the full share URL as text:
    https://share.example.com/s/AB12CD

    Below the URL there is a prominent Material UI Button labeled “Copy link” (with a copy icon).
    Clicking the button triggers a copy handler that uses navigator.clipboard.writeText(url) and shows a bottom Snackbar: “Link copied”.

    Distractors: a secondary button “Open in new tab” (does nothing relevant) and a short help sentence.
    Initial state: snackbar hidden; nothing copied.
  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: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Large, clearly labeled button with a single obvious target value; feedback via snackbar confirms success.
  success_trigger:
    human_readable:
    - Clipboard text equals "https://share.example.com/s/AB12CD".
    - Task ends when the clipboard predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: https://share.example.com/s/AB12CD
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking 'Open in new tab' without copying.
  - Clipboard contains a truncated or modified URL.
  expected_interaction_path:
  - Click the 'Copy link' button.
  notes: Composite copy control should have aria-label 'Copy link' for IconButton equivalents.
- id: clipboard_copy-mui-T03
  name: Copy Shipping reference (two instances)
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: IconButton copy controls in form section (composite)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the Shipping reference SHIP-MUI-33018 to your clipboard using the copy icon next to it. The task will finish automatically when done.
  ui_copy: Form shows Billing reference and Shipping reference, each with a copy icon.
  setup_description: |
    Layout: form_section, centered.
    A “Checkout” form shows two read-only rows:
    - Billing reference: BILL-MUI-33018
    - Shipping reference: SHIP-MUI-33018

    Each row has a small MUI IconButton with a copy icon to the right. Clicking an IconButton copies the row’s value using navigator.clipboard.writeText and shows a small inline helper text “Copied”.

    Distractors: editable fields above (Name, Address) that are present but not required; they do not affect success. Initial state: helper texts hidden.
    Requirement: instances=2; target instance is “Shipping reference”.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar copy icons require selecting the correct labeled row, but the values are short and clearly displayed.
  success_trigger:
    human_readable:
    - Clipboard text equals "SHIP-MUI-33018".
    - Copy must originate from the Shipping reference instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: SHIP-MUI-33018
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Shipping reference
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Billing reference (BILL-MUI-33018).
  - Clicking in the form but not pressing the copy IconButton (clipboard unchanged).
  expected_interaction_path:
  - Find the Shipping reference row.
  - Click the copy icon on that row.
  notes: 'Ensure each IconButton has distinct aria-labels: ''Copy billing reference'' vs ''Copy shipping reference''.'
- id: clipboard_copy-mui-T04
  name: Hover to reveal copy on code snippet
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Code block with hover-revealed IconButton (composite)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Copy the install command "npm install @acme/sdk@2.1.0" to your clipboard. The copy icon appears when you hover the code block. The task will finish automatically when done.
  ui_copy: A code block shows an install command; copy icon button appears on hover.
  setup_description: |
    Layout: isolated_card anchored at the top-left (placement=top_left).
    The card title is “Quick start”. It contains a single code block showing:
        npm install @acme/sdk@2.1.0

    A small MUI IconButton with a copy icon is positioned in the top-right corner of the code block, but it is only visible on hover/focus of the code block (disclosed affordance).

    Component behavior:
    - Clicking the revealed IconButton copies the full command string to the clipboard (navigator.clipboard.writeText).
    - A small Tooltip changes from “Copy” to “Copied”.

    Distractors: a short paragraph above the code block. Initial state: IconButton hidden; tooltip state “Copy”.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Copy control is hidden until hover and requires precise acquisition of a small icon inside a code block.
  success_trigger:
    human_readable:
    - Clipboard text equals "npm install @acme/sdk@2.1.0".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: npm install @acme/sdk@2.1.0
      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:
  - Copy icon never revealed/clicked (clipboard unchanged).
  - Copying only part of the command due to text selection rather than the copy button.
  expected_interaction_path:
  - Hover over the code block to reveal the copy IconButton.
  - Click the copy IconButton.
  notes: For AX observability, ensure the IconButton is in the DOM and only visually hidden (not display:none) so screen readers/agents can find it.
- id: clipboard_copy-mui-T05
  name: Open Share popover and copy invite link
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Button + Popover with copy action (composite)'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Share popover and copy the invite link to your clipboard. The task will finish automatically when done.
  ui_copy: A Share button opens a popover that contains a 'Copy invite link' control.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Invite teammates”. It has a single button labeled “Share”.

    Clicking “Share” opens a Material UI Popover anchored to the button. Inside the popover:
    - A read-only text field shows the invite link: https://invite.example.com/join/7Q9P
    - To the right of the field is a copy IconButton (clipboard_copy component).
    - A small helper text under the field explains “Anyone with this link can join”.

    Component behavior:
    - Clicking the copy IconButton writes the invite link to the clipboard.
    - A snackbar appears: “Invite link copied”.
    - No separate Apply/OK is required; closing the popover is optional.

    Distractors: the popover also contains a secondary button “Email invite” that is irrelevant.
    Initial state: popover closed.
  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: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a popover overlay to access the copy control; small icon target and transient snackbar feedback.
  success_trigger:
    human_readable:
    - Clipboard text equals "https://invite.example.com/join/7Q9P".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: https://invite.example.com/join/7Q9P
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opening the Share popover but not copying the link (clipboard unchanged).
  - Copying from the wrong control (e.g., selecting and copying helper text).
  expected_interaction_path:
  - Click 'Share' to open the popover.
  - Click the copy IconButton next to the invite link.
  notes: Popover should trap focus lightly but not require closing; success depends only on the copy action.
- id: clipboard_copy-mui-T06
  name: Scroll to Session token card and copy
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Card + IconButton copy (composite)'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: Scroll down and copy the Session token sess_3F9C-88AA to your clipboard using its copy icon. The task will finish automatically when done.
  ui_copy: A long dashboard page; Session token card (below the fold) includes a copy icon.
  setup_description: |
    Layout: dashboard, centered. The dashboard is longer than the viewport.
    The top of the page shows several summary cards (Usage, Status, Alerts) that are distractors.

    Below the fold there is a card titled “Session token”. Inside it:
    - A monospace token value “sess_3F9C-88AA”
    - A small copy IconButton aligned to the right of the token (clipboard_copy component)
    - A caption: “Use this token for support requests” (distractor)

    Component behavior:
    - Clicking the IconButton copies the token (navigator.clipboard.writeText).
    - A snackbar “Token copied” appears at the bottom for ~2 seconds.

    Initial state: page loads at top; Session token card not visible until scrolling.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires scrolling on a dashboard with multiple cards; once found, the copy action is straightforward.
  success_trigger:
    human_readable:
    - Clipboard text equals "sess_3F9C-88AA".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: sess_3F9C-88AA
      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:
  - Copying a value from a different dashboard card.
  - Scrolling but not clicking the copy icon (clipboard unchanged).
  expected_interaction_path:
  - Scroll down until the Session token card is visible.
  - Click the copy IconButton next to sess_3F9C-88AA.
  notes: Ensure dashboard cards have clear headings to support scroll_find strategies.
- id: clipboard_copy-mui-T07
  name: Copy the token matching the Reference chip
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: List rows + IconButton copy (composite)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Copy the API token that matches the Reference chip to your clipboard using the copy icon on that row. The task will finish automatically when done.
  ui_copy: Reference chip indicates target; three similar token rows each have a copy icon.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Active API tokens”. At the top of the card there is a prominent chip labeled “Reference” showing the target token in full:
    - Reference: tk_7F12-6D9A

    Below the chip there is a list of three token rows. Each row shows the token (monospace) and an IconButton copy control at the end:
    1) tk_7F12-6D8A
    2) tk_7F12-6D9A   (this is the target)
    3) tk_7F12-6D9B

    Component behavior:
    - Clicking a row’s copy IconButton copies that row’s full token value to the clipboard.
    - A small inline “Copied” tooltip appears on the clicked button.

    Distractors: a “Revoke” text link on each row (does nothing in this benchmark).
    Requirement: instances=3; target instance is the row whose token matches the Reference chip.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 3
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires matching a visually provided reference token to one of several similar rows and clicking a small copy icon.
  success_trigger:
    human_readable:
    - Clipboard text equals "tk_7F12-6D9A".
    - Copy must originate from the matching token row (correct instance).
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: tk_7F12-6D9A
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Token row tk_7F12-6D9A
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying tk_7F12-6D8A or tk_7F12-6D9B.
  - Clicking the Revoke link instead of copying (clipboard unchanged).
  expected_interaction_path:
  - Read the token value shown in the Reference chip.
  - Find the matching token row in the list.
  - Click that row’s copy IconButton.
  notes: Make sure list rows have stable data-ids so the checker can validate source instance.
- id: clipboard_copy-mui-T08
  name: Open Copy menu and select API key
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Button + Menu items that trigger clipboard writes (composite)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the “Copy…” menu and select the option that copies the API key API-PROD-9X2K to your clipboard. The task will finish automatically when done.
  ui_copy: A 'Copy…' button opens a menu with several copy options (User ID, Email, API key, etc.).
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Account”. On the right side of the card header there is a Material UI Button labeled “Copy…” with a dropdown arrow.

    Clicking “Copy…” opens a MUI Menu (popover). The menu contains 6 items, each item copies a different value:
    - Copy User ID → user_4821
    - Copy Email → alex@example.com
    - Copy API key → API-PROD-9X2K   (target)
    - Copy Workspace ID → ws_113
    - Copy Billing ID → bill_993
    - Copy Support PIN → PIN-2049

    Component behavior:
    - Selecting a menu item immediately writes the corresponding value to the clipboard and closes the menu.
    - A snackbar appears: “Copied to clipboard”.

    Distractors: an “Edit profile” button in the card body (irrelevant).
    Initial state: menu closed; nothing copied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a menu overlay and choosing the correct option among multiple similar copy actions.
  success_trigger:
    human_readable:
    - Clipboard text equals "API-PROD-9X2K".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: API-PROD-9X2K
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting the wrong menu item (clipboard becomes user_4821 / alex@example.com / etc.).
  - Opening the menu but not selecting any item (clipboard unchanged).
  - Closing the menu without copying.
  expected_interaction_path:
  - Click the 'Copy…' button to open the menu.
  - Click 'Copy API key'.
  - Optionally observe the snackbar.
  notes: For checkers, log both lastCopiedValue and lastCopiedActionLabel (e.g., 'Copy API key') to debug mis-selections.
- id: clipboard_copy-mui-T09
  name: Copy Production base URL from compact table
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Table rows + IconButton copy (composite)'
  task_template: activate
  secondary_template: null
  browsergym_goal: In the Environments table, copy the Production base URL https://api.example.com/prod/v1 to your clipboard using the copy icon in that row. The task will finish automatically when done.
  ui_copy: Compact table with Dev/Staging/Production rows; each row has a copy icon for the Base URL.
  setup_description: |
    Layout: table_cell, anchored near the bottom-left (placement=bottom_left).
    Universal factors: spacing=compact, scale=small.

    The page contains a compact MUI Table labeled “Environments” with three rows (Dev, Staging, Production). Column “Base URL” shows a URL string and a small IconButton copy control in the same cell.
    - Dev: https://api.example.com/dev/v1
    - Staging: https://api.example.com/staging/v1
    - Production: https://api.example.com/prod/v1  (target)

    Component behavior:
    - Clicking the copy IconButton in a row copies that row’s full Base URL and shows a snackbar “Copied”.

    Distractors: column sort icons and a pagination footer (not required).
    Requirement: instances=3; target instance is the Production row’s copy icon.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_left
    scale: small
    instances: 3
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: Small copy icons inside a compact table require precise targeting and correct row selection among similar environment entries.
  success_trigger:
    human_readable:
    - Clipboard text equals "https://api.example.com/prod/v1".
    - Copy must originate from the Production row instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: https://api.example.com/prod/v1
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Production row
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Dev or Staging base URL.
  - Clicking the URL text without clicking the copy IconButton (clipboard unchanged).
  - Copying a truncated display if the cell ellipsizes the URL.
  expected_interaction_path:
  - Find the Production row in the table.
  - Click the copy IconButton in the Production Base URL cell.
  notes: To increase observability, include row headers as plain text and ensure IconButtons have aria-labels like 'Copy base URL for Production'.
- id: clipboard_copy-mui-T10
  name: Confirm copying client secret (dark dialog)
  canonical_type: clipboard_copy
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: IconButton + Dialog confirmation (composite)'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Copy the client secret to your clipboard. When the confirmation dialog appears, click “Copy secret” to confirm. The task will finish automatically when done.
  ui_copy: Client credentials card (dark theme) has a copy icon; copying requires confirmation in a dialog.
  setup_description: |
    Layout: modal_flow, centered.
    Universal factors: theme=dark.

    The page shows a “Client credentials” card with two fields:
    - Client ID: cli_MUI_2048 (with no copy button; distractor)
    - Client secret: sec_live_MUI_91D0C5 (value is masked with bullets, but a copy IconButton is present)

    Sensitive copy confirmation:
    - Clicking the copy IconButton next to Client secret opens a Material UI Dialog titled “Copy client secret?”.
    - Dialog buttons: “Cancel” and primary “Copy secret”.
    - Only clicking “Copy secret” writes the FULL secret string “sec_live_MUI_91D0C5” to the clipboard and closes the dialog.
    - A snackbar “Secret copied” appears after success.

    Initial state: dialog closed; nothing copied; secret displayed masked but stored as a data attribute for copying.
  scene_context:
    theme: dark
    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: 2
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 4
      disambiguation_load: 2
    justification: Requires a confirmation dialog to complete copying, and the secret is visually masked, reducing semantic observability in dark theme.
  success_trigger:
    human_readable:
    - User confirms the dialog by clicking “Copy secret”.
    - Clipboard text equals "sec_live_MUI_91D0C5".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: sec_live_MUI_91D0C5
      tolerance: null
      require_confirm: true
      confirm_control: Copy secret
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking Cancel or closing the dialog (no copy performed).
  - Copying the Client ID instead of the secret.
  - Attempting to select masked bullets and copy (clipboard incorrect).
  expected_interaction_path:
  - Click the copy IconButton next to Client secret.
  - In the dialog, click 'Copy secret'.
  - Optionally observe snackbar.
  notes: Because browsers may restrict clipboard reads, log the secret value that was passed to writeText for the checker.
- id: clipboard_copy-mantine-T01
  name: Copy coupon code (CopyButton)
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the coupon code SAVE-20-NY to your clipboard using the Copy button. The task will finish automatically when done.
  ui_copy: Coupon card shows code SAVE-20-NY and a Copy button that uses Mantine CopyButton.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Your coupon”. It shows the coupon code in a monospace pill: “SAVE-20-NY”.

    To the right is a Mantine CopyButton wrapped around a normal Mantine Button labeled “Copy”.
    Component behavior (CopyButton):
    - On click, it copies the coupon code value and changes the button label to “Copied” for a short timeout.
    - No additional confirmation is required.

    Distractors: none. Initial state: button label is “Copy”.
  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: 1
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Large labeled button with direct feedback (Copy→Copied); single visible value.
  success_trigger:
    human_readable:
    - Clipboard text equals "SAVE-20-NY".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: SAVE-20-NY
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking elsewhere without copying (clipboard unchanged).
  - Clipboard contains any text other than SAVE-20-NY.
  expected_interaction_path:
  - Click the 'Copy' button.
  notes: Mantine CopyButton exposes 'copied' state; checker can also accept copied==true if clipboard logging is available.
- id: clipboard_copy-mantine-T02
  name: Copy support email (ActionIcon)
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton + ActionIcon'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the support email help@acme.example to your clipboard using the copy icon. The task will finish automatically when done.
  ui_copy: Contact card shows support email and a copy icon (ActionIcon) using Mantine CopyButton.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Contact support”. It shows one line:
    - Support email: help@acme.example

    To the right of the email is a small Mantine ActionIcon wrapped in Mantine CopyButton (clipboard_copy component).
    Component behavior:
    - Clicking the icon copies the email to the clipboard and the icon briefly switches to a checkmark state (copied=true) for the timeout.
    - A Tooltip changes from “Copy” to “Copied”.

    Distractors: none. Initial state: Tooltip says “Copy”, not copied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single small icon target, but only one instance and the copied value is short and visible.
  success_trigger:
    human_readable:
    - Clipboard text equals "help@acme.example".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: help@acme.example
      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:
  - Hovering the icon without clicking (clipboard unchanged).
  - Copying a different email address (if any).
  expected_interaction_path:
  - Click the copy ActionIcon next to help@acme.example.
  notes: Add aria-label='Copy support email' to ActionIcon for accessibility-tree agents.
- id: clipboard_copy-mantine-T03
  name: Copy Public key (two instances)
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton (two rows)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Copy the Public key pub_mantine_1A2B3C to your clipboard using the copy control on that row. The task will finish automatically when done.
  ui_copy: Keys card shows Public key and Private key, each with a copy control.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Keys”. It contains two rows, each with its own Mantine CopyButton:
    - Public key: pub_mantine_1A2B3C  (target)
    - Private key: priv_mantine_9Z8Y7X

    Each row uses a small ActionIcon wrapped in CopyButton. Clicking an icon copies its row’s value and toggles the icon/tooltip to “Copied” briefly.

    Distractors: a “Regenerate keys” button (disabled) below the rows.
    Requirement: instances=2; target instance is the Public key row.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar copy icons require selecting the correct labeled row; otherwise the interaction is straightforward with clear copied feedback.
  success_trigger:
    human_readable:
    - Clipboard text equals "pub_mantine_1A2B3C".
    - Copy must originate from the Public key instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: pub_mantine_1A2B3C
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Public key
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Private key (priv_mantine_9Z8Y7X).
  - Clicking the disabled Regenerate button (no copy).
  expected_interaction_path:
  - Locate the Public key row.
  - Click its copy ActionIcon.
  notes: For checker debugging, record lastCopySourceLabel ('Public key'/'Private key') alongside lastCopiedValue.
- id: clipboard_copy-mantine-T04
  name: Hover to reveal copy on curl snippet
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton + ActionIcon (hover reveal)'
  task_template: disclose
  secondary_template: null
  browsergym_goal: Copy the curl command shown in the code snippet to your clipboard. The copy icon appears when you hover the snippet. The task will finish automatically when done.
  ui_copy: A code snippet shows a curl command; a copy icon appears on hover to copy it.
  setup_description: |
    Layout: isolated_card, anchored near the top-left of the viewport (placement=top_left).
    The card title is “Test request”. It contains a single code snippet block:
        curl https://api.example.com/ping

    The snippet has a Mantine ActionIcon wrapped in CopyButton in the top-right corner of the snippet, but it is only visible when the user hovers/focuses the snippet (disclosed control).

    Component behavior:
    - Clicking the revealed icon copies the full snippet text to clipboard.
    - Tooltip changes from “Copy” to “Copied” for the timeout; icon swaps to a checkmark.

    Distractors: none. Initial state: copy icon hidden; not copied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: top_left
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: The copy affordance is only disclosed on hover and is a small icon within the code block.
  success_trigger:
    human_readable:
    - Clipboard text equals "curl https://api.example.com/ping".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: curl https://api.example.com/ping
      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:
  - Failing to reveal/click the copy icon (clipboard unchanged).
  - Copying only part of the snippet via text selection.
  expected_interaction_path:
  - Hover over the code snippet to reveal the copy icon.
  - Click the copy icon.
  notes: Keep the ActionIcon mounted in the DOM (opacity:0) rather than removing it, to support AX-tree discovery.
- id: clipboard_copy-mantine-T05
  name: Open drawer and copy personal access token
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: Drawer + CopyButton'
  task_template: open_overlay
  secondary_template: null
  browsergym_goal: Open the Access token drawer and copy the token mantine_pat_55C0A1 to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: A 'View token' button opens a drawer showing the token with a copy button.
  setup_description: |
    Layout: drawer_flow, centered.
    The page shows a small card titled “Access tokens” with a button “View token”.

    Clicking “View token” opens a Mantine Drawer that slides in from the right. Inside the drawer:
    - A labeled row “Personal access token” displays “mantine_pat_55C0A1” in monospace text.
    - A Mantine CopyButton is placed next to the token (implemented as a small ActionIcon with Tooltip).
    - A close button (X) at the top is a distractor.

    Component behavior:
    - Clicking the copy ActionIcon copies the token and changes Tooltip to “Copied” for the timeout.
    - Drawer stays open; closing it is optional.

    Initial state: drawer closed; token not visible until opened.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a drawer overlay to reach the copy control; otherwise a standard copy action with clear copied feedback.
  success_trigger:
    human_readable:
    - Clipboard text equals "mantine_pat_55C0A1".
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: mantine_pat_55C0A1
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Opening the drawer but not copying the token.
  - Copying any other field (if present).
  expected_interaction_path:
  - Click 'View token' to open the drawer.
  - Click the copy icon next to mantine_pat_55C0A1.
  notes: Checker should be resilient to drawer being left open/closed; only clipboard state matters.
- id: clipboard_copy-mantine-T06
  name: Copy the device key matching the reference suffix
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton in list rows'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Copy the device key that matches the Reference badge to your clipboard using the copy control on that row. The task will finish automatically when done.
  ui_copy: Reference badge shows target suffix; multiple device keys each have a copy button.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Device keys”. At the top there is a badge labeled “Reference” that shows the target suffix in large text:
    - Reference suffix: 4419

    Below, there is a list of four device rows. Each row shows:
    - Device name (Device A/B/C/D)
    - Device key (monospace)
    - A Mantine CopyButton ActionIcon at the end of the row

    The keys are:
    - Device A: devkey-0-4417
    - Device B: devkey-1-4418
    - Device C: devkey-2-4419  (target; matches reference suffix)
    - Device D: devkey-3-4420

    Component behavior:
    - Clicking a row’s copy icon copies that row’s full device key and toggles to “Copied” state briefly.

    Distractors: a small “Last used” timestamp per row (irrelevant).
    Requirement: instances=4; target is the row whose key matches the reference suffix.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 4
    guidance: mixed
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires matching a reference suffix to one of several similar keys and clicking the correct row’s small copy icon.
  success_trigger:
    human_readable:
    - Clipboard text equals "devkey-2-4419".
    - Copy must originate from the matching device row instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: devkey-2-4419
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Device C
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying any other device key (devkey-0-4417, devkey-1-4418, devkey-3-4420).
  - Clicking on the row but not on the copy icon (clipboard unchanged).
  expected_interaction_path:
  - Read the Reference suffix (4419).
  - Find the device key that ends with 4419.
  - Click that row’s copy icon.
  notes: If you implement keys with ellipsis, ensure the copied full value remains deterministic for checking.
- id: clipboard_copy-mantine-T07
  name: Open copy menu and select Copy as JSON
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: useClipboard
  implementation_component: 'Mantine: Menu + useClipboard hook (composite copy actions)'
  task_template: open_and_select
  secondary_template: null
  browsergym_goal: Open the Copy menu and select “Copy as JSON” so the JSON payload is copied to your clipboard. The task will finish automatically when done.
  ui_copy: A Copy menu offers multiple formats; 'Copy as JSON' copies a JSON payload.
  setup_description: |
    Layout: isolated_card, centered.
    The card title is “Export user”. It displays a small preview of the user object (ID and role) and a button group on the right:
    - A button labeled “Copy” with a dropdown arrow opens a Mantine Menu.

    Menu options (each triggers clipboard write via useClipboard.copy):
    - Copy as text
    - Copy as JSON   (target)
    - Copy as CSV
    - Copy as URL

    The JSON payload that should be copied is shown in a small code preview under “JSON preview”:
    {"id":"u_128","role":"admin"}

    Component behavior:
    - Selecting “Copy as JSON” writes the exact JSON string to the clipboard and closes the menu.
    - A small notification “Copied” appears in the top-right corner of the card.

    Distractors: a “Download” button next to Copy that does nothing relevant.
    Initial state: menu closed; nothing copied.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 4
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 2
    justification: Requires opening a menu and selecting the correct copy format among several similar options; target is an exact JSON string.
  success_trigger:
    human_readable:
    - Clipboard text equals the exact JSON string {"id":"u_128","role":"admin"}.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: '{"id":"u_128","role":"admin"}'
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Selecting a different menu option (text/CSV/URL) resulting in a different clipboard value.
  - Opening the menu but not selecting any item (clipboard unchanged).
  - Copying a pretty-printed multi-line JSON instead of the exact one-line string.
  expected_interaction_path:
  - Click the 'Copy' button to open the menu.
  - Click 'Copy as JSON'.
  - Optionally observe a 'Copied' notification.
  notes: Checker should treat JSON string as exact match (including quotes/braces) with no extra whitespace.
- id: clipboard_copy-mantine-T08
  name: Copy STAGING webhook in dark dashboard
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: Dashboard cards + CopyButton'
  task_template: activate
  secondary_template: null
  browsergym_goal: On the dashboard, copy the webhook endpoint from the STAGING card to your clipboard using the copy control. The task will finish automatically when done.
  ui_copy: Dark dashboard shows DEV/STAGING/PROD cards; each card has a webhook endpoint with a copy icon.
  setup_description: |
    Layout: dashboard, centered.
    Universal factors: theme=dark, clutter=high.

    The dashboard has multiple widgets (charts, recent events list, status badges) as realistic clutter.
    In the middle column there is an “Environments” section with three compact cards:
    - DEV (green badge)
    - STAGING (orange badge)  ← target
    - PROD (red badge)

    Each environment card contains a labeled value “Webhook endpoint” displayed in monospace and a Mantine CopyButton ActionIcon.
    Endpoints:
    - DEV: https://hooks.example.com/dev/mt-21
    - STAGING: https://hooks.example.com/staging/mt-88  (target)
    - PROD: https://hooks.example.com/prod/mt-55

    Component behavior:
    - Clicking the copy icon on a card copies that card’s full endpoint and briefly switches the icon/tooltip to “Copied”.

    Requirement: instances=3; target instance is the STAGING card’s copy icon.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 3
    guidance: mixed
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 4
    justification: High dashboard clutter and dark theme increase search and acquisition difficulty; three similar environment cards require correct disambiguation.
  success_trigger:
    human_readable:
    - Clipboard text equals "https://hooks.example.com/staging/mt-88".
    - Copy must originate from the STAGING environment card instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: https://hooks.example.com/staging/mt-88
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: STAGING card
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the DEV or PROD endpoint.
  - Clicking on other dashboard widgets without copying (clipboard unchanged).
  expected_interaction_path:
  - Find the Environments section and locate the STAGING card.
  - Click the copy icon next to the STAGING webhook endpoint.
  notes: Make badges include accessible text (e.g., 'STAGING') in addition to color to support non-visual agents.
- id: clipboard_copy-mantine-T09
  name: Copy read-only DSN in compact small panel
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: CopyButton
  implementation_component: 'Mantine: CopyButton with ellipsized text (compact)'
  task_template: activate
  secondary_template: null
  browsergym_goal: 'Copy the Read-only DSN to your clipboard: postgres://ro_user@db.example.com:5432/app_ro?sslmode=require. The task will finish automatically when done.'
  ui_copy: Database section lists three connection strings with copy icons; text is truncated due to compact/small styling.
  setup_description: |
    Layout: settings_panel anchored near the bottom-left (placement=bottom_left).
    Universal factors: spacing=compact, scale=small.

    The panel title is “Database connections”. It lists three connection strings (each row has a Mantine CopyButton ActionIcon):
    - Read-write DSN: postgres://rw_user@db.example.com:5432/app?sslmode=require
    - Read-only DSN: postgres://ro_user@db.example.com:5432/app_ro?sslmode=require   (target)
    - Analytics DSN: postgres://an_user@db.example.com:5432/analytics?sslmode=require

    Due to compact spacing and small scale, each DSN is displayed in a single line with ellipsis truncation. The copy icon is small and aligned at the end of the row.

    Component behavior:
    - Clicking a row’s copy icon copies the FULL DSN string (not the truncated rendering) and briefly changes tooltip to “Copied”.

    Distractors: an “Edit” icon per row (disabled; does nothing).
    Requirement: instances=3; target is the Read-only DSN row.
  scene_context:
    theme: light
    spacing: compact
    layout: settings_panel
    placement: bottom_left
    scale: small
    instances: 3
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 4
      disambiguation_load: 4
    justification: Compact/small styling truncates long values and shrinks targets; multiple similar DSN rows increase disambiguation and reduce observability.
  success_trigger:
    human_readable:
    - Clipboard text equals the full Read-only DSN string "postgres://ro_user@db.example.com:5432/app_ro?sslmode=require".
    - Copy must originate from the Read-only DSN row instance.
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: postgres://ro_user@db.example.com:5432/app_ro?sslmode=require
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Read-only DSN
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Copying the Read-write or Analytics DSN instead of Read-only.
  - Copying only the truncated visible portion (e.g., missing query string).
  - Clicking disabled Edit icons (no copy).
  expected_interaction_path:
  - Locate the Read-only DSN row.
  - Click its copy icon.
  notes: 'Implementation hint: store the full DSN in a data attribute (data-value) so copying and checking do not rely on rendered text.'
- id: clipboard_copy-mantine-T10
  name: Confirm copying backup codes
  canonical_type: clipboard_copy
  implementation_source: mantine
  implementation_variant: useClipboard
  implementation_component: 'Mantine: Modal + useClipboard hook'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Copy the backup codes to your clipboard. When the confirmation modal appears, click “Copy” to proceed. The task will finish automatically when done.
  ui_copy: A Backup codes section has a 'Copy codes' action that requires confirmation in a modal.
  setup_description: |2
            Layout: modal_flow, centered.
            The page shows a “Two-factor authentication” section with a preformatted list of backup codes (4 lines).
            A button labeled “Copy codes” is shown next to the section header.

            Confirmation flow:
            - Clicking “Copy codes” opens a Mantine Modal titled “Copy backup codes?” with warning text about sensitivity.
            - The modal has two buttons in the footer: “Cancel” and primary “Copy”.
            - Only clicking “Copy” triggers clipboard write of the entire multi-line backup code block and closes the modal.
            - After success, a small notification appears: “Copied”.

            Target clipboard text (exact, including newlines):
            BK-1200
    BK-1201
    BK-1202
    BK-1203

            Initial state: modal closed; nothing copied.
  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: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 4
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 1
    justification: Requires a confirmation modal to complete copying and copies a multi-line value, increasing depth and feedback complexity.
  success_trigger:
    human_readable:
    - User confirms the modal by clicking “Copy”.
    - Clipboard text equals the full backup code block exactly (4 lines).
    - Task ends when predicate holds.
    canonical_predicate:
      predicate_type: equals
      target_state:
        clipboard_text: |-
          BK-1200
          BK-1201
          BK-1202
          BK-1203
      tolerance: null
      require_confirm: true
      confirm_control: Copy
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Clicking Cancel or closing the modal (no clipboard write).
  - Copying only a subset of lines (partial selection).
  - Triggering the modal but not pressing “Copy”.
  expected_interaction_path:
  - Click 'Copy codes' to open the confirmation modal.
  - Click 'Copy' in the modal.
  - Optionally observe the 'Copied' notification.
  notes: Checker should validate that the modal confirm button was clicked when require_confirm=true (e.g., track lastConfirmAction).