@documentation-robotics/cli 0.1.0

package/dist/schemas/bundled/12-testing-layer.schema.json

@@ -0,0 +1,1091 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/12-testing-layer.schema.json",
+  "title": "Testing Layer Schema",
+  "description": "Models test coverage requirements, input space partitioning, and coverage criteria to ensure comprehensive testing with traceability to requirements.",
+  "layerMetadata": {
+    "layerId": "12-testing",
+    "layerName": "Testing Layer",
+    "intraLayerRelationshipSupport": true,
+    "crossLayerRelationshipSupport": true,
+    "relationshipCatalogVersion": "2.1.0"
+  },
+  "intraLayerRelationships": {
+    "$comment": "Relationships between entities within this layer. References relationship-catalog.json by ID.",
+    "allowed": [
+      {
+        "relationshipTypeId": "composition",
+        "sourceTypes": ["CoverageRequirement", "TestCoverageModel", "TestCoverageTarget"],
+        "targetTypes": ["InputPartitionSelection", "OutcomeCategory", "TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "TestCoverageModel",
+            "target": "TestCoverageTarget",
+            "description": "Coverage model composes targets defining what needs testing"
+          },
+          {
+            "source": "TestCoverageTarget",
+            "target": "OutcomeCategory",
+            "description": "Coverage target composes expected outcome categories"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "InputPartitionSelection",
+            "description": "Coverage requirement composes partition value selections"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "aggregation",
+        "sourceTypes": ["CoverageRequirement", "InputPartitionSelection"],
+        "targetTypes": ["ContextVariation", "PartitionValue"],
+        "examples": [
+          {
+            "source": "InputPartitionSelection",
+            "target": "PartitionValue",
+            "description": "Partition selection aggregates multiple partition values to cover"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "ContextVariation",
+            "description": "Requirement aggregates selected contexts for testing"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "triggering",
+        "sourceTypes": ["CoverageGap", "PartitionDependency"],
+        "targetTypes": ["CoverageRequirement", "PartitionValue"],
+        "examples": [
+          {
+            "source": "PartitionDependency",
+            "target": "PartitionValue",
+            "description": "Dependency condition triggers inclusion/exclusion of partition values"
+          },
+          {
+            "source": "CoverageGap",
+            "target": "CoverageRequirement",
+            "description": "Identified gap triggers need for additional coverage"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "flow",
+        "sourceTypes": ["CoverageRequirement", "TestCoverageTarget"],
+        "targetTypes": ["CoverageRequirement", "TestCaseSketch"],
+        "examples": [
+          {
+            "source": "TestCoverageTarget",
+            "target": "CoverageRequirement",
+            "description": "Target flows to requirements that specify its coverage"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "TestCaseSketch",
+            "description": "Requirement flows to sketches that implement it"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "serving",
+        "sourceTypes": ["ContextVariation", "InputSpacePartition"],
+        "targetTypes": ["TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "InputSpacePartition",
+            "target": "TestCoverageTarget",
+            "description": "Partition serves target by defining testable input space"
+          },
+          {
+            "source": "ContextVariation",
+            "target": "TestCoverageTarget",
+            "description": "Context serves target by defining execution environments"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "access",
+        "sourceTypes": ["CoverageRequirement", "TestCaseSketch"],
+        "targetTypes": ["InputPartitionSelection", "InputSelection"],
+        "examples": [
+          {
+            "source": "TestCaseSketch",
+            "target": "InputSelection",
+            "description": "Test sketch accesses input selections for test execution"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "InputPartitionSelection",
+            "description": "Requirement accesses partition selections for coverage"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "reference",
+        "sourceTypes": ["CoverageRequirement", "InputSelection", "TestCaseSketch"],
+        "targetTypes": ["CoverageRequirement", "PartitionValue", "TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "TestCaseSketch",
+            "target": "CoverageRequirement",
+            "description": "Test case sketch references coverage requirement it satisfies"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "TestCoverageTarget",
+            "description": "Coverage requirement references target it covers"
+          },
+          {
+            "source": "InputSelection",
+            "target": "PartitionValue",
+            "description": "Input selection references selected partition value"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "depends-on",
+        "sourceTypes": ["CoverageRequirement", "TestCaseSketch"],
+        "targetTypes": ["ContextVariation", "InputSpacePartition", "OutcomeCategory"],
+        "examples": [
+          {
+            "source": "TestCaseSketch",
+            "target": "ContextVariation",
+            "description": "Test sketch depends on context for execution environment"
+          },
+          {
+            "source": "TestCaseSketch",
+            "target": "OutcomeCategory",
+            "description": "Test sketch depends on expected outcome category"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "InputSpacePartition",
+            "description": "Requirement depends on partitions for coverage criteria"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "validates",
+        "sourceTypes": ["TargetCoverageSummary", "TestCaseSketch"],
+        "targetTypes": ["CoverageRequirement", "TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "TestCaseSketch",
+            "target": "CoverageRequirement",
+            "description": "Test sketch validates requirement is satisfied"
+          },
+          {
+            "source": "TargetCoverageSummary",
+            "target": "TestCoverageTarget",
+            "description": "Summary validates coverage completeness of target"
+          }
+        ]
+      }
+    ]
+  },
+  "crossLayerRelationships": {
+    "$comment": "Relationships to/from entities in other layers",
+    "outgoing": [
+      {
+        "id": "testing-supports-goals",
+        "predicate": "supports-goals",
+        "inversePredicate": "supported-by",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["Goal"],
+        "sourceTypes": ["TestCoverageModel", "TestCaseSketch"],
+        "fieldPath": "motivation.supports-goals",
+        "cardinality": "array",
+        "format": "uuid",
+        "strength": "high",
+        "required": false,
+        "description": "Testing elements support strategic goals"
+      },
+      {
+        "id": "testing-fulfills-requirements",
+        "predicate": "fulfills-requirements",
+        "inversePredicate": "fulfilled-by",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["Requirement"],
+        "sourceTypes": ["TestCoverageModel", "TestCaseSketch", "CoverageRequirement"],
+        "fieldPath": "motivation.fulfills-requirements",
+        "cardinality": "array",
+        "format": "uuid",
+        "strength": "high",
+        "required": false,
+        "description": "Testing elements fulfill requirements"
+      },
+      {
+        "id": "testing-governed-by-principles",
+        "predicate": "governed-by-principles",
+        "inversePredicate": "governs",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["Principle"],
+        "sourceTypes": ["TestCoverageModel"],
+        "fieldPath": "motivation.governed-by-principles",
+        "cardinality": "array",
+        "format": "uuid",
+        "strength": "high",
+        "required": false,
+        "description": "Testing models governed by testing principles"
+      },
+      {
+        "id": "testing-constrained-by",
+        "predicate": "constrained-by",
+        "inversePredicate": "constrains",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["Constraint"],
+        "sourceTypes": ["TestCoverageModel", "CoverageRequirement"],
+        "fieldPath": "motivation.constrained-by",
+        "cardinality": "array",
+        "format": "uuid",
+        "strength": "medium",
+        "required": false,
+        "description": "Testing elements constrained by limitations"
+      }
+    ],
+    "incoming": []
+  },
+  "type": "object",
+  "properties": {
+    "test-coverage-models": {
+      "type": "array",
+      "description": "Collection of TestCoverageModel entities",
+      "items": {
+        "$ref": "#/definitions/TestCoverageModel"
+      }
+    },
+    "test-coverage-targets": {
+      "type": "array",
+      "description": "Collection of TestCoverageTarget entities",
+      "items": {
+        "$ref": "#/definitions/TestCoverageTarget"
+      }
+    },
+    "target-input-fields": {
+      "type": "array",
+      "description": "Collection of TargetInputField entities",
+      "items": {
+        "$ref": "#/definitions/TargetInputField"
+      }
+    },
+    "input-space-partitions": {
+      "type": "array",
+      "description": "Collection of InputSpacePartition entities",
+      "items": {
+        "$ref": "#/definitions/InputSpacePartition"
+      }
+    },
+    "partition-values": {
+      "type": "array",
+      "description": "Collection of PartitionValue entities",
+      "items": {
+        "$ref": "#/definitions/PartitionValue"
+      }
+    },
+    "partition-dependencies": {
+      "type": "array",
+      "description": "Collection of PartitionDependency entities",
+      "items": {
+        "$ref": "#/definitions/PartitionDependency"
+      }
+    },
+    "context-variations": {
+      "type": "array",
+      "description": "Collection of ContextVariation entities",
+      "items": {
+        "$ref": "#/definitions/ContextVariation"
+      }
+    },
+    "environment-factors": {
+      "type": "array",
+      "description": "Collection of EnvironmentFactor entities",
+      "items": {
+        "$ref": "#/definitions/EnvironmentFactor"
+      }
+    },
+    "outcome-categories": {
+      "type": "array",
+      "description": "Collection of OutcomeCategory entities",
+      "items": {
+        "$ref": "#/definitions/OutcomeCategory"
+      }
+    },
+    "coverage-requirements": {
+      "type": "array",
+      "description": "Collection of CoverageRequirement entities",
+      "items": {
+        "$ref": "#/definitions/CoverageRequirement"
+      }
+    },
+    "input-partition-selections": {
+      "type": "array",
+      "description": "Collection of InputPartitionSelection entities",
+      "items": {
+        "$ref": "#/definitions/InputPartitionSelection"
+      }
+    },
+    "coverage-exclusions": {
+      "type": "array",
+      "description": "Collection of CoverageExclusion entities",
+      "items": {
+        "$ref": "#/definitions/CoverageExclusion"
+      }
+    },
+    "test-case-sketches": {
+      "type": "array",
+      "description": "Collection of TestCaseSketch entities",
+      "items": {
+        "$ref": "#/definitions/TestCaseSketch"
+      }
+    },
+    "input-selections": {
+      "type": "array",
+      "description": "Collection of InputSelection entities",
+      "items": {
+        "$ref": "#/definitions/InputSelection"
+      }
+    },
+    "coverage-summaries": {
+      "type": "array",
+      "description": "Collection of CoverageSummary entities",
+      "items": {
+        "$ref": "#/definitions/CoverageSummary"
+      }
+    },
+    "target-coverage-summaries": {
+      "type": "array",
+      "description": "Collection of TargetCoverageSummary entities",
+      "items": {
+        "$ref": "#/definitions/TargetCoverageSummary"
+      }
+    },
+    "coverage-gaps": {
+      "type": "array",
+      "description": "Collection of CoverageGap entities",
+      "items": {
+        "$ref": "#/definitions/CoverageGap"
+      }
+    }
+  },
+  "definitions": {
+    "TargetType": {
+      "type": "string",
+      "enum": [
+        "workflow",
+        "workflow-step",
+        "form",
+        "api-operation",
+        "data-transform",
+        "navigation-path",
+        "integration",
+        "composite"
+      ]
+    },
+    "Priority": {
+      "type": "string",
+      "enum": ["critical", "high", "medium", "low"]
+    },
+    "FieldRelevance": {
+      "type": "string",
+      "enum": ["primary", "secondary", "contextual"]
+    },
+    "PresenceRule": {
+      "type": "string",
+      "enum": ["required", "optional", "conditional"]
+    },
+    "PartitionCategory": {
+      "type": "string",
+      "enum": ["typical", "boundary", "invalid", "None", "special"]
+    },
+    "DependencyEffect": {
+      "type": "string",
+      "enum": ["requires", "excludes", "enables", "modifies"]
+    },
+    "ContextType": {
+      "type": "string",
+      "enum": ["ui-entry", "api-entry", "event-triggered", "scheduled", "integration"]
+    },
+    "OutcomeType": {
+      "type": "string",
+      "enum": [
+        "success",
+        "validation-error",
+        "authorization-denied",
+        "not-found",
+        "conflict",
+        "precondition-failed",
+        "idempotent-noop",
+        "partial-success",
+        "error"
+      ]
+    },
+    "CoverageCriteria": {
+      "type": "string",
+      "enum": [
+        "exhaustive",
+        "pairwise",
+        "each-choice",
+        "boundary",
+        "risk-based",
+        "happy-path",
+        "error-path"
+      ]
+    },
+    "SketchStatus": {
+      "type": "string",
+      "enum": ["planned", "implemented", "automated", "manual", "blocked", "deprecated"]
+    },
+    "ImplementationFormat": {
+      "type": "string",
+      "enum": [
+        "gherkin",
+        "postman",
+        "jest",
+        "pytest",
+        "playwright",
+        "cypress",
+        "robot",
+        "manual",
+        "other"
+      ]
+    },
+    "GapSeverity": {
+      "type": "string",
+      "enum": ["critical", "high", "medium", "low"]
+    },
+    "TestCoverageModel": {
+      "type": "object",
+      "description": "Complete test coverage model for application",
+      "required": ["id", "name", "version", "application"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "application": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "coverageTargets": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "inputSpacePartitions": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "contextVariations": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "coverageRequirements": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "testCaseSketches": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "TestCoverageTarget": {
+      "type": "object",
+      "description": "An artifact or functionality that requires test coverage",
+      "required": ["id", "name", "targetType"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "targetType": {
+          "$ref": "#/definitions/TargetType"
+        },
+        "priority": {
+          "$ref": "#/definitions/Priority"
+        },
+        "applicableContexts": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "inputFields": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "outcomeCategories": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "source": {
+          "type": "object",
+          "description": "Source code reference for the artifact requiring test coverage",
+          "properties": {
+            "reference": {
+              "$ref": "common/source-references.schema.json#/definitions/SourceReference"
+            }
+          }
+        }
+      }
+    },
+    "TargetInputField": {
+      "type": "object",
+      "description": "Input field associated with a coverage target",
+      "required": ["id", "name", "fieldRef", "partitionRef"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "fieldRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "partitionRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "relevance": {
+          "$ref": "#/definitions/FieldRelevance"
+        }
+      }
+    },
+    "InputSpacePartition": {
+      "type": "object",
+      "description": "Partitioning of an input dimension into testable categories",
+      "required": ["id", "name", "fieldRef", "presenceRule"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "fieldRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "presenceRule": {
+          "$ref": "#/definitions/PresenceRule"
+        },
+        "partitions": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "dependencies": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "PartitionValue": {
+      "type": "object",
+      "description": "A specific partition within the input space",
+      "required": [
+        "name",
+        "id",
+        "label",
+        "constraint",
+        "constraintExpression",
+        "category",
+        "representativeValue"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "label": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "constraint": {
+          "type": "string",
+          "minLength": 1
+        },
+        "constraintExpression": {
+          "type": "string",
+          "minLength": 1
+        },
+        "category": {
+          "$ref": "#/definitions/PartitionCategory"
+        },
+        "representativeValue": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "PartitionDependency": {
+      "type": "object",
+      "description": "Constraint between partition values across fields",
+      "required": [
+        "id",
+        "name",
+        "dependsOnPartition",
+        "dependsOnValue",
+        "effect",
+        "affectedValues"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "dependsOnPartition": {
+          "type": "string",
+          "minLength": 1
+        },
+        "dependsOnValue": {
+          "type": "string",
+          "minLength": 1
+        },
+        "effect": {
+          "$ref": "#/definitions/DependencyEffect"
+        },
+        "affectedValues": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "ContextVariation": {
+      "type": "object",
+      "description": "Different context in which functionality can be invoked",
+      "required": ["id", "name", "contextType"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "contextType": {
+          "$ref": "#/definitions/ContextType"
+        },
+        "environmentFactors": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "EnvironmentFactor": {
+      "type": "object",
+      "description": "Environmental condition that may affect behavior",
+      "required": ["id", "name", "factor", "value"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "factor": {
+          "type": "string",
+          "minLength": 1
+        },
+        "value": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "OutcomeCategory": {
+      "type": "object",
+      "description": "Category of expected outcomes (not specific assertions)",
+      "required": ["id", "name", "outcomeType", "httpStatusRange"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "outcomeType": {
+          "$ref": "#/definitions/OutcomeType"
+        },
+        "httpStatusRange": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "CoverageRequirement": {
+      "type": "object",
+      "description": "Requirement for test coverage of a target",
+      "required": ["id", "name", "coverageCriteria"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "coverageCriteria": {
+          "$ref": "#/definitions/CoverageCriteria"
+        },
+        "priority": {
+          "$ref": "#/definitions/Priority"
+        },
+        "inputPartitionSelections": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "contextSelections": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "outcomeSelections": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "exclusions": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "InputPartitionSelection": {
+      "type": "object",
+      "description": "Selection of partition values to include in coverage",
+      "required": [
+        "id",
+        "name",
+        "partitionRef",
+        "coverValues",
+        "coverAllCategories",
+        "excludeValues"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "partitionRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "coverValues": {
+          "type": "string",
+          "minLength": 1
+        },
+        "coverAllCategories": {
+          "type": "boolean"
+        },
+        "excludeValues": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "CoverageExclusion": {
+      "type": "object",
+      "description": "Explicit exclusion from coverage with justification",
+      "required": ["id", "name", "description", "reason", "riskAccepted", "approvedBy"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "reason": {
+          "type": "string",
+          "minLength": 1
+        },
+        "riskAccepted": {
+          "type": "boolean"
+        },
+        "approvedBy": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "TestCaseSketch": {
+      "type": "object",
+      "description": "Abstract test case selecting specific partition values",
+      "required": ["id", "name", "status"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "status": {
+          "$ref": "#/definitions/SketchStatus"
+        },
+        "inputSelections": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "source": {
+          "type": "object",
+          "description": "Source code reference to the test case implementation",
+          "properties": {
+            "reference": {
+              "$ref": "common/source-references.schema.json#/definitions/SourceReference"
+            }
+          }
+        }
+      }
+    },
+    "InputSelection": {
+      "type": "object",
+      "description": "Specific partition value selected for a test case",
+      "required": ["id", "name", "partitionRef", "selectedValue", "concreteValue", "valueSource"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "partitionRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "selectedValue": {
+          "type": "string",
+          "minLength": 1
+        },
+        "concreteValue": {
+          "type": "string",
+          "minLength": 1
+        },
+        "valueSource": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "CoverageSummary": {
+      "type": "object",
+      "description": "Summary of coverage status (can be computed or declared)",
+      "required": ["totalTargets", "totalRequirements", "totalSketches"],
+      "properties": {
+        "generatedAt": {
+          "type": "string",
+          "minLength": 1
+        },
+        "totalTargets": {
+          "type": "integer"
+        },
+        "totalRequirements": {
+          "type": "integer"
+        },
+        "totalSketches": {
+          "type": "integer"
+        },
+        "targetSummaries": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "gaps": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "TargetCoverageSummary": {
+      "type": "object",
+      "description": "Coverage metrics summary for a single test coverage target",
+      "required": ["targetRef", "sketchCount", "implementedCount", "automatedCount"],
+      "properties": {
+        "targetRef": {
+          "type": "string",
+          "minLength": 1
+        },
+        "sketchCount": {
+          "type": "integer"
+        },
+        "implementedCount": {
+          "type": "integer"
+        },
+        "automatedCount": {
+          "type": "integer"
+        },
+        "coveragePercentage": {
+          "type": "number"
+        }
+      }
+    },
+    "CoverageGap": {
+      "type": "object",
+      "description": "Identified gap in test coverage requiring attention",
+      "required": ["description", "severity", "affectedRequirements"],
+      "properties": {
+        "description": {
+          "type": "string",
+          "minLength": 1
+        },
+        "severity": {
+          "$ref": "#/definitions/GapSeverity"
+        },
+        "affectedRequirements": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    }
+  }
+}