@toolproof-core/genesis 1.0.47

package/generated-src/schemas/schemas.json

@@ -0,0 +1,1670 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$comment": "This file defines all schemas used internally by ToolProof.",
+    "$id": "https://schemas.toolproof.com/v1/Genesis.json",
+    "$defs": {
+        "Name": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^[A-Z][a-zA-Z0-9]*$",
+            "$comment": "Validation is intercepted by an AI Agent that verifies the name against Toolproof's naming conventions.",
+            "semanticValidation": "Ajv custom keyword to verify name."
+        },
+        "NameFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "name"
+            ],
+            "properties": {
+                "name": {
+                    "$ref": "#/$defs/Name"
+                }
+            }
+        },
+        "Description": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "minLength": 1,
+            "$comment": "Validation is intercepted by an AI Agent that verifies the description against Toolproof's documentation standards.",
+            "semanticValidation": "Ajv custom keyword to verify description."
+        },
+        "DescriptionFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "description"
+            ],
+            "properties": {
+                "description": {
+                    "$ref": "#/$defs/Description"
+                }
+            }
+        },
+        "DocumentationSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/NameFacet"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "symbol": {
+                            "type": "string"
+                        }
+                    }
+                },
+                {
+                    "$ref": "#/$defs/DescriptionFacet"
+                }
+            ]
+        },
+        "JsonSchemaObject": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "$schema"
+            ],
+            "properties": {
+                "$schema": {
+                    "const": "https://json-schema.org/draft/2020-12/schema"
+                }
+            },
+            "additionalProperties": true
+        },
+        "TypeRef": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$comment": "A type reference is either resource-backed (resourceTypeHandle, strategy-legal) or schema-backed (roleSchema, internal/Core-only). The roleSchema branch holds an object whose $ref names the type parameter (e.g. '#OperandType'), matching an entry in the template's GenericAssignmentByRoleName.mapKeys. Exactly one branch must be present.",
+            "oneOf": [
+                {
+                    "type": "object",
+                    "required": [
+                        "resourceTypeHandle"
+                    ],
+                    "properties": {
+                        "resourceTypeHandle": {
+                            "$ref": "#/$defs/ResourceTypeHandle"
+                        }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "roleSchema"
+                    ],
+                    "properties": {
+                        "roleSchema": {
+                            "type": "object",
+                            "required": [
+                                "$ref"
+                            ],
+                            "$comment": "A reference to a named type parameter. The $ref value must be '#' followed by a RoleName, matching a key in the template's GenericAssignmentByRoleName.mapKeys.",
+                            "properties": {
+                                "$ref": {
+                                    "type": "string",
+                                    "pattern": "^#[A-Z][a-zA-Z0-9]*$"
+                                }
+                            },
+                            "additionalProperties": false
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
+        "Embedding": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "embeddingToolHandle",
+                "targetResourcePointer",
+                "data"
+            ],
+            "properties": {
+                "embeddingToolHandle": {
+                    "$ref": "#/$defs/ToolHandle"
+                },
+                "targetResourcePointer": {
+                    "$ref": "#/$defs/ResourcePointer"
+                },
+                "data": {
+                    "type": "array",
+                    "items": {
+                        "type": "number"
+                    }
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "ResourceTypeHandle": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^TYPE-.+$"
+        },
+        "ResourceType": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "handle"
+            ],
+            "properties": {
+                "handle": {
+                    "$ref": "#/$defs/ResourceTypeHandle"
+                },
+                "valueSchema": {
+                    "$ref": "#/$defs/JsonSchemaObject"
+                },
+                "parserToolHandle": {
+                    "$ref": "#/$defs/ToolHandle"
+                },
+                "embeddingModelTools": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolHandle"
+                    },
+                    "minItems": 1,
+                    "$comment": "A ResourceType may specify a set of embeddingModelTools that convert the raw data (or one of its alternative representations) into vector embeddings. The build process enforces that the entries are members of a set of predefined embeddingModelTools."
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/DocumentationSpec"
+                },
+                {
+                    "$comment": "A ResourceType must specify either a valueSchema or a parserToolHandle, or both. If only a valueSchema is specified, the author assumes no burden of implementing a parser for the ResourceType. They can rely on the valueSchema for validation. If only a parserToolHandle is specified, the author assumes the burden of implementing a parser that can validate instances of the ResourceType. If both are specified, the author assumes the burden of implementing an augmented parser that also serves as a generator between the raw data and an instance of the valueSchema.",
+                    "anyOf": [
+                        {
+                            "required": [
+                                "valueSchema"
+                            ]
+                        },
+                        {
+                            "required": [
+                                "parserToolHandle"
+                            ]
+                        }
+                    ]
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "RoleName": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "#/$defs/Name"
+        },
+        "ContainerKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "scalar",
+                "array",
+                "map"
+            ]
+        },
+        "RoleValue": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$comment": "Pairs a type reference (typeRef) with a container shape. typeRef is either resource-backed (resourceTypeHandle) or schema-backed (roleSchema).",
+            "type": "object",
+            "required": [
+                "typeRef",
+                "containerKind"
+            ],
+            "properties": {
+                "typeRef": {
+                    "$ref": "#/$defs/TypeRef"
+                },
+                "refinementSchema": {
+                    "$comment": "Allows Tool authors to specify additional constraints on the role value beyond those expressible in the type system.",
+                    "$ref": "#/$defs/JsonSchemaObject"
+                },
+                "containerKind": {
+                    "$ref": "#/$defs/ContainerKind"
+                },
+                "containerSchema": {
+                    "$ref": "#/$defs/JsonSchemaObject"
+                },
+                "mapKeys": {
+                    "$ref": "#/$defs/RoleNameArray"
+                }
+            },
+            "allOf": [
+                {
+                    "$comment": "If containerKind is scalar, containerSchema is forbidden. Otherwise, it is optional.",
+                    "if": {
+                        "properties": {
+                            "containerKind": {
+                                "const": "scalar"
+                            }
+                        }
+                    },
+                    "then": {
+                        "not": {
+                            "required": [
+                                "containerSchema"
+                            ]
+                        }
+                    }
+                },
+                {
+                    "$comment": "If containerKind is array and containerSchema is provided, it must describe a homogeneous array (type=array with items; tuple-only schemas are disallowed).",
+                    "if": {
+                        "required": [
+                            "containerSchema"
+                        ],
+                        "properties": {
+                            "containerKind": {
+                                "const": "array"
+                            }
+                        }
+                    },
+                    "then": {
+                        "properties": {
+                            "containerSchema": {
+                                "type": "object",
+                                "required": [
+                                    "type",
+                                    "items"
+                                ],
+                                "properties": {
+                                    "type": {
+                                        "const": "array"
+                                    },
+                                    "items": {
+                                        "type": "object"
+                                    }
+                                },
+                                "not": {
+                                    "required": [
+                                        "prefixItems"
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "$comment": "If containerKind is map and containerSchema is provided, it must describe a homogeneous map (type=object with additionalProperties; key-specific schemas are disallowed).",
+                    "if": {
+                        "required": [
+                            "containerSchema"
+                        ],
+                        "properties": {
+                            "containerKind": {
+                                "const": "map"
+                            }
+                        }
+                    },
+                    "then": {
+                        "properties": {
+                            "containerSchema": {
+                                "type": "object",
+                                "required": [
+                                    "type",
+                                    "additionalProperties"
+                                ],
+                                "properties": {
+                                    "type": {
+                                        "const": "object"
+                                    },
+                                    "additionalProperties": {
+                                        "type": "object"
+                                    }
+                                },
+                                "not": {
+                                    "anyOf": [
+                                        {
+                                            "required": [
+                                                "properties"
+                                            ]
+                                        },
+                                        {
+                                            "required": [
+                                                "patternProperties"
+                                            ]
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "$comment": "If containerKind is map, mapKeys is optional (omit for open/dynamic keys, supply for statically-known fixed keys). On non-map containers, mapKeys is forbidden.",
+                    "if": {
+                        "properties": {
+                            "containerKind": {
+                                "const": "map"
+                            }
+                        }
+                    },
+                    "then": {},
+                    "else": {
+                        "not": {
+                            "required": [
+                                "mapKeys"
+                            ]
+                        }
+                    }
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "RoleValueByName": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "propertyNames": {
+                "$ref": "#/$defs/RoleName"
+            },
+            "additionalProperties": {
+                "$ref": "#/$defs/RoleValue"
+            }
+        },
+        "RoleNameArray": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/RoleName"
+            }
+        },
+        "RoleSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "inputRoleValueByName",
+                "outputRoleValueByName"
+            ],
+            "properties": {
+                "inputRoleValueByName": {
+                    "$ref": "#/$defs/RoleValueByName"
+                },
+                "outputRoleValueByName": {
+                    "$ref": "#/$defs/RoleValueByName"
+                },
+                "refinementSchema": {
+                    "$comment": "Allows Tool authors to specify additional constraints on the role assignment beyond those expressible in the type system.",
+                    "$ref": "#/$defs/JsonSchemaObject"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "RoleSpecFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "roleSpec"
+            ],
+            "properties": {
+                "roleSpec": {
+                    "$ref": "#/$defs/RoleSpec"
+                }
+            }
+        },
+        "ToolHandle": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^TOOL-.+$"
+        },
+        "ToolKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "runtime",
+                "buildtime"
+            ]
+        },
+        "Tool": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "handle",
+                "isTemplate"
+            ],
+            "properties": {
+                "handle": {
+                    "$ref": "#/$defs/ToolHandle"
+                },
+                "isTemplate": {
+                    "type": "boolean"
+                },
+                "templateToolHandle": {
+                    "$ref": "#/$defs/ToolHandle"
+                },
+                "instantiationRoleSpec": {
+                    "$ref": "#/$defs/RoleSpec"
+                }
+            },
+            "$comment": "Template Tools own dispatch contract: Core scans all instantiation Tools grouped by templateToolHandle, derives a specializationKey from each tool's generic role assignment (canonical order of genericRoleName -> resourceTypeHandle pairs), and asserts injectivity (no two instantiation Tools share the same key for the same template). At invocation time Core injects the specializationKey -> instantiationToolHandle lookup as the second input, then resolves the first input against it to return one instantiation Tool. Cross-resource compatibility between an instantiation Tool's roleSpec and the template's instantiationRoleSpec is deferred to the validation package.",
+            "semanticValidation": "Deferred: verify injectivity of specializationKey map per template; verify instantiation Tool roleSpec matches template instantiationRoleSpec; verify every supplied generic assignment key-set exactly equals roleSpec.inputRoleValueByName.GenericAssignmentByRoleName.mapKeys; verify every supplied generic assignment matches a registered specializationKey.",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/DocumentationSpec"
+                },
+                {
+                    "if": {
+                        "required": [
+                            "isTemplate"
+                        ],
+                        "properties": {
+                            "isTemplate": {
+                                "const": true
+                            }
+                        }
+                    },
+                    "then": {
+                        "required": [
+                            "instantiationRoleSpec"
+                        ]
+                    },
+                    "else": {
+                        "not": {
+                            "required": [
+                                "instantiationRoleSpec"
+                            ]
+                        }
+                    }
+                },
+                {
+                    "$comment": "Template Tools must declare named roles: two map inputs (GenericAssignmentByRoleName and InstantiationToolHandleBySpecializationKey) and one scalar TYPE-Tool output (InstantiationTool). Runtime semantic validation enforces that invocation input keys for GenericAssignmentByRoleName exactly match this role's declared mapKeys.",
+                    "if": {
+                        "required": [
+                            "isTemplate"
+                        ],
+                        "properties": {
+                            "isTemplate": {
+                                "const": true
+                            }
+                        }
+                    },
+                    "then": {
+                        "properties": {
+                            "roleSpec": {
+                                "properties": {
+                                    "inputRoleValueByName": {
+                                        "required": [
+                                            "GenericAssignmentByRoleName",
+                                            "InstantiationToolHandleBySpecializationKey"
+                                        ],
+                                        "properties": {
+                                            "GenericAssignmentByRoleName": {
+                                                "required": [
+                                                    "containerKind",
+                                                    "typeRef",
+                                                    "mapKeys"
+                                                ],
+                                                "properties": {
+                                                    "containerKind": {
+                                                        "const": "map"
+                                                    },
+                                                    "typeRef": {
+                                                        "required": [
+                                                            "resourceTypeHandle"
+                                                        ],
+                                                        "properties": {
+                                                            "resourceTypeHandle": {
+                                                                "const": "TYPE-ResourceType"
+                                                            }
+                                                        }
+                                                    },
+                                                    "mapKeys": {
+                                                        "type": "array",
+                                                        "items": {
+                                                            "$ref": "#/$defs/RoleName"
+                                                        },
+                                                        "minItems": 1,
+                                                        "uniqueItems": true
+                                                    }
+                                                }
+                                            },
+                                            "InstantiationToolHandleBySpecializationKey": {
+                                                "required": [
+                                                    "containerKind",
+                                                    "typeRef"
+                                                ],
+                                                "properties": {
+                                                    "containerKind": {
+                                                        "const": "map"
+                                                    },
+                                                    "typeRef": {
+                                                        "required": [
+                                                            "resourceTypeHandle"
+                                                        ],
+                                                        "properties": {
+                                                            "resourceTypeHandle": {
+                                                                "const": "TYPE-Tool"
+                                                            }
+                                                        }
+                                                    }
+                                                },
+                                                "not": {
+                                                    "required": [
+                                                        "mapKeys"
+                                                    ]
+                                                }
+                                            }
+                                        },
+                                        "additionalProperties": false
+                                    },
+                                    "outputRoleValueByName": {
+                                        "required": [
+                                            "InstantiationTool"
+                                        ],
+                                        "properties": {
+                                            "InstantiationTool": {
+                                                "required": [
+                                                    "containerKind",
+                                                    "typeRef"
+                                                ],
+                                                "properties": {
+                                                    "containerKind": {
+                                                        "const": "scalar"
+                                                    },
+                                                    "typeRef": {
+                                                        "required": [
+                                                            "resourceTypeHandle"
+                                                        ],
+                                                        "properties": {
+                                                            "resourceTypeHandle": {
+                                                                "const": "TYPE-Tool"
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        "additionalProperties": false
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "$ref": "#/$defs/RoleSpecFacet"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "RoleBindingSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "inputBindings",
+                "outputBindings"
+            ],
+            "properties": {
+                "inputBindings": {
+                    "$ref": "#/$defs/RoleNameArray"
+                },
+                "outputBindings": {
+                    "$ref": "#/$defs/RoleNameArray"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "RoleBindingSpecFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "roleBindingSpec"
+            ],
+            "properties": {
+                "roleBindingSpec": {
+                    "$ref": "#/$defs/RoleBindingSpec"
+                }
+            }
+        },
+        "StepKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "tool",
+                "branch",
+                "while",
+                "for"
+            ]
+        },
+        "StepKindFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepKind"
+            ],
+            "properties": {
+                "stepKind": {
+                    "$ref": "#/$defs/StepKind"
+                }
+            }
+        },
+        "ToolStep": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepKind",
+                "toolHandle"
+            ],
+            "properties": {
+                "stepKind": {
+                    "const": "tool"
+                },
+                "toolHandle": {
+                    "$ref": "#/$defs/ToolHandle"
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/StepKindFacet"
+                },
+                {
+                    "$comment": "This will be overlaid dynamically to specify roleBindingSpec corresponding to the roleSpec of the underlying tool.",
+                    "$ref": "#/$defs/RoleBindingSpecFacet"
+                }
+            ]
+        },
+        "Case": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "when",
+                "what"
+            ],
+            "properties": {
+                "when": {
+                    "$ref": "#/$defs/ToolStep"
+                },
+                "what": {
+                    "$ref": "#/$defs/ToolStep"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "BranchStep": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepKind",
+                "cases"
+            ],
+            "properties": {
+                "stepKind": {
+                    "const": "branch"
+                },
+                "cases": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/Case"
+                    },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/StepKindFacet"
+                }
+            ]
+        },
+        "WhileStep": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepKind",
+                "case"
+            ],
+            "properties": {
+                "stepKind": {
+                    "const": "while"
+                },
+                "case": {
+                    "$ref": "#/$defs/Case"
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/StepKindFacet"
+                }
+            ]
+        },
+        "ForStep": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepKind",
+                "case"
+            ],
+            "properties": {
+                "stepKind": {
+                    "const": "for"
+                },
+                "case": {
+                    "$ref": "#/$defs/Case"
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/StepKindFacet"
+                }
+            ]
+        },
+        "Step": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/ToolStep"
+                },
+                {
+                    "$ref": "#/$defs/BranchStep"
+                },
+                {
+                    "$ref": "#/$defs/WhileStep"
+                },
+                {
+                    "$ref": "#/$defs/ForStep"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "OutputAddress": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "roleName",
+                "toolStepPath"
+            ],
+            "properties": {
+                "roleName": {
+                    "$ref": "#/$defs/RoleName"
+                },
+                "toolStepPath": {
+                    "$ref": "#/$defs/ToolStepPath"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "ProvenanceKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "genesis",
+                "strategy"
+            ]
+        },
+        "GenesisProvenance": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "provenanceKind"
+            ],
+            "properties": {
+                "provenanceKind": {
+                    "const": "genesis"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "StrategyProvenance": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "provenanceKind",
+                "strategyTraceHandle",
+                "outputAddress"
+            ],
+            "properties": {
+                "provenanceKind": {
+                    "const": "strategy"
+                },
+                "strategyTraceHandle": {
+                    "$ref": "#/$defs/StrategyTraceHandle"
+                },
+                "outputAddress": {
+                    "$ref": "#/$defs/OutputAddress"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "DeferredStrategyProvenance": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$comment": "Build-time strategy provenance without strategyTraceHandle. strategyTraceHandle is only known at runtime.",
+            "type": "object",
+            "required": [
+                "provenanceKind",
+                "outputAddress"
+            ],
+            "properties": {
+                "provenanceKind": {
+                    "const": "strategy"
+                },
+                "outputAddress": {
+                    "$ref": "#/$defs/OutputAddress"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "Provenance": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/GenesisProvenance"
+                },
+                {
+                    "$ref": "#/$defs/StrategyProvenance"
+                }
+            ]
+        },
+        "ProvenanceFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "provenance"
+            ],
+            "properties": {
+                "provenance": {
+                    "$ref": "#/$defs/Provenance"
+                }
+            }
+        },
+        "ResourceId": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^RESOURCE-.+$"
+        },
+        "ResourcePointer": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "id",
+                "resourceTypeHandle",
+                "version"
+            ],
+            "properties": {
+                "id": {
+                    "$ref": "#/$defs/ResourceId"
+                },
+                "resourceTypeHandle": {
+                    "$ref": "#/$defs/ResourceTypeHandle"
+                },
+                "version": {
+                    "const": 1
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/ProvenanceFacet"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "BaseResource": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "value"
+            ],
+            "properties": {
+                "value": true
+            },
+            "$comment": "This will be overlaid dynamically to match the data structure of the underlying ResourceType's valueSchema.",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/ResourcePointer"
+                }
+            ]
+        },
+        "Resource": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "$ref": "#/$defs/BaseResource",
+            "unevaluatedProperties": false
+        },
+        "StrategyStateInputKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "inputResource",
+                "externalInputPotential",
+                "internalInputPotential"
+            ]
+        },
+        "InputResource": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "strategyStateInputKind"
+            ],
+            "properties": {
+                "strategyStateInputKind": {
+                    "const": "inputResource"
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseResource"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "ExternalInputPotential": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "strategyStateInputKind",
+                "id",
+                "resourceTypeHandle"
+            ],
+            "properties": {
+                "strategyStateInputKind": {
+                    "const": "externalInputPotential"
+                },
+                "id": {
+                    "$ref": "#/$defs/ResourceId"
+                },
+                "resourceTypeHandle": {
+                    "$ref": "#/$defs/ResourceTypeHandle"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "InternalInputPotential": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "strategyStateInputKind",
+                "id",
+                "resourceTypeHandle",
+                "provenance"
+            ],
+            "properties": {
+                "strategyStateInputKind": {
+                    "const": "internalInputPotential"
+                },
+                "id": {
+                    "$ref": "#/$defs/ResourceId"
+                },
+                "resourceTypeHandle": {
+                    "$ref": "#/$defs/ResourceTypeHandle"
+                },
+                "provenance": {
+                    "$ref": "#/$defs/DeferredStrategyProvenance"
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "InputPotential": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/ExternalInputPotential"
+                },
+                {
+                    "$ref": "#/$defs/InternalInputPotential"
+                }
+            ]
+        },
+        "StrategyStateInputEntry": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/InputPotential"
+                },
+                {
+                    "$ref": "#/$defs/InputResource"
+                }
+            ]
+        },
+        "StrategyStateInputEntryByRoleName": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "propertyNames": {
+                "$ref": "#/$defs/RoleName"
+            },
+            "additionalProperties": {
+                "$ref": "#/$defs/StrategyStateInputEntry"
+            }
+        },
+        "StepArray": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/Step"
+            },
+            "uniqueItems": true
+        },
+        "StepArrayArray": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/StepArray"
+            }
+        },
+        "StepsFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "steps"
+            ],
+            "properties": {
+                "steps": {
+                    "$ref": "#/$defs/StepArray"
+                }
+            }
+        },
+        "ToolStepPathSlot": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "self",
+                "case.when",
+                "case.what",
+                "cases.when",
+                "cases.what"
+            ]
+        },
+        "ToolStepPathSlotFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "toolStepPathSlot"
+            ],
+            "properties": {
+                "toolStepPathSlot": {
+                    "$ref": "#/$defs/ToolStepPathSlot"
+                }
+            }
+        },
+        "BaseToolStepPathSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepIndex",
+                "toolStepPathSlot"
+            ],
+            "properties": {
+                "stepIndex": {
+                    "$ref": "#/$defs/Natural"
+                },
+                "toolStepPathSlot": {
+                    "$ref": "#/$defs/ToolStepPathSlot"
+                },
+                "caseIndex": {
+                    "$ref": "#/$defs/Natural"
+                }
+            },
+            "allOf": [
+                {
+                    "if": {
+                        "properties": {
+                            "toolStepPathSlot": {
+                                "enum": [
+                                    "cases.when",
+                                    "cases.what"
+                                ]
+                            }
+                        }
+                    },
+                    "then": {
+                        "required": [
+                            "caseIndex"
+                        ]
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "toolStepPathSlot": {
+                                "enum": [
+                                    "self",
+                                    "case.when",
+                                    "case.what"
+                                ]
+                            }
+                        }
+                    },
+                    "then": {
+                        "not": {
+                            "required": [
+                                "caseIndex"
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "UnthreadedToolStepPathSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseToolStepPathSpec"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "ThreadedToolStepPathSpec": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseToolStepPathSpec"
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "threadIndex"
+                    ],
+                    "properties": {
+                        "threadIndex": {
+                            "$ref": "#/$defs/Natural"
+                        }
+                    }
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "ToolStepPath": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/UnthreadedToolStepPath"
+                },
+                {
+                    "$ref": "#/$defs/ThreadedToolStepPath"
+                }
+            ]
+        },
+        "UnthreadedToolStepPath": {
+            "type": "string",
+            "pattern": "^/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$"
+        },
+        "ThreadedToolStepPath": {
+            "type": "string",
+            "pattern": "^/threads/[0-9]+/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$"
+        },
+        "UnthreadedStrategyState": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "propertyNames": {
+                "$ref": "#/$defs/UnthreadedToolStepPath"
+            },
+            "additionalProperties": {
+                "$ref": "#/$defs/StrategyStateInputEntryByRoleName"
+            }
+        },
+        "ThreadedStrategyState": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "propertyNames": {
+                "$ref": "#/$defs/ThreadedToolStepPath"
+            },
+            "additionalProperties": {
+                "$ref": "#/$defs/StrategyStateInputEntryByRoleName"
+            }
+        },
+        "UnthreadedStrategyStateFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "strategyState"
+            ],
+            "properties": {
+                "strategyState": {
+                    "$ref": "#/$defs/UnthreadedStrategyState"
+                }
+            }
+        },
+        "ThreadedStrategyStateFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "strategyState"
+            ],
+            "properties": {
+                "strategyState": {
+                    "$ref": "#/$defs/ThreadedStrategyState"
+                }
+            }
+        },
+        "StrategyKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "unthreaded",
+                "threaded"
+            ]
+        },
+        "StrategyHandle": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^STRATEGY-.+$"
+        },
+        "BaseStrategy": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "handle",
+                "strategyKind"
+            ],
+            "properties": {
+                "handle": {
+                    "$ref": "#/$defs/StrategyHandle"
+                },
+                "strategyKind": {
+                    "$ref": "#/$defs/StrategyKind"
+                }
+            }
+        },
+        "UnthreadedStrategy": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseStrategy"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "strategyKind": {
+                            "const": "unthreaded"
+                        }
+                    }
+                },
+                {
+                    "$ref": "#/$defs/StepsFacet"
+                },
+                {
+                    "$ref": "#/$defs/UnthreadedStrategyStateFacet"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "ThreadedStrategy": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseStrategy"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "strategyKind": {
+                            "const": "threaded"
+                        }
+                    }
+                },
+                {
+                    "$ref": "#/$defs/StepsByThreadIndexFacet"
+                },
+                {
+                    "$ref": "#/$defs/ThreadedStrategyStateFacet"
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "Strategy": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/UnthreadedStrategy"
+                },
+                {
+                    "$ref": "#/$defs/ThreadedStrategy"
+                }
+            ]
+        },
+        "StepsByThreadIndexFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "stepsByThreadIndex"
+            ],
+            "properties": {
+                "stepsByThreadIndex": {
+                    "$ref": "#/$defs/StepArrayArray"
+                }
+            }
+        },
+        "TracePointCounterSnapshot": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "stepCounterAfter": {
+                    "$ref": "#/$defs/Natural"
+                },
+                "iterationCounterAfter": {
+                    "$ref": "#/$defs/Natural"
+                }
+            }
+        },
+        "TracePointDelta": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "stepsMutation": {
+                    "type": "object",
+                    "required": [
+                        "insertAt",
+                        "insertedSteps"
+                    ],
+                    "properties": {
+                        "insertAt": {
+                            "$ref": "#/$defs/Natural"
+                        },
+                        "insertedSteps": {
+                            "$ref": "#/$defs/StepArray"
+                        }
+                    }
+                },
+                "strategyStateDelta": {
+                    "$ref": "#/$defs/ThreadedStrategyState"
+                },
+                "interruptData": {
+                    "$comment": "Kept permissive; the engine may evolve interrupt payloads.",
+                    "type": [
+                        "object",
+                        "null"
+                    ]
+                }
+            }
+        },
+        "TracePointKind": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "enum": [
+                "graph_start",
+                "tick",
+                "interrupt",
+                "graph_end"
+            ]
+        },
+        "BaseTracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "tracePointKind",
+                "strategyHandle",
+                "threadIndex",
+                "tracePointIndex"
+            ],
+            "properties": {
+                "tracePointKind": {
+                    "$ref": "#/$defs/TracePointKind"
+                },
+                "strategyHandle": {
+                    "$ref": "#/$defs/StrategyHandle"
+                },
+                "threadIndex": {
+                    "$ref": "#/$defs/Natural"
+                },
+                "tracePointIndex": {
+                    "$ref": "#/$defs/Natural"
+                }
+            }
+        },
+        "ThreadedStrategyFacet": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "threadedStrategy"
+            ],
+            "properties": {
+                "threadedStrategy": {
+                    "$ref": "#/$defs/ThreadedStrategy"
+                }
+            }
+        },
+        "GraphStartTracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseTracePoint"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "tracePointKind": {
+                            "const": "graph_start"
+                        }
+                    }
+                },
+                {
+                    "$ref": "#/$defs/ThreadedStrategyFacet"
+                }
+            ]
+        },
+        "TickTracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseTracePoint"
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "counterSnapshot",
+                        "toolStepPath",
+                        "delta"
+                    ],
+                    "properties": {
+                        "tracePointKind": {
+                            "const": "tick"
+                        },
+                        "counterSnapshot": {
+                            "$ref": "#/$defs/TracePointCounterSnapshot"
+                        },
+                        "toolStepPath": {
+                            "$ref": "#/$defs/ThreadedToolStepPath"
+                        },
+                        "delta": {
+                            "$ref": "#/$defs/TracePointDelta"
+                        }
+                    }
+                }
+            ]
+        },
+        "InterruptTracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseTracePoint"
+                },
+                {
+                    "type": "object",
+                    "required": [
+                        "counterSnapshot",
+                        "toolStepPath",
+                        "delta"
+                    ],
+                    "properties": {
+                        "tracePointKind": {
+                            "const": "interrupt"
+                        },
+                        "counterSnapshot": {
+                            "$ref": "#/$defs/TracePointCounterSnapshot"
+                        },
+                        "toolStepPath": {
+                            "$ref": "#/$defs/ThreadedToolStepPath"
+                        },
+                        "delta": {
+                            "allOf": [
+                                {
+                                    "$ref": "#/$defs/TracePointDelta"
+                                },
+                                {
+                                    "type": "object",
+                                    "required": [
+                                        "interruptData"
+                                    ],
+                                    "properties": {
+                                        "interruptData": {
+                                            "$comment": "Interrupt events must include a non-null interrupt payload.",
+                                            "type": "object"
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        "GraphEndTracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/BaseTracePoint"
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "tracePointKind": {
+                            "const": "graph_end"
+                        }
+                    }
+                }
+            ]
+        },
+        "TracePoint": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/GraphStartTracePoint"
+                },
+                {
+                    "$ref": "#/$defs/TickTracePoint"
+                },
+                {
+                    "$ref": "#/$defs/InterruptTracePoint"
+                },
+                {
+                    "$ref": "#/$defs/GraphEndTracePoint"
+                }
+            ]
+        },
+        "StrategyTraceHandle": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^STRATEGY_TRACE-.+$"
+        },
+        "StrategyTrace": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "handle",
+                "strategyHandle",
+                "tracePoints"
+            ],
+            "properties": {
+                "handle": {
+                    "$ref": "#/$defs/StrategyTraceHandle"
+                },
+                "strategyHandle": {
+                    "$comment": "Could be derived from the first event but useful for indexing.",
+                    "$ref": "#/$defs/StrategyHandle"
+                },
+                "tracePoints": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/TracePoint"
+                    }
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "GoalHandle": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "pattern": "^GOAL-.+$"
+        },
+        "Goal": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "handle",
+                "target"
+            ],
+            "properties": {
+                "handle": {
+                    "$ref": "#/$defs/GoalHandle"
+                },
+                "target": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "disallowedTools": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolHandle"
+                    }
+                },
+                "disallowedSequences": {
+                    "type": "array",
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "#/$defs/ToolHandle"
+                        }
+                    }
+                },
+                "minSteps": {
+                    "type": "integer",
+                    "minimum": 1
+                },
+                "maxSteps": {
+                    "type": "integer",
+                    "minimum": 1
+                }
+            },
+            "unevaluatedProperties": false
+        },
+        "Error": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/DocumentationSpec"
+                },
+                {
+                    "properties": {
+                        "details": {
+                            "type": "object"
+                        }
+                    }
+                }
+            ],
+            "unevaluatedProperties": false
+        },
+        "Natural": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "integer",
+            "minimum": 0
+        },
+        "Boolean": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "boolean"
+        },
+        "TimestampedResource": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "required": [
+                "timestamp"
+            ],
+            "properties": {
+                "timestamp": {
+                    "type": "string",
+                    "format": "date-time",
+                    "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$"
+                }
+            },
+            "allOf": [
+                {
+                    "$ref": "#/$defs/Resource"
+                }
+            ],
+            "unevaluatedProperties": false
+        }
+    }
+}