tasks/v1/date_input_text.yaml

- id: date_input_text-antd-T01
  name: AntD basic typed date in ISO format
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) with manual typing enabled'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the Date entry card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Set Invoice date to 2026-02-14 (YYYY-MM-DD).'
  setup_description: |-
    Layout: isolated_card centered in the viewport (single card on an otherwise blank page).
    Component: One Ant Design DatePicker rendered inline inside the card with label “Invoice date”.
    The input shows a placeholder “YYYY-MM-DD”, a calendar icon on the right, and a clear (✕) icon that appears when a value is present.
    Initial state: the field is empty (no date selected) and no popup is open.
    Sub-controls/behavior: typing a date and pressing Enter (or blurring the field) commits the value; clicking the calendar icon would open a calendar popover but is not required.
    Distractors: none (no other inputs/buttons in the card).
    Feedback: once committed, the formatted date text is visible in the input.
  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: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single, large date input with an explicit placeholder and immediate visible feedback after typing.
  success_trigger:
    human_readable:
    - The DatePicker value (canonical date) equals 2026-02-14.
    - No confirmation button is required; the committed field value is sufficient.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-02-14'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Any other date is entered (including 2026-02-13 or 2026-02-15).
  - The text is typed but not committed (value remains empty / invalid).
  - The date is entered into a non-existent or wrong field (not applicable here, but still invalid).
  expected_interaction_path: Click the input → type 2026-02-14 → press Enter or click outside to commit.
  notes: 'Instrumentation: expose the DatePicker input as data-testid=''invoice-date''. Checker should read the component value and normalize to ISO YYYY-MM-DD.'
- id: date_input_text-antd-T02
  name: AntD overwrite an existing date
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) with manual typing enabled'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Change the “Shipping date” field to 2026-02-20 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Shipping date should be 2026-02-20.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One Ant Design DatePicker labeled “Shipping date”.
    Initial state: the field is pre-filled with 2026-02-01 (YYYY-MM-DD). The clear icon is available because a value is set.
    Sub-controls/behavior: the date can be edited by focusing the input and typing over the existing value; calendar popover is available but optional.
    Distractors: a non-interactive summary line under the field (“Orders ship within 2 business days.”) to look realistic.
    Feedback: the input text updates to the new date when committed.
  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: Requires replacing an existing value, but the field is still isolated with clear visual confirmation.
  success_trigger:
    human_readable:
    - The DatePicker value (canonical date) equals 2026-02-20.
    - No additional Save/Apply action is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-02-20'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Leaving the original date (2026-02-01) unchanged.
  - Entering 2026-02-02 or any other off-by-one date.
  - Typing the date but leaving the field in an invalid/uncommitted state (checker still reads old value).
  expected_interaction_path: Click the input → select all (or clear) → type 2026-02-20 → commit by Enter/blur.
  notes: 'Instrumentation: data-testid=''shipping-date''. Consider normalizing value via onChange-emitted Dayjs/Date object to ISO.'
- id: date_input_text-antd-T03
  name: AntD clear a pre-filled date
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) with allowClear'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done.
  ui_copy: 'Goal: Reminder date should be cleared (empty).'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One Ant Design DatePicker labeled “Reminder date”.
    Initial state: the field contains 2026-03-10 (YYYY-MM-DD).
    Sub-controls/behavior: a small clear (✕) icon becomes available in the input when it has a value (typical AntD allowClear behavior). Clearing removes the value and restores the placeholder.
    Distractors: none.
    Feedback: after clearing, the input shows the placeholder text again and the value becomes null/empty.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: The main challenge is acquiring the small clear control; otherwise the task is straightforward with immediate feedback.
  success_trigger:
    human_readable:
    - The DatePicker value is empty/null (no date selected).
    - The field shows the empty state (placeholder visible) and no date is committed.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: null
      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
      canonical_type: date_input_text
      empty_ok: true
  negative_cases:
  - A date value remains set (including the original 2026-03-10).
  - The user types and leaves an invalid string that does not clear the underlying value.
  - Clearing is attempted but the value is not actually removed (e.g., only selects text).
  expected_interaction_path: Hover/focus the input if needed → click the clear (✕) icon (or delete the value and commit) → verify placeholder returns.
  notes: 'Instrumentation: data-testid=''reminder-date''. Checker should treat null/undefined/empty as cleared.'
- id: date_input_text-antd-T04
  name: AntD typed date in US format
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) with format MM/DD/YYYY'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the “Event date” field to 03/03/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Goal: Event date = 03/03/2026.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One Ant Design DatePicker labeled “Event date”.
    Configuration: display/parse format is set to MM/DD/YYYY, and the placeholder shows “MM/DD/YYYY”.
    Initial state: empty.
    Sub-controls/behavior: typing is supported; the calendar popover exists but is optional.
    Distractors: none.
    Feedback: after commit, the input shows “03/03/2026”.
  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: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single field with an explicit format hint; success is an exact semantic date match.
  success_trigger:
    human_readable:
    - The DatePicker value (canonical date) equals 2026-03-03.
    - The displayed text corresponds to MM/DD/YYYY for that date.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-03-03'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      expected_display_format: MM/DD/YYYY
  negative_cases:
  - Entering 03/02/2026 or 02/03/2026 (month/day swapped).
  - Entering a malformed date that does not parse (field remains empty/invalid).
  - Leaving the field empty.
  expected_interaction_path: Click input → type 03/03/2026 → press Enter or blur.
  notes: 'Instrumentation: data-testid=''event-date''. Checker should compare parsed date, not raw text.'
- id: date_input_text-antd-T05
  name: AntD pick the correct field among two instances
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) x2 in a form section'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Booking form: Set End date to 2026-05-20.'
  setup_description: |-
    Layout: form_section centered in the viewport, resembling a typical booking form.
    Components: Two Ant Design DatePicker inputs shown inline in the same section:
      1) “Start date” (pre-filled with 2026-05-10)
      2) “End date” (empty)
    Both fields use the same YYYY-MM-DD format and both allow manual typing.
    Sub-controls: each input has its own calendar icon and clear behavior.
    Distractors (clutter=low): there is also a “Guests” numeric input and a disabled “Promo code” text box, but they do not affect success.
    Feedback: the “End date” field shows the selected/typed date once committed.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two identical date inputs require disambiguation by label; otherwise the interaction is direct typing with immediate feedback.
  success_trigger:
    human_readable:
    - The “End date” DatePicker value equals 2026-05-20.
    - The “Start date” field may be unchanged; only the targeted instance is checked.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-05-20'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: End date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Setting the “Start date” to 2026-05-20 while leaving “End date” empty.
  - Entering 2026-05-02 or any other date (wrong day/month).
  - Typing into the field but not committing (checker still reads empty).
  expected_interaction_path: Locate “End date” → focus input → type 2026-05-20 → commit by Enter/blur.
  notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Checker must ensure correct instance by associated label.'
