Publish original Headless Browser inputs from 91ca91ae26d6baf84fbc104431f13e577ca41abf (part 6)

definitions/tasks/L1/raw_cdp/v2_boot_target_get_targets.json

@@ -0,0 +1,77 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Creates a page target then calls Target.getTargets and asserts the returned targetInfos array is non-empty and contains at least one 'page' entry with a targetId. Real semantic probe of getTargets return structure.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "about:blank"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "method": "Target.getTargets",
+        "params": {},
+        "save_result_as": "targets",
+        "session": "browser"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.get_targets",
+    "cdp.target.create_target"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "array_length",
+        "min": 1,
+        "name": "targets",
+        "path": "targetInfos"
+      },
+      {
+        "expected": {
+          "type": "page"
+        },
+        "kind": "array_contains",
+        "name": "targets",
+        "path": "targetInfos"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "targets",
+        "path": "targetInfos.0.targetId"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "coverage.tier1_bootstrap",
+    "family.bootstrap",
+    "version.v0_2"
+  ],
+  "task_id": "v2_boot_target_get_targets",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "Target.getTargets enumerates page targets"
+}

definitions/tasks/L1/raw_cdp/v2_boot_target_set_discover_targets.json

@@ -0,0 +1,81 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Turns on target discovery on the browser session, creates a page target, and waits for the Target.targetCreated event for that exact target id, asserting it describes a 'page'. Real probe that setDiscoverTargets actually opens the discovery event stream.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.setDiscoverTargets",
+        "params": {
+          "discover": true
+        },
+        "session": "browser"
+      },
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "about:blank"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "match": {
+          "targetInfo": {
+            "targetId": "{saved:created.targetId}"
+          }
+        },
+        "save_result_as": "discovered",
+        "session": "browser",
+        "timeout_ms": 5000,
+        "wait_for_event": "Target.targetCreated"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.set_discover_targets",
+    "cdp.target.target_created"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Target.targetCreated",
+        "name": "discovered"
+      },
+      {
+        "expected": "page",
+        "kind": "saved_path_equals",
+        "name": "discovered",
+        "path": "targetInfo.type"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "coverage.tier1_bootstrap",
+    "family.bootstrap",
+    "version.v0_2"
+  ],
+  "task_id": "v2_boot_target_set_discover_targets",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "Target.setDiscoverTargets emits targetCreated"
+}

definitions/tasks/L1/raw_cdp/v2_diag_dispatchmouse_geometry.json

@@ -0,0 +1,72 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. Input.dispatchMouseEvent press+release at CSS coordinate (150,110), the center of a 100x60 target at (100,80). A coordinate hit-test must fire the click handler, recording 'CLICKED@150,110'.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Input.dispatchMouseEvent",
+        "params": {
+          "button": "left",
+          "buttons": 1,
+          "clickCount": 1,
+          "type": "mousePressed",
+          "x": 150,
+          "y": 110
+        }
+      },
+      {
+        "method": "Input.dispatchMouseEvent",
+        "params": {
+          "button": "left",
+          "buttons": 1,
+          "clickCount": 1,
+          "type": "mouseReleased",
+          "x": 150,
+          "y": 110
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__clickInfo",
+          "returnByValue": true
+        },
+        "save_as": "click"
+      }
+    ]
+  },
+  "features": [
+    "cdp.input.dispatch_mouse_event",
+    "web.layout.hit_test"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": "CLICKED@150,110",
+        "kind": "value_equals",
+        "name": "click"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/click"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_dispatchmouse_geometry",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "Input.dispatchMouseEvent coordinate hit-test"
+}

definitions/tasks/L1/raw_cdp/v2_diag_domsnapshot_computed_styles.json

@@ -0,0 +1,71 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. DOMSnapshot.captureSnapshot with computedStyles:['display','color']; assert the requested computed styles came back: layout.styles is populated and the resolved values ('block' for display, 'rgb(0, 0, 0)' for color) appear in the strings table.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "DOM.enable",
+        "optional": true
+      },
+      {
+        "method": "DOMSnapshot.enable",
+        "optional": true
+      },
+      {
+        "method": "DOMSnapshot.captureSnapshot",
+        "params": {
+          "computedStyles": [
+            "display",
+            "color"
+          ]
+        },
+        "save_result_as": "snap"
+      }
+    ]
+  },
+  "features": [
+    "cdp.domsnapshot.capture_snapshot"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "saved_path_truthy",
+        "name": "snap",
+        "path": "documents.0.layout.styles"
+      },
+      {
+        "expected": "block",
+        "kind": "array_contains",
+        "name": "snap",
+        "path": "strings"
+      },
+      {
+        "expected": "rgb(0, 0, 0)",
+        "kind": "array_contains",
+        "name": "snap",
+        "path": "strings"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/snapshot"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_domsnapshot_computed_styles",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "DOMSnapshot computedStyles round-trip"
+}

definitions/tasks/L1/raw_cdp/v2_diag_domsnapshot_shape.json

@@ -0,0 +1,73 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. DOMSnapshot.captureSnapshot over a known fixture; assert the snapshot shape invariants: exactly one document, a non-empty strings table, and the document exposes parallel layout.nodeIndex and nodes arrays.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "DOM.enable",
+        "optional": true
+      },
+      {
+        "method": "DOMSnapshot.enable",
+        "optional": true
+      },
+      {
+        "method": "DOMSnapshot.captureSnapshot",
+        "params": {
+          "computedStyles": []
+        },
+        "save_result_as": "snap"
+      }
+    ]
+  },
+  "features": [
+    "cdp.domsnapshot.capture_snapshot"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 1,
+        "kind": "array_length",
+        "name": "snap",
+        "path": "documents"
+      },
+      {
+        "kind": "array_length",
+        "min": 10,
+        "name": "snap",
+        "path": "strings"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "snap",
+        "path": "documents.0.layout.nodeIndex"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "snap",
+        "path": "documents.0.nodes.nodeName"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/snapshot"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_domsnapshot_shape",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "DOMSnapshot.captureSnapshot shape invariants"
+}

definitions/tasks/L1/raw_cdp/v2_diag_gbcr_fixed.json

@@ -0,0 +1,49 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] getBoundingClientRect over Runtime.evaluate on a fixed 300x150 element at (0,0) (Defect C root: kernels miscompute layout). Expect exactly '300x150@0,0'.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "(function(){var r=document.getElementById('fixed').getBoundingClientRect();return r.width+'x'+r.height+'@'+r.left+','+r.top;})()",
+          "returnByValue": true
+        },
+        "save_as": "v"
+      }
+    ]
+  },
+  "features": [
+    "web.layout.bounding_client_rect"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": "300x150@0,0",
+        "kind": "value_equals",
+        "name": "v"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/trio"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_gbcr_fixed",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "getBoundingClientRect on fixed-px element"
+}

