tasks/v1/inline_editable_text.yaml

- id: inline_editable_text-antd-T01
  name: Rename display name (single field)
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Display name to “Ava Chen”. Click Save to commit the
    change. The task will finish automatically when done.
  ui_copy: Change the Display name to “Ava Chen”. Click Save to commit the change.
    The task will finish automatically when done.
  setup_description: 'A single centered card titled “Profile” contains one inline
    editable text row labeled “Display name”.

    The value is shown as Ant Design Typography.Text with a pencil edit icon on hover.
    Initial value: “Ava Li”.

    Clicking the text or the pencil icon turns it into a one-line input with two inline
    controls: “Save” (check icon) and “Cancel” (close icon).

    There are no other editable text components on the page and no extra distractors.
    Saving immediately commits the value back to the read-only Typography view.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single large target in a clean, centered card; only one short string
      to enter and a clear Save control to commit.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Display name' is the one that must be checked.
    - The committed (display) value equals 'Ava Chen' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Ava Chen
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Display name
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing a different field (there is only one; any other interaction does not count).
  - Typing “Ava Chen” but leaving the component in editing mode (input still visible).
  - Typing the value but clicking outside without committing, or pressing Cancel.
  - A near match such as “AvaChen”, “Ava  Chen”, or “Ava Chen ” (extra/missing whitespace
    or characters).
  expected_interaction_path:
  - Click the Display name text (or pencil icon) to enter edit mode
  - Type Ava Chen
  - Click Save (check icon) to commit and return to display mode
  notes: 'Instrumentation: add data-testid on the editable root (e.g., editable-display-name),
    the input, and Save/Cancel controls so the checker can read committed value and
    mode.'
- id: inline_editable_text-antd-T02
  name: Enter edit mode (no text change)
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Put the Project title text into edit mode (you do not need to change
    the text). The task will finish automatically when done.
  ui_copy: Put the Project title text into edit mode (you do not need to change the
    text). The task will finish automatically when done.
  setup_description: 'A centered card titled “Project” shows a single inline editable
    text labeled “Project title”.

    The value is displayed as “Launch Plan” in Ant Design Typography.Text with an
    edit (pencil) icon.

    Clicking the text (or the pencil icon) swaps the Typography view for a focused
    one-line input plus inline “Save” and “Cancel” controls.

    The task is purely about entering the editing state; committing or changing text
    is not required.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Only one editable target and success is achieved as soon as the
      component visibly enters edit mode.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Project title' is the one that must be checked.
    - The component is in editing mode (mode='editing').
    canonical_predicate:
      predicate_type: equals
      target_state:
        mode: editing
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Project title
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Focusing a different control (there are no other editable text instances).
  - Changing the text and saving/canceling—these are unnecessary and not required
    for success.
  - Opening unrelated UI like tooltips; the inline editor must actually be in editing
    mode (input visible).
  expected_interaction_path:
  - Click the Project title text (or pencil icon)
  - Verify the inline input appears and is focused
  notes: Checker should detect mode by presence of the input element within the editable
    component subtree.
- id: inline_editable_text-antd-T03
  name: Clear a status note to empty
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the Status note so it becomes empty, then click Save. The
    task will finish automatically when done.
  ui_copy: Clear the Status note so it becomes empty, then click Save. The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Status” contains one inline editable
    text row labeled “Status note”.

    Initial value: “Waiting for approval”. The text is shown as Typography.Text with
    an edit icon.

    When editing, the component shows a one-line input with a built-in clear (×) affordance
    inside the input, plus inline “Save” and “Cancel” controls.

    The page has no other inline editable text components and no extra clutter.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: Single field with obvious clear and Save controls; success is simply
      committing an empty string.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Status note' is the one that must be checked.
    - The committed (display) value equals '' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ''
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Status note
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving any characters behind (including a single space).
  - Clicking Cancel after clearing, which restores the original text.
  - Clearing the input but not committing (e.g., leaving it in edit mode).
  - Any non-empty value such as “ ”, “-”, or “None”.
  expected_interaction_path:
  - Click Status note to enter edit mode
  - Use the clear (×) control or delete all text
  - Click Save to commit the empty value
  notes: Checker should treat the committed value as empty only when it is exactly
    ''. Consider trimming only if the UI itself trims.
- id: inline_editable_text-antd-T04
  name: Set status label using mixed guidance
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Set the Status label to “READY” (it should match the green preview
    chip), then click Save. The task will finish automatically when done.
  ui_copy: Set the Status label to “READY” (it should match the green preview chip),
    then click Save. The task will finish automatically when done.
  setup_description: 'A centered card titled “Status Label” contains one inline editable
    text labeled “Status label”.

    The editable text currently shows “Idle”. To the right of it, a non-interactive
    green preview chip displays the desired label styling.

    Entering edit mode turns the Typography.Text into a one-line input with inline
    Save/Cancel controls. The chip remains visible while editing.

    The goal provides the target text explicitly (“READY”) but also includes the visual
    confirmation cue via the preview chip.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: mixed
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 1
      disambiguation_load: 1
    justification: The target value is explicitly stated and there is only one field;
      the preview chip is an extra confirmation cue rather than a disambiguation challenge.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Status label' is the one that must be checked.
    - The committed (display) value equals 'READY' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: READY
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Status label
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Entering a different casing like “Ready” or “ready”.
  - Committing the old value (“Idle”) or any other text.
  - Typing the correct text but not clicking Save to commit.
  - Leaving the component in edit mode (input still visible).
  expected_interaction_path:
  - Click Status label to enter edit mode
  - Type READY
  - Click Save to commit
  notes: The green preview chip is non-interactive and should not be used as the success
    signal; success is based only on the editable text state.