- id: date_input_text-antd-T06
  name: AntD match a date from a visual reference badge
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) with manual typing enabled'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Report date” field to match the date shown on the “Reference stamp” on the page. The task will finish automatically when done.
  ui_copy: 'Goal: Report date must match the Reference stamp.'
  setup_description: |-
    Layout: dashboard-style card with two columns, centered in the viewport.
    Left column: an Ant Design DatePicker labeled “Report date” (format YYYY-MM-DD) with placeholder “YYYY-MM-DD”.
    Right column: a prominent “Reference stamp” badge styled like a rubber stamp. It visually displays the target date as:
      “JUN 01 2026”
    Initial state: “Report date” is empty.
    Distractors (clutter=low): a small “Report title” text field is present but disabled and does not affect success.
    Feedback: after entering a valid date, the DatePicker shows the formatted date text in the input.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: The target date is not provided in the instruction and must be read from an on-screen reference, increasing observability demand.
  success_trigger:
    human_readable:
    - The “Report date” DatePicker value equals the reference date 2026-06-01.
    - No additional confirmation action is required.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        date_iso: '2026-06-01'
        reference_id: reference-stamp
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Report date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Entering any other date that does not match the Reference stamp.
  - Leaving the field empty.
  - Typing an invalid string that fails to parse (value remains null).
  expected_interaction_path: Read the date from the Reference stamp → focus “Report date” → type the equivalent YYYY-MM-DD value → commit.
  notes: 'Instrumentation: reference badge data-testid=''reference-stamp'' (for dataset generation) and input data-testid=''report-date''. Checker uses the fixed target date encoded in the task instance.'
- id: date_input_text-antd-T07
  name: AntD date input inside a modal with Save/Cancel
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Modal + DatePicker (date) in a form'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open the “Edit reservation” dialog, set “Check-in date” to 2026-07-04 (YYYY-MM-DD), then click “Save reservation”. The task will finish automatically when done.
  ui_copy: Edit reservation → set Check-in date to 2026-07-04 → Save reservation.
  setup_description: |-
    Layout: modal_flow. The base page shows a small reservation summary card and a primary button “Edit reservation”.
    When “Edit reservation” is clicked, an Ant Design Modal opens in the center of the screen.
    Inside the modal is a short form with:
      - “Guest name” (prefilled text input; not required)
      - “Check-in date” (Ant Design DatePicker; format YYYY-MM-DD; manual typing enabled)
    Initial state: modal is closed; “Check-in date” is empty once the modal opens.
    Actions: modal footer has two buttons: “Cancel” (secondary) and “Save reservation” (primary).
    Feedback: clicking “Save reservation” closes the modal and shows a small inline success message under the reservation summary (“Saved”).
  scene_context:
    theme: light
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires opening a modal layer and committing via an explicit Save button; success depends on both the entered date and confirmation.
  success_trigger:
    human_readable:
    - The “Check-in date” value in the modal form equals 2026-07-04.
    - The user has clicked “Save reservation” (confirmation required) and the saved value is persisted.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-07-04'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Save reservation
      require_correct_instance: true
      target_instance_label_or_id: Check-in date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      persisted_state_id: reservation.checkin
  negative_cases:
  - Correct date is entered but “Save reservation” is not clicked (modal left open).
  - Clicking “Cancel” after entering the date (should not count).
  - Saving with any date other than 2026-07-04.
  - Entering text that looks right but does not parse to a valid date value.
  expected_interaction_path: Click “Edit reservation” → focus Check-in date → type 2026-07-04 → commit → click “Save reservation”.
  notes: 'Instrumentation: modal root data-testid=''edit-reservation-modal''; input data-testid=''checkin-date''; save button data-testid=''save-reservation''. Checker should verify a persisted state update, not just transient text.'
- id: date_input_text-antd-T08
  name: AntD masked date input in dark compact small card
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: mask_format
  implementation_component: 'AntD: DatePicker (date) using Mask Format demo-style input'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the Cutoff card, enter 2026-12-31 into the “Cutoff date” field. The task will finish automatically when done.
  ui_copy: 'Cutoff card: Cutoff date should be 2026-12-31.'
  setup_description: |-
    Layout: isolated_card anchored at the top-right of the viewport (not centered).
    Theme/spacing: dark theme with compact spacing; the component uses the small size variant.
    Component: one Ant Design DatePicker labeled “Cutoff date”.
    Configuration: the field uses a mask-like date format (YYYY-MM-DD) where the caret advances by segments; the placeholder shows a partially formatted mask (e.g., “YYYY-MM-DD” with guides).
    Initial state: empty. No popup is open.
    Sub-controls/behavior: the input attempts to align to the last valid date on blur if the typed text is close but incomplete; arrow keys can move between segments; the calendar icon is present but small.
    Distractors: none.
    Feedback: once a valid date is committed, the masked field displays the fully formatted date.
  scene_context:
    theme: dark
    spacing: compact
    layout: isolated_card
    placement: top_right
    scale: small
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 3
      disambiguation_load: 1
    justification: Small, compact masked input in a corner placement increases target acquisition difficulty and requires precise formatted entry/segment editing.
  success_trigger:
    human_readable:
    - The “Cutoff date” value equals 2026-12-31 after the input is committed.
    - No Save/Apply button is required.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-12-31'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Cutoff date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      input_mode: mask
  negative_cases:
  - Entering 2026-12-13 or 2026-11-31 (wrong day/month).
  - Leaving the input partially filled so the underlying date value is still null/invalid.
  - Relying on auto-alignment to a different date than the target.
  expected_interaction_path: Focus the small masked field → type 2026-12-31 (or fill segments) → blur/Enter to commit.
  notes: 'Implementation hint: use AntD DatePicker Mask Format example configuration. Instrument input as data-testid=''cutoff-date''.'