definitions/tasks/L1/raw_cdp/v2_diag_getboxmodel_border_box.json

@@ -0,0 +1,92 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. DOM.getBoxModel on an element with content 200x100, padding 10, border 5. Assert the border box (model width/height 230x130 at origin 400,60) is distinct from the content box (200 wide at origin 415,75), proving content/padding/border box separation.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "DOM.enable",
+        "optional": true
+      },
+      {
+        "method": "DOM.getDocument",
+        "params": {
+          "depth": -1
+        },
+        "save_result_as": "doc"
+      },
+      {
+        "method": "DOM.querySelector",
+        "params": {
+          "nodeId": "{saved:doc.root.nodeId}",
+          "selector": "#padbox"
+        },
+        "save_result_as": "q"
+      },
+      {
+        "method": "DOM.getBoxModel",
+        "params": {
+          "nodeId": "{saved:q.nodeId}"
+        },
+        "save_result_as": "box"
+      }
+    ]
+  },
+  "features": [
+    "cdp.dom.get_box_model"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 230,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.width"
+      },
+      {
+        "expected": 130,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.height"
+      },
+      {
+        "expected": 400,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.border.0"
+      },
+      {
+        "expected": 415,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.content.0"
+      },
+      {
+        "expected": 615,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.content.2"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/geom"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_getboxmodel_border_box",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "DOM.getBoxModel content vs border box"
+}

definitions/tasks/L1/raw_cdp/v2_diag_getboxmodel_dims.json

@@ -0,0 +1,92 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. DOM.getBoxModel on a fixed 240x120 absolutely-positioned element (no border/padding, so content box == border box). Assert model width/height and the content quad coordinates (origin 50,60; far corner 290,180).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "DOM.enable",
+        "optional": true
+      },
+      {
+        "method": "DOM.getDocument",
+        "params": {
+          "depth": -1
+        },
+        "save_result_as": "doc"
+      },
+      {
+        "method": "DOM.querySelector",
+        "params": {
+          "nodeId": "{saved:doc.root.nodeId}",
+          "selector": "#box"
+        },
+        "save_result_as": "q"
+      },
+      {
+        "method": "DOM.getBoxModel",
+        "params": {
+          "nodeId": "{saved:q.nodeId}"
+        },
+        "save_result_as": "box"
+      }
+    ]
+  },
+  "features": [
+    "cdp.dom.get_box_model"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 240,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.width"
+      },
+      {
+        "expected": 120,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.height"
+      },
+      {
+        "expected": 8,
+        "kind": "array_length",
+        "name": "box",
+        "path": "model.content"
+      },
+      {
+        "expected": 50,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.content.0"
+      },
+      {
+        "expected": 290,
+        "kind": "saved_path_equals",
+        "name": "box",
+        "path": "model.content.2"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/geom"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_getboxmodel_dims",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "DOM.getBoxModel geometry on fixed element"
+}

definitions/tasks/L1/raw_cdp/v2_diag_getcontentquads_shape.json

@@ -0,0 +1,86 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. DOM.getContentQuads on a fixed 240x120 element. Assert exactly one quad of 8 coordinates, matching the element rectangle (50,60)-(290,180).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "DOM.enable",
+        "optional": true
+      },
+      {
+        "method": "DOM.getDocument",
+        "params": {
+          "depth": -1
+        },
+        "save_result_as": "doc"
+      },
+      {
+        "method": "DOM.querySelector",
+        "params": {
+          "nodeId": "{saved:doc.root.nodeId}",
+          "selector": "#box"
+        },
+        "save_result_as": "q"
+      },
+      {
+        "method": "DOM.getContentQuads",
+        "params": {
+          "nodeId": "{saved:q.nodeId}"
+        },
+        "save_result_as": "quads"
+      }
+    ]
+  },
+  "features": [
+    "cdp.dom.get_content_quads"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 1,
+        "kind": "array_length",
+        "name": "quads",
+        "path": "quads"
+      },
+      {
+        "expected": 8,
+        "kind": "array_length",
+        "name": "quads",
+        "path": "quads.0"
+      },
+      {
+        "expected": 50,
+        "kind": "saved_path_equals",
+        "name": "quads",
+        "path": "quads.0.0"
+      },
+      {
+        "expected": 290,
+        "kind": "saved_path_equals",
+        "name": "quads",
+        "path": "quads.0.2"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/geom"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_getcontentquads_shape",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "DOM.getContentQuads shape on fixed element"
+}

definitions/tasks/L1/raw_cdp/v2_diag_layoutmetrics_viewport.json

@@ -0,0 +1,59 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] This method is on the real framework main path (on_framework_main_path); routed to the diagnostic lane per bench policy. Page.getLayoutMetrics viewport consistency: cssLayoutViewport.clientWidth, cssContentSize.width and the (deprecated) layoutViewport.clientWidth must all agree (780 under the pinned Chrome headless viewport).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Page.getLayoutMetrics",
+        "save_result_as": "lm"
+      }
+    ]
+  },
+  "features": [
+    "cdp.page.get_layout_metrics",
+    "web.layout.viewport"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 780,
+        "kind": "saved_path_equals",
+        "name": "lm",
+        "path": "cssLayoutViewport.clientWidth"
+      },
+      {
+        "expected": 780,
+        "kind": "saved_path_equals",
+        "name": "lm",
+        "path": "cssContentSize.width"
+      },
+      {
+        "expected": 780,
+        "kind": "saved_path_equals",
+        "name": "lm",
+        "path": "layoutViewport.clientWidth"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/geom"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_layoutmetrics_viewport",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "Page.getLayoutMetrics viewport consistency"
+}

definitions/tasks/L1/raw_cdp/v2_diag_offset_dims_fixed.json

@@ -0,0 +1,49 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] offsetWidth/offsetHeight over Runtime.evaluate on a fixed 300x150 element (Defect C root). Expect exactly '300x150'.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "(function(){var e=document.getElementById('fixed');return e.offsetWidth+'x'+e.offsetHeight;})()",
+          "returnByValue": true
+        },
+        "save_as": "v"
+      }
+    ]
+  },
+  "features": [
+    "web.layout.offset_dimensions"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": "300x150",
+        "kind": "value_equals",
+        "name": "v"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/trio"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_offset_dims_fixed",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "offsetWidth/offsetHeight on fixed-px element"
+}

