doc-detective-common 4.33.0 → 4.34.0

package/dist/index.cjs

@@ -34564,6 +34564,56 @@ var schemas_default = {
                                                             }
                                                           ]
                                                         },
+                                                        verify: {
+                                                          title: "Recording verify guards",
+                                                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                          type: "object",
+                                                          additionalProperties: false,
+                                                          properties: {
+                                                            minDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is shorter than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            maxDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is longer than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            resolution: {
+                                                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                              anyOf: [
+                                                                {
+                                                                  type: "boolean",
+                                                                  title: "Verify resolution (boolean)"
+                                                                },
+                                                                {
+                                                                  type: "object",
+                                                                  title: "Verify resolution (detailed)",
+                                                                  additionalProperties: false,
+                                                                  required: [
+                                                                    "width",
+                                                                    "height"
+                                                                  ],
+                                                                  properties: {
+                                                                    width: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    },
+                                                                    height: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    }
+                                                                  }
+                                                                }
+                                                              ]
+                                                            },
+                                                            notBlack: {
+                                                              type: "boolean",
+                                                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                            }
+                                                          }
+                                                        },
                                                         checkpoints: {
                                                           title: "Recording checkpoints",
                                                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -34919,6 +34969,56 @@ var schemas_default = {
                                                               }
                                                             ]
                                                           },
+                                                          verify: {
+                                                            title: "Recording verify guards",
+                                                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                            type: "object",
+                                                            additionalProperties: false,
+                                                            properties: {
+                                                              minDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is shorter than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              maxDuration: {
+                                                                type: "number",
+                                                                description: "Fail if the video is longer than this many seconds.",
+                                                                minimum: 0
+                                                              },
+                                                              resolution: {
+                                                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                anyOf: [
+                                                                  {
+                                                                    type: "boolean",
+                                                                    title: "Verify resolution (boolean)"
+                                                                  },
+                                                                  {
+                                                                    type: "object",
+                                                                    title: "Verify resolution (detailed)",
+                                                                    additionalProperties: false,
+                                                                    required: [
+                                                                      "width",
+                                                                      "height"
+                                                                    ],
+                                                                    properties: {
+                                                                      width: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      },
+                                                                      height: {
+                                                                        type: "integer",
+                                                                        minimum: 1
+                                                                      }
+                                                                    }
+                                                                  }
+                                                                ]
+                                                              },
+                                                              notBlack: {
+                                                                type: "boolean",
+                                                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                              }
+                                                            }
+                                                          },
                                                           checkpoints: {
                                                             title: "Recording checkpoints",
                                                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -80286,6 +80386,56 @@ var schemas_default = {
                                               }
                                             ]
                                           },
+                                          verify: {
+                                            title: "Recording verify guards",
+                                            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                            type: "object",
+                                            additionalProperties: false,
+                                            properties: {
+                                              minDuration: {
+                                                type: "number",
+                                                description: "Fail if the video is shorter than this many seconds.",
+                                                minimum: 0
+                                              },
+                                              maxDuration: {
+                                                type: "number",
+                                                description: "Fail if the video is longer than this many seconds.",
+                                                minimum: 0
+                                              },
+                                              resolution: {
+                                                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                anyOf: [
+                                                  {
+                                                    type: "boolean",
+                                                    title: "Verify resolution (boolean)"
+                                                  },
+                                                  {
+                                                    type: "object",
+                                                    title: "Verify resolution (detailed)",
+                                                    additionalProperties: false,
+                                                    required: [
+                                                      "width",
+                                                      "height"
+                                                    ],
+                                                    properties: {
+                                                      width: {
+                                                        type: "integer",
+                                                        minimum: 1
+                                                      },
+                                                      height: {
+                                                        type: "integer",
+                                                        minimum: 1
+                                                      }
+                                                    }
+                                                  }
+                                                ]
+                                              },
+                                              notBlack: {
+                                                type: "boolean",
+                                                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                              }
+                                            }
+                                          },
                                           checkpoints: {
                                             title: "Recording checkpoints",
                                             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -80641,6 +80791,56 @@ var schemas_default = {
                                                 }
                                               ]
                                             },