- id: date_input_text-antd-T09
  name: AntD edit a date field inside a dense table row
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: Table + DatePicker (date) in table cells'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Milestones table, set the “Milestone date” for the “Beta” row to 2026-04-01 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Milestones table: Beta → Milestone date = 2026-04-01.'
  setup_description: |-
    Layout: table_cell scene with the table centered in the viewport.
    Component instances: three Ant Design DatePicker inputs rendered directly inside the “Milestone date” column cells (one per row).
    Rows: “Alpha”, “Beta”, “Gamma”.
    Each cell shows a small DatePicker input (size=small, format YYYY-MM-DD) with a calendar icon; manual typing is enabled.
    Initial state:
      - Alpha milestone date: 2026-03-15
      - Beta milestone date: empty
      - Gamma milestone date: 2026-05-10
    Clutter (high): table also includes an “Owner” dropdown and a “Status” tag column; these are distractors and not required.
    Feedback: the edited cell updates immediately after commit and the table highlights the changed cell briefly (1s).
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: center
    scale: small
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Multiple small, similar date inputs inside a dense table require precise target acquisition and correct row disambiguation.
  success_trigger:
    human_readable:
    - In the “Beta” row, the “Milestone date” cell’s DatePicker value equals 2026-04-01.
    - Other rows’ milestone dates may remain unchanged.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-04-01'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Milestone date (Beta)
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      table_row_key: Beta
      table_column_key: milestone_date
  negative_cases:
  - Setting the Alpha or Gamma row’s date to 2026-04-01 instead of Beta.
  - Entering 2026-01-04 (month/day swapped) or any other incorrect date.
  - Leaving Beta empty or in an invalid state.
  expected_interaction_path: Find the Beta row → focus its Milestone date input → type 2026-04-01 → commit by Enter/blur.
  notes: 'Instrumentation: add data-row-key attributes for each row and data-testid for each cell input (e.g., milestone-date-beta). Checker should resolve the correct row via stable row key, not screen position.'
- id: date_input_text-antd-T10
  name: AntD match reference date with Apply in a cluttered dashboard
  canonical_type: date_input_text
  implementation_source: antd
  implementation_variant: null
  implementation_component: 'AntD: DatePicker (date) x2 + sticky Apply bar'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Backup deadline” field to match the date shown on the “Reference calendar” tile, then click “Apply changes”. The task will finish automatically when done.
  ui_copy: 'Dashboard: Backup deadline must match Reference calendar, then Apply changes.'
  setup_description: |-
    Layout: dashboard scene anchored at the bottom-right of the viewport (not centered).
    Components: Two Ant Design DatePicker inputs in a “Deadlines” panel:
      - “Primary deadline” (pre-filled with 2026-04-01)
      - “Backup deadline” (empty)
    Both use YYYY-MM-DD format and allow manual typing.
    Visual reference: a separate tile labeled “Reference calendar” shows the target date prominently as “APR 09 2026”.
    Clutter (medium): the dashboard also contains a small activity feed and two filter chips; they are irrelevant.
    Confirmation: a sticky footer bar contains “Discard” and a primary “Apply changes” button. Changes are not persisted until “Apply changes” is clicked.
    Feedback: clicking “Apply changes” shows a toast “Changes applied” and the sticky bar disappears.
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: bottom_right
    scale: default
    instances: 2
    guidance: visual
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 3
    justification: Requires reading a visual reference, editing the correct field among two similar instances, and committing via an explicit Apply action.
  success_trigger:
    human_readable:
    - The “Backup deadline” DatePicker value equals the reference date 2026-04-09.
    - The user has clicked “Apply changes” (confirmation required) so the value is persisted.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        date_iso: '2026-04-09'
        reference_id: reference-calendar-tile
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Apply changes
      require_correct_instance: true
      target_instance_label_or_id: Backup deadline
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      persisted_state_id: deadlines.backup
  negative_cases:
  - Setting “Primary deadline” instead of “Backup deadline”.
  - Entering the correct date but not clicking “Apply changes”.
  - Clicking “Discard”.
  - Choosing a date that is off by one day (e.g., 2026-04-08 or 2026-04-10).
  expected_interaction_path: Read date on Reference calendar tile → focus Backup deadline → type corresponding YYYY-MM-DD → commit → click Apply changes.
  notes: 'Instrumentation: data-testid=''primary-deadline'', ''backup-deadline'', ''apply-changes'', ''reference-calendar-tile''. Checker should verify persisted state updated after Apply.'
- id: date_input_text-mui-T01
  name: MUI DateField basic typed date (MM/DD/YYYY)
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the “Birthday” field to 03/15/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Goal: Birthday = 03/15/2026.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One MUI X DateField labeled “Birthday”.
    Visuals/behavior: the field shows a placeholder like “MM/DD/YYYY” and uses a sectioned input (month/day/year sections) typical of MUI X fields.
    Initial state: empty; no popover is open (field-only).
    Sub-controls: a calendar icon is not shown (DateField only); the user edits directly in the field.
    Distractors: none.
    Feedback: once a valid date is entered, the field displays it in MM/DD/YYYY and the internal value becomes a valid date object.
  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: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single date field with a clear placeholder; no overlays or extra confirmations.
  success_trigger:
    human_readable:
    - The DateField value (canonical date) equals 2026-03-15.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-03-15'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Entering 03/05/2026 or 05/03/2026 (swapped day/month).
  - Leaving the field incomplete so it does not parse to a valid date value.
  - Leaving it empty.
  expected_interaction_path: Focus the DateField → type 03/15/2026 (or fill sections) → blur/Enter to commit.
  notes: 'Instrumentation: data-testid=''birthday-datefield''. Checker should normalize the Date value to ISO.'
- id: date_input_text-mui-T02
  name: MUI DateField overwrite an existing date
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Change the “Start date” field to 02/28/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Goal: Start date should be 02/28/2026.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One MUI X DateField labeled “Start date”.
    Initial state: pre-filled with 02/10/2026.
    Behavior: the DateField uses month/day/year sections; user can edit by selecting sections and typing.
    Distractors: a read-only “Project name” text line above the field.
    Feedback: the value updates in place when the edit is committed (blur/Enter).
  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: Overwriting a pre-filled value adds a small edit step, but the field is isolated with clear feedback.
  success_trigger:
    human_readable:
    - The “Start date” DateField value equals 2026-02-28.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-02-28'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Start date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Leaving the original date (02/10/2026).
  - Entering 02/18/2026 or any other incorrect date.
  - Typing but not committing (checker still reads old value).
  expected_interaction_path: Focus Start date field → select/overwrite sections → type 02/28/2026 → commit.
  notes: 'Instrumentation: data-testid=''start-date''. For sectioned fields, checker should read the component value rather than DOM text only.'