definitions/tasks/L1/raw_cdp/v2_diag_scrollsize_fixed.json

@@ -0,0 +1,49 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "[diagnostic lane] scrollHeight/scrollWidth over Runtime.evaluate on a 100x50 scroller whose 400x400 inner content sets the scrollable extent (Defect C root). Expect exactly '400x400'.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "(function(){var e=document.getElementById('scroller');return e.scrollHeight+'x'+e.scrollWidth;})()",
+          "returnByValue": true
+        },
+        "save_as": "v"
+      }
+    ]
+  },
+  "features": [
+    "web.layout.scroll_dimensions"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": "400x400",
+        "kind": "value_equals",
+        "name": "v"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/diag/trio"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.diagnostics",
+    "purpose.diagnostic",
+    "version.v0_2"
+  ],
+  "task_id": "v2_diag_scrollsize_fixed",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "scrollHeight/scrollWidth on overflow container"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_auth_required_e2e.json

@@ -0,0 +1,124 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "End-to-end Basic-auth interception: Fetch.enable with handleAuthRequests, a page fetch() hits the 401-challenging /__auth__/ endpoint, Fetch.requestPaused is continued, Fetch.authRequired arrives carrying the Basic challenge, Fetch.continueWithAuth provides credentials, the retried request is continued and the page observes the authenticated 200 body. Closes the last T1_intercept anchor (Fetch.authRequired).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "handleAuthRequests": true,
+          "patterns": [
+            {
+              "urlPattern": "*__auth__*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "fetch('/__auth__/data').then(function(r){return r.text();}).then(function(t){window.__abbAuth = t;}).catch(function(e){window.__abbAuth = 'ERR:' + String(e);})"
+        }
+      },
+      {
+        "save_result_as": "paused1",
+        "session": "page",
+        "timeout_ms": 5000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused1.requestId}"
+        }
+      },
+      {
+        "save_result_as": "challenge",
+        "session": "page",
+        "timeout_ms": 5000,
+        "wait_for_event": "Fetch.authRequired"
+      },
+      {
+        "method": "Fetch.continueWithAuth",
+        "params": {
+          "authChallengeResponse": {
+            "password": "secret",
+            "response": "ProvideCredentials",
+            "username": "bench"
+          },
+          "requestId": "{saved:challenge.requestId}"
+        }
+      },
+      {
+        "optional": true,
+        "save_result_as": "paused2",
+        "session": "page",
+        "timeout_ms": 5000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "optional": true,
+        "params": {
+          "requestId": "{saved:paused2.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 600
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbAuth",
+          "returnByValue": true
+        },
+        "save_as": "fetched"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.auth_required",
+    "cdp.fetch.continue_with_auth",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.authRequired",
+        "name": "challenge"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "challenge",
+        "path": "authChallenge.scheme"
+      },
+      {
+        "expected": "granted",
+        "kind": "value_contains",
+        "name": "fetched"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/l1/core"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_auth_required_e2e",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.authRequired end-to-end Basic auth challenge"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_continue_request_modify_headers.json

@@ -0,0 +1,96 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.continueRequest with an overridden request headers array (injecting x-abb-injected and Accept) still delivers the origin body to the page. Note: the fixture server does not echo request headers, so server-visible header values cannot be asserted here (documented in skipped_fetch.md); this probe covers the continueRequest header-override parameter path end to end.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "headers": [
+            {
+              "name": "x-abb-injected",
+              "value": "1"
+            },
+            {
+              "name": "Accept",
+              "value": "text/plain"
+            }
+          ],
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_continue_request_modify_headers",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.continueRequest with header/method override"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_continue_request_modify_url.json

@@ -0,0 +1,96 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "The page fetches the 'real' route, but Fetch.continueRequest overrides the request url to a different origin route ('truth'); the server therefore serves the other resource and the page renders the truth body. Proves continueRequest url rewriting reaches the origin.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "location.origin+'/v0_2/fetch/abbfetch-truth'",
+          "returnByValue": true
+        },
+        "save_as": "truthurl"
+      },
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}",
+          "url": "{saved:truthurl.result.value}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.request_paused",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "ROUTE-TRUTH-BODY",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_continue_request_modify_url",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.continueRequest rewrites the request URL"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_continue_with_auth_probe.json