+                                            verify: {
+                                              title: "Recording verify guards",
+                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                              type: "object",
+                                              additionalProperties: false,
+                                              properties: {
+                                                minDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                maxDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is longer than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                resolution: {
+                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                  anyOf: [
+                                                    {
+                                                      type: "boolean",
+                                                      title: "Verify resolution (boolean)"
+                                                    },
+                                                    {
+                                                      type: "object",
+                                                      title: "Verify resolution (detailed)",
+                                                      additionalProperties: false,
+                                                      required: [
+                                                        "width",
+                                                        "height"
+                                                      ],
+                                                      properties: {
+                                                        width: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        },
+                                                        height: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        }
+                                                      }
+                                                    }
+                                                  ]
+                                                },
+                                                notBlack: {
+                                                  type: "boolean",
+                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                }
+                                              }
+                                            },
                                             checkpoints: {
                                               title: "Recording checkpoints",
                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -106648,6 +106848,56 @@ var schemas_default = {
               }
             ]
           },
+          verify: {
+            title: "Recording verify guards",
+            description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              minDuration: {
+                type: "number",
+                description: "Fail if the video is shorter than this many seconds.",
+                minimum: 0
+              },
+              maxDuration: {
+                type: "number",
+                description: "Fail if the video is longer than this many seconds.",
+                minimum: 0
+              },
+              resolution: {
+                description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                anyOf: [
+                  {
+                    type: "boolean",
+                    title: "Verify resolution (boolean)"
+                  },
+                  {
+                    type: "object",
+                    title: "Verify resolution (detailed)",
+                    additionalProperties: false,
+                    required: [
+                      "width",
+                      "height"
+                    ],
+                    properties: {
+                      width: {
+                        type: "integer",
+                        minimum: 1
+                      },
+                      height: {
+                        type: "integer",
+                        minimum: 1
+                      }
+                    }
+                  }
+                ]
+              },
+              notBlack: {
+                type: "boolean",
+                description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+              }
+            }
+          },
           checkpoints: {
             title: "Recording checkpoints",
             description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -107003,6 +107253,56 @@ var schemas_default = {
                 }
               ]
             },
+            verify: {
+              title: "Recording verify guards",
+              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                minDuration: {
+                  type: "number",
+                  description: "Fail if the video is shorter than this many seconds.",
+                  minimum: 0
+                },
+                maxDuration: {
+                  type: "number",
+                  description: "Fail if the video is longer than this many seconds.",
+                  minimum: 0
+                },
+                resolution: {
+                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                  anyOf: [
+                    {
+                      type: "boolean",
+                      title: "Verify resolution (boolean)"
+                    },
+                    {
+                      type: "object",
+                      title: "Verify resolution (detailed)",
+                      additionalProperties: false,
+                      required: [
+                        "width",
+                        "height"
+                      ],
+                      properties: {
+                        width: {
+                          type: "integer",
+                          minimum: 1
+                        },
+                        height: {
+                          type: "integer",
+                          minimum: 1
+                        }
+                      }
+                    }
+                  ]
+                },
+                notBlack: {
+                  type: "boolean",
+                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                }
+              }
+            },
             checkpoints: {
               title: "Recording checkpoints",
               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -139372,6 +139672,56 @@ var schemas_default = {
                                                                 }
                                                               ]
                                                             },
+                                                            verify: {
+                                                              title: "Recording verify guards",
+                                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                              type: "object",
+                                                              additionalProperties: false,
+                                                              properties: {
+                                                                minDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                maxDuration: {
+                                                                  type: "number",
+                                                                  description: "Fail if the video is longer than this many seconds.",
+                                                                  minimum: 0
+                                                                },
+                                                                resolution: {
+                                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                  anyOf: [
+                                                                    {
+                                                                      type: "boolean",
+                                                                      title: "Verify resolution (boolean)"
+                                                                    },
+                                                                    {
+                                                                      type: "object",
+                                                                      title: "Verify resolution (detailed)",
+                                                                      additionalProperties: false,
+                                                                      required: [
+                                                                        "width",
+                                                                        "height"
+                                                                      ],
+                                                                      properties: {
+                                                                        width: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        },
+                                                                        height: {
+                                                                          type: "integer",
+                                                                          minimum: 1
+                                                                        }
+                                                                      }
+                                                                    }
+                                                                  ]
+                                                                },
+                                                                notBlack: {
+                                                                  type: "boolean",
+                                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                }
+                                                              }
+                                                            },
                                                             checkpoints: {
                                                               title: "Recording checkpoints",
                                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -139727,6 +140077,56 @@ var schemas_default = {
                                                                   }
                                                                 ]
                                                               },