- id: inline_editable_text-antd-T05
  name: Enter a formatted ticket code
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Change the Ticket code to “TKT-1042” and click Save. The task will
    finish automatically when done.
  ui_copy: Change the Ticket code to “TKT-1042” and click Save. The task will finish
    automatically when done.
  setup_description: 'A centered card titled “Support Ticket” contains one inline
    editable text labeled “Ticket code”.

    The current value is “TKT-1000”. Clicking the value opens an input with Save/Cancel
    controls.

    While editing, an inline validation hint appears under the input: “Format: TKT-####”.

    If the format is wrong (missing hyphen, wrong prefix, not four digits), the input
    shows an error state and the Save control is disabled until valid.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires exact formatted entry with validation and a disabled Save
      state on errors, but still a single, well-labeled field in a simple layout.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Ticket code' is the one that must be checked.
    - The committed (display) value equals 'TKT-1042' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: TKT-1042
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Ticket code
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong format such as “TKT1042”, “TK-1042”, or “TKT-142”.
  - Correct text typed but not committed via Save (still editing).
  - Leaving any trailing/leading characters (e.g., “TKT-1042 ”).
  - Canceling the edit so the value reverts to “TKT-1000”.
  expected_interaction_path:
  - Click Ticket code to enter edit mode
  - Type TKT-1042
  - Click Save (enabled only when valid)
  notes: Checker should read the committed value (not the input draft) so partial/invalid
    drafts do not pass.
- id: inline_editable_text-antd-T06
  name: Save a tagline with asynchronous feedback
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Update the Team tagline to “Built to ship.” and click Save. The
    task will finish automatically when done.
  ui_copy: Update the Team tagline to “Built to ship.” and click Save. The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Team” contains one inline editable text
    labeled “Team tagline”.

    The tagline is displayed as Typography.Text with an edit icon. Initial value:
    “Ship it”.

    When you click Save, the component shows a brief loading state (Save control disabled
    and a small spinner appears) before returning to the read-only view.

    A toast message “Saved” appears in the top-right of the page after the commit.
    If the text exceeds 20 characters, an inline error appears and the value is not
    committed.'
  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: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: Even with a single field, saving involves transient loading feedback
      and a constraint (max length) that can block committing if the entry is off
      by a character.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Team tagline' is the one that must be checked.
    - The committed (display) value equals 'Built to ship.' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Built to ship.
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Team tagline
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Typing the text but not committing it (e.g., leaving the input open).
  - A close match such as “Built to ship” (missing period) or “Built  to ship.” (double
    space).
  - Text longer than allowed that leaves the component in an error state without committing.
  - Clicking Cancel after typing, which reverts to the original tagline.
  expected_interaction_path:
  - Click Team tagline to enter edit mode
  - Type Built to ship.
  - Click Save and wait for the component to return to display mode
  notes: Checker should use the committed value after save completes (not intermediate
    loading state).
- id: inline_editable_text-antd-T07
  name: Match badge text from a visual reference
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the Badge text to match the example shown on the sample badge,
    then click Save. The task will finish automatically when done.
  ui_copy: Set the Badge text to match the example shown on the sample badge, then
    click Save. The task will finish automatically when done.
  setup_description: 'A centered card titled “Badge Designer” is split into two columns.

    Left column: one inline editable text labeled “Badge text”, currently “VISITOR”.

    Right column: a non-editable sample badge preview showing the desired text exactly
    as it should appear (including punctuation and spacing).

    The editable text uses Ant Design Typography.Text with an edit icon; editing shows
    an input with Save/Cancel controls.

    The target text is not written in the instructions; it must be read from the sample
    badge preview.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires extracting an exact string from a visual reference (including
      special punctuation), but still a single component in a low-clutter scene.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Badge text' is the one that must be checked.
    - The committed (display) value equals 'STAFF — 2026' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: STAFF — 2026
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Badge text
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Using a hyphen instead of an em dash, or missing spaces around the dash.
  - Matching only part of the reference (e.g., “STAFF” only).
  - Typing the correct string but not committing with Save.
  - Clicking Cancel, which restores “VISITOR”.
  expected_interaction_path:
  - Read the exact text shown on the sample badge preview
  - Click Badge text to enter edit mode
  - Type the reference text
  - Click Save to commit
  notes: For robustness, the sample badge preview should be clearly legible and have
    stable text content for the checker to use as the canonical target.