@@ -0,0 +1,65 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Structural probe for the auth path: Fetch.enable accepts handleAuthRequests true (auth-handling mode), and Fetch.continueWithAuth is a recognized command that cleanly rejects an invalid interception id. A full Basic-auth challenge (Fetch.authRequired) cannot be produced against the 200-only fixture server; see skipped_fetch.md.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "handleAuthRequests": true,
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "expect_unsupported": true,
+        "method": "Fetch.continueWithAuth",
+        "params": {
+          "authChallengeResponse": {
+            "password": "p",
+            "response": "ProvideCredentials",
+            "username": "u"
+          },
+          "requestId": "abb-nonexistent-000"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.continue_with_auth"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Fetch.continueWithAuth",
+        "name": "value"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_continue_with_auth_probe",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.enable(handleAuthRequests) + continueWithAuth recognized"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_disable_stops_pausing.json

@@ -0,0 +1,111 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "First proves interception is active (a fetch pauses and is continued). Then Fetch.disable is issued; a second fetch to the same pattern is NOT paused (the optional wait times out and no paused event is captured) and completes normally with the real origin body. Verifies Fetch.disable tears down interception.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused1",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused1.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 300
+      },
+      {
+        "method": "Fetch.disable"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "optional": true,
+        "save_result_as": "paused2",
+        "session": "page",
+        "timeout_ms": 1500,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "sleep_ms": 300
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body2"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.disable"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused1"
+      },
+      {
+        "expected": null,
+        "kind": "saved_path_equals",
+        "name": "paused2",
+        "path": null
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "value_contains",
+        "name": "body2"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_disable_stops_pausing",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.disable stops further requestPaused events"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_enable_no_patterns.json

@@ -0,0 +1,79 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.enable called with no patterns (intercept every request). A single page fetch() is paused, then released with Fetch.continueRequest; the page receives the real origin body. Contrasts with the pattern-scoped enable and exercises the pattern-less interception form.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {}
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_enable_no_patterns",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.enable() without patterns intercepts all requests"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_enable_patterns_continue.json

@@ -0,0 +1,104 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.enable with a URL pattern at requestStage Request; a page fetch() triggers Fetch.requestPaused; the driver inspects the paused request fields and lets it through unchanged with Fetch.continueRequest, so the page receives the real origin body. Covers enable+patterns, Request stage, requestPaused field semantics, and plain continueRequest.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.request_paused",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "paused",
+        "path": "requestId"
+      },
+      {
+        "expected": "abbfetch-real",
+        "kind": "saved_path_contains",
+        "name": "paused",
+        "path": "request.url"
+      },
+      {
+        "expected": "GET",
+        "kind": "saved_path_equals",
+        "name": "paused",
+        "path": "request.method"
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_enable_patterns_continue",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.enable(patterns, Request) + continueRequest passthrough"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_fail_request.json

@@ -0,0 +1,87 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.failRequest with errorReason BlockedByClient aborts the paused request; the page's fetch() promise rejects and stores an ERR marker. Verifies failRequest surfaces as a network error to the page.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.failRequest",
+        "params": {
+          "errorReason": "BlockedByClient",
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fail_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "ERR:",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_fail_request",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.failRequest(BlockedByClient) rejects the request"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_fail_request_alt_reason.json

@@ -0,0 +1,87 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "A second failRequest error-reason probe: errorReason ConnectionRefused also aborts the request and rejects the page fetch() promise. Confirms distinct Fetch.failRequest error codes route to a page-visible network failure.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.failRequest",
+        "params": {
+          "errorReason": "ConnectionRefused",
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "body"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fail_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "ERR:",
+        "kind": "value_contains",
+        "name": "body"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_fail_request_alt_reason",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.failRequest(ConnectionRefused) error semantics"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_fulfill_custom_response.json

@@ -0,0 +1,108 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.fulfillRequest injects a synthetic response: status 201, a custom x-abb-tag header, and a text body. The page reads back the status code, the custom header value, and the body, proving all three fulfillRequest response fields take effect.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "RlVMRklMTEVELUJPRFktdG9rZW4tZWNobw==",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 201,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "text/plain"
+            },
+            {
+              "name": "x-abb-tag",
+              "value": "hdr-echo-77"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbStatus+'|'+window.__abbXTag+'|'+window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "combo"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "201",
+        "kind": "value_contains",
+        "name": "combo"
+      },
+      {
+        "expected": "hdr-echo-77",
+        "kind": "value_contains",
+        "name": "combo"
+      },
+      {
+        "expected": "FULFILLED-BODY-token-echo",
+        "kind": "value_contains",
+        "name": "combo"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_fulfill_custom_response",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.fulfillRequest with custom code, headers and body"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_fulfill_json.json

@@ -0,0 +1,94 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.fulfillRequest returns a JSON body with an application/json content type; the page JSON.parses it and reads a field. Verifies fulfillRequest can mock a JSON API response the origin never produced.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "eyJhbnN3ZXIiOiJNT0NLRURfTElWRV9BTlNXRVIifQ==",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "application/json"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "JSON.parse(window.__abbBody).answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "MOCKED_LIVE_ANSWER",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_fulfill_json",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.fulfillRequest returns synthetic JSON"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_fulfill_status_override_404.json

@@ -0,0 +1,99 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.fulfillRequest returns a non-2xx status (404) with a custom body for a route that would otherwise return 200; the page observes status 404 and the injected body. Covers fulfillRequest response-code override semantics.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "bm90LWhlcmUtNDA0LWJvZHk=",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 404,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "text/plain"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 400
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbStatus+'|'+window.__abbBody",
+          "returnByValue": true
+        },
+        "save_as": "combo"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "404",
+        "kind": "value_contains",
+        "name": "combo"
+      },
+      {
+        "expected": "not-here-404-body",
+        "kind": "value_contains",
+        "name": "combo"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_fulfill_status_override_404",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.fulfillRequest overrides status to 404"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_load_network_resource.json

@@ -0,0 +1,99 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Network.loadNetworkResource fetches an origin resource out-of-band for a given frameId; the returned resource reports success, httpStatusCode 200, and an IO stream handle that IO.read drains to the body text. Covers the loadNetworkResource + IO stream read path.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Network.enable"
+      },
+      {
+        "method": "Page.enable"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "location.origin+'/v0_2/fetch/abbfetch-real'",
+          "returnByValue": true
+        },
+        "save_as": "realurl"
+      },
+      {
+        "method": "Page.getFrameTree",
+        "save_result_as": "ft"
+      },
+      {
+        "method": "Network.loadNetworkResource",
+        "params": {
+          "frameId": "{saved:ft.frameTree.frame.id}",
+          "options": {
+            "disableCache": true,
+            "includeCredentials": false
+          },
+          "url": "{saved:realurl.result.value}"
+        },
+        "save_result_as": "lnr"
+      },
+      {
+        "method": "IO.read",
+        "params": {
+          "handle": "{saved:lnr.resource.stream}",
+          "size": 4096
+        },
+        "save_result_as": "lread"
+      },
+      {
+        "method": "IO.close",
+        "params": {
+          "handle": "{saved:lnr.resource.stream}"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.network.load_network_resource",
+    "cdp.io.read",
+    "cdp.io.close"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": true,
+        "kind": "saved_path_equals",
+        "name": "lnr",
+        "path": "resource.success"
+      },
+      {
+        "expected": 200,
+        "kind": "saved_path_equals",
+        "name": "lnr",
+        "path": "resource.httpStatusCode"
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "saved_path_contains",
+        "name": "lread",
+        "path": "data"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_load_network_resource",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Network.loadNetworkResource streams a resource"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_network_get_response_body.json

@@ -0,0 +1,83 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "With the Network domain enabled, a page fetch() drives Network.responseReceived (captures requestId) and Network.loadingFinished; Network.getResponseBody then returns the decoded body (base64Encoded false for text). Covers Network.getResponseBody plus the responseReceived/loadingFinished events.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Network.enable"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "resp",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Network.responseReceived"
+      },
+      {
+        "optional": true,
+        "save_result_as": "fin",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Network.loadingFinished"
+      },
+      {
+        "method": "Network.getResponseBody",
+        "params": {
+          "requestId": "{saved:resp.requestId}"
+        },
+        "save_result_as": "rb"
+      }
+    ]
+  },
+  "features": [
+    "cdp.network.get_response_body",
+    "cdp.network.response_received",
+    "cdp.network.loading_finished"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Network.responseReceived",
+        "name": "resp"
+      },
+      {
+        "expected": "REAL-SERVER-BODY",
+        "kind": "saved_path_contains",
+        "name": "rb",
+        "path": "body"
+      },
+      {
+        "expected": false,
+        "kind": "saved_path_equals",
+        "name": "rb",
+        "path": "base64Encoded"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_network_get_response_body",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Network.getResponseBody after loadingFinished"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_network_relative_ordering.json

@@ -0,0 +1,90 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "With both Fetch (Request stage) and Network enabled, a fetch pauses first (Fetch.requestPaused); only after Fetch.continueRequest does the origin respond and Network.responseReceived fire. Asserts the observed-event order: requestPaused is index 0, responseReceived follows.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Network.enable"
+      },
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "save_result_as": "resp",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Network.responseReceived"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.request_paused",
+    "cdp.network.response_received"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": "Fetch.requestPaused",
+        "kind": "saved_path_equals",
+        "name": "__events_observed__",
+        "path": "0"
+      },
+      {
+        "kind": "event_observed",
+        "method": "Network.responseReceived",
+        "name": "resp"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "resp",
+        "path": "requestId"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_network_relative_ordering",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.requestPaused precedes Network.responseReceived"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_request_paused_request_stage_fields.json

@@ -0,0 +1,93 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "At requestStage Request, asserts the Fetch.requestPaused event carries requestId, frameId, request.method GET and request.url, and that responseStatusCode is absent (null) because the response has not been received yet. The request is released with continueRequest.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*abbfetch-real*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-real?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.request_paused"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "saved_path_truthy",
+        "name": "paused",
+        "path": "requestId"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "paused",
+        "path": "frameId"
+      },
+      {
+        "expected": "GET",
+        "kind": "saved_path_equals",
+        "name": "paused",
+        "path": "request.method"
+      },
+      {
+        "expected": "abbfetch-real",
+        "kind": "saved_path_contains",
+        "name": "paused",
+        "path": "request.url"
+      },
+      {
+        "expected": null,
+        "kind": "saved_path_equals",
+        "name": "paused",
+        "path": "responseStatusCode"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_request_paused_request_stage_fields",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Fetch.requestPaused field semantics at Request stage"
+}