+                                                              verify: {
+                                                                title: "Recording verify guards",
+                                                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                                type: "object",
+                                                                additionalProperties: false,
+                                                                properties: {
+                                                                  minDuration: {
+                                                                    type: "number",
+                                                                    description: "Fail if the video is shorter than this many seconds.",
+                                                                    minimum: 0
+                                                                  },
+                                                                  maxDuration: {
+                                                                    type: "number",
+                                                                    description: "Fail if the video is longer than this many seconds.",
+                                                                    minimum: 0
+                                                                  },
+                                                                  resolution: {
+                                                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                                    anyOf: [
+                                                                      {
+                                                                        type: "boolean",
+                                                                        title: "Verify resolution (boolean)"
+                                                                      },
+                                                                      {
+                                                                        type: "object",
+                                                                        title: "Verify resolution (detailed)",
+                                                                        additionalProperties: false,
+                                                                        required: [
+                                                                          "width",
+                                                                          "height"
+                                                                        ],
+                                                                        properties: {
+                                                                          width: {
+                                                                            type: "integer",
+                                                                            minimum: 1
+                                                                          },
+                                                                          height: {
+                                                                            type: "integer",
+                                                                            minimum: 1
+                                                                          }
+                                                                        }
+                                                                      }
+                                                                    ]
+                                                                  },
+                                                                  notBlack: {
+                                                                    type: "boolean",
+                                                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                                  }
+                                                                }
+                                                              },
                                                               checkpoints: {
                                                                 title: "Recording checkpoints",
                                                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -185094,6 +185494,56 @@ var schemas_default = {
                                                   }
                                                 ]
                                               },
+                                              verify: {
+                                                title: "Recording verify guards",
+                                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                type: "object",
+                                                additionalProperties: false,
+                                                properties: {
+                                                  minDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is shorter than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  maxDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is longer than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  resolution: {
+                                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                    anyOf: [
+                                                      {
+                                                        type: "boolean",
+                                                        title: "Verify resolution (boolean)"
+                                                      },
+                                                      {
+                                                        type: "object",
+                                                        title: "Verify resolution (detailed)",
+                                                        additionalProperties: false,
+                                                        required: [
+                                                          "width",
+                                                          "height"
+                                                        ],
+                                                        properties: {
+                                                          width: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          },
+                                                          height: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          }
+                                                        }
+                                                      }
+                                                    ]
+                                                  },
+                                                  notBlack: {
+                                                    type: "boolean",
+                                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                  }
+                                                }
+                                              },
                                               checkpoints: {
                                                 title: "Recording checkpoints",
                                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -185449,6 +185899,56 @@ var schemas_default = {
                                                     }
                                                   ]
                                                 },
+                                                verify: {
+                                                  title: "Recording verify guards",
+                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                  type: "object",
+                                                  additionalProperties: false,
+                                                  properties: {
+                                                    minDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    maxDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is longer than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    resolution: {
+                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                      anyOf: [
+                                                        {
+                                                          type: "boolean",
+                                                          title: "Verify resolution (boolean)"
+                                                        },
+                                                        {
+                                                          type: "object",
+                                                          title: "Verify resolution (detailed)",
+                                                          additionalProperties: false,
+                                                          required: [
+                                                            "width",
+                                                            "height"
+                                                          ],
+                                                          properties: {
+                                                            width: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            },
+                                                            height: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            }
+                                                          }
+                                                        }
+                                                      ]
+                                                    },
+                                                    notBlack: {
+                                                      type: "boolean",
+                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                    }
+                                                  }
+                                                },
                                                 checkpoints: {
                                                   title: "Recording checkpoints",
                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -232555,6 +233055,56 @@ var schemas_default = {
                                                     }
                                                   ]
                                                 },
+                                                verify: {
+                                                  title: "Recording verify guards",
+                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                  type: "object",
+                                                  additionalProperties: false,
+                                                  properties: {
+                                                    minDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    maxDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is longer than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    resolution: {
+                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                      anyOf: [
+                                                        {
+                                                          type: "boolean",
+                                                          title: "Verify resolution (boolean)"
+                                                        },
+                                                        {
+                                                          type: "object",
+                                                          title: "Verify resolution (detailed)",
+                                                          additionalProperties: false,
+                                                          required: [
+                                                            "width",
+                                                            "height"
+                                                          ],
+                                                          properties: {
+                                                            width: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            },
+                                                            height: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            }
+                                                          }
+                                                        }
+                                                      ]
+                                                    },
+                                                    notBlack: {
+                                                      type: "boolean",
+                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                    }
+                                                  }
+                                                },
                                                 checkpoints: {
                                                   title: "Recording checkpoints",
                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -232910,6 +233460,56 @@ var schemas_default = {
                                                       }
                                                     ]
                                                   },