- id: inline_editable_text-antd-T08
  name: Edit the Billing note among two fields
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Form + Typography.Text (editable)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: In the Notes section, change the Billing note to “Send invoice
    by email”, then click Save. The task will finish automatically when done.
  ui_copy: In the Notes section, change the Billing note to “Send invoice by email”,
    then click Save. The task will finish automatically when done.
  setup_description: "The page shows a centered “Checkout Settings” form section with\
    \ several read-only fields (e.g., Company, Region) and a “Notes” subsection.\n\
    Inside “Notes” there are two inline editable text rows of the same component type:\n\
    \  • “Shipping note” (initial: “Leave at front desk”)\n  • “Billing note” (initial:\
    \ “Net 30”)\nEach row is displayed as Ant Design Typography.Text with a pencil\
    \ icon and turns into an input with Save/Cancel controls when edited.\nThe surrounding\
    \ form fields are distractors only; success depends solely on committing the correct\
    \ text in the Billing note instance."
  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: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar inline editable fields in a small form section require
      careful instance selection, but the entry itself is a straightforward sentence.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Billing note' is the one that must be checked.
    - The committed (display) value equals 'Send invoice by email' exactly (case-
      and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Send invoice by email
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Billing note
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing the Shipping note instead of the Billing note.
  - Setting the Billing note correctly but not clicking Save to commit.
  - Leaving the component in edit mode (input visible).
  - A close but incorrect sentence such as “Send invoice via email”.
  expected_interaction_path:
  - Locate the Notes section
  - Click the Billing note row to enter edit mode
  - Type Send invoice by email
  - Click Save
  notes: Add stable labels/aria-labelledby so the checker can identify the Billing
    note instance even when both rows use the same underlying component.
- id: inline_editable_text-antd-T09
  name: Enter account code in dark theme
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Typography.Text (editable)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the Account code to “ACCT-2049” and click Save. The task will
    finish automatically when done.
  ui_copy: Set the Account code to “ACCT-2049” and click Save. The task will finish
    automatically when done.
  setup_description: 'A single card is centered on a dark-themed page (dark background,
    light text) titled “Account”.

    It contains one inline editable text labeled “Account code” with initial value
    “ACCT-1020”.

    Editing opens a one-line input with Save/Cancel controls. A small helper text
    under the input states: “Format: ACCT-#### (uppercase)”.

    If the entry does not match the format, the input shows an error state and Save
    is disabled. The darker theme makes the icon controls and helper text slightly
    harder to visually pick out.'
  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: 4
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Dark theme reduces contrast for small icon controls, and the value
      must match an exact formatted pattern with validation gating the Save action.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Account code' is the one that must be checked.
    - The committed (display) value equals 'ACCT-2049' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ACCT-2049
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Account code
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong format such as “acct-2049”, “ACCT2049”, or “ACCT-249”.
  - Typing the correct code but not committing via Save.
  - Leaving the input open (still editing) even if the text matches.
  - Canceling the edit (reverts to “ACCT-1020”).
  expected_interaction_path:
  - Click Account code to enter edit mode
  - Type ACCT-2049 exactly
  - Click Save
  notes: For AX-tree agents, ensure the Save/Cancel icon buttons have aria-labels
    ('Save', 'Cancel') to keep observability comparable across modes.
- id: inline_editable_text-antd-T10
  name: Edit a specific table cell (compact, corner placement)
  canonical_type: inline_editable_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Table + Typography.Text (editable)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Orders table, edit the Owner cell for order “Gamma” to “M.
    Rivera”, then click Save. The task will finish automatically when done.
  ui_copy: In the Orders table, edit the Owner cell for order “Gamma” to “M. Rivera”,
    then click Save. The task will finish automatically when done.
  setup_description: 'A compact-density table card is anchored near the bottom-right
    of the viewport (you can see it without scrolling).

    The card title is “Orders”. The table has three rows (Alpha, Beta, Gamma) and
    columns: Order, Owner, Status.

    Only one cell uses the inline editable text component: the Owner cell in the Gamma
    row. That cell shows “Unassigned” as Typography.Text and reveals a small pencil
    icon when hovered.

    Clicking that cell enters inline edit mode inside the table cell, showing a one-line
    input and small Save/Cancel icon controls.

    Other rows and columns are non-editable and serve as realistic table clutter.
    Success depends only on the committed value in the Gamma/Owner inline editor.'
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_right
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: Small, dense table targets in a corner placement increase acquisition
      difficulty, and the user must correctly locate the one editable cell before
      entering and committing the exact value.
  success_trigger:
    human_readable:
    - The inline editable text instance inside the table cell (row='Gamma', column='Owner')
      is the one that must be checked.
    - The committed (display) value of that cell equals 'M. Rivera' exactly.
    - The cell is no longer in editing mode (input hidden).
    - The value is committed via the inline editor's Save control.
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: M. Rivera
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: OrdersTable:Gamma/Owner
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing a different row or column (e.g., Alpha/Owner) if the UI mistakenly allows
    it.
  - Typing “M. Rivera” but not committing (still editing / input visible).
  - Committing a close value like “M Rivera” or “M. Rivera ” (missing punctuation
    or extra whitespace).
  - Clicking Cancel, which restores “Unassigned”.
  expected_interaction_path:
  - Locate the Gamma row and the Owner column
  - Click the editable cell to enter edit mode
  - Type M. Rivera
  - Click Save (check icon) to commit
  notes: 'Instrumentation: encode row/column identifiers in data-testid (e.g., editable-cell-gamma-owner)
    so the checker can disambiguate the target instance unambiguously.'