definitions/tasks/L1/raw_cdp/v2_fetch_response_stage_take_stream.json

@@ -0,0 +1,121 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "Fetch.enable at requestStage Response pauses after the response is available (requestPaused carries responseStatusCode 200). Fetch.takeResponseBodyAsStream returns an IO stream handle; IO.read pulls the body text, a second IO.read reaches eof, and IO.close releases the handle. Covers the streaming response-body read path.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Response",
+              "urlPattern": "*abbfetch-big*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbGet(location.origin+'/v0_2/fetch/abbfetch-big?n='+Date.now())"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.takeResponseBodyAsStream",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        },
+        "save_result_as": "stream"
+      },
+      {
+        "method": "IO.read",
+        "params": {
+          "handle": "{saved:stream.stream}",
+          "size": 4096
+        },
+        "save_result_as": "read1"
+      },
+      {
+        "method": "IO.read",
+        "params": {
+          "handle": "{saved:stream.stream}",
+          "size": 4096
+        },
+        "save_result_as": "read2"
+      },
+      {
+        "method": "IO.close",
+        "params": {
+          "handle": "{saved:stream.stream}"
+        }
+      },
+      {
+        "method": "Fetch.failRequest",
+        "optional": true,
+        "params": {
+          "errorReason": "Aborted",
+          "requestId": "{saved:paused.requestId}"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.take_response_body_as_stream",
+    "cdp.io.read",
+    "cdp.io.close"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "expected": 200,
+        "kind": "saved_path_equals",
+        "name": "paused",
+        "path": "responseStatusCode"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "stream",
+        "path": "stream"
+      },
+      {
+        "expected": "STREAM-CHUNK",
+        "kind": "saved_path_contains",
+        "name": "read1",
+        "path": "data"
+      },
+      {
+        "expected": true,
+        "kind": "saved_path_equals",
+        "name": "read2",
+        "path": "eof"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/fetch/page"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch",
+    "version.v0_2"
+  ],
+  "task_id": "v2_fetch_response_stage_take_stream",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Response-stage takeResponseBodyAsStream + IO.read/close"
+}

definitions/tasks/L1/raw_cdp/v2_h_compute_product.json

@@ -0,0 +1,120 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Builds a child page session via the dialect handshake, navigates to a compute fixture, clicks the compute button via Runtime.evaluate, and reads the page-computed result (a*b+7 from body data attributes => 6*7+7 = 49). The answer emerges from the runtime computation, not a literal in the markup.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.setAutoAttach",
+        "params": {
+          "autoAttach": true,
+          "flatten": true,
+          "waitForDebuggerOnStart": true
+        },
+        "session": "browser"
+      },
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "{fixture_url}"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "match": {
+          "targetInfo": {
+            "targetId": "{saved:created.targetId}"
+          }
+        },
+        "save_result_as": "attached",
+        "save_session_as": "h_page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Target.attachedToTarget"
+      },
+      {
+        "method": "Page.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Page.setLifecycleEventsEnabled",
+        "params": {
+          "enabled": true
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.runIfWaitingForDebugger",
+        "session": "h_page"
+      },
+      {
+        "match": {
+          "name": "load"
+        },
+        "save_result_as": "loaded",
+        "session": "h_page",
+        "timeout_ms": 8000,
+        "wait_for_event": "Page.lifecycleEvent"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "document.getElementById('go').click(); Number(document.getElementById('result').textContent);",
+          "returnByValue": true
+        },
+        "save_as": "answer",
+        "session": "h_page"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.attached_to_target",
+    "cdp.runtime.run_if_waiting_for_debugger",
+    "cdp.page.lifecycle_event"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Page.lifecycleEvent",
+        "name": "loaded"
+      },
+      {
+        "expected": 49,
+        "kind": "value_equals",
+        "name": "answer"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/h/compute"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.handwritten",
+    "version.v0_2"
+  ],
+  "task_id": "v2_h_compute_product",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 40000,
+    "task_ms": 25000
+  },
+  "title": "bootstrap replay -> data-attribute product"
+}

definitions/tasks/L1/raw_cdp/v2_h_counter_clicks.json