+                                                  verify: {
+                                                    title: "Recording verify guards",
+                                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                    type: "object",
+                                                    additionalProperties: false,
+                                                    properties: {
+                                                      minDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is shorter than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      maxDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is longer than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      resolution: {
+                                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                        anyOf: [
+                                                          {
+                                                            type: "boolean",
+                                                            title: "Verify resolution (boolean)"
+                                                          },
+                                                          {
+                                                            type: "object",
+                                                            title: "Verify resolution (detailed)",
+                                                            additionalProperties: false,
+                                                            required: [
+                                                              "width",
+                                                              "height"
+                                                            ],
+                                                            properties: {
+                                                              width: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              },
+                                                              height: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              }
+                                                            }
+                                                          }
+                                                        ]
+                                                      },
+                                                      notBlack: {
+                                                        type: "boolean",
+                                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                      }
+                                                    }
+                                                  },
                                                   checkpoints: {
                                                     title: "Recording checkpoints",
                                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -277539,6 +278139,56 @@ var schemas_default = {
                                                           }
                                                         ]
                                                       },
+                                                      verify: {
+                                                        title: "Recording verify guards",
+                                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                        type: "object",
+                                                        additionalProperties: false,
+                                                        properties: {
+                                                          minDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is shorter than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          maxDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is longer than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          resolution: {
+                                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                            anyOf: [
+                                                              {
+                                                                type: "boolean",
+                                                                title: "Verify resolution (boolean)"
+                                                              },
+                                                              {
+                                                                type: "object",
+                                                                title: "Verify resolution (detailed)",
+                                                                additionalProperties: false,
+                                                                required: [
+                                                                  "width",
+                                                                  "height"
+                                                                ],
+                                                                properties: {
+                                                                  width: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  },
+                                                                  height: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  }
+                                                                }
+                                                              }
+                                                            ]
+                                                          },
+                                                          notBlack: {
+                                                            type: "boolean",
+                                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                          }
+                                                        }
+                                                      },
                                                       checkpoints: {
                                                         title: "Recording checkpoints",
                                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -277894,6 +278544,56 @@ var schemas_default = {
                                                             }
                                                           ]
                                                         },
+                                                        verify: {
+                                                          title: "Recording verify guards",
+                                                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                          type: "object",
+                                                          additionalProperties: false,
+                                                          properties: {
+                                                            minDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is shorter than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            maxDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is longer than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            resolution: {
+                                                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                              anyOf: [
+                                                                {
+                                                                  type: "boolean",
+                                                                  title: "Verify resolution (boolean)"
+                                                                },
+                                                                {
+                                                                  type: "object",
+                                                                  title: "Verify resolution (detailed)",
+                                                                  additionalProperties: false,
+                                                                  required: [
+                                                                    "width",
+                                                                    "height"
+                                                                  ],
+                                                                  properties: {
+                                                                    width: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    },
+                                                                    height: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    }
+                                                                  }
+                                                                }
+                                                              ]
+                                                            },
+                                                            notBlack: {
+                                                              type: "boolean",
+                                                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                            }
+                                                          }
+                                                        },
                                                         checkpoints: {
                                                           title: "Recording checkpoints",
                                                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -325484,6 +326184,56 @@ var schemas_default = {
                                                     }
                                                   ]
                                                 },
+                                                verify: {
+                                                  title: "Recording verify guards",
+                                                  description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                  type: "object",
+                                                  additionalProperties: false,
+                                                  properties: {
+                                                    minDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is shorter than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    maxDuration: {
+                                                      type: "number",
+                                                      description: "Fail if the video is longer than this many seconds.",
+                                                      minimum: 0
+                                                    },
+                                                    resolution: {
+                                                      description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                      anyOf: [
+                                                        {
+                                                          type: "boolean",
+                                                          title: "Verify resolution (boolean)"
+                                                        },
+                                                        {
+                                                          type: "object",
+                                                          title: "Verify resolution (detailed)",
+                                                          additionalProperties: false,
+                                                          required: [
+                                                            "width",
+                                                            "height"
+                                                          ],
+                                                          properties: {
+                                                            width: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            },
+                                                            height: {
+                                                              type: "integer",
+                                                              minimum: 1
+                                                            }
+                                                          }
+                                                        }
+                                                      ]
+                                                    },
+                                                    notBlack: {
+                                                      type: "boolean",
+                                                      description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                    }
+                                                  }
+                                                },
                                                 checkpoints: {
                                                   title: "Recording checkpoints",
                                                   description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -325839,6 +326589,56 @@ var schemas_default = {
                                                       }
                                                     ]
                                                   },