- id: date_input_text-mui-T03
  name: MUI DateField clear using clearable control
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField (clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Due date” field so it becomes empty. The task will finish automatically when done.
  ui_copy: 'Goal: Due date should be cleared (empty).'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: One MUI X DateField labeled “Due date” with clearable behavior enabled.
    Initial state: pre-filled with 04/05/2026.
    Sub-controls: a small clear icon button appears inside the field when it has a value (standard MUI X clearable behavior).
    Distractors: none.
    Feedback: after clearing, the field shows the placeholder “MM/DD/YYYY” again and the value becomes null.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Clearing requires acquiring a small clear icon (or deleting all sections), but the page is otherwise minimal.
  success_trigger:
    human_readable:
    - The “Due date” DateField value is empty/null (no date selected).
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Due date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      empty_ok: true
  negative_cases:
  - A date value remains set (including 04/05/2026).
  - Only selecting text/sections without clearing the underlying value.
  - Leaving an invalid partial date that does not clear to null.
  expected_interaction_path: Focus Due date field → click clear icon (or delete content) → ensure placeholder returns.
  notes: 'Instrumentation: data-testid=''due-date''. If using MUI X clearable prop, also tag clear button data-testid=''due-date-clear''.'
- id: date_input_text-mui-T04
  name: MUI two DateFields in a form section (disambiguate by label)
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField x2'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the Schedule form, set the “End date” field to 05/20/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Schedule form: End date = 05/20/2026.'
  setup_description: |-
    Layout: form_section centered in the viewport with a header “Schedule”.
    Components: two MUI X DateField inputs stacked with labels:
      - “Start date” (pre-filled with 05/10/2026)
      - “End date” (empty)
    Both fields use MM/DD/YYYY and sectioned editing.
    Distractors (clutter=low): a “Timezone” select (disabled) and a “Notes” multiline field (optional) are visible.
    Feedback: entering a valid date updates the field’s displayed value and removes any placeholder sections.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Two similar fields require selecting the correct instance; otherwise the interaction is simple sectioned typing.
  success_trigger:
    human_readable:
    - The “End date” DateField value equals 2026-05-20.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-05-20'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: End date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Setting “Start date” to 05/20/2026 instead of “End date”.
  - Entering 05/02/2026 or any other incorrect date.
  - Leaving End date empty.
  expected_interaction_path: Find End date field → focus → type 05/20/2026 → commit.
  notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''. Ensure labels are programmatically associated with inputs for accessibility-based agents.'
- id: date_input_text-mui-T05
  name: MUI DateField with dash separator custom format
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField (custom format YYYY-MM-DD)'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: Set the “Archive date” field to 2026-06-30 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Archive date = 2026-06-30.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: one MUI X DateField labeled “Archive date”.
    Configuration: the field uses a dash-separated display/parse format (YYYY-MM-DD) and shows a placeholder like “YYYY-MM-DD”.
    Initial state: empty.
    Behavior: sectioned input still applies, but separators are dashes; users can type the full string or edit sections.
    Distractors: none.
    Feedback: the value becomes valid only when all sections form a real calendar date.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Custom formatting increases precision requirements and can trip agents that assume the default MM/DD/YYYY layout.
  success_trigger:
    human_readable:
    - The “Archive date” DateField value equals 2026-06-30.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-06-30'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Archive date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      expected_display_format: YYYY-MM-DD
  negative_cases:
  - Entering 06/30/2026 (slashes) if it does not parse under the configured format.
  - Entering 2026-30-06 (swapped month/day).
  - Leaving the field partially filled so it remains invalid.
  expected_interaction_path: Focus Archive date → type 2026-06-30 → commit by blur/Enter.
  notes: 'Instrumentation: data-testid=''archive-date''. Configure MUI X format explicitly so the UI is deterministic.'
- id: date_input_text-mui-T06
  name: MUI scroll to find a date field in settings panel
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField inside a scrollable Settings panel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In Settings, scroll to the “Data retention start date” field and set it to 08/01/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Settings: Data retention start date = 08/01/2026.'
  setup_description: |-
    Layout: settings_panel. The page has a left navigation rail (non-interactive for this task) and a main scrollable settings pane.
    Target component: a MUI X DateField labeled “Data retention start date” located in the “Retention” section near the bottom of the scrollable pane (initially below the fold).
    Initial state: the field is empty.
    Other content (clutter=medium): multiple toggles, helper text paragraphs, and a numeric input appear above it; none affect success.
    Behavior: standard sectioned MM/DD/YYYY input; no popovers.
    Feedback: after entry, the field displays “08/01/2026” and the section header shows a small “Unsaved changes” dot (cosmetic).
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires scrolling within a settings pane to locate the correct labeled field amid moderate clutter before performing the usual date entry.
  success_trigger:
    human_readable:
    - The “Data retention start date” DateField value equals 2026-08-01.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-08-01'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Data retention start date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      scroll_required: true
  negative_cases:
  - Entering the date in a different setting field.
  - Entering any date other than 08/01/2026.
  - Leaving the field empty because it was not found.
  expected_interaction_path: Scroll the settings pane until the Retention section → focus Data retention start date → type 08/01/2026 → commit.
  notes: 'Instrumentation: data-testid=''retention-start-date''. Include a stable section container id for scroll targeting.'
- id: date_input_text-mui-T07
  name: MUI match a date from a shipping label preview
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Ship date” field to match the date shown on the “Shipping label preview”. The task will finish automatically when done.
  ui_copy: 'Goal: Ship date must match the Shipping label preview.'
  setup_description: |-
    Layout: dashboard-style card centered in the viewport.
    Left side: a MUI X DateField labeled “Ship date” (MM/DD/YYYY).
    Right side: a “Shipping label preview” panel that visually prints the target date in bold, uppercase stamp style:
      “SEP 09 2026”
    Initial state: Ship date field is empty.
    Clutter (low): a disabled “Carrier” dropdown is visible under the preview (not required).
    Feedback: when a valid date is entered, the date field updates; the preview’s “Ship date” line also updates (cosmetic).
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: The instruction omits the exact date, requiring the agent to extract it from a visual preview before entering it.
  success_trigger:
    human_readable:
    - The “Ship date” value equals the reference date 2026-09-09.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        date_iso: '2026-09-09'
        reference_id: shipping-label-preview
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Ship date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Entering a different date than shown in the preview.
  - Leaving the field empty or invalid.
  - Entering the correct date into a non-target field (if any).
  expected_interaction_path: Read the stamped date on the preview → enter that date into Ship date → commit.
  notes: 'Instrumentation: data-testid=''ship-date'' and ''shipping-label-preview''.'
- id: date_input_text-mui-T08
  name: MUI DatePicker field inside dark themed modal with Save
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DatePicker
  implementation_component: 'MUI X: DatePicker (keyboard input) inside a Dialog'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open the “New appointment” dialog, set “Appointment date” to 10/12/2026 (MM/DD/YYYY), then click “Save appointment”. The task will finish automatically when done.
  ui_copy: New appointment → Appointment date = 10/12/2026 → Save appointment.
  setup_description: |-
    Layout: modal_flow with dark theme.
    Base page: a small toolbar with a primary button “New appointment”.
    Clicking it opens a MUI Dialog in the center containing a short form:
      - “Title” text field (prefilled; not required)
      - “Appointment date” using MUI X DatePicker input field (manual typing supported; calendar popover can be opened from the field but is optional)
    Footer buttons: “Cancel” and “Save appointment”.
    Initial state: Appointment date is empty when the dialog opens.
    Feedback: after clicking “Save appointment”, the dialog closes and an inline confirmation text appears (“Appointment saved”).
  scene_context:
    theme: dark
    spacing: comfortable
    layout: modal_flow
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Multiple-layer interaction (open dialog, edit date, then explicitly save) with dark theme reduces contrast and increases layering/feedback demands.
  success_trigger:
    human_readable:
    - The “Appointment date” value equals 2026-10-12.
    - The user clicked “Save appointment” and the saved value is persisted.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-10-12'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Save appointment
      require_correct_instance: true
      target_instance_label_or_id: Appointment date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      persisted_state_id: appointment.date
  negative_cases:
  - Entering the correct date but closing the dialog without saving.
  - Clicking “Cancel”.
  - Saving a different date.
  - Leaving the field invalid/empty.
  expected_interaction_path: Click New appointment → focus Appointment date field → type 10/12/2026 → commit → click Save appointment.
  notes: 'Instrumentation: data-testid=''new-appointment'', dialog data-testid=''appointment-dialog'', date field data-testid=''appointment-date'', save button data-testid=''save-appointment''.'
- id: date_input_text-mui-T09
  name: MUI edit a date field inside a compact table
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DateField
  implementation_component: 'MUI X: DateField in DataGrid/Table cells'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Release plan table, set the “Release date” for the “v2.0” row to 11/01/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Release plan: v2.0 → Release date = 11/01/2026.'
  setup_description: |-
    Layout: table_cell anchored near the top-left of the viewport.
    Theme/spacing: light theme with compact spacing; small component scale.
    Table: a compact release plan table with three rows: “v1.0”, “v2.0”, “v3.0”.
    Component instances: each row contains an inline editable MUI X DateField in the “Release date” column (MM/DD/YYYY).
    Initial state:
      - v1.0: 09/01/2026
      - v2.0: empty
      - v3.0: 12/15/2026
    Clutter (high): additional columns (“Owner”, “Risk”) include chips and icons; not required.
    Feedback: after a valid date is entered in the v2.0 row, the cell shows the formatted date and briefly displays a small “Edited” indicator on that row.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: top_left
    scale: small
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Dense table layout with multiple small, similar date fields creates high disambiguation load and target acquisition difficulty.
  success_trigger:
    human_readable:
    - In the “v2.0” row, the “Release date” field value equals 2026-11-01.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-11-01'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Release date (v2.0)
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      table_row_key: v2.0
      table_column_key: release_date
  negative_cases:
  - Editing v1.0 or v3.0 instead of v2.0.
  - Entering 01/11/2026 (day/month swapped) or any other incorrect date.
  - Leaving the v2.0 cell empty or invalid.
  expected_interaction_path: Locate v2.0 row → focus Release date cell → type 11/01/2026 → commit.
  notes: 'Instrumentation: stable row keys; data-testid=''release-date-v2''. Checker should match by row key, not visual order.'
- id: date_input_text-mui-T10
  name: MUI fix a validation error and set an in-range date
  canonical_type: date_input_text
  implementation_source: mui
  implementation_variant: DatePicker
  implementation_component: 'MUI X: DatePicker (keyboard input) with min/max validation'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the “Compliance date” field to 07/01/2026 (MM/DD/YYYY). The task will finish automatically when done.
  ui_copy: 'Compliance: Compliance date must be 07/01/2026.'
  setup_description: |-
    Layout: form_section anchored near the bottom-left of the viewport.
    Component: a single MUI X DatePicker input labeled “Compliance date” (manual typing supported).
    Validation configuration: the field enforces an allowed range (minDate=01/01/2026, maxDate=12/31/2026) and shows an error helper text when out of range.
    Initial state: the field is pre-filled with 01/01/2027 and is currently in an error state (red underline + helper text “Date must be within 2026”).
    Clutter (medium): there are two non-required controls nearby: a checkbox “Send reminder email” and a disabled text field “Compliance owner”.
    Feedback: when a valid in-range date is entered, the error state disappears and the helper text changes to “Looks good”.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: bottom_left
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 2
      feedback_dynamics: 4
      semantic_observability: 2
      disambiguation_load: 2
    justification: The field starts in an error state with range validation, requiring the agent to correct the value and observe error feedback clearing.
  success_trigger:
    human_readable:
    - The “Compliance date” value equals 2026-07-01.
    - The field is not in an error/invalid state after commit.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-07-01'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Compliance date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      require_valid: true
  negative_cases:
  - Entering a date outside 2026 (error remains).
  - Entering 01/07/2026 (month/day swapped).
  - Leaving the invalid initial value (01/01/2027).
  - Typing without committing so the component value does not update.
  expected_interaction_path: Focus Compliance date → replace with 07/01/2026 → commit → verify error cleared.
  notes: 'Instrumentation: data-testid=''compliance-date''. Checker should verify both value equality and validity flag (no error).'
- id: date_input_text-mantine-T01
  name: Mantine DateInput basic typed ISO date
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput'
  task_template: enter_formatted
  secondary_template: null
  browsergym_goal: In the Date input card, set the “Invoice date” field to 2026-02-14 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Invoice date = 2026-02-14.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: one Mantine DateInput labeled “Invoice date”.
    Configuration: the input displays/accepts YYYY-MM-DD (valueFormat set accordingly) and shows placeholder “YYYY-MM-DD”.
    Initial state: empty; dropdown calendar is closed.
    Sub-controls: a calendar icon is shown inside the input; a clear button appears only when a value exists (if clearable is enabled, but not needed here).
    Distractors: none.
    Feedback: after committing a valid date, the input displays the formatted value and keeps it as the canonical date state.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L0
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 2
      disambiguation_load: 1
    justification: Single Mantine DateInput with explicit placeholder and immediate visible value after typing.
  success_trigger:
    human_readable:
    - The DateInput value (canonical date) equals 2026-02-14.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-02-14'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: false
      target_instance_label_or_id: null
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Entering 2026-02-41 or another invalid date string (should not parse).
  - Entering any other date.
  - Leaving the field empty.
  expected_interaction_path: Click input → type 2026-02-14 → blur/Enter to commit.
  notes: 'Instrumentation: data-testid=''invoice-date''. Checker reads Date value and normalizes to ISO.'
- id: date_input_text-mantine-T02
  name: Mantine overwrite an existing date value
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Change the “Renewal date” field to 2026-03-31 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Renewal date should be 2026-03-31.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: one Mantine DateInput labeled “Renewal date” with valueFormat YYYY-MM-DD.
    Initial state: pre-filled with 2026-03-01.
    Sub-controls: calendar icon is present but optional; editing can be done via typing.
    Distractors: none.
    Feedback: once a valid date is committed, the input displays the new value and any internal error state remains clear.
  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: Requires replacing an existing value but remains a single isolated date input with clear feedback.
  success_trigger:
    human_readable:
    - The “Renewal date” DateInput value equals 2026-03-31.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-03-31'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Renewal date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Leaving the original date (2026-03-01).
  - Entering 2026-03-13 or any other incorrect date.
  - Typing without committing so the value doesn't update.
  expected_interaction_path: Focus Renewal date → select/overwrite → type 2026-03-31 → commit.
  notes: 'Instrumentation: data-testid=''renewal-date''.'
- id: date_input_text-mantine-T03
  name: Mantine clear a date with clearable button
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput (clearable)'
  task_template: clear_reset
  secondary_template: null
  browsergym_goal: Clear the “Reminder date” field so it becomes empty. The task will finish automatically when done.
  ui_copy: 'Goal: Reminder date should be cleared (empty).'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: one Mantine DateInput labeled “Reminder date” with clearable enabled (clear button appears in the right section when a value exists).
    Initial state: pre-filled with 2026-04-10.
    Sub-controls: calendar icon + clear (✕) button within the input’s right section.
    Distractors: none.
    Feedback: clearing removes the value and restores the placeholder “YYYY-MM-DD”.
  scene_context:
    theme: light
    spacing: comfortable
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: easy
    tier: L1
    axes_ratings:
      precision_requirement: 1
      target_acquisition: 3
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 1
    justification: Clearing relies on a small right-section control, but the rest of the scene is minimal and the cleared state is obvious.
  success_trigger:
    human_readable:
    - The “Reminder date” DateInput value is empty/null (no date selected).
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: null
      tolerance: null
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Reminder date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      empty_ok: true
  negative_cases:
  - Any date remains set (including 2026-04-10).
  - Selecting text without clearing the underlying value.
  - Leaving an invalid partial string that does not clear to null.
  expected_interaction_path: Focus Reminder date → click the clear (✕) button (or delete all text) → commit/blur.
  notes: 'Instrumentation: data-testid=''reminder-date'' and data-testid=''reminder-date-clear'' for the clear button.'
- id: date_input_text-mantine-T04
  name: Mantine two DateInputs in a form section
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput x2'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: In the Booking form, set the “End date” field to 2026-05-20 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Booking form: End date = 2026-05-20.'
  setup_description: |-
    Layout: form_section centered in the viewport with header “Booking”.
    Components: two Mantine DateInput fields side-by-side:
      - “Start date” (pre-filled with 2026-05-10)
      - “End date” (empty)
    Both use valueFormat YYYY-MM-DD and allow free-form typing; calendar dropdown is available but optional.
    Distractors (clutter=low): a “Guests” number input and a “Room type” select are shown but not required.
    Feedback: after committing a valid date, the End date input shows the new value.
  scene_context:
    theme: light
    spacing: comfortable
    layout: form_section
    placement: center
    scale: default
    instances: 2
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 3
    justification: Requires choosing the correct date field among two similar instances within a realistic form layout.
  success_trigger:
    human_readable:
    - The “End date” DateInput value equals 2026-05-20.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-05-20'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: End date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Setting “Start date” instead of “End date”.
  - Entering 2026-05-02 or any other incorrect date.
  - Leaving End date empty/invalid.
  expected_interaction_path: Focus End date → type 2026-05-20 → blur/Enter.
  notes: 'Instrumentation: data-testid=''start-date'' and ''end-date''.'
- id: date_input_text-mantine-T05
  name: Mantine match a date from a packing slip preview
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Delivery date” field to match the date shown on the “Packing slip preview”. The task will finish automatically when done.
  ui_copy: 'Goal: Delivery date must match the Packing slip preview.'
  setup_description: |-
    Layout: dashboard scene centered in the viewport.
    Left pane: Mantine DateInput labeled “Delivery date” (valueFormat YYYY-MM-DD).
    Right pane: “Packing slip preview” card with a large printed date line in a stylized header:
      “JUN 10 2026”
    Initial state: Delivery date input is empty.
    Clutter (low): the preview also shows a fake order number and address lines (non-interactive).
    Feedback: once a valid date is entered, the Delivery date field displays it; the preview updates a small “Delivery date” line (cosmetic).
  scene_context:
    theme: light
    spacing: comfortable
    layout: dashboard
    placement: center
    scale: default
    instances: 1
    guidance: visual
    clutter: low
  difficulty:
    difficulty_bucket: mid
    tier: L1
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 1
      semantic_observability: 3
      disambiguation_load: 2
    justification: The date must be extracted from an on-screen preview rather than being provided directly in text instructions.
  success_trigger:
    human_readable:
    - The “Delivery date” DateInput value equals the reference date 2026-06-10.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        date_iso: '2026-06-10'
        reference_id: packing-slip-preview
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Delivery date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
  negative_cases:
  - Entering a different date than shown on the preview.
  - Leaving the input empty or invalid.
  - Typing the date into a non-target field (if any).
  expected_interaction_path: Read date from Packing slip preview → type equivalent YYYY-MM-DD into Delivery date → commit.
  notes: 'Instrumentation: data-testid=''delivery-date'' and data-testid=''packing-slip-preview''.'
- id: date_input_text-mantine-T06
  name: Mantine scroll to locate a DateInput in settings panel
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput in a scrollable Settings panel'
  task_template: scroll_find
  secondary_template: null
  browsergym_goal: In Settings, scroll to the “Maintenance date” field and set it to 2026-07-15 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Settings: Maintenance date = 2026-07-15.'
  setup_description: |-
    Layout: settings_panel with a scrollable main content area.
    Target component: a Mantine DateInput labeled “Maintenance date” in the “System maintenance” section located near the bottom of the settings content (initially below the fold).
    Configuration: valueFormat YYYY-MM-DD; free-form typing enabled.
    Initial state: empty.
    Clutter (medium): several switches, sliders, and informational callouts appear above; they are distractors.
    Feedback: after entering a valid date, the input shows the formatted date and a small helper text appears (“Next maintenance scheduled”).
  scene_context:
    theme: light
    spacing: comfortable
    layout: settings_panel
    placement: bottom_right
    scale: default
    instances: 1
    guidance: text
    clutter: medium
  difficulty:
    difficulty_bucket: mid
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 2
      depth_layering: 3
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 2
    justification: The agent must scroll within a settings panel to find the correct labeled DateInput amid moderate clutter before entering the target date.
  success_trigger:
    human_readable:
    - The “Maintenance date” DateInput value equals 2026-07-15.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-07-15'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Maintenance date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      scroll_required: true
  negative_cases:
  - Entering the date in a different field in Settings.
  - Entering any date other than 2026-07-15.
  - Leaving the Maintenance date field empty because it was not found.
  expected_interaction_path: Scroll to System maintenance section → focus Maintenance date → type 2026-07-15 → commit.
  notes: 'Instrumentation: data-testid=''maintenance-date''. Provide stable section anchors for automated scrolling.'
- id: date_input_text-mantine-T07
  name: Mantine DateInput with min/max and weekdays-only validation
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput with minDate/maxDate + exclude weekends'
  task_template: set_scalar
  secondary_template: null
  browsergym_goal: Set the “Payroll date” field to 2026-02-25 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Goal: Payroll date = 2026-02-25.'
  setup_description: |-
    Layout: isolated_card centered in the viewport.
    Component: one Mantine DateInput labeled “Payroll date” (valueFormat YYYY-MM-DD).
    Validation configuration:
      - minDate = 2026-02-01
      - maxDate = 2026-02-28
      - weekends are disabled (only weekdays are allowed)
    A helper hint under the input reads: “Weekdays only. Allowed range: 2026-02-01 to 2026-02-28.”
    Initial state: pre-filled with 2026-02-10 (a valid weekday).
    Behavior: if the user types a date outside the allowed range or on a weekend, the input is considered invalid and reverts to the last known valid date when blurred/committed (Mantine DateInput validation behavior).
    Distractors: none.
    Feedback: invalid entry shows a brief inline error message (“Invalid date”) before reverting; valid entry clears the error and keeps the new value.
  scene_context:
    theme: light
    spacing: compact
    layout: isolated_card
    placement: center
    scale: default
    instances: 1
    guidance: text
    clutter: none
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 3
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 1
      feedback_dynamics: 4
      semantic_observability: 3
      disambiguation_load: 1
    justification: Strict validity constraints with automatic revert on invalid input increase feedback dynamics and require careful formatted entry.
  success_trigger:
    human_readable:
    - The “Payroll date” DateInput value equals 2026-02-25.
    - The value is valid under the configured constraints (within range and not a weekend).
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-02-25'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Payroll date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      require_valid: true
      constraints:
        min: '2026-02-01'
        max: '2026-02-28'
        weekdays_only: true
  negative_cases:
  - Entering a weekend date (e.g., 2026-02-28) so the input reverts.
  - Entering a date outside the allowed range so the input reverts.
  - Leaving the original date (2026-02-10).
  - Typing without committing (checker still reads old value).
  expected_interaction_path: Focus Payroll date → replace with 2026-02-25 → blur/Enter to commit → ensure it stays (no revert).
  notes: 'Instrumentation: data-testid=''payroll-date''. Checker should verify component value and that error state is false.'
- id: date_input_text-mantine-T08
  name: Mantine edit a date input inside a dense table
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput in table cells (multiple instances)'
  task_template: table_operation
  secondary_template: null
  browsergym_goal: In the Maintenance table, set the “Maintenance date” for the “Server B” row to 2026-09-01 (YYYY-MM-DD). The task will finish automatically when done.
  ui_copy: 'Maintenance table: Server B → Maintenance date = 2026-09-01.'
  setup_description: |-
    Layout: table_cell scene anchored at the bottom-right of the viewport.
    Theme/spacing: light theme with compact spacing; small component scale.
    Table: three rows labeled “Server A”, “Server B”, “Server C”.
    Component instances: each row has an inline Mantine DateInput in the “Maintenance date” column (valueFormat YYYY-MM-DD).
    Initial state:
      - Server A: 2026-08-15
      - Server B: empty
      - Server C: 2026-10-20
    Clutter (high): additional columns show status pills and action icons; these do not affect success.
    Feedback: the edited cell updates after the input is committed and briefly shows a subtle background highlight.
  scene_context:
    theme: light
    spacing: compact
    layout: table_cell
    placement: bottom_right
    scale: small
    instances: 3
    guidance: text
    clutter: high
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 4
      density_choice_interference: 3
      depth_layering: 1
      feedback_dynamics: 2
      semantic_observability: 2
      disambiguation_load: 4
    justification: Small inputs embedded in a compact table increase pointing precision needs and disambiguation across multiple similar instances.
  success_trigger:
    human_readable:
    - In the “Server B” row, the “Maintenance date” DateInput value equals 2026-09-01.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-09-01'
      tolerance:
        days: 0
      require_confirm: false
      confirm_control: null
      require_correct_instance: true
      target_instance_label_or_id: Maintenance date (Server B)
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      table_row_key: Server B
      table_column_key: maintenance_date
  negative_cases:
  - Editing Server A or Server C instead of Server B.
  - Entering 2026-01-09 or any other incorrect date.
  - Leaving Server B empty or invalid.
  expected_interaction_path: Find Server B row → focus its Maintenance date input → type 2026-09-01 → commit.
  notes: 'Instrumentation: stable row keys; data-testid=''maintenance-date-server-b''.'
- id: date_input_text-mantine-T09
  name: Mantine match reference date among three inputs and apply
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: DateInput x3 + Apply action bar'
  task_template: match_reference
  secondary_template: null
  browsergym_goal: Set the “Secondary window” date to match the date shown on the “Reference banner”, then click “Apply schedule”. The task will finish automatically when done.
  ui_copy: 'Schedule dashboard: Secondary window must match Reference banner → Apply schedule.'
  setup_description: |-
    Layout: dashboard scene anchored at the top-right of the viewport.
    Theme: dark.
    Components: three Mantine DateInput fields in a panel titled “Maintenance windows”:
      - “Primary window” (pre-filled with 2026-10-01)
      - “Secondary window” (empty)
      - “Fallback window” (pre-filled with 2026-10-15)
    Visual reference: a prominent “Reference banner” above the panel shows the target date in large type:
      “OCT 05 2026”
    Clutter (medium): the dashboard includes a small status chart placeholder and two filter chips; not required.
    Confirmation: a sticky action bar at the bottom of the panel has “Reset” and a primary button “Apply schedule”. Changes are only persisted after “Apply schedule”.
    Feedback: after Apply, a toast “Schedule applied” appears and the sticky bar collapses.
  scene_context:
    theme: dark
    spacing: comfortable
    layout: dashboard
    placement: top_right
    scale: default
    instances: 3
    guidance: visual
    clutter: medium
  difficulty:
    difficulty_bucket: hard
    tier: L3
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 3
      density_choice_interference: 2
      depth_layering: 2
      feedback_dynamics: 3
      semantic_observability: 3
      disambiguation_load: 4
    justification: Dark theme plus three similar inputs requires careful disambiguation, extracting the date from a reference banner, and committing via Apply.
  success_trigger:
    human_readable:
    - The “Secondary window” DateInput value equals the reference date 2026-10-05.
    - The user clicked “Apply schedule” and the value is persisted.
    canonical_predicate:
      predicate_type: matches_reference
      target_state:
        date_iso: '2026-10-05'
        reference_id: reference-banner
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Apply schedule
      require_correct_instance: true
      target_instance_label_or_id: Secondary window
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      persisted_state_id: maintenance.secondary_window
  negative_cases:
  - Setting Primary or Fallback window instead of Secondary window.
  - Entering the correct date but not clicking Apply schedule.
  - Clicking Reset (should not count).
  - Entering any date other than the reference date.
  expected_interaction_path: Read date on Reference banner → edit Secondary window input → commit → click Apply schedule.
  notes: 'Instrumentation: data-testid=''primary-window'', ''secondary-window'', ''fallback-window'', ''apply-schedule'', ''reference-banner''. Checker verifies persisted state updated after Apply.'
- id: date_input_text-mantine-T10
  name: Mantine DateInput inside a drawer with Save/Cancel
  canonical_type: date_input_text
  implementation_source: mantine
  implementation_variant: null
  implementation_component: 'Mantine: Drawer + DateInput'
  task_template: confirm_cancel
  secondary_template: null
  browsergym_goal: Open the “Edit subscription” drawer, set “Next billing date” to 2026-11-15 (YYYY-MM-DD), then click “Save changes”. The task will finish automatically when done.
  ui_copy: Edit subscription → Next billing date = 2026-11-15 → Save changes.
  setup_description: |-
    Layout: drawer_flow. The base page shows a subscription summary and a button “Edit subscription”.
    Clicking it opens a right-side Drawer that slides in from the edge.
    Inside the drawer is a small form with:
      - “Plan” select (disabled; not required)
      - “Next billing date” (Mantine DateInput, valueFormat YYYY-MM-DD, manual typing enabled)
    Initial state: drawer is closed; when opened, Next billing date is empty.
    Drawer footer: “Cancel” and primary “Save changes”.
    Clutter (low): a short paragraph explaining billing (non-interactive).
    Feedback: after clicking “Save changes”, the drawer closes and the summary updates the displayed next billing date.
  scene_context:
    theme: light
    spacing: comfortable
    layout: drawer_flow
    placement: top_right
    scale: default
    instances: 1
    guidance: text
    clutter: low
  difficulty:
    difficulty_bucket: hard
    tier: L2
    axes_ratings:
      precision_requirement: 2
      target_acquisition: 2
      density_choice_interference: 1
      depth_layering: 3
      feedback_dynamics: 3
      semantic_observability: 2
      disambiguation_load: 2
    justification: Requires handling a drawer overlay and explicitly saving; the date input is straightforward once located.
  success_trigger:
    human_readable:
    - The “Next billing date” value equals 2026-11-15.
    - The user clicked “Save changes” and the saved value is persisted to the summary.
    canonical_predicate:
      predicate_type: equals
      target_state:
        date_iso: '2026-11-15'
      tolerance:
        days: 0
      require_confirm: true
      confirm_control: Save changes
      require_correct_instance: true
      target_instance_label_or_id: Next billing date
      terminal_condition: task_ends_when_predicate_holds
      canonical_type: date_input_text
      persisted_state_id: subscription.next_billing_date
  negative_cases:
  - Entering the correct date but clicking Cancel or closing the drawer without saving.
  - Saving a different date.
  - Leaving the field empty/invalid.
  expected_interaction_path: Click Edit subscription → in drawer, focus Next billing date → type 2026-11-15 → commit → click Save changes.
  notes: 'Instrumentation: data-testid=''edit-subscription'', drawer data-testid=''subscription-drawer'', input data-testid=''next-billing-date'', save button data-testid=''save-changes''.'