@@ -0,0 +1,120 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Builds a flat child page session via the dialect handshake, navigates to a counter fixture, drives a click sequence (three +3 clicks and two +5 clicks) via Runtime.evaluate on the child session, and reads back the running total. The answer (19) emerges only from the interaction; it is not present as a literal in the fixture HTML/JS.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.setAutoAttach",
+        "params": {
+          "autoAttach": true,
+          "flatten": true,
+          "waitForDebuggerOnStart": true
+        },
+        "session": "browser"
+      },
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "{fixture_url}"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "match": {
+          "targetInfo": {
+            "targetId": "{saved:created.targetId}"
+          }
+        },
+        "save_result_as": "attached",
+        "save_session_as": "h_page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Target.attachedToTarget"
+      },
+      {
+        "method": "Page.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Page.setLifecycleEventsEnabled",
+        "params": {
+          "enabled": true
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.runIfWaitingForDebugger",
+        "session": "h_page"
+      },
+      {
+        "match": {
+          "name": "load"
+        },
+        "save_result_as": "loaded",
+        "session": "h_page",
+        "timeout_ms": 8000,
+        "wait_for_event": "Page.lifecycleEvent"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "for(var i=0;i<3;i++){document.getElementById('add3').click();} for(var j=0;j<2;j++){document.getElementById('add5').click();} Number(document.getElementById('total').textContent);",
+          "returnByValue": true
+        },
+        "save_as": "answer",
+        "session": "h_page"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.attached_to_target",
+    "cdp.runtime.run_if_waiting_for_debugger",
+    "cdp.page.lifecycle_event"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Page.lifecycleEvent",
+        "name": "loaded"
+      },
+      {
+        "expected": 19,
+        "kind": "value_equals",
+        "name": "answer"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/h/counter"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.handwritten",
+    "version.v0_2"
+  ],
+  "task_id": "v2_h_counter_clicks",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 40000,
+    "task_ms": 25000
+  },
+  "title": "bootstrap replay -> counter interaction"
+}

definitions/tasks/L1/raw_cdp/v2_h_form_checksum.json

@@ -0,0 +1,135 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Builds a child page session via the dialect handshake, navigates to a form fixture, focuses the input and types via Input.insertText, clicks compute, and reads the page-computed checksum (sum of char codes mod 1000). The answer (317 for 'abz') is computed by the page from the typed value, not stored as a literal.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.setAutoAttach",
+        "params": {
+          "autoAttach": true,
+          "flatten": true,
+          "waitForDebuggerOnStart": true
+        },
+        "session": "browser"
+      },
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "{fixture_url}"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "match": {
+          "targetInfo": {
+            "targetId": "{saved:created.targetId}"
+          }
+        },
+        "save_result_as": "attached",
+        "save_session_as": "h_page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Target.attachedToTarget"
+      },
+      {
+        "method": "Page.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Page.setLifecycleEventsEnabled",
+        "params": {
+          "enabled": true
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.runIfWaitingForDebugger",
+        "session": "h_page"
+      },
+      {
+        "match": {
+          "name": "load"
+        },
+        "save_result_as": "loaded",
+        "session": "h_page",
+        "timeout_ms": 8000,
+        "wait_for_event": "Page.lifecycleEvent"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "document.getElementById('name').focus();",
+          "returnByValue": true
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Input.insertText",
+        "params": {
+          "text": "abz"
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "document.getElementById('compute').click(); Number(document.getElementById('out').textContent);",
+          "returnByValue": true
+        },
+        "save_as": "answer",
+        "session": "h_page"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.attached_to_target",
+    "cdp.runtime.run_if_waiting_for_debugger",
+    "cdp.input.insert_text"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Page.lifecycleEvent",
+        "name": "loaded"
+      },
+      {
+        "expected": 317,
+        "kind": "value_equals",
+        "name": "answer"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/h/form"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.handwritten",
+    "version.v0_2"
+  ],
+  "task_id": "v2_h_form_checksum",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 40000,
+    "task_ms": 25000
+  },
+  "title": "bootstrap replay -> typed-value checksum"
+}

definitions/tasks/L1/raw_cdp/v2_h_frame_token.json

@@ -0,0 +1,127 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Builds a child page session via the dialect handshake, navigates to a parent fixture with a same-origin iframe, verifies the child frame appears in Page.getFrameTree, and reads the token that the child frame computes from a data attribute (reversed 'xy9' => '9yx'). The answer is derived by the child frame at runtime, not a static literal.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Target.setAutoAttach",
+        "params": {
+          "autoAttach": true,
+          "flatten": true,
+          "waitForDebuggerOnStart": true
+        },
+        "session": "browser"
+      },
+      {
+        "method": "Target.createTarget",
+        "params": {
+          "url": "{fixture_url}"
+        },
+        "save_result_as": "created",
+        "session": "browser"
+      },
+      {
+        "match": {
+          "targetInfo": {
+            "targetId": "{saved:created.targetId}"
+          }
+        },
+        "save_result_as": "attached",
+        "save_session_as": "h_page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Target.attachedToTarget"
+      },
+      {
+        "method": "Page.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Page.setLifecycleEventsEnabled",
+        "params": {
+          "enabled": true
+        },
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.enable",
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.runIfWaitingForDebugger",
+        "session": "h_page"
+      },
+      {
+        "match": {
+          "name": "load"
+        },
+        "save_result_as": "loaded",
+        "session": "h_page",
+        "timeout_ms": 8000,
+        "wait_for_event": "Page.lifecycleEvent"
+      },
+      {
+        "method": "Page.getFrameTree",
+        "params": {},
+        "save_result_as": "tree",
+        "session": "h_page"
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.frames[0].document.getElementById('ctoken').textContent;",
+          "returnByValue": true
+        },
+        "save_as": "answer",
+        "session": "h_page"
+      },
+      {
+        "method": "Target.closeTarget",
+        "optional": true,
+        "params": {
+          "targetId": "{saved:created.targetId}"
+        },
+        "session": "browser"
+      }
+    ]
+  },
+  "features": [
+    "cdp.target.attached_to_target",
+    "cdp.page.get_frame_tree",
+    "cdp.runtime.run_if_waiting_for_debugger"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "array_length",
+        "min": 1,
+        "name": "tree",
+        "path": "frameTree.childFrames"
+      },
+      {
+        "expected": "9yx",
+        "kind": "value_equals",
+        "name": "answer"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v2/h/frames_parent"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.handwritten",
+    "version.v0_2"
+  ],
+  "task_id": "v2_h_frame_token",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 40000,
+    "task_ms": 25000
+  },
+  "title": "bootstrap replay -> cross-frame token read"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_block_resource_fallback.json