- id: inline_editable_text-mui-T01
  name: Rename display name (single field, MUI composite)
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField + IconButton (inline edit
    composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Display name to “Jordan Lee”. Click Save to commit the
    change. The task will finish automatically when done.
  ui_copy: Change the Display name to “Jordan Lee”. Click Save to commit the change.
    The task will finish automatically when done.
  setup_description: 'A centered card titled “Profile” contains one inline editable
    text row labeled “Display name”.

    In read-only mode, the value is rendered as MUI Typography with a small pencil
    IconButton at the end of the row. Initial value: “Jordan L.”

    Clicking the pencil (or the text) swaps the Typography for a MUI TextField styled
    to look inline, plus two small buttons: “Save” and “Cancel”.

    Save commits the value and returns to the Typography view. There are no other
    inline editable text components on the page.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single inline editor with clearly labeled Save/Cancel controls
      in a clean scene; only a short name string must be entered.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Display name' is the one that must be checked.
    - The committed (display) value equals 'Jordan Lee' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Jordan Lee
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Display name
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Typing the correct value but leaving the TextField open (not committed).
  - Clicking Cancel after typing, which restores the original value.
  - A near match such as “Jordan  Lee” or “Jordan Lee ”.
  - Changing any other control (none exist of this canonical type).
  expected_interaction_path:
  - Click the pencil icon to enter edit mode
  - Type Jordan Lee
  - Click Save to commit
  notes: 'Composite implementation note: MUI does not ship a single dedicated ''inline
    editable text'' component; this uses a controlled toggle between Typography and
    TextField.'
- id: inline_editable_text-mui-T02
  name: Enter edit mode (MUI composite)
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField (inline edit composite)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Put the Project nickname text into edit mode (no need to change
    it). The task will finish automatically when done.
  ui_copy: Put the Project nickname text into edit mode (no need to change it). The
    task will finish automatically when done.
  setup_description: 'A centered card titled “Project” has one inline editable text
    row labeled “Project nickname”.

    The read-only value is Typography showing “Apollo” with a trailing pencil IconButton.

    Clicking the pencil changes the row into a focused MUI TextField with Save and
    Cancel buttons.

    Success is defined as the component being in editing mode (TextField visible),
    regardless of what text is entered.'
  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: Only one target and the success condition is a visible mode change
      (Typography → TextField).
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Project nickname' is the one that must be
      checked.
    - The component is in editing mode (mode='editing').
    canonical_predicate:
      predicate_type: equals
      target_state:
        mode: editing
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Project nickname
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Interacting with the card without opening the TextField (still in read-only Typography
    mode).
  - Opening a tooltip only; the TextField must appear.
  - Saving/canceling is unnecessary; the component must remain in editing mode for
    success.
  expected_interaction_path:
  - Click the pencil IconButton next to Project nickname
  - Confirm the TextField appears (editing mode)
  notes: Checker can detect editing mode by presence of the TextField element within
    the editable row container.
- id: inline_editable_text-mui-T03
  name: Clear status message to empty (MUI composite)
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField (inline edit composite)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the Status message so it is empty, then click Save. The task
    will finish automatically when done.
  ui_copy: Clear the Status message so it is empty, then click Save. The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Status” contains one inline editable
    text row labeled “Status message”.

    The read-only Typography value is “In a meeting”. Clicking the pencil icon opens
    a one-line MUI TextField.

    While editing, a small clear (×) IconButton appears inside the TextField end-adornment;
    Save/Cancel buttons are displayed to the right.

    Saving commits the empty string back to read-only mode. No other inline editable
    text components are present.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single field with an explicit clear affordance and clear Save/Cancel
      commit controls.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Status message' is the one that must be
      checked.
    - The committed (display) value equals '' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ''
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Status message
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving whitespace (e.g., a single space) instead of truly empty.
  - Clearing but clicking Cancel, which restores the original message.
  - Clearing but not saving (TextField still open).
  - Entering placeholder text like “-” or “n/a” (non-empty).
  expected_interaction_path:
  - Click Status message pencil to enter edit mode
  - Use the clear (×) control or delete all text
  - Click Save
  notes: If the UI trims whitespace on save, document it; otherwise the checker should
    treat whitespace as non-empty.
- id: inline_editable_text-mui-T04
  name: Enter formatted customer ID
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField (inline edit composite)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the Customer ID to “CUS-00942” and click Save. The task will
    finish automatically when done.
  ui_copy: Set the Customer ID to “CUS-00942” and click Save. The task will finish
    automatically when done.
  setup_description: 'A centered card titled “Customer” contains one inline editable
    text labeled “Customer ID”.

    The current value is “CUS-00001” in Typography. Clicking edit opens a one-line
    TextField with helper text: “Format: CUS-#####”.

    The component validates the prefix and digit count; if invalid, the TextField
    shows an error and the Save button is disabled.

    Save commits the value and returns to Typography display mode.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Exact formatted input with validation gating Save increases precision
      and feedback complexity, but there is only one well-labeled field.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Customer ID' is the one that must be checked.
    - The committed (display) value equals 'CUS-00942' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: CUS-00942
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Customer ID
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong format like “CUS-942”, “CUS00942”, or “CUST-00942”.
  - Correct value typed but not committed with Save.
  - Leaving the editor in editing mode (TextField visible).
  - Canceling the edit so the original ID remains.
  expected_interaction_path:
  - Click Customer ID edit icon
  - Type CUS-00942
  - Click Save
  notes: For checker robustness, read committed state variable rather than relying
    on DOM text which may include formatting or spacing.
- id: inline_editable_text-mui-T05
  name: Update meeting title (simple text)
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField (inline edit composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Meeting title to “Weekly Sync” and click Save. The task
    will finish automatically when done.
  ui_copy: Change the Meeting title to “Weekly Sync” and click Save. The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Calendar” includes a single inline editable
    text labeled “Meeting title”.

    Initial Typography value: “Sync”. Clicking the pencil icon opens a one-line TextField
    with Save/Cancel buttons.

    A small helper hint under the field says “Title is shown on the calendar”. No
    other inline editable text components appear on the page.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Still a single field, but requires an explicit Save action and
      exact string entry; overall remains low-interference.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Meeting title' is the one that must be checked.
    - The committed (display) value equals 'Weekly Sync' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Weekly Sync
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Meeting title
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Typing but not saving (TextField still open).
  - Saving a close value like “Weekly sync” (case mismatch) or “Weekly  Sync” (extra
    space).
  - Canceling so the value stays “Sync”.
  expected_interaction_path:
  - Click Meeting title edit icon
  - Type Weekly Sync
  - Click Save
  notes: null
- id: inline_editable_text-mui-T06
  name: Commit release note with snackbar feedback
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography + TextField + Snackbar (inline edit composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Release note to “Deploy at 5 PM ET” and click Save.
    The task will finish automatically when done.
  ui_copy: Change the Release note to “Deploy at 5 PM ET” and click Save. The task
    will finish automatically when done.
  setup_description: 'A centered card titled “Release” has one inline editable text
    labeled “Release note”.

    Initial value: “Deploy soon”. Clicking edit opens a TextField with Save/Cancel
    buttons.

    When Save is clicked, the Save button becomes disabled and a Snackbar appears
    saying “Saving…”, then updates to “Saved”.

    The TextField only returns to read-only mode after the save completes; this introduces
    a short feedback latency compared to immediate commit.'
  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: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: The agent must handle delayed commit and transient UI states (disabled
      Save + snackbar) while still ensuring the final committed text matches exactly.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Release note' is the one that must be checked.
    - The committed (display) value equals 'Deploy at 5 PM ET' exactly (case- and
      punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Deploy at 5 PM ET
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Release note
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Saving before the full text is entered (partial commit).
  - Clicking Save but leaving the editor open in an intermediate state (still editing).
  - A near miss like “Deploy at 5PM ET” (missing space) or “Deploy at 5 PM” (missing
    suffix).
  - Clicking Cancel, which reverts to “Deploy soon”.
  expected_interaction_path:
  - Click Release note edit icon
  - Type Deploy at 5 PM ET
  - Click Save and wait for the component to return to read-only mode
  notes: Checker should ignore the snackbar text and rely on the committed value +
    display mode.
- id: inline_editable_text-mui-T07
  name: Match badge label from a preview chip
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Chip (preview) + Typography/TextField (inline edit
    composite)'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the Badge label to match the text shown in the blue preview
    chip, then click Save. The task will finish automatically when done.
  ui_copy: Set the Badge label to match the text shown in the blue preview chip, then
    click Save. The task will finish automatically when done.
  setup_description: "A centered card titled “Badge” shows:\n  • Left: one inline\
    \ editable text labeled “Badge label”, currently “OFF”.\n  • Right: a non-editable\
    \ MUI Chip preview (blue) that displays the desired label text exactly as it should\
    \ be saved.\nThe editable label is rendered as Typography with an edit IconButton;\
    \ edit mode uses a one-line TextField with Save/Cancel.\nThe goal requires reading\
    \ the target string from the preview chip rather than from the instruction text."
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Requires extracting the exact target from a visual reference, but
      interaction remains a simple single-field edit with a clear Save action.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Badge label' is the one that must be checked.
    - The committed (display) value equals 'ON-CALL' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ON-CALL
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Badge label
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Typing “ON CALL” (missing hyphen) or “On-Call” (case mismatch).
  - Copying only part of the chip text.
  - Not saving after typing (still in edit mode).
  - Canceling the edit.
  expected_interaction_path:
  - Read the label shown in the blue chip preview
  - Click Badge label edit icon
  - Type the chip text
  - Click Save
  notes: Preview chip must be static and readable; checker should still use the canonical
    target in this task spec.
- id: inline_editable_text-mui-T08
  name: Edit secondary label among two fields
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography/TextField inline edit composite (two
    instances)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Secondary label to “Archived”, then click Save. The
    task will finish automatically when done.
  ui_copy: Change the Secondary label to “Archived”, then click Save. The task will
    finish automatically when done.
  setup_description: "A centered card titled “Labels” contains two inline editable\
    \ text rows stacked vertically:\n  • “Primary label” (initial: “Active”)\n  •\
    \ “Secondary label” (initial: “Pending”)\nBoth rows use the same composite pattern:\
    \ Typography in read-only mode with a pencil IconButton; TextField with Save/Cancel\
    \ in edit mode.\nThere is no other clutter. The key difficulty is selecting the\
    \ correct instance (“Secondary label”) before editing and committing."
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two same-type instances increase disambiguation load; otherwise
      the edit is straightforward with clear controls.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Secondary label' is the one that must be
      checked.
    - The committed (display) value equals 'Archived' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Archived
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Secondary label
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing the Primary label instead of the Secondary label.
  - Typing “Archived” but not clicking Save (still editing).
  - Committing a close value like “Archive” or “archived”.
  - Canceling after typing so the Secondary label remains “Pending”.
  expected_interaction_path:
  - Locate the Secondary label row
  - Click its edit icon to enter edit mode
  - Type Archived
  - Click Save
  notes: 'Instrumentation: each row should have a unique data-testid or aria-label
    so the checker can map committed values to instance labels.'
- id: inline_editable_text-mui-T09
  name: Enter tracking ID in dark theme
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Typography/TextField inline edit composite'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the Tracking ID to “ZX-2049-NA” and click Save. The task will
    finish automatically when done.
  ui_copy: Set the Tracking ID to “ZX-2049-NA” and click Save. The task will finish
    automatically when done.
  setup_description: 'The page is rendered in a dark theme. A centered card titled
    “Shipment” contains one inline editable text labeled “Tracking ID”.

    The initial value is “ZX-0000-NA”. Clicking edit opens a one-line TextField with
    helper text: “Use uppercase letters and digits: XX-####-XX”.

    Invalid entries show an error and disable Save until the format is correct. In
    dark mode, the outline, helper text, and icon buttons have reduced visual salience
    compared to light mode.'
  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: 4
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Exact formatted entry with validation plus dark-theme icon/button
      contrast makes acquisition and feedback handling more demanding.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Tracking ID' is the one that must be checked.
    - The committed (display) value equals 'ZX-2049-NA' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ZX-2049-NA
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Tracking ID
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong casing or format (e.g., “zx-2049-na”, “ZX2049NA”).
  - Saving without committing the final value (still editing).
  - Entering a close value like “ZX-2049-N A” (extra space).
  - Canceling the edit, leaving the original tracking ID.
  expected_interaction_path:
  - Click Tracking ID edit icon
  - Type ZX-2049-NA exactly
  - Click Save
  notes: null
- id: inline_editable_text-mui-T10
  name: Edit table status cell (compact, top-right)
  canonical_type: inline_editable_text
  implementation_source: mui
  implementation_variant: composite
  implementation_component: 'MUI: Table + Typography/TextField inline edit composite'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Inventory table, edit the Status cell for item “Widget B”
    to “In Stock”, then click Save. The task will finish automatically when done.
  ui_copy: In the Inventory table, edit the Status cell for item “Widget B” to “In
    Stock”, then click Save. The task will finish automatically when done.
  setup_description: 'A compact table card is positioned near the top-right of the
    viewport.

    The card title is “Inventory”. The table has three rows (Widget A, Widget B, Widget
    C) and columns: Item, Status, Qty.

    Only one cell is inline-editable: the Status cell in the Widget B row. It shows
    “Backorder” as Typography and reveals a small pencil IconButton when hovered.

    Clicking it turns the cell into a one-line TextField with small Save/Cancel buttons
    rendered inline.

    Other cells are read-only and act as realistic table context; the task succeeds
    only when the Widget B/Status editable cell is committed to the target text.'
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 4
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: A small editable affordance inside a dense table, placed in the
      corner of the viewport, increases acquisition difficulty and makes it easy to
      target the wrong cell.
  success_trigger:
    human_readable:
    - The inline editable text instance inside the table cell (row='Widget B', column='Status')
      is the one that must be checked.
    - The committed (display) value equals 'In Stock' exactly.
    - The cell has exited edit mode (TextField hidden).
    - The value is committed via the inline editor's Save control.
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: In Stock
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: InventoryTable:Widget B/Status
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing Widget A or Widget C instead of Widget B.
  - Saving “In stock” (case mismatch) or “In  Stock” (extra space).
  - Typing the correct value but not saving (still editing).
  - Canceling the edit so the cell remains “Backorder”.
  expected_interaction_path:
  - Locate the Inventory table and the Widget B row
  - Click the Status cell edit affordance
  - Type In Stock
  - Click Save
  notes: Ensure the editable cell and controls have stable identifiers; table virtualization
    is disabled for this task to keep the target visible.
- id: inline_editable_text-mantine-T01
  name: Rename workspace name (Mantine composite)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text + TextInput + ActionIcon (inline edit composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Workspace name to “Northwind Lab” and click Save. The
    task will finish automatically when done.
  ui_copy: Change the Workspace name to “Northwind Lab” and click Save. The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Workspace” contains one inline editable
    text row labeled “Workspace name”.

    In view mode, the value is displayed as Mantine Text with a small pencil ActionIcon
    on the right. Initial value: “Northwind”.

    Clicking the pencil swaps the Text for a one-line Mantine TextInput styled to
    blend into the row, with inline ActionIcons for Save and Cancel.

    Clicking Save commits the value and returns to the view mode Text. No other inline
    editable text instances are present.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single field with clear Save/Cancel ActionIcons in a clean scene;
      only a short string must be entered and committed.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Workspace name' is the one that must be
      checked.
    - The committed (display) value equals 'Northwind Lab' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Northwind Lab
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Workspace name
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Typing the correct value but leaving the TextInput open (not committed).
  - Clicking Cancel after typing, which restores the previous name.
  - A close variant like “NorthwindLab” or “Northwind Lab ”.
  - Interacting with other controls (none exist of this canonical type).
  expected_interaction_path:
  - Click the pencil ActionIcon next to Workspace name
  - Type Northwind Lab
  - Click Save
  notes: 'Composite note: Mantine does not provide a dedicated inline-edit text component;
    this pattern toggles between Text and TextInput.'
- id: inline_editable_text-mantine-T02
  name: Enter edit mode (Mantine composite)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text + TextInput (inline edit composite)'
  task_template: activate
  secondary_template: null
  browsergym_goal: Put the Tagline text into edit mode (no need to change it). The
    task will finish automatically when done.
  ui_copy: Put the Tagline text into edit mode (no need to change it). The task will
    finish automatically when done.
  setup_description: 'A centered card titled “Branding” contains one inline editable
    text row labeled “Tagline”.

    The read-only value is Mantine Text showing “Fast & simple” with a pencil ActionIcon.

    Clicking the pencil turns the row into a focused one-line TextInput and shows
    Save/Cancel ActionIcons.

    Success is achieved once the component is in editing mode (TextInput visible),
    regardless of the value.'
  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 target; success is just a mode switch to show the input
      field.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Tagline' is the one that must be checked.
    - The component is in editing mode (mode='editing').
    canonical_predicate:
      predicate_type: equals
      target_state:
        mode: editing
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Tagline
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Hovering without clicking so the input never appears.
  - Opening unrelated UI (none exists); the TextInput must be visible.
  - Saving/canceling is not required; the component must be in edit mode.
  expected_interaction_path:
  - Click the Tagline pencil ActionIcon
  - Confirm the TextInput is visible (editing mode)
  notes: null
- id: inline_editable_text-mantine-T03
  name: Clear note to empty (Mantine composite)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text + TextInput (inline edit composite)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the Note text so it is empty, then click Save. The task will
    finish automatically when done.
  ui_copy: Clear the Note text so it is empty, then click Save. The task will finish
    automatically when done.
  setup_description: 'A centered card titled “Note” includes one inline editable text
    labeled “Note”.

    The current value is “Call me after lunch”. Clicking the edit ActionIcon opens
    a one-line TextInput.

    While editing, a clear (×) affordance appears inside the input rightSection and
    Save/Cancel ActionIcons appear beside it.

    Saving commits the empty string and returns to the Text view.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single inline editor with an explicit clear affordance; committing
      an empty string is straightforward.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Note' is the one that must be checked.
    - The committed (display) value equals '' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: ''
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Note
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Leaving whitespace or any character behind (not truly empty).
  - Clearing but clicking Cancel, which restores the previous note.
  - Clearing but not committing (still editing).
  - Replacing with placeholder text like “-” instead of empty.
  expected_interaction_path:
  - Click Note edit icon
  - Clear all text (× or backspace)
  - Click Save
  notes: If the UI uses placeholder text when empty, ensure the checker reads the
    stored value, not placeholder rendering.
- id: inline_editable_text-mantine-T04
  name: Enter formatted team code
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text + TextInput (inline edit composite)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the Team code to “TEAM-0042” and click Save. The task will
    finish automatically when done.
  ui_copy: Set the Team code to “TEAM-0042” and click Save. The task will finish automatically
    when done.
  setup_description: 'A centered card titled “Team” contains one inline editable text
    row labeled “Team code”.

    The initial value is “TEAM-0001”. Clicking the pencil ActionIcon opens a one-line
    TextInput with helper text under it: “Format: TEAM-####”.

    If the prefix/casing or digit count is wrong, the input shows an error message
    and the Save ActionIcon is disabled until valid.

    Save commits the value and returns to Text display mode.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 4
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Exact formatted input with validation gating the Save control,
      but otherwise a clean single-field interaction.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Team code' is the one that must be checked.
    - The committed (display) value equals 'TEAM-0042' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: TEAM-0042
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Team code
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong format like “TEAM-42”, “team-0042”, or “TEAM0042”.
  - Typing the correct code but not saving (still editing).
  - Canceling the edit so the old code remains.
  - Any extra character such as a trailing space.
  expected_interaction_path:
  - Click Team code edit icon
  - Type TEAM-0042
  - Click Save (enabled only when valid)
  notes: null
- id: inline_editable_text-mantine-T05
  name: Update event title (simple text)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text + TextInput (inline edit composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Event title to “Open House” and click Save. The task
    will finish automatically when done.
  ui_copy: Change the Event title to “Open House” and click Save. The task will finish
    automatically when done.
  setup_description: 'A centered card titled “Event” shows one inline editable text
    row labeled “Event title”.

    The current value is “Launch”. Clicking the edit ActionIcon opens a one-line TextInput
    with Save/Cancel.

    A small description below the row says “Shown on the public event page”. There
    are no other inline editable text rows on the page.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: A standard single-field inline edit requiring an explicit Save
      commit, with minimal distraction.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Event title' is the one that must be checked.
    - The committed (display) value equals 'Open House' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Open House
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Event title
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Not saving after typing (still editing).
  - Saving a close value like “Open house” (case mismatch) or “OpenHouse” (missing
    space).
  - Canceling, leaving the title unchanged.
  expected_interaction_path:
  - Click Event title edit icon
  - Type Open House
  - Click Save
  notes: null
- id: inline_editable_text-mantine-T06
  name: Commit short description with toast feedback
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: TextInput + Notifications (inline edit composite)'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Change the Short description to “New orders ship Monday.” and click
    Save. The task will finish automatically when done.
  ui_copy: Change the Short description to “New orders ship Monday.” and click Save.
    The task will finish automatically when done.
  setup_description: 'A centered card titled “Description” contains one inline editable
    text row labeled “Short description”.

    The initial value is “Ships soon”. Clicking the pencil ActionIcon opens a one-line
    TextInput with Save/Cancel.

    On Save, the component shows a brief loading indicator on the Save icon and then
    displays a toast notification “Saved”.

    If the description exceeds 24 characters, an inline error appears and the value
    is not committed.'
  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: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 1
    justification: Delayed commit with transient loading/toast feedback and a character-limit
      constraint increases the chance of partial or invalid saves.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Short description' is the one that must
      be checked.
    - The committed (display) value equals 'New orders ship Monday.' exactly (case-
      and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: New orders ship Monday.
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Short description
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Missing the period or committing a close variant like “New orders ship Monday”
    (no punctuation).
  - Entering a too-long string that triggers an error and prevents commit.
  - Typing correctly but not saving (still editing).
  - Canceling, leaving the original value.
  expected_interaction_path:
  - Click Short description edit icon
  - Type New orders ship Monday.
  - Click Save and wait for return to display mode
  notes: Checker should ignore the toast and rely on committed value + display mode.
- id: inline_editable_text-mantine-T07
  name: Match internal label from reference card (two instances)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text/TextInput inline edit composite (two instances)
    + Reference card'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the Internal label to match the bold text shown in the reference
    card, then click Save. The task will finish automatically when done.
  ui_copy: Set the Internal label to match the bold text shown in the reference card,
    then click Save. The task will finish automatically when done.
  setup_description: "A centered card titled “Labels” has two inline editable text\
    \ rows:\n  • “Public label” (initial: “Customer”)\n  • “Internal label” (initial:\
    \ “Ops”)\nTo the right, a reference card titled “Reference” shows the desired\
    \ internal label in bold text.\nEach label row uses the same inline edit composite:\
    \ Text view + pencil ActionIcon, then TextInput with Save/Cancel ActionIcons.\n\
    The target string is not included in the instruction; it must be read from the\
    \ reference card. The main challenge is choosing the correct instance (Internal\
    \ label) and matching the reference exactly."
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 2
    guidance: visual
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Combines visual reference extraction with instance disambiguation
      across two same-type fields, while keeping the overall scene low clutter.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Internal label' is the one that must be
      checked.
    - The committed (display) value equals 'Back Office' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Back Office
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Internal label
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing the Public label instead of the Internal label.
  - Using a close value like “BackOffice” (missing space) or “Back office” (case mismatch).
  - Typing correctly but not saving (still editing).
  - Canceling after typing so the Internal label stays “Ops”.
  expected_interaction_path:
  - Read the bold text in the Reference card
  - Click the Internal label edit icon
  - Type the reference text
  - Click Save
  notes: Reference card content should be static for the task; checker uses the canonical
    target specified here.
- id: inline_editable_text-mantine-T08
  name: Scroll to find footer line and edit it
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: ScrollArea + Text/TextInput inline edit composite'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In the settings list, scroll until you find “Footer line”. Change
    it to “Powered by Mantine” and click Save. The task will finish automatically
    when done.
  ui_copy: In the settings list, scroll until you find “Footer line”. Change it to
    “Powered by Mantine” and click Save. The task will finish automatically when done.
  setup_description: 'The page shows a settings panel with a scrollable list of settings
    groups (inside a Mantine ScrollArea).

    Near the top are several distractor rows (toggles, selects, and read-only text)
    such as “Email alerts”, “Theme”, and “Timezone”.

    The target inline editable text row labeled “Footer line” is further down and
    is not visible at initial load without scrolling.

    “Footer line” displays a Text value (initial: “© 2026”) with a pencil ActionIcon;
    editing opens a one-line TextInput with Save/Cancel ActionIcons.

    Success depends only on committing the new Footer line value; the other settings
    are present only as clutter and do not affect completion.'
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires scrolling within a settings panel to locate the correct
      row amid distractors, then performing an exact inline edit and commit.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Footer line' is the one that must be checked.
    - The committed (display) value equals 'Powered by Mantine' exactly (case- and
      punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Powered by Mantine
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Footer line
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing a different nearby setting row (e.g., changing some other text value).
  - Typing the value but not saving (still editing).
  - Entering a close value like “Powered by  Mantine” (double space) or “Powered by
    mantine” (case mismatch).
  - Scrolling the page but never actually changing the Footer line value.
  expected_interaction_path:
  - Scroll the settings list until the Footer line row is visible
  - Click the Footer line edit icon
  - Type Powered by Mantine
  - Click Save
  notes: Checker should locate the target by its label and read committed value; avoid
    relying on scroll position.
- id: inline_editable_text-mantine-T09
  name: Enter team slug in dark theme
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Text/TextInput inline edit composite'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the Team slug to “team-ops-42” and click Save. The task will
    finish automatically when done.
  ui_copy: Set the Team slug to “team-ops-42” and click Save. The task will finish
    automatically when done.
  setup_description: 'A centered card titled “Team” is displayed on a dark-themed
    page.

    It contains one inline editable text labeled “Team slug” with initial value “team-ops-01”.

    Editing opens a one-line TextInput with helper text: “Lowercase letters, digits,
    and hyphens only”.

    If uppercase letters or spaces are used, the input shows an error and the Save
    ActionIcon is disabled until the slug is valid.

    The dark theme reduces contrast for small helper text and icon controls compared
    to light mode.'
  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: 4
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 1
    justification: Strict formatting constraints combined with reduced contrast in
      dark theme raise both precision and target acquisition difficulty.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Team slug' is the one that must be checked.
    - The committed (display) value equals 'team-ops-42' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: team-ops-42
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Team slug
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Wrong casing like “Team-ops-42” or “TEAM-OPS-42”.
  - Using underscores or spaces (e.g., “team_ops_42” or “team ops 42”).
  - Typing correctly but not saving (still editing).
  - Canceling and leaving the original slug unchanged.
  expected_interaction_path:
  - Click Team slug edit icon
  - Type team-ops-42
  - Click Save
  notes: null
- id: inline_editable_text-mantine-T10
  name: Edit display name inside a drawer (two fields, small scale)
  canonical_type: inline_editable_text
  implementation_source: mantine
  implementation_variant: composite
  implementation_component: 'Mantine: Drawer + Text/TextInput inline edit composite'
  task_template: enter_text
  secondary_template: null
  browsergym_goal: Open the Edit profile drawer. Change the Display name to “Riley
    Quinn”, then click Save. The task will finish automatically when done.
  ui_copy: Open the Edit profile drawer. Change the Display name to “Riley Quinn”,
    then click Save. The task will finish automatically when done.
  setup_description: "The main page shows a small “Edit profile” button. Clicking\
    \ it opens a Mantine Drawer that slides in from the left.\nInside the drawer is\
    \ a compact profile form with two inline editable text rows of the same canonical\
    \ type:\n  • “Display name” (initial: “Riley Q.”)\n  • “Username” (initial: “rileyq”)\n\
    Both rows use the inline edit composite: Text view with pencil ActionIcon → small-size\
    \ TextInput with Save/Cancel ActionIcons.\nThe drawer also contains a few non-editable\
    \ lines (e.g., “Account created: 2024”) as low clutter, but they do not affect\
    \ success.\nThe task requires editing the Display name (not Username) and committing\
    \ the change via Save, all within the drawer overlay context."
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_left
    scale: small
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 4
    justification: Adds an overlay layer (drawer) plus two same-type instances in
      a smaller scale UI, increasing layering and disambiguation demands alongside
      normal text entry and commit.
  success_trigger:
    human_readable:
    - The editable text instance labeled 'Display name' is the one that must be checked.
    - The committed (display) value equals 'Riley Quinn' exactly (case- and punctuation-sensitive).
    - The component is not in editing mode (mode='display').
    - The value is committed via the component's confirm control ('Save').
    canonical_predicate:
      predicate_type: equals
      target_state:
        text: Riley Quinn
        mode: display
      tolerance: null
      require_confirm: true
      confirm_control: Save
      require_correct_instance: true
      target_instance_label_or_id: Display name
      terminal_condition: task ends when predicate holds
  negative_cases:
  - Editing the Username field instead of Display name.
  - Typing the correct name but not saving (still editing).
  - Closing the drawer without committing the change.
  - Committing a close value like “Riley Quinn ” (trailing space) or “Riley Quin”
    (missing letter).
  expected_interaction_path:
  - Click Edit profile to open the drawer
  - In the drawer, click Display name edit icon
  - Type Riley Quinn
  - Click Save
  notes: Checker should ensure it reads the committed value associated with the Display
    name instance, independent of whether the drawer remains open.