+                                                  verify: {
+                                                    title: "Recording verify guards",
+                                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                    type: "object",
+                                                    additionalProperties: false,
+                                                    properties: {
+                                                      minDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is shorter than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      maxDuration: {
+                                                        type: "number",
+                                                        description: "Fail if the video is longer than this many seconds.",
+                                                        minimum: 0
+                                                      },
+                                                      resolution: {
+                                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                        anyOf: [
+                                                          {
+                                                            type: "boolean",
+                                                            title: "Verify resolution (boolean)"
+                                                          },
+                                                          {
+                                                            type: "object",
+                                                            title: "Verify resolution (detailed)",
+                                                            additionalProperties: false,
+                                                            required: [
+                                                              "width",
+                                                              "height"
+                                                            ],
+                                                            properties: {
+                                                              width: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              },
+                                                              height: {
+                                                                type: "integer",
+                                                                minimum: 1
+                                                              }
+                                                            }
+                                                          }
+                                                        ]
+                                                      },
+                                                      notBlack: {
+                                                        type: "boolean",
+                                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                      }
+                                                    }
+                                                  },
                                                   checkpoints: {
                                                     title: "Recording checkpoints",
                                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -370468,6 +371268,56 @@ var schemas_default = {
                                                           }
                                                         ]
                                                       },
+                                                      verify: {
+                                                        title: "Recording verify guards",
+                                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                        type: "object",
+                                                        additionalProperties: false,
+                                                        properties: {
+                                                          minDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is shorter than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          maxDuration: {
+                                                            type: "number",
+                                                            description: "Fail if the video is longer than this many seconds.",
+                                                            minimum: 0
+                                                          },
+                                                          resolution: {
+                                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                            anyOf: [
+                                                              {
+                                                                type: "boolean",
+                                                                title: "Verify resolution (boolean)"
+                                                              },
+                                                              {
+                                                                type: "object",
+                                                                title: "Verify resolution (detailed)",
+                                                                additionalProperties: false,
+                                                                required: [
+                                                                  "width",
+                                                                  "height"
+                                                                ],
+                                                                properties: {
+                                                                  width: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  },
+                                                                  height: {
+                                                                    type: "integer",
+                                                                    minimum: 1
+                                                                  }
+                                                                }
+                                                              }
+                                                            ]
+                                                          },
+                                                          notBlack: {
+                                                            type: "boolean",
+                                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                          }
+                                                        }
+                                                      },
                                                       checkpoints: {
                                                         title: "Recording checkpoints",
                                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -370823,6 +371673,56 @@ var schemas_default = {
                                                             }
                                                           ]
                                                         },
+                                                        verify: {
+                                                          title: "Recording verify guards",
+                                                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                          type: "object",
+                                                          additionalProperties: false,
+                                                          properties: {
+                                                            minDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is shorter than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            maxDuration: {
+                                                              type: "number",
+                                                              description: "Fail if the video is longer than this many seconds.",
+                                                              minimum: 0
+                                                            },
+                                                            resolution: {
+                                                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                              anyOf: [
+                                                                {
+                                                                  type: "boolean",
+                                                                  title: "Verify resolution (boolean)"
+                                                                },
+                                                                {
+                                                                  type: "object",
+                                                                  title: "Verify resolution (detailed)",
+                                                                  additionalProperties: false,
+                                                                  required: [
+                                                                    "width",
+                                                                    "height"
+                                                                  ],
+                                                                  properties: {
+                                                                    width: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    },
+                                                                    height: {
+                                                                      type: "integer",
+                                                                      minimum: 1
+                                                                    }
+                                                                  }
+                                                                }
+                                                              ]
+                                                            },
+                                                            notBlack: {
+                                                              type: "boolean",
+                                                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                            }
+                                                          }
+                                                        },
                                                         checkpoints: {
                                                           title: "Recording checkpoints",
                                                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -421743,6 +422643,56 @@ var schemas_default = {
                                           }
                                         ]
                                       },
+                                      verify: {
+                                        title: "Recording verify guards",
+                                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                        type: "object",
+                                        additionalProperties: false,
+                                        properties: {
+                                          minDuration: {
+                                            type: "number",
+                                            description: "Fail if the video is shorter than this many seconds.",
+                                            minimum: 0
+                                          },
+                                          maxDuration: {
+                                            type: "number",
+                                            description: "Fail if the video is longer than this many seconds.",
+                                            minimum: 0
+                                          },
+                                          resolution: {
+                                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                            anyOf: [
+                                              {
+                                                type: "boolean",
+                                                title: "Verify resolution (boolean)"
+                                              },
+                                              {
+                                                type: "object",
+                                                title: "Verify resolution (detailed)",
+                                                additionalProperties: false,
+                                                required: [
+                                                  "width",
+                                                  "height"
+                                                ],
+                                                properties: {
+                                                  width: {
+                                                    type: "integer",
+                                                    minimum: 1
+                                                  },
+                                                  height: {
+                                                    type: "integer",
+                                                    minimum: 1
+                                                  }
+                                                }
+                                              }
+                                            ]
+                                          },
+                                          notBlack: {
+                                            type: "boolean",
+                                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                          }
+                                        }
+                                      },
                                       checkpoints: {
                                         title: "Recording checkpoints",
                                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -422098,6 +423048,56 @@ var schemas_default = {
                                             }
                                           ]
                                         },