@@ -0,0 +1,87 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "The app requests /api-primary; the driver failRequest(BlockedByClient) blocks it, and the page's catch/fallback path renders a local FALLBACK_LOCAL_42 value. Proves resource blocking activates the client fallback branch.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-primary*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbWithFallback(location.origin+'/v0_2/ifx/api-primary','FALLBACK_LOCAL_42')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.failRequest",
+        "params": {
+          "errorReason": "BlockedByClient",
+          "requestId": "{saved:paused.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fail_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "FALLBACK_LOCAL_42",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_block_resource_fallback",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Blocked resource triggers client fallback"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_header_rewrite_client.json

@@ -0,0 +1,98 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "fulfillRequest returns a custom x-abb-token response header; the app reads response.headers and renders the injected token. Covers client-observable response-header rewriting. (Server-visible request-header injection is not observable via the fixture server; see skipped_fetch.md.)",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbHeader(location.origin+'/v0_2/ifx/api-answer','x-abb-token')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "b2s=",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "text/plain"
+            },
+            {
+              "name": "x-abb-token",
+              "value": "injected-token-xyz"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "injected-token-xyz",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_header_rewrite_client",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Injected response header observed by the client"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_json_field_inject.json

@@ -0,0 +1,94 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "The app reads the 'secret' field from /api-answer; the origin JSON has no such field. fulfillRequest returns JSON containing secret=INJECTED_FIELD_VALUE and the page renders it. Proves field-level response fabrication.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbApiField(location.origin+'/v0_2/ifx/api-answer','secret')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "eyJhbnN3ZXIiOiJ4Iiwic2VjcmV0IjoiSU5KRUNURURfRklFTERfVkFMVUUifQ==",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "application/json"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "INJECTED_FIELD_VALUE",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_json_field_inject",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Inject a JSON field the origin never returns"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_mock_api_rewrite.json

@@ -0,0 +1,95 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "End-to-end mock: the app fetches /api-answer (origin serves {\"answer\":\"SERVER_DECOY_SECRET\"}); the driver intercepts at Request stage and fulfillRequest returns {\"answer\":\"MOCKED_LIVE_ANSWER\"}. The page renders the mocked answer, which does not exist on the origin route, proving the interception superseded the server value. Mechanism trace: Fetch.requestPaused observed.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbApiField(location.origin+'/v0_2/ifx/api-answer')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "eyJhbnN3ZXIiOiJNT0NLRURfTElWRV9BTlNXRVIifQ==",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "application/json"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.request_paused",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "MOCKED_LIVE_ANSWER",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_mock_api_rewrite",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Mock API rewrite: fulfilled JSON supersedes origin"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_multi_intercept.json

@@ -0,0 +1,116 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "The app issues two concurrent fetches (/api-answer and /api-second), both matched by patterns. The driver fulfills the first paused request with FULFILLED_ONE and continues the second to the origin. Verifies independent handling of multiple paused requests by requestId.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            },
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-second*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbTwo(location.origin+'/v0_2/ifx/api-answer', location.origin+'/v0_2/ifx/api-second')"
+        }
+      },
+      {
+        "save_result_as": "p1",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "eyJhbnN3ZXIiOiJGVUxGSUxMRURfT05FIn0=",
+          "requestId": "{saved:p1.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "application/json"
+            }
+          ]
+        }
+      },
+      {
+        "save_result_as": "p2",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:p2.requestId}"
+        }
+      },
+      {
+        "sleep_ms": 600
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "String(window.__a)+'|'+String(window.__b)",
+          "returnByValue": true
+        },
+        "save_as": "combo"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "p1"
+      },
+      {
+        "kind": "saved_path_truthy",
+        "name": "p2",
+        "path": "requestId"
+      },
+      {
+        "expected": "FULFILLED_ONE",
+        "kind": "value_contains",
+        "name": "combo"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_multi_intercept",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Two concurrent requests: one fulfilled, one continued"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_request_rewrite_url.json

@@ -0,0 +1,95 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "The app fetches /api-answer (origin: SERVER_DECOY_SECRET); Fetch.continueRequest rewrites the url to /api-truth, so the origin actually serves REWRITTEN_TRUTH_ROUTE and the page renders it. Proves URL rewriting changes which origin resource the server delivers.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "location.origin+'/v0_2/ifx/api-truth'",
+          "returnByValue": true
+        },
+        "save_as": "truthurl"
+      },
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbApiField(location.origin+'/v0_2/ifx/api-answer')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.continueRequest",
+        "params": {
+          "requestId": "{saved:paused.requestId}",
+          "url": "{saved:truthurl.result.value}"
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.continue_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "REWRITTEN_TRUTH_ROUTE",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_request_rewrite_url",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Request URL rewrite redirects to a different origin route"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_response_body_tamper.json

@@ -0,0 +1,112 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "At requestStage Response, the driver reads the true origin body via Fetch.getResponseBody (contains the ORIG token), then fulfillRequest replaces it with a TAMPERED/INJECTED body. The page renders the tampered text. Proves the original was observed and then rewritten. It passes when the `Fetch.requestPaused` event is observed; the decoded body in `orig` equals `original-document-body-token-ORIG`, regardless of CDP base64 representation; the saved value `ans` contains `TAMPERED`; the saved value `ans` contains `INJECTED`.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Response",
+              "urlPattern": "*ifx/doc*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbText(location.origin+'/v0_2/ifx/doc')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.getResponseBody",
+        "params": {
+          "requestId": "{saved:paused.requestId}"
+        },
+        "save_result_as": "orig"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "VEFNUEVSRUQtZG9jLWJvZHktSU5KRUNURUQ=",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 200,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "text/plain"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.get_response_body",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "original-document-body-token-ORIG",
+        "kind": "saved_body_text_equals",
+        "name": "orig"
+      },
+      {
+        "expected": "TAMPERED",
+        "kind": "value_contains",
+        "name": "ans"
+      },
+      {
+        "expected": "INJECTED",
+        "kind": "value_contains",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_response_body_tamper",
+  "task_version": 2,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Response-body tamper after reading the origin body"
+}

definitions/tasks/L1/raw_cdp/v2_ifx_status_override_branch.json

@@ -0,0 +1,94 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "off",
+  "description": "fulfillRequest returns status 503 for /api-answer; the app's status branch renders DEGRADED_MODE_503 instead of the success path. Proves an injected error status steers client control flow.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "method": "Fetch.enable",
+        "params": {
+          "patterns": [
+            {
+              "requestStage": "Request",
+              "urlPattern": "*ifx/api-answer*"
+            }
+          ]
+        }
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__abbStatusBranch(location.origin+'/v0_2/ifx/api-answer')"
+        }
+      },
+      {
+        "save_result_as": "paused",
+        "session": "page",
+        "timeout_ms": 6000,
+        "wait_for_event": "Fetch.requestPaused"
+      },
+      {
+        "method": "Fetch.fulfillRequest",
+        "params": {
+          "body": "",
+          "requestId": "{saved:paused.requestId}",
+          "responseCode": 503,
+          "responseHeaders": [
+            {
+              "name": "Content-Type",
+              "value": "text/plain"
+            }
+          ]
+        }
+      },
+      {
+        "sleep_ms": 500
+      },
+      {
+        "method": "Runtime.evaluate",
+        "params": {
+          "expression": "window.__answer",
+          "returnByValue": true
+        },
+        "save_as": "ans"
+      }
+    ]
+  },
+  "features": [
+    "cdp.fetch.enable",
+    "cdp.fetch.fulfill_request"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "event_observed",
+        "method": "Fetch.requestPaused",
+        "name": "paused"
+      },
+      {
+        "expected": "DEGRADED_MODE_503",
+        "kind": "value_equals",
+        "name": "ans"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "self_hosted_fixture",
+    "url": "/v0_2/ifx/app"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.fetch_intercept",
+    "version.v0_2"
+  ],
+  "task_id": "v2_ifx_status_override_branch",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 20000
+  },
+  "title": "Injected 503 status drives a degradation branch"
+}

