@documentation-robotics/cli 0.1.0 → 0.1.5

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

@@ -1,1091 +0,0 @@
-{
-  "$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
-        }
-      }
-    }
-  }
-}