+                                        verify: {
+                                          title: "Recording verify guards",
+                                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                          type: "object",
+                                          additionalProperties: false,
+                                          properties: {
+                                            minDuration: {
+                                              type: "number",
+                                              description: "Fail if the video is shorter than this many seconds.",
+                                              minimum: 0
+                                            },
+                                            maxDuration: {
+                                              type: "number",
+                                              description: "Fail if the video is longer than this many seconds.",
+                                              minimum: 0
+                                            },
+                                            resolution: {
+                                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                              anyOf: [
+                                                {
+                                                  type: "boolean",
+                                                  title: "Verify resolution (boolean)"
+                                                },
+                                                {
+                                                  type: "object",
+                                                  title: "Verify resolution (detailed)",
+                                                  additionalProperties: false,
+                                                  required: [
+                                                    "width",
+                                                    "height"
+                                                  ],
+                                                  properties: {
+                                                    width: {
+                                                      type: "integer",
+                                                      minimum: 1
+                                                    },
+                                                    height: {
+                                                      type: "integer",
+                                                      minimum: 1
+                                                    }
+                                                  }
+                                                }
+                                              ]
+                                            },
+                                            notBlack: {
+                                              type: "boolean",
+                                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                            }
+                                          }
+                                        },
                                         checkpoints: {
                                           title: "Recording checkpoints",
                                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -466727,6 +467727,56 @@ var schemas_default = {
                                                 }
                                               ]
                                             },
+                                            verify: {
+                                              title: "Recording verify guards",
+                                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                              type: "object",
+                                              additionalProperties: false,
+                                              properties: {
+                                                minDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is shorter than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                maxDuration: {
+                                                  type: "number",
+                                                  description: "Fail if the video is longer than this many seconds.",
+                                                  minimum: 0
+                                                },
+                                                resolution: {
+                                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                  anyOf: [
+                                                    {
+                                                      type: "boolean",
+                                                      title: "Verify resolution (boolean)"
+                                                    },
+                                                    {
+                                                      type: "object",
+                                                      title: "Verify resolution (detailed)",
+                                                      additionalProperties: false,
+                                                      required: [
+                                                        "width",
+                                                        "height"
+                                                      ],
+                                                      properties: {
+                                                        width: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        },
+                                                        height: {
+                                                          type: "integer",
+                                                          minimum: 1
+                                                        }
+                                                      }
+                                                    }
+                                                  ]
+                                                },
+                                                notBlack: {
+                                                  type: "boolean",
+                                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                }
+                                              }
+                                            },
                                             checkpoints: {
                                               title: "Recording checkpoints",
                                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -467082,6 +468132,56 @@ var schemas_default = {
                                                   }
                                                 ]
                                               },
+                                              verify: {
+                                                title: "Recording verify guards",
+                                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                                type: "object",
+                                                additionalProperties: false,
+                                                properties: {
+                                                  minDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is shorter than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  maxDuration: {
+                                                    type: "number",
+                                                    description: "Fail if the video is longer than this many seconds.",
+                                                    minimum: 0
+                                                  },
+                                                  resolution: {
+                                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                                    anyOf: [
+                                                      {
+                                                        type: "boolean",
+                                                        title: "Verify resolution (boolean)"
+                                                      },
+                                                      {
+                                                        type: "object",
+                                                        title: "Verify resolution (detailed)",
+                                                        additionalProperties: false,
+                                                        required: [
+                                                          "width",
+                                                          "height"
+                                                        ],
+                                                        properties: {
+                                                          width: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          },
+                                                          height: {
+                                                            type: "integer",
+                                                            minimum: 1
+                                                          }
+                                                        }
+                                                      }
+                                                    ]
+                                                  },
+                                                  notBlack: {
+                                                    type: "boolean",
+                                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                                  }
+                                                }
+                                              },
                                               checkpoints: {
                                                 title: "Recording checkpoints",
                                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -513403,6 +514503,56 @@ var schemas_default = {
                           }
                         ]
                       },
+                      verify: {
+                        title: "Recording verify guards",
+                        description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                          minDuration: {
+                            type: "number",
+                            description: "Fail if the video is shorter than this many seconds.",
+                            minimum: 0
+                          },
+                          maxDuration: {
+                            type: "number",
+                            description: "Fail if the video is longer than this many seconds.",
+                            minimum: 0
+                          },
+                          resolution: {
+                            description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                            anyOf: [
+                              {
+                                type: "boolean",
+                                title: "Verify resolution (boolean)"
+                              },
+                              {
+                                type: "object",
+                                title: "Verify resolution (detailed)",
+                                additionalProperties: false,
+                                required: [
+                                  "width",
+                                  "height"
+                                ],
+                                properties: {
+                                  width: {
+                                    type: "integer",
+                                    minimum: 1
+                                  },
+                                  height: {
+                                    type: "integer",
+                                    minimum: 1
+                                  }
+                                }
+                              }
+                            ]
+                          },
+                          notBlack: {
+                            type: "boolean",
+                            description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                          }
+                        }
+                      },
                       checkpoints: {
                         title: "Recording checkpoints",
                         description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -513758,6 +514908,56 @@ var schemas_default = {
                             }
                           ]
                         },
+                        verify: {
+                          title: "Recording verify guards",
+                          description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                          type: "object",
+                          additionalProperties: false,
+                          properties: {
+                            minDuration: {
+                              type: "number",
+                              description: "Fail if the video is shorter than this many seconds.",
+                              minimum: 0
+                            },
+                            maxDuration: {
+                              type: "number",
+                              description: "Fail if the video is longer than this many seconds.",
+                              minimum: 0
+                            },
+                            resolution: {
+                              description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                              anyOf: [
+                                {
+                                  type: "boolean",
+                                  title: "Verify resolution (boolean)"
+                                },
+                                {
+                                  type: "object",
+                                  title: "Verify resolution (detailed)",
+                                  additionalProperties: false,
+                                  required: [
+                                    "width",
+                                    "height"
+                                  ],
+                                  properties: {
+                                    width: {
+                                      type: "integer",
+                                      minimum: 1
+                                    },
+                                    height: {
+                                      type: "integer",
+                                      minimum: 1
+                                    }
+                                  }
+                                }
+                              ]
+                            },
+                            notBlack: {
+                              type: "boolean",
+                              description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                            }
+                          }
+                        },
                         checkpoints: {
                           title: "Recording checkpoints",
                           description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -561732,6 +562932,56 @@ var schemas_default = {
                                 }
                               ]
                             },
+                            verify: {
+                              title: "Recording verify guards",
+                              description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                              type: "object",
+                              additionalProperties: false,
+                              properties: {
+                                minDuration: {
+                                  type: "number",
+                                  description: "Fail if the video is shorter than this many seconds.",
+                                  minimum: 0
+                                },
+                                maxDuration: {
+                                  type: "number",
+                                  description: "Fail if the video is longer than this many seconds.",
+                                  minimum: 0
+                                },
+                                resolution: {
+                                  description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                  anyOf: [
+                                    {
+                                      type: "boolean",
+                                      title: "Verify resolution (boolean)"
+                                    },
+                                    {
+                                      type: "object",
+                                      title: "Verify resolution (detailed)",
+                                      additionalProperties: false,
+                                      required: [
+                                        "width",
+                                        "height"
+                                      ],
+                                      properties: {
+                                        width: {
+                                          type: "integer",
+                                          minimum: 1
+                                        },
+                                        height: {
+                                          type: "integer",
+                                          minimum: 1
+                                        }
+                                      }
+                                    }
+                                  ]
+                                },
+                                notBlack: {
+                                  type: "boolean",
+                                  description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                }
+                              }
+                            },
                             checkpoints: {
                               title: "Recording checkpoints",
                               description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -562087,6 +563337,56 @@ var schemas_default = {
                                   }
                                 ]
                               },
+                              verify: {
+                                title: "Recording verify guards",
+                                description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                type: "object",
+                                additionalProperties: false,
+                                properties: {
+                                  minDuration: {
+                                    type: "number",
+                                    description: "Fail if the video is shorter than this many seconds.",
+                                    minimum: 0
+                                  },
+                                  maxDuration: {
+                                    type: "number",
+                                    description: "Fail if the video is longer than this many seconds.",
+                                    minimum: 0
+                                  },
+                                  resolution: {
+                                    description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                    anyOf: [
+                                      {
+                                        type: "boolean",
+                                        title: "Verify resolution (boolean)"
+                                      },
+                                      {
+                                        type: "object",
+                                        title: "Verify resolution (detailed)",
+                                        additionalProperties: false,
+                                        required: [
+                                          "width",
+                                          "height"
+                                        ],
+                                        properties: {
+                                          width: {
+                                            type: "integer",
+                                            minimum: 1
+                                          },
+                                          height: {
+                                            type: "integer",
+                                            minimum: 1
+                                          }
+                                        }
+                                      }
+                                    ]
+                                  },
+                                  notBlack: {
+                                    type: "boolean",
+                                    description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                  }
+                                }
+                              },
                               checkpoints: {
                                 title: "Recording checkpoints",
                                 description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -606716,6 +608016,56 @@ var schemas_default = {
                                       }
                                     ]
                                   },
+                                  verify: {
+                                    title: "Recording verify guards",
+                                    description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                    type: "object",
+                                    additionalProperties: false,
+                                    properties: {
+                                      minDuration: {
+                                        type: "number",
+                                        description: "Fail if the video is shorter than this many seconds.",
+                                        minimum: 0
+                                      },
+                                      maxDuration: {
+                                        type: "number",
+                                        description: "Fail if the video is longer than this many seconds.",
+                                        minimum: 0
+                                      },
+                                      resolution: {
+                                        description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                        anyOf: [
+                                          {
+                                            type: "boolean",
+                                            title: "Verify resolution (boolean)"
+                                          },
+                                          {
+                                            type: "object",
+                                            title: "Verify resolution (detailed)",
+                                            additionalProperties: false,
+                                            required: [
+                                              "width",
+                                              "height"
+                                            ],
+                                            properties: {
+                                              width: {
+                                                type: "integer",
+                                                minimum: 1
+                                              },
+                                              height: {
+                                                type: "integer",
+                                                minimum: 1
+                                              }
+                                            }
+                                          }
+                                        ]
+                                      },
+                                      notBlack: {
+                                        type: "boolean",
+                                        description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                      }
+                                    }
+                                  },
                                   checkpoints: {
                                     title: "Recording checkpoints",
                                     description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",
@@ -607071,6 +608421,56 @@ var schemas_default = {
                                         }
                                       ]
                                     },
+                                    verify: {
+                                      title: "Recording verify guards",
+                                      description: "Structural assertions on the produced video file, evaluated when the recording stops. Unlike checkpoint drift (a WARNING), a violated guard FAILs the stopRecord step \u2014 these are properties you explicitly demand of the artifact.",
+                                      type: "object",
+                                      additionalProperties: false,
+                                      properties: {
+                                        minDuration: {
+                                          type: "number",
+                                          description: "Fail if the video is shorter than this many seconds.",
+                                          minimum: 0
+                                        },
+                                        maxDuration: {
+                                          type: "number",
+                                          description: "Fail if the video is longer than this many seconds.",
+                                          minimum: 0
+                                        },
+                                        resolution: {
+                                          description: "Verify the video's dimensions (\xB12 pixels \u2014 encoders round to even dimensions). `true` compares against the capture plan's resolved expectation (the crop rectangle when a window/viewport crop applied, else the capture frame size; skipped when no expectation exists for the engine). An object compares literal dimensions.",
+                                          anyOf: [
+                                            {
+                                              type: "boolean",
+                                              title: "Verify resolution (boolean)"
+                                            },
+                                            {
+                                              type: "object",
+                                              title: "Verify resolution (detailed)",
+                                              additionalProperties: false,
+                                              required: [
+                                                "width",
+                                                "height"
+                                              ],
+                                              properties: {
+                                                width: {
+                                                  type: "integer",
+                                                  minimum: 1
+                                                },
+                                                height: {
+                                                  type: "integer",
+                                                  minimum: 1
+                                                }
+                                              }
+                                            }
+                                          ]
+                                        },
+                                        notBlack: {
+                                          type: "boolean",
+                                          description: "Fail if the video is essentially all black (black frames cover 95% or more of its duration) \u2014 the classic symptom of a broken screen capture."
+                                        }
+                                      }
+                                    },
                                     checkpoints: {
                                       title: "Recording checkpoints",
                                       description: "Capture a checkpoint screenshot after every step while this recording is active and compare each against a persistent baseline stored beside the recording (`<path>.checkpoints/` by default). Baselines seed on the first run; on later runs, per-checkpoint variation is reported in the `stopRecord` step's outputs, and variation beyond `maxVariation` surfaces as a WARNING. If `false` or unset, no checkpoints are captured.",