definitions/tasks/L1/raw_cdp/v2_neg_dom_getboxmodelfornode.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative: DOM.getBoxModelForNode does not exist (the real command is DOM.getBoxModel). A misremembered method name must be cleanly rejected as unknown, not silently accepted.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "DOM.getBoxModelForNode",
+        "params": {
+          "nodeId": 1
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.protocol.unknown_method"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "DOM.getBoxModelForNode"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_dom_getboxmodelfornode",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "dom_getboxmodelfornode"
+}

definitions/tasks/L1/raw_cdp/v2_neg_emulation_devicemetrics_badwidth.json

@@ -0,0 +1,49 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative (bad param type): Emulation.setDeviceMetricsOverride.width must be an integer; passing a string must yield a clean InvalidParams rejection rather than a hang.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Emulation.setDeviceMetricsOverride",
+        "params": {
+          "deviceScaleFactor": 1,
+          "height": 600,
+          "mobile": false,
+          "width": "wide"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.emulation.set_device_metrics_override"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Emulation.setDeviceMetricsOverride"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_emulation_devicemetrics_badwidth",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "emulation_devicemetrics_badwidth"
+}

definitions/tasks/L1/raw_cdp/v2_neg_input_dispatchkey_badtype.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative (bad param type): Input.dispatchKeyEvent.type must be one of the enum strings; passing a number must yield a clean InvalidParams rejection rather than a hang or a synthesized event.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Input.dispatchKeyEvent",
+        "params": {
+          "type": 42
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.input.dispatch_key_event"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Input.dispatchKeyEvent"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_input_dispatchkey_badtype",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "input_dispatchkey_badtype"
+}

definitions/tasks/L1/raw_cdp/v2_neg_input_dispatchkey_missing_type.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative (missing required param): Input.dispatchKeyEvent requires 'type'; omitting it must yield a clean InvalidParams rejection rather than a hang or a synthesized event.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Input.dispatchKeyEvent",
+        "params": {
+          "key": "a"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.input.dispatch_key_event"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Input.dispatchKeyEvent"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_input_dispatchkey_missing_type",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "input_dispatchkey_missing_type"
+}

definitions/tasks/L1/raw_cdp/v2_neg_nonexistent_domain.json

@@ -0,0 +1,44 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative: 'Moli' is not a CDP domain and inspectEverything is not a command. A call into a wholly nonexistent domain must be cleanly rejected as unknown.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Moli.inspectEverything",
+        "params": {}
+      }
+    ]
+  },
+  "features": [
+    "cdp.protocol.unknown_method"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Moli.inspectEverything"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_nonexistent_domain",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "nonexistent_domain"
+}

definitions/tasks/L1/raw_cdp/v2_neg_page_deletecookie.json

@@ -0,0 +1,47 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative: Page.deleteCookie was removed from the Page domain and relocated to Network.deleteCookies. On a conformant engine it must be cleanly rejected as an unknown method; a hang or crash fails. Declared expect_unsupported so the clean rejection is the passing outcome.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Page.deleteCookie",
+        "params": {
+          "cookieName": "x",
+          "url": "http://127.0.0.1/"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.page.delete_cookie.removed"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Page.deleteCookie"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_page_deletecookie",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "page_deletecookie"
+}

definitions/tasks/L1/raw_cdp/v2_neg_page_navigate_badurl.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative (bad param type): Page.navigate.url must be a string; passing a number must yield a clean synchronous InvalidParams rejection rather than a hang or a bogus navigation. Declared expect_unsupported (a rejected/InvalidParams outcome passes).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Page.navigate",
+        "params": {
+          "url": 123
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.page.navigate"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Page.navigate"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_page_navigate_badurl",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "page_navigate_badurl"
+}

definitions/tasks/L1/raw_cdp/v2_neg_runtime_evaluateexpression.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative: Runtime.evaluateExpression is not a real command (the actual command is Runtime.evaluate). A plausible-but-wrong method name must be cleanly rejected as unknown, not silently accepted; a hang or crash fails.",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Runtime.evaluateExpression",
+        "params": {
+          "expression": "1"
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.protocol.unknown_method"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Runtime.evaluateExpression"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_runtime_evaluateexpression",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "runtime_evaluateexpression"
+}

definitions/tasks/L1/raw_cdp/v2_neg_runtime_getproperties_badobjid.json

@@ -0,0 +1,46 @@
+{
+  "artifact_profile": "l1_standard",
+  "chrome_gate": "best_effort",
+  "description": "Negative (bad param type): Runtime.getProperties.objectId must be a string RemoteObjectId; passing an integer must yield a clean synchronous InvalidParams rejection rather than a hang. Declared expect_unsupported (a rejected/InvalidParams outcome passes).",
+  "driver": {
+    "kind": "raw_cdp",
+    "steps": [
+      {
+        "expect_unsupported": true,
+        "method": "Runtime.getProperties",
+        "params": {
+          "objectId": 12345
+        }
+      }
+    ]
+  },
+  "features": [
+    "cdp.runtime.get_properties"
+  ],
+  "grader": {
+    "checks": [
+      {
+        "kind": "unsupported_observed",
+        "method": "Runtime.getProperties"
+      }
+    ],
+    "kind": "inline_assertions"
+  },
+  "layer": "L1",
+  "scene": {
+    "kind": "about_blank"
+  },
+  "subset_id": "l1.raw_cdp",
+  "tags": [
+    "family.negative",
+    "purpose.negative",
+    "version.v0_2"
+  ],
+  "task_id": "v2_neg_runtime_getproperties_badobjid",
+  "task_version": 1,
+  "timeouts": {
+    "hard_kill_ms": 30000,
+    "task_ms": 15000
+  },
+  "title": "runtime_getproperties_badobjid